move test into a unittest.TestCase, no functional changes

Lib/test/test_sort.py

-from test.test_support import verbose
+from test import test_support
 import random
-from UserList import UserList
+import sys
+import unittest
 
+verbose = test_support.verbose
 nerrors = 0
 
 def check(tag, expected, raw, compare=None):
@@ -36,91 +38,88 @@ def check(tag, expected, raw, compare=None):
             nerrors += 1
             return
 
-# Try a variety of sizes at and around powers of 2, and at powers of 10.
-sizes = [0]
-for power in range(1, 10):
-    n = 2 ** power
-    sizes.extend(range(n-1, n+2))
-sizes.extend([10, 100, 1000])
-
-class Complains(object):
-    maybe_complain = True
+class TestBase(unittest.TestCase):
+    def testStressfully(self):
+        # Try a variety of sizes at and around powers of 2, and at powers of 10.
+        sizes = [0]
+        for power in range(1, 10):
+            n = 2 ** power
+            sizes.extend(range(n-1, n+2))
+        sizes.extend([10, 100, 1000])
 
-    def __init__(self, i):
-        self.i = i
+        class Complains(object):
+            maybe_complain = True
 
-    def __lt__(self, other):
-        if Complains.maybe_complain and random.random() < 0.001:
-            if verbose:
-                print "        complaining at", self, other
-            raise RuntimeError
-        return self.i < other.i
+            def __init__(self, i):
+                self.i = i
 
-    def __repr__(self):
-        return "Complains(%d)" % self.i
+            def __lt__(self, other):
+                if Complains.maybe_complain and random.random() < 0.001:
+                    if verbose:
+                        print "        complaining at", self, other
+                    raise RuntimeError
+                return self.i < other.i
 
-class Stable(object):
-    def __init__(self, key, i):
-        self.key = key
-        self.index = i
+            def __repr__(self):
+                return "Complains(%d)" % self.i
 
-    def __cmp__(self, other):
-        return cmp(self.key, other.key)
+        class Stable(object):
+            def __init__(self, key, i):
+                self.key = key
+                self.index = i
 
-    def __repr__(self):
-        return "Stable(%d, %d)" % (self.key, self.index)
+            def __cmp__(self, other):
+                return cmp(self.key, other.key)
 
-for n in sizes:
-    x = range(n)
-    if verbose:
-        print "Testing size", n
+            def __repr__(self):
+                return "Stable(%d, %d)" % (self.key, self.index)
 
-    s = x[:]
-    check("identity", x, s)
-
-    s = x[:]
-    s.reverse()
-    check("reversed", x, s)
+        for n in sizes:
+            x = range(n)
+            if verbose:
+                print "Testing size", n
 
-    s = x[:]
-    random.shuffle(s)
-    check("random permutation", x, s)
+            s = x[:]
+            check("identity", x, s)
 
-    y = x[:]
-    y.reverse()
-    s = x[:]
-    check("reversed via function", y, s, lambda a, b: cmp(b, a))
+            s = x[:]
+            s.reverse()
+            check("reversed", x, s)
 
-    if verbose:
-        print "    Checking against an insane comparison function."
-        print "        If the implementation isn't careful, this may segfault."
-    s = x[:]
-    s.sort(lambda a, b:  int(random.random() * 3) - 1)
-    check("an insane function left some permutation", x, s)
-
-    x = [Complains(i) for i in x]
-    s = x[:]
-    random.shuffle(s)
-    Complains.maybe_complain = True
-    it_complained = False
-    try:
-        s.sort()
-    except RuntimeError:
-        it_complained = True
-    if it_complained:
-        Complains.maybe_complain = False
-        check("exception during sort left some permutation", x, s)
-
-    s = [Stable(random.randrange(10), i) for i in xrange(n)]
-    augmented = [(e, e.index) for e in s]
-    augmented.sort()    # forced stable because ties broken by index
-    x = [e for e, i in augmented] # a stable sort of s
-    check("stability", x, s)
+            s = x[:]
+            random.shuffle(s)
+            check("random permutation", x, s)
 
+            y = x[:]
+            y.reverse()
+            s = x[:]
+            check("reversed via function", y, s, lambda a, b: cmp(b, a))
 
-import unittest
-from test import test_support
-import sys
+            if verbose:
+                print "    Checking against an insane comparison function."
+                print "        If the implementation isn't careful, this may segfault."
+            s = x[:]
+            s.sort(lambda a, b:  int(random.random() * 3) - 1)
+            check("an insane function left some permutation", x, s)
+
+            x = [Complains(i) for i in x]
+            s = x[:]
+            random.shuffle(s)
+            Complains.maybe_complain = True
+            it_complained = False
+            try:
+                s.sort()
+            except RuntimeError:
+                it_complained = True
+            if it_complained:
+                Complains.maybe_complain = False
+                check("exception during sort left some permutation", x, s)
+
+            s = [Stable(random.randrange(10), i) for i in xrange(n)]
+            augmented = [(e, e.index) for e in s]
+            augmented.sort()    # forced stable because ties broken by index
+            x = [e for e, i in augmented] # a stable sort of s
+            check("stability", x, s)
 
 #==============================================================================
 
@@ -269,6 +268,7 @@ class TestDecorateSortUndecorate(unittest.TestCase):
 
 def test_main(verbose=None):
     test_classes = (
+        TestBase,
         TestDecorateSortUndecorate,
         TestBugs,
     )