derivepassphrase.git

@@ -31,16 +31,27 @@ startup_ssh_auth_sock = os.environ.get("SSH_AUTH_SOCK", None)

 def pytest_configure(config: pytest.Config) -> None:

-    """Configure `pytest`: add the `heavy_duty` marker."""

+    """Configure `pytest`: add custom markers."""

     config.addinivalue_line(

         "markers",

         (

             "heavy_duty: "

-            "mark test as a slow, heavy-duty test (e.g., an integration test)"

-            "\n"

+            "mark test as a slow, heavy-duty test"

+        )

+    )

+    config.addinivalue_line(

+        "markers",

+        (

+            "correctness_focused: "

+            "mark test as a potentially slow, correctness-focused test"

+        )

+    )

+    config.addinivalue_line(

+        "markers",

+        (

             "non_reentrant_agent: "

             "mark the agent (fixture output) as non-reentrant"

-        ),

+        )

     )

     hypothesis_machinery._hypothesis_settings_setup()

@@ -17,7 +17,6 @@ All similar-minded code requiring only plain `pytest` lives in [the

 from __future__ import annotations

 import copy

-import datetime

 import importlib

 import importlib.util

 import math

@@ -94,36 +93,45 @@ def _hypothesis_settings_setup() -> None:

             and isinstance(trace_func.__self__, pytracer_class)

         ):

             slowdown = 8.0

