schemathesis 4.0.0a9__py3-none-any.whl → 4.0.0a11__py3-none-any.whl

schemathesis/generation/case.py

@@ -71,7 +71,7 @@ class Case:
 
     def as_curl_command(self, headers: Mapping[str, Any] | None = None, verify: bool = True) -> str:
         """Construct a curl command for a given case."""
-        request_data = prepare_request(self, headers, self.operation.schema.output_config.sanitize)
+        request_data = prepare_request(self, headers, config=self.operation.schema.config.output.sanitization)
         return curl.generate(
             method=str(request_data.method),
             url=str(request_data.url),
@@ -142,7 +142,9 @@ class Case:
             override=self._override,
             auth=None,
             headers=CaseInsensitiveDict(headers) if headers else None,
-            config={},
+            config=self.operation.schema.config.checks_config_for(
+                operation=self.operation, phase=self.meta.phase.name.value if self.meta is not None else None
+            ),
             transport_kwargs=transport_kwargs,
             recorder=None,
         )
@@ -163,7 +165,7 @@ class Case:
                 response=response,
                 failures=_failures,
                 curl=curl,
-                config=self.operation.schema.output_config,
+                config=self.operation.schema.config.output,
             )
             raise FailureGroup(_failures, message) from None
 

schemathesis/generation/coverage.py

@@ -16,12 +16,13 @@ from hypothesis_jsonschema import from_schema
 from hypothesis_jsonschema._canonicalise import canonicalish
 from hypothesis_jsonschema._from_schema import STRING_FORMATS as BUILT_IN_STRING_FORMATS
 
-from schemathesis.core import NOT_SET
+from schemathesis.core import INTERNAL_BUFFER_SIZE, NOT_SET
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.hypothesis import examples
+from schemathesis.openapi.generation.filters import is_invalid_path_parameter
 
 from ..specs.openapi.converter import update_pattern_in_schema
 from ..specs.openapi.formats import STRING_FORMATS, get_default_format_strategies
@@ -36,7 +37,6 @@ def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
     return st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3)
 
 
-BUFFER_SIZE = 8 * 1024
 NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN = 100
 NEGATIVE_MODE_MAX_ITEMS = 15
 FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
@@ -153,6 +153,8 @@ class CoverageContext:
     def is_valid_for_location(self, value: Any) -> bool:
         if self.location in ("header", "cookie") and isinstance(value, str):
             return not value or (is_latin_1_encodable(value) and not has_invalid_characters("", value))
+        elif self.location == "path":
+            return not is_invalid_path_parameter(value)
         return True
 
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
@@ -161,7 +163,7 @@ class CoverageContext:
     def generate_from_schema(self, schema: dict | bool) -> Any:
         if isinstance(schema, bool):
             return 0
-        keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example"]])
+        keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example", "examples"]])
         if keys == ["type"] and isinstance(schema["type"], str) and schema["type"] in STRATEGIES_FOR_TYPE:
             return cached_draw(STRATEGIES_FOR_TYPE[schema["type"]])
         if keys == ["format", "type"]:
