fixes for building

diff --git a/pmachines/gui/menu.py b/pmachines/gui/menu.py
index 3fa571d8668ff076eb786cfb6a2e00b806c16acb..8ec41a3c8d727246f962d865eebda7d76565d343 100644 (file)
--- a/pmachines/gui/menu.py
+++ b/pmachines/gui/menu.py
@@ -106,7 +106,7 @@ class Menu(DirectObject):
 
         def btn_exit():
             if self._fun_test:
-                ServerProxy('http://localhost:6000').destroy()
+                ServerProxy('http://localhost:7000').destroy()
             exit()
         self._widgets += [DirectButton(
             text=_('Exit'), pos=(0, 1, -.6), command=lambda: btn_exit(),

diff --git a/pmachines/posmgr.py b/pmachines/posmgr.py
index 0ec5340390d577855fc4efb1d618aace1925251b..077bd2a59d29b1ced9ff35f4e1504f4b426c02e5 100644 (file)
--- a/pmachines/posmgr.py
+++ b/pmachines/posmgr.py
@@ -7,7 +7,7 @@ class PositionMgr:
         self._pos = {}
 
     def register(self, wdg, pos):
-        print('register', wdg, pos)
+        # print('register', wdg, pos)
         self._pos[wdg] = pos
 
     def get(self, tgt):

diff --git a/prj.org b/prj.org
index 4887b944ef6dffcd27360294c334219344ea9dd8..a0b4289ae6fd9d16369778d1f78ca959b89a3e86 100644 (file)
--- a/prj.org
+++ b/prj.org
@@ -3,7 +3,8 @@
 #+CATEGORY: pmachines
 #+TAGS: bug(b) calendar(c) waiting(w)
 
-* CODE create builds and update website/itch.io
+* CODE logging functional tests: process name; during the execution and in the file
+* READY create builds and update website/itch.io
 * READY refactoring (recurring task)
 * BACKLOG intro animation (from target item to start position)
 * BACKLOG buttons of the scenes enabled sequentially

diff --git a/tests/functional_test.py b/tests/functional_test.py
index acc95464ab173c6f4913b27f8faca5cc4fa919c7..e039c1c64cb0b63f99c00b7f49a8bba5310ba804 100644 (file)
--- a/tests/functional_test.py
+++ b/tests/functional_test.py
@@ -21,25 +21,28 @@ from panda3d.core import Filename
 from direct.showbase.ShowBase import ShowBase
 from direct.gui.OnscreenText import OnscreenText
 from ya2.build.build import _branch
+import asyncio
+import xmlrpc
 
 
 class FunctionalTest:
 
-    screenshot_time = 1.2
-    evt_time = 1.0
-    drag_time = 1.0
+    screenshot_time = 2.0
+    evt_time = 2.0
+    drag_time = 2.0
     start_time = 2
 
     def __init__(self, idx, offset):
+        debug('creating FunctionalTest (%s)' % id(self))
         super().__init__()
         info('test idx: %s' % idx)
         self._offset = offset
-        sleep(5)
-        self._proxy = ServerProxy('http://localhost:6000')
+        sleep(12)
+        self._proxy = ServerProxy('http://localhost:7000')
         self._curr_time = 0
         self._tasks = []
         self._prev_time = 0
-        taskMgr.add(self.on_frame_unpausable, 'on-frame-unpausable')
+        #taskMgr.add(self.on_frame_unpausable, 'on-frame-unpausable')
         self._proxy.set_idx(idx)
         self._do_screenshots(idx)
 
@@ -49,439 +52,468 @@ class FunctionalTest:
         self._proxy.screenshot(name)
         info('screenshot %s' % name)
 
-    def _screenshot(self, time, name):
-        self._tasks += [(
-            self._curr_time + time,
-            lambda: self._do_screenshot(name),
-            'screenshot: %s' % name)]
-        self._curr_time += time
+    async def _screenshot(self, time, name):
+        #self._tasks += [(
+        #    self._curr_time + time,
+        #    lambda: self._do_screenshot(name),
+        #    'screenshot: %s' % name)]
+        #self._curr_time += time
+        await asyncio.sleep(time)
+        self._do_screenshot(name)
 
-    def __mouse_click(self, tgt, btn):
+    async def __mouse_click(self, tgt, btn):
+        await asyncio.sleep(.5)
         offset_x = int((1920 - 1360) / 2) #+ 1  # xfce decorations
         offset_y = int((1080 - 768) / 2) #+ 24 + self._offset  # xfce decorations
         btn = 3 if btn == 'right' else 1
         pos = self._proxy.get_pos(tgt)
-        print(tgt, pos)
         system('xdotool mousemove %s %s' % (offset_x + pos[0], offset_y + pos[1]))
-        def click(task):
-            system('xdotool click %s' % btn)
-        taskMgr.do_method_later(.28, click, 'click')
+        #def click(task):
+        #    system('xdotool click %s' % tgt)
+        #    print('CLICK %s' % str(btn))
+        #taskMgr.do_method_later(.28, click, 'click')
+        await asyncio.sleep(.5)
+        system('xdotool click %s' % btn)
 
-    def __mouse_drag(self, start, end, btn):
+    async def __mouse_drag(self, start, end, btn):
+        await asyncio.sleep(.5)
         offset_x = int((1920 - 1360) / 2) #+ 1  # xfce decorations
         offset_y = int((1080 - 768) / 2) #+ 24 + self._offset  # xfce decorations
         btn = 3 if btn == 'right' else 1
         start = self._proxy.get_pos(start)
         end = self._proxy.get_pos(end)
         system('xdotool mousemove %s %s' % (offset_x + start[0], offset_y + start[1]))
-        def mousedown(task):
-            system('xdotool mousedown %s' % btn)
-            def mousemove(task):
-                system('xdotool mousemove %s %s' % (offset_x + end[0], offset_y + end[1]))
-                def mouseup(task):
-                    system('xdotool mouseup %s' % btn)
-                taskMgr.do_method_later(.28, mouseup, 'mouseup')
-            taskMgr.do_method_later(.28, mousemove, 'mousemove')
-        taskMgr.do_method_later(.28, mousedown, 'mousedown')
+        await asyncio.sleep(.5)
+        system('xdotool mousedown %s' % btn)
+        await asyncio.sleep(.5)
+        system('xdotool mousemove %s %s' % (offset_x + end[0], offset_y + end[1]))
+        await asyncio.sleep(.5)
+        system('xdotool mouseup %s' % btn)
+        # def mousedown(task):
+        #     system('xdotool mousedown %s' % btn)
+        #     def mousemove(task):
+        #         system('xdotool mousemove %s %s' % (offset_x + end[0], offset_y + end[1]))
+        #         def mouseup(task):
+        #             system('xdotool mouseup %s' % btn)
+        #         taskMgr.do_method_later(.28, mouseup, 'mouseup')
+        #     taskMgr.do_method_later(.28, mousemove, 'mousemove')
+        # taskMgr.do_method_later(.28, mousedown, 'mousedown')
 
-    def _event(self, time, evt, mouse_args=None):
+    async def _event(self, time, evt, mouse_args=None):
+        await asyncio.sleep(time)
         if evt == 'mouseclick':
-            cback = lambda: self.__mouse_click(*mouse_args)
+            #cback = lambda: self.__mouse_click(*mouse_args)
+            await self.__mouse_click(*mouse_args)
         elif evt == 'mousedrag':
-            cback = lambda: self.__mouse_drag(*mouse_args)
-        self._tasks += [(
-            self._curr_time + time,
-            cback,
-            'event: %s' % evt)]
-        self._curr_time += time
+            #cback = lambda: self.__mouse_drag(*mouse_args)
+            await self.__mouse_drag(*mouse_args)
+        #self._tasks += [(
+        #    self._curr_time + time,
+        #    cback,
+        #    'event: %s' % evt)]
+        #self._curr_time += time
 
-    def _enforce_res(self, time, res):
-        def cback():
-            self._proxy.enforce_res(res)
-            info('enforce_res %s' % res)
-        self._tasks += [(
-            self._curr_time + time,
-            cback,
-            'enforce res: %s' % res)]
-        self._curr_time += time
+    async def _enforce_res(self, time, res):
+        await asyncio.sleep(time)
+        self._proxy.enforce_res(res)
+        #def cback():
+        #    self._proxy.enforce_res(res)
+        #    info('enforce_res %s' % res)
+        #self._tasks += [(
+        #    self._curr_time + time,
+        #    cback,
+        #    'enforce res: %s' % res)]
+        #self._curr_time += time
 
-    def _enforce_resolution(self, time, res):
-        def cback():
-            self._proxy.enforce_resolution(res)
-            info('enforce_resolution %s (send)' % res)
-        self._tasks += [(
-            self._curr_time + time,
-            cback,
-            'enforce resolution: %s' % res)]
-        self._curr_time += time
+    async def _enforce_resolution(self, time, res):
+        await asyncio.sleep(time)
+        self._proxy.enforce_resolution(res)
+        #def cback():
+        #    self._proxy.enforce_resolution(res)
+        #    info('enforce_resolution %s (send)' % res)
+        #self._tasks += [(
+        #    self._curr_time + time,
+        #    cback,
+        #    'enforce resolution: %s' % res)]
+        #self._curr_time += time
 
-    def _verify(self):
-        def __verify():
-            self._proxy.verify()
-            info('verify')
-        self._tasks += [(
-            self._curr_time + 3,
-            lambda: __verify(),
-            'verify')]
-        self._curr_time += 3
+    async def _verify(self, time):
+        await asyncio.sleep(time)
+        self._proxy.verify()
+        info('verify')
+        #def __verify():
+        #    self._proxy.verify()
+        #    info('verify')
+        #self._tasks += [(
+        #    self._curr_time + 3,
+        #    lambda: __verify(),
+        #    'verify')]
+        #self._curr_time += 3
 
-    def _exit(self):
-        def do_exit():
+    async def _exit(self, time):
+        await asyncio.sleep(time)
+        try:
             self._proxy.close()
-            exit()
-        self._tasks += [(
-            self._curr_time + 3,
-            lambda: do_exit(),
-            'exit')]
+        except (ConnectionRefusedError, xmlrpc.client.Fault) as e:  # the other part has been closed with the exit button
+            debug('already closed (%s)' % e)
+        debug('destroying FunctionalTest (%s)' % id(self))
+        exit()
+        #def do_exit():
+        #    try:
+        #        self._proxy.close()
+        #    except (ConnectionRefusedError, xmlrpc.client.Fault) as e:  # the other part has been closed with the exit button
+        #        debug('already closed (%s)' % e)
+        #    debug('destroying FunctionalTest (%s)' % id(self))
+        #    exit()
+        #self._tasks += [(
+        #    self._curr_time + 3,
+        #    lambda: do_exit(),
+        #    'exit')]
 
-    def on_frame_unpausable(self, task):
-        for tsk in self._tasks:
-            #if self._prev_time <= tsk[0] < self.eng.event.unpaused_time:
-            if self._prev_time <= tsk[0] < globalClock.getFrameTime():
-                debug('%s %s' % (tsk[0], tsk[2]))
-                tsk[1]()
-        self._prev_time = globalClock.getFrameTime()  # self.eng.event.unpaused_time
-        return task.cont
+    # def on_frame_unpausable(self, task):
+    #     for tsk in self._tasks:
+    #         #if self._prev_time <= tsk[0] < self.eng.event.unpaused_time:
+    #         if self._prev_time <= tsk[0] < globalClock.getFrameTime():
+    #             debug('%s %s' % (tsk[0], tsk[2]))
+    #             tsk[1]()
+    #     self._prev_time = globalClock.getFrameTime()  # self.eng.event.unpaused_time
+    #     return task.cont
 
-    def _do_screenshots_1(self):
+    async def _do_screenshots_1(self):
         info('_do_screenshots_1')
-        self._screenshot(FunctionalTest.start_time, 'main_menu')
-        self._do_screenshots_credits()
-        self._do_screenshots_options()
-        self._do_screenshots_exit()
+        await self._screenshot(FunctionalTest.start_time, 'main_menu')
+        await self._do_screenshots_credits()
+        await self._do_screenshots_options()
+        await self._do_screenshots_exit()
 
-    def _do_screenshots_credits(self):
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['credits', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'credits_menu')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'main_menu_back_from_credits')
+    async def _do_screenshots_credits(self):
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['credits', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'credits_menu')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'main_menu_back_from_credits')
 
