Merge lp:~james-w/linaro-image-tools/add-other-relations-to-packages-file into lp:linaro-image-tools/11.11

[James Westby]

Hi,

This is similar to the last branch, just extends it to Pre-Depends,
Conflicts and Recommends as well. I didn't bother with Suggests, as
I doubt anyone would ever want to install a hwpack and pull in the
suggested packages at the same time. It would be easy to add
though.

There's some small refactorings thrown in now that code is shared
between these different paths.

Thanks,

James

[lp:~james-w/linaro-image-tools/add-other-relations-to-packages-file]

139. By James Westby on 2010-09-10

Merge add-relations-to-packages-file into add-other-relations-to-packages-file.

140. By James Westby on 2010-09-13

Merged add-relations-to-packages-file into add-other-relations-to-packages-file.

[Zygmunt Krynicki (zyga)]

You seem to have changed FetchedPackage.__eq__ but did not change __hash__ (it still refers to the old set of fields).

In addition you should not define __eq__ but __cmp__ unless you are prepared to define __ne__. Moreover you should not define __hash__ as your instances are not immutable.

Currently you can create two identical FetchedPackage objects A and B and the following will hold:
assert A == B # because we have __eq__ that works
assert A != B # because __ne__ compares id() by default

The same issue affects TarfileWrongValueMismatch and TarfileMissingPathMismatch

From pydoc SPECIALMETHODS

 There are no implied relationships among the comparison operators.
   The truth of ``x==y`` does not imply that ``x!=y`` is false.
   Accordingly, when defining ``__eq__()``, one should also define
   ``__ne__()`` so that the operators will behave as expected. See
   the paragraph on ``__hash__()`` for some important notes on
   creating *hashable* objects which support custom comparison
   operations and are usable as dictionary keys.

   If a class does not define a ``__cmp__()`` or ``__eq__()`` method
   it should not define a ``__hash__()`` operation either; if it
   defines ``__cmp__()`` or ``__eq__()`` but not ``__hash__()``, its
   instances will not be usable in hashed collections. If a class
   defines mutable objects and implements a ``__cmp__()`` or
   ``__eq__()`` method, it should not implement ``__hash__()``, since
   hashable collection implementations require that a object's hash
   value is immutable (if the object's hash value changes, it will be
   in the wrong hash bucket).

review: Needs Fixing

[James Westby (james-w)]

On Tue, 14 Sep 2010 19:47:43 -0000, Zygmunt Krynicki <email address hidden> wrote:
> Review: Needs Fixing
> You seem to have changed FetchedPackage.__eq__ but did not change
> __hash__ (it still refers to the old set of fields).

Because content() was never in the __hash__ calculation.

> In addition you should not define __eq__ but __cmp__ unless you are
> prepared to define __ne__. Moreover you should not define __hash__ as
> your instances are not immutable.

__cmp__ doesn't really make sense as there is no natural ordering. Your
other points make sense though.

Thanks,

James

[James Westby (james-w)]

Changed, thanks.

James

[lp:~james-w/linaro-image-tools/add-other-relations-to-packages-file]

141. By James Westby on 2010-09-14

Define __ne__ and remove __hash__ on FetchedPackage. Thanks Zygmunt.

142. By James Westby on 2010-09-14

Add __ne__ and remove __hash__ from the Mismatches. Thanks Zygmunt.

[Zygmunt Krynicki (zyga)]

Looks fine now, please merge!

review: Approve

=== modified file 'hwpack/packages.py'
--- hwpack/packages.py	2010-09-10 21:51:33 +0000
+++ hwpack/packages.py	2010-09-14 20:36:09 +0000
@@ -25,12 +25,52 @@
         parts.append('Architecture: %s' % package.architecture)
         if package.depends:
             parts.append('Depends: %s' % package.depends)
+        if package.pre_depends:
+            parts.append('Pre-Depends: %s' % package.pre_depends)
+        if package.conflicts:
+            parts.append('Conflicts: %s' % package.conflicts)
+        if package.recommends:
+            parts.append('Recommends: %s' % package.recommends)
         parts.append('MD5sum: %s' % package.md5)
         content += "\n".join(parts)
         content += "\n\n"
     return content
 
 
