Python test_support.due_to_ironpython_bug函数代码示例

    def testTwoResults(self):
        if due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            return

        unittest.installHandler()

        result = unittest.TestResult()
        unittest.registerResult(result)
        new_handler = signal.getsignal(signal.SIGINT)

        result2 = unittest.TestResult()
        unittest.registerResult(result2)
        self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)

        result3 = unittest.TestResult()

        def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)

        try:
            test(result)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")

        if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            self.assertTrue(result.shouldStop)
            self.assertTrue(result2.shouldStop)
        self.assertFalse(result3.shouldStop)

 def test_none_assignment(self):
     stmts = [
         "None = 0",
         "None += 0",
         "__builtins__.None = 0",
         "def None(): pass",
         "class None: pass",
         "(a, None) = 0, 0",
         "for None in range(10): pass",
         "def f(None): pass",
         "import None",
         "import x as None",
         "from x import None",
         "from x import y as None",
     ]
     for stmt in stmts:
         stmt += "\n"
         if not test_support.due_to_ironpython_bug(
             "http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=314864"
         ):
             self.assertRaises(SyntaxError, compile, stmt, "tmp", "single")
             self.assertRaises(SyntaxError, compile, stmt, "tmp", "exec")
     if test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
         return
     # This is ok.
     compile("from None import x", "tmp", "exec")
     compile("from x import None as y", "tmp", "exec")
     compile("import None as x", "tmp", "exec")

    def test__format__(self):
        def test(value, format, expected):
            # test both with and without the trailing 's'
            self.assertEqual(value.__format__(format), expected)
            self.assertEqual(value.__format__(format + 's'), expected)

        test('', '', '')
        test('abc', '', 'abc')
        test('abc', '.3', 'abc')
        test('ab', '.3', 'ab')
        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            test('abcdef', '.3', 'abc')
            test('abcdef', '.0', '')
        test('abc', '3.3', 'abc')
        test('abc', '2.3', 'abc')
        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            test('abc', '2.2', 'ab')
            test('abc', '3.2', 'ab ')
        test('result', 'x<0', 'result')
        test('result', 'x<5', 'result')
        test('result', 'x<6', 'result')
        if test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            return
        test('result', 'x<7', 'resultx')
        test('result', 'x<8', 'resultxx')
        test('result', ' <7', 'result ')
        test('result', '<7', 'result ')
        test('result', '>7', ' result')
        test('result', '>8', '  result')
        test('result', '^8', ' result ')
        test('result', '^9', ' result  ')
        test('result', '^10', '  result  ')
        test('a', '10000', 'a' + ' ' * 9999)
        test('', '10000', ' ' * 10000)
        test('', '10000000', ' ' * 10000000)

    def testSecondInterrupt(self):
        if due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            return

        result = unittest.TestResult()
        unittest.installHandler()
        unittest.registerResult(result)

        def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
            result.breakCaught = True
            if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
                self.assertTrue(result.shouldStop)
            os.kill(pid, signal.SIGINT)
            if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
                self.fail("Second KeyboardInterrupt not raised")

        try:
            test(result)
        except KeyboardInterrupt:
            pass
        else:
            if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
                self.fail("Second KeyboardInterrupt not raised")
        self.assertTrue(result.breakCaught)

    def testGetSetAndDel(self):
        # Interfering tests
        class ExtraTests(AllTests):
            @trackCall
            def __getattr__(self, *args):
                return "SomeVal"

            @trackCall
            def __setattr__(self, *args):
                pass

            @trackCall
            def __delattr__(self, *args):
                pass

        testme = ExtraTests()

        callLst[:] = []
        testme.spam
        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            self.assertCallStack([('__getattr__', (testme, "spam"))])

        callLst[:] = []
        testme.eggs = "spam, spam, spam and ham"
        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            self.assertCallStack([('__setattr__', (testme, "eggs",
                                                   "spam, spam, spam and ham"))])

        callLst[:] = []
        del testme.cardinal
        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"):
            self.assertCallStack([('__delattr__', (testme, "cardinal"))])

    def test_format_auto_numbering(self):
        class C:
            def __init__(self, x=100):
                self._x = x
            def __format__(self, spec):
                return spec

        self.assertEqual('{}'.format(10), '10')
        self.assertEqual('{:5}'.format('s'), 's    ')
        self.assertEqual('{!r}'.format('s'), "'s'")
        self.assertEqual('{._x}'.format(C(10)), '10')
        self.assertEqual('{[1]}'.format([1, 2]), '2')
        self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4')
        self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c')

        if not test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            self.assertEqual('a{:{}}b'.format('x', '^10'), 'a    x     b')
            self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b')

        # can't mix and match numbering and auto-numbering
        self.assertRaises(ValueError, '{}{1}'.format, 1, 2)
        self.assertRaises(ValueError, '{1}{}'.format, 1, 2)
        if not test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            self.assertRaises(ValueError, '{:{1}}'.format, 1, 2)
            self.assertRaises(ValueError, '{0:{}}'.format, 1, 2)

        # can mix and match auto-numbering and named
        self.assertEqual('{f}{}'.format(4, f='test'), 'test4')
        self.assertEqual('{}{f}'.format(4, f='test'), '4test')
        self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
        if not test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
            self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')

    def _do_single(self, filename):
        self.assertTrue(os.path.exists(filename))
        self.assertTrue(os.path.isfile(filename))
        self.assertTrue(os.access(filename, os.R_OK))
        self.assertTrue(os.path.exists(os.path.abspath(filename)))
        self.assertTrue(os.path.isfile(os.path.abspath(filename)))
        self.assertTrue(os.access(os.path.abspath(filename), os.R_OK))
        if not test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=363042"):
            os.chmod(filename, 0777)
        os.utime(filename, None)
        os.utime(filename, (time.time(), time.time()))
        # Copy/rename etc tests using the same filename
        self._do_copyish(filename, filename)
        # Filename should appear in glob output
        self.assertTrue(
            os.path.abspath(filename)==os.path.abspath(glob.glob(filename)[0]))
        # basename should appear in listdir.
        path, base = os.path.split(os.path.abspath(filename))
        if isinstance(base, str):
            base = base.decode(TESTFN_ENCODING)
        file_list = os.listdir(path)
        # listdir() with a unicode arg may or may not return Unicode
        # objects, depending on the platform.
        if file_list and isinstance(file_list[0], str):
            file_list = [f.decode(TESTFN_ENCODING) for f in file_list]

        # Normalize the unicode strings, as round-tripping the name via the OS
        # may return a different (but equivalent) value.
        if not test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=303481"):
            base = unicodedata.normalize("NFD", base)
            file_list = [unicodedata.normalize("NFD", f) for f in file_list]

            self.assertIn(base, file_list)

    def test_hangul_syllables(self):
        if test_support.due_to_ironpython_bug(
            "http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=323261"
        ):
            return
        self.checkletter("HANGUL SYLLABLE GA", u"\uac00")
        self.checkletter("HANGUL SYLLABLE GGWEOSS", u"\uafe8")
        self.checkletter("HANGUL SYLLABLE DOLS", u"\ub3d0")
        self.checkletter("HANGUL SYLLABLE RYAN", u"\ub7b8")
        self.checkletter("HANGUL SYLLABLE MWIK", u"\ubba0")
        self.checkletter("HANGUL SYLLABLE BBWAEM", u"\ubf88")
        self.checkletter("HANGUL SYLLABLE SSEOL", u"\uc370")
        self.checkletter("HANGUL SYLLABLE YI", u"\uc758")
        self.checkletter("HANGUL SYLLABLE JJYOSS", u"\ucb40")
        self.checkletter("HANGUL SYLLABLE KYEOLS", u"\ucf28")
        self.checkletter("HANGUL SYLLABLE PAN", u"\ud310")
        self.checkletter("HANGUL SYLLABLE HWEOK", u"\ud6f8")
        self.checkletter("HANGUL SYLLABLE HIH", u"\ud7a3")

        # no unicodedata module
        if test_support.due_to_ironpython_bug(
            "http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=303481"
        ):
            return
        import unicodedata

        self.assertRaises(ValueError, unicodedata.name, u"\ud7a4")

    def test_1(self):
        from sys import getrefcount as grc

        f = dll._testfunc_callback_i_if
        f.restype = ctypes.c_int
        f.argtypes = [ctypes.c_int, MyCallback]

        def callback(value):
            #print "called back with", value
            return value

        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=22374"):
            self.assertEqual(grc(callback), 2)
        cb = MyCallback(callback)

        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=22374"):
            self.assertTrue(grc(callback) > 2)
        result = f(-10, cb)
        self.assertEqual(result, -18)
        cb = None

        gc.collect()

        if not test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=22374"):
            self.assertEqual(grc(callback), 2)

 def test_returned_value(self):
     # Limit to the minimum of all limits (b2a_uu)
     if self.type2test is not str and test_support.due_to_ironpython_bug(
         "http://ironpython.codeplex.com/workitem/28171"
     ):
         return
     MAX_ALL = 45
     raw = self.rawdata[:MAX_ALL]
     for fa, fb in zip(a2b_functions, b2a_functions):
         a2b = getattr(binascii, fa)
         b2a = getattr(binascii, fb)
         try:
             if test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
                 if "hqx" in fa or "qp" in fa:
                     continue
             a = b2a(self.type2test(raw))
             res = a2b(self.type2test(a))
         except Exception, err:
             self.fail("{}/{} conversion raises {!r}".format(fb, fa, err))
         if fb == "b2a_hqx":
             # b2a_hqx returns a tuple
             res, _ = res
         self.assertEqual(res, raw, "{}/{} conversion: " "{!r} != {!r}".format(fb, fa, res, raw))
         self.assertIsInstance(res, str)
         self.assertIsInstance(a, str)
         self.assertLess(max(ord(c) for c in a), 128)

    def test_infix_binops(self):
        for ia, a in enumerate(candidates):
            for ib, b in enumerate(candidates):
                results = infix_results[(ia, ib)]
                for op, res, ires in zip(infix_binops, results[0], results[1]):
                    if res is TE:
                        if not due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=299894"):                                   
                            self.assertRaises(TypeError, eval,
                                              'a %s b' % op, {'a': a, 'b': b})
                    else:
                        self.assertEquals(format_result(res),
                                          format_result(eval('a %s b' % op)),
                                          '%s %s %s == %s failed' % (a, op, b, res))

                    if not due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=151094"):                                          
                        try:
                            z = copy.copy(a)
                        except copy.Error:
                            z = a # assume it has no inplace ops
                        if ires is TE:
                            try:
                                exec 'z %s= b' % op
                            except TypeError:
                                pass
                            else:
                                self.fail("TypeError not raised")
                        else:
                            exec('z %s= b' % op)
                            self.assertEquals(ires, z)

 def test_special_escapes(self):
     self.assertEqual(re.search(r"\b(b.)\b",
                                "abcd abc bcd bx").group(1), "bx")
     if not due_to_ironpython_bug("http://vstfdevdiv:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=306834"):
         self.assertEqual(re.search(r"\B(b.)\B",
                                    "abc bcd bc abxd").group(1), "bx")
     self.assertEqual(re.search(r"\b(b.)\b",
                                "abcd abc bcd bx", re.LOCALE).group(1), "bx")
     if not due_to_ironpython_bug("http://vstfdevdiv:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=306834"):
         self.assertEqual(re.search(r"\B(b.)\B",
                                    "abc bcd bc abxd", re.LOCALE).group(1), "bx")
     self.assertEqual(re.search(r"\b(b.)\b",
                                "abcd abc bcd bx", re.UNICODE).group(1), "bx")
     if not due_to_ironpython_bug("http://vstfdevdiv:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=306834"):
         self.assertEqual(re.search(r"\B(b.)\B",
                                    "abc bcd bc abxd", re.UNICODE).group(1), "bx")
     self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
     self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
     self.assertEqual(re.search(r"^\Aabc\Z$", "\nabc\n", re.M), None)
     self.assertEqual(re.search(r"\b(b.)\b",
                                u"abcd abc bcd bx").group(1), "bx")
     if not due_to_ironpython_bug("http://vstfdevdiv:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=306834"):
         self.assertEqual(re.search(r"\B(b.)\B",
                                    u"abc bcd bc abxd").group(1), "bx")
     self.assertEqual(re.search(r"^abc$", u"\nabc\n", re.M).group(0), "abc")
     self.assertEqual(re.search(r"^\Aabc\Z$", u"abc", re.M).group(0), "abc")
     self.assertEqual(re.search(r"^\Aabc\Z$", u"\nabc\n", re.M), None)
     self.assertEqual(re.search(r"\d\D\w\W\s\S",
                                "1aa! a").group(0), "1aa! a")
     self.assertEqual(re.search(r"\d\D\w\W\s\S",
                                "1aa! a", re.LOCALE).group(0), "1aa! a")
     self.assertEqual(re.search(r"\d\D\w\W\s\S",
                                "1aa! a", re.UNICODE).group(0), "1aa! a")

