fixing test; speeding up OrderableNone

tests/util/test_misc.py

@@ -10,23 +10,26 @@
 from wc_utils.util.misc import most_qual_cls_name, round_direct, OrderableNone
 from wc_utils.util.stats import ExponentialMovingAverage
 
+
 class C(object):
+
     class D(object):
         pass
-d=C.D()
+d = C.D()
+
 
 class TestMisc(unittest.TestCase):
 
     def test_get_qual_name(self):
-    
+
         ema = ExponentialMovingAverage(1, .5)
         self.assertEqual(most_qual_cls_name(self), 'tests.util.test_misc.TestMisc')
         self.assertEqual(most_qual_cls_name(TestMisc), 'tests.util.test_misc.TestMisc')
         self.assertEqual(most_qual_cls_name(ema),
-            'wc_utils.util.stats.ExponentialMovingAverage')
+                         'wc_utils.util.stats.ExponentialMovingAverage')
         self.assertEqual(most_qual_cls_name(ExponentialMovingAverage),
-            'wc_utils.util.stats.ExponentialMovingAverage')
-            
+                         'wc_utils.util.stats.ExponentialMovingAverage')
+
         try:
             # Fully qualified class names are available for Python >= 3.3.
             hasattr(self, '__qualname__')
@@ -42,9 +45,59 @@ def test_round_direct(self):
         self.assertEqual(round_direct(2.99, 1), '3.0-')
 
     def test_orderable_none(self):
+        self.assertTrue(OrderableNone < 1)
+        self.assertTrue(OrderableNone <= 1)
+        self.assertFalse(OrderableNone == 1)
+        self.assertFalse(OrderableNone >= 1)
+        self.assertFalse(OrderableNone > 1)
+
+        self.assertFalse(1 < OrderableNone)
+        self.assertFalse(1 <= OrderableNone)
+        self.assertFalse(1 == OrderableNone)
+        self.assertTrue(1 >= OrderableNone)
+        self.assertTrue(1 > OrderableNone)
+
+        self.assertFalse(OrderableNone < None)
+        self.assertTrue(OrderableNone <= None)
+        self.assertTrue(OrderableNone == None)
+        self.assertTrue(OrderableNone >= None)
+        self.assertFalse(OrderableNone > None)
+
+        self.assertFalse(None < OrderableNone)
+        self.assertTrue(None <= OrderableNone)
+        self.assertTrue(None == OrderableNone)
+        self.assertTrue(None >= OrderableNone)
+        self.assertFalse(None > OrderableNone)
+
+        self.assertFalse(OrderableNone < OrderableNone)
+        self.assertTrue(OrderableNone <= OrderableNone)
+        self.assertTrue(OrderableNone == OrderableNone)
+        self.assertTrue(OrderableNone >= OrderableNone)
+        self.assertFalse(OrderableNone > OrderableNone)
+
+        self.assertFalse(OrderableNone < OrderableNone)
+        self.assertTrue(OrderableNone <= OrderableNone)
+        self.assertTrue(OrderableNone == OrderableNone)
+        self.assertTrue(OrderableNone >= OrderableNone)
+        self.assertFalse(OrderableNone > OrderableNone)
+
         x = [1, 3, 2, OrderableNone]
         y = sorted(x)
-        self.assertEqual(x[0], OrderableNone)
-        self.assertEqual(x[1], 1)
-        self.assertEqual(x[2], 2)
-        self.assertEqual(x[3], 3)
+        self.assertEqual(y[0], OrderableNone)
+        self.assertEqual(y[1], 1)
+        self.assertEqual(y[2], 2)
+        self.assertEqual(y[3], 3)
+
+        x = [OrderableNone, 1, 3, 2]
+        y = sorted(x)
+        self.assertEqual(y[0], OrderableNone)
+        self.assertEqual(y[1], 1)
+        self.assertEqual(y[2], 2)
+        self.assertEqual(y[3], 3)
+
+        x = [3, 1, OrderableNone, 2]
+        y = sorted(x)
+        self.assertEqual(y[0], OrderableNone)
+        self.assertEqual(y[1], 1)
+        self.assertEqual(y[2], 2)
+        self.assertEqual(y[3], 3)

wc_utils/util/misc.py

@@ -7,7 +7,6 @@
 :License: MIT
 """
 
-from functools import total_ordering
 import sys
 
 
@@ -116,7 +115,6 @@ def quote(s):
         return s
 
 
-@total_ordering
 class OrderableNoneType(object):
     """ Type than can be used for sorting in Python 3 in place of :obj:`None` """
 
@@ -129,5 +127,11 @@ def __le__(self, other):
     def __eq__(self, other):
         return (other is self) or (other is None)
 
+    def __ge__(self, other):
+        return (other is self) or (other is None)
+
+    def __gt__(self, other):
+        return False
+
 OrderableNone = OrderableNoneType()
 # Object than can be used for sorting in Python 3 in place of :obj:`None`