approval-utilities 15.3.2.dev3__tar.gz → 15.3.2.dev5__tar.gz

{approval_utilities-15.3.2.dev3 → approval_utilities-15.3.2.dev5}/PKG-INFO

@@ -1,13 +1,10 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.4
 Name: approval_utilities
-Version: 15.3.2.dev3
+Version: 15.3.2.dev5
 Summary: Utilities for your production code that work well with approvaltests
 Home-page: https://github.com/approvals/ApprovalTests.Python
 Author: ApprovalTests Contributors
 Author-email: llewellyn.falco@gmail.com
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -23,3 +20,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Requires-Python: >=3.8
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

{approval_utilities-15.3.2.dev3 → approval_utilities-15.3.2.dev5}/approval_utilities.egg-info/PKG-INFO

@@ -1,13 +1,10 @@
-Metadata-Version: 1.2
-Name: approval-utilities
-Version: 15.3.2.dev3
+Metadata-Version: 2.4
+Name: approval_utilities
+Version: 15.3.2.dev5
 Summary: Utilities for your production code that work well with approvaltests
 Home-page: https://github.com/approvals/ApprovalTests.Python
 Author: ApprovalTests Contributors
 Author-email: llewellyn.falco@gmail.com
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -23,3 +20,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Requires-Python: >=3.8
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

{approval_utilities-15.3.2.dev3 → approval_utilities-15.3.2.dev5}/approval_utilities.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ requirements.prod.txt
 version.py
 approval_utilities/__init__.py
 approval_utilities/list_utils.py
+approval_utilities/py.typed
 approval_utilities/utils.py
 approval_utilities.egg-info/PKG-INFO
 approval_utilities.egg-info/SOURCES.txt
@@ -38,4 +39,30 @@ approval_utilities/utilities/logger/simple_logger.py
 approval_utilities/utilities/persistence/__init__.py
 approval_utilities/utilities/persistence/loader.py
 approval_utilities/utilities/persistence/saver.py
-setup/setup_utils.py
+setup/setup_utils.py
+tests/test_approvaltests_temp_dir.py
+tests/test_asserts.py
+tests/test_build.py
+tests/test_combinations.py
+tests/test_compare_file_lists.py
+tests/test_custom_printers.py
+tests/test_example_numpy.py
+tests/test_exception_utils.py
+tests/test_fileapprover.py
+tests/test_find_stale_approved_files.py
+tests/test_inline_approvals.py
+tests/test_list.py
+tests/test_multiline_string_utils.py
+tests/test_namer.py
+tests/test_options.py
+tests/test_pairwise_combinations.py
+tests/test_parse_inputs.py
+tests/test_python_patterns.py
+tests/test_scenarios.py
+tests/test_simple_logger.py
+tests/test_split_code.py
+tests/test_verify.py
+tests/test_verify_all.py
+tests/test_verify_argument_parser.py
+tests/test_workflow_matrix.py
+tests/test_writer.py

approval_utilities-15.3.2.dev5/tests/test_approvaltests_temp_dir.py

@@ -0,0 +1,8 @@
+from approvaltests.internals.logs.log_commons import APPROVAL_TESTS_TEMP_DIRECTORY
+
+
+def test_temp_directory_is_setup_automatically() -> None:
+    # setup happens automatically
+    gitignore_path = APPROVAL_TESTS_TEMP_DIRECTORY / ".gitignore"
+    contents = gitignore_path.read_text()
+    assert contents == "*"

approval_utilities-15.3.2.dev5/tests/test_asserts.py

