Fixes to get ctest up and running again.

bin/cros_au_test_harness.py

 #!/usr/bin/python
 
 # 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.
 
 import optparse
 import os
 import re
 import sys
@@ skipping 67 matching lines @@
         break
 
     return int(percent_passed)
 
   # TODO(sosa) - Remove try and convert function to DeltaUpdateImage().
   def TryDeltaAndFallbackToFull(self, src_image, image, stateful_change='old'):
     """Tries the delta update first if set and falls back to full update."""
     if self.use_delta_updates:
       try:
         self.source_image = src_image
-        self._UpdateImageReportError(image)
+        self._UpdateImageReportError(image, stateful_change)
       except:
         Warning('Delta update failed, disabling delta updates and retrying.')
         self.use_delta_updates = False
         self.source_image = ''
-        self._UpdateImageReportError(image)
+        self._UpdateImageReportError(image, stateful_change)
     else:
-      self._UpdateImageReportError(image)
+      self._UpdateImageReportError(image, stateful_change)
 
   def _UpdateImageReportError(self, image_path, stateful_change='old',
                               proxy_port=None):
     """Calls UpdateImage and reports any error to the console.
 
        Still throws the exception.
     """
     try:
       self.UpdateImage(image_path, stateful_change, proxy_port)
     except UpdateException as err:
@@ skipping 12 matching lines @@
 
     Warning("Didn't find '%s' in:" % expected_msg)
     Warning(err.stdout)
     self.fail('We managed to update when failure was expected')
 
   def _AttemptUpdateWithFilter(self, filter):
     """Update through a proxy, with a specified filter, and expect success."""
 
     self.PrepareBase(target_image_path)
 
-    # The devserver runs at port 8080 by default. We assume that here, and  
-    # start our proxy at 8081. We then tell our update tools to have the    
+    # The devserver runs at port 8080 by default. We assume that here, and
+    # start our proxy at 8081. We then tell our update tools to have the
     # client connect to 8081 instead of 8080.
     proxy_port = 8081
     proxy = cros_test_proxy.CrosTestProxy(port_in=proxy_port,
                                           address_out='127.0.0.1',
                                           port_out=8080,
                                           filter=filter)
     proxy.serve_forever_in_thread()
 
     # This update is expected to fail...
     try:
@@ skipping 151 matching lines @@
 
     # This update is expected to fail...
     expected_msg = 'zlib inflate() error:-3'
     self._AttemptUpdateWithPayloadExpectedFailure(payload, expected_msg)
 
   def testInterruptedUpdate(self):
     """Tests what happens if we interrupt payload delivery 3 times."""
 
     class InterruptionFilter(cros_test_proxy.Filter):
       """This filter causes the proxy to interrupt the download 3 times
-      
+
          It does this by closing the first three connections to transfer
-         2M total in the outbound connection after they transfer the 
+         2M total in the outbound connection after they transfer the
          2M.
       """
       def __init__(self):
         """Defines variable shared across all connections"""
         self.close_count = 0
-      
+
       def setup(self):
         """Called once at the start of each connection."""
         self.data_size = 0
 
       def OutBound(self, data):
         """Called once per packet for outgoing data.
 
            The first three connections transferring more than 2M
            outbound will be closed.
         """
         if self.close_count < 3:
           if self.data_size > (2 * 1024 * 1024):
             self.close_count += 1
             return None
-        
+
         self.data_size += len(data)
-        return data 
+        return data
 
     self._AttemptUpdateWithFilter(InterruptionFilter())
 
   def testDelayedUpdate(self):
     """Tests what happens if some data is delayed during update delivery"""
 
     class DelayedFilter(cros_test_proxy.Filter):
       """Causes intermittent delays in data transmission.
-      
+
          It does this by inserting 3 20 second delays when transmitting
          data after 2M has been sent.
       """
       def setup(self):
         """Called once at the start of each connection."""
         self.data_size = 0
         self.delay_count = 0
 
       def OutBound(self, data):
         """Called once per packet for outgoing data.
 
            The first three packets after we reach 2M transferred
            are delayed by 20 seconds.
         """
         if self.delay_count < 3:
           if self.data_size > (2 * 1024 * 1024):
             self.delay_count += 1
             time.sleep(20)
-        
+
         self.data_size += len(data)
