Reduce flakes in the 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):
@@ skipping 31 matching lines @@
   def _VerifyExpectation(self, expectation_name, expectation,
                          variable_expander):
     """Overridden from verifier.Verifier.
 
     Verifies a registry key according to the |expectation|.
 
     Args:
       expectation_name: The registry key being verified. It is expanded using
           Expand.
       expectation: A dictionary with the following keys and values:
-          'exists' a boolean indicating whether the registry key should exist.
+          'exists' a string indicating whether the registry key's existence is
+              'required', 'optional', or 'forbidden'.
           'values' (optional) a dictionary where each key is a registry value
               and its associated value is a dictionary with the following key
               and values:
-                  'type' a string indicating the type of the registry value.
-                  'data' the associated data of the registry value. If it is a
-                      string, it is expanded using Expand.
+                  '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)
     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,
                                    _winreg.KEY_QUERY_VALUE)
     except WindowsError:
       # Key doesn't exist. See that it matches the expectation.
-      assert not expectation['exists'], ('Registry key %s is missing' %
-                                         key)
+      assert expectation['exists'] is not 'required', ('Registry key %s is '
+                                                       'missing' % key)
+      # Values are not checked if the missing key's existence is optional.

[robertshield, 2014/09/02 15:45:27]

Can you reference this in the method comment?

[grt (UTC plus 2), 2014/09/02 16:37:11]

Done.

       return
     # The key exists, see that it matches the expectation.
-    assert expectation['exists'], ('Registry key %s exists' % key)
+    assert expectation['exists'] is not '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:
-        raise KeyError("Value '%s' of registry key %s is missing" % (
-            value, key))
+        # The value does not exist. See that this matches the expectation.
+        assert 'type' not in value_expectation, ('Value %s of registry key %s '
+                                                 'is missing' % (value, key))
+        continue
+
+      assert 'type' in value_expectation, ('Value %s of registry key %s exists '
+                                           'with value %s' % (value, key, data))
 
       # Verify the type of the value.
       expected_value_type = value_expectation['type']
       assert self._ValueTypeConstant(expected_value_type) == value_type, \
           "Value '%s' of registry key %s has unexpected type '%s'" % (
               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))