-    def _do_screenshots_options(self):
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 300), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['options', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu')
+    async def _do_screenshots_options(self):
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 300), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['options', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu')
         # languages
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 60), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['languages', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'open_languages')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(980, 120), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['italian', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu_italian')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 60), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['languages', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'open_languages')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(980, 120), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['italian', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu_italian')
         # volume
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(740, 163), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['volume', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu_drag_1')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(740, 163), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['volume', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu_drag_1')
         # antialiasing
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 440), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['aa', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'antialiasing_no')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 440), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['aa', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'antialiasing_no')
         # shadows
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 540), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['shadows', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'shadows_no')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 540), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['shadows', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'shadows_no')
         # test aa and shadows
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])  # back
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])  # play
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])  # domino
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(900, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])  # close instructions
-        self._screenshot(FunctionalTest.screenshot_time, 'aa_no_shadows_no')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(25, 740), 'left'])  # home
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['home', 'left'])  # home
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])  # back
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])  # play
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])  # domino
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(900, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])  # close instructions
+        await self._screenshot(FunctionalTest.screenshot_time, 'aa_no_shadows_no')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(25, 740), 'left'])  # home
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['home', 'left'])  # home
 
-    def _do_screenshots_restore_options(self):
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 300), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['options', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu_restored')
+    async def _do_screenshots_restore_options(self):
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 300), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['options', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu_restored')
         # languages
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 60), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['languages', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'open_languages_restored')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(980, 20), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['english', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu_english')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 60), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['languages', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'open_languages_restored')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(980, 20), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['english', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu_english')
         # volume
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(719, 163), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['volume_0', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'options_menu_drag_2')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(719, 163), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['volume_0', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'options_menu_drag_2')
         # fullscreen
         # the first one is because of the windowed mode in test
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'fullscreen')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'fullscreen')
-        #self._event(8 + FunctionalTest.evt_time, 'mouseclick', [(440, 120), 'left'])
-        #self._event(8 + FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
-        self._screenshot(8 + FunctionalTest.screenshot_time, 'back_from_fullscreen')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'fullscreen')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'fullscreen')
+        #await self._event(8 + FunctionalTest.evt_time, 'mouseclick', [(440, 120), 'left'])
+        #await self._event(8 + FunctionalTest.evt_time, 'mouseclick', [(680, 250), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['fullscreen', 'left'])
+        await self._screenshot(8 + FunctionalTest.screenshot_time, 'back_from_fullscreen')
         # resolution
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 340), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['resolutions', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'resolutions')
-        self._enforce_resolution(FunctionalTest.evt_time, '1440x900')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1000, 440), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['res_1440x900', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, '1440x900')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(740, 400), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['resolutions', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'resolutions_2')
-        self._enforce_resolution(FunctionalTest.evt_time, '1360x768')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1110, 80), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['res_1360x768', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, '1360x768')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 340), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['resolutions', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'resolutions')
+        await self._enforce_resolution(FunctionalTest.evt_time, '1440x900')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1000, 440), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['res_1440x900', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, '1440x900')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(740, 400), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['resolutions', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'resolutions_2')
+        await self._enforce_resolution(FunctionalTest.evt_time, '1360x768')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1110, 80), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['res_1360x768', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, '1360x768')
         # antialiasing
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 440), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['aa', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'antialiasing_yes')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 440), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['aa', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'antialiasing_yes')
         # shadows
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 540), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['shadows', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'shadows_yes')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 540), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['shadows', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'shadows_yes')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
 