+def stringify_relationship(pkg, relationship):
+    """Given a Package, return a string of the specified relationship.
+
+    apt.package.Version stores the relationship information of the
+    package as objects. This function will convert those objects
+    in to the string form that we are used to from debian/control
+    or Packages files.
+
+    :param pkg: the package to take the relationship information from.
+    :type pkg: apt.package.Version
+    :param relationship: the relationship to stringify, as understood
+        by apt.package.Package.get_dependencies, e.g. "Depends",
+        "PreDepends".
+    :type relationship: str or None if the package has no relationships
+         of that type.
+    """
+    relationship_str = None
+    pkg_dependencies = pkg.get_dependencies(relationship)
+    if pkg_dependencies:
+        relationship_list = []
+        for or_dep in pkg_dependencies:
+            or_list = []
+            for or_alternative in or_dep.or_dependencies:
+                suffix = ""
+                if or_alternative.relation:
+                    suffix = " (%s %s)" % (
+                        or_alternative.relation,
+                        or_alternative.version)
+                or_list.append("%s%s" % (or_alternative.name, suffix))
+            relationship_list.append(" | ".join(or_list))
+        relationship_str = ", ".join(relationship_list)
+    return relationship_str
+
+
 class DummyProgress(object):
     """An AcquireProgress that silences all output.
 
@@ -79,14 +119,27 @@
     :ivar architecture: the architecture that the package is for, may be
         'all'.
     :type architecture: str
-    :ivar depends: the depends string that the package has, i.e. the
+    :ivar depends: the Depends string that the package has, i.e. the
         dependencies as specified in debian/control. May be None if the
         package has none.
     :type depends: str or None
+    :ivar pre_depends: the Pre-Depends string that the package has, i.e. the
+        pre-dependencies as specified in debian/control. May be None if the
+        package has none.
+    :type pre_depends: str or None
+    :ivar conflicts: the Conflicts string that the package has, i.e. the
+        conflicts as specified in debian/control. May be None if the
+        package has none.
+    :type conflicts: str or None
+    :ivar recommends: the Recommends string that the package has, i.e. the
+        recommends as specified in debian/control. May be None if the
+        package has none.
+    :type recommends: str or None
     """
 
     def __init__(self, name, version, filename, content, size, md5,
-                 architecture, depends=None):
+                 architecture, depends=None, pre_depends=None,
+                 conflicts=None, recommends=None):
         """Create a FetchedPackage.
 
         See the instance variables for the arguments.
@@ -99,6 +152,9 @@
         self.md5 = md5
         self.architecture = architecture
         self.depends = depends
+        self.pre_depends = pre_depends
+        self.conflicts = conflicts
+        self.recommends = recommends
 
     @classmethod
     def from_apt(cls, pkg, filename, content):
@@ -116,23 +172,15 @@
         :param content: the content of the package.
         :type content: file-like object
         """
-        depends = None
-        pkg_dependencies = pkg.get_dependencies("Depends")
-        if pkg_dependencies:
-            depends_list = []
-            for or_dep in pkg_dependencies:
-                or_list = []
-                for or_alternative in or_dep.or_dependencies:
-                    suffix = ""
-                    if or_alternative.relation:
-                        suffix = " (%s %s)" % (
-                            or_alternative.relation, or_alternative.version)
-                    or_list.append("%s%s" % (or_alternative.name, suffix))
-                depends_list.append(" | ".join(or_list))
-            depends = ", ".join(depends_list)
+        depends = stringify_relationship(pkg, "Depends")
+        pre_depends = stringify_relationship(pkg, "PreDepends")
+        conflicts = stringify_relationship(pkg, "Conflicts")
+        recommends = stringify_relationship(pkg, "Recommends")
         return cls(
             pkg.package.name, pkg.version, filename, content, pkg.size,
-            pkg.md5, pkg.architecture, depends=depends)
+            pkg.md5, pkg.architecture, depends=depends,
+            pre_depends=pre_depends, conflicts=conflicts,
+            recommends=recommends)
 
     def __eq__(self, other):
         return (self.name == other.name
@@ -142,19 +190,21 @@
                 and self.size == other.size
                 and self.md5 == other.md5
                 and self.architecture == other.architecture
-                and self.depends == other.depends)
+                and self.depends == other.depends
+                and self.pre_depends == other.pre_depends
+                and self.conflicts == other.conflicts
+                and self.recommends == other.recommends)
 