-    settings = hypothesis.settings(

+    hypothesis.settings.register_profile(

+        "default",

+        parent=settings,

         deadline=slowdown * settings.deadline

-        if slowdown

+        if slowdown and settings.deadline is not None

         else settings.deadline,

         stateful_step_count=32,

-        suppress_health_check=(hypothesis.HealthCheck.too_slow,),

+        suppress_health_check=[hypothesis.HealthCheck.too_slow],

     )

-    hypothesis.settings.register_profile("default", settings)

+    default_profile = hypothesis.settings.get_profile("default")

     hypothesis.settings.register_profile(

-        "dev", derandomize=True, max_examples=10

+        "regression",

+        parent=hypothesis.settings.get_profile("ci"),

+        derandomize=True,

+        database=None,

+        max_examples=3,

+        stateful_step_count=3,

+        suppress_health_check=[hypothesis.HealthCheck.too_slow],

+        phases=[

+            hypothesis.Phase.explicit,

+            hypothesis.Phase.reuse,

+            hypothesis.Phase.generate,

+        ],

     )

     hypothesis.settings.register_profile(

         "debug",

-        parent=hypothesis.settings.get_profile("dev"),

+        parent=default_profile,

         verbosity=hypothesis.Verbosity.verbose,

     )

     hypothesis.settings.register_profile(

-        "flaky",

-        deadline=(

-            settings.deadline - settings.deadline // 4

-            if settings.deadline is not None

-            else datetime.timedelta(milliseconds=150)

-        ),

+        "debug-regression",

+        parent=hypothesis.settings.get_profile("regression"),

+        verbosity=hypothesis.Verbosity.verbose,

     )

-    ci_profile = hypothesis.settings.get_profile("ci")

     hypothesis.settings.register_profile(

-        "intense",

-        parent=ci_profile,

+        "correctness",

+        parent=default_profile,

         derandomize=False,

-        max_examples=10 * ci_profile.max_examples,

+        max_examples=10 * default_profile.max_examples,

     )

@@ -161,13 +169,13 @@ def get_process_spawning_state_machine_examples_count(

     examples count by default, and require the user to opt-in to the

     original naive example count explicitly.

-    If the "intense" profile is in effect, or something with even higher

-    `max_examples` and `stateful_step_count`, then we return the

+    If the "correctness" profile is in effect, or something with even

+    higher `max_examples` and `stateful_step_count`, then we return the

     unaltered example count for the *default* profile.  Otherwise, we

     return the square root of the `max_examples` setting (rounded down).

-    We *never* return a value below the "dev" profile's example count:

-    any lower computed example count is increased to the "dev" profile's

-    example count.

+    We *never* return a value below the "regression" profile's example

+    count: any lower computed example count is increased to the

+    "regression" profile's example count.

     Args:

         settings:

@@ -182,20 +190,22 @@ def get_process_spawning_state_machine_examples_count(

     _hypothesis_settings_setup()

     these_values = (settings.max_examples, settings.stateful_step_count)

-    intense_profile = hypothesis.settings.get_profile("intense")

-    intense_values = (

-        intense_profile.max_examples,

-        intense_profile.stateful_step_count,

+    correctness_profile = hypothesis.settings.get_profile("correctness")

+    correctness_values = (

+        correctness_profile.max_examples,

+        correctness_profile.stateful_step_count,

     )

-    min_count = hypothesis.settings.get_profile("dev").max_examples

+    min_count = hypothesis.settings.get_profile("regression").max_examples

     high_count = hypothesis.settings.get_profile("default").max_examples

-    we_are_intense = (

-        these_values[0] >= intense_values[0]

-        and these_values[1] >= intense_values[1]

+    correctness_based_testing = (

+        these_values[0] >= correctness_values[0]

+        and these_values[1] >= correctness_values[1]

     )

     return max(

         min_count,

-        high_count if we_are_intense else math.isqrt(settings.max_examples),

+        high_count

+        if correctness_based_testing

+        else math.isqrt(settings.max_examples),

     )

@@ -143,19 +143,30 @@ def xfail_on_the_annoying_os(

 heavy_duty = pytest.mark.heavy_duty

 """

-A cached `pytest` mark indicating that this test function/class/module

-is a slow, heavy duty test.  Users who are impatient (or otherwise

-cannot afford to wait for these tests to complete) may wish to exclude

-these tests; this mark helps in achieving that.

+Test functions/classes/modules with this `pytest` mark are slow, heavy

+duty tests.  Users who are impatient (or otherwise cannot afford to wait

+for these tests to complete) may wish to exclude these tests; this mark

+helps in achieving that.

+"""

-All current heavy duty tests are integration tests.

+correctness_focused = pytest.mark.correctness_focused

 """

+Test functions/classes/modules with this `pytest` mark are designed

+primarily to verify correctness and to find novel failure cases, even at

+the cost of high CPU or wall clock time.

+

+Contrast this with tests designed primarily to verify that the existing

+system still behaves as before in all the important ways ("is healthy")

+even after introducing a small change, but before committing it.  (See

+[Two kinds of testing][TWO_KINDS] for more elaboration.)

+[TWO_KINDS]: https://blog.nelhage.com/post/two-kinds-of-testing/

+"""

 non_isolated_agent_use = pytest.mark.xdist_group("non_isolated_agent_use")

 """

-A cached `pytest` mark, for use with xdist's "loadgroup" scheduling,

-that marks a test as part of the group of tests that use a potentially

+Tests with this `pytest` mark (for use with xdist's "loadgroup"

+scheduling), comprise the group of tests that use a potentially

 non-isolated agent, and thus need to be run serially, in the same worker

 (because of the setup and teardown).

@@ -1245,7 +1245,9 @@ class TestTempdir:

             ),

         ),

     )

-    @hypothesis.example(env_var="", suffix=".")

+    @hypothesis.example(env_var="", suffix=".").via(

+        "static example; branch coverage (test)"

+    )

     def test_get_tempdir(

         self,

         env_var: str,

@@ -141,6 +141,9 @@ class TestNotesPrinting:

     @Parametrize.NOTES_PLACEMENT

     @hypothesis.given(notes=Strategies.notes().filter(str.strip))

+    @hypothesis.example(notes="  ").xfail(

+        reason="empty notes", raises=AssertionError

+    )

     def test_notes_placement(

         self,

         notes_placement: Literal["before", "after"],

@@ -347,11 +350,15 @@ class TestNotesEditingValid(TestNotesEditing):

         ],

     )

     @hypothesis.given(

-        notes=Strategies.notes()

+        notes=Strategies

+        .notes()

         .filter(str.strip)

         .filter(lambda notes: notes != TestNotesEditingValid.CURRENT_NOTES)

     )

     @hypothesis.example(TestNotesEditing.CURRENT_NOTES)

+    @hypothesis.example(notes="  ").xfail(

+        reason="empty notes", raises=AssertionError

+    )

     def test_successful_edit(

         self,

         caplog: pytest.LogCaptureFixture,

@@ -463,6 +470,9 @@ class TestNotesEditingValid(TestNotesEditing):

         ],

     )

     @hypothesis.given(notes=Strategies.notes().filter(str.strip))

+    @hypothesis.example(notes="  ").xfail(

+        reason="empty notes", raises=AssertionError

+    )

     def test_marker_removed(

         self,

         caplog: pytest.LogCaptureFixture,

@@ -509,7 +519,7 @@ class TestNotesEditingInvalid(TestNotesEditing):

     """Tests concerning editing service notes: invalid/error calls."""

     @hypothesis.given(notes=Strategies.notes())

-    @hypothesis.example("")

+    @hypothesis.example(notes="")

     def test_abort(

         self,

         notes: str,

@@ -548,7 +558,7 @@ class TestNotesEditingInvalid(TestNotesEditing):

         ],

     )

     @hypothesis.given(notes=Strategies.notes())

-    @hypothesis.example("")

+    @hypothesis.example(notes="")

     def test_fail_on_config_option_missing(

         self,

         caplog: pytest.LogCaptureFixture,

@@ -391,6 +391,7 @@ class TestStoreroom:

                 == data.VAULT_STOREROOM_CONFIG_DATA

             )

+    @pytest_machinery.correctness_focused

     def test_decrypt_bucket_item_unknown_version(self) -> None:

         """Fail on unknown versions of the master keys file."""

         bucket_item = (

@@ -404,6 +405,7 @@ class TestStoreroom:

         with pytest.raises(ValueError, match="Cannot handle version 255"):

             storeroom._decrypt_bucket_item(bucket_item, master_keys)

+    @pytest_machinery.correctness_focused

     @Parametrize.BAD_CONFIG

     def test_decrypt_bucket_file_bad_json_or_version(

         self,

@@ -427,6 +429,7 @@ class TestStoreroom:

             with pytest.raises(ValueError, match="Invalid bucket file: "):

                 list(storeroom._decrypt_bucket_file(p, master_keys))

+    @pytest_machinery.correctness_focused

     @Parametrize.BAD_MASTER_KEYS_DATA

     @Parametrize.STOREROOM_HANDLER

     def test_export_storeroom_data_bad_master_keys_file(

@@ -447,6 +450,7 @@ class TestStoreroom:

             with pytest.raises(RuntimeError, match=err_msg):

                 handler(format="storeroom")

+    @pytest_machinery.correctness_focused

     @Parametrize.BAD_STOREROOM_CONFIG_DATA

     @Parametrize.STOREROOM_HANDLER

     def test_export_storeroom_data_bad_directory_listing(

@@ -476,6 +480,7 @@ class TestStoreroom:

             with pytest.raises(RuntimeError, match=error_text):

                 handler(format="storeroom")

+    @pytest_machinery.correctness_focused

     def test_decrypt_keys_wrong_data_length(self) -> None:

         """Fail on internal structural data of the wrong size.

@@ -527,6 +532,7 @@ class TestStoreroom:

                 ),

             )

+    @pytest_machinery.correctness_focused

     @hypothesis.given(

         data=strategies.binary(

             min_size=storeroom.MAC_SIZE, max_size=storeroom.MAC_SIZE

@@ -193,66 +193,86 @@ class TestCLIUtilities:

             )

             yield monkeypatch

+    @hypothesis.given(

+        vault_key_env=VaultKeyEnvironment.strategy().filter(

+            lambda env: bool(env.expected)

+        ),

+    )

+    # BEGIN pre-hypothesis parametrization examples

     @hypothesis.example(

-        VaultKeyEnvironment("4username", None, None, None, "4username")

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "4username", None, None, None, "4username"

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("3user", None, None, "3user", None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment("3user", None, None, "3user", None)

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("3user", None, None, "3user", "4username")

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "3user", None, None, "3user", "4username"

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("2logname", None, "2logname", None, None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "2logname", None, "2logname", None, None

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("2logname", None, "2logname", None, "4username")

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "2logname", None, "2logname", None, "4username"

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("2logname", None, "2logname", "3user", None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "2logname", None, "2logname", "3user", None

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("2logname", None, "2logname", "3user", "4username")

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "2logname", None, "2logname", "3user", "4username"

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("1vault_key", "1vault_key", None, None, None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "1vault_key", "1vault_key", None, None, None

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment(

+        vault_key_env=VaultKeyEnvironment(

             "1vault_key", "1vault_key", None, None, "4username"

         )

-    ).via("manual, pre-hypothesis parametrization value")

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("1vault_key", "1vault_key", None, "3user", None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "1vault_key", "1vault_key", None, "3user", None

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment(

+        vault_key_env=VaultKeyEnvironment(

             "1vault_key", "1vault_key", None, "3user", "4username"

         )

-    ).via("manual, pre-hypothesis parametrization value")

+    )

     @hypothesis.example(

-        VaultKeyEnvironment("1vault_key", "1vault_key", "2logname", None, None)

-    ).via("manual, pre-hypothesis parametrization value")

+        vault_key_env=VaultKeyEnvironment(

+            "1vault_key", "1vault_key", "2logname", None, None

+        )

+    )

     @hypothesis.example(

-        VaultKeyEnvironment(

+        vault_key_env=VaultKeyEnvironment(

             "1vault_key", "1vault_key", "2logname", None, "4username"

         )

-    ).via("manual, pre-hypothesis parametrization value")

+    )

     @hypothesis.example(

-        VaultKeyEnvironment(

+        vault_key_env=VaultKeyEnvironment(

             "1vault_key", "1vault_key", "2logname", "3user", None

         )

-    ).via("manual, pre-hypothesis parametrization value")

+    )

     @hypothesis.example(

-        VaultKeyEnvironment(

+        vault_key_env=VaultKeyEnvironment(

             "1vault_key", "1vault_key", "2logname", "3user", "4username"

         )

-    ).via("manual, pre-hypothesis parametrization value")

-    @hypothesis.given(

-        vault_key_env=VaultKeyEnvironment.strategy().filter(

-            lambda env: bool(env.expected)

-        ),

     )

+    # END pre-hypothesis parametrization examples

     def test_get_vault_key(

         self,

         vault_key_env: VaultKeyEnvironment,

@@ -164,21 +164,24 @@ class TestStaticFunctionality:

             )

     @hypothesis.given(test_case=BigEndianNumberTest.strategy())

+    # decimal example

     @hypothesis.example(

-        BigEndianNumberTest([1, 2, 3, 4, 5, 6], 10, 123456)

-    ).via("manual decimal example")

+        test_case=BigEndianNumberTest([1, 2, 3, 4, 5, 6], 10, 123456)

+    )

+    # decimal example, different base

+    @hypothesis.example(

+        test_case=BigEndianNumberTest([1, 2, 3, 4, 5, 6], 100, 10203040506)

+    )

+    # leading zeroes example

     @hypothesis.example(

-        BigEndianNumberTest([1, 2, 3, 4, 5, 6], 100, 10203040506)

-    ).via("manual decimal example in different base")

-    @hypothesis.example(BigEndianNumberTest([0, 0, 1, 4, 9, 7], 10, 1497)).via(

-        "manual example with leading zeroes"

+        test_case=BigEndianNumberTest([0, 0, 1, 4, 9, 7], 10, 1497)

     )

+    # binary example

     @hypothesis.example(

-        BigEndianNumberTest([1, 0, 0, 1, 0, 0, 0, 0], 2, 144)

-    ).via("manual binary example")

-    @hypothesis.example(BigEndianNumberTest([1, 7, 5, 5], 8, 0o1755)).via(

-        "manual octal example"

+        test_case=BigEndianNumberTest([1, 0, 0, 1, 0, 0, 0, 0], 2, 144)

     )

+    # octal example

+    @hypothesis.example(test_case=BigEndianNumberTest([1, 7, 5, 5], 8, 0o1755))

     def test_big_endian_number(self, test_case: BigEndianNumberTest) -> None:

         """Conversion to big endian numbers in any base works.

@@ -294,22 +297,28 @@ class TestSequin:

             )

     @hypothesis.given(test_case=ConstructorTestCase.strategy())

+    # bitstring example

     @hypothesis.example(

-        ConstructorTestCase([1, 0, 0, 1, 0, 1], True, [1, 0, 0, 1, 0, 1])

-    ).via("manual example bitstring")

+        test_case=ConstructorTestCase(

+            [1, 0, 0, 1, 0, 1], True, [1, 0, 0, 1, 0, 1]

+        )

+    )

+    # bitstring as bytestring example

     @hypothesis.example(

-        ConstructorTestCase(

+        test_case=ConstructorTestCase(

             [1, 0, 0, 1, 0, 1],

             False,

             bitseq("000000010000000000000000000000010000000000000001"),

         )

-    ).via("manual example bitstring as byte string")

+    )

+    # true byte string example

     @hypothesis.example(

-        ConstructorTestCase(b"OK", False, bitseq("0100111101001011"))

-    ).via("manual example true byte string")

+        test_case=ConstructorTestCase(b"OK", False, bitseq("0100111101001011"))

+    )

+    # latin1 text example

     @hypothesis.example(

-        ConstructorTestCase("OK", False, bitseq("0100111101001011"))

-    ).via("manual example latin1 text")

+        test_case=ConstructorTestCase("OK", False, bitseq("0100111101001011"))

+    )

     def test_constructor(

         self,

         test_case: ConstructorTestCase,

@@ -355,8 +364,9 @@ class TestSequin:

                 ],

             )

+    @hypothesis.given(sequence=GenerationSequence.strategy())

     @hypothesis.example(

-        GenerationSequence(

+        sequence=GenerationSequence(

             bitseq("110101011111001"),

             [

                 (1, 0),

@@ -367,8 +377,7 @@ class TestSequin:

                 (1, sequin.SequinExhaustedError),

             ],

         )

-    ).via("manual, pre-hypothesis parametrization value")

-    @hypothesis.given(sequence=GenerationSequence.strategy())

+    )

     def test_generating(self, sequence: GenerationSequence) -> None:

         """The sequin generates deterministic sequences."""

         seq = sequin.Sequin(sequence.bit_sequence, is_bitstring=True)

@@ -396,8 +405,9 @@ class TestSequin:

         with pytest.raises(ValueError, match="invalid target range"):

             seq.generate(0)

+    @hypothesis.given(sequence=GenerationSequence.strategy())

     @hypothesis.example(

-        GenerationSequence(

+        sequence=GenerationSequence(

             bitseq("110101011111001"),

             [

                 (1, 0),

@@ -408,8 +418,7 @@ class TestSequin:

                 (1, sequin.SequinExhaustedError),

             ],

         )

-    ).via("manual, pre-hypothesis parametrization value")

-    @hypothesis.given(sequence=GenerationSequence.strategy())

+    )

     def test_internal_generating(self, sequence: GenerationSequence) -> None:

         """The sequin internals generate deterministic sequences."""

         seq = sequin.Sequin(sequence.bit_sequence, is_bitstring=True)

@@ -495,7 +504,7 @@ class TestSequin:

     @hypothesis.given(sequence=ShiftSequence.strategy())

     @hypothesis.example(

-        ShiftSequence(

+        sequence=ShiftSequence(

             bitseq("1010010001"),

             [

                 (3, bitseq("101"), bitseq("0010001")),

@@ -533,17 +533,17 @@ class TestSSHProtocolDatatypes(TestStaticFunctionality):

         uint32 = ssh_agent.SSHAgentClient.uint32

         assert uint32(input) == expected

-    @hypothesis.given(strategies.integers(min_value=0, max_value=0xFFFFFFFF))

-    @hypothesis.example(0xDEADBEEF).via("manual, pre-hypothesis example")

+    @hypothesis.given(

+        num=strategies.integers(min_value=0, max_value=0xFFFFFFFF)

+    )

+    @hypothesis.example(num=0xDEADBEEF)

     def test_uint32_from_number(self, num: int) -> None:

         """`uint32` encoding works, starting from numbers."""

         uint32 = ssh_agent.SSHAgentClient.uint32

         assert int.from_bytes(uint32(num), "big", signed=False) == num

-    @hypothesis.given(strategies.binary(min_size=4, max_size=4))

-    @hypothesis.example(b"\xde\xad\xbe\xef").via(

-        "manual, pre-hypothesis example"

-    )

+    @hypothesis.given(bytestring=strategies.binary(min_size=4, max_size=4))

+    @hypothesis.example(bytestring=b"\xde\xad\xbe\xef")

     def test_uint32_from_bytestring(self, bytestring: bytes) -> None:

         """`uint32` encoding works, starting from length four byte strings."""

         uint32 = ssh_agent.SSHAgentClient.uint32

@@ -560,10 +560,9 @@ class TestSSHProtocolDatatypes(TestStaticFunctionality):

         string = ssh_agent.SSHAgentClient.string

         assert bytes(string(input)) == expected

-    @hypothesis.given(strategies.binary(max_size=0x0001FFFF))

-    @hypothesis.example(b"DEADBEEF" * 10000).via(

-        "manual, pre-hypothesis example with highest order bit set"

-    )

+    @hypothesis.given(bytestring=strategies.binary(max_size=0x0001FFFF))

+    # example with highest order bit set

+    @hypothesis.example(bytestring=b"DEADBEEF" * 10000)

     def test_string_from_bytestring(self, bytestring: bytes) -> None:

         """SSH string encoding works, starting from a byte string."""

         res = ssh_agent.SSHAgentClient.string(bytestring)

@@ -584,13 +583,11 @@ class TestSSHProtocolDatatypes(TestStaticFunctionality):

             b"",

         )

-    @hypothesis.given(strategies.binary(max_size=0x00FFFFFF))

-    @hypothesis.example(b"\x00\x00\x00\x07ssh-rsa").via(

-        "manual, pre-hypothesis example to attempt to detect double-decoding"

-    )

-    @hypothesis.example(b"\x00\x00\x00\x01").via(

-        "detect no-op encoding via ill-formed SSH string"

-    )

+    @hypothesis.given(bytestring=strategies.binary(max_size=0x00FFFFFF))

+    # should not double-decode

+    @hypothesis.example(bytestring=b"\x00\x00\x00\x07ssh-rsa")

+    # should not choke on ill-formed SSH string payloads

+    @hypothesis.example(bytestring=b"\x00\x00\x00\x01")

     def test_unstring_of_string_of_data(self, bytestring: bytes) -> None:

         """SSH string decoding of encoded SSH strings works.

@@ -612,7 +609,7 @@ class TestSSHProtocolDatatypes(TestStaticFunctionality):

         assert unstring_prefix(encoded2) == (bytestring, trailing_data)

     @hypothesis.given(

-        strategies.binary(max_size=0x00FFFFFF).map(

+        encoded=strategies.binary(max_size=0x00FFFFFF).map(

             # Scoping issues, and the fact that staticmethod objects

             # (before class finalization) are not callable, necessitate

             # wrapping this staticmethod call in a lambda.

@@ -70,9 +70,7 @@ def js_nested_strategy(draw: strategies.DrawFn) -> Any:

 @hypothesis.given(value=js_nested_strategy())

-@hypothesis.example(float("nan")).via(

-    "for branch coverage in the implementation"

-)

+@hypothesis.example(value=float("nan")).via("branch coverage (implementation)")

 def test_js_truthiness(value: Any) -> None:

     """Determine the truthiness of a value according to JavaScript.

@@ -303,8 +303,7 @@ class TestPhraseDependence:

         service=Strategies.text_strategy(),

     )

     @hypothesis.example(phrases=[b"\x00", b"\x00\x00"], service="0").xfail(

-        reason="phrases are interchangable",

-        raises=AssertionError,

+        reason="phrases are interchangable", raises=AssertionError

     )

     def test_small(self, phrases: Sequence[bytes], service: str) -> None:

         """The internal hash is dependent on the master passphrase.

@@ -320,6 +319,10 @@ class TestPhraseDependence:

         ),

         service=Strategies.text_strategy(),

     )

+    @hypothesis.example(

+        phrases=[b"\x01" * DIGEST_SIZE, b"\x01" * DIGEST_SIZE],

+        service="service",

+    ).xfail(reason="phrases are interchangable", raises=AssertionError)

     def test_medium(self, phrases: Sequence[bytes], service: str) -> None:

         """The internal hash is dependent on the master passphrase.

@@ -172,14 +172,14 @@ class TestDebugTranslations:

         assert not suffix or suffix.startswith("(")

     @hypothesis.given(value=Strategies.printable_strings())

-    @hypothesis.example("{")

+    @hypothesis.example(value="{")

     def test_get_str(self, value: str) -> None:

         """Translating a raw string object does nothing."""

         translated = msg.translation.gettext(value)

         assert translated == value

     @hypothesis.given(value=Strategies.printable_strings())

-    @hypothesis.example("{")

+    @hypothesis.example(value="{")

     def test_get_ts_str(self, value: str) -> None:

         """Translating a constant TranslatableString does nothing."""

         translated = msg.TranslatedString.constant(value)