def test_main():
    import ctypes.test

    skipped, testcases = ctypes.test.get_tests(ctypes.test, "test_*.py", verbosity=0)
    suites = [unittest.makeSuite(t) for t in testcases]

    if due_to_ironpython_bug("http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=374"):
        for suite in suites:
            length = len(suite._tests)
            i = 0
            while i < length:
                if suite._tests[i].id() in IRONPYTHON_DISABLED_LIST:
                    suite._tests.pop(i)
                    i -= 1
                    length -= 1
                i += 1

    try:
        run_unittest(unittest.TestSuite(suites))
    finally:
        if due_to_ironpython_bug("http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=22393"):
            try:
                System.IO.File.Delete(nt.getcwd() + r"\Python26.dll")
            except:
                pass
            print "%d of these test cases were disabled under IronPython." % len(IRONPYTHON_DISABLED_LIST)

 def test(result):
     pid = os.getpid()
     os.kill(pid, signal.SIGINT)
     result.breakCaught = True
     if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
         self.assertTrue(result.shouldStop)
     os.kill(pid, signal.SIGINT)
     if not due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
         self.fail("Second KeyboardInterrupt not raised")

 def tearDown(self):
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=317178"):
         return
     sys.version = self.save_version
     sys.subversion = self.save_subversion
     sys.platform = self.save_platform
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=317178"):
         return
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=317178"):
         return