@@ -0,0 +1,68 @@
+import unittest
+from pathlib import Path
+from typing import Optional
+
+from typing_extensions import override
+
+from approval_utilities.utils import get_adjacent_file
+from approvaltests import Options, assert_against_file, assert_equal_with_reporter
+from approvaltests.approval_exception import ApprovalException
+from approvaltests.core import Reporter
+from approvaltests.reporters.testing_reporter import ReporterForTesting
+from approvaltests.scrubbers import scrub_all_guids
+
+
+class TestAssertEqualWithReporter(unittest.TestCase):
+    def test_assert_with_scrubbing_and_options(self) -> None:
+        actuals = "2fd78d4a-ad49-447d-96a8-deda585a9aa5 and text"
+        expected = "<guid_0> and text"
+        assert_equal_with_reporter(
+            expected,
+            actuals,
+            options=Options()
+            .with_scrubber(scrub_all_guids)
+            .for_file.with_extension(".md"),
+        )
+
+    def test_text_reporter_called_on_failure(self) -> None:
+        class LocalReporter(Reporter):
+            def __init__(self) -> None:
+                self.received: Optional[str] = None
+                self.approved: Optional[str] = None
+                self.extention: Optional[str] = None
+
+            @override
+            def report(self, received_path: str, approved_path: str) -> bool:
+                self.received = Path(received_path).read_text(encoding="utf-8-sig")
+                self.approved = Path(approved_path).read_text(encoding="utf-8-sig")
+                self.extention = Path(received_path).suffix
+
+        reporter = LocalReporter()
+        try:
+            assert_equal_with_reporter(
+                "expected",
+                "actual",
+                options=Options()
+                .with_reporter(reporter)
+                .for_file.with_extension(".md"),
+            )
+        except AssertionError:
+            pass
+        self.assertEqual(reporter.received, "actual")
+        self.assertEqual(reporter.approved, "expected")
+        self.assertEqual(reporter.extention, ".md")
+
+
+class TestAsserts(unittest.TestCase):
+    def test_assert_against_file_works(self) -> None:
+        file_path = get_adjacent_file("manual_file.approved.txt")
+        assert_against_file("This text is in a file\n", file_path)
+
+    def test_assert_against_file_fails_with_reporter(self) -> None:
+        reporter = ReporterForTesting()
+        file_path = get_adjacent_file("manual_file.approved.txt")
+        try:
+            assert_against_file("This text is NOT in a file", file_path, reporter)
+        except ApprovalException:
+            pass
+        self.assertTrue(reporter.called)

approval_utilities-15.3.2.dev5/tests/test_build.py

@@ -0,0 +1,33 @@
+import ast
+import os
+
+
+def test_no_imports_from_build_directory() -> None:
+    # Make sure no file imports from build
+    root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    for dirpath, dirnames, filenames in os.walk(root_dir):
+        # Exclude directories that start with '.'
+        dirnames[:] = [d for d in dirnames if not d.startswith(".") and d != "build"]
+        # also exclude venv
+        dirnames[:] = [d for d in dirnames if not d.startswith("venv")]
+        for filename in filenames:
+            # Skip files that start with '.' and non-Python files
+            if filename.startswith(".") or not filename.endswith(".py"):
+                continue
+            file_path = os.path.join(dirpath, filename)
+            with open(file_path, "r", encoding="utf-8") as file:
+                source = file.read()
+            try:
+                tree = ast.parse(source, filename=file_path)
+            except SyntaxError:
+                continue  # Skip files with syntax errors
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name == "build" or alias.name.startswith("build."):
+                            assert False, f"{file_path} imports 'build'"
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module == "build" or (
+                        node.module and node.module.startswith("build.")
+                    ):
+                        assert False, f"{file_path} imports from 'build'"

approval_utilities-15.3.2.dev5/tests/test_combinations.py