@@ -253,6 +255,24 @@ def _to_hashable_key(value: T, _encode: Callable = _encode) -> tuple[type, str |
     return (type(value), value)
 
 
+class HashSet:
+    """Helper to track already generated values."""
+
+    __slots__ = ("_data",)
+
+    def __init__(self) -> None:
+        self._data: set[tuple] = set()
+
+    def insert(self, value: Any) -> bool:
+        key = _to_hashable_key(value)
+        before = len(self._data)
+        self._data.add(key)
+        return len(self._data) > before
+
+    def clear(self) -> None:
+        self._data.clear()
+
+
 def _cover_positive_for_type(
     ctx: CoverageContext, schema: dict, ty: str | None
 ) -> Generator[GeneratedValue, None, None]:
@@ -326,10 +346,10 @@ def _ignore_unfixable(
 
 
 def cover_schema_iter(
-    ctx: CoverageContext, schema: dict | bool, seen: set[Any | tuple[type, str]] | None = None
+    ctx: CoverageContext, schema: dict | bool, seen: HashSet | None = None
 ) -> Generator[GeneratedValue, None, None]:
     if seen is None:
-        seen = set()
+        seen = HashSet()
     if isinstance(schema, bool):
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
@@ -352,12 +372,9 @@ def cover_schema_iter(
                     yield from _negative_enum(ctx, value, seen)
                 elif key == "const":
                     for value_ in _negative_enum(ctx, [value], seen):
-                        k = _to_hashable_key(value_.value)
-                        if k not in seen:
-                            yield value_
-                            seen.add(k)
+                        yield value_
                 elif key == "type":
-                    yield from _negative_type(ctx, seen, value)
+                    yield from _negative_type(ctx, value, seen)
                 elif key == "properties":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_properties(ctx, template, value)
@@ -374,37 +391,30 @@ def cover_schema_iter(
                     yield from _negative_format(ctx, schema, value)
                 elif key == "maximum":
                     next = value + 1
-                    if next not in seen:
+                    if seen.insert(next):
                         yield NegativeValue(next, description="Value greater than maximum", location=ctx.current_path)
-                        seen.add(next)
                 elif key == "minimum":
                     next = value - 1
-                    if next not in seen:
+                    if seen.insert(next):
                         yield NegativeValue(next, description="Value smaller than minimum", location=ctx.current_path)
-                        seen.add(next)
-                elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
+                elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and seen.insert(value):
                     verb = "greater" if key == "exclusiveMaximum" else "smaller"
                     limit = "maximum" if key == "exclusiveMaximum" else "minimum"
                     yield NegativeValue(value, description=f"Value {verb} than {limit}", location=ctx.current_path)
-                    seen.add(value)
                 elif key == "multipleOf":
                     for value_ in _negative_multiple_of(ctx, schema, value):
-                        k = _to_hashable_key(value_.value)
-                        if k not in seen:
+                        if seen.insert(value_.value):
                             yield value_
-                            seen.add(k)
-                elif key == "minLength" and 0 < value < BUFFER_SIZE:
+                elif key == "minLength" and 0 < value < INTERNAL_BUFFER_SIZE:
                     if value == 1:
                         # In this case, the only possible negative string is an empty one
                         # The `pattern` value may require an non-empty one and the generation will fail
                         # However, it is fine to violate `pattern` here as it is negative string generation anyway
                         value = ""
-                        k = _to_hashable_key(value)
-                        if k not in seen:
+                        if seen.insert(value):
                             yield NegativeValue(
                                 value, description="String smaller than minLength", location=ctx.current_path
                             )
-                            seen.add(k)
                     else:
                         with suppress(InvalidArgument):
                             min_length = max_length = value - 1
@@ -421,13 +431,11 @@ def cover_schema_iter(
                                     value = ctx.generate_from_schema(new_schema)
                             else:
                                 value = ctx.generate_from_schema(new_schema)
-                            k = _to_hashable_key(value)
-                            if k not in seen:
+                            if seen.insert(value):
                                 yield NegativeValue(
                                     value, description="String smaller than minLength", location=ctx.current_path
                                 )
-                                seen.add(k)
-                elif key == "maxLength" and value < BUFFER_SIZE:
+                elif key == "maxLength" and value < INTERNAL_BUFFER_SIZE:
                     try:
                         min_length = max_length = value + 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
@@ -448,12 +456,10 @@ def cover_schema_iter(
                                     value = ctx.generate_from_schema(new_schema)
                         else:
                             value = ctx.generate_from_schema(new_schema)
-                        k = _to_hashable_key(value)
-                        if k not in seen:
+                        if seen.insert(value):
                             yield NegativeValue(
                                 value, description="String larger than maxLength", location=ctx.current_path
                             )
-                            seen.add(k)
                     except (InvalidArgument, Unsatisfiable):
                         pass
                 elif key == "uniqueItems" and value:
@@ -461,7 +467,7 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
-                elif key == "maxItems" and isinstance(value, int) and value < BUFFER_SIZE:
+                elif key == "maxItems" and isinstance(value, int) and value < INTERNAL_BUFFER_SIZE:
                     if value > NEGATIVE_MODE_MAX_ITEMS:
                         # It could be extremely slow to generate large arrays
                         # Generate values up to the limit and reuse them to construct the final array
@@ -471,34 +477,41 @@ def cover_schema_iter(
                             "maxItems": NEGATIVE_MODE_MAX_ITEMS,
                             "type": "array",
                         }
-                        array_value = ctx.generate_from_schema(new_schema)
+                        if "items" in schema and isinstance(schema["items"], dict):
+                            # The schema may have another large array nested, therefore generate covering cases
+                            # and use them to build an array for the current schema
+                            negative = [case.value for case in cover_schema_iter(ctx, schema["items"])]
+                            positive = [case.value for case in cover_schema_iter(ctx.with_positive(), schema["items"])]
+                            # Interleave positive & negative values
+                            array_value = [value for pair in zip(positive, negative) for value in pair][
+                                :NEGATIVE_MODE_MAX_ITEMS
+                            ]
+                        else:
+                            array_value = ctx.generate_from_schema(new_schema)
+
                         # Extend the array to be of length value + 1 by repeating its own elements
                         diff = value + 1 - len(array_value)
-                        if diff > 0:
+                        if diff > 0 and array_value:
                             array_value += (
                                 array_value * (diff // len(array_value)) + array_value[: diff % len(array_value)]
                             )
-                        k = _to_hashable_key(array_value)
-                        if k not in seen:
+                        if seen.insert(array_value):
                             yield NegativeValue(
                                 array_value,
                                 description="Array with more items than allowed by maxItems",
                                 location=ctx.current_path,
                             )
-                            seen.add(k)
                     else:
                         try:
                             # Force the array to have one more item than allowed
                             new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
                             array_value = ctx.generate_from_schema(new_schema)
-                            k = _to_hashable_key(array_value)
-                            if k not in seen:
+                            if seen.insert(array_value):
                                 yield NegativeValue(
                                     array_value,
                                     description="Array with more items than allowed by maxItems",
                                     location=ctx.current_path,
                                 )
-                                seen.add(k)
                         except (InvalidArgument, Unsatisfiable):
                             pass
                 elif key == "minItems" and isinstance(value, int) and value > 0:
@@ -506,14 +519,12 @@ def cover_schema_iter(
                         # Force the array to have one less item than the minimum
                         new_schema = {**schema, "minItems": value - 1, "maxItems": value - 1, "type": "array"}
                         array_value = ctx.generate_from_schema(new_schema)
-                        k = _to_hashable_key(array_value)
-                        if k not in seen:
+                        if seen.insert(array_value):
                             yield NegativeValue(
                                 array_value,
                                 description="Array with fewer items than allowed by minItems",
                                 location=ctx.current_path,
                             )
-                            seen.add(k)
                     except (InvalidArgument, Unsatisfiable):
                         pass
                 elif (
@@ -574,6 +585,22 @@ def _get_template_schema(schema: dict, ty: str) -> dict:
     return {**schema, "type": ty}
 
 
+def _ensure_valid_path_parameter_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    # Path parameters should have at least 1 character length and don't contain any characters with special treatment
+    # on the transport level.
+    # The implementation below sneaks into `not` to avoid clashing with existing `pattern` keyword
+    not_ = schema.get("not", {}).copy()
+    not_["pattern"] = r"[/{}]"
+    return {**schema, "minLength": 1, "not": not_}
+
+
+def _ensure_valid_headers_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    # Reject any character that is not A-Z, a-z, or 0-9 for simplicity
+    not_ = schema.get("not", {}).copy()
+    not_["pattern"] = r"[^A-Za-z0-9]"
+    return {**schema, "not": not_}
+
+
 def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     """Generate positive string values."""
     # Boundary and near boundary values
@@ -581,67 +608,90 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     if min_length == 0:
         min_length = None
     max_length = schema.get("maxLength")
+    if ctx.location == "path":
+        schema = _ensure_valid_path_parameter_schema(schema)
+    elif ctx.location in ("header", "cookie") and not ("format" in schema and schema["format"] in FORMAT_STRATEGIES):
+        # Don't apply it for known formats - they will insure the correct format during generation
+        schema = _ensure_valid_headers_schema(schema)
+
     example = schema.get("example")
     examples = schema.get("examples")
     default = schema.get("default")
+
+    # Two-layer check to avoid potentially expensive data generation using schema constraints as a key
+    seen_values = HashSet()
+    seen_constraints: set[tuple] = set()
+
     if example or examples or default:
-        if example and ctx.is_valid_for_location(example):
+        has_valid_example = False
+        if example and ctx.is_valid_for_location(example) and seen_values.insert(example):
+            has_valid_example = True
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                if ctx.is_valid_for_location(example):
+                if ctx.is_valid_for_location(example) and seen_values.insert(example):
+                    has_valid_example = True
                     yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
             and ctx.is_valid_for_location(default)
+            and seen_values.insert(default)
         ):
+            has_valid_example = True
             yield PositiveValue(default, description="Default value")
-    elif not min_length and not max_length:
-        # Default positive value
-        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
-    elif "pattern" in schema:
-        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
-
-    seen = set()
-
-    if min_length is not None and min_length < BUFFER_SIZE:
+        if not has_valid_example:
+            if not min_length and not max_length or "pattern" in schema:
+                value = ctx.generate_from_schema(schema)
+                seen_values.insert(value)
+                seen_constraints.add((min_length, max_length))
+                yield PositiveValue(value, description="Valid string")
+    elif not min_length and not max_length or "pattern" in schema:
+        value = ctx.generate_from_schema(schema)
+        seen_values.insert(value)
+        seen_constraints.add((min_length, max_length))
+        yield PositiveValue(value, description="Valid string")
+
+    if min_length is not None and min_length < INTERNAL_BUFFER_SIZE:
         # Exactly the minimum length
-        yield PositiveValue(
-            ctx.generate_from_schema({**schema, "maxLength": min_length}), description="Minimum length string"
-        )
-        seen.add(min_length)
+        key = (min_length, min_length)
+        if key not in seen_constraints:
+            seen_constraints.add(key)
+            value = ctx.generate_from_schema({**schema, "maxLength": min_length})
+            if seen_values.insert(value):
+                yield PositiveValue(value, description="Minimum length string")
 
         # One character more than minimum if possible
         larger = min_length + 1
-        if larger < BUFFER_SIZE and larger not in seen and (not max_length or larger <= max_length):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger}),
-                description="Near-boundary length string",
-            )
-            seen.add(larger)
+        key = (larger, larger)
+        if larger < INTERNAL_BUFFER_SIZE and key not in seen_constraints and (not max_length or larger <= max_length):
+            seen_constraints.add(key)
+            value = ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger})
+            if seen_values.insert(value):
+                yield PositiveValue(value, description="Near-boundary length string")
 
     if max_length is not None:
         # Exactly the maximum length
-        if max_length < BUFFER_SIZE and max_length not in seen:
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minLength": max_length}), description="Maximum length string"
-            )
-            seen.add(max_length)
+        key = (max_length, max_length)
+        if max_length < INTERNAL_BUFFER_SIZE and key not in seen_constraints:
+            seen_constraints.add(key)
+            value = ctx.generate_from_schema({**schema, "minLength": max_length, "maxLength": max_length})
+            if seen_values.insert(value):
+                yield PositiveValue(value, description="Maximum length string")
 
         # One character less than maximum if possible
         smaller = max_length - 1
+        key = (smaller, smaller)
         if (
-            smaller < BUFFER_SIZE
-            and smaller not in seen
+            smaller < INTERNAL_BUFFER_SIZE
+            and key not in seen_constraints
             and (smaller > 0 and (min_length is None or smaller >= min_length))
         ):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller}),
