def assertAlmostEqual(self, first, second, places = 7, msg = None):
     if first == second:
         return
     if round(abs(second - first), places) != 0:
         standardMsg = '%s != %s within %r places' % (safe_repr(first), safe_repr(second), places)
         msg = self._formatMessage(msg, standardMsg)
         raise self.failureException(msg)

    def assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None):
        """Fail if the two objects are equal as determined by their
           difference rounded to the given number of decimal places
           (default 7) and comparing to zero, or by comparing that the
           between the two objects is less than the given delta.

           Note that decimal places (from zero) are usually not the same
           as significant digits (measured from the most signficant digit).

           Objects that are equal automatically fail.
        """
        if delta is not None and places is not None:
            raise TypeError("specify delta or places not both")
        if delta is not None:
            if not (first == second) and abs(first - second) > delta:
                return
            standardMsg = '%s == %s within %s delta' % (safe_repr(first), 
                                                        safe_repr(second),
                                                        safe_repr(delta))
        else:
            if places is None:
                places = 7
            if not (first == second) and round(abs(second-first), places) != 0:
                return
            standardMsg = '%s == %s within %r places' % (safe_repr(first), 
                                                         safe_repr(second),
                                                         places)

        msg = self._formatMessage(msg, standardMsg)
        raise self.failureException(msg)

    def assertDictContainsSubset(self, expected, actual, msg=None):
        """Checks whether actual is a superset of expected."""
        missing = []
        mismatched = []
        for key, value in expected.iteritems():
            if key not in actual:
                missing.append(key)
            elif value != actual[key]:
                mismatched.append('%s, expected: %s, actual: %s' %
                                  (safe_repr(key), safe_repr(value), 
                                   safe_repr(actual[key])))

        if not (missing or mismatched):
            return

        standardMsg = ''
        if missing:
            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in 
                                                    missing)
        if mismatched:
            if standardMsg:
                standardMsg += '; '
            standardMsg += 'Mismatched values: %s' % ','.join(mismatched)

        self.fail(self._formatMessage(msg, standardMsg))

    def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
        """An unordered sequence specific comparison. It asserts that
        expected_seq and actual_seq contain the same elements. It is
        the equivalent of::
        
            self.assertEqual(sorted(expected_seq), sorted(actual_seq))

        Raises with an error message listing which elements of expected_seq
        are missing from actual_seq and vice versa if any.
        
        Asserts that each element has the same count in both sequences.
        Example:
            - [0, 1, 1] and [1, 0, 1] compare equal.
            - [0, 0, 1] and [0, 1] compare unequal.
        """
        try:
            expected = sorted(expected_seq)
            actual = sorted(actual_seq)
        except TypeError:
            # Unsortable items (example: set(), complex(), ...)
            expected = list(expected_seq)
            actual = list(actual_seq)
            missing, unexpected = unorderable_list_difference(expected, actual, ignore_duplicate=False)
        else:
            return self.assertSequenceEqual(expected, actual, msg=msg)

        errors = []
        if missing:
            errors.append("Expected, but missing:\n    %s" % safe_repr(missing))
        if unexpected:
            errors.append("Unexpected, but present:\n    %s" % safe_repr(unexpected))
        if errors:
            standardMsg = "\n".join(errors)
            self.fail(self._formatMessage(msg, standardMsg))

 def assertNotEqual(self, first, second, msg=None):
     """Fail if the two objects are equal as determined by the '=='
        operator.
     """
     if not first != second:
         msg = self._formatMessage(msg, "%s == %s" % (safe_repr(first), safe_repr(second)))
         raise self.failureException(msg)

    def assertDictEqual(self, d1, d2, msg=None):
        self.assert_(isinstance(d1, dict), "First argument is not a dictionary")
        self.assert_(isinstance(d2, dict), "Second argument is not a dictionary")

        if d1 != d2:
            standardMsg = "%s != %s" % (safe_repr(d1, True), safe_repr(d2, True))
            diff = "\n" + "\n".join(difflib.ndiff(pprint.pformat(d1).splitlines(), pprint.pformat(d2).splitlines()))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertMultiLineEqual(self, first, second, msg=None):
        """Assert that two multi-line strings are equal."""
        self.assert_(isinstance(first, basestring), ("First argument is not a string"))
        self.assert_(isinstance(second, basestring), ("Second argument is not a string"))

        if first != second:
            standardMsg = "%s != %s" % (safe_repr(first, True), safe_repr(second, True))
            diff = "\n" + "".join(difflib.ndiff(first.splitlines(True), second.splitlines(True)))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertDictEqual(self, d1, d2, msg=None):
        self.assertTrue(IsMappingType(d1), 'First argument is not a dictionary')
        self.assertTrue(IsMappingType(d2), 'Second argument is not a dictionary')

        if d1 != d2:
            standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True))
            diff = ('\n' + '\n'.join(difflib.ndiff(
                           pprint.pformat(d1).splitlines(),
                           pprint.pformat(d2).splitlines())))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertDictEqual(self, d1, d2, msg=None):
        self.assert_(isinstance(d1, dict), 'First argument is not a dictionary')
        self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary')

        if d1 != d2:
            standardMsg = '{0!s} != {1!s}'.format(safe_repr(d1, True), safe_repr(d2, True))
            diff = ('\n' + '\n'.join(difflib.ndiff(
                           pprint.pformat(d1).splitlines(),
                           pprint.pformat(d2).splitlines())))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertMultiLineEqual(self, first, second, msg=None):
        """Assert that two multi-line strings are equal."""
        self.assert_(isinstance(first, six.string_types), (
                'First argument is not a string'))
        self.assert_(isinstance(second, six.string_types), (
                'Second argument is not a string'))

        if first != second:
            standardMsg = '%s != %s' % (safe_repr(first, True), safe_repr(second, True))
            diff = '\n' + ''.join(difflib.ndiff(first.splitlines(True),
                                                       second.splitlines(True)))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertDictContainsSubset(self, expected, actual, msg=None):
        missing = []
        mismatched = []
        for key, value in expected.iteritems():
            if key not in actual:
                missing.append(key)
            elif value != actual[key]:
                mismatched.append(
                    "%s, expected: %s, actual: %s" % (safe_repr(key), safe_repr(value), safe_repr(actual[key]))
                )

        if not (missing or mismatched):
            return
        standardMsg = ""
        if missing:
            standardMsg = "Missing: %s" % ",".join((safe_repr(m) for m in missing))
        if mismatched:
            if standardMsg:
                standardMsg += "; "
            standardMsg += "Mismatched values: %s" % ",".join(mismatched)
        self.fail(self._formatMessage(msg, standardMsg))

    def assertSameElements(self, expected_seq, actual_seq, msg = None):
        try:
            expected = set(expected_seq)
            actual = set(actual_seq)
            missing = list(expected.difference(actual))
            unexpected = list(actual.difference(expected))
            missing.sort()
            unexpected.sort()
        except TypeError:
            expected = list(expected_seq)
            actual = list(actual_seq)
            expected.sort()
            actual.sort()
            missing, unexpected = sorted_list_difference(expected, actual)

        errors = []
        if missing:
            errors.append('Expected, but missing:\n    %s' % safe_repr(missing))
        if unexpected:
            errors.append('Unexpected, but present:\n    %s' % safe_repr(unexpected))
        if errors:
            standardMsg = '\n'.join(errors)
            self.fail(self._formatMessage(msg, standardMsg))

    def assertAlmostEqual(self, first, second, places=None, msg=None, delta=None):
        """Fail if the two objects are unequal as determined by their
           difference rounded to the given number of decimal places
           (default 7) and comparing to zero, or by comparing that the
           between the two objects is more than the given delta.

           Note that decimal places (from zero) are usually not the same
           as significant digits (measured from the most signficant digit).

           If the two objects compare equal then they will automatically
           compare almost equal.
        """
        if first == second:
            # shortcut
            return
        if delta is not None and places is not None:
            raise TypeError("specify delta or places not both")
        
        if delta is not None:
            if abs(first - second) <= delta:
                return
        
            standardMsg = '{0!s} != {1!s} within {2!s} delta'.format(safe_repr(first), 
                                                        safe_repr(second), 
                                                        safe_repr(delta))
        else:
            if places is None:
                places = 7
                
            if round(abs(second-first), places) == 0:
                return
        
            standardMsg = '{0!s} != {1!s} within {2!r} places'.format(safe_repr(first), 
                                                          safe_repr(second), 
                                                          places)
        msg = self._formatMessage(msg, standardMsg)
        raise self.failureException(msg)

 def assertIsNot(self, expr1, expr2, msg=None):
     """Just like self.assertTrue(a is not b), but with a nicer default message."""
     if expr1 is expr2:
         standardMsg = 'unexpectedly identical: %s' % (safe_repr(expr1),)
         self.fail(self._formatMessage(msg, standardMsg))

 def assertIs(self, expr1, expr2, msg=None):
     """Just like self.assertTrue(a is b), but with a nicer default message."""
     if expr1 is not expr2:
         standardMsg = '%s is not %s' % (safe_repr(expr1), safe_repr(expr2))
         self.fail(self._formatMessage(msg, standardMsg))

 def assertNotIn(self, member, container, msg=None):
     """Just like self.assertTrue(a not in b), but with a nicer default message."""
     if member in container:
         standardMsg = '%s unexpectedly found in %s' % (safe_repr(member), 
                                                         safe_repr(container))
         self.fail(self._formatMessage(msg, standardMsg))

 def assertIsInstance(self, obj, cls, msg=None):
     """Same as self.assertTrue(isinstance(obj, cls)), with a nicer
     default message."""
     if not isinstance(obj, cls):
         standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls)
         self.fail(self._formatMessage(msg, standardMsg))

 def assertGreaterEqual(self, a, b, msg=None):
     """Just like self.assertTrue(a >= b), but with a nicer default message."""
     if not a >= b:
         standardMsg = '%s not greater than or equal to %s' % (safe_repr(a), safe_repr(b))
         self.fail(self._formatMessage(msg, standardMsg))

 def assertTrue(self, expr, msg=None):
     """Fail the test unless the expression is true."""
     if not expr:
         msg = self._formatMessage(msg, "%s is not True" % safe_repr(expr))
         raise self.failureException(msg)

 def assertIsNone(self, obj, msg = None):
     if obj is not None:
         standardMsg = '%s is not None' % (safe_repr(obj),)
         self.fail(self._formatMessage(msg, standardMsg))