@@ -0,0 +1,175 @@
+import unittest
+
+from typing_extensions import override
+
+from approvaltests.approval_exception import ApprovalException
+from approvaltests.combination_approvals import (
+    verify_all_combinations,
+    verify_all_combinations_with_labeled_input,
+    verify_all_combinations_with_namer,
+)
+from approvaltests.reporters import CommandLineReporter
+from approvaltests.reporters.testing_reporter import ReporterForTesting
+
+
+class VerifyAllCombinationsTests(unittest.TestCase):
+    @override
+    def setUp(self) -> None:
+        self.reporter = None
+        self.func = lambda *args: sum(args) + 1
+
+    def test_fails_for_mismatch_with_for_func_accepting_one_arg_and_combination_of_one_arg(
+        self,
+    ) -> None:
+        arg1_combinations = (1,)
+        all_args_combinations = (arg1_combinations,)
+        with self.assertRaises(ApprovalException):
+            verify_all_combinations(
+                self.func, all_args_combinations, reporter=ReporterForTesting()
+            )
+
+    def test_passes_for_func_accepting_one_arg_and_combination_of_one_arg(self) -> None:
+        arg1_combinations = (1,)
+        all_args_combinations = (arg1_combinations,)
+        verify_all_combinations(
+            self.func, all_args_combinations, reporter=self.reporter
+        )
+
+    def test_fails_for_mismatch_with_for_func_accepting_one_arg_and_combination_of_two_args(
+        self,
+    ) -> None:
+        arg1_combinations = (1, 2)
+        all_args_combinations = (arg1_combinations,)
+        with self.assertRaises(ApprovalException):
+            verify_all_combinations(
+                self.func, all_args_combinations, reporter=ReporterForTesting()
+            )
+
+    def test_passes_for_func_accepting_one_arg_and_combination_of_two_args(
+        self,
+    ) -> None:
+        arg1_combinations = (1, 2)
+        all_args_combinations = (arg1_combinations,)
+        verify_all_combinations(
+            self.func, all_args_combinations, reporter=self.reporter
+        )
+
+    def test_fails_for_mismatch_with_for_func_accepting_two_args_and_combination_of_one_arg(
+        self,
+    ) -> None:
+        arg1_combinations = (1,)
+        arg2_combinations = (2,)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        with self.assertRaises(ApprovalException):
+            verify_all_combinations(
+                self.func, arg_combinations, reporter=ReporterForTesting()
+            )
+
+    def test_passes_for_func_accepting_two_args_and_combination_of_one_arg(
+        self,
+    ) -> None:
+        arg1_combinations = (1,)
+        arg2_combinations = (2,)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        verify_all_combinations(self.func, arg_combinations, reporter=self.reporter)
+
+    def test_fails_for_mismatch_with_for_func_accepting_two_args_and_combination_of_two_args(
+        self,
+    ) -> None:
+        arg1_combinations = (1, 3)
+        arg2_combinations = (2, 4)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        with self.assertRaises(ApprovalException):
+            verify_all_combinations(
+                self.func, arg_combinations, reporter=ReporterForTesting()
+            )
+
+    def test_for_func_accepting_three_args_and_combination_of_three_args(self) -> None:
+        arg1_combinations = (1, 2, 3)
+        arg2_combinations = (2, 4, 6)
+        arg3_combinations = (10, 11, 12)
+        arg_combinations = [arg1_combinations, arg2_combinations, arg3_combinations]
+        verify_all_combinations(self.func, arg_combinations, reporter=self.reporter)
+
+    def test_when_arg_combinations_have_equal_lengths(self) -> None:
+        arg1_combinations = (1, 3, 5, 7)
+        arg2_combinations = (2, 4, 6)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        verify_all_combinations(self.func, arg_combinations, reporter=self.reporter)
+
+    def test_records_exception_message_when_function_under_test_throws_an_exception(
+        self,
+    ) -> None:
+        def function_that_raises_exceptions(*args: object) -> None:
+            raise Exception(args)
+
+        arg1_combinations = (1, 3)
+        arg2_combinations = (2, 4)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        verify_all_combinations(
+            function_that_raises_exceptions, arg_combinations, reporter=self.reporter
+        )
+
+    def test_uses_user_specified_formatter_when_supplied(self) -> None:
+        arg1_combinations = (1, 3)
+        arg2_combinations = (2, 4)
+        arg_combinations = (arg1_combinations, arg2_combinations)
+        verify_all_combinations(
+            self.func,
+            arg_combinations,
+            formatter=lambda args, output: "inputs="
+            + str(args)
+            + ", outputs="
+            + str(output)
+            + "\n",
+            reporter=self.reporter,
+        )
+
+    def test_with_labeled_input(self) -> None:
+        # begin-snippet: named_combinations
+        verify_all_combinations_with_labeled_input(
+            self.func,
+            arg1=(1, 3),
+            arg2=(2, 4),
+        )
+        # end-snippet
+
+
+class VerifyAllCombinationsWithNamerTests(unittest.TestCase):
+    @override
+    def setUp(self) -> None:
+        self.reporter = CommandLineReporter()
+        self.func = lambda *args: sum(args) + 1
+
+    def test_passes_for_func_accepting_one_arg_and_combination_of_one_arg(self) -> None:
+        arg1_combinations = (1,)
+        all_args_combinations = (arg1_combinations,)
+        verify_all_combinations_with_namer(
+            self.func, all_args_combinations, reporter=self.reporter
+        )
+
+
+def test_example_for_combinations() -> None:
+    # begin-snippet: combination_introduction
+    verify_all_combinations(is_awake, [["Monday", "Sunday"], ["7:00", "9:00", "11:00"]])
+    # end-snippet
+
+
+def test_starting_snippet() -> None:
+    # begin-snippet: combinations_starting_point
+    inputs1 = ["input1.value1", "input1.value2"]
+    inputs2 = ["input2.value1", "input2.value2", "input2.value3"]
+    verify_all_combinations(lambda a, b: "placeholder", [inputs1, inputs2])
+    # end-snippet
+
+
+def is_awake(day: str, time) -> str:
+    weekdays = ["Monday"]
+    is_weekday = day in weekdays
+    time = int(time.replace(":00", ""))
+    if is_weekday and time > 8:
+        return "Yes"
+    elif not is_weekday and time < 10:
+        return "No"
+    else:
+        return "Maybe"

