Benjamin Peterson | 90f5ba5 | 2010-03-11 22:53:45 +0000 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 2 | |
| 3 | """Unit tests for the keyword only argument specified in PEP 3102.""" |
| 4 | |
| 5 | __author__ = "Jiwon Seo" |
| 6 | __email__ = "seojiwon at gmail dot com" |
| 7 | |
| 8 | import unittest |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 9 | from test.support import run_unittest |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 10 | |
| 11 | def posonly_sum(pos_arg1, *arg, **kwarg): |
| 12 | return pos_arg1 + sum(arg) + sum(kwarg.values()) |
| 13 | def keywordonly_sum(*, k1=0, k2): |
| 14 | return k1 + k2 |
| 15 | def keywordonly_nodefaults_sum(*, k1, k2): |
| 16 | return k1 + k2 |
| 17 | def keywordonly_and_kwarg_sum(*, k1, k2, **kwarg): |
| 18 | return k1 + k2 + sum(kwarg.values()) |
| 19 | def mixedargs_sum(a, b=0, *arg, k1, k2=0): |
| 20 | return a + b + k1 + k2 + sum(arg) |
| 21 | def mixedargs_sum2(a, b=0, *arg, k1, k2=0, **kwargs): |
| 22 | return a + b + k1 + k2 + sum(arg) + sum(kwargs.values()) |
| 23 | |
| 24 | def sortnum(*nums, reverse=False): |
| 25 | return sorted(list(nums), reverse=reverse) |
| 26 | |
| 27 | def sortwords(*words, reverse=False, **kwargs): |
| 28 | return sorted(list(words), reverse=reverse) |
| 29 | |
| 30 | class Foo: |
| 31 | def __init__(self, *, k1, k2=0): |
| 32 | self.k1 = k1 |
| 33 | self.k2 = k2 |
| 34 | def set(self, p1, *, k1, k2): |
| 35 | self.k1 = k1 |
| 36 | self.k2 = k2 |
| 37 | def sum(self): |
| 38 | return self.k1 + self.k2 |
| 39 | |
| 40 | class KeywordOnlyArgTestCase(unittest.TestCase): |
| 41 | def assertRaisesSyntaxError(self, codestr): |
| 42 | def shouldRaiseSyntaxError(s): |
| 43 | compile(s, "<test>", "single") |
| 44 | self.assertRaises(SyntaxError, shouldRaiseSyntaxError, codestr) |
| 45 | |
| 46 | def testSyntaxErrorForFunctionDefinition(self): |
| 47 | self.assertRaisesSyntaxError("def f(p, *):\n pass\n") |
| 48 | self.assertRaisesSyntaxError("def f(p1, *, p1=100):\n pass\n") |
| 49 | self.assertRaisesSyntaxError("def f(p1, *k1, k1=100):\n pass\n") |
| 50 | self.assertRaisesSyntaxError("def f(p1, *, k1, k1=100):\n pass\n") |
Amaury Forgeot d'Arc | 40d3a67 | 2007-12-09 21:49:48 +0000 | [diff] [blame] | 51 | self.assertRaisesSyntaxError("def f(p1, *, **k1):\n pass\n") |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 52 | self.assertRaisesSyntaxError("def f(p1, *, k1, **k1):\n pass\n") |
| 53 | self.assertRaisesSyntaxError("def f(p1, *, None, **k1):\n pass\n") |
| 54 | self.assertRaisesSyntaxError("def f(p, *, (k1, k2), **kw):\n pass\n") |
| 55 | |
| 56 | def testSyntaxForManyArguments(self): |
| 57 | fundef = "def f(" |
| 58 | for i in range(255): |
| 59 | fundef += "i%d, "%i |
| 60 | fundef += "*, key=100):\n pass\n" |
| 61 | self.assertRaisesSyntaxError(fundef) |
| 62 | |
| 63 | fundef2 = "def foo(i,*," |
| 64 | for i in range(255): |
| 65 | fundef2 += "i%d, "%i |
| 66 | fundef2 += "lastarg):\n pass\n" |
| 67 | self.assertRaisesSyntaxError(fundef2) |
| 68 | |
| 69 | # exactly 255 arguments, should compile ok |
| 70 | fundef3 = "def f(i,*," |
| 71 | for i in range(253): |
| 72 | fundef3 += "i%d, "%i |
| 73 | fundef3 += "lastarg):\n pass\n" |
| 74 | compile(fundef3, "<test>", "single") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 75 | |
Benjamin Peterson | 88968ad | 2010-06-25 19:30:21 +0000 | [diff] [blame] | 76 | def testTooManyPositionalErrorMessage(self): |
| 77 | def f(a, b=None, *, c=None): |
| 78 | pass |
| 79 | with self.assertRaises(TypeError) as exc: |
| 80 | f(1, 2, 3) |
Benjamin Peterson | b204a42 | 2011-06-05 22:04:07 -0500 | [diff] [blame] | 81 | expected = "f() takes from 1 to 2 positional arguments but 3 were given" |
Benjamin Peterson | 88968ad | 2010-06-25 19:30:21 +0000 | [diff] [blame] | 82 | self.assertEqual(str(exc.exception), expected) |
| 83 | |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 84 | def testSyntaxErrorForFunctionCall(self): |
| 85 | self.assertRaisesSyntaxError("f(p, k=1, p2)") |
Benjamin Peterson | 2d735bc | 2008-08-19 20:57:10 +0000 | [diff] [blame] | 86 | self.assertRaisesSyntaxError("f(p, k1=50, *(1,2), k1=100)") |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 87 | |
| 88 | def testRaiseErrorFuncallWithUnexpectedKeywordArgument(self): |
| 89 | self.assertRaises(TypeError, keywordonly_sum, ()) |
| 90 | self.assertRaises(TypeError, keywordonly_nodefaults_sum, ()) |
| 91 | self.assertRaises(TypeError, Foo, ()) |
| 92 | try: |
| 93 | keywordonly_sum(k2=100, non_existing_arg=200) |
| 94 | self.fail("should raise TypeError") |
| 95 | except TypeError: |
| 96 | pass |
| 97 | try: |
| 98 | keywordonly_nodefaults_sum(k2=2) |
| 99 | self.fail("should raise TypeError") |
| 100 | except TypeError: |
| 101 | pass |
| 102 | |
| 103 | def testFunctionCall(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 104 | self.assertEqual(1, posonly_sum(1)) |
| 105 | self.assertEqual(1+2, posonly_sum(1,**{"2":2})) |
| 106 | self.assertEqual(1+2+3, posonly_sum(1,*(2,3))) |
| 107 | self.assertEqual(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 108 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 109 | self.assertEqual(1, keywordonly_sum(k2=1)) |
| 110 | self.assertEqual(1+2, keywordonly_sum(k1=1, k2=2)) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 111 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 112 | self.assertEqual(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) |
| 113 | self.assertEqual(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) |
| 114 | self.assertEqual(1+2+3+4, |
| 115 | keywordonly_and_kwarg_sum(k1=1, k2=2, |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 116 | **{"a":3,"b":4})) |
| 117 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 118 | self.assertEqual(1+2, mixedargs_sum(1, k1=2)) |
| 119 | self.assertEqual(1+2+3, mixedargs_sum(1, 2, k1=3)) |
| 120 | self.assertEqual(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) |
| 121 | self.assertEqual(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 122 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 123 | self.assertEqual(1+2, mixedargs_sum2(1, k1=2)) |
| 124 | self.assertEqual(1+2+3, mixedargs_sum2(1, 2, k1=3)) |
| 125 | self.assertEqual(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) |
| 126 | self.assertEqual(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) |
| 127 | self.assertEqual(1+2+3+4+5+6, |
| 128 | mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) |
| 129 | self.assertEqual(1+2+3+4+5+6, |
| 130 | mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 131 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 132 | self.assertEqual(1, Foo(k1=1).sum()) |
| 133 | self.assertEqual(1+2, Foo(k1=1,k2=2).sum()) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 134 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 135 | self.assertEqual([1,2,3], sortnum(3,2,1)) |
| 136 | self.assertEqual([3,2,1], sortnum(1,2,3, reverse=True)) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 137 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 138 | self.assertEqual(['a','b','c'], sortwords('a','c','b')) |
| 139 | self.assertEqual(['c','b','a'], sortwords('a','c','b', reverse=True)) |
| 140 | self.assertEqual(['c','b','a'], |
| 141 | sortwords('a','c','b', reverse=True, ignore='ignore')) |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 142 | |
| 143 | def testKwDefaults(self): |
| 144 | def foo(p1,p2=0, *, k1, k2=0): |
| 145 | return p1 + p2 + k1 + k2 |
| 146 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 147 | self.assertEqual(2, foo.__code__.co_kwonlyargcount) |
| 148 | self.assertEqual({"k2":0}, foo.__kwdefaults__) |
Neal Norwitz | 221085d | 2007-02-25 20:55:47 +0000 | [diff] [blame] | 149 | foo.__kwdefaults__ = {"k1":0} |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 150 | try: |
| 151 | foo(1,k1=10) |
Neal Norwitz | 221085d | 2007-02-25 20:55:47 +0000 | [diff] [blame] | 152 | self.fail("__kwdefaults__ is not properly changed") |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 153 | except TypeError: |
| 154 | pass |
| 155 | |
Christian Heimes | eda9e2b | 2007-12-08 22:32:47 +0000 | [diff] [blame] | 156 | def test_kwonly_methods(self): |
| 157 | class Example: |
| 158 | def f(self, *, k1=1, k2=2): |
| 159 | return k1, k2 |
| 160 | |
| 161 | self.assertEqual(Example().f(k1=1, k2=2), (1, 2)) |
| 162 | self.assertEqual(Example.f(Example(), k1=1, k2=2), (1, 2)) |
| 163 | self.assertRaises(TypeError, Example.f, k1=1, k2=2) |
| 164 | |
Guido van Rossum | dfc9d4f | 2006-11-22 14:42:41 +0000 | [diff] [blame] | 165 | def test_main(): |
| 166 | run_unittest(KeywordOnlyArgTestCase) |
| 167 | |
| 168 | if __name__ == "__main__": |
| 169 | test_main() |