1"""Unit tests for the keyword only argument specified in PEP 3102.""" 2 3__author__ = "Jiwon Seo" 4__email__ = "seojiwon at gmail dot com" 5 6import unittest 7 8def posonly_sum(pos_arg1, *arg, **kwarg): 9 return pos_arg1 + sum(arg) + sum(kwarg.values()) 10def keywordonly_sum(*, k1=0, k2): 11 return k1 + k2 12def keywordonly_nodefaults_sum(*, k1, k2): 13 return k1 + k2 14def keywordonly_and_kwarg_sum(*, k1, k2, **kwarg): 15 return k1 + k2 + sum(kwarg.values()) 16def mixedargs_sum(a, b=0, *arg, k1, k2=0): 17 return a + b + k1 + k2 + sum(arg) 18def mixedargs_sum2(a, b=0, *arg, k1, k2=0, **kwargs): 19 return a + b + k1 + k2 + sum(arg) + sum(kwargs.values()) 20 21def sortnum(*nums, reverse=False): 22 return sorted(list(nums), reverse=reverse) 23 24def sortwords(*words, reverse=False, **kwargs): 25 return sorted(list(words), reverse=reverse) 26 27class Foo: 28 def __init__(self, *, k1, k2=0): 29 self.k1 = k1 30 self.k2 = k2 31 def set(self, p1, *, k1, k2): 32 self.k1 = k1 33 self.k2 = k2 34 def sum(self): 35 return self.k1 + self.k2 36 37class KeywordOnlyArgTestCase(unittest.TestCase): 38 def assertRaisesSyntaxError(self, codestr): 39 def shouldRaiseSyntaxError(s): 40 compile(s, "<test>", "single") 41 self.assertRaises(SyntaxError, shouldRaiseSyntaxError, codestr) 42 43 def testSyntaxErrorForFunctionDefinition(self): 44 self.assertRaisesSyntaxError("def f(p, *):\n pass\n") 45 self.assertRaisesSyntaxError("def f(p1, *, p1=100):\n pass\n") 46 self.assertRaisesSyntaxError("def f(p1, *k1, k1=100):\n pass\n") 47 self.assertRaisesSyntaxError("def f(p1, *, k1, k1=100):\n pass\n") 48 self.assertRaisesSyntaxError("def f(p1, *, **k1):\n pass\n") 49 self.assertRaisesSyntaxError("def f(p1, *, k1, **k1):\n pass\n") 50 self.assertRaisesSyntaxError("def f(p1, *, None, **k1):\n pass\n") 51 self.assertRaisesSyntaxError("def f(p, *, (k1, k2), **kw):\n pass\n") 52 53 def testSyntaxForManyArguments(self): 54 fundef = "def f(" 55 for i in range(255): 56 fundef += "i%d, "%i 57 fundef += "*, key=100):\n pass\n" 58 self.assertRaisesSyntaxError(fundef) 59 60 fundef2 = "def foo(i,*," 61 for i in range(255): 62 fundef2 += "i%d, "%i 63 fundef2 += "lastarg):\n pass\n" 64 self.assertRaisesSyntaxError(fundef2) 65 66 # exactly 255 arguments, should compile ok 67 fundef3 = "def f(i,*," 68 for i in range(253): 69 fundef3 += "i%d, "%i 70 fundef3 += "lastarg):\n pass\n" 71 compile(fundef3, "<test>", "single") 72 73 def testTooManyPositionalErrorMessage(self): 74 def f(a, b=None, *, c=None): 75 pass 76 with self.assertRaises(TypeError) as exc: 77 f(1, 2, 3) 78 expected = "f() takes from 1 to 2 positional arguments but 3 were given" 79 self.assertEqual(str(exc.exception), expected) 80 81 def testSyntaxErrorForFunctionCall(self): 82 self.assertRaisesSyntaxError("f(p, k=1, p2)") 83 self.assertRaisesSyntaxError("f(p, k1=50, *(1,2), k1=100)") 84 85 def testRaiseErrorFuncallWithUnexpectedKeywordArgument(self): 86 self.assertRaises(TypeError, keywordonly_sum, ()) 87 self.assertRaises(TypeError, keywordonly_nodefaults_sum, ()) 88 self.assertRaises(TypeError, Foo, ()) 89 try: 90 keywordonly_sum(k2=100, non_existing_arg=200) 91 self.fail("should raise TypeError") 92 except TypeError: 93 pass 94 try: 95 keywordonly_nodefaults_sum(k2=2) 96 self.fail("should raise TypeError") 97 except TypeError: 98 pass 99 100 def testFunctionCall(self): 101 self.assertEqual(1, posonly_sum(1)) 102 self.assertEqual(1+2, posonly_sum(1,**{"2":2})) 103 self.assertEqual(1+2+3, posonly_sum(1,*(2,3))) 104 self.assertEqual(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) 105 106 self.assertEqual(1, keywordonly_sum(k2=1)) 107 self.assertEqual(1+2, keywordonly_sum(k1=1, k2=2)) 108 109 self.assertEqual(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) 110 self.assertEqual(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) 111 self.assertEqual(1+2+3+4, 112 keywordonly_and_kwarg_sum(k1=1, k2=2, 113 **{"a":3,"b":4})) 114 115 self.assertEqual(1+2, mixedargs_sum(1, k1=2)) 116 self.assertEqual(1+2+3, mixedargs_sum(1, 2, k1=3)) 117 self.assertEqual(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) 118 self.assertEqual(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) 119 120 self.assertEqual(1+2, mixedargs_sum2(1, k1=2)) 121 self.assertEqual(1+2+3, mixedargs_sum2(1, 2, k1=3)) 122 self.assertEqual(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) 123 self.assertEqual(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) 124 self.assertEqual(1+2+3+4+5+6, 125 mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) 126 self.assertEqual(1+2+3+4+5+6, 127 mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) 128 129 self.assertEqual(1, Foo(k1=1).sum()) 130 self.assertEqual(1+2, Foo(k1=1,k2=2).sum()) 131 132 self.assertEqual([1,2,3], sortnum(3,2,1)) 133 self.assertEqual([3,2,1], sortnum(1,2,3, reverse=True)) 134 135 self.assertEqual(['a','b','c'], sortwords('a','c','b')) 136 self.assertEqual(['c','b','a'], sortwords('a','c','b', reverse=True)) 137 self.assertEqual(['c','b','a'], 138 sortwords('a','c','b', reverse=True, ignore='ignore')) 139 140 def testKwDefaults(self): 141 def foo(p1,p2=0, *, k1, k2=0): 142 return p1 + p2 + k1 + k2 143 144 self.assertEqual(2, foo.__code__.co_kwonlyargcount) 145 self.assertEqual({"k2":0}, foo.__kwdefaults__) 146 foo.__kwdefaults__ = {"k1":0} 147 try: 148 foo(1,k1=10) 149 self.fail("__kwdefaults__ is not properly changed") 150 except TypeError: 151 pass 152 153 def test_kwonly_methods(self): 154 class Example: 155 def f(self, *, k1=1, k2=2): 156 return k1, k2 157 158 self.assertEqual(Example().f(k1=1, k2=2), (1, 2)) 159 self.assertEqual(Example.f(Example(), k1=1, k2=2), (1, 2)) 160 self.assertRaises(TypeError, Example.f, k1=1, k2=2) 161 162 def test_issue13343(self): 163 # The Python compiler must scan all symbols of a function to 164 # determine their scope: global, local, cell... 165 # This was not done for the default values of keyword 166 # arguments in a lambda definition, and the following line 167 # used to fail with a SystemError. 168 lambda *, k1=unittest: None 169 170 def test_mangling(self): 171 class X: 172 def f(self, *, __a=42): 173 return __a 174 self.assertEqual(X().f(), 42) 175 176 def test_default_evaluation_order(self): 177 # See issue 16967 178 a = 42 179 with self.assertRaises(NameError) as err: 180 def f(v=a, x=b, *, y=c, z=d): 181 pass 182 self.assertEqual(str(err.exception), "name 'b' is not defined") 183 with self.assertRaises(NameError) as err: 184 f = lambda v=a, x=b, *, y=c, z=d: None 185 self.assertEqual(str(err.exception), "name 'b' is not defined") 186 187 188if __name__ == "__main__": 189 unittest.main() 190