-    def _do_screenshots_play(self):
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'play_menu')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'back_from_play')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino scene
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_domino_instructions')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_domino')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(25, 740), 'left'])  # home
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['home', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'home_back_from_scene')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(70, 740), 'left'])  # info
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['information', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'info')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        # self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (430, 280), 'left'])  # drag a piece
-        # self._screenshot(FunctionalTest.screenshot_time, 'domino_dragged')
-        # self._event(FunctionalTest.evt_time, 'mouseclick', [(1220, 740), 'left'])  # rewind
-        # self._screenshot(FunctionalTest.screenshot_time, 'rewind')
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (550, 380), 'left'])  # drag a piece
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
-        # self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(630, 450), 'left'])  # home
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['home_win', 'left'])  # home
-        self._screenshot(FunctionalTest.screenshot_time, 'home_back_from_fail')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])  # play
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (550, 380), 'left'])  # drag a piece
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a piece  .49 .06
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino_2')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])  # play
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (570, 380), 'left'])  # drag a piece -1.54 .06
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a piece -1.54 .06
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(570, 355), (605, 355), 'right'])  # rotate the piece -1.05 .4
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_3', 'right'])  # rotate the piece -1.54 .4 -1.05 .4
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_domino')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])  # play
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_box')
+    async def _do_screenshots_play(self):
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'play_menu')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 680), 'left'])  # back
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['back', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'back_from_play')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino scene
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_domino_instructions')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_domino')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(25, 740), 'left'])  # home
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['home', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'home_back_from_scene')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(70, 740), 'left'])  # info
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['information', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'info')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        # await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (430, 280), 'left'])  # drag a piece
+        # await self._screenshot(FunctionalTest.screenshot_time, 'domino_dragged')
+        # await self._event(FunctionalTest.evt_time, 'mouseclick', [(1220, 740), 'left'])  # rewind
+        # await self._screenshot(FunctionalTest.screenshot_time, 'rewind')
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (550, 380), 'left'])  # drag a piece
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
+        # await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(630, 450), 'left'])  # home
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['home_win', 'left'])  # home
+        await self._screenshot(FunctionalTest.screenshot_time, 'home_back_from_fail')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 140), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['play', 'left'])  # play
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(230, 160), 'left'])  # domino
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['domino', 'left'])
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(850, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (550, 380), 'left'])  # drag a piece
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a piece  .49 .06
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino_2')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])  # play
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (570, 380), 'left'])  # drag a piece -1.54 .06
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a piece -1.54 .06
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(570, 355), (605, 355), 'right'])  # rotate the piece -1.05 .4
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_3', 'right'])  # rotate the piece -1.54 .4 -1.05 .4
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(35, 60), (715, 380), 'left'])  # drag a piece
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a piece
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])  # play
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_domino')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])  # play
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_box')
         # scene 2
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(880, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 620), 'left'])  # drag a box .42 -3.29
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box .42 -3.29
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 540), 'left'])  # drag a box .42 -2.18
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box .42 -2.18
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_box')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 620), 'left'])  # drag a box
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
-       # self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 540), 'left'])  # drag a box
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box
-       # self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (705, 460), 'left'])  # drag a box .35 -1.06
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a box .35 -1.06
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_box')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_box_domino')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(880, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 620), 'left'])  # drag a box .42 -3.29
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box .42 -3.29
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 540), 'left'])  # drag a box .42 -2.18
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box .42 -2.18
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_box')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 620), 'left'])  # drag a box
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
+       # await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (710, 540), 'left'])  # drag a box
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box
+       # await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (705, 460), 'left'])  # drag a box .35 -1.06
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a box .35 -1.06
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_box')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_box_domino')
         # scene 3
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(930, 485), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 440), 'left'])  # drag a box 3.21 -.78
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box 3.21 -.78
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 360), 'left'])  # drag a box 3.21 .33
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box 3.21 .33
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_box_domino')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 440), 'left'])  # drag a box
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (835, 250), 'left'])  # drag a box 2.16 1.87
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a box 2.16 1.87
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_box_domino')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(930, 485), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 440), 'left'])  # drag a box 3.21 -.78
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box 3.21 -.78
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 360), 'left'])  # drag a box 3.21 .33
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box 3.21 .33
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_box_domino')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (910, 440), 'left'])  # drag a box
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (835, 250), 'left'])  # drag a box 2.16 1.87
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_2', 'left'])  # drag a box 2.16 1.87
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_box_domino')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_basketball')
         # scene 4
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(870, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(55, 50), (650, 310), 'left'])  # drag a ball -.42 1.03
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a ball -.42 1.03
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_basketball')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(55, 50), (380, 50), 'left'])  # drag a ball -4.19 4.66
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a ball -4.19 4.66
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_basketball')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_domino_box_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(870, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(55, 50), (650, 310), 'left'])  # drag a ball -.42 1.03
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a ball -.42 1.03
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(55, 50), (380, 50), 'left'])  # drag a ball -4.19 4.66
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a ball -4.19 4.66
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_basketball')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_domino_box_basketball')
         # scene 5
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(865, 490), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (580, 440), 'left'])  # drag a box -1.4 -.78
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -1.4 -.78
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(30, 60), (590, 370), 'left'])  # drag a piece -1.26 .2
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_1', 'left'])  # drag a piece -1.26 .2
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino_box_basketball')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (580, 440), 'left'])  # drag a box
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(30, 60), (660, 440), 'left'])  # drag a piece -.28 -.78
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'left'])  # drag a piece -.28 -.78
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(660, 425), (625, 425), 'right'])  # rotate a piece -.28 -.57 -.77 -.57
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_2', 'drag_stop_3', 'right'])  # rotate a piece -.28 -.57 -.77 -.57
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(660, 435), (650, 445), 'left'])  # drag a piece -.28 -.85 -.42 -.85
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_3', 'drag_stop_4', 'left'])  # drag a piece -.28 -.85 -.42 -.85
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_domino_box_basketball')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_teeter_tooter')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(865, 490), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (580, 440), 'left'])  # drag a box -1.4 -.78
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -1.4 -.78
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(30, 60), (590, 370), 'left'])  # drag a piece -1.26 .2
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_1', 'left'])  # drag a piece -1.26 .2
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_domino_box_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(65, 60), (580, 440), 'left'])  # drag a box
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(30, 60), (660, 440), 'left'])  # drag a piece -.28 -.78
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'left'])  # drag a piece -.28 -.78
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(660, 425), (625, 425), 'right'])  # rotate a piece -.28 -.57 -.77 -.57
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_2', 'drag_stop_3', 'right'])  # rotate a piece -.28 -.57 -.77 -.57
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(660, 435), (650, 445), 'left'])  # drag a piece -.28 -.85 -.42 -.85
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_3', 'drag_stop_4', 'left'])  # drag a piece -.28 -.85 -.42 -.85
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_domino_box_basketball')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_teeter_tooter')
         # scene 6
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(870, 485), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (490, 300), 'left'])  # drag a box -2.65 1.18
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -2.65 1.18
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_teeter_tooter')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (490, 150), 'left'])  # drag a box -2.65 3.27
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box -2.65 3.27
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(515, 115), (515, 122), 'right'])  # rotate a box -2.3 3.75 -2.5 3.66
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'right'])  # rotate a box -2.3 3.75 -2.5 3.66
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_teeter_tooter')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'scene_teeter_domino_box_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(870, 485), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (490, 300), 'left'])  # drag a box -2.65 1.18
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -2.65 1.18
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_teeter_tooter')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (490, 150), 'left'])  # drag a box -2.65 3.27
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box -2.65 3.27
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(515, 115), (515, 122), 'right'])  # rotate a box -2.3 3.75 -2.5 3.66
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'right'])  # rotate a box -2.3 3.75 -2.5 3.66
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_teeter_tooter')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(735, 450), 'left'])  # next
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['next', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'scene_teeter_domino_box_basketball')
         # scene 7
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(930, 485), 'left'])  # close instructions
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (155, 180), 'left'])  # drag a box -7.33 4.24
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -7.33 4.24
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_teeter_domino_box_basketball')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (170, 80), 'left'])  # drag a box -7.12 4.24
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box -7.12 4.24
-        #self._event(FunctionalTest.drag_time, 'mousedrag', [(195, 50), (195, 80), 'right'])  # rotate a box -6.77 4.66 -6.77 4.24
-        self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'right'])  # rotate a box -6.77 4.66 -6.77 4.24
-        self._enforce_res(FunctionalTest.evt_time, 'win')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
-        self._screenshot(16 + FunctionalTest.screenshot_time, 'win_teeter_domino_box_basketball')
-        self._enforce_res(FunctionalTest.evt_time, '')
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(630, 450), 'left'])  # home
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['home_win', 'left'])
-        self._screenshot(FunctionalTest.screenshot_time, 'home_from_play')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(930, 485), 'left'])  # close instructions
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['close_instructions', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (155, 180), 'left'])  # drag a box -7.33 4.24
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_0', 'left'])  # drag a box -7.33 4.24
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'fail_teeter_domino_box_basketball')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 450), 'left'])  # replay
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['replay', 'left'])
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(60, 60), (170, 80), 'left'])  # drag a box -7.12 4.24
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_0', 'drag_stop_1', 'left'])  # drag a box -7.12 4.24
+        #await self._event(FunctionalTest.drag_time, 'mousedrag', [(195, 50), (195, 80), 'right'])  # rotate a box -6.77 4.66 -6.77 4.24
+        await self._event(FunctionalTest.drag_time, 'mousedrag', ['drag_start_1', 'drag_stop_2', 'right'])  # rotate a box -6.77 4.66 -6.77 4.24
+        await self._enforce_res(FunctionalTest.evt_time, 'win')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(1340, 740), 'left'])  # play
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['right', 'left'])
+        await self._screenshot(16 + FunctionalTest.screenshot_time, 'win_teeter_domino_box_basketball')
+        await self._enforce_res(FunctionalTest.evt_time, '')
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(630, 450), 'left'])  # home
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['home_win', 'left'])
+        await self._screenshot(FunctionalTest.screenshot_time, 'home_from_play')
 