approval_utilities-15.3.2.dev5/tests/test_compare_file_lists.py

@@ -0,0 +1,30 @@
+from typing import List
+
+
+def compare_log_and_file_system(
+    log_file_names: List[str], fs_file_names: List[str]
+) -> List[str]:
+    return [file for file in fs_file_names if file not in log_file_names]
+
+
+def test_returns_empty_list_for_two_empty_lists() -> None:
+    log_file_names: List[str] = []
+    fs_file_names: List[str] = []
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == []
+
+
+def test_returns_empty_list_for_identical_lists() -> None:
+    log_file_names = ["a", "b", "c"]
+    fs_file_names = ["a", "b", "c"]
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == []
+
+
+def test_returns_items_only_in_fs() -> None:
+    log_file_names = ["a", "b", "c"]
+    fs_file_names = ["a", "b", "c", "d", "e"]
+    assert compare_log_and_file_system(log_file_names, fs_file_names) == ["d", "e"]
+
+
+# Future tests
+# 1 - fs:[a,b,c], log:[a,b,c] => []
+# 2 - fs:[a,b,c,d], log:[a,b,c] => [d]

approval_utilities-15.3.2.dev5/tests/test_custom_printers.py

@@ -0,0 +1,41 @@
+import argparse
+import typing
+
+from typing_extensions import override
+
+from approvaltests import (
+    approvals,
+    find_formatter_for_specified_class,
+    register_formatter,
+    verify,
+)
+from approvaltests.core.format_wrapper import FormatWrapper
+from approvaltests.verifiable_objects.formatter_of_argparse_namespace import (
+    FormatterOfArgparseNamespace,
+)
+
+
+def test_argparse_namespace() -> None:
+    approvals.settings().allow_multiple_verify_calls_for_this_method()
+    args = argparse.ArgumentParser()
+    args.add_argument("foo")
+    args.add_argument("--foo2")
+    result = args.parse_args(["bar", "--foo2=bar2"])
+    verify(FormatterOfArgparseNamespace(result))
+    verify(result)
+
+
+def test_register_formatter() -> None:
+    class ExampleFormatterWrapper(FormatWrapper):
+        @override
+        def is_match(self, data: typing.Any) -> bool:
+            return True
+
+        @override
+        def wrap(self, data: typing.Any) -> typing.Any:
+            return 42
+
+    with register_formatter(ExampleFormatterWrapper()):
+        assert 42 == find_formatter_for_specified_class("Some Result")
+        verify("Some Result")
+    assert "Some Result" == find_formatter_for_specified_class("Some Result")

