Debian Codegraph @

Lib/test/test_tcl.py

raw
1 import unittest
2 import subprocess
3 import sys
4 import os
5 from test import support
6 from test.support import import_helper
7 from test.support import os_helper
8
9 # Skip this test if the _tkinter module wasn't built.
10 _tkinter = import_helper.import_module('_tkinter')
11
12 import tkinter
13 from tkinter import Tcl
14 from _tkinter import TclError
15
16 try:
17 from _testcapi import INT_MAX, PY_SSIZE_T_MAX
18 except ImportError:
19 INT_MAX = PY_SSIZE_T_MAX = sys.maxsize
20
21 tcl_version = tuple(map(int, _tkinter.TCL_VERSION.split('.')))
22
23
24 class TkinterTest(unittest.TestCase):
25
26 def testFlattenLen(self):
27 # Object without length.
28 self.assertRaises(TypeError, _tkinter._flatten, True)
29 # Object with length, but not sequence.
30 self.assertRaises(TypeError, _tkinter._flatten, {})
31 # Sequence or set, but not tuple or list.
32 # (issue44608: there were leaks in the following cases)
33 self.assertRaises(TypeError, _tkinter._flatten, 'string')
34 self.assertRaises(TypeError, _tkinter._flatten, {'set'})
35
36
37 class TclTest(unittest.TestCase):
38
39 def setUp(self):
40 self.interp = Tcl()
41 self.wantobjects = self.interp.tk.wantobjects()
42
43 def passValue(self, value):
44 return self.interp.call('set', '_', value)
45
46 def testEval(self):
47 tcl = self.interp
48 tcl.eval('set a 1')
49 self.assertEqual(tcl.eval('set a'),'1')
50
51 def test_eval_null_in_result(self):
52 tcl = self.interp
53 self.assertEqual(tcl.eval('set a "a\\0b"'), 'a\x00b')
54
55 def test_eval_surrogates_in_result(self):
56 tcl = self.interp
57 self.assertEqual(tcl.eval(r'set a "<\ud83d\udcbb>"'), '<\U0001f4bb>')
58
59 def testEvalException(self):
60 tcl = self.interp
61 self.assertRaises(TclError,tcl.eval,'set a')
62
63 def testEvalException2(self):
64 tcl = self.interp
65 self.assertRaises(TclError,tcl.eval,'this is wrong')
66
67 def test_eval_returns_tcl_obj(self):
68 tcl = self.interp.tk
69 tcl.eval(r'set a "\u20ac \ud83d\udcbb \0 \udcab"; regexp -about $a')
70 a = tcl.eval('set a')
71 expected = '\u20ac \U0001f4bb \0 \udced\udcb2\udcab'
72 self.assertEqual(a, expected)
73
74 def testCall(self):
75 tcl = self.interp
76 tcl.call('set','a','1')
77 self.assertEqual(tcl.call('set','a'),'1')
78
79 def test_call_passing_null(self):
80 tcl = self.interp
81 tcl.call('set', 'a', 'a\0b') # ASCII-only
82 self.assertEqual(tcl.getvar('a'), 'a\x00b')
83 self.assertEqual(tcl.call('set', 'a'), 'a\x00b')
84 self.assertEqual(tcl.eval('set a'), 'a\x00b')
85
86 tcl.call('set', 'a', '\u20ac\0') # non-ASCII
87 self.assertEqual(tcl.getvar('a'), '\u20ac\x00')
88 self.assertEqual(tcl.call('set', 'a'), '\u20ac\x00')
89 self.assertEqual(tcl.eval('set a'), '\u20ac\x00')
90
91 def testCallException(self):
92 tcl = self.interp
93 self.assertRaises(TclError,tcl.call,'set','a')
94
95 def testCallException2(self):
96 tcl = self.interp
97 self.assertRaises(TclError,tcl.call,'this','is','wrong')
98
99 def test_call_returns_tcl_obj(self):
100 tcl = self.interp.tk
101 tcl.eval(r'set a "\u20ac \ud83d\udcbb \0 \udcab"; regexp -about $a')
102 a = tcl.call('set', 'a')
103 expected = '\u20ac \U0001f4bb \0 \udced\udcb2\udcab'
104 if self.wantobjects:
105 self.assertEqual(str(a), expected)
106 self.assertEqual(a.string, expected)
107 self.assertEqual(a.typename, 'regexp')
108 else:
109 self.assertEqual(a, expected)
110
111 def testSetVar(self):
112 tcl = self.interp
113 tcl.setvar('a','1')
114 self.assertEqual(tcl.eval('set a'),'1')
115
116 def test_setvar_passing_null(self):
117 tcl = self.interp
118 tcl.setvar('a', 'a\0b') # ASCII-only
119 self.assertEqual(tcl.getvar('a'), 'a\x00b')
120 self.assertEqual(tcl.call('set', 'a'), 'a\x00b')
121 self.assertEqual(tcl.eval('set a'), 'a\x00b')
122
123 tcl.setvar('a', '\u20ac\0') # non-ASCII
124 self.assertEqual(tcl.getvar('a'), '\u20ac\x00')
125 self.assertEqual(tcl.call('set', 'a'), '\u20ac\x00')
126 self.assertEqual(tcl.eval('set a'), '\u20ac\x00')
127
128 def testSetVarArray(self):
129 tcl = self.interp
130 tcl.setvar('a(1)','1')
131 self.assertEqual(tcl.eval('set a(1)'),'1')
132
133 def testGetVar(self):
134 tcl = self.interp
135 tcl.eval('set a 1')
136 self.assertEqual(tcl.getvar('a'),'1')
137
138 def testGetVarArray(self):
139 tcl = self.interp
140 tcl.eval('set a(1) 1')
141 self.assertEqual(tcl.getvar('a(1)'),'1')
142
143 def testGetVarException(self):
144 tcl = self.interp
145 self.assertRaises(TclError,tcl.getvar,'a')
146
147 def testGetVarArrayException(self):
148 tcl = self.interp
149 self.assertRaises(TclError,tcl.getvar,'a(1)')
150
151 def test_getvar_returns_tcl_obj(self):
152 tcl = self.interp.tk
153 tcl.eval(r'set a "\u20ac \ud83d\udcbb \0 \udcab"; regexp -about $a')
154 a = tcl.getvar('a')
155 expected = '\u20ac \U0001f4bb \0 \udced\udcb2\udcab'
156 if self.wantobjects:
157 self.assertEqual(str(a), expected)
158 self.assertEqual(a.string, expected)
159 self.assertEqual(a.typename, 'regexp')
160 else:
161 self.assertEqual(a, expected)
162
163 def testUnsetVar(self):
164 tcl = self.interp
165 tcl.setvar('a',1)
166 self.assertEqual(tcl.eval('info exists a'),'1')
167 tcl.unsetvar('a')
168 self.assertEqual(tcl.eval('info exists a'),'0')
169
170 def testUnsetVarArray(self):
171 tcl = self.interp
172 tcl.setvar('a(1)',1)
173 tcl.setvar('a(2)',2)
174 self.assertEqual(tcl.eval('info exists a(1)'),'1')
175 self.assertEqual(tcl.eval('info exists a(2)'),'1')
176 tcl.unsetvar('a(1)')
177 self.assertEqual(tcl.eval('info exists a(1)'),'0')
178 self.assertEqual(tcl.eval('info exists a(2)'),'1')
179
180 def testUnsetVarException(self):
181 tcl = self.interp
182 self.assertRaises(TclError,tcl.unsetvar,'a')
183
184 def get_integers(self):
185 return (0, 1, -1,
186 2**31-1, -2**31, 2**31, -2**31-1,
187 2**63-1, -2**63, 2**63, -2**63-1,
188 2**1000, -2**1000)
189
190 def test_getint(self):
191 tcl = self.interp.tk
192 for i in self.get_integers():
193 self.assertEqual(tcl.getint(' %d ' % i), i)
194 self.assertEqual(tcl.getint(' %#o ' % i), i)
195 # Numbers starting with 0 are parsed as decimal in Tcl 9.0
196 # and as octal in older versions.
197 self.assertEqual(tcl.getint((' %#o ' % i).replace('o', '')),
198 i if tcl_version < (9, 0) else int('%o' % i))
199 self.assertEqual(tcl.getint(' %#x ' % i), i)
200 self.assertEqual(tcl.getint(42), 42)
201 self.assertRaises(TypeError, tcl.getint)
202 self.assertRaises(TypeError, tcl.getint, '42', '10')
203 self.assertRaises(TypeError, tcl.getint, b'42')
204 self.assertRaises(TypeError, tcl.getint, 42.0)
205 self.assertRaises(TclError, tcl.getint, 'a')
206 self.assertRaises((TypeError, ValueError, TclError),
207 tcl.getint, '42\0')
208 self.assertRaises((UnicodeEncodeError, ValueError, TclError),
209 tcl.getint, '42\ud800')
210
211 def test_getdouble(self):
212 tcl = self.interp.tk
213 self.assertEqual(tcl.getdouble(' 42 '), 42.0)
214 self.assertEqual(tcl.getdouble(' 42.5 '), 42.5)
215 self.assertEqual(tcl.getdouble(42.5), 42.5)
216 self.assertEqual(tcl.getdouble(42), 42.0)
217 self.assertRaises(TypeError, tcl.getdouble)
218 self.assertRaises(TypeError, tcl.getdouble, '42.5', '10')
219 self.assertRaises(TypeError, tcl.getdouble, b'42.5')
220 self.assertRaises(TclError, tcl.getdouble, 'a')
221 self.assertRaises((TypeError, ValueError, TclError),
222 tcl.getdouble, '42.5\0')
223 self.assertRaises((UnicodeEncodeError, ValueError, TclError),
224 tcl.getdouble, '42.5\ud800')
225
226 def test_getboolean(self):
227 tcl = self.interp.tk
228 self.assertIs(tcl.getboolean('on'), True)
229 self.assertIs(tcl.getboolean('1'), True)
230 self.assertIs(tcl.getboolean(42), True)
231 self.assertIs(tcl.getboolean(0), False)
232 self.assertRaises(TypeError, tcl.getboolean)
233 self.assertRaises(TypeError, tcl.getboolean, 'on', '1')
234 self.assertRaises(TypeError, tcl.getboolean, b'on')
235 self.assertRaises(TypeError, tcl.getboolean, 1.0)
236 self.assertRaises(TclError, tcl.getboolean, 'a')
237 self.assertRaises((TypeError, ValueError, TclError),
238 tcl.getboolean, 'on\0')
239 self.assertRaises((UnicodeEncodeError, ValueError, TclError),
240 tcl.getboolean, 'on\ud800')
241
242 def testEvalFile(self):
243 tcl = self.interp
244 filename = os_helper.TESTFN_ASCII
245 self.addCleanup(os_helper.unlink, filename)
246 with open(filename, 'w') as f:
247 f.write("""set a 1
248 set b 2
249 set c [ expr $a + $b ]
250 """)
251 tcl.evalfile(filename)
252 self.assertEqual(tcl.eval('set a'),'1')
253 self.assertEqual(tcl.eval('set b'),'2')
254 self.assertEqual(tcl.eval('set c'),'3')
255
256 def test_evalfile_null_in_result(self):
257 tcl = self.interp
258 filename = os_helper.TESTFN_ASCII
259 self.addCleanup(os_helper.unlink, filename)
260 with open(filename, 'w') as f:
261 f.write("""
262 set a "a\0b"
263 set b "a\\0b"
264 """)
265 tcl.evalfile(filename)
266 self.assertEqual(tcl.eval('set a'), 'a\x00b')
267 self.assertEqual(tcl.eval('set b'), 'a\x00b')
268
269 def test_evalfile_surrogates_in_result(self):
270 tcl = self.interp
271 encoding = tcl.call('encoding', 'system')
272 self.addCleanup(tcl.call, 'encoding', 'system', encoding)
273 tcl.call('encoding', 'system', 'utf-8')
274
275 filename = os_helper.TESTFN_ASCII
276 self.addCleanup(os_helper.unlink, filename)
277 with open(filename, 'wb') as f:
278 f.write(b"""
279 set a "<\xed\xa0\xbd\xed\xb2\xbb>"
280 """)
281 if tcl_version >= (9, 0):
282 self.assertRaises(TclError, tcl.evalfile, filename)
283 else:
284 tcl.evalfile(filename)
285 self.assertEqual(tcl.eval('set a'), '<\U0001f4bb>')
286
287 with open(filename, 'wb') as f:
288 f.write(b"""
289 set b "<\\ud83d\\udcbb>"
290 """)
291 tcl.evalfile(filename)
292 self.assertEqual(tcl.eval('set b'), '<\U0001f4bb>')
293
294 def testEvalFileException(self):
295 tcl = self.interp
296 filename = "doesnotexists"
297 try:
298 os.remove(filename)
299 except Exception as e:
300 pass
301 self.assertRaises(TclError,tcl.evalfile,filename)
302
303 def testPackageRequireException(self):
304 tcl = self.interp
305 self.assertRaises(TclError,tcl.eval,'package require DNE')
306
307 @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows')
308 def testLoadWithUNC(self):
309 # Build a UNC path from the regular path.
310 # Something like
311 # \\%COMPUTERNAME%\c$\python27\python.exe
312
313 fullname = os.path.abspath(sys.executable)
314 if fullname[1] != ':':
315 raise unittest.SkipTest('Absolute path should have drive part')
316 unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'],
317 fullname[0],
318 fullname[3:])
319 if not os.path.exists(unc_name):
320 raise unittest.SkipTest('Cannot connect to UNC Path')
321
322 with os_helper.EnvironmentVarGuard() as env:
323 env.unset("TCL_LIBRARY")
324 stdout = subprocess.check_output(
325 [unc_name, '-c', 'import tkinter; print(tkinter)'])
326
327 self.assertIn(b'tkinter', stdout)
328
329 def test_exprstring(self):
330 tcl = self.interp
331 tcl.call('set', 'a', 3)
332 tcl.call('set', 'b', 6)
333 def check(expr, expected):
334 result = tcl.exprstring(expr)
335 self.assertEqual(result, expected)
336 self.assertIsInstance(result, str)
337
338 self.assertRaises(TypeError, tcl.exprstring)
339 self.assertRaises(TypeError, tcl.exprstring, '8.2', '+6')
340 self.assertRaises(TypeError, tcl.exprstring, b'8.2 + 6')
341 self.assertRaises(TclError, tcl.exprstring, 'spam')
342 check('', '0')
343 check('8.2 + 6', '14.2')
344 check('3.1 + $a', '6.1')
345 check('2 + "$a.$b"', '5.6')
346 check('4*[llength "6 2"]', '8')
347 check('{word one} < "word $a"', '0')
348 check('4*2 < 7', '0')
349 check('hypot($a, 4)', '5.0')
350 check('5 / 4', '1')
351 check('5 / 4.0', '1.25')
352 check('5 / ( [string length "abcd"] + 0.0 )', '1.25')
353 check('20.0/5.0', '4.0')
354 check('"0x03" > "2"', '1')
355 check('[string length "a\xbd\u20ac"]', '3')
356 check(r'[string length "a\xbd\u20ac"]', '3')
357 check('"abc"', 'abc')
358 check('"a\xbd\u20ac"', 'a\xbd\u20ac')
359 check(r'"a\xbd\u20ac"', 'a\xbd\u20ac')
360 check(r'"a\0b"', 'a\x00b')
361 check('2**64', str(2**64))
362
363 def test_exprdouble(self):
364 tcl = self.interp
365 tcl.call('set', 'a', 3)
366 tcl.call('set', 'b', 6)
367 def check(expr, expected):
368 result = tcl.exprdouble(expr)
369 self.assertEqual(result, expected)
370 self.assertIsInstance(result, float)
371
372 self.assertRaises(TypeError, tcl.exprdouble)
373 self.assertRaises(TypeError, tcl.exprdouble, '8.2', '+6')
374 self.assertRaises(TypeError, tcl.exprdouble, b'8.2 + 6')
375 self.assertRaises(TclError, tcl.exprdouble, 'spam')
376 check('', 0.0)
377 check('8.2 + 6', 14.2)
378 check('3.1 + $a', 6.1)
379 check('2 + "$a.$b"', 5.6)
380 check('4*[llength "6 2"]', 8.0)
381 check('{word one} < "word $a"', 0.0)
382 check('4*2 < 7', 0.0)
383 check('hypot($a, 4)', 5.0)
384 check('5 / 4', 1.0)
385 check('5 / 4.0', 1.25)
386 check('5 / ( [string length "abcd"] + 0.0 )', 1.25)
387 check('20.0/5.0', 4.0)
388 check('"0x03" > "2"', 1.0)
389 check('[string length "a\xbd\u20ac"]', 3.0)
390 check(r'[string length "a\xbd\u20ac"]', 3.0)
391 self.assertRaises(TclError, tcl.exprdouble, '"abc"')
392 check('2**64', float(2**64))
393
394 def test_exprlong(self):
395 tcl = self.interp
396 tcl.call('set', 'a', 3)
397 tcl.call('set', 'b', 6)
398 def check(expr, expected):
399 result = tcl.exprlong(expr)
400 self.assertEqual(result, expected)
401 self.assertIsInstance(result, int)
402
403 self.assertRaises(TypeError, tcl.exprlong)
404 self.assertRaises(TypeError, tcl.exprlong, '8.2', '+6')
405 self.assertRaises(TypeError, tcl.exprlong, b'8.2 + 6')
406 self.assertRaises(TclError, tcl.exprlong, 'spam')
407 check('', 0)
408 check('8.2 + 6', 14)
409 check('3.1 + $a', 6)
410 check('2 + "$a.$b"', 5)
411 check('4*[llength "6 2"]', 8)
412 check('{word one} < "word $a"', 0)
413 check('4*2 < 7', 0)
414 check('hypot($a, 4)', 5)
415 check('5 / 4', 1)
416 check('5 / 4.0', 1)
417 check('5 / ( [string length "abcd"] + 0.0 )', 1)
418 check('20.0/5.0', 4)
419 check('"0x03" > "2"', 1)
420 check('[string length "a\xbd\u20ac"]', 3)
421 check(r'[string length "a\xbd\u20ac"]', 3)
422 self.assertRaises(TclError, tcl.exprlong, '"abc"')
423 self.assertRaises(TclError, tcl.exprlong, '2**64')
424
425 def test_exprboolean(self):
426 tcl = self.interp
427 tcl.call('set', 'a', 3)
428 tcl.call('set', 'b', 6)
429 def check(expr, expected):
430 result = tcl.exprboolean(expr)
431 self.assertEqual(result, expected)
432 self.assertIsInstance(result, int)
433 self.assertNotIsInstance(result, bool)
434
435 self.assertRaises(TypeError, tcl.exprboolean)
436 self.assertRaises(TypeError, tcl.exprboolean, '8.2', '+6')
437 self.assertRaises(TypeError, tcl.exprboolean, b'8.2 + 6')
438 self.assertRaises(TclError, tcl.exprboolean, 'spam')
439 check('', False)
440 for value in ('0', 'false', 'no', 'off'):
441 check(value, False)
442 check('"%s"' % value, False)
443 check('{%s}' % value, False)
444 for value in ('1', 'true', 'yes', 'on'):
445 check(value, True)
446 check('"%s"' % value, True)
447 check('{%s}' % value, True)
448 check('8.2 + 6', True)
449 check('3.1 + $a', True)
450 check('2 + "$a.$b"', True)
451 check('4*[llength "6 2"]', True)
452 check('{word one} < "word $a"', False)
453 check('4*2 < 7', False)
454 check('hypot($a, 4)', True)
455 check('5 / 4', True)
456 check('5 / 4.0', True)
457 check('5 / ( [string length "abcd"] + 0.0 )', True)
458 check('20.0/5.0', True)
459 check('"0x03" > "2"', True)
460 check('[string length "a\xbd\u20ac"]', True)
461 check(r'[string length "a\xbd\u20ac"]', True)
462 self.assertRaises(TclError, tcl.exprboolean, '"abc"')
463 check('2**64', True)
464
465 def test_booleans(self):
466 tcl = self.interp
467 def check(expr, expected):
468 result = tcl.call('expr', expr)
469 if tcl.wantobjects():
470 self.assertEqual(result, expected)
471 self.assertIsInstance(result, int)
472 else:
473 self.assertIn(result, (expr, str(int(expected))))
474 self.assertIsInstance(result, str)
475 check('true', True)
476 check('yes', True)
477 check('on', True)
478 check('false', False)
479 check('no', False)
480 check('off', False)
481 check('1 < 2', True)
482 check('1 > 2', False)
483
484 def test_expr_bignum(self):
485 tcl = self.interp
486 for i in self.get_integers():
487 result = tcl.call('expr', str(i))
488 if self.wantobjects:
489 self.assertEqual(result, i)
490 self.assertIsInstance(result, int)
491 else:
492 self.assertEqual(result, str(i))
493 self.assertIsInstance(result, str)
494
495 def test_passing_values(self):
496 passValue = self.passValue
497
498 self.assertEqual(passValue(True), True if self.wantobjects else '1')
499 self.assertEqual(passValue(False), False if self.wantobjects else '0')
500 self.assertEqual(passValue('string'), 'string')
501 self.assertEqual(passValue('string\u20ac'), 'string\u20ac')
502 self.assertEqual(passValue('string\U0001f4bb'), 'string\U0001f4bb')
503 self.assertEqual(passValue('str\x00ing'), 'str\x00ing')
504 self.assertEqual(passValue('str\x00ing\xbd'), 'str\x00ing\xbd')
505 self.assertEqual(passValue('str\x00ing\u20ac'), 'str\x00ing\u20ac')
506 self.assertEqual(passValue('str\x00ing\U0001f4bb'),
507 'str\x00ing\U0001f4bb')
508 if sys.platform != 'win32':
509 self.assertEqual(passValue('<\udce2\udc82\udcac>'),
510 '<\u20ac>')
511 self.assertEqual(passValue('<\udced\udca0\udcbd\udced\udcb2\udcbb>'),
512 '<\U0001f4bb>')
513 self.assertEqual(passValue(b'str\x00ing'),
514 b'str\x00ing' if self.wantobjects else 'str\x00ing')
515 self.assertEqual(passValue(b'str\xc0\x80ing'),
516 b'str\xc0\x80ing' if self.wantobjects else 'str\xc0\x80ing')
517 self.assertEqual(passValue(b'str\xbding'),
518 b'str\xbding' if self.wantobjects else 'str\xbding')
519 for i in self.get_integers():
520 self.assertEqual(passValue(i), i if self.wantobjects else str(i))
521 for f in (0.0, 1.0, -1.0, 1/3,
522 sys.float_info.min, sys.float_info.max,
523 -sys.float_info.min, -sys.float_info.max):
524 if self.wantobjects:
525 self.assertEqual(passValue(f), f)
526 else:
527 self.assertEqual(float(passValue(f)), f)
528 if self.wantobjects:
529 f = passValue(float('nan'))
530 self.assertNotEqual(f, f)
531 self.assertEqual(passValue(float('inf')), float('inf'))
532 self.assertEqual(passValue(-float('inf')), -float('inf'))
533 else:
534 self.assertEqual(float(passValue(float('inf'))), float('inf'))
535 self.assertEqual(float(passValue(-float('inf'))), -float('inf'))
536 # XXX NaN representation can be not parsable by float()
537 self.assertEqual(passValue((1, '2', (3.4,))),
538 (1, '2', (3.4,)) if self.wantobjects else '1 2 3.4')
539 self.assertEqual(passValue(['a', ['b', 'c']]),
540 ('a', ('b', 'c')) if self.wantobjects else 'a {b c}')
541
542 def test_set_object_concurrent_mutation_in_sequence_conversion(self):
543 # Prevent SIGSEV when the object to convert is concurrently mutated.
544 # See: https://github.com/python/cpython/issues/143310.
545
546 string = "value"
547
548 class Value:
549 def __str__(self):
550 values.clear()
551 return string
552
553 class List(list):
554 pass
555
556 expect = (string, "pad") if self.wantobjects else f"{string} pad"
557 self.assertEqual(self.passValue(values := [Value(), "pad"]), expect)
558 self.assertEqual(self.passValue(values := List([Value(), "pad"])), expect)
559
560 def test_user_command(self):
561 result = None
562 def testfunc(arg):
563 nonlocal result
564 result = arg
565 return arg
566 self.interp.createcommand('testfunc', testfunc)
567 self.addCleanup(self.interp.tk.deletecommand, 'testfunc')
568 def check(value, expected1=None, expected2=None, *, eq=self.assertEqual):
569 expected = value
570 if self.wantobjects >= 2:
571 if expected2 is not None:
572 expected = expected2
573 expected_type = type(expected)
574 else:
575 if expected1 is not None:
576 expected = expected1
577 expected_type = str
578 nonlocal result
579 result = None
580 r = self.interp.call('testfunc', value)
581 self.assertIsInstance(result, expected_type)
582 eq(result, expected)
583 self.assertIsInstance(r, expected_type)
584 eq(r, expected)
585 def float_eq(actual, expected):
586 self.assertAlmostEqual(float(actual), expected,
587 delta=abs(expected) * 1e-10)
588
589 check(True, '1', 1)
590 check(False, '0', 0)
591 check('string')
592 check('string\xbd')
593 check('string\u20ac')
594 check('string\U0001f4bb')
595 if sys.platform != 'win32':
596 check('<\udce2\udc82\udcac>', '<\u20ac>', '<\u20ac>')
597 check('<\udced\udca0\udcbd\udced\udcb2\udcbb>', '<\U0001f4bb>', '<\U0001f4bb>')
598 check('')
599 check(b'string', 'string')
600 check(b'string\xe2\x82\xac', 'string\xe2\x82\xac')
601 check(b'string\xbd', 'string\xbd')
602 check(b'', '')
603 check('str\x00ing')
604 check('str\x00ing\xbd')
605 check('str\x00ing\u20ac')
606 check(b'str\x00ing', 'str\x00ing')
607 check(b'str\xc0\x80ing', 'str\xc0\x80ing')
608 check(b'str\xc0\x80ing\xe2\x82\xac', 'str\xc0\x80ing\xe2\x82\xac')
609 for i in self.get_integers():
610 check(i, str(i))
611 for f in (0.0, 1.0, -1.0):
612 check(f, repr(f))
613 for f in (1/3.0, sys.float_info.min, sys.float_info.max,
614 -sys.float_info.min, -sys.float_info.max):
615 check(f, eq=float_eq)
616 check(float('inf'), eq=float_eq)
617 check(-float('inf'), eq=float_eq)
618 # XXX NaN representation can be not parsable by float()
619 check((), '', '')
620 check((1, (2,), (3, 4), '5 6', ()),
621 '1 2 {3 4} {5 6} {}',
622 (1, (2,), (3, 4), '5 6', ''))
623 check([1, [2,], [3, 4], '5 6', []],
624 '1 2 {3 4} {5 6} {}',
625 (1, (2,), (3, 4), '5 6', ''))
626
627 def test_passing_tcl_obj(self):
628 tcl = self.interp.tk
629 a = None
630 def testfunc(arg):
631 nonlocal a
632 a = arg
633 self.interp.createcommand('testfunc', testfunc)
634 self.addCleanup(self.interp.tk.deletecommand, 'testfunc')
635 tcl.eval(r'set a "\u20ac \ud83d\udcbb \0 \udcab"; regexp -about $a')
636 tcl.eval(r'testfunc $a')
637 expected = '\u20ac \U0001f4bb \0 \udced\udcb2\udcab'
638 if self.wantobjects >= 2:
639 self.assertEqual(str(a), expected)
640 self.assertEqual(a.string, expected)
641 self.assertEqual(a.typename, 'regexp')
642 else:
643 self.assertEqual(a, expected)
644
645 def test_splitlist(self):
646 splitlist = self.interp.tk.splitlist
647 call = self.interp.tk.call
648 self.assertRaises(TypeError, splitlist)
649 self.assertRaises(TypeError, splitlist, 'a', 'b')
650 self.assertRaises(TypeError, splitlist, 2)
651 testcases = [
652 ('2', ('2',)),
653 ('', ()),
654 ('{}', ('',)),
655 ('""', ('',)),
656 ('a\n b\t\r c\n ', ('a', 'b', 'c')),
657 (b'a\n b\t\r c\n ', ('a', 'b', 'c')),
658 ('a \u20ac', ('a', '\u20ac')),
659 ('a \U0001f4bb', ('a', '\U0001f4bb')),
660 (b'a \xe2\x82\xac', ('a', '\u20ac')),
661 (b'a \xf0\x9f\x92\xbb', ('a', '\U0001f4bb')),
662 (b'a \xed\xa0\xbd\xed\xb2\xbb', ('a', '\U0001f4bb')),
663 (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')),
664 ('a {b c}', ('a', 'b c')),
665 (r'a b\ c', ('a', 'b c')),
666 (('a', 'b c'), ('a', 'b c')),
667 ('a 2', ('a', '2')),
668 (('a', 2), ('a', 2)),
669 ('a 3.4', ('a', '3.4')),
670 (('a', 3.4), ('a', 3.4)),
671 ((), ()),
672 ([], ()),
673 (['a', ['b', 'c']], ('a', ['b', 'c'])),
674 (call('list', 1, '2', (3.4,)),
675 (1, '2', (3.4,)) if self.wantobjects else
676 ('1', '2', '3.4')),
677 ]
678 if not self.wantobjects:
679 expected = ('12', '\u20ac', '\xe2\x82\xac', '3.4')
680 else:
681 expected = (12, '\u20ac', b'\xe2\x82\xac', (3.4,))
682 testcases += [
683 (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)),
684 expected),
685 ]
686 dbg_info = ('want objects? %s, Tcl version: %s, Tcl patchlevel: %s'
687 % (self.wantobjects, tcl_version, self.interp.info_patchlevel()))
688 for arg, res in testcases:
689 self.assertEqual(splitlist(arg), res,
690 'arg=%a, %s' % (arg, dbg_info))
691 self.assertRaises(TclError, splitlist, '{')
692
693 def test_splitdict(self):
694 splitdict = tkinter._splitdict
695 tcl = self.interp.tk
696
697 arg = '-a {1 2 3} -something foo status {}'
698 self.assertEqual(splitdict(tcl, arg, False),
699 {'-a': '1 2 3', '-something': 'foo', 'status': ''})
700 self.assertEqual(splitdict(tcl, arg),
701 {'a': '1 2 3', 'something': 'foo', 'status': ''})
702
703 arg = ('-a', (1, 2, 3), '-something', 'foo', 'status', '{}')
704 self.assertEqual(splitdict(tcl, arg, False),
705 {'-a': (1, 2, 3), '-something': 'foo', 'status': '{}'})
706 self.assertEqual(splitdict(tcl, arg),
707 {'a': (1, 2, 3), 'something': 'foo', 'status': '{}'})
708
709 self.assertRaises(RuntimeError, splitdict, tcl, '-a b -c ')
710 self.assertRaises(RuntimeError, splitdict, tcl, ('-a', 'b', '-c'))
711
712 arg = tcl.call('list',
713 '-a', (1, 2, 3), '-something', 'foo', 'status', ())
714 self.assertEqual(splitdict(tcl, arg),
715 {'a': (1, 2, 3) if self.wantobjects else '1 2 3',
716 'something': 'foo', 'status': ''})
717
718 arg = tcl.call('dict', 'create',
719 '-a', (1, 2, 3), '-something', 'foo', 'status', ())
720 if not self.wantobjects:
721 expected = {'a': '1 2 3', 'something': 'foo', 'status': ''}
722 else:
723 expected = {'a': (1, 2, 3), 'something': 'foo', 'status': ''}
724 self.assertEqual(splitdict(tcl, arg), expected)
725
726 def test_join(self):
727 join = tkinter._join
728 tcl = self.interp.tk
729 def unpack(s):
730 return tcl.call('lindex', s, 0)
731 def check(value):
732 self.assertEqual(unpack(join([value])), value)
733 self.assertEqual(unpack(join([value, 0])), value)
734 self.assertEqual(unpack(unpack(join([[value]]))), value)
735 self.assertEqual(unpack(unpack(join([[value, 0]]))), value)
736 self.assertEqual(unpack(unpack(join([[value], 0]))), value)
737 self.assertEqual(unpack(unpack(join([[value, 0], 0]))), value)
738 check('')
739 check('spam')
740 check('sp am')
741 check('sp\tam')
742 check('sp\nam')
743 check(' \t\n')
744 check('{spam}')
745 check('{sp am}')
746 check('"spam"')
747 check('"sp am"')
748 check('{"spam"}')
749 check('"{spam}"')
750 check('sp\\am')
751 check('"sp\\am"')
752 check('"{}" "{}"')
753 check('"\\')
754 check('"{')
755 check('"}')
756 check('\n\\')
757 check('\n{')
758 check('\n}')
759 check('\\\n')
760 check('{\n')
761 check('}\n')
762
763 @support.cpython_only
764 def test_new_tcl_obj(self):
765 support.check_disallow_instantiation(self, _tkinter.Tcl_Obj)
766 support.check_disallow_instantiation(self, _tkinter.TkttType)
767 support.check_disallow_instantiation(self, _tkinter.TkappType)
768
769
770 class BigmemTclTest(unittest.TestCase):
771
772 def setUp(self):
773 self.interp = Tcl()
774
775 @support.cpython_only
776 @unittest.skipUnless(INT_MAX < PY_SSIZE_T_MAX, "needs UINT_MAX < SIZE_MAX")
777 @support.bigmemtest(size=INT_MAX + 1, memuse=5, dry_run=False)
778 def test_huge_string_call(self, size):
779 value = ' ' * size
780 self.assertRaises(OverflowError, self.interp.call, 'string', 'index', value, 0)
781
782 @support.cpython_only
783 @unittest.skipUnless(INT_MAX < PY_SSIZE_T_MAX, "needs UINT_MAX < SIZE_MAX")
784 @support.bigmemtest(size=INT_MAX + 1, memuse=2, dry_run=False)
785 def test_huge_string_builtins(self, size):
786 tk = self.interp.tk
787 value = '1' + ' ' * size
788 self.assertRaises(OverflowError, tk.getint, value)
789 self.assertRaises(OverflowError, tk.getdouble, value)
790 self.assertRaises(OverflowError, tk.getboolean, value)
791 self.assertRaises(OverflowError, tk.eval, value)
792 self.assertRaises(OverflowError, tk.evalfile, value)
793 self.assertRaises(OverflowError, tk.record, value)
794 self.assertRaises(OverflowError, tk.adderrorinfo, value)
795 self.assertRaises(OverflowError, tk.setvar, value, 'x', 'a')
796 self.assertRaises(OverflowError, tk.setvar, 'x', value, 'a')
797 self.assertRaises(OverflowError, tk.unsetvar, value)
798 self.assertRaises(OverflowError, tk.unsetvar, 'x', value)
799 self.assertRaises(OverflowError, tk.adderrorinfo, value)
800 self.assertRaises(OverflowError, tk.exprstring, value)
801 self.assertRaises(OverflowError, tk.exprlong, value)
802 self.assertRaises(OverflowError, tk.exprboolean, value)
803 self.assertRaises(OverflowError, tk.splitlist, value)
804 self.assertRaises(OverflowError, tk.createcommand, value, max)
805 self.assertRaises(OverflowError, tk.deletecommand, value)
806
807 @support.cpython_only
808 @unittest.skipUnless(INT_MAX < PY_SSIZE_T_MAX, "needs UINT_MAX < SIZE_MAX")
809 @support.bigmemtest(size=INT_MAX + 1, memuse=6, dry_run=False)
810 def test_huge_string_builtins2(self, size):
811 # These commands require larger memory for possible error messages
812 tk = self.interp.tk
813 value = '1' + ' ' * size
814 self.assertRaises(OverflowError, tk.evalfile, value)
815 self.assertRaises(OverflowError, tk.unsetvar, value)
816 self.assertRaises(OverflowError, tk.unsetvar, 'x', value)
817
818
819 def setUpModule():
820 wantobjects = support.get_resource_value('wantobjects')
821 if wantobjects is not None:
822 unittest.enterModuleContext(
823 support.swap_attr(tkinter, 'wantobjects', int(wantobjects)))
824 if support.verbose:
825 tcl = Tcl()
826 print('patchlevel =', tcl.call('info', 'patchlevel'), flush=True)
827
828
829 if __name__ == "__main__":
830 unittest.main()