-    def _exit(self):
-        self._tasks += [(
-            self._curr_time + 3,
-            lambda: exit(),
-            'exit')]
+    async def _do_screenshots_exit(self):
+        await self._verify(FunctionalTest.evt_time)
+        #await self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 600), 'left'])
+        await self._event(FunctionalTest.evt_time, 'mouseclick', ['exit', 'left'])
+        await self._exit(FunctionalTest.evt_time)
 
-    def _do_screenshots_exit(self):
-        self._verify()
-        #self._event(FunctionalTest.evt_time, 'mouseclick', [(680, 600), 'left'])
-        self._event(FunctionalTest.evt_time, 'mouseclick', ['exit', 'left'])
-        self._exit()
-
-    def _do_screenshots_2(self):
+    async def _do_screenshots_2(self):
         info('_do_screenshots_2')
-        self._screenshot(FunctionalTest.start_time, 'main_menu_2')
-        self._do_screenshots_restore_options()
-        self._do_screenshots_play()
-        self._do_screenshots_exit()
+        await self._screenshot(FunctionalTest.start_time, 'main_menu_2')
+        await self._do_screenshots_restore_options()
+        await self._do_screenshots_play()
+        await self._do_screenshots_exit()
 
     def _do_screenshots(self, idx):
-        [self._do_screenshots_1, self._do_screenshots_2][int(idx) - 1]()
+        asyncio.run(
+            [self._do_screenshots_1, self._do_screenshots_2][int(idx) - 1]()
+        )
 
 
 class TestApp(ShowBase):