-    def __hash__(self):
-        return hash(
-            (self.name, self.version, self.filename, self.size, self.md5,
-             self.depends))
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
     def __repr__(self):
         return (
             '<%s name=%s version=%s size=%s md5=%s architecture=%s '
-            'depends="%s">' % (self.__class__.__name__, self.name,
-                self.version, self.size, self.md5, self.architecture,
-                self.depends))
+            'depends="%s" pre_depends="%s" conflicts="%s" recommends="%s">'
+            % (self.__class__.__name__, self.name, self.version, self.size,
+                self.md5, self.architecture, self.depends, self.pre_depends,
+                self.conflicts, self.recommends))
 
 
 class IsolatedAptCache(object):

=== modified file 'hwpack/tarfile_matchers.py'
--- hwpack/tarfile_matchers.py	2010-08-31 16:33:16 +0000
+++ hwpack/tarfile_matchers.py	2010-09-14 20:36:09 +0000
@@ -20,8 +20,8 @@
     def __eq__(self, other):
         return self.tarball == other.tarball and self.path == other.path
 
-    def __hash__(self):
-        return hash((self.tarball, self.path))
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
 
 class TarfileWrongValueMismatch(Mismatch):
@@ -56,10 +56,8 @@
                 and self.expected == other.expected
                 and self.actual == other.actual)
 
-    def __hash__(self):
-        return hash(
-            (self.attribute, self.tarball, self.path, self.expected,
-             self.actual))
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
 
 class TarfileHasFile(Matcher):

