Treat invalid pattern property as unevaluated

jsonschema/_utils.py

@@ -291,10 +291,10 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
 
     if "patternProperties" in schema:
         for property, value in instance.items():
-            for pattern, _ in schema["patternProperties"].items():
+            for pattern, subschema in schema["patternProperties"].items():
                 if re.search(pattern, property) and validator.evolve(
-                    schema=schema["patternProperties"],
-                ).is_valid({property: value}):
+                    schema=subschema,
+                ).is_valid(value):
                     evaluated_keys.append(property)
 
     if "dependentSchemas" in schema:

jsonschema/tests/test_validators.py

@@ -284,11 +284,14 @@ def id_of(schema):
 
 
 class TestValidationErrorMessages(TestCase):
-    def message_for(self, instance, schema, *args, **kwargs):
+    def errors_for(self, instance, schema, *args, **kwargs):
         cls = kwargs.pop("cls", validators._LATEST_VERSION)
         cls.check_schema(schema)
         validator = cls(schema, *args, **kwargs)
-        errors = list(validator.iter_errors(instance))
+        return list(validator.iter_errors(instance))
+
+    def message_for(self, instance, schema, *args, **kwargs):
+        errors = self.errors_for(instance, schema, *args, **kwargs)
         self.assertTrue(errors, msg=f"No errors were raised for {instance!r}")
         self.assertEqual(
             len(errors),
@@ -677,6 +680,28 @@ def test_unevaluated_properties_disallowed(self):
             "('bar', 'foo' were unexpected)",
         )
 
+    def test_unevaluated_properties_failed_validation(self):
+        schema = {
+            "type": "object",
+            "patternProperties": {
+                "^foo": {"type": "string"},
+            },
+            "unevaluatedProperties": False,
+        }
+        errors = self.errors_for(
+            instance={
+                "foo": 42,
+            },
+            schema=schema,
+        )
+        error = [e for e in errors
+                 if e.validator == "unevaluatedProperties"][0]
+        self.assertEqual(
+            error.message,
+            "Unevaluated properties are not allowed "
+            "('foo' was unexpected)",
+        )
+
     def test_unevaluated_properties_on_invalid_type(self):
         schema = {"type": "object", "unevaluatedProperties": False}
         message = self.message_for(instance="foo", schema=schema)