diff --git a/tests/test_functional.py b/tests/test_functional.py
index 49ab3ffbd727d9d9480fd55b2ce9a1f2b9d9d31e..c5cb38047dd43c54bf5f91a97461269a8ea7cf63 100644 (file)
--- a/tests/test_functional.py
+++ b/tests/test_functional.py
@@ -11,6 +11,7 @@ from time import sleep
 from os import system, remove, environ
 from os.path import exists, basename, join
 from glob import glob
+from subprocess import PIPE, run, Popen
 from panda3d.core import Filename
 from ya2.build.build import exec_cmd, _branch, _version
 
@@ -66,14 +67,54 @@ class FunctionalTests(TestCase):
         print('compare %s %s: %s' % (ref_img, tst_img, res))
         return float(res) > .8
 
-    def __test_template(self, cmd, path):
+    def __test_template(self, app_cmd, test1_cmd, test2_cmd, path):
         if environ.get('FUNCTIONAL') != '1':
             self.skipTest('skipped functional tests')
         self.__clean()
         self.__awake()
         system('amixer sset Master 0%')
-        ret = system(cmd)
-        self.assertEqual(ret, 0, 'error while executing ' + cmd)
+        #ret = system(cmd)
+        #proc = run(cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True, check=check)
+        #return proc.stdout.strip() + proc.stderr.strip()
+        info('launching ' + app_cmd)
+        print('launching ' + app_cmd)
+        p_app = Popen(app_cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        sleep(8)
+        info('launching ' + test1_cmd)
+        print('launching ' + test1_cmd)
+        p_test = Popen(test1_cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        p_app_out, p_app_err = p_app.communicate()
+        t_out, t_err = p_test.communicate()
+        info('output (%s): %s' % (app_cmd, p_app_out))
+        info('error (%s): %s' % (app_cmd, p_app_err))
+        info('output (%s): %s' % (test1_cmd, t_out))
+        info('error (%s): %s' % (test1_cmd, t_err))
+        print('output (%s): %s' % (app_cmd, p_app_out))
+        print('error (%s): %s' % (app_cmd, p_app_err))
+        print('output (%s): %s' % (test1_cmd, t_out))
+        print('error (%s): %s' % (test1_cmd, t_err))
+        self.assertEqual(p_app.returncode, 0, 'error while executing ' + app_cmd)
+        self.assertEqual(p_test.returncode, 0, 'error while executing ' + test1_cmd)
+        sleep(12)
+        info('launching ' + app_cmd)
+        print('launching ' + app_cmd)
+        p_app = Popen(app_cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        sleep(8)
+        info('launching ' + test2_cmd)
+        print('launching ' + test2_cmd)
+        p_test = Popen(test2_cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        p_app_out, p_app_err = p_app.communicate()
+        t_out, t_err = p_test.communicate()
+        info('output (%s): %s' % (app_cmd, p_app_out))
+        info('error (%s): %s' % (app_cmd, p_app_err))
+        info('output (%s): %s' % (test2_cmd, t_out))
+        info('error (%s): %s' % (test2_cmd, t_err))
+        print('output (%s): %s' % (app_cmd, p_app_out))
+        print('error (%s): %s' % (app_cmd, p_app_err))
+        print('output (%s): %s' % (test2_cmd, t_out))
+        print('error (%s): %s' % (test2_cmd, t_err))
+        self.assertEqual(p_app.returncode, 0, 'error while executing ' + app_cmd)
+        self.assertEqual(p_test.returncode, 0, 'error while executing ' + test2_cmd)
         files = glob(str(Path.home()) + '/.local/share/pmachines/tests/functional_ref_%s/*.png' % _branch())
         self.assertGreater(len(files), 1)
         for fname in files:
@@ -92,10 +133,9 @@ class FunctionalTests(TestCase):
     def test_code(self):
         info('test_code')
         self.__test_template(
-            'timeout 720s ~/venv/bin/python main.py --functional-test & '
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 1; sleep 5; '
-            'timeout 720s ~/venv/bin/python main.py --functional-test & '
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 2',
+            'timeout 7200s ~/venv/bin/python main.py --functional-test',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 1',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 2',
             str(Path.home()) + '/.local/share/pmachines/tests/functional/')
 
     def test_appimage(self):
@@ -103,10 +143,9 @@ class FunctionalTests(TestCase):
         bld_branch = {'master': 'alpha', 'rc': 'rc', 'stable': 'stable'}[_branch()]
         bld_branch = '' if bld_branch == 'stable' else ('-' + bld_branch)
         self.__test_template(
-            'timeout 720s ./dist/Pmachines%s-x86_64.AppImage --functional-test & '
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 1; sleep 5; '
-            'timeout 720s ./dist/Pmachines%s-x86_64.AppImage --functional-test & ' % (bld_branch, bld_branch) +
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 2',
+            'timeout 7200s ./dist/Pmachines%s-x86_64.AppImage --functional-test' % bld_branch,
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 1',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 2',
             str(Path.home()) + '/.local/share/pmachines/tests/functional/')
 
     # def test_flatpak(self):
@@ -144,10 +183,9 @@ class FunctionalTests(TestCase):
             return
         self.__update_itchio()
         self.__test_template(
-            'timeout 720s /home/flavio/.config/itch/apps/pmachines/pmachines --functional-test & '
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 1; sleep 5; '
-            'timeout 720s /home/flavio/.config/itch/apps/pmachines/pmachines --functional-test & '
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 2',
+            'timeout 7200s /home/flavio/.config/itch/apps/pmachines/pmachines --functional-test',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 1',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 2',
             str(Path.home()) + '/.local/share/pmachines/tests/functional/')
 
     def test_windows(self):
@@ -155,10 +193,9 @@ class FunctionalTests(TestCase):
         system('pkill -f "pmachines.exe"')
         abspath = str(Path(__file__).parent.parent) + '/build/win_amd64/pmachines.exe'
         self.__test_template(
-            'timeout 720s wine %s --functional-test & ' % abspath +
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 1; sleep 5; '
-            'timeout 720s wine %s --functional-test & ' % abspath +
-            'timeout 720s ~/venv/bin/python -m tests.functional_test.py 2',
+            'timeout 7200s wine %s --functional-test' % abspath,
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 1',
+            'timeout 7200s ~/venv/bin/python -m tests.functional_test.py 2',
             str(Path.home()) + '/.wine/drive_c/users/flavio/AppData/Local/pmachines/tests/functional/')
 
     def test_versions(self):
@@ -177,15 +214,15 @@ class FunctionalTests(TestCase):
                 __ver = fver.read().strip() + '-'
         exp = '%s-%s' % (__ver, commit)
         cmds = [
-            ('timeout 720s ./build/manylinux2010_x86_64/pmachines --version', str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt'),
-            ('timeout 720s ./dist/Pmachines-%s-x86_64.AppImage --version' % bld_branch, str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt'),
-            ('timeout 720s wine ./build/win_amd64/pmachines.exe --version', '/home/flavio/.wine/drive_c/users/flavio/AppData/Local/pmachines/obs_version.txt')
+            ('timeout 7200s ./build/manylinux2010_x86_64/pmachines --version', str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt'),
+            ('timeout 7200s ./dist/Pmachines-%s-x86_64.AppImage --version' % bld_branch, str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt'),
+            ('timeout 7200s wine ./build/win_amd64/pmachines.exe --version', '/home/flavio/.wine/drive_c/users/flavio/AppData/Local/pmachines/obs_version.txt')
         ]
         if environ.get('FUNCTIONALPOST') == '1':
             if _branch() == 'master':
                 self.__update_itchio()
-                cmds += [('timeout 720s /home/flavio/.config/itch/apps/pmachines/pmachines --version', str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt')]
-            # cmds += [('timeout 720s flatpak run it.ya2.Pmachines//%s --version' % bld_branch, '/home/flavio/.var/app/it.ya2.Pmachines/data/pmachines/obs_version.txt')]
+                cmds += [('timeout 7200s /home/flavio/.config/itch/apps/pmachines/pmachines --version', str(Filename.get_user_appdata_directory()) + '/pmachines/obs_version.txt')]
+            # cmds += [('timeout 7200s flatpak run it.ya2.Pmachines//%s --version' % bld_branch, '/home/flavio/.var/app/it.ya2.Pmachines/data/pmachines/obs_version.txt')]
         # info('executing flatpak update --user -y it.ya2.Pmachines//%s' % bld_branch)
         # #system('flatpak update -y --user it.ya2.Pmachines//%s' % bld_branch)
         # fout = exec_cmd('flatpak update -y --user it.ya2.Pmachines//%s' % bld_branch)

diff --git a/ya2/utils/functional.py b/ya2/utils/functional.py
index 719bcbfe1f53eb48387f3499da1122f74f5da2a9..abe1079e0f8fe83f82ca2c68784c24bac5de26bc 100644 (file)
--- a/ya2/utils/functional.py
+++ b/ya2/utils/functional.py
@@ -13,7 +13,7 @@ from ya2.build.build import _branch
 class RPCServer(SimpleXMLRPCServer):
 
     def __init__(self, callbacks):
-        super().__init__(('localhost', 6000), allow_none=True)
+        super().__init__(('localhost', 7000), allow_none=True)
         self._callbacks = callbacks
         self.register_introspection_functions()
         self.register_function(self.screenshot, 'screenshot')