Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/python/test/test_util.py

-# -*- test-case-name: twisted.test.test_util -*-
-# Copyright (c) 2001-2008 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-import os.path, sys
-import shutil, errno
-try:
-    import pwd, grp
-except ImportError:
-    pwd = grp = None
-
-from twisted.trial import unittest
-
-from twisted.python import util
-from twisted.internet import reactor
-from twisted.internet.interfaces import IReactorProcess
-from twisted.internet.protocol import ProcessProtocol
-from twisted.internet.defer import Deferred
-from twisted.internet.error import ProcessDone
-
-
-class UtilTestCase(unittest.TestCase):
-
-    def testUniq(self):
-        l = ["a", 1, "ab", "a", 3, 4, 1, 2, 2, 4, 6]
-        self.assertEquals(util.uniquify(l), ["a", 1, "ab", 3, 4, 2, 6])
-
-    def testRaises(self):
-        self.failUnless(util.raises(ZeroDivisionError, divmod, 1, 0))
-        self.failIf(util.raises(ZeroDivisionError, divmod, 0, 1))
-
-        try:
-            util.raises(TypeError, divmod, 1, 0)
-        except ZeroDivisionError:
-            pass
-        else:
-            raise unittest.FailTest, "util.raises didn't raise when it should have"
-
-    def testUninterruptably(self):
-        def f(a, b):
-            self.calls += 1
-            exc = self.exceptions.pop()
-            if exc is not None:
-                raise exc(errno.EINTR, "Interrupted system call!")
-            return a + b
-
-        self.exceptions = [None]
-        self.calls = 0
-        self.assertEquals(util.untilConcludes(f, 1, 2), 3)
-        self.assertEquals(self.calls, 1)
-
-        self.exceptions = [None, OSError, IOError]
-        self.calls = 0
-        self.assertEquals(util.untilConcludes(f, 2, 3), 5)
-        self.assertEquals(self.calls, 3)
-
-    def testUnsignedID(self):
-        util.id = lambda x: x
-        try:
-            for i in range(1, 100):
-                self.assertEquals(util.unsignedID(i), i)
-            top = (sys.maxint + 1L) * 2L
-            for i in range(-100, -1):
-                self.assertEquals(util.unsignedID(i), top + i)
-        finally:
-            del util.id
-
-    def testNameToLabel(self):
-        """
-        Test the various kinds of inputs L{nameToLabel} supports.
-        """
-        nameData = [
-            ('f', 'F'),
-            ('fo', 'Fo'),
-            ('foo', 'Foo'),
-            ('fooBar', 'Foo Bar'),
-            ('fooBarBaz', 'Foo Bar Baz'),
-            ]
-        for inp, out in nameData:
-            got = util.nameToLabel(inp)
-            self.assertEquals(
-                got, out,
-                "nameToLabel(%r) == %r != %r" % (inp, got, out))
-
-
-    def test_uidFromNumericString(self):
-        """
-        When L{uidFromString} is called with a base-ten string representation
-        of an integer, it returns the integer.
-        """
-        self.assertEqual(util.uidFromString("100"), 100)
-
-
-    def test_uidFromUsernameString(self):
-        """
-        When L{uidFromString} is called with a base-ten string representation
-        of an integer, it returns the integer.
-        """
-        pwent = pwd.getpwuid(os.getuid())
-        self.assertEqual(util.uidFromString(pwent.pw_name), pwent.pw_uid)
-    if pwd is None:
-        test_uidFromUsernameString.skip = (
-            "Username/UID conversion requires the pwd module.")
-
-
-    def test_gidFromNumericString(self):
-        """
-        When L{gidFromString} is called with a base-ten string representation
-        of an integer, it returns the integer.
-        """
-        self.assertEqual(util.gidFromString("100"), 100)
-
-
-    def test_gidFromGroupnameString(self):
-        """
-        When L{gidFromString} is called with a base-ten string representation
-        of an integer, it returns the integer.
-        """
-        grent = grp.getgrgid(os.getgid())
-        self.assertEqual(util.gidFromString(grent.gr_name), grent.gr_gid)
-    if grp is None:
-        test_gidFromGroupnameString.skip = (
-            "Group Name/GID conversion requires the grp module.")
-
-
-
-class TestMergeFunctionMetadata(unittest.TestCase):
-    """
-    Tests for L{mergeFunctionMetadata}.
-    """
-
-    def test_mergedFunctionBehavesLikeMergeTarget(self):
-        """
-        After merging C{foo}'s data into C{bar}, the returned function behaves
-        as if it is C{bar}.
-        """
-        foo_object = object()
-        bar_object = object()
-
-        def foo():
-            return foo_object
-
-        def bar(x, y, (a, b), c=10, *d, **e):
-            return bar_object
-
-        baz = util.mergeFunctionMetadata(foo, bar)
-        self.assertIdentical(baz(1, 2, (3, 4), quux=10), bar_object)
-
-
-    def test_moduleIsMerged(self):
-        """
-        Merging C{foo} into C{bar} returns a function with C{foo}'s
-        C{__module__}.
-        """
-        def foo():
-            pass
-
-        def bar():
-            pass
-        bar.__module__ = 'somewhere.else'
-
-        baz = util.mergeFunctionMetadata(foo, bar)
-        self.assertEqual(baz.__module__, foo.__module__)
-
-
-    def test_docstringIsMerged(self):
-        """
-        Merging C{foo} into C{bar} returns a function with C{foo}'s docstring.
-        """
-
-        def foo():
-            """
-            This is foo.
-            """
-
-        def bar():
-            """
-            This is bar.
-            """
-
-        baz = util.mergeFunctionMetadata(foo, bar)
-        self.assertEqual(baz.__doc__, foo.__doc__)
-
-
-    def test_nameIsMerged(self):
-        """
-        Merging C{foo} into C{bar} returns a function with C{foo}'s name.
-        """
-
-        def foo():
-            pass
-
-        def bar():
-            pass
-
-        baz = util.mergeFunctionMetadata(foo, bar)
-        self.assertEqual(baz.__name__, foo.__name__)
-
-
-    def test_instanceDictionaryIsMerged(self):
-        """
-        Merging C{foo} into C{bar} returns a function with C{bar}'s
-        dictionary, updated by C{foo}'s.
-        """
-
-        def foo():
-            pass
-        foo.a = 1
-        foo.b = 2
-
-        def bar():
-            pass
-        bar.b = 3
-        bar.c = 4
-
-        baz = util.mergeFunctionMetadata(foo, bar)
-        self.assertEqual(foo.a, baz.a)
-        self.assertEqual(foo.b, baz.b)
-        self.assertEqual(bar.c, baz.c)
-
-
-
-class OrderedDictTest(unittest.TestCase):
-    def testOrderedDict(self):
-        d = util.OrderedDict()
-        d['a'] = 'b'
-        d['b'] = 'a'
-        d[3] = 12
-        d[1234] = 4321
-        self.assertEquals(repr(d), "{'a': 'b', 'b': 'a', 3: 12, 1234: 4321}")
-        self.assertEquals(d.values(), ['b', 'a', 12, 4321])
-        del d[3]
-        self.assertEquals(repr(d), "{'a': 'b', 'b': 'a', 1234: 4321}")
-        self.assertEquals(d, {'a': 'b', 'b': 'a', 1234:4321})
-        self.assertEquals(d.keys(), ['a', 'b', 1234])
-        self.assertEquals(list(d.iteritems()),
-                          [('a', 'b'), ('b','a'), (1234, 4321)])
-        item = d.popitem()
-        self.assertEquals(item, (1234, 4321))
-
-    def testInitialization(self):
-        d = util.OrderedDict({'monkey': 'ook',
-                              'apple': 'red'})
-        self.failUnless(d._order)
-
-        d = util.OrderedDict(((1,1),(3,3),(2,2),(0,0)))
-        self.assertEquals(repr(d), "{1: 1, 3: 3, 2: 2, 0: 0}")
-
-class InsensitiveDictTest(unittest.TestCase):
-    def testPreserve(self):
-        InsensitiveDict=util.InsensitiveDict
-        dct=InsensitiveDict({'Foo':'bar', 1:2, 'fnz':{1:2}}, preserve=1)
-        self.assertEquals(dct['fnz'], {1:2})
-        self.assertEquals(dct['foo'], 'bar')
-        self.assertEquals(dct.copy(), dct)
-        self.assertEquals(dct['foo'], dct.get('Foo'))
-        assert 1 in dct and 'foo' in dct
-        self.assertEquals(eval(repr(dct)), dct)
-        keys=['Foo', 'fnz', 1]
-        for x in keys:
-            assert x in dct.keys()
-            assert (x, dct[x]) in dct.items()
-        self.assertEquals(len(keys), len(dct))
-        del dct[1]
-        del dct['foo']
-
-    def testNoPreserve(self):
-        InsensitiveDict=util.InsensitiveDict
-        dct=InsensitiveDict({'Foo':'bar', 1:2, 'fnz':{1:2}}, preserve=0)
-        keys=['foo', 'fnz', 1]
-        for x in keys:
-            assert x in dct.keys()
-            assert (x, dct[x]) in dct.items()
-        self.assertEquals(len(keys), len(dct))
-        del dct[1]
-        del dct['foo']
-
-
-
-
-class PasswordTestingProcessProtocol(ProcessProtocol):
-    """
-    Write the string C{"secret\n"} to a subprocess and then collect all of
-    its output and fire a Deferred with it when the process ends.
-    """
-    def connectionMade(self):
-        self.output = []
-        self.transport.write('secret\n')
-
-    def childDataReceived(self, fd, output):
-        self.output.append((fd, output))
-
-    def processEnded(self, reason):
-        self.finished.callback((reason, self.output))
-
-
-class GetPasswordTest(unittest.TestCase):
-    if not IReactorProcess.providedBy(reactor):
-        skip = "Process support required to test getPassword"
-
-    def test_stdin(self):
-        """
-        Making sure getPassword accepts a password from standard input by
-        running a child process which uses getPassword to read in a string
-        which it then writes it out again.  Write a string to the child
-        process and then read one and make sure it is the right string.
-        """
-        p = PasswordTestingProcessProtocol()
-        p.finished = Deferred()
-        reactor.spawnProcess(
-            p,
-            sys.executable,
-            [sys.executable,
-             '-c',
-             ('import sys\n'
-             'from twisted.python.util import getPassword\n'
-              'sys.stdout.write(getPassword())\n'
-              'sys.stdout.flush()\n')],
-            env={'PYTHONPATH': os.pathsep.join(sys.path)})
-
-        def processFinished((reason, output)):
-            reason.trap(ProcessDone)
-            self.assertIn((1, 'secret'), output)
-
-        return p.finished.addCallback(processFinished)
-
-
-
-class SearchUpwardsTest(unittest.TestCase):
-    def testSearchupwards(self):
-        os.makedirs('searchupwards/a/b/c')
-        file('searchupwards/foo.txt', 'w').close()
-        file('searchupwards/a/foo.txt', 'w').close()
-        file('searchupwards/a/b/c/foo.txt', 'w').close()
-        os.mkdir('searchupwards/bar')
-        os.mkdir('searchupwards/bam')
-        os.mkdir('searchupwards/a/bar')
-        os.mkdir('searchupwards/a/b/bam')
-        actual=util.searchupwards('searchupwards/a/b/c',
-                                  files=['foo.txt'],
-                                  dirs=['bar', 'bam'])
-        expected=os.path.abspath('searchupwards') + os.sep
-        self.assertEqual(actual, expected)
-        shutil.rmtree('searchupwards')
-        actual=util.searchupwards('searchupwards/a/b/c',
-                                  files=['foo.txt'],
-                                  dirs=['bar', 'bam'])
-        expected=None
-        self.assertEqual(actual, expected)
-
-class Foo:
-    def __init__(self, x):
-        self.x = x
-
-class DSU(unittest.TestCase):
-    def testDSU(self):
-        L = [Foo(x) for x in range(20, 9, -1)]
-        L2 = util.dsu(L, lambda o: o.x)
-        self.assertEquals(range(10, 21), [o.x for o in L2])
-
-class IntervalDifferentialTestCase(unittest.TestCase):
-    def testDefault(self):
-        d = iter(util.IntervalDifferential([], 10))
-        for i in range(100):
-            self.assertEquals(d.next(), (10, None))
-
-    def testSingle(self):
-        d = iter(util.IntervalDifferential([5], 10))
-        for i in range(100):
-            self.assertEquals(d.next(), (5, 0))
-
-    def testPair(self):
-        d = iter(util.IntervalDifferential([5, 7], 10))
-        for i in range(100):
-            self.assertEquals(d.next(), (5, 0))
-            self.assertEquals(d.next(), (2, 1))
-            self.assertEquals(d.next(), (3, 0))
-            self.assertEquals(d.next(), (4, 1))
-            self.assertEquals(d.next(), (1, 0))
-            self.assertEquals(d.next(), (5, 0))
-            self.assertEquals(d.next(), (1, 1))
-            self.assertEquals(d.next(), (4, 0))
-            self.assertEquals(d.next(), (3, 1))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (5, 0))
-            self.assertEquals(d.next(), (0, 1))
-
-    def testTriple(self):
-        d = iter(util.IntervalDifferential([2, 4, 5], 10))
-        for i in range(100):
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (0, 1))
-            self.assertEquals(d.next(), (1, 2))
-            self.assertEquals(d.next(), (1, 0))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (0, 1))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (0, 2))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (0, 1))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (1, 2))
-            self.assertEquals(d.next(), (1, 0))
-            self.assertEquals(d.next(), (0, 1))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (2, 0))
-            self.assertEquals(d.next(), (0, 1))
-            self.assertEquals(d.next(), (0, 2))
-
-    def testInsert(self):
-        d = iter(util.IntervalDifferential([], 10))
-        self.assertEquals(d.next(), (10, None))
-        d.addInterval(3)
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (3, 0))
-        d.addInterval(6)
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (0, 1))
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (0, 1))
-
-    def testRemove(self):
-        d = iter(util.IntervalDifferential([3, 5], 10))
-        self.assertEquals(d.next(), (3, 0))
-        self.assertEquals(d.next(), (2, 1))
-        self.assertEquals(d.next(), (1, 0))
-        d.removeInterval(3)
-        self.assertEquals(d.next(), (4, 0))
-        self.assertEquals(d.next(), (5, 0))
-        d.removeInterval(5)
-        self.assertEquals(d.next(), (10, None))
-        self.assertRaises(ValueError, d.removeInterval, 10)
-
-
-
-class Record(util.FancyEqMixin):
-    """
-    Trivial user of L{FancyEqMixin} used by tests.
-    """
-    compareAttributes = ('a', 'b')
-
-    def __init__(self, a, b):
-        self.a = a
-        self.b = b
-
-
-
-class DifferentRecord(util.FancyEqMixin):
-    """
-    Trivial user of L{FancyEqMixin} which is not related to L{Record}.
-    """
-    compareAttributes = ('a', 'b')
-
-    def __init__(self, a, b):
-        self.a = a
-        self.b = b
-
-
-
-class DerivedRecord(Record):
-    """
-    A class with an inheritance relationship to L{Record}.
-    """
-
-
-
-class EqualToEverything(object):
-    """
-    A class the instances of which consider themselves equal to everything.
-    """
-    def __eq__(self, other):
-        return True
-
-
-    def __ne__(self, other):
-        return False
-
-
-
-class EqualToNothing(object):
-    """
-    A class the instances of which consider themselves equal to nothing.
-    """
-    def __eq__(self, other):
-        return False
-
-
-    def __ne__(self, other):
-        return True
-
-
-
-class EqualityTests(unittest.TestCase):
-    """
-    Tests for L{FancyEqMixin}.
-    """
-    def test_identity(self):
-        """
-        Instances of a class which mixes in L{FancyEqMixin} but which
-        defines no comparison attributes compare by identity.
-        """
-        class Empty(util.FancyEqMixin):
-            pass
-
-        self.assertFalse(Empty() == Empty())
-        self.assertTrue(Empty() != Empty())
-        empty = Empty()
-        self.assertTrue(empty == empty)
-        self.assertFalse(empty != empty)
-
-
-    def test_equality(self):
-        """
-        Instances of a class which mixes in L{FancyEqMixin} should compare
-        equal if all of their attributes compare equal.  They should not
-        compare equal if any of their attributes do not compare equal.
-        """
-        self.assertTrue(Record(1, 2) == Record(1, 2))
-        self.assertFalse(Record(1, 2) == Record(1, 3))
-        self.assertFalse(Record(1, 2) == Record(2, 2))
-        self.assertFalse(Record(1, 2) == Record(3, 4))
-
-
-    def test_unequality(self):
-        """
-        Unequality between instances of a particular L{record} should be
-        defined as the negation of equality.
-        """
-        self.assertFalse(Record(1, 2) != Record(1, 2))
-        self.assertTrue(Record(1, 2) != Record(1, 3))
-        self.assertTrue(Record(1, 2) != Record(2, 2))
-        self.assertTrue(Record(1, 2) != Record(3, 4))
-
-
-    def test_differentClassesEquality(self):
-        """
-        Instances of different classes which mix in L{FancyEqMixin} should not
-        compare equal.
-        """
-        self.assertFalse(Record(1, 2) == DifferentRecord(1, 2))
-
-
-    def test_differentClassesInequality(self):
-        """
-        Instances of different classes which mix in L{FancyEqMixin} should
-        compare unequal.
-        """
-        self.assertTrue(Record(1, 2) != DifferentRecord(1, 2))
-
-
-    def test_inheritedClassesEquality(self):
-        """
-        An instance of a class which derives from a class which mixes in
-        L{FancyEqMixin} should compare equal to an instance of the base class
-        if and only if all of their attributes compare equal.
-        """
-        self.assertTrue(Record(1, 2) == DerivedRecord(1, 2))
-        self.assertFalse(Record(1, 2) == DerivedRecord(1, 3))
-        self.assertFalse(Record(1, 2) == DerivedRecord(2, 2))
-        self.assertFalse(Record(1, 2) == DerivedRecord(3, 4))
-
-
-    def test_inheritedClassesInequality(self):
-        """
-        An instance of a class which derives from a class which mixes in
-        L{FancyEqMixin} should compare unequal to an instance of the base
-        class if any of their attributes compare unequal.
-        """
-        self.assertFalse(Record(1, 2) != DerivedRecord(1, 2))
-        self.assertTrue(Record(1, 2) != DerivedRecord(1, 3))
-        self.assertTrue(Record(1, 2) != DerivedRecord(2, 2))
-        self.assertTrue(Record(1, 2) != DerivedRecord(3, 4))
-
-
-    def test_rightHandArgumentImplementsEquality(self):
-        """
-        The right-hand argument to the equality operator is given a chance
-        to determine the result of the operation if it is of a type
-        unrelated to the L{FancyEqMixin}-based instance on the left-hand
-        side.
-        """
-        self.assertTrue(Record(1, 2) == EqualToEverything())
-        self.assertFalse(Record(1, 2) == EqualToNothing())
-
-
-    def test_rightHandArgumentImplementsUnequality(self):
-        """
-        The right-hand argument to the non-equality operator is given a
-        chance to determine the result of the operation if it is of a type
-        unrelated to the L{FancyEqMixin}-based instance on the left-hand
-        side.
-        """
-        self.assertFalse(Record(1, 2) != EqualToEverything())
-        self.assertTrue(Record(1, 2) != EqualToNothing())