Cleanup machine based on the state in configuration file for mini installer test.

chrome/test/mini_installer/registry_verifier.py

 # Copyright 2013 The Chromium 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 _winreg
 
 import verifier
 
 
 class RegistryVerifier(verifier.Verifier):
   """Verifies that the current registry matches the specified criteria."""
 
+  def __init__(self):
+    self._root_key_value = None
+    self._is_key_forbidden = None
+    self._sub_key = None
+
   def _RootKeyConstant(self, root_key):
     """Converts a root registry key string into a _winreg.HKEY_* constant."""
     root_key_mapping = {
         'HKEY_CLASSES_ROOT': _winreg.HKEY_CLASSES_ROOT,
         'HKEY_CURRENT_USER': _winreg.HKEY_CURRENT_USER,
         'HKEY_LOCAL_MACHINE': _winreg.HKEY_LOCAL_MACHINE,
         'HKEY_USERS': _winreg.HKEY_USERS,
     }
     if root_key not in root_key_mapping:
       raise KeyError("Unknown root registry key '%s'" % root_key)
@@ skipping 33 matching lines @@
               and its associated value is a dictionary with the following key
               and values:
                   'type' (optional) a string indicating the type of the registry
                       value. If not present, the corresponding value is expected
                       to be absent in the registry.
                   'data' the associated data of the registry value if 'type' is
                       specified. If it is a string, it is expanded using Expand.
       variable_expander: A VariableExpander object.
     """
     key = variable_expander.Expand(expectation_name)
-    root_key, sub_key = key.split('\\', 1)
+    root_key, self._sub_key = key.split('\\', 1)
+    self._root_key_value = self._RootKeyConstant(root_key)
+    self._is_key_forbidden = (expectation['exists'] == 'forbidden')
     try:
       # Query the Windows registry for the registry key. It will throw a
       # WindowsError if the key doesn't exist.
-      key_handle = _winreg.OpenKey(self._RootKeyConstant(root_key), sub_key, 0,
+      key_handle = _winreg.OpenKey(self._root_key_value, self._sub_key, 0,
                                    _winreg.KEY_QUERY_VALUE)
     except WindowsError:
       # Key doesn't exist. See that it matches the expectation.
-      assert expectation['exists'] != 'required', ('Registry key %s is '
-                                                   'missing' % key)
+      self._Assert(expectation['exists'] != 'required', ('Registry key %s is '
+                                                   'missing' % key))
       # Values are not checked if the missing key's existence is optional.
       return
     # The key exists, see that it matches the expectation.
-    assert expectation['exists'] != 'forbidden', ('Registry key %s exists' %
-                                                  key)
+    self._Assert(expectation['exists'] != 'forbidden',
+                 ('Registry key %s exists' % key))
 
     # Verify the expected values.
     if 'values' not in expectation:
       return
     for value, value_expectation in expectation['values'].iteritems():
       # Query the value. It will throw a WindowsError if the value doesn't
       # exist.
       try:
         data, value_type = _winreg.QueryValueEx(key_handle, value)
       except WindowsError:
@@ skipping 12 matching lines @@
               value, key, expected_value_type)
 
       # Verify the associated data of the value.
       expected_data = value_expectation['data']
       if isinstance(expected_data, basestring):
         expected_data = variable_expander.Expand(expected_data)
       assert expected_data == data, \
           ("Value '%s' of registry key %s has unexpected data.\n"
            "  Expected: %s\n"
            "  Actual: %s" % (value, key, expected_data, data))