+ fixing inconsisten behaviour WRT rich comparisons between ipv4 and ipv6

    objects.

git-svn-id: https://ipaddr-py.googlecode.com/svn@138 09200d28-7f98-11dd-ad27-0f66e57d2035

2 files changed, 46 insertions, 29 deletions

diff --git a/trunk/ipaddr.py b/trunk/ipaddr.py
index 0f55b02..7f3bc3a 100644
--- a/trunk/ipaddr.py
+++ b/trunk/ipaddr.py
@@ -390,8 +390,8 @@ class _BaseIP(_IPAddrBase):
 
     def __eq__(self, other):
         try:
-            return not (self._ip != other._ip
-                        or self._version != other._version)
+            return (self._ip == other._ip
+                    and self._version == other._version)
         except AttributeError:
             return NotImplemented
 
@@ -415,14 +415,16 @@ class _BaseIP(_IPAddrBase):
 
     def __lt__(self, other):
         if self._version != other._version:
-            return self._version < other._version
+            raise TypeError("%s and %s aren't of the same version" % (
+                str(self), str(other)))        
         if self._ip != other._ip:
             return self._ip < other._ip
         return False
 
     def __gt__(self, other):
         if self._version != other._version:
-            return self._version > other._version
+            raise TypeError("%s and %s aren't of the same version" % (
+                str(self), str(other)))        
         if self._ip != other._ip:
             return self._ip > other._ip
         return False
@@ -490,28 +492,24 @@ class _BaseNet(_IPAddrBase):
             return IPAddress(broadcast + n, version=self._version)
 
     def __lt__(self, other):
-        try:
-            if self._version != other._version:
-                return self._version < other._version
-            if self.network != other.network:
-                return self.network < other.network
-            if self.netmask != other.netmask:
-                return self.netmask < other.netmask
-            return False
-        except AttributeError:
-            return NotImplemented
+        if self._version != other._version:
+            raise TypeError("%s and %s aren't of the same version" % (
+                str(self), str(other)))        
+        if self.network != other.network:
+            return self.network < other.network
+        if self.netmask != other.netmask:
+            return self.netmask < other.netmask
+        return False
 
     def __gt__(self, other):
-        try:
-            if self._version != other._version:
-                return self._version > other._version
-            if self.network != other.network:
-                return self.network > other.network
-            if self.netmask != other.netmask:
-                return self.netmask > other.netmask
-            return False
-        except AttributeError:
-            return NotImplemented
+        if self._version != other._version:
+            raise TypeError("%s and %s aren't of the same version" % (
+                str(self), str(other)))        
+        if self.network != other.network:
+            return self.network > other.network
+        if self.netmask != other.netmask:
+            return self.netmask > other.netmask
+        return False
 
     def __le__(self, other):
         gt = self.__gt__(other)
diff --git a/trunk/ipaddr_test.py b/trunk/ipaddr_test.py
index 4336ddf..f4ce79d 100755
--- a/trunk/ipaddr_test.py
+++ b/trunk/ipaddr_test.py
@@ -100,6 +100,24 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(str(self.ipv6.hostmask),
                          '::ffff:ffff:ffff:ffff')
 
+
+    def testBadVersionComparison(self):
+        # These should always raise TypeError
+        v4addr = ipaddr.IPAddress('1.1.1.1')
+        v4net = ipaddr.IPNetwork('1.1.1.1')
+        v6addr = ipaddr.IPAddress('::1')
+        v6net = ipaddr.IPAddress('::1')
+        
+        self.assertRaises(TypeError, v4addr.__lt__, v6addr)
+        self.assertRaises(TypeError, v4addr.__gt__, v6addr)
+        self.assertRaises(TypeError, v4net.__lt__, v6net)
+        self.assertRaises(TypeError, v4net.__gt__, v6net)
+
+        self.assertRaises(TypeError, v6addr.__lt__, v4addr)
+        self.assertRaises(TypeError, v6addr.__gt__, v4addr)
+        self.assertRaises(TypeError, v6net.__lt__, v4net)
+        self.assertRaises(TypeError, v6net.__gt__, v4net)
+
     def testIpFromInt(self):
         self.assertEqual(self.ipv4.ip, ipaddr.IPv4Network(16909060).ip)
         self.assertRaises(ipaddr.AddressValueError,
@@ -525,11 +543,14 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEquals(ip1.compare_networks(ip3), -1)
         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 
-        # Test comparing different protocols
+        # Test comparing different protocols.
+        # Should always raise a TypeError.
         ipv6 = ipaddr.IPv6Network('::/0')
         ipv4 = ipaddr.IPv4Network('0.0.0.0/0')
-        self.assertTrue(ipv6 > ipv4)
-        self.assertTrue(ipv4 < ipv6)
+        self.assertRaises(TypeError, ipv4.__lt__, ipv6)
+        self.assertRaises(TypeError, ipv4.__gt__, ipv6)
+        self.assertRaises(TypeError, ipv6.__lt__, ipv4)
+        self.assertRaises(TypeError, ipv6.__gt__, ipv4)
 
         # Regression test for issue 19.
         ip1 = ipaddr.IPNetwork('10.1.2.128/25')
@@ -655,10 +676,8 @@ class IpaddrUnitTest(unittest.TestCase):
                           ipaddr.IPAddress('127.100.200.254').is_loopback)
         self.assertEquals(True, ipaddr.IPAddress('127.42.0.0').is_loopback)
         self.assertEquals(False, ipaddr.IPAddress('128.0.0.0').is_loopback)
-
         self.assertEquals(True, ipaddr.IPNetwork('0.0.0.0').is_unspecified)
 
-        
     def testReservedIpv6(self):
 
         self.assertEquals(True, ipaddr.IPNetwork('ffff::').is_multicast)