=== modified file 'hwpack/testing.py'
--- hwpack/testing.py	2010-09-10 18:58:06 +0000
+++ hwpack/testing.py	2010-09-14 20:36:09 +0000
@@ -54,11 +54,15 @@
     See FetchedPackage for the instance variables.
     """
 
-    def __init__(self, name, version, architecture="all", depends=None):
+    def __init__(self, name, version, architecture="all", depends=None,
+                 pre_depends=None, conflicts=None, recommends=None):
         self.name = name
         self.version = version
         self.architecture = architecture
         self.depends = depends
+        self.pre_depends = pre_depends
+        self.conflicts = conflicts
+        self.recommends = recommends
 
     @property
     def filename(self):

=== modified file 'hwpack/tests/test_packages.py'
--- hwpack/tests/test_packages.py	2010-09-10 20:53:42 +0000
+++ hwpack/tests/test_packages.py	2010-09-14 20:36:09 +0000
@@ -9,6 +9,7 @@
     FetchedPackage,
     get_packages_file,
     PackageFetcher,
+    stringify_relationship,
     )
 from hwpack.testing import (
     AptSourceFixture,
@@ -41,21 +42,89 @@
             get_packages_file([package1]) + get_packages_file([package2]),
             get_packages_file([package1, package2]))
 
+    def get_stanza(self, package, relationships=""):
+        stanza = textwrap.dedent("""\
+            Package: foo
+            Version: 1.1
+            Filename: %(filename)s
+            Size: %(size)d
+            Architecture: all
+            """ % {
+            'filename': package.filename,
+            'size': package.size,
+            })
+        stanza += relationships
+        stanza += "MD5sum: %s\n\n" % package.md5
+        return stanza
+
     def test_with_depends(self):
         package = DummyFetchedPackage("foo", "1.1", depends="bar | baz")
-        self.assertEqual(textwrap.dedent("""\
-            Package: foo
-            Version: 1.1
-            Filename: %(filename)s
-            Size: %(size)d
-            Architecture: all
-            Depends: bar | baz
-            MD5sum: %(md5)s
-            \n""" % {
-                'filename': package.filename,
-                'size': package.size,
-                'md5': package.md5,
-            }), get_packages_file([package]))
+        self.assertEqual(
+            self.get_stanza(package, "Depends: bar | baz\n"),
+            get_packages_file([package]))
+
+    def test_with_pre_depends(self):
+        package = DummyFetchedPackage("foo", "1.1", pre_depends="bar | baz")
+        self.assertEqual(
+            self.get_stanza(package, "Pre-Depends: bar | baz\n"),
+            get_packages_file([package]))
+
+    def test_with_conflicts(self):
+        package = DummyFetchedPackage("foo", "1.1", conflicts="bar | baz")
+        self.assertEqual(
+            self.get_stanza(package, "Conflicts: bar | baz\n"),
+            get_packages_file([package]))
+
+    def test_with_recommends(self):
+        package = DummyFetchedPackage("foo", "1.1", recommends="bar | baz")
+        self.assertEqual(
+            self.get_stanza(package, "Recommends: bar | baz\n"),
+            get_packages_file([package]))
+
+
+class StringifyRelationshipTests(TestCaseWithFixtures):
+
+    def test_no_relationship(self):
+        target_package = DummyFetchedPackage("foo", "1.0")
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            self.assertEqual(
+                None, stringify_relationship(candidate, "Depends"))
+
+    def test_single_package(self):
+        target_package = DummyFetchedPackage("foo", "1.0", depends="bar")
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            self.assertEqual(
+                "bar", stringify_relationship(candidate, "Depends"))
+
+    def test_multiple_package(self):
+        target_package = DummyFetchedPackage("foo", "1.0", depends="bar, baz")
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            self.assertEqual(
+                "bar, baz", stringify_relationship(candidate, "Depends"))
+
+    def test_alternative_packages(self):
+        target_package = DummyFetchedPackage(
+            "foo", "1.0", depends="bar | baz")
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            self.assertEqual(
+                "bar | baz", stringify_relationship(candidate, "Depends"))
+
+    def test_package_with_version(self):
+        target_package = DummyFetchedPackage(
+            "foo", "1.0", depends="baz (<= 2.0)")
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            self.assertEqual(
+                "baz (<= 2.0)", stringify_relationship(candidate, "Depends"))
 
 
 class FetchedPackageTests(TestCaseWithFixtures):
@@ -78,6 +147,7 @@
         package2 = FetchedPackage(
             "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertEqual(package1, package2)
+        self.assertFalse(package1 != package2)
 
     def test_not_equal_different_name(self):
         package1 = FetchedPackage(
@@ -155,21 +225,86 @@
             depends="bar")
         self.assertEqual(package1, package2)
 
-    def test_equal_hash_equal(self):
-        package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
-        package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
-        self.assertEqual(hash(package1), hash(package2))
-
-    def test_equal_hash_equal_with_depends(self):
-        package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
-            depends="bar")
-        package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
-            depends="bar")
-        self.assertEqual(hash(package1), hash(package2))
+    def test_not_equal_different_pre_depends(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends="baz")
+        self.assertNotEqual(package1, package2)
+
+    def test_not_equal_different_pre_depends_one_None(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends=None)
+        self.assertNotEqual(package1, package2)
+
+    def test_equal_same_pre_depends(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            pre_depends="bar")
+        self.assertEqual(package1, package2)
+
+    def test_not_equal_different_conflicts(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts="baz")
+        self.assertNotEqual(package1, package2)
+
+    def test_not_equal_different_conflicts_one_None(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts=None)
+        self.assertNotEqual(package1, package2)
+
+    def test_equal_same_conflicts(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            conflicts="bar")
+        self.assertEqual(package1, package2)
+
+    def test_not_equal_different_recommends(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends="baz")
+        self.assertNotEqual(package1, package2)
+
+    def test_not_equal_different_recommends_one_None(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends=None)
+        self.assertNotEqual(package1, package2)
+
+    def test_equal_same_recommends(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends="bar")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel",
+            recommends="bar")
+        self.assertEqual(package1, package2)
 
     def test_from_apt(self):
         target_package = DummyFetchedPackage("foo", "1.0")
@@ -180,15 +315,28 @@
                 candidate, target_package.filename, target_package.content)
             self.assertEqual(target_package, created_package)
 
+    def assert_from_apt_translates_relationship(self, relationship):
+        kwargs = {}
+        kwargs[relationship] = "bar | baz (>= 1.0), zap"
+        target_package = DummyFetchedPackage("foo", "1.0", **kwargs)
+        source = self.useFixture(AptSourceFixture([target_package]))
+        with IsolatedAptCache([source.sources_entry]) as cache:
+            candidate = cache.cache['foo'].candidate
+            created_package = FetchedPackage.from_apt(
+                candidate, target_package.filename, target_package.content)
+            self.assertEqual(target_package, created_package)
+
     def test_from_apt_with_depends(self):
-        target_package = DummyFetchedPackage(
-            "foo", "1.0", depends="bar | baz (>= 1.0), zap")
-        source = self.useFixture(AptSourceFixture([target_package]))
-        with IsolatedAptCache([source.sources_entry]) as cache:
-            candidate = cache.cache['foo'].candidate
-            created_package = FetchedPackage.from_apt(
-                candidate, target_package.filename, target_package.content)
-            self.assertEqual(target_package, created_package)
+        self.assert_from_apt_translates_relationship('depends')
+
+    def test_from_apt_with_pre_depends(self):
+        self.assert_from_apt_translates_relationship('pre_depends')
+
+    def test_from_apt_with_conflicts(self):
+        self.assert_from_apt_translates_relationship('conflicts')
+
+    def test_from_apt_with_recommends(self):
+        self.assert_from_apt_translates_relationship('recommends')
 
 
 class AptCacheTests(TestCaseWithFixtures):
@@ -386,3 +534,16 @@
         fetcher = self.get_fetcher([source], architecture="arch1")
         self.assertEqual(
             wanted_package, fetcher.fetch_packages(["foo"])[0])
+
+    def test_fetch_package_fetches_with_relationships(self):
+        depends = "foo"
+        pre_depends = "bar (>= 1.0)"
+        conflicts = "baz | zap"
+        recommends = "zing, zang"
+        wanted_package = DummyFetchedPackage(
+            "foo", "1.0", depends=depends, pre_depends=pre_depends,
+            conflicts=conflicts, recommends=recommends)
+        source = self.useFixture(AptSourceFixture([wanted_package]))
+        fetcher = self.get_fetcher([source])
+        self.assertEqual(
+            wanted_package, fetcher.fetch_packages(["foo"])[0])

=== modified file 'hwpack/tests/test_tarfile_matchers.py'
--- hwpack/tests/test_tarfile_matchers.py	2010-08-31 16:35:41 +0000
+++ hwpack/tests/test_tarfile_matchers.py	2010-09-14 20:36:09 +0000
@@ -21,6 +21,7 @@
         mismatch1 = TarfileMissingPathMismatch("foo", "bar")
         mismatch2 = TarfileMissingPathMismatch("foo", "bar")
         self.assertEqual(mismatch1, mismatch2)
+        self.assertFalse(mismatch1 != mismatch2)
 
     def test_no_eq_different_tarball(self):
         mismatch1 = TarfileMissingPathMismatch("foo", "bar")
@@ -32,21 +33,6 @@
         mismatch2 = TarfileMissingPathMismatch("foo", "baz")
         self.assertNotEqual(mismatch1, mismatch2)
 
-    def test_hash_equal(self):
-        mismatch1 = TarfileMissingPathMismatch("foo", "bar")
-        mismatch2 = TarfileMissingPathMismatch("foo", "bar")
-        self.assertEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_tarball_different_hash(self):
-        mismatch1 = TarfileMissingPathMismatch("foo", "bar")
-        mismatch2 = TarfileMissingPathMismatch("baz", "bar")
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_path_different_hash(self):
-        mismatch1 = TarfileMissingPathMismatch("foo", "bar")
-        mismatch2 = TarfileMissingPathMismatch("foo", "baz")
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
 
 class TarfileWrongTypeMismatchTests(TestCase):
 
@@ -60,6 +46,7 @@
         mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
         mismatch2 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
         self.assertEqual(mismatch1, mismatch2)
+        self.assertFalse(mismatch1 != mismatch2)
 
     def test_not_eq_different_attribute(self):
         mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
@@ -86,36 +73,6 @@
         mismatch2 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 3)
         self.assertNotEqual(mismatch1, mismatch2)
 
-    def test_hash_equal(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        self.assertEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_attribute_different_hash(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("size", "foo", "bar", 1, 2)
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_tarball_different_hash(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("type", "baz", "bar", 1, 2)
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_path_different_hash(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("type", "foo", "baz", 1, 2)
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_expected_different_hash(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("type", "foo", "bar", 3, 2)
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
-    def test_different_actual_different_hash(self):
-        mismatch1 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 2)
-        mismatch2 = TarfileWrongValueMismatch("type", "foo", "bar", 1, 3)
-        self.assertNotEqual(hash(mismatch1), hash(mismatch2))
-
 
 class TarfileHasFileTests(TestCase):