def test_invalid_line(self):
     self.tmpfile.write('justkey\n')
     self.tmpfile.flush()
     assert_raises(
             errors.ConfigurationError,
             loader.PropertiesConfiguration,
             self.tmpfile.name)

 def test_fails_when_exception_is_not_raised(self):
     raises_nothing = lambda: None
     try:
         assertions.assert_raises(ValueError, raises_nothing)
     except AssertionError:
         pass
     else:
         assert_not_reached('AssertionError should have been raised')

 def test_callable_is_called_with_all_arguments(self):
     class GoodArguments(Exception): pass
     arg1, arg2, kwarg = object(), object(), object()
     def check_arguments(*args, **kwargs):
         assert_equal((arg1, arg2), args)
         assert_equal({'kwarg': kwarg}, kwargs)
         raise GoodArguments
     assertions.assert_raises(GoodArguments, check_arguments, arg1, arg2, kwarg=kwarg)

 def test_read_config_failed(self):
     self.namespace.get.return_value = proxy.UndefToken
     assert_raises(
             errors.ConfigurationError,
             readers._read_config,
             'some_key',
             self.namespace,
             None)

 def test_xml_configuration_safe_value_tag(self):
     content = """
         <config>
             <sometag value="snazz">E</sometag>
         </config>
     """
     self.write_content_to_file(content)
     assert_raises(errors.ConfigurationError, loader.XMLConfiguration, self.tmpfile.name, safe=True)

    def test_build_loader_optional(self):
        err_msg = "Failed to do"
        loader_func = mock.Mock()
        loader_func.side_effect = ValueError(err_msg)
        config_loader = loader.build_loader(loader_func)

        config_loader(optional=True)
        assert_raises(ValueError, config_loader)

 def test_fails_when_wrong_exception_is_raised(self):
     def raises_value_error():
         raise ValueError
     try:
         assertions.assert_raises(MyException, raises_value_error)
     except ValueError:
         pass
     else:
         assert_not_reached('ValueError should have been raised')

 def test_xml_configuration_safe_override(self):
     content = """
         <config>
             <sometag foo="bar">
                 <foo>E</foo>
             </sometag>
         </config>
     """
     self.write_content_to_file(content)
     assert_raises(errors.ConfigurationError, loader.XMLConfiguration, self.tmpfile.name, safe=True)

    def test_no_vars(self):
        """
        To allocate a .__dict__ attribute of this object means that we're
        allocating a second, mutable dictionary as part of our frozendict.
        This would be a waste of memory as well as yielding pretty nonsensical
        semantics wrt immutability.
        """
        fd = fdict(a=1)
        with T.assert_raises(TypeError):
            vars(fd)

        with T.assert_raises(AttributeError):
            fd.__dict__

 def test_fails_when_no_exception_is_raised(self):
     """Tests that the assertion fails when no exception is raised."""
     def exists(e):
         return True
     with assertions.assert_raises(AssertionError):
         with assertions.assert_raises_such_that(Exception, exists):
             pass

    def test_unexpected_exception_passes_through(self):
        class DifferentException(Exception):
            pass

        with assertions.assert_raises(DifferentException):
            with assertions.assert_raises_exactly(self.MyException, "first", "second"):
                raise DifferentException("first", "second")

    def test_fails_with_different_class(self):
        class SpecialException(self.MyException):
            pass

        with assertions.assert_raises(AssertionError):
            with assertions.assert_raises_exactly(self.MyException, "first", "second"):
                raise SpecialException("first", "second")

 def test_fails_when_exception_test_fails(self):
     """Tests that when an exception of the right type that fails the
     passed in exception test is raised, the assertion fails."""
     has_two_args = lambda e: assertions.assert_length(e.args, 2)
     with assertions.assert_raises(AssertionError):
         with assertions.assert_raises_such_that(Exception, has_two_args):
             raise Exception("only one argument")

 def test_parse_test_runner_command_line_args_no_test_path(self):
     """Make sure that if no options and no arguments are passed,
     parse_test_runner_command_line_args DOES complain about a missing test
     path.
     """
     with assert_raises(OptionParserErrorException):
         test_program.parse_test_runner_command_line_args([], [])

 def test_fails_when_incorrect_warning_with_callable(self):
     """
     Test that assert_warns fails when we pass a specific warning and
     a different warning class is thrown.
     """
     with assertions.assert_raises(AssertionError):
         assertions.assert_warns(DeprecationWarning, self._create_user_warning)

    def perform_exception_test(self, exc_class):
        self.expected_reference_counts = self.get_reference_counts()
        for _ in xrange(self.num_stress_test_iterations + 1):
            # there's a fun wrinkle here. we have to make sure the raised exception
            # is completely out of scope and destroyed before we check the reference
            # counts again; otherwise it may hold incidental references to objects,
            # which will appear to the reference count checks here as though it were
            # a memory leak. not that this, you know, actually happened to me or anything.
            assert_raises(exc_class, self.run_templating)
            assert_equal(self.get_reference_counts(), self.expected_reference_counts)

        try:
            self.run_templating()
        except exc_class, e:
            # now that we're done counting references, save the exception for examination:
            self.exception = e

    def test_fails_on_infinite_generator(self):
        """Tests that assert_empty fails on an infinite generator."""
        def yes():
            while True:
                yield 'y'

        with assertions.assert_raises(AssertionError):
            assertions.assert_empty(yes())

 def test_fails_when_warnings_test_raises_exception(self):
     """
     Test that assert_warns_such_that (used as a context manager)
     fails when the warnings_test method raises an exception.
     """
     with assertions.assert_raises(RuntimeError):
         with assertions.assert_warns_such_that(self._raise_exception):
             self._create_user_warning()

 def test_fails_when_warnings_test_raises_exception_with_callable(self):
     """
     Test that assert_warns_such_that (when given a callable object)
     fails when the warnings_test method raises an exception.
     """
     with assertions.assert_raises(RuntimeError):
         assertions.assert_warns_such_that(self._raise_exception,
                                           self._create_user_warning)

    def test_fails_on_unyielding_generator(self):
        """Test that assert_not_empty fails on an 'empty' generator."""
        def yield_nothing():
            if False:
                yield 0

        with assertions.assert_raises(AssertionError):
            assertions.assert_not_empty(yield_nothing())