factory_test_tools: fix results for HWQual tests

gft_hwcomp.py

 #!/usr/bin/python
 #
 # Copyright (c) 2011 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.
 
 import glob
 import imp
 import os
 import pprint
@@ skipping 71 matching lines @@
     'part_id_ec_flash_chip',
     ]
 
   # _not_test_cids and _to_be_tested_cids will be re-created for each match.
   _not_test_cids = []
   _to_be_tested_cids = []
 
   # TODO(hungte) unify the 'not available' style messages
   _not_present = ''
   _no_match = 'No match'
+  _failure_list = [_not_present, _no_match, '']
 
   # Type id for connection management (compatible to flimflam)
   _type_3g = 'cellular'
   _type_ethernet = 'ethernet'
   _type_wireless = 'wifi'
 
   _flimflam_dir = '/usr/local/lib/flimflam/test'
 
   def __init__(self, verbose=False):
     self._initialized = False
@@ skipping 643 matching lines @@
       else:
         fetch_enumerable_component(cid)
 
     # Complete the threads
     for thread in thread_pools:
       thread.start()
     for thread in thread_pools:
       thread.join()
     return results
 
+  def format_failure(self, exact_values, approved_values):
+    message_not_present = 'Not Present'
+    actual = [(message_not_present
+               if value in self._failure_list else value)
+              for value in exact_values]
+    expected = [(message_not_present
+                 if value in self._failure_list else value)
+                for value in approved_values]
+    return ['Actual: %s' % ', '.join(set(actual)),
+            'Expected: %s' % ' | '.join(set(expected))]
+
   def check_enumerable_component(self, cid, exact_values, approved_values):
     if '*' in approved_values:
       return
 
     unmatched = [value for value in exact_values
                  if value not in approved_values]
     if not unmatched:
       return
 
     # there's some error, let's try to match them in legacy list
-    legacy_approved = filter(self.is_legacy_device_record, approved_values)
-    if set(legacy_approved) == set(approved_values):
+    match_goal = [value for value in approved_values
+                  if value not in self._failure_list]
+    legacy_approved = filter(self.is_legacy_device_record, match_goal)
+    if match_goal and (set(legacy_approved) == set(match_goal)):
       DebugMsg('Start legacy search for cid: ' + cid)
-      # safe for legacy match
       # TODO(hungte) prefetch this list in async batch process.
       legacy_list = self._get_legacy_device_list()
-      matched = list(set(legacy_list).intersection(set(approved_values)))
+      matched = list(set(legacy_list).intersection(set(match_goal)))
       if matched:
         DebugMsg('Changed detected list: %s->%s' % (self._system[cid], matched))
         self._system[cid] = matched
         return
     # update with remaining error.
-    self._failures[cid] = unmatched
+    self._failures[cid] = self.format_failure(exact_values, approved_values)
 
   @Memorize
   def verify_probable_component(self, cid, approved_values):
     if '*' in approved_values:
       return (True, ['*'])
 
     for value in approved_values:
       present = getattr(self, 'probe_' + cid)(value)
       if present:
         return (True, [value])
     return (False, [self._no_match])
 
   def check_probable_component(self, cid, approved_values):
     (probed, value) = self.verify_probable_component(cid, approved_values)
     if probed:
       self._system[cid] = value
     else:
-      self._failures[cid] = value
+      self._failures[cid] = self.format_failure(value, approved_values)
 
   def pformat(self, obj):
     return '\n' + self._pp.pformat(obj) + '\n'
 
   def initialize(self, force=False, async=False):
     if self._initialized and not force:
       return
     # probe current system components
     DebugMsg('Starting to detect system components...')
     self._enumerable_system = self.get_all_enumerable_components(async)
@@ skipping 63 matching lines @@
   print 'Starting to match system...'
   for arg in compdb_list:
     (matched, failures) = components.match_current_system(arg)
     print 'Probed (%s):' % arg
     print components.pformat(matched)
     print 'Failures (%s):' % arg
     print components.pformat(failures)
 
 if __name__ == '__main__':
   _main(sys.argv[0], sys.argv[1:])