Relocate library files for wider access and re-use; also associated cleanup.

client/site_tests/factory_Display/factory_Display.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
 # DESCRIPTION :
 #
-# This is an example factory test that does not really do anything --
-# it displays a message in the center of the testing area, as
-# communicated by arguments to run_once().  This test makes use of the
-# factory_test library to display its UI, and to monitor keyboard
-# events for test-switching triggers.  This test can be terminated by
-# typing SHIFT-Q.
+# This is a factory test to test the LCD display.
 
-from autotest_lib.client.bin import test
-from autotest_lib.client.common_lib import error
-from autotest_lib.client.common_lib import factory_test
 
 import gtk
 import pango
 import os
 import sys
 
+from autotest_lib.client.bin import factory
+from autotest_lib.client.bin import factory_ui_lib as ful
+from autotest_lib.client.bin import test
+from autotest_lib.client.common_lib import error
 
-def XXX_log(s):
-    print >> sys.stderr, 'FACTORY: ' + s
-
-
-_BLACK = gtk.gdk.Color()
-_RED =   gtk.gdk.Color(0xFFFF, 0, 0)
-_GREEN = gtk.gdk.Color(0, 0xFFFF, 0)
-_BLUE =  gtk.gdk.Color(0, 0, 0xFFFF)
-_WHITE = gtk.gdk.Color(0xFFFF, 0xFFFF, 0xFFFF)
-
-_ACTIVE = 'ACTIVE'
-_PASSED = 'PASS'
-_FAILED = 'FAIL'
-_UNTESTED = 'UNTESTED'
-
-_LABEL_COLORS = {
-    _ACTIVE: gtk.gdk.color_parse('light goldenrod'),
-    _PASSED: gtk.gdk.color_parse('pale green'),
-    _FAILED: gtk.gdk.color_parse('tomato'),
-    _UNTESTED: gtk.gdk.color_parse('dark slate grey')}
 
 _LABEL_STATUS_SIZE = (140, 30)
 _LABEL_STATUS_FONT = pango.FontDescription('courier new condensed 16')
 _LABEL_FONT = pango.FontDescription('courier new condensed 20')
 _LABEL_FG = gtk.gdk.color_parse('light green')
 _LABEL_UNTESTED_FG = gtk.gdk.color_parse('grey40')
 
 
 def pattern_cb_solid(widget, event, color=None):
     dr = widget.window
     xmax, ymax = dr.get_size()
     gc = gtk.gdk.GC(dr)
     gc.set_rgb_fg_color(color)
     dr.draw_rectangle(gc, True, 0, 0, xmax, ymax)
     return False
 
 
 def pattern_cb_grid(widget, event, color=None):
     dr = widget.window
     xmax, ymax = dr.get_size()
     gc = gtk.gdk.GC(dr)
-    gc.set_rgb_fg_color(_BLACK)
+    gc.set_rgb_fg_color(ful.BLACK)
     dr.draw_rectangle(gc, True, 0, 0, xmax, ymax)
     gc.set_rgb_fg_color(color)
     gc.set_line_attributes(1,
                            gtk.gdk.LINE_SOLID,
                            gtk.gdk.CAP_BUTT,
                            gtk.gdk.JOIN_MITER)
     for x in range(0, xmax, 20):
         dr.draw_line(gc, x, 0, x, ymax)
     for y in range(0, ymax, 20):
         dr.draw_line(gc, 0, y, xmax, y)
     return False
 
 
 _PATTERN_LIST = [
-    ('solid red', lambda *x: pattern_cb_solid(*x, **{'color':_RED})),
-    ('solid green', lambda *x: pattern_cb_solid(*x, **{'color':_GREEN})),
-    ('solid blue', lambda *x: pattern_cb_solid(*x, **{'color':_BLUE})),
-    ('solid white', lambda *x: pattern_cb_solid(*x, **{'color':_WHITE})),
-    ('grid', lambda *x: pattern_cb_grid(*x, **{'color':_GREEN}))]
+    ('solid red', lambda *x: pattern_cb_solid(*x, **{'color':ful.RED})),
+    ('solid green', lambda *x: pattern_cb_solid(*x, **{'color':ful.GREEN})),
+    ('solid blue', lambda *x: pattern_cb_solid(*x, **{'color':ful.BLUE})),
+    ('solid white', lambda *x: pattern_cb_solid(*x, **{'color':ful.WHITE})),
+    ('grid', lambda *x: pattern_cb_grid(*x, **{'color':ful.GREEN}))]
 
 
 class factory_Display(test.test):
     version = 1
 
     def display_full_screen(self, pattern_callback):
         window = gtk.Window(gtk.WINDOW_TOPLEVEL)
         screen = window.get_screen()
         screen_size = (screen.get_width(), screen.get_height())
         window.set_size_request(*screen_size)
         drawing_area = gtk.DrawingArea()
         window.add(drawing_area)
         window.show_all()
         self._fs_window = window
         drawing_area.connect('expose_event', pattern_callback)
 
     def goto_next_pattern(self):
         if not self._pattern_queue:
             gtk.main_quit()
             return
         self._current_pattern = self._pattern_queue.pop()
         name, cb_fn = self._current_pattern
-        self._status_map[name] = _ACTIVE
+        self._status_map[name] = ful.ACTIVE
         self._current_pattern_shown = False
 
     def key_press_callback(self, widget, event):
         pattern_name, pattern_cb = self._current_pattern
         if event.keyval == gtk.keysyms.space and not self._fs_window:
             self.display_full_screen(pattern_cb)
         return True
 
     def key_release_callback(self, widget, event):
         pattern_name, pattern_cb = self._current_pattern
         if event.keyval == gtk.keysyms.space and self._fs_window is not None:
             self._fs_window.destroy()
             self._fs_window = None
             self._current_pattern_shown = True
         elif event.keyval == gtk.keysyms.Tab and self._current_pattern_shown:
-            self._status_map[pattern_name] = _FAILED
+            self._status_map[pattern_name] = ful.FAILED
             self.goto_next_pattern()
         elif event.keyval == gtk.keysyms.Return and self._current_pattern_shown:
-            self._status_map[pattern_name] = _PASSED
+            self._status_map[pattern_name] = ful.PASSED
             self.goto_next_pattern()
         elif event.keyval == ord('Q'):
-            factory_test.XXX_log('factory_Display exiting...')
             gtk.main_quit()
         else:
-            factory_test.test_switch_on_trigger(event)
+            self._ft_state.exit_on_trigger(event)
         self._test_widget.queue_draw()
         return True
 
     def label_status_expose(self, widget, event, name=None):
         status = self._status_map[name]
         widget.set_text(status)
-        widget.modify_fg(gtk.STATE_NORMAL, _LABEL_COLORS[status])
+        widget.modify_fg(gtk.STATE_NORMAL, ful.LABEL_COLORS[status])
 
     def make_pattern_label_box(self, name):
         eb = gtk.EventBox()
-        eb.modify_bg(gtk.STATE_NORMAL, _BLACK)
-        label_status = gtk.Label(_UNTESTED)
+        eb.modify_bg(gtk.STATE_NORMAL, ful.BLACK)
+        label_status = gtk.Label(ful.UNTESTED)
         label_status.set_size_request(*_LABEL_STATUS_SIZE)
         label_status.set_alignment(0, 0.5)
         label_status.modify_font(_LABEL_STATUS_FONT)
         label_status.modify_fg(gtk.STATE_NORMAL, _LABEL_UNTESTED_FG)
         expose_cb = lambda *x: self.label_status_expose(*x, **{'name':name})
         label_status.connect('expose_event', expose_cb)
         label_en = gtk.Label(name)
         label_en.set_alignment(1, 0.5)
         label_en.modify_font(_LABEL_STATUS_FONT)
         label_en.modify_fg(gtk.STATE_NORMAL, _LABEL_FG)
         label_sep = gtk.Label(' : ')
         label_sep.set_alignment(0.5, 0.5)
         label_sep.modify_font(_LABEL_FONT)
         label_sep.modify_fg(gtk.STATE_NORMAL, _LABEL_FG)
         hbox = gtk.HBox()
         hbox.pack_end(label_status, False, False)
         hbox.pack_end(label_sep, False, False)
         hbox.pack_end(label_en, False, False)
         eb.add(hbox)
         return eb
 
     def register_callbacks(self, window):
         window.connect('key-press-event', self.key_press_callback)
         window.add_events(gtk.gdk.KEY_PRESS_MASK)
         window.connect('key-release-event', self.key_release_callback)
         window.add_events(gtk.gdk.KEY_RELEASE_MASK)
 
-    def run_once(self, test_widget_size=None, trigger_set=None,
+    def run_once(self,
+                 test_widget_size=None,
+                 trigger_set=None,
                  result_file_path=None):
 
-        factory_test.XXX_log('factory_Display')
+        factory.log('%s run_once' % self.__class__)
 
         xset_status = os.system('xset r off')
-        xmm_status = os.system('xmodmap -e "clear Lock"')
-        if xset_status or xmm_status:
-            raise TestFail('ERROR: disabling key repeat or caps lock')
+        if xset_status:
+            raise TestFail('ERROR: disabling key repeat')
 
-        factory_test.init(trigger_set=trigger_set,
-                          result_file_path=result_file_path)
+        self._ft_state = ful.State(
+            trigger_set=trigger_set,
+            result_file_path=result_file_path)
 
         self._pattern_queue = [x for x in reversed(_PATTERN_LIST)]
-        self._status_map = dict((n, _UNTESTED) for n, f in _PATTERN_LIST)
+        self._status_map = dict((n, ful.UNTESTED) for n, f in _PATTERN_LIST)
 
         prompt_label = gtk.Label('hold SPACE to display pattern,\n'
                                  'TAB to fail and RETURN to pass\n')
         prompt_label.modify_font(_LABEL_FONT)
         prompt_label.set_alignment(0.5, 0.5)
         prompt_label.modify_fg(gtk.STATE_NORMAL, _LABEL_FG)
         self._prompt_label = prompt_label
 
         vbox = gtk.VBox()
         vbox.pack_start(prompt_label, False, False)
 
         for name, cb_fun in _PATTERN_LIST:
             label_box = self.make_pattern_label_box(name)
             vbox.pack_start(label_box, False, False)
 
         test_widget = gtk.EventBox()
-        test_widget.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('black'))
+        test_widget.modify_bg(gtk.STATE_NORMAL, ful.BLACK)
         test_widget.add(vbox)
         self._test_widget = test_widget
 
         self.goto_next_pattern()
 
         self._fs_window = None
 
-        factory_test.run_test_widget(
+        self._ft_state.run_test_widget(
             test_widget=test_widget,
             test_widget_size=test_widget_size,
             window_registration_callback=self.register_callbacks)
 
         failed_set = set(name for name, status in self._status_map.items()
-                         if status is not _PASSED)
+                         if status is not ful.PASSED)
         if failed_set:
             raise error.TestFail('some patterns failed (%s)' %
                                  ', '.join(failed_set))
 
-        factory_test.XXX_log('exiting factory_Display')
+        factory.log('%s run_once finished' % self.__class__)