approval_utilities-15.3.2.dev5/tests/test_example_numpy.py

@@ -0,0 +1,60 @@
+import io
+from pathlib import Path
+
+import numpy as np
+from typing_extensions import override
+
+from approvaltests import Options, verify_binary
+from approvaltests.core import Reporter
+from approvaltests.reporters import get_command_text
+
+
+def serialize_ndarray(a: np.ndarray) -> bytes:
+    bs = io.BytesIO()
+    np.save(bs, a)
+    bs.seek(0)
+    return bs.read()
+
+
+# begin-snippet: verify_numpy_array
+def test_simulator_produces_correct_output() -> None:
+    np_array = np.full(shape=(32, 16), fill_value=42, dtype=np.int64)
+    verify_binary(
+        serialize_ndarray(np_array),
+        ".npy",
+        options=Options().with_reporter(NDArrayDiffReporter()),
+    )
+
+
+# end-snippet
+
+# Use a custom reporter to show the assertion message from numpy
+# Also the default python console reporter will try to interpret the numpy data as text causing an error
+
+# begin-snippet: numpy_custom_reporter
+
+
+def load_ndarray(path: str):
+    with open(path, mode="rb") as f:
+        return np.load(f)
+
+
+class NDArrayDiffReporter(Reporter):
+    @override
+    def report(self, received_path: str, approved_path: str) -> bool:
+        if not Path(approved_path).is_file():
+            self._create_empty_array(approved_path)
+        received = load_ndarray(received_path)
+        approved = load_ndarray(approved_path)
+        to_approve_msg = (
+            f"To approve run:\n {get_command_text(received_path, approved_path)}"
+        )
+        print(np.testing.build_err_msg([received, approved], err_msg=to_approve_msg))
+        return True
+
+    # end-snippet
+
+    @staticmethod
+    def _create_empty_array(path: str) -> None:
+        with open(path, mode="wb") as f:
+            f.write(serialize_ndarray(np.zeros((0,))))

approval_utilities-15.3.2.dev5/tests/test_exception_utils.py

@@ -0,0 +1,22 @@
+from approval_utilities.utilities.exceptions.exception_collector import (
+    ExceptionCollector,
+    gather_all_exceptions,
+)
+from approvaltests import verify_exception
+
+
+def is_odd(integer: int) -> None:
+    if integer % 2 != 0:
+        raise ValueError(f"{integer} is not odd!")
+
+
+def test_gather_all_exceptions() -> None:
+    collector = ExceptionCollector()
+    for i in range(1, 6):
+        collector.gather(lambda: is_odd(i))
+
+    verify_exception(lambda: collector.release())
+
+
+def test_gather_all_exceptions_from_list() -> None:
+    verify_exception(lambda: gather_all_exceptions(range(1, 6), is_odd).release())

approval_utilities-15.3.2.dev5/tests/test_fileapprover.py