-        return data 
-
+        return data
 
     self._AttemptUpdateWithFilter(DelayedFilter())
 
+  def SimpleTest(self):
+    """A simple update  that updates the target image to itself.
+
+    We explicitly don't use test prefix so that isn't run by default.  Can be
+    run using test_prefix option.
+    """
+    self.PrepareBase(target_image_path)
+    self.UpdateImage(target_image_path)
+    self.VerifyImage(100)
+
+
 class RealAUTest(unittest.TestCase, AUTest):
   """Test harness for updating real images."""
 
   def setUp(self):
     AUTest.setUp(self)
 
   def PrepareBase(self, image_path):
     """Auto-update to base image to prepare for test."""
     self._UpdateImageReportError(image_path)
 
   def UpdateImage(self, image_path, stateful_change='old', proxy_port=None):
     """Updates a remote image using image_to_live.sh."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
     cmd = ['%s/image_to_live.sh' % self.crosutils,
            '--image=%s' % image_path,
            '--remote=%s' % remote,
            stateful_change_flag,
            '--verify',
            '--src_image=%s' % self.source_image
           ]
 
     if proxy_port:
-      cmd.append('--proxy_port=%s' % proxy_port) 
+      cmd.append('--proxy_port=%s' % proxy_port)
 
     if self.verbose:
       try:
         RunCommand(cmd)
       except Exception, e:
         raise UpdateException(1, e.message)
     else:
       (code, stdout, stderr) = RunCommandCaptureOutput(cmd)
       if code != 0:
         raise UpdateException(code, stdout)
 
   def UpdateUsingPayload(self,
                          update_path,
                          stateful_change='old',
                          proxy_port=None):
     """Updates a remote image using image_to_live.sh."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
     cmd = ['%s/image_to_live.sh' % self.crosutils,
            '--payload=%s' % update_path,
            '--remote=%s' % remote,
            stateful_change_flag,
            '--verify',
           ]
 
     if proxy_port:
-      cmd.append('--proxy_port=%s' % proxy_port) 
+      cmd.append('--proxy_port=%s' % proxy_port)
 
     if self.verbose:
       try:
         RunCommand(cmd)
       except Exception, e:
         raise UpdateException(1, e.message)
     else:
       (code, stdout, stderr) = RunCommandCaptureOutput(cmd)
       if code != 0:
         raise UpdateException(code, stdout)
@@ skipping 64 matching lines @@
            '--vm_image_path=%s' % self.vm_image_path,
            '--snapshot',
            vm_graphics_flag,
            '--persist',
            '--kvm_pid=%s' % _KVM_PID_FILE,
            stateful_change_flag,
            '--src_image=%s' % self.source_image,
            ]
 
     if proxy_port:
-      cmd.append('--proxy_port=%s' % proxy_port) 
+      cmd.append('--proxy_port=%s' % proxy_port)
 
     if self.verbose:
       try:
         RunCommand(cmd)
       except Exception, e:
         raise UpdateException(1, e.message)
     else:
       (code, stdout, stderr) = RunCommandCaptureOutput(cmd)
       if code != 0:
         raise UpdateException(code, stdout)
@@ skipping 12 matching lines @@
            '--vm_image_path=%s' % self.vm_image_path,
            '--snapshot',
            vm_graphics_flag,
            '--persist',
            '--kvm_pid=%s' % _KVM_PID_FILE,
            stateful_change_flag,
            '--src_image=%s' % self.source_image,
            ]
 
     if proxy_port:
-      cmd.append('--proxy_port=%s' % proxy_port) 
+      cmd.append('--proxy_port=%s' % proxy_port)
 
     if self.verbose:
       try:
         RunCommand(cmd)
       except Exception, e:
         raise UpdateException(1, e.message)
     else:
       (code, stdout, stderr) = RunCommandCaptureOutput(cmd)
       if code != 0:
         raise UpdateException(code, stdout)
@@ skipping 81 matching lines @@
   elif options.type == 'real': test_class = RealAUTest
   else: parser.error('Could not parse harness type %s.' % options.type)
 
   remote = options.remote
 
   test_suite = test_loader.loadTestsFromTestCase(test_class)
   test_result = unittest.TextTestRunner(verbosity=2).run(test_suite)
 
   if not test_result.wasSuccessful():
     Die('Test harness was not successful')