Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 1 | import unittest |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 2 | from test import support |
Larry Hastings | 83a9f48 | 2012-03-20 20:06:16 +0000 | [diff] [blame] | 3 | from _testcapi import getargs_keywords, getargs_keyword_only |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 4 | |
| 5 | """ |
| 6 | > How about the following counterproposal. This also changes some of |
| 7 | > the other format codes to be a little more regular. |
| 8 | > |
| 9 | > Code C type Range check |
| 10 | > |
| 11 | > b unsigned char 0..UCHAR_MAX |
Guido van Rossum | bbb931b | 2003-04-18 00:13:53 +0000 | [diff] [blame] | 12 | > h signed short SHRT_MIN..SHRT_MAX |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 13 | > B unsigned char none ** |
| 14 | > H unsigned short none ** |
| 15 | > k * unsigned long none |
| 16 | > I * unsigned int 0..UINT_MAX |
| 17 | |
| 18 | |
| 19 | > i int INT_MIN..INT_MAX |
| 20 | > l long LONG_MIN..LONG_MAX |
| 21 | |
| 22 | > K * unsigned long long none |
| 23 | > L long long LLONG_MIN..LLONG_MAX |
| 24 | |
| 25 | > Notes: |
| 26 | > |
| 27 | > * New format codes. |
| 28 | > |
| 29 | > ** Changed from previous "range-and-a-half" to "none"; the |
| 30 | > range-and-a-half checking wasn't particularly useful. |
| 31 | |
| 32 | Plus a C API or two, e.g. PyInt_AsLongMask() -> |
| 33 | unsigned long and PyInt_AsLongLongMask() -> unsigned |
| 34 | long long (if that exists). |
| 35 | """ |
| 36 | |
| 37 | LARGE = 0x7FFFFFFF |
Guido van Rossum | e2a383d | 2007-01-15 16:59:06 +0000 | [diff] [blame] | 38 | VERY_LARGE = 0xFF0000121212121212121242 |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 39 | |
| 40 | from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \ |
Mark Dickinson | 1554b18 | 2009-12-20 16:03:30 +0000 | [diff] [blame] | 41 | INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, \ |
| 42 | SHRT_MIN, SHRT_MAX |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 43 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 44 | # fake, they are not defined in Python's header files |
| 45 | LLONG_MAX = 2**63-1 |
| 46 | LLONG_MIN = -2**63 |
| 47 | ULLONG_MAX = 2**64-1 |
| 48 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 49 | class Int: |
| 50 | def __int__(self): |
| 51 | return 99 |
| 52 | |
| 53 | class Unsigned_TestCase(unittest.TestCase): |
| 54 | def test_b(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 55 | from _testcapi import getargs_b |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 56 | # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX) |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 57 | self.assertRaises(TypeError, getargs_b, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 58 | self.assertEqual(99, getargs_b(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 59 | |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 60 | self.assertRaises(OverflowError, getargs_b, -1) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 61 | self.assertEqual(0, getargs_b(0)) |
| 62 | self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 63 | self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 64 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 65 | self.assertEqual(42, getargs_b(42)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 66 | self.assertRaises(OverflowError, getargs_b, VERY_LARGE) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 67 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 68 | def test_B(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 69 | from _testcapi import getargs_B |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 70 | # B returns 'unsigned char', no range checking |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 71 | self.assertRaises(TypeError, getargs_B, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 72 | self.assertEqual(99, getargs_B(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 73 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 74 | self.assertEqual(UCHAR_MAX, getargs_B(-1)) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 75 | self.assertEqual(0, getargs_B(0)) |
| 76 | self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) |
| 77 | self.assertEqual(0, getargs_B(UCHAR_MAX+1)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 78 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 79 | self.assertEqual(42, getargs_B(42)) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 80 | self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 81 | |
| 82 | def test_H(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 83 | from _testcapi import getargs_H |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 84 | # H returns 'unsigned short', no range checking |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 85 | self.assertRaises(TypeError, getargs_H, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 86 | self.assertEqual(99, getargs_H(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 87 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 88 | self.assertEqual(USHRT_MAX, getargs_H(-1)) |
| 89 | self.assertEqual(0, getargs_H(0)) |
| 90 | self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX)) |
| 91 | self.assertEqual(0, getargs_H(USHRT_MAX+1)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 92 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 93 | self.assertEqual(42, getargs_H(42)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 94 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 95 | self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 96 | |
| 97 | def test_I(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 98 | from _testcapi import getargs_I |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 99 | # I returns 'unsigned int', no range checking |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 100 | self.assertRaises(TypeError, getargs_I, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 101 | self.assertEqual(99, getargs_I(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 102 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 103 | self.assertEqual(UINT_MAX, getargs_I(-1)) |
| 104 | self.assertEqual(0, getargs_I(0)) |
| 105 | self.assertEqual(UINT_MAX, getargs_I(UINT_MAX)) |
| 106 | self.assertEqual(0, getargs_I(UINT_MAX+1)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 107 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 108 | self.assertEqual(42, getargs_I(42)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 109 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 110 | self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 111 | |
| 112 | def test_k(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 113 | from _testcapi import getargs_k |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 114 | # k returns 'unsigned long', no range checking |
| 115 | # it does not accept float, or instances with __int__ |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 116 | self.assertRaises(TypeError, getargs_k, 3.14) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 117 | self.assertRaises(TypeError, getargs_k, Int()) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 118 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 119 | self.assertEqual(ULONG_MAX, getargs_k(-1)) |
| 120 | self.assertEqual(0, getargs_k(0)) |
| 121 | self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX)) |
| 122 | self.assertEqual(0, getargs_k(ULONG_MAX+1)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 123 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 124 | self.assertEqual(42, getargs_k(42)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 125 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 126 | self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 127 | |
| 128 | class Signed_TestCase(unittest.TestCase): |
Mark Dickinson | 1554b18 | 2009-12-20 16:03:30 +0000 | [diff] [blame] | 129 | def test_h(self): |
| 130 | from _testcapi import getargs_h |
| 131 | # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX) |
| 132 | self.assertRaises(TypeError, getargs_h, 3.14) |
| 133 | self.assertEqual(99, getargs_h(Int())) |
| 134 | |
| 135 | self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1) |
| 136 | self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN)) |
| 137 | self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX)) |
| 138 | self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1) |
| 139 | |
| 140 | self.assertEqual(42, getargs_h(42)) |
| 141 | self.assertRaises(OverflowError, getargs_h, VERY_LARGE) |
| 142 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 143 | def test_i(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 144 | from _testcapi import getargs_i |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 145 | # i returns 'int', and does range checking (INT_MIN ... INT_MAX) |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 146 | self.assertRaises(TypeError, getargs_i, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 147 | self.assertEqual(99, getargs_i(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 148 | |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 149 | self.assertRaises(OverflowError, getargs_i, INT_MIN-1) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 150 | self.assertEqual(INT_MIN, getargs_i(INT_MIN)) |
| 151 | self.assertEqual(INT_MAX, getargs_i(INT_MAX)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 152 | self.assertRaises(OverflowError, getargs_i, INT_MAX+1) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 153 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 154 | self.assertEqual(42, getargs_i(42)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 155 | self.assertRaises(OverflowError, getargs_i, VERY_LARGE) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 156 | |
| 157 | def test_l(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 158 | from _testcapi import getargs_l |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 159 | # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX) |
Thomas Wouters | c947123 | 2006-04-15 09:15:11 +0000 | [diff] [blame] | 160 | self.assertRaises(TypeError, getargs_l, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 161 | self.assertEqual(99, getargs_l(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 162 | |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 163 | self.assertRaises(OverflowError, getargs_l, LONG_MIN-1) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 164 | self.assertEqual(LONG_MIN, getargs_l(LONG_MIN)) |
| 165 | self.assertEqual(LONG_MAX, getargs_l(LONG_MAX)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 166 | self.assertRaises(OverflowError, getargs_l, LONG_MAX+1) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 167 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 168 | self.assertEqual(42, getargs_l(42)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 169 | self.assertRaises(OverflowError, getargs_l, VERY_LARGE) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 170 | |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 171 | def test_n(self): |
| 172 | from _testcapi import getargs_n |
| 173 | # n returns 'Py_ssize_t', and does range checking |
| 174 | # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX) |
Thomas Wouters | d807328 | 2006-04-21 11:36:13 +0000 | [diff] [blame] | 175 | self.assertRaises(TypeError, getargs_n, 3.14) |
Trent Nelson | 3513358 | 2008-04-22 19:02:40 +0000 | [diff] [blame] | 176 | self.assertRaises(TypeError, getargs_n, Int()) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 177 | |
| 178 | self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 179 | self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN)) |
| 180 | self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX)) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 181 | self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1) |
| 182 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 183 | self.assertEqual(42, getargs_n(42)) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 184 | self.assertRaises(OverflowError, getargs_n, VERY_LARGE) |
| 185 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 186 | |
| 187 | class LongLong_TestCase(unittest.TestCase): |
| 188 | def test_L(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 189 | from _testcapi import getargs_L |
Mark Dickinson | de60401 | 2010-01-01 19:27:32 +0000 | [diff] [blame] | 190 | # L returns 'long long', and does range checking (LLONG_MIN |
| 191 | # ... LLONG_MAX) |
Mark Dickinson | c730131 | 2010-06-10 16:05:10 +0000 | [diff] [blame] | 192 | self.assertRaises(TypeError, getargs_L, 3.14) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 193 | self.assertRaises(TypeError, getargs_L, "Hello") |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 194 | self.assertEqual(99, getargs_L(Int())) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 195 | |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 196 | self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 197 | self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN)) |
| 198 | self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 199 | self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 200 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 201 | self.assertEqual(42, getargs_L(42)) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 202 | self.assertRaises(OverflowError, getargs_L, VERY_LARGE) |
Tim Peters | 0eadaac | 2003-04-24 16:02:54 +0000 | [diff] [blame] | 203 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 204 | def test_K(self): |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 205 | from _testcapi import getargs_K |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 206 | # K return 'unsigned long long', no range checking |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 207 | self.assertRaises(TypeError, getargs_K, 3.14) |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 208 | self.assertRaises(TypeError, getargs_K, Int()) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 209 | self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) |
| 210 | self.assertEqual(0, getargs_K(0)) |
| 211 | self.assertEqual(0, getargs_K(ULLONG_MAX+1)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 212 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 213 | self.assertEqual(42, getargs_K(42)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 214 | |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 215 | self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 216 | |
Larry Hastings | faf91e7 | 2012-05-05 16:54:29 -0700 | [diff] [blame^] | 217 | class Paradox: |
| 218 | "This statement is false." |
| 219 | def __bool__(self): |
| 220 | raise NotImplementedError |
| 221 | |
| 222 | class Boolean_TestCase(unittest.TestCase): |
| 223 | def test_p(self): |
| 224 | from _testcapi import getargs_p |
| 225 | self.assertEqual(0, getargs_p(False)) |
| 226 | self.assertEqual(0, getargs_p(None)) |
| 227 | self.assertEqual(0, getargs_p(0)) |
| 228 | self.assertEqual(0, getargs_p(0.0)) |
| 229 | self.assertEqual(0, getargs_p(0j)) |
| 230 | self.assertEqual(0, getargs_p('')) |
| 231 | self.assertEqual(0, getargs_p(())) |
| 232 | self.assertEqual(0, getargs_p([])) |
| 233 | self.assertEqual(0, getargs_p({})) |
| 234 | |
| 235 | self.assertEqual(1, getargs_p(True)) |
| 236 | self.assertEqual(1, getargs_p(1)) |
| 237 | self.assertEqual(1, getargs_p(1.0)) |
| 238 | self.assertEqual(1, getargs_p(1j)) |
| 239 | self.assertEqual(1, getargs_p('x')) |
| 240 | self.assertEqual(1, getargs_p((1,))) |
| 241 | self.assertEqual(1, getargs_p([1])) |
| 242 | self.assertEqual(1, getargs_p({1:2})) |
| 243 | self.assertEqual(1, getargs_p(unittest.TestCase)) |
| 244 | |
| 245 | self.assertRaises(NotImplementedError, getargs_p, Paradox()) |
| 246 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 247 | |
| 248 | class Tuple_TestCase(unittest.TestCase): |
| 249 | def test_tuple(self): |
| 250 | from _testcapi import getargs_tuple |
| 251 | |
| 252 | ret = getargs_tuple(1, (2, 3)) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 253 | self.assertEqual(ret, (1,2,3)) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 254 | |
| 255 | # make sure invalid tuple arguments are handled correctly |
| 256 | class seq: |
| 257 | def __len__(self): |
| 258 | return 2 |
| 259 | def __getitem__(self, n): |
| 260 | raise ValueError |
| 261 | self.assertRaises(TypeError, getargs_tuple, 1, seq()) |
| 262 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 263 | class Keywords_TestCase(unittest.TestCase): |
| 264 | def test_positional_args(self): |
| 265 | # using all positional args |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 266 | self.assertEqual( |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 267 | getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10), |
| 268 | (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) |
| 269 | ) |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 270 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 271 | def test_mixed_args(self): |
| 272 | # positional and keyword args |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 273 | self.assertEqual( |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 274 | getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10), |
| 275 | (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) |
| 276 | ) |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 277 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 278 | def test_keyword_args(self): |
| 279 | # all keywords |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 280 | self.assertEqual( |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 281 | getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10), |
| 282 | (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) |
| 283 | ) |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 284 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 285 | def test_optional_args(self): |
| 286 | # missing optional keyword args, skipping tuples |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 287 | self.assertEqual( |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 288 | getargs_keywords(arg1=(1,2), arg2=3, arg5=10), |
| 289 | (1, 2, 3, -1, -1, -1, -1, -1, -1, 10) |
| 290 | ) |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 291 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 292 | def test_required_args(self): |
| 293 | # required arg missing |
| 294 | try: |
| 295 | getargs_keywords(arg1=(1,2)) |
| 296 | except TypeError as err: |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 297 | self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found") |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 298 | else: |
| 299 | self.fail('TypeError should have been raised') |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 300 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 301 | def test_too_many_args(self): |
| 302 | try: |
| 303 | getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) |
| 304 | except TypeError as err: |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 305 | self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 306 | else: |
| 307 | self.fail('TypeError should have been raised') |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 308 | |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 309 | def test_invalid_keyword(self): |
| 310 | # extraneous keyword arg |
| 311 | try: |
| 312 | getargs_keywords((1,2),3,arg5=10,arg666=666) |
| 313 | except TypeError as err: |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 314 | self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") |
Christian Heimes | 380f7f2 | 2008-02-28 11:19:05 +0000 | [diff] [blame] | 315 | else: |
| 316 | self.fail('TypeError should have been raised') |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 317 | |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 318 | def test_surrogate_keyword(self): |
| 319 | try: |
| 320 | getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10}) |
| 321 | except TypeError as err: |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 322 | self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function") |
Victor Stinner | 93b5513 | 2010-05-19 00:54:06 +0000 | [diff] [blame] | 323 | else: |
| 324 | self.fail('TypeError should have been raised') |
| 325 | |
Larry Hastings | 83a9f48 | 2012-03-20 20:06:16 +0000 | [diff] [blame] | 326 | class KeywordOnly_TestCase(unittest.TestCase): |
| 327 | def test_positional_args(self): |
| 328 | # using all possible positional args |
| 329 | self.assertEqual( |
| 330 | getargs_keyword_only(1, 2), |
| 331 | (1, 2, -1) |
| 332 | ) |
| 333 | |
| 334 | def test_mixed_args(self): |
| 335 | # positional and keyword args |
| 336 | self.assertEqual( |
| 337 | getargs_keyword_only(1, 2, keyword_only=3), |
| 338 | (1, 2, 3) |
| 339 | ) |
| 340 | |
| 341 | def test_keyword_args(self): |
| 342 | # all keywords |
| 343 | self.assertEqual( |
| 344 | getargs_keyword_only(required=1, optional=2, keyword_only=3), |
| 345 | (1, 2, 3) |
| 346 | ) |
| 347 | |
| 348 | def test_optional_args(self): |
| 349 | # missing optional keyword args, skipping tuples |
| 350 | self.assertEqual( |
| 351 | getargs_keyword_only(required=1, optional=2), |
| 352 | (1, 2, -1) |
| 353 | ) |
| 354 | self.assertEqual( |
| 355 | getargs_keyword_only(required=1, keyword_only=3), |
| 356 | (1, -1, 3) |
| 357 | ) |
| 358 | |
| 359 | def test_required_args(self): |
| 360 | self.assertEqual( |
| 361 | getargs_keyword_only(1), |
| 362 | (1, -1, -1) |
| 363 | ) |
| 364 | self.assertEqual( |
| 365 | getargs_keyword_only(required=1), |
| 366 | (1, -1, -1) |
| 367 | ) |
| 368 | # required arg missing |
| 369 | with self.assertRaisesRegex(TypeError, |
| 370 | "Required argument 'required' \(pos 1\) not found"): |
| 371 | getargs_keyword_only(optional=2) |
| 372 | |
| 373 | with self.assertRaisesRegex(TypeError, |
| 374 | "Required argument 'required' \(pos 1\) not found"): |
| 375 | getargs_keyword_only(keyword_only=3) |
| 376 | |
| 377 | def test_too_many_args(self): |
| 378 | with self.assertRaisesRegex(TypeError, |
| 379 | "Function takes at most 2 positional arguments \(3 given\)"): |
| 380 | getargs_keyword_only(1, 2, 3) |
| 381 | |
| 382 | with self.assertRaisesRegex(TypeError, |
| 383 | "function takes at most 3 arguments \(4 given\)"): |
| 384 | getargs_keyword_only(1, 2, 3, keyword_only=5) |
| 385 | |
| 386 | def test_invalid_keyword(self): |
| 387 | # extraneous keyword arg |
| 388 | with self.assertRaisesRegex(TypeError, |
| 389 | "'monster' is an invalid keyword argument for this function"): |
| 390 | getargs_keyword_only(1, 2, monster=666) |
| 391 | |
| 392 | def test_surrogate_keyword(self): |
| 393 | with self.assertRaisesRegex(TypeError, |
| 394 | "'\udc80' is an invalid keyword argument for this function"): |
| 395 | getargs_keyword_only(1, 2, **{'\uDC80': 10}) |
| 396 | |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 397 | class Bytes_TestCase(unittest.TestCase): |
Eli Bendersky | 906b88f | 2011-07-29 07:05:08 +0300 | [diff] [blame] | 398 | def test_c(self): |
| 399 | from _testcapi import getargs_c |
| 400 | self.assertRaises(TypeError, getargs_c, b'abc') # len > 1 |
| 401 | self.assertEqual(getargs_c(b'a'), b'a') |
| 402 | self.assertEqual(getargs_c(bytearray(b'a')), b'a') |
| 403 | self.assertRaises(TypeError, getargs_c, memoryview(b'a')) |
| 404 | self.assertRaises(TypeError, getargs_c, 's') |
| 405 | self.assertRaises(TypeError, getargs_c, None) |
| 406 | |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 407 | def test_s(self): |
| 408 | from _testcapi import getargs_s |
| 409 | self.assertEqual(getargs_s('abc\xe9'), b'abc\xc3\xa9') |
| 410 | self.assertRaises(TypeError, getargs_s, 'nul:\0') |
| 411 | self.assertRaises(TypeError, getargs_s, b'bytes') |
| 412 | self.assertRaises(TypeError, getargs_s, bytearray(b'bytearray')) |
| 413 | self.assertRaises(TypeError, getargs_s, memoryview(b'memoryview')) |
| 414 | self.assertRaises(TypeError, getargs_s, None) |
| 415 | |
| 416 | def test_s_star(self): |
| 417 | from _testcapi import getargs_s_star |
| 418 | self.assertEqual(getargs_s_star('abc\xe9'), b'abc\xc3\xa9') |
| 419 | self.assertEqual(getargs_s_star('nul:\0'), b'nul:\0') |
| 420 | self.assertEqual(getargs_s_star(b'bytes'), b'bytes') |
| 421 | self.assertEqual(getargs_s_star(bytearray(b'bytearray')), b'bytearray') |
| 422 | self.assertEqual(getargs_s_star(memoryview(b'memoryview')), b'memoryview') |
| 423 | self.assertRaises(TypeError, getargs_s_star, None) |
| 424 | |
| 425 | def test_s_hash(self): |
| 426 | from _testcapi import getargs_s_hash |
| 427 | self.assertEqual(getargs_s_hash('abc\xe9'), b'abc\xc3\xa9') |
| 428 | self.assertEqual(getargs_s_hash('nul:\0'), b'nul:\0') |
| 429 | self.assertEqual(getargs_s_hash(b'bytes'), b'bytes') |
| 430 | self.assertRaises(TypeError, getargs_s_hash, bytearray(b'bytearray')) |
| 431 | self.assertRaises(TypeError, getargs_s_hash, memoryview(b'memoryview')) |
| 432 | self.assertRaises(TypeError, getargs_s_hash, None) |
| 433 | |
| 434 | def test_z(self): |
| 435 | from _testcapi import getargs_z |
| 436 | self.assertEqual(getargs_z('abc\xe9'), b'abc\xc3\xa9') |
| 437 | self.assertRaises(TypeError, getargs_z, 'nul:\0') |
Victor Stinner | 4aae1eb | 2010-06-24 22:08:25 +0000 | [diff] [blame] | 438 | self.assertRaises(TypeError, getargs_z, b'bytes') |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 439 | self.assertRaises(TypeError, getargs_z, bytearray(b'bytearray')) |
| 440 | self.assertRaises(TypeError, getargs_z, memoryview(b'memoryview')) |
| 441 | self.assertIsNone(getargs_z(None)) |
| 442 | |
| 443 | def test_z_star(self): |
| 444 | from _testcapi import getargs_z_star |
| 445 | self.assertEqual(getargs_z_star('abc\xe9'), b'abc\xc3\xa9') |
| 446 | self.assertEqual(getargs_z_star('nul:\0'), b'nul:\0') |
| 447 | self.assertEqual(getargs_z_star(b'bytes'), b'bytes') |
| 448 | self.assertEqual(getargs_z_star(bytearray(b'bytearray')), b'bytearray') |
| 449 | self.assertEqual(getargs_z_star(memoryview(b'memoryview')), b'memoryview') |
| 450 | self.assertIsNone(getargs_z_star(None)) |
| 451 | |
| 452 | def test_z_hash(self): |
| 453 | from _testcapi import getargs_z_hash |
| 454 | self.assertEqual(getargs_z_hash('abc\xe9'), b'abc\xc3\xa9') |
| 455 | self.assertEqual(getargs_z_hash('nul:\0'), b'nul:\0') |
| 456 | self.assertEqual(getargs_z_hash(b'bytes'), b'bytes') |
| 457 | self.assertRaises(TypeError, getargs_z_hash, bytearray(b'bytearray')) |
| 458 | self.assertRaises(TypeError, getargs_z_hash, memoryview(b'memoryview')) |
| 459 | self.assertIsNone(getargs_z_hash(None)) |
| 460 | |
| 461 | def test_y(self): |
| 462 | from _testcapi import getargs_y |
| 463 | self.assertRaises(TypeError, getargs_y, 'abc\xe9') |
| 464 | self.assertEqual(getargs_y(b'bytes'), b'bytes') |
| 465 | self.assertRaises(TypeError, getargs_y, b'nul:\0') |
| 466 | self.assertRaises(TypeError, getargs_y, bytearray(b'bytearray')) |
| 467 | self.assertRaises(TypeError, getargs_y, memoryview(b'memoryview')) |
| 468 | self.assertRaises(TypeError, getargs_y, None) |
| 469 | |
| 470 | def test_y_star(self): |
| 471 | from _testcapi import getargs_y_star |
| 472 | self.assertRaises(TypeError, getargs_y_star, 'abc\xe9') |
| 473 | self.assertEqual(getargs_y_star(b'bytes'), b'bytes') |
| 474 | self.assertEqual(getargs_y_star(b'nul:\0'), b'nul:\0') |
| 475 | self.assertEqual(getargs_y_star(bytearray(b'bytearray')), b'bytearray') |
| 476 | self.assertEqual(getargs_y_star(memoryview(b'memoryview')), b'memoryview') |
| 477 | self.assertRaises(TypeError, getargs_y_star, None) |
| 478 | |
| 479 | def test_y_hash(self): |
| 480 | from _testcapi import getargs_y_hash |
| 481 | self.assertRaises(TypeError, getargs_y_hash, 'abc\xe9') |
| 482 | self.assertEqual(getargs_y_hash(b'bytes'), b'bytes') |
| 483 | self.assertEqual(getargs_y_hash(b'nul:\0'), b'nul:\0') |
| 484 | self.assertRaises(TypeError, getargs_y_hash, bytearray(b'bytearray')) |
| 485 | self.assertRaises(TypeError, getargs_y_hash, memoryview(b'memoryview')) |
| 486 | self.assertRaises(TypeError, getargs_y_hash, None) |
| 487 | |
Victor Stinner | 25e8ec4 | 2010-06-25 00:02:38 +0000 | [diff] [blame] | 488 | def test_w_star(self): |
| 489 | # getargs_w_star() modifies first and last byte |
| 490 | from _testcapi import getargs_w_star |
| 491 | self.assertRaises(TypeError, getargs_w_star, 'abc\xe9') |
| 492 | self.assertRaises(TypeError, getargs_w_star, b'bytes') |
| 493 | self.assertRaises(TypeError, getargs_w_star, b'nul:\0') |
Antoine Pitrou | ad62b03 | 2011-01-18 18:57:52 +0000 | [diff] [blame] | 494 | self.assertRaises(TypeError, getargs_w_star, memoryview(b'bytes')) |
Victor Stinner | 25e8ec4 | 2010-06-25 00:02:38 +0000 | [diff] [blame] | 495 | self.assertEqual(getargs_w_star(bytearray(b'bytearray')), b'[ytearra]') |
Antoine Pitrou | ad62b03 | 2011-01-18 18:57:52 +0000 | [diff] [blame] | 496 | self.assertEqual(getargs_w_star(memoryview(bytearray(b'memoryview'))), |
| 497 | b'[emoryvie]') |
Victor Stinner | 25e8ec4 | 2010-06-25 00:02:38 +0000 | [diff] [blame] | 498 | self.assertRaises(TypeError, getargs_w_star, None) |
| 499 | |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 500 | |
| 501 | class Unicode_TestCase(unittest.TestCase): |
| 502 | def test_u(self): |
| 503 | from _testcapi import getargs_u |
| 504 | self.assertEqual(getargs_u('abc\xe9'), 'abc\xe9') |
| 505 | self.assertRaises(TypeError, getargs_u, 'nul:\0') |
| 506 | self.assertRaises(TypeError, getargs_u, b'bytes') |
| 507 | self.assertRaises(TypeError, getargs_u, bytearray(b'bytearray')) |
| 508 | self.assertRaises(TypeError, getargs_u, memoryview(b'memoryview')) |
| 509 | self.assertRaises(TypeError, getargs_u, None) |
| 510 | |
| 511 | def test_u_hash(self): |
| 512 | from _testcapi import getargs_u_hash |
| 513 | self.assertEqual(getargs_u_hash('abc\xe9'), 'abc\xe9') |
| 514 | self.assertEqual(getargs_u_hash('nul:\0'), 'nul:\0') |
| 515 | self.assertRaises(TypeError, getargs_u_hash, b'bytes') |
| 516 | self.assertRaises(TypeError, getargs_u_hash, bytearray(b'bytearray')) |
| 517 | self.assertRaises(TypeError, getargs_u_hash, memoryview(b'memoryview')) |
| 518 | self.assertRaises(TypeError, getargs_u_hash, None) |
| 519 | |
| 520 | def test_Z(self): |
| 521 | from _testcapi import getargs_Z |
| 522 | self.assertEqual(getargs_Z('abc\xe9'), 'abc\xe9') |
| 523 | self.assertRaises(TypeError, getargs_Z, 'nul:\0') |
| 524 | self.assertRaises(TypeError, getargs_Z, b'bytes') |
| 525 | self.assertRaises(TypeError, getargs_Z, bytearray(b'bytearray')) |
| 526 | self.assertRaises(TypeError, getargs_Z, memoryview(b'memoryview')) |
| 527 | self.assertIsNone(getargs_Z(None)) |
| 528 | |
| 529 | def test_Z_hash(self): |
| 530 | from _testcapi import getargs_Z_hash |
| 531 | self.assertEqual(getargs_Z_hash('abc\xe9'), 'abc\xe9') |
| 532 | self.assertEqual(getargs_Z_hash('nul:\0'), 'nul:\0') |
| 533 | self.assertRaises(TypeError, getargs_Z_hash, b'bytes') |
| 534 | self.assertRaises(TypeError, getargs_Z_hash, bytearray(b'bytearray')) |
| 535 | self.assertRaises(TypeError, getargs_Z_hash, memoryview(b'memoryview')) |
| 536 | self.assertIsNone(getargs_Z_hash(None)) |
| 537 | |
| 538 | |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 539 | def test_main(): |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 540 | tests = [ |
| 541 | Signed_TestCase, |
| 542 | Unsigned_TestCase, |
Larry Hastings | faf91e7 | 2012-05-05 16:54:29 -0700 | [diff] [blame^] | 543 | Boolean_TestCase, |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 544 | Tuple_TestCase, |
| 545 | Keywords_TestCase, |
Larry Hastings | 83a9f48 | 2012-03-20 20:06:16 +0000 | [diff] [blame] | 546 | KeywordOnly_TestCase, |
Victor Stinner | 06e49dd | 2010-06-13 18:21:50 +0000 | [diff] [blame] | 547 | Bytes_TestCase, |
| 548 | Unicode_TestCase, |
| 549 | ] |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 550 | try: |
Thomas Heller | 54aa578 | 2003-04-24 16:15:29 +0000 | [diff] [blame] | 551 | from _testcapi import getargs_L, getargs_K |
| 552 | except ImportError: |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 553 | pass # PY_LONG_LONG not available |
| 554 | else: |
Walter Dörwald | 21d3a32 | 2003-05-01 17:45:56 +0000 | [diff] [blame] | 555 | tests.append(LongLong_TestCase) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 556 | support.run_unittest(*tests) |
Thomas Heller | a4ea603 | 2003-04-17 18:55:45 +0000 | [diff] [blame] | 557 | |
| 558 | if __name__ == "__main__": |
| 559 | test_main() |