@@ -0,0 +1,114 @@
+import shutil
+import unittest
+
+from approvaltests import Options, approvals, get_default_namer, verify, verify_file
+from approvaltests.file_approver import FileApprover
+from approvaltests.internals.logs.approved_file_log import ApprovedFilesLog
+from approvaltests.internals.logs.failed_comparison_log import FailedComparisonLog
+from approvaltests.reporters.generic_diff_reporter_factory import (
+    GenericDiffReporterFactory,
+)
+from approvaltests.reporters.report_quietly import ReportQuietly
+from approvaltests.reporters.testing_reporter import ReporterForTesting
+from approvaltests.string_writer import StringWriter
+
+
+class FileApproverTests(unittest.TestCase):
+    @staticmethod
+    def test_compare_same_files() -> None:
+        writer = StringWriter("a")
+        writer.write_received_file("a.txt")
+        shutil.copy("a.txt", "a_same.txt")
+        FileApprover.verify_files("a.txt", "a_same.txt", None, Options().comparator)
+
+    def test_compare_different_files(self) -> None:
+        reporter = ReporterForTesting()
+        FileApprover.verify_files("a.txt", "b.txt", reporter, Options().comparator)
+        self.assertTrue(reporter.called)
+
+    def test_scrubbed_files(self) -> None:
+        verify_file("a.txt", options=Options().with_scrubber(lambda t: "<scrubbed>"))
+
+    def test_full(self) -> None:
+        namer = get_default_namer()
+        writer = StringWriter("b")
+        reporter = ReporterForTesting()
+        FileApprover.verify(namer, writer, reporter, Options().comparator)
+        self.assertTrue(reporter.called)
+
+    def test_returns_error_when_files_are_different(self) -> None:
+        approvals.settings().allow_multiple_verify_calls_for_this_method()
+        namer = get_default_namer()
+        writer = StringWriter("b")
+        reporter = ReporterForTesting()
+        error = FileApprover.verify(namer, writer, reporter, Options().comparator)
+        import re
+
+        replaced = re.sub("ved: .*approved_files.", "ved: <rootdir>/", error)
+
+        verify(replaced)
+
+    def test_returns_none_when_files_are_same_files(self) -> None:
+        namer = get_default_namer()
+        writer = StringWriter("b")
+        reporter = GenericDiffReporterFactory().get_first_working()
+        error = FileApprover.verify(namer, writer, reporter, Options().comparator)
+        self.assertEqual(None, error)
+
+    def test_approved_file_is_logged(self) -> None:
+        name = approvals.get_default_namer().get_approved_filename()
+        name1 = name.replace(".txt", ".txt1")
+        name2 = name.replace(".txt", ".txt2")
+
+        log = ApprovedFilesLog.get_approved_files_log()
+        log_lines = log.read_text().split("\n")
+
+        # check log is cleared
+        self.assertNotIn(name1, log_lines)
+        self.assertNotIn(name2, log_lines)
+
+        # touch approved file
+        verify("a", options=Options().for_file.with_extension(".txt1"))
+        verify("a", options=Options().for_file.with_extension(".txt2"))
+
+        # assert that the approved file is logged
+        log_lines = log.read_text().split("\n")
+        self.assertIn(name1, log_lines)
+        self.assertIn(name2, log_lines)
+
+    def test_failed_comparison_is_logged(self) -> None:
+        approved_name = approvals.get_default_namer().get_approved_filename()
+        received_name = approvals.get_default_namer().get_received_filename()
+        expected_line = f"{received_name} -> {approved_name}"
+
+        name1 = expected_line.replace(".txt", ".txt1")
+        name2 = expected_line.replace(".txt", ".txt2")
+
+        log = FailedComparisonLog.get_failed_comparison_log()
+
+        log_lines = log.read_text().split("\n")
+
+        # check log is cleared
+        self.assertNotIn(name1, log_lines)
+        self.assertNotIn(name2, log_lines)
+
+        # fail a verify and log it
+        self.run_a_failing_test(".txt1")
+        self.run_a_failing_test(".txt2")
+
+        # assert that the approved file is logged
+        log_lines = log.read_text().split("\n")
+        self.assertIn(name1, log_lines)
+        self.assertIn(name2, log_lines)
+
+    def run_a_failing_test(self, extension: str) -> None:
+        try:
+            verify(
+                "a",
+                options=Options()
+                .for_file.with_extension(extension)
+                .with_reporter(ReportQuietly()),
+            )
+            self.fail("expected to fail")
+        except:
+            pass