-                description="Near-boundary length string",
-            )
-            seen.add(smaller)
+            seen_constraints.add(key)
+            value = ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller})
+            if seen_values.insert(value):
+                yield PositiveValue(value, description="Near-boundary length string")
 
 
 def closest_multiple_greater_than(y: int, x: int) -> int:
@@ -668,23 +718,26 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     examples = schema.get("examples")
     default = schema.get("default")
 
+    seen = HashSet()
+
     if example or examples or default:
-        if example:
+        if example and seen.insert(example):
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example, description="Example value")
+                if seen.insert(example):
+                    yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
+            and seen.insert(default)
         ):
             yield PositiveValue(default, description="Default value")
     elif not minimum and not maximum:
-        # Default positive value
-        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid number")
-
-    seen = set()
+        value = ctx.generate_from_schema(schema)
+        seen.insert(value)
+        yield PositiveValue(value, description="Valid number")
 
     if minimum is not None:
         # Exactly the minimum
@@ -692,16 +745,15 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             smallest = closest_multiple_greater_than(minimum, multiple_of)
         else:
             smallest = minimum
-        seen.add(smallest)
-        yield PositiveValue(smallest, description="Minimum value")
+        if seen.insert(smallest):
+            yield PositiveValue(smallest, description="Minimum value")
 
         # One more than minimum if possible
         if multiple_of is not None:
             larger = smallest + multiple_of
         else:
             larger = minimum + 1
-        if larger not in seen and (not maximum or larger <= maximum):
-            seen.add(larger)
+        if (not maximum or larger <= maximum) and seen.insert(larger):
             yield PositiveValue(larger, description="Near-boundary number")
 
     if maximum is not None:
@@ -710,8 +762,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             largest = maximum - (maximum % multiple_of)
         else:
             largest = maximum
-        if largest not in seen:
-            seen.add(largest)
+        if seen.insert(largest):
             yield PositiveValue(largest, description="Maximum value")
 
         # One less than maximum if possible
@@ -719,71 +770,65 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             smaller = largest - multiple_of
         else:
             smaller = maximum - 1
-        if smaller not in seen and (smaller > 0 and (minimum is None or smaller >= minimum)):
-            seen.add(smaller)
+        if (smaller > 0 and (minimum is None or smaller >= minimum)) and seen.insert(smaller):
             yield PositiveValue(smaller, description="Near-boundary number")
 
 
 def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator[GeneratedValue, None, None]:
-    seen = set()
     example = schema.get("example")
     examples = schema.get("examples")
     default = schema.get("default")
 
+    seen = HashSet()
+    seen_constraints: set[tuple] = set()
+
     if example or examples or default:
-        if example:
-            seen.add(_to_hashable_key(example))
+        if example and seen.insert(example):
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                seen.add(_to_hashable_key(example))
-                yield PositiveValue(example, description="Example value")
+                if seen.insert(example):
+                    yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
+            and seen.insert(default)
         ):
-            seen.add(_to_hashable_key(default))
             yield PositiveValue(default, description="Default value")
-    else:
+    elif seen.insert(template):
         yield PositiveValue(template, description="Valid array")
-    seen.add(_to_hashable_key(template))
 
     # Boundary and near-boundary sizes
     min_items = schema.get("minItems")
     max_items = schema.get("maxItems")
     if min_items is not None:
         # Do not generate an array with `minItems` length, because it is already covered by `template`
-
         # One item more than minimum if possible
         larger = min_items + 1
-        if larger not in seen and (max_items is None or larger <= max_items):
+        if (max_items is None or larger <= max_items) and larger not in seen_constraints:
+            seen_constraints.add(larger)
             value = ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
-            key = _to_hashable_key(value)
-            if key not in seen:
-                seen.add(key)
+            if seen.insert(value):
                 yield PositiveValue(value, description="Near-boundary items array")
 
     if max_items is not None:
-        if max_items < BUFFER_SIZE and max_items not in seen:
+        if max_items < INTERNAL_BUFFER_SIZE and max_items not in seen_constraints:
+            seen_constraints.add(max_items)
             value = ctx.generate_from_schema({**schema, "minItems": max_items})
-            key = _to_hashable_key(value)
-            if key not in seen:
-                seen.add(key)
+            if seen.insert(value):
                 yield PositiveValue(value, description="Maximum items array")
 
         # One item smaller than maximum if possible
         smaller = max_items - 1
         if (
-            smaller < BUFFER_SIZE
+            smaller < INTERNAL_BUFFER_SIZE
             and smaller > 0
-            and smaller not in seen
             and (min_items is None or smaller >= min_items)
+            and smaller not in seen_constraints
         ):
             value = ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
-            key = _to_hashable_key(value)
-            if key not in seen:
-                seen.add(key)
+            if seen.insert(value):
                 yield PositiveValue(value, description="Near-boundary items array")
 
     if "items" in schema and "enum" in schema["items"] and isinstance(schema["items"]["enum"], list) and max_items != 0:
@@ -791,9 +836,7 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
         length = min_items or 1
         for variant in schema["items"]["enum"]:
             value = [variant] * length
-            key = _to_hashable_key(value)
-            if key not in seen:
-                seen.add(key)
+            if seen.insert(value):
                 yield PositiveValue(value, description="Enum value from available for items array")
     elif min_items is None and max_items is None and "items" in schema and isinstance(schema["items"], dict):
         # Otherwise only an empty array is generated
@@ -840,16 +883,14 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
     if set(properties) != required:
         only_required = {k: v for k, v in template.items() if k in required}
         yield PositiveValue(only_required, description="Object with only required properties")
-    seen = set()
+    seen = HashSet()
     for name, sub_schema in properties.items():
-        seen.add(_to_hashable_key(template.get(name)))
+        seen.insert(template.get(name))
         for new in cover_schema_iter(ctx, sub_schema):
-            key = _to_hashable_key(new.value)
-            if key not in seen:
+            if seen.insert(new.value):
                 yield PositiveValue(
                     {**template, name: new.value}, description=f"Object with valid '{name}' value: {new.description}"
                 )
-                seen.add(key)
         seen.clear()
 
 
@@ -858,14 +899,11 @@ def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
         yield next(combinations(optional, size))
 
 
-def _negative_enum(
-    ctx: CoverageContext, value: list, seen: set[Any | tuple[type, str]]
-) -> Generator[GeneratedValue, None, None]:
+def _negative_enum(ctx: CoverageContext, value: list, seen: HashSet) -> Generator[GeneratedValue, None, None]:
     def is_not_in_value(x: Any) -> bool:
         if x in value or not ctx.is_valid_for_location(x):
             return False
-        _hashed = _to_hashable_key(x)
-        return _hashed not in seen
+        return seen.insert(x)
 
     strategy = (
         st.text(alphabet=st.characters(min_codepoint=65, max_codepoint=122, categories=["L"]), min_size=3)
@@ -873,10 +911,11 @@ def _negative_enum(
         | st.booleans()
         | NUMERIC_STRATEGY
     ).filter(is_not_in_value)
-    value = ctx.generate_from(strategy)
-    yield NegativeValue(value, description="Invalid enum value", location=ctx.current_path)
-    hashed = _to_hashable_key(value)
-    seen.add(hashed)
+    yield NegativeValue(
+        ctx.generate_from(strategy),
+        description="Invalid enum value",
+        location=ctx.current_path,
+    )
 
 
 def _negative_properties(
@@ -1005,7 +1044,11 @@ def _is_non_integer_float(x: float) -> bool:
     return x != int(x)
 
 
-def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
+def _negative_type(
+    ctx: CoverageContext,
+    ty: str | list[str],
+    seen: HashSet,
+) -> Generator[GeneratedValue, None, None]:
     if isinstance(ty, str):
         types = [ty]
     else:
@@ -1017,11 +1060,8 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
     for strategy in strategies.values():
         value = ctx.generate_from(strategy)
-        hashed = _to_hashable_key(value)
-        if hashed in seen:
-            continue
-        yield NegativeValue(value, description="Incorrect type", location=ctx.current_path)
-        seen.add(hashed)
+        if seen.insert(value):
+            yield NegativeValue(value, description="Incorrect type", location=ctx.current_path)
 
 
 def push_examples_to_properties(schema: dict[str, Any]) -> None: