def main():
    test_support.run_unittest(LockTests, RLockTests, EventTests,
                                   ConditionAsRLockTests, ConditionTests,
                                   SemaphoreTests, BoundedSemaphoreTests,
                                   ThreadTests,
                                   ThreadJoinOnShutdown,
                                   ThreadingExceptionTests,
                                   )

def test_main(verbose=None):
    NamedTupleDocs = doctest.DocTestSuite(module=collections)
    test_classes = [
        TestNamedTuple,
        NamedTupleDocs,
        TestOneTrickPonyABCs,
        TestCollectionABCs,
        TestCounter,
        TestOrderedDict,
        GeneralMappingTests,
        SubclassMappingTests,
    ]
    test_support.run_unittest(*test_classes)
    test_support.run_doctest(collections, verbose)

def test_main(verbose=None):
    import sys

    test_classes = (TestBasic, TestVariousIteratorArgs, TestSubclass, TestSubclassWithKwargs)

    test_support.run_unittest(*test_classes)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        import gc

        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*test_classes)
            gc.collect()
            counts[i] = sys.gettotalrefcount()
        print counts

    # doctests
    import test_deque

    test_support.run_doctest(test_deque, verbose)

def test_main():
    import sys
    test_support.run_unittest(TestSubclasses)

def test_main():
    test_support.run_unittest(MessageTestCase)

def test_main():
    test_support.run_unittest(ImportHooksTestCase)

def test_main():
    test_support.run_unittest(QueueTest, LifoQueueTest, PriorityQueueTest,
                              FailingQueueTest)

def test_main():
    run_unittest(CommandTests)

            old = None
        lst = []
        try:
            def trace(frame, ev, arg):
                lst.append((frame.f_code.co_filename, frame.f_lineno, ev))
                six.print_("TRACE: %s:%s %s" % lst[-1])
                return trace

            with gevent.thread.allocate_lock():
                sys.settrace(trace)
        finally:
            sys.settrace(old)

        self.failUnless(lst == [], "trace not empty")

    def run_script(self, more_args=[]):
        rc = subprocess.call([sys.executable, "-c", script] + more_args)
        self.failIf(rc == 2, "interpreter was blocked")
        self.failUnless(rc == 0, "Unexpected error")

    def test_finalize_with_trace(self):
        self.run_script()

    def test_bootstrap_inner_with_trace(self):
        self.run_script(["1"])


if __name__ == "__main__":
    import test_support
    test_support.run_unittest(ThreadTrace)

def test_main():
    test_support.run_unittest(JreloadTestCase)

def test_main():
    run_unittest(CodeopTests)

def testall():
    test_support.run_unittest(Test)

def test_main():
    run_unittest(GlobTests)

default login log2 password pass2 

"""

temp_filename = tempfile.mktemp()

class NetrcTestCase(unittest.TestCase):

    def setUp (self):
        fp = open(temp_filename, 'wt')
        fp.write(TEST_NETRC)
        fp.close()
        self.netrc = netrc.netrc(temp_filename)
        
    def tearDown (self):
        del self.netrc
        os.unlink(temp_filename)

    def test_case_1(self):
        self.assert_(self.netrc.macros == {'macro1':['line1\n', 'line2\n'],
                                           'macro2':['line3\n', 'line4\n']}
                                           )
        self.assert_(self.netrc.hosts['foo'] == ('log1', 'acct1', 'pass1'))
        self.assert_(self.netrc.hosts['default'] == ('log2', None, 'pass2'))
            
        
if __name__ == "__main__":
    test_support.run_unittest(NetrcTestCase)

def test_main():
    run_unittest(MhlibTests)

def test_main():
    try:
        test_support.run_unittest(DumbDBMTestCase)
    finally:
        _delete_files()

def test_main():
    run_unittest(CompileTests)

def test_main():
    run_unittest(PyclbrTest)

(double)
(double)
(double)
(double)
(float)
(java.io.Serializable)
(java.io.Serializable)
(java.io.Serializable)
(java.io.Serializable)
(java.io.Serializable)
(java.io.Serializable)
(java.lang.Object)     
                   """)


def printout(meth_dict,lbl,rng,args):
    for i in rng:
        print meth_dict['ov_%s%s' % (lbl,i)](jo,args)

import sys

if __name__ == '__main__' and not sys.argv[1:] == ['break-out']:
    try:
        import test_support
    except ImportError:
        unittest.main()
    else:
        test_support.run_unittest(OverloadedDispatchTests)
        
    

def test_main():
    test_support.run_unittest(HTMLParserTestCase)