def tcl_interp(): """ create a new Tcl interpreter with the standard packages loaded TESTS:: sage: from yacop.utils.tcl import tcl_interp, tcl_eval sage: tcl = tcl_interp() sage: tcl.eval("package present sqlite3") # random 3.8.2 """ tcl = Tcl() xdirs = Yacop.tcllibrary if not xdirs is None: if not isinstance(xdirs, list): xdirs = [xdirs] [tcl.eval("lappend auto_path {%s}" % path) for path in xdirs] tcl.eval( """ lappend auto_path $::env(SAGE_LOCAL)/tcl/lib lappend auto_path $::env(SAGE_LOCAL)/lib package require yacop::sage 1.0 """ ) return tcl
def get_tk_patchlevel(): global _tk_patchlevel if _tk_patchlevel is None: tcl = Tcl() patchlevel = [] for x in tcl.call('info', 'patchlevel').split('.'): try: x = int(x, 10) except ValueError: x = -1 patchlevel.append(x) _tk_patchlevel = tuple(patchlevel) return _tk_patchlevel
def get_tk_patchlevel(): global _tk_patchlevel if _tk_patchlevel is None: tcl = Tcl() patchlevel = tcl.call('info', 'patchlevel') m = re.fullmatch(r'(\d+)\.(\d+)([ab.])(\d+)', patchlevel) major, minor, releaselevel, serial = m.groups() major, minor, serial = int(major), int(minor), int(serial) releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel] if releaselevel == 'final': _tk_patchlevel = major, minor, serial, releaselevel, 0 else: _tk_patchlevel = major, minor, 0, releaselevel, serial return _tk_patchlevel
def __init__(self, sim_dir, fn_root, **kwargs): rms = kwargs.get('rms', False) down = kwargs.get('downsample', 1) self.sim_dir = sim_dir datp_dir = os.path.join(sim_dir, 'datp') rotation = kwargs.get('rotation', 0) self.rot = rotation / 180 * np.pi self.length_scale = kwargs.get('length_scale', 96) # Find what you're looking for fns = [fn for fn in os.listdir(datp_dir) if fn.startswith(fn_root) and fn.endswith('.pvti')] # Sort files fns = Tcl().call('lsort', '-dict', fns) if len(fns) > 1: print("More than one fn with this name. Taking time average.") # Store snapshots of field self.snaps = [] for fn in fns[::down]: snap = vti_to_mesh(os.path.join(datp_dir, fn), self.length_scale) self.snaps.append(snap) del snap # Time average the flow field snaps mean_t = np.mean(np.array(self.snaps).T, axis=1) self.X, self.Y = mean_t[0:2] self.u, self.v, self.w = mean_t[2:-1] self.U, self.V = np.mean(self.u, axis=2), np.mean(self.v, axis=2) self.p = np.mean(mean_t[-1], axis=0) del mean_t else: # assert (len(fns) > 0), 'You dont have '+fn_root+'.pvtr in your datp folder' self.X, self.Y, self.U, self.V, self.W, self.p = vti_to_mesh(os.path.join(datp_dir, fns[0]), self.length_scale) self.U, self.V = np.squeeze(self.U), np.squeeze(self.V) self.p = np.squeeze(self.p)
def __init__(self, path, img_size=640): p = str(Path(path)) # os-agnostic p = os.path.abspath(p) # absolute path if '*' in p: files = sorted(glob.glob(p, recursive=True)) # glob elif os.path.isdir(p): files = Tcl().call('lsort', '-dict', glob.glob(os.path.join(p, '*.*'))) elif os.path.isfile(p): files = [p] # files else: raise Exception('ERROR: %s does not exist' % p) images = [x for x in files if x.split('.')[-1].lower() in img_formats] videos = [x for x in files if x.split('.')[-1].lower() in vid_formats] ni, nv = len(images), len(videos) self.img_size = img_size self.files = images + videos self.nf = ni + nv # number of files self.video_flag = [False] * ni + [True] * nv self.mode = 'images' if any(videos): self.new_video(videos[0]) # new video else: self.cap = None assert self.nf > 0, 'No images or videos found in %s. Supported formats are:\nimages: %s\nvideos: %s' % \ (p, img_formats, vid_formats)
def hook_tkinter(finder, module): """Recusively copy tcl and tk directories""" from tkinter import Tcl from _tkinter import TK_VERSION tcl_dir = os.path.normpath(Tcl().eval("info library")) assert os.path.isdir(tcl_dir) finder.add_datadirectory("lib/tcl", tcl_dir, recursive=True) tk_dir = os.path.join(os.path.dirname(tcl_dir), 'tk{}'.format(TK_VERSION)) assert os.path.isdir(tk_dir) finder.add_datadirectory("lib/tk", tk_dir, recursive=True) finder.set_min_bundle("tkinter", 2) if sys.version_info >= (3, 6, 0): finder.import_hook("imp") # import DLLs tk_ver = TK_VERSION.replace('.', '') import glob for dll_search in ["tcl" + tk_ver + "*.dll", "tk" + tk_ver + "*.dll"]: for dll_path in glob.glob( os.path.join(sys.base_prefix, "DLLs", dll_search)): dll_name = os.path.basename(dll_path) finder.add_dll(dll_path) # add environment variables that point to the copied paths at runtime finder.add_bootcode(""" def tk_env_paths(): import os tcl_dir = os.path.join(os.getcwd(), 'lib', 'tcl') tk_dir = os.path.join(os.getcwd(), 'lib', 'tk') os.environ["TCL_LIBRARY"] = tcl_dir os.environ["TK_LIBRARY"] = tk_dir tk_env_paths() del tk_env_paths """)
def hook_tkinter(finder, module): """Recusively copy tcl and tk directories""" from tkinter import Tcl from _tkinter import TK_VERSION tcl_dir = os.path.normpath(Tcl().eval("info library")) assert os.path.isdir(tcl_dir) finder.add_datadirectory("lib/tcl", tcl_dir, recursive=True) tk_dir = os.path.join(os.path.dirname(tcl_dir), 'tk{}'.format(TK_VERSION)) assert os.path.isdir(tk_dir) finder.add_datadirectory("lib/tk", tk_dir, recursive=True) if sys.version_info >= (3, 6, 0): finder.import_hook("imp") # add environment variables that point to the copied paths at runtime finder.add_bootcode(""" def tk_env_paths(): import os import sys import _tkinter basepath = os.path.dirname(sys.executable) tcl_dir = os.path.join(basepath, 'lib', 'tcl') tk_dir = os.path.join(basepath, 'lib', 'tk') os.environ["TCL_LIBRARY"] = tcl_dir os.environ["TK_LIBRARY"] = tk_dir tk_env_paths() del tk_env_paths """)
class TgnTk: """Native Python Tk interpreter.""" def __init__(self) -> None: """Init Tcl object.""" self.tcl = Tcl() def eval(self, command: str) -> str: # noqa: A003 """Execute Tcl eval command.""" return self.tcl.eval(command)
def get_nlast_images(nb_images): imgs_list_full_dir = f"{ROOT_DIR}/_tmp/full/" os.chdir(imgs_list_full_dir) images_taken = glob.glob('*.JPG') images_taken.extend(glob.glob('*.jpeg')) images_taken.extend(glob.glob('*.jpg')) images_taken_sorted = Tcl().call('lsort', '-dict', images_taken) return images_taken_sorted if nb_images == -1 else images_taken_sorted[-nb_images:]
def testLoadTk(self): import os if 'DISPLAY' not in os.environ: # skipping test of clean upgradeability return tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) tcl.loadtk() self.assertEqual('1x1+0+0', tcl.winfo_geometry()) tcl.destroy()
def _init_tcl(self): """Initialize Tcl interpreter. Returns: None """ try: self.Tcl is None except AttributeError: self.Tcl = Tcl() # Define logger def tcl_puts(*args): """Enables logging for tcl output. Returns: None """ if len(args) >= 2: stream = args[0] if stream == "stdout": self.class_logger.debug(" ".join(args[1:])) elif stream == "stderr": self.class_logger.error(" ".join(args[1:])) else: self.class_logger.debug("stream <%s>: %s" % (args[0], " ".join(args[1:]))) elif len(args) == 1: self.class_logger.debug(args[0]) else: self.class_logger.error("Called puts without arguments.") return None self.Tcl.createcommand("tcl_puts", tcl_puts) self.class_logger.debug("Insert tcl script to catch puts output.") ixia_helpers.tcl_puts_replace(self.Tcl) ixia_helpers.ixtclhal_import(self.Tcl)
def testLoadTkFailure(self): old_display = None if sys.platform.startswith(('win', 'darwin', 'cygwin')): return with test_support.EnvironmentVarGuard() as env: if 'DISPLAY' in os.environ: del env['DISPLAY'] with os.popen('echo $DISPLAY') as pipe: display = pipe.read().strip() if display: return tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) self.assertRaises(TclError, tcl.loadtk)
def cards(): path = f"{ROOT_DIR}/_tmp/cards" os.chdir(path) images_taken = glob.glob('*.JPG') images_taken.extend(glob.glob('*.jpeg')) images_taken.extend(glob.glob('*.jpg')) images_taken_sorted = Tcl().call('lsort', '-dict', images_taken) images_taken_sorted = list(reversed(images_taken_sorted)) return render_template('cards.html', images_list=images_taken_sorted, classes=generate_grid_classes( len(images_taken_sorted)))
def animate(self, folder, **kwargs): for idx, snap in enumerate(self.snaps): dat = np.array(snap).T plot_2D_fp_isocontours(dat, 'mag', folder + str(idx) + '.png', **kwargs) # Sort filenames to make sure they're in order fn_images = os.listdir(folder) fn_images = Tcl().call('lsort', '-dict', fn_images) images = [] for filename in fn_images: images.append(imageio.imread(os.path.join(folder, filename))) imageio.mimsave(folder + '/flow.gif', images, duration=0.2, bitrate=1000)
def testLoadTk(self): import os if 'DISPLAY' not in os.environ: # skipping test of clean upgradeability return tcl = Tcl() self.assertRaises(TclError,tcl.winfo_geometry) tcl.loadtk() self.assertEqual('1x1+0+0', tcl.winfo_geometry()) tcl.destroy()
def __init__(self, sim_dir, fn_root, **kwargs): rms = kwargs.get('rms', False) down = kwargs.get('downsample', 1) self.sim_dir = sim_dir datp_dir = os.path.join(sim_dir, 'datp') rotation = kwargs.get('rotation', 0) self.rot = 0 self.length_scale = kwargs.get('length_scale', 96) # Find what you're looking for fns = [ fn for fn in os.listdir(datp_dir) if fn.startswith(fn_root) and fn.endswith('.pvtr') ] # Sort files fns = Tcl().call('lsort', '-dict', fns) if len(fns) > 1: print("More than one fn with this name. Taking time average.") # Store snapshots of field self.snaps = [] for fn in fns[::down]: snap = vtr_to_mesh(os.path.join(datp_dir, fn), self.length_scale) self.snaps.append(snap) del snap # Time average the flow field snaps mean_t = np.mean(np.array(self.snaps).T, axis=1) self.X, self.Y = mean_t[0:2] self.u, self.v, self.w = mean_t[2:-1] self.U, self.V = np.mean(self.u, axis=2), np.mean(self.v, axis=2) self.p = np.mean(mean_t[-1], axis=0) del mean_t else: assert (len(fns) > 0 ), 'You dont have ' + fn_root + '.pvtr in your datp folder' self.X, self.Y, self.U, self.V, self.W, self.p = vtr_to_mesh( os.path.join(datp_dir, fns[0]), self.length_scale) self.U, self.V = np.squeeze(self.U), np.squeeze(self.V) self.p = np.squeeze(self.p) self.z = np.ones(np.shape(self.X)) # --- Unpack mean flow quantities --- names = kwargs.get('names', [ 't', 'dt', 'px', 'py', 'pz', 'vx', 'vy', 'vz', 'v2x', 'v2y', 'v2z' ]) fos = (io.unpack_flex_forces(os.path.join(self.sim_dir, 'fort.9'), names)) self.fos = dict(zip(names, fos))
def generate_corpus(txt_dirs): for txt_dir in txt_dirs: corpus_full_path = txt_dir + '/corpus.txt' if path.exists(corpus_full_path): print('Corpus exists, returning...') continue with open(corpus_full_path, 'w+') as corpus: # Need to preserve order for file in Tcl().call('lsort', '-dict', os.listdir(txt_dir)): full_path = txt_dir + '/' + file with open(full_path, 'r') as source: corpus.write(source.read()) corpus.write(' ')
def create_txt(set, ids): path = os.path.join('datasets', args.project) os.makedirs(path, exist_ok=True) with open(os.path.join(path, f'{set}.txt'), 'w') as f: for label, id in enumerate(ids): if (val_size == 0) and (set == 'val'): break images = os.listdir(os.path.join(root, id)) images = Tcl().call('lsort', '-dict', images) # sort if val_size != 0: if set == 'train': images = images[:-val_size] elif set == 'val': images = images[-val_size:] for image in images: f.write(f'{id}/{image} {label}\n') return print(f'------{set}.txt created------')
def testLoadTkFailure(self): old_display = None if sys.platform.startswith(('win', 'darwin', 'cygwin')): # no failure possible on windows? # XXX Maybe on tk older than 8.4.13 it would be possible, # see tkinter.h. return with test_support.EnvironmentVarGuard() as env: if 'DISPLAY' in os.environ: del env['DISPLAY'] # on some platforms, deleting environment variables # doesn't actually carry through to the process level # because they don't support unsetenv # If that's the case, abort. display = os.popen('echo $DISPLAY').read().strip() if display: return tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) self.assertRaises(TclError, tcl.loadtk)
def testLoadTkFailure(self): import os old_display = None import sys if sys.platform.startswith(('win', 'darwin', 'cygwin')): return # no failure possible on windows? if 'DISPLAY' in os.environ: old_display = os.environ['DISPLAY'] del os.environ['DISPLAY'] # on some platforms, deleting environment variables # doesn't actually carry through to the process level # because they don't support unsetenv # If that's the case, abort. display = os.popen('echo $DISPLAY').read().strip() if display: return try: tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) self.assertRaises(TclError, tcl.loadtk) finally: if old_display is not None: os.environ['DISPLAY'] = old_display
def __check_enviroment(self): try: self.py_Version = platform.python_version() self.py_Compiler = platform.python_compiler() self.py_Build = platform.python_build() major, minor, patch = self.py_Version.split(".") if (int(major) < MIN_PY_MAJOR_VERSION) or ( (int(major) == MIN_PY_MAJOR_VERSION) and (int(minor) < MIN_PY_MINOR_VERSION) ): raise Exception( "Python Version " + MIN_TCL_MAJOR_VERSION + "." + MIN_TCL_MINOR_VERSION + ".x or higher required" ) self.tcl_Version = Tcl().eval("info patchlevel") major, minor, patch = self.tcl_Version.split(".") if (int(major) < MIN_TCL_MAJOR_VERSION) or ( (int(major) == MIN_TCL_MAJOR_VERSION) and (int(minor) < MIN_TCL_MINOR_VERSION) ): raise Exception( "TCL Version " + MIN_TCL_MAJOR_VERSION + "." + MIN_TCL_MINOR_VERSION + ".x or higher required" ) except: raise
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'), '1') def test_eval_null_in_result(self): tcl = self.interp self.assertEqual(tcl.eval('set a "a\\0b"'), 'a\x00b') def test_eval_surrogates_in_result(self): tcl = self.interp self.assertIn(tcl.eval(r'set a "<\ud83d\udcbb>"'), '<\U0001f4bb>') def testEvalException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'this is wrong') def testCall(self): tcl = self.interp tcl.call('set', 'a', '1') self.assertEqual(tcl.call('set', 'a'), '1') def testCallException(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'set', 'a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'this', 'is', 'wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a', '1') self.assertEqual(tcl.eval('set a'), '1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)', '1') self.assertEqual(tcl.eval('set a(1)'), '1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'), '1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'), '1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a', 1) self.assertEqual(tcl.eval('info exists a'), '1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'), '0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)', 1) tcl.setvar('a(2)', 2) self.assertEqual(tcl.eval('info exists a(1)'), '1') self.assertEqual(tcl.eval('info exists a(2)'), '1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'), '0') self.assertEqual(tcl.eval('info exists a(2)'), '1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.unsetvar, 'a') def get_integers(self): integers = (0, 1, -1, 2**31 - 1, -2**31, 2**31, -2**31 - 1, 2**63 - 1, -2**63) # bignum was added in Tcl 8.5, but its support is able only since 8.5.8. # Actually it is determined at compile time, so using get_tk_patchlevel() # is not reliable. # TODO: expose full static version. if tcl_version >= (8, 5): v = get_tk_patchlevel() if v >= (8, 6, 0, 'final') or (8, 5, 8) <= v < (8, 6): integers += (2**63, -2**63 - 1, 2**1000, -2**1000) return integers def test_getint(self): tcl = self.interp.tk for i in self.get_integers(): self.assertEqual(tcl.getint(' %d ' % i), i) if tcl_version >= (8, 5): self.assertEqual(tcl.getint(' %#o ' % i), i) self.assertEqual(tcl.getint((' %#o ' % i).replace('o', '')), i) self.assertEqual(tcl.getint(' %#x ' % i), i) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.getint, str(2**1000)) self.assertEqual(tcl.getint(42), 42) self.assertRaises(TypeError, tcl.getint) self.assertRaises(TypeError, tcl.getint, '42', '10') self.assertRaises(TypeError, tcl.getint, b'42') self.assertRaises(TypeError, tcl.getint, 42.0) self.assertRaises(TclError, tcl.getint, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getint, '42\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getint, '42\ud800') def test_getdouble(self): tcl = self.interp.tk self.assertEqual(tcl.getdouble(' 42 '), 42.0) self.assertEqual(tcl.getdouble(' 42.5 '), 42.5) self.assertEqual(tcl.getdouble(42.5), 42.5) self.assertEqual(tcl.getdouble(42), 42.0) self.assertRaises(TypeError, tcl.getdouble) self.assertRaises(TypeError, tcl.getdouble, '42.5', '10') self.assertRaises(TypeError, tcl.getdouble, b'42.5') self.assertRaises(TclError, tcl.getdouble, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getdouble, '42.5\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getdouble, '42.5\ud800') def test_getboolean(self): tcl = self.interp.tk self.assertIs(tcl.getboolean('on'), True) self.assertIs(tcl.getboolean('1'), True) self.assertIs(tcl.getboolean(42), True) self.assertIs(tcl.getboolean(0), False) self.assertRaises(TypeError, tcl.getboolean) self.assertRaises(TypeError, tcl.getboolean, 'on', '1') self.assertRaises(TypeError, tcl.getboolean, b'on') self.assertRaises(TypeError, tcl.getboolean, 1.0) self.assertRaises(TclError, tcl.getboolean, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getboolean, 'on\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getboolean, 'on\ud800') def testEvalFile(self): tcl = self.interp filename = os_helper.TESTFN_ASCII self.addCleanup(os_helper.unlink, filename) with open(filename, 'w') as f: f.write("""set a 1 set b 2 set c [ expr $a + $b ] """) tcl.evalfile(filename) self.assertEqual(tcl.eval('set a'), '1') self.assertEqual(tcl.eval('set b'), '2') self.assertEqual(tcl.eval('set c'), '3') def test_evalfile_null_in_result(self): tcl = self.interp filename = os_helper.TESTFN_ASCII self.addCleanup(os_helper.unlink, filename) with open(filename, 'w') as f: f.write(""" set a "a\0b" set b "a\\0b" """) tcl.evalfile(filename) self.assertEqual(tcl.eval('set a'), 'a\x00b') self.assertEqual(tcl.eval('set b'), 'a\x00b') def test_evalfile_surrogates_in_result(self): tcl = self.interp encoding = tcl.call('encoding', 'system') self.addCleanup(tcl.call, 'encoding', 'system', encoding) tcl.call('encoding', 'system', 'utf-8') filename = os_helper.TESTFN_ASCII self.addCleanup(os_helper.unlink, filename) with open(filename, 'wb') as f: f.write(b""" set a "<\xed\xa0\xbd\xed\xb2\xbb>" set b "<\\ud83d\\udcbb>" """) tcl.evalfile(filename) self.assertEqual(tcl.eval('set a'), '<\U0001f4bb>') self.assertEqual(tcl.eval('set b'), '<\U0001f4bb>') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError, tcl.evalfile, filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with os_helper.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") stdout = subprocess.check_output( [unc_name, '-c', 'import tkinter; print(tkinter)']) self.assertIn(b'tkinter', stdout) def test_exprstring(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprstring(expr) self.assertEqual(result, expected) self.assertIsInstance(result, str) self.assertRaises(TypeError, tcl.exprstring) self.assertRaises(TypeError, tcl.exprstring, '8.2', '+6') self.assertRaises(TypeError, tcl.exprstring, b'8.2 + 6') self.assertRaises(TclError, tcl.exprstring, 'spam') check('', '0') check('8.2 + 6', '14.2') check('3.1 + $a', '6.1') check('2 + "$a.$b"', '5.6') check('4*[llength "6 2"]', '8') check('{word one} < "word $a"', '0') check('4*2 < 7', '0') check('hypot($a, 4)', '5.0') check('5 / 4', '1') check('5 / 4.0', '1.25') check('5 / ( [string length "abcd"] + 0.0 )', '1.25') check('20.0/5.0', '4.0') check('"0x03" > "2"', '1') check('[string length "a\xbd\u20ac"]', '3') check(r'[string length "a\xbd\u20ac"]', '3') check('"abc"', 'abc') check('"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\0b"', 'a\x00b') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', str(2**64)) def test_exprdouble(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprdouble(expr) self.assertEqual(result, expected) self.assertIsInstance(result, float) self.assertRaises(TypeError, tcl.exprdouble) self.assertRaises(TypeError, tcl.exprdouble, '8.2', '+6') self.assertRaises(TypeError, tcl.exprdouble, b'8.2 + 6') self.assertRaises(TclError, tcl.exprdouble, 'spam') check('', 0.0) check('8.2 + 6', 14.2) check('3.1 + $a', 6.1) check('2 + "$a.$b"', 5.6) check('4*[llength "6 2"]', 8.0) check('{word one} < "word $a"', 0.0) check('4*2 < 7', 0.0) check('hypot($a, 4)', 5.0) check('5 / 4', 1.0) check('5 / 4.0', 1.25) check('5 / ( [string length "abcd"] + 0.0 )', 1.25) check('20.0/5.0', 4.0) check('"0x03" > "2"', 1.0) check('[string length "a\xbd\u20ac"]', 3.0) check(r'[string length "a\xbd\u20ac"]', 3.0) self.assertRaises(TclError, tcl.exprdouble, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', float(2**64)) def test_exprlong(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprlong(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertRaises(TypeError, tcl.exprlong) self.assertRaises(TypeError, tcl.exprlong, '8.2', '+6') self.assertRaises(TypeError, tcl.exprlong, b'8.2 + 6') self.assertRaises(TclError, tcl.exprlong, 'spam') check('', 0) check('8.2 + 6', 14) check('3.1 + $a', 6) check('2 + "$a.$b"', 5) check('4*[llength "6 2"]', 8) check('{word one} < "word $a"', 0) check('4*2 < 7', 0) check('hypot($a, 4)', 5) check('5 / 4', 1) check('5 / 4.0', 1) check('5 / ( [string length "abcd"] + 0.0 )', 1) check('20.0/5.0', 4) check('"0x03" > "2"', 1) check('[string length "a\xbd\u20ac"]', 3) check(r'[string length "a\xbd\u20ac"]', 3) self.assertRaises(TclError, tcl.exprlong, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.exprlong, '2**64') def test_exprboolean(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprboolean(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertNotIsInstance(result, bool) self.assertRaises(TypeError, tcl.exprboolean) self.assertRaises(TypeError, tcl.exprboolean, '8.2', '+6') self.assertRaises(TypeError, tcl.exprboolean, b'8.2 + 6') self.assertRaises(TclError, tcl.exprboolean, 'spam') check('', False) for value in ('0', 'false', 'no', 'off'): check(value, False) check('"%s"' % value, False) check('{%s}' % value, False) for value in ('1', 'true', 'yes', 'on'): check(value, True) check('"%s"' % value, True) check('{%s}' % value, True) check('8.2 + 6', True) check('3.1 + $a', True) check('2 + "$a.$b"', True) check('4*[llength "6 2"]', True) check('{word one} < "word $a"', False) check('4*2 < 7', False) check('hypot($a, 4)', True) check('5 / 4', True) check('5 / 4.0', True) check('5 / ( [string length "abcd"] + 0.0 )', True) check('20.0/5.0', True) check('"0x03" > "2"', True) check('[string length "a\xbd\u20ac"]', True) check(r'[string length "a\xbd\u20ac"]', True) self.assertRaises(TclError, tcl.exprboolean, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', True) @unittest.skipUnless(tcl_version >= (8, 5), 'requires Tcl version >= 8.5') def test_booleans(self): tcl = self.interp def check(expr, expected): result = tcl.call('expr', expr) if tcl.wantobjects(): self.assertEqual(result, expected) self.assertIsInstance(result, int) else: self.assertIn(result, (expr, str(int(expected)))) self.assertIsInstance(result, str) check('true', True) check('yes', True) check('on', True) check('false', False) check('no', False) check('off', False) check('1 < 2', True) check('1 > 2', False) def test_expr_bignum(self): tcl = self.interp for i in self.get_integers(): result = tcl.call('expr', str(i)) if self.wantobjects: self.assertEqual(result, i) self.assertIsInstance(result, int) else: self.assertEqual(result, str(i)) self.assertIsInstance(result, str) if get_tk_patchlevel() < (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.call, 'expr', str(2**1000)) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True if self.wantobjects else '1') self.assertEqual(passValue(False), False if self.wantobjects else '0') self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') self.assertEqual(passValue('string\U0001f4bb'), 'string\U0001f4bb') self.assertEqual(passValue('str\x00ing'), 'str\x00ing') self.assertEqual(passValue('str\x00ing\xbd'), 'str\x00ing\xbd') self.assertEqual(passValue('str\x00ing\u20ac'), 'str\x00ing\u20ac') self.assertEqual(passValue('str\x00ing\U0001f4bb'), 'str\x00ing\U0001f4bb') if sys.platform != 'win32': self.assertEqual(passValue('<\udce2\udc82\udcac>'), '<\u20ac>') self.assertEqual( passValue('<\udced\udca0\udcbd\udced\udcb2\udcbb>'), '<\U0001f4bb>') self.assertEqual(passValue(b'str\x00ing'), b'str\x00ing' if self.wantobjects else 'str\x00ing') self.assertEqual( passValue(b'str\xc0\x80ing'), b'str\xc0\x80ing' if self.wantobjects else 'str\xc0\x80ing') self.assertEqual(passValue(b'str\xbding'), b'str\xbding' if self.wantobjects else 'str\xbding') for i in self.get_integers(): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 self.assertEqual(passValue(2**1000), str(2**1000)) for f in (0.0, 1.0, -1.0, 1 / 3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float('nan')) self.assertNotEqual(f, f) self.assertEqual(passValue(float('inf')), float('inf')) self.assertEqual(passValue(-float('inf')), -float('inf')) else: self.assertEqual(float(passValue(float('inf'))), float('inf')) self.assertEqual(float(passValue(-float('inf'))), -float('inf')) # XXX NaN representation can be not parsable by float() self.assertEqual(passValue((1, '2', (3.4, ))), (1, '2', (3.4, )) if self.wantobjects else '1 2 3.4') self.assertEqual(passValue(['a', ['b', 'c']]), ('a', ('b', 'c')) if self.wantobjects else 'a {b c}') def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand('testfunc', testfunc) self.addCleanup(self.interp.tk.deletecommand, 'testfunc') def check(value, expected=None, *, eq=self.assertEqual): if expected is None: expected = value nonlocal result result = None r = self.interp.call('testfunc', value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) check(True, '1') check(False, '0') check('string') check('string\xbd') check('string\u20ac') check('string\U0001f4bb') if sys.platform != 'win32': check('<\udce2\udc82\udcac>', '<\u20ac>') check('<\udced\udca0\udcbd\udced\udcb2\udcbb>', '<\U0001f4bb>') check('') check(b'string', 'string') check(b'string\xe2\x82\xac', 'string\xe2\x82\xac') check(b'string\xbd', 'string\xbd') check(b'', '') check('str\x00ing') check('str\x00ing\xbd') check('str\x00ing\u20ac') check(b'str\x00ing', 'str\x00ing') check(b'str\xc0\x80ing', 'str\xc0\x80ing') check(b'str\xc0\x80ing\xe2\x82\xac', 'str\xc0\x80ing\xe2\x82\xac') for i in self.get_integers(): check(i, str(i)) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 check(2**1000, str(2**1000)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1 / 3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, eq=float_eq) check(float('inf'), eq=float_eq) check(-float('inf'), eq=float_eq) # XXX NaN representation can be not parsable by float() check((), '') check((1, (2, ), (3, 4), '5 6', ()), '1 2 {3 4} {5 6} {}') check([1, [ 2, ], [3, 4], '5 6', []], '1 2 {3 4} {5 6} {}') def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2', )), ('', ()), ('{}', ('', )), ('""', ('', )), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), ('a \U0001f4bb', ('a', '\U0001f4bb')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a \xf0\x9f\x92\xbb', ('a', '\U0001f4bb')), (b'a \xed\xa0\xbd\xed\xb2\xbb', ('a', '\U0001f4bb')), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), ([], ()), (['a', ['b', 'c']], ('a', ['b', 'c'])), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, )) if self.wantobjects else ('1', '2', '3.4')), ] tk_patchlevel = get_tk_patchlevel() if tcl_version >= (8, 5): if not self.wantobjects or tk_patchlevel < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\xe2\x82\xac', '3.4') else: expected = (12, '\u20ac', b'\xe2\x82\xac', (3.4, )) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4, )), expected), ] dbg_info = ('want objects? %s, Tcl version: %s, Tk patchlevel: %s' % (self.wantobjects, tcl_version, tk_patchlevel)) for arg, res in testcases: self.assertEqual(splitlist(arg), res, 'arg=%a, %s' % (arg, dbg_info)) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call with warnings.catch_warnings(): warnings.filterwarnings('ignore', r'\bsplit\b.*\bsplitlist\b', DeprecationWarning) self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b', 'a\x00b'), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), (b'{a\xc0\x80b c\xc0\x80d', '{a\x00b c\x00d'), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), ([], ()), (['a', 'b c'], ('a', ('b', 'c'))), (['a', ['b', 'c']], ('a', ('b', 'c'))), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, )) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\xe2\x82\xac', '3.4') else: expected = (12, '\u20ac', b'\xe2\x82\xac', (3.4, )) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4, )), expected), ] for arg, res in testcases: with self.assertWarns(DeprecationWarning): self.assertEqual(split(arg), res, msg=arg) def test_splitdict(self): splitdict = tkinter._splitdict tcl = self.interp.tk arg = '-a {1 2 3} -something foo status {}' self.assertEqual(splitdict(tcl, arg, False), { '-a': '1 2 3', '-something': 'foo', 'status': '' }) self.assertEqual(splitdict(tcl, arg), { 'a': '1 2 3', 'something': 'foo', 'status': '' }) arg = ('-a', (1, 2, 3), '-something', 'foo', 'status', '{}') self.assertEqual(splitdict(tcl, arg, False), { '-a': (1, 2, 3), '-something': 'foo', 'status': '{}' }) self.assertEqual(splitdict(tcl, arg), { 'a': (1, 2, 3), 'something': 'foo', 'status': '{}' }) self.assertRaises(RuntimeError, splitdict, tcl, '-a b -c ') self.assertRaises(RuntimeError, splitdict, tcl, ('-a', 'b', '-c')) arg = tcl.call('list', '-a', (1, 2, 3), '-something', 'foo', 'status', ()) self.assertEqual( splitdict(tcl, arg), { 'a': (1, 2, 3) if self.wantobjects else '1 2 3', 'something': 'foo', 'status': '' }) if tcl_version >= (8, 5): arg = tcl.call('dict', 'create', '-a', (1, 2, 3), '-something', 'foo', 'status', ()) if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = {'a': '1 2 3', 'something': 'foo', 'status': ''} else: expected = {'a': (1, 2, 3), 'something': 'foo', 'status': ''} self.assertEqual(splitdict(tcl, arg), expected) def test_join(self): join = tkinter._join tcl = self.interp.tk def unpack(s): return tcl.call('lindex', s, 0) def check(value): self.assertEqual(unpack(join([value])), value) self.assertEqual(unpack(join([value, 0])), value) self.assertEqual(unpack(unpack(join([[value]]))), value) self.assertEqual(unpack(unpack(join([[value, 0]]))), value) self.assertEqual(unpack(unpack(join([[value], 0]))), value) self.assertEqual(unpack(unpack(join([[value, 0], 0]))), value) check('') check('spam') check('sp am') check('sp\tam') check('sp\nam') check(' \t\n') check('{spam}') check('{sp am}') check('"spam"') check('"sp am"') check('{"spam"}') check('"{spam}"') check('sp\\am') check('"sp\\am"') check('"{}" "{}"') check('"\\') check('"{') check('"}') check('\n\\') check('\n{') check('\n}') check('\\\n') check('{\n') check('}\n') @support.cpython_only def test_new_tcl_obj(self): support.check_disallow_instantiation(self, _tkinter.Tcl_Obj) support.check_disallow_instantiation(self, _tkinter.TkttType) support.check_disallow_instantiation(self, _tkinter.TkappType)
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'),'1') def testEvalException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'this is wrong') def testCall(self): tcl = self.interp tcl.call('set','a','1') self.assertEqual(tcl.call('set','a'),'1') def testCallException(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'set','a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'this','is','wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a','1') self.assertEqual(tcl.eval('set a'),'1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)','1') self.assertEqual(tcl.eval('set a(1)'),'1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'),'1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'),'1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a',1) self.assertEqual(tcl.eval('info exists a'),'1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'),'0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)',1) tcl.setvar('a(2)',2) self.assertEqual(tcl.eval('info exists a(1)'),'1') self.assertEqual(tcl.eval('info exists a(2)'),'1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'),'0') self.assertEqual(tcl.eval('info exists a(2)'),'1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.unsetvar,'a') def testEvalFile(self): tcl = self.interp filename = "testEvalFile.tcl" fd = open(filename,'w') script = """set a 1 set b 2 set c [ expr $a + $b ] """ fd.write(script) fd.close() tcl.evalfile(filename) os.remove(filename) self.assertEqual(tcl.eval('set a'),'1') self.assertEqual(tcl.eval('set b'),'2') self.assertEqual(tcl.eval('set c'),'3') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError,tcl.evalfile,filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name,)) self.assertIn('tkinter', f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True) self.assertEqual(passValue(False), False) self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') for i in (0, 1, -1, 2**31-1, -2**31): self.assertEqual(passValue(i), i) for f in (0.0, 1.0, -1.0, 1/3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): self.assertEqual(passValue(f), f) for f in float('nan'), float('inf'), -float('inf'): if f != f: # NaN self.assertNotEqual(passValue(f), f) else: self.assertEqual(passValue(f), f) self.assertEqual(passValue((1, '2', (3.4,))), (1, '2', (3.4,))) def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2',)), ('', ()), ('{}', ('',)), ('""', ('',)), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,))), ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,))), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg)
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval("set a 1") self.assertEqual(tcl.eval("set a"), "1") def test_eval_null_in_result(self): tcl = self.interp self.assertEqual(tcl.eval('set a "a\\0b"'), "a\x00b") def testEvalException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "set a") def testEvalException2(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "this is wrong") def testCall(self): tcl = self.interp tcl.call("set", "a", "1") self.assertEqual(tcl.call("set", "a"), "1") def testCallException(self): tcl = self.interp self.assertRaises(TclError, tcl.call, "set", "a") def testCallException2(self): tcl = self.interp self.assertRaises(TclError, tcl.call, "this", "is", "wrong") def testSetVar(self): tcl = self.interp tcl.setvar("a", "1") self.assertEqual(tcl.eval("set a"), "1") def testSetVarArray(self): tcl = self.interp tcl.setvar("a(1)", "1") self.assertEqual(tcl.eval("set a(1)"), "1") def testGetVar(self): tcl = self.interp tcl.eval("set a 1") self.assertEqual(tcl.getvar("a"), "1") def testGetVarArray(self): tcl = self.interp tcl.eval("set a(1) 1") self.assertEqual(tcl.getvar("a(1)"), "1") def testGetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, "a") def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, "a(1)") def testUnsetVar(self): tcl = self.interp tcl.setvar("a", 1) self.assertEqual(tcl.eval("info exists a"), "1") tcl.unsetvar("a") self.assertEqual(tcl.eval("info exists a"), "0") def testUnsetVarArray(self): tcl = self.interp tcl.setvar("a(1)", 1) tcl.setvar("a(2)", 2) self.assertEqual(tcl.eval("info exists a(1)"), "1") self.assertEqual(tcl.eval("info exists a(2)"), "1") tcl.unsetvar("a(1)") self.assertEqual(tcl.eval("info exists a(1)"), "0") self.assertEqual(tcl.eval("info exists a(2)"), "1") def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.unsetvar, "a") def testEvalFile(self): tcl = self.interp with open(support.TESTFN, "w") as f: self.addCleanup(support.unlink, support.TESTFN) f.write( """set a 1 set b 2 set c [ expr $a + $b ] """ ) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval("set a"), "1") self.assertEqual(tcl.eval("set b"), "2") self.assertEqual(tcl.eval("set c"), "3") def test_evalfile_null_in_result(self): tcl = self.interp with open(support.TESTFN, "w") as f: self.addCleanup(support.unlink, support.TESTFN) f.write( """ set a "a\0b" set b "a\\0b" """ ) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval("set a"), "a\x00b") self.assertEqual(tcl.eval("set b"), "a\x00b") def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError, tcl.evalfile, filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "package require DNE") @unittest.skipUnless(sys.platform == "win32", "Requires Windows") def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ":": raise unittest.SkipTest("Absolute path should have drive part") unc_name = r"\\%s\%s$\%s" % (os.environ["COMPUTERNAME"], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest("Cannot connect to UNC Path") with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name,)) self.assertIn("tkinter", f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_exprstring(self): tcl = self.interp tcl.call("set", "a", 3) tcl.call("set", "b", 6) def check(expr, expected): result = tcl.exprstring(expr) self.assertEqual(result, expected) self.assertIsInstance(result, str) self.assertRaises(TypeError, tcl.exprstring) self.assertRaises(TypeError, tcl.exprstring, "8.2", "+6") self.assertRaises(TypeError, tcl.exprstring, b"8.2 + 6") self.assertRaises(TclError, tcl.exprstring, "spam") check("", "0") check("8.2 + 6", "14.2") check("3.1 + $a", "6.1") check('2 + "$a.$b"', "5.6") check('4*[llength "6 2"]', "8") check('{word one} < "word $a"', "0") check("4*2 < 7", "0") check("hypot($a, 4)", "5.0") check("5 / 4", "1") check("5 / 4.0", "1.25") check('5 / ( [string length "abcd"] + 0.0 )', "1.25") check("20.0/5.0", "4.0") check('"0x03" > "2"', "1") check('[string length "a\xbd\u20ac"]', "3") check(r'[string length "a\xbd\u20ac"]', "3") check('"abc"', "abc") check('"a\xbd\u20ac"', "a\xbd\u20ac") check(r'"a\xbd\u20ac"', "a\xbd\u20ac") check(r'"a\0b"', "a\x00b") if tcl_version >= (8, 5): check("2**64", str(2 ** 64)) def test_exprdouble(self): tcl = self.interp tcl.call("set", "a", 3) tcl.call("set", "b", 6) def check(expr, expected): result = tcl.exprdouble(expr) self.assertEqual(result, expected) self.assertIsInstance(result, float) self.assertRaises(TypeError, tcl.exprdouble) self.assertRaises(TypeError, tcl.exprdouble, "8.2", "+6") self.assertRaises(TypeError, tcl.exprdouble, b"8.2 + 6") self.assertRaises(TclError, tcl.exprdouble, "spam") check("", 0.0) check("8.2 + 6", 14.2) check("3.1 + $a", 6.1) check('2 + "$a.$b"', 5.6) check('4*[llength "6 2"]', 8.0) check('{word one} < "word $a"', 0.0) check("4*2 < 7", 0.0) check("hypot($a, 4)", 5.0) check("5 / 4", 1.0) check("5 / 4.0", 1.25) check('5 / ( [string length "abcd"] + 0.0 )', 1.25) check("20.0/5.0", 4.0) check('"0x03" > "2"', 1.0) check('[string length "a\xbd\u20ac"]', 3.0) check(r'[string length "a\xbd\u20ac"]', 3.0) self.assertRaises(TclError, tcl.exprdouble, '"abc"') if tcl_version >= (8, 5): check("2**64", float(2 ** 64)) def test_exprlong(self): tcl = self.interp tcl.call("set", "a", 3) tcl.call("set", "b", 6) def check(expr, expected): result = tcl.exprlong(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertRaises(TypeError, tcl.exprlong) self.assertRaises(TypeError, tcl.exprlong, "8.2", "+6") self.assertRaises(TypeError, tcl.exprlong, b"8.2 + 6") self.assertRaises(TclError, tcl.exprlong, "spam") check("", 0) check("8.2 + 6", 14) check("3.1 + $a", 6) check('2 + "$a.$b"', 5) check('4*[llength "6 2"]', 8) check('{word one} < "word $a"', 0) check("4*2 < 7", 0) check("hypot($a, 4)", 5) check("5 / 4", 1) check("5 / 4.0", 1) check('5 / ( [string length "abcd"] + 0.0 )', 1) check("20.0/5.0", 4) check('"0x03" > "2"', 1) check('[string length "a\xbd\u20ac"]', 3) check(r'[string length "a\xbd\u20ac"]', 3) self.assertRaises(TclError, tcl.exprlong, '"abc"') if tcl_version >= (8, 5): self.assertRaises(TclError, tcl.exprlong, "2**64") def test_exprboolean(self): tcl = self.interp tcl.call("set", "a", 3) tcl.call("set", "b", 6) def check(expr, expected): result = tcl.exprboolean(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertNotIsInstance(result, bool) self.assertRaises(TypeError, tcl.exprboolean) self.assertRaises(TypeError, tcl.exprboolean, "8.2", "+6") self.assertRaises(TypeError, tcl.exprboolean, b"8.2 + 6") self.assertRaises(TclError, tcl.exprboolean, "spam") check("", False) for value in ("0", "false", "no", "off"): check(value, False) check('"%s"' % value, False) check("{%s}" % value, False) for value in ("1", "true", "yes", "on"): check(value, True) check('"%s"' % value, True) check("{%s}" % value, True) check("8.2 + 6", True) check("3.1 + $a", True) check('2 + "$a.$b"', True) check('4*[llength "6 2"]', True) check('{word one} < "word $a"', False) check("4*2 < 7", False) check("hypot($a, 4)", True) check("5 / 4", True) check("5 / 4.0", True) check('5 / ( [string length "abcd"] + 0.0 )', True) check("20.0/5.0", True) check('"0x03" > "2"', True) check('[string length "a\xbd\u20ac"]', True) check(r'[string length "a\xbd\u20ac"]', True) self.assertRaises(TclError, tcl.exprboolean, '"abc"') if tcl_version >= (8, 5): check("2**64", True) def test_passing_values(self): def passValue(value): return self.interp.call("set", "_", value) self.assertEqual(passValue(True), True if self.wantobjects else "1") self.assertEqual(passValue(False), False if self.wantobjects else "0") self.assertEqual(passValue("string"), "string") self.assertEqual(passValue("string\u20ac"), "string\u20ac") self.assertEqual(passValue("str\x00ing"), "str\x00ing") self.assertEqual(passValue("str\x00ing\xbd"), "str\x00ing\xbd") self.assertEqual(passValue("str\x00ing\u20ac"), "str\x00ing\u20ac") self.assertEqual(passValue(b"str\x00ing"), "str\x00ing") self.assertEqual(passValue(b"str\xc0\x80ing"), "str\x00ing") for i in (0, 1, -1, 2 ** 31 - 1, -2 ** 31): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) for f in ( 0.0, 1.0, -1.0, 1 / 3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max, ): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float("nan")) self.assertNotEqual(f, f) self.assertEqual(passValue(float("inf")), float("inf")) self.assertEqual(passValue(-float("inf")), -float("inf")) else: f = float(passValue(float("nan"))) self.assertNotEqual(f, f) self.assertEqual(float(passValue(float("inf"))), float("inf")) self.assertEqual(float(passValue(-float("inf"))), -float("inf")) self.assertEqual(passValue((1, "2", (3.4,))), (1, "2", (3.4,)) if self.wantobjects else "1 2 3.4") def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand("testfunc", testfunc) def check(value, expected, eq=self.assertEqual): r = self.interp.call("testfunc", value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): expected = float(expected) self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) def nan_eq(actual, expected): actual = float(actual) self.assertNotEqual(actual, actual) check(True, "1") check(False, "0") check("string", "string") check("string\xbd", "string\xbd") check("string\u20ac", "string\u20ac") check(b"string", "string") check(b"string\xe2\x82\xac", "string\u20ac") check("str\x00ing", "str\x00ing") check("str\x00ing\xbd", "str\x00ing\xbd") check("str\x00ing\u20ac", "str\x00ing\u20ac") check(b"str\xc0\x80ing", "str\x00ing") check(b"str\xc0\x80ing\xe2\x82\xac", "str\x00ing\u20ac") for i in (0, 1, -1, 2 ** 31 - 1, -2 ** 31): check(i, str(i)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1 / 3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, f, eq=float_eq) check(float("inf"), "Inf", eq=float_eq) check(-float("inf"), "-Inf", eq=float_eq) check(float("nan"), "NaN", eq=nan_eq) check((), "") check((1, (2,), (3, 4), "5 6", ()), "1 2 {3 4} {5 6} {}") def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, "a", "b") self.assertRaises(TypeError, splitlist, 2) testcases = [ ("2", ("2",)), ("", ()), ("{}", ("",)), ('""', ("",)), ("a\n b\t\r c\n ", ("a", "b", "c")), (b"a\n b\t\r c\n ", ("a", "b", "c")), ("a \u20ac", ("a", "\u20ac")), (b"a \xe2\x82\xac", ("a", "\u20ac")), (b"a\xc0\x80b c\xc0\x80d", ("a\x00b", "c\x00d")), ("a {b c}", ("a", "b c")), (r"a b\ c", ("a", "b c")), (("a", "b c"), ("a", "b c")), ("a 2", ("a", "2")), (("a", 2), ("a", 2)), ("a 3.4", ("a", "3.4")), (("a", 3.4), ("a", 3.4)), ((), ()), (call("list", 1, "2", (3.4,)), (1, "2", (3.4,)) if self.wantobjects else ("1", "2", "3.4")), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ("12", "\u20ac", "\u20ac", "3.4") else: expected = (12, "\u20ac", "\u20ac", (3.4,)) testcases += [(call("dict", "create", 12, "\u20ac", b"\xe2\x82\xac", (3.4,)), expected)] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, "{") def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, "a", "b") self.assertRaises(TypeError, split, 2) testcases = [ ("2", "2"), ("", ""), ("{}", ""), ('""', ""), ("{", "{"), ("a\n b\t\r c\n ", ("a", "b", "c")), (b"a\n b\t\r c\n ", ("a", "b", "c")), ("a \u20ac", ("a", "\u20ac")), (b"a \xe2\x82\xac", ("a", "\u20ac")), (b"a\xc0\x80b", "a\x00b"), (b"a\xc0\x80b c\xc0\x80d", ("a\x00b", "c\x00d")), (b"{a\xc0\x80b c\xc0\x80d", "{a\x00b c\x00d"), ("a {b c}", ("a", ("b", "c"))), (r"a b\ c", ("a", ("b", "c"))), (("a", b"b c"), ("a", ("b", "c"))), (("a", "b c"), ("a", ("b", "c"))), ("a 2", ("a", "2")), (("a", 2), ("a", 2)), ("a 3.4", ("a", "3.4")), (("a", 3.4), ("a", 3.4)), (("a", (2, 3.4)), ("a", (2, 3.4))), ((), ()), (call("list", 1, "2", (3.4,)), (1, "2", (3.4,)) if self.wantobjects else ("1", "2", "3.4")), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ("12", "\u20ac", "\u20ac", "3.4") else: expected = (12, "\u20ac", "\u20ac", (3.4,)) testcases += [(call("dict", "create", 12, "\u20ac", b"\xe2\x82\xac", (3.4,)), expected)] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg)
def setUpModule(): if support.verbose: tcl = Tcl() print('patchlevel =', tcl.call('info', 'patchlevel'))
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'),'1') def test_eval_null_in_result(self): tcl = self.interp self.assertEqual(tcl.eval('set a "a\\0b"'), 'a\x00b') def testEvalException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'this is wrong') def testCall(self): tcl = self.interp tcl.call('set','a','1') self.assertEqual(tcl.call('set','a'),'1') def testCallException(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'set','a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'this','is','wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a','1') self.assertEqual(tcl.eval('set a'),'1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)','1') self.assertEqual(tcl.eval('set a(1)'),'1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'),'1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'),'1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a',1) self.assertEqual(tcl.eval('info exists a'),'1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'),'0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)',1) tcl.setvar('a(2)',2) self.assertEqual(tcl.eval('info exists a(1)'),'1') self.assertEqual(tcl.eval('info exists a(2)'),'1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'),'0') self.assertEqual(tcl.eval('info exists a(2)'),'1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.unsetvar,'a') def testEvalFile(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write("""set a 1 set b 2 set c [ expr $a + $b ] """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'),'1') self.assertEqual(tcl.eval('set b'),'2') self.assertEqual(tcl.eval('set c'),'3') def test_evalfile_null_in_result(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write(""" set a "a\0b" set b "a\\0b" """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'), 'a\x00b') self.assertEqual(tcl.eval('set b'), 'a\x00b') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError,tcl.evalfile,filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name,)) self.assertIn('tkinter', f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_exprstring(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprstring(expr) self.assertEqual(result, expected) self.assertIsInstance(result, str) self.assertRaises(TypeError, tcl.exprstring) self.assertRaises(TypeError, tcl.exprstring, '8.2', '+6') self.assertRaises(TypeError, tcl.exprstring, b'8.2 + 6') self.assertRaises(TclError, tcl.exprstring, 'spam') check('', '0') check('8.2 + 6', '14.2') check('3.1 + $a', '6.1') check('2 + "$a.$b"', '5.6') check('4*[llength "6 2"]', '8') check('{word one} < "word $a"', '0') check('4*2 < 7', '0') check('hypot($a, 4)', '5.0') check('5 / 4', '1') check('5 / 4.0', '1.25') check('5 / ( [string length "abcd"] + 0.0 )', '1.25') check('20.0/5.0', '4.0') check('"0x03" > "2"', '1') check('[string length "a\xbd\u20ac"]', '3') check(r'[string length "a\xbd\u20ac"]', '3') check('"abc"', 'abc') check('"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\0b"', 'a\x00b') if tcl_version >= (8, 5): check('2**64', str(2**64)) def test_exprdouble(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprdouble(expr) self.assertEqual(result, expected) self.assertIsInstance(result, float) self.assertRaises(TypeError, tcl.exprdouble) self.assertRaises(TypeError, tcl.exprdouble, '8.2', '+6') self.assertRaises(TypeError, tcl.exprdouble, b'8.2 + 6') self.assertRaises(TclError, tcl.exprdouble, 'spam') check('', 0.0) check('8.2 + 6', 14.2) check('3.1 + $a', 6.1) check('2 + "$a.$b"', 5.6) check('4*[llength "6 2"]', 8.0) check('{word one} < "word $a"', 0.0) check('4*2 < 7', 0.0) check('hypot($a, 4)', 5.0) check('5 / 4', 1.0) check('5 / 4.0', 1.25) check('5 / ( [string length "abcd"] + 0.0 )', 1.25) check('20.0/5.0', 4.0) check('"0x03" > "2"', 1.0) check('[string length "a\xbd\u20ac"]', 3.0) check(r'[string length "a\xbd\u20ac"]', 3.0) self.assertRaises(TclError, tcl.exprdouble, '"abc"') if tcl_version >= (8, 5): check('2**64', float(2**64)) def test_exprlong(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprlong(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertRaises(TypeError, tcl.exprlong) self.assertRaises(TypeError, tcl.exprlong, '8.2', '+6') self.assertRaises(TypeError, tcl.exprlong, b'8.2 + 6') self.assertRaises(TclError, tcl.exprlong, 'spam') check('', 0) check('8.2 + 6', 14) check('3.1 + $a', 6) check('2 + "$a.$b"', 5) check('4*[llength "6 2"]', 8) check('{word one} < "word $a"', 0) check('4*2 < 7', 0) check('hypot($a, 4)', 5) check('5 / 4', 1) check('5 / 4.0', 1) check('5 / ( [string length "abcd"] + 0.0 )', 1) check('20.0/5.0', 4) check('"0x03" > "2"', 1) check('[string length "a\xbd\u20ac"]', 3) check(r'[string length "a\xbd\u20ac"]', 3) self.assertRaises(TclError, tcl.exprlong, '"abc"') if tcl_version >= (8, 5): self.assertRaises(TclError, tcl.exprlong, '2**64') def test_exprboolean(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprboolean(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertNotIsInstance(result, bool) self.assertRaises(TypeError, tcl.exprboolean) self.assertRaises(TypeError, tcl.exprboolean, '8.2', '+6') self.assertRaises(TypeError, tcl.exprboolean, b'8.2 + 6') self.assertRaises(TclError, tcl.exprboolean, 'spam') check('', False) for value in ('0', 'false', 'no', 'off'): check(value, False) check('"%s"' % value, False) check('{%s}' % value, False) for value in ('1', 'true', 'yes', 'on'): check(value, True) check('"%s"' % value, True) check('{%s}' % value, True) check('8.2 + 6', True) check('3.1 + $a', True) check('2 + "$a.$b"', True) check('4*[llength "6 2"]', True) check('{word one} < "word $a"', False) check('4*2 < 7', False) check('hypot($a, 4)', True) check('5 / 4', True) check('5 / 4.0', True) check('5 / ( [string length "abcd"] + 0.0 )', True) check('20.0/5.0', True) check('"0x03" > "2"', True) check('[string length "a\xbd\u20ac"]', True) check(r'[string length "a\xbd\u20ac"]', True) self.assertRaises(TclError, tcl.exprboolean, '"abc"') if tcl_version >= (8, 5): check('2**64', True) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True if self.wantobjects else '1') self.assertEqual(passValue(False), False if self.wantobjects else '0') self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') self.assertEqual(passValue('str\x00ing'), 'str\x00ing') self.assertEqual(passValue('str\x00ing\xbd'), 'str\x00ing\xbd') self.assertEqual(passValue('str\x00ing\u20ac'), 'str\x00ing\u20ac') self.assertEqual(passValue(b'str\x00ing'), 'str\x00ing') self.assertEqual(passValue(b'str\xc0\x80ing'), 'str\x00ing') for i in (0, 1, -1, 2**31-1, -2**31): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) for f in (0.0, 1.0, -1.0, 1/3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float('nan')) self.assertNotEqual(f, f) self.assertEqual(passValue(float('inf')), float('inf')) self.assertEqual(passValue(-float('inf')), -float('inf')) else: f = float(passValue(float('nan'))) self.assertNotEqual(f, f) self.assertEqual(float(passValue(float('inf'))), float('inf')) self.assertEqual(float(passValue(-float('inf'))), -float('inf')) self.assertEqual(passValue((1, '2', (3.4,))), (1, '2', (3.4,)) if self.wantobjects else '1 2 3.4') def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand('testfunc', testfunc) self.addCleanup(self.interp.tk.deletecommand, 'testfunc') def check(value, expected, eq=self.assertEqual): r = self.interp.call('testfunc', value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): expected = float(expected) self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) def nan_eq(actual, expected): actual = float(actual) self.assertNotEqual(actual, actual) check(True, '1') check(False, '0') check('string', 'string') check('string\xbd', 'string\xbd') check('string\u20ac', 'string\u20ac') check(b'string', 'string') check(b'string\xe2\x82\xac', 'string\u20ac') check('str\x00ing', 'str\x00ing') check('str\x00ing\xbd', 'str\x00ing\xbd') check('str\x00ing\u20ac', 'str\x00ing\u20ac') check(b'str\xc0\x80ing', 'str\x00ing') check(b'str\xc0\x80ing\xe2\x82\xac', 'str\x00ing\u20ac') for i in (0, 1, -1, 2**31-1, -2**31): check(i, str(i)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1/3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, f, eq=float_eq) check(float('inf'), 'Inf', eq=float_eq) check(-float('inf'), '-Inf', eq=float_eq) check(float('nan'), 'NaN', eq=nan_eq) check((), '') check((1, (2,), (3, 4), '5 6', ()), '1 2 {3 4} {5 6} {}') def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2',)), ('', ()), ('{}', ('',)), ('""', ('',)), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\u20ac', '3.4') else: expected = (12, '\u20ac', '\u20ac', (3.4,)) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)), expected), ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b', 'a\x00b'), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), (b'{a\xc0\x80b c\xc0\x80d', '{a\x00b c\x00d'), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\u20ac', '3.4') else: expected = (12, '\u20ac', '\u20ac', (3.4,)) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)), expected), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg) def test_merge(self): with support.check_warnings(('merge is deprecated', DeprecationWarning)): merge = self.interp.tk.merge call = self.interp.tk.call testcases = [ ((), ''), (('a',), 'a'), ((2,), '2'), (('',), '{}'), ('{', '\\{'), (('a', 'b', 'c'), 'a b c'), ((' ', '\t', '\r', '\n'), '{ } {\t} {\r} {\n}'), (('a', ' ', 'c'), 'a { } c'), (('a', '€'), 'a €'), (('a', '\U000104a2'), 'a \U000104a2'), (('a', b'\xe2\x82\xac'), 'a €'), (('a', ('b', 'c')), 'a {b c}'), (('a', 2), 'a 2'), (('a', 3.4), 'a 3.4'), (('a', (2, 3.4)), 'a {2 3.4}'), ((), ''), ((call('list', 1, '2', (3.4,)),), '{1 2 3.4}'), ] if tcl_version >= (8, 5): testcases += [ ((call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)),), '{12 € € 3.4}'), ] for args, res in testcases: self.assertEqual(merge(*args), res, msg=args) self.assertRaises(UnicodeDecodeError, merge, b'\x80') self.assertRaises(UnicodeEncodeError, merge, '\udc80')
def setUp(self): self.root = Tcl()
def testLoadTk(self): tcl = Tcl() self.assertRaises(TclError,tcl.winfo_geometry) tcl.loadtk() self.assertEqual('1x1+0+0', tcl.winfo_geometry()) tcl.destroy()
i += 1 return id_to_labels, labels_to_id print("\n") label_file = 'output_labels_alphabet.txt' id_to_labels, labels_to_id = load_label_dicts(label_file) files = [] crop_folder_path = os.path.join('crop') path = os.path.join(crop_folder_path, "*.png") frames = glob.glob(path) files = frames files = list(Tcl().call('lsort', '-dict', files)) prediction_vector = get_inference_vector_one_frame_alphabet(files) prediction_vector = np.array(prediction_vector) print("\n") l = [] for i in range(prediction_vector.shape[0]): l.append(id_to_labels[np.argmax(prediction_vector[i])]) print("Labels from Cropped images") print(l) files = [] data_folder_path = os.path.join('data') path = os.path.join(data_folder_path, "*.png")
class c_mainFrame(Tk): """ classdocs """ def __init__(self, **paras): """ Constructor """ try: super().__init__(**paras) self.__check_enviroment() self.system = self.tk.call("tk", "windowingsystem") self.__mystyle() self.__setup() self.__create_children() pass except: raise else: pass def __del__(self): try: pass except: pass else: pass def __check_enviroment(self): try: self.py_Version = platform.python_version() self.py_Compiler = platform.python_compiler() self.py_Build = platform.python_build() major, minor, patch = self.py_Version.split(".") if (int(major) < MIN_PY_MAJOR_VERSION) or ( (int(major) == MIN_PY_MAJOR_VERSION) and (int(minor) < MIN_PY_MINOR_VERSION) ): raise Exception( "Python Version " + MIN_TCL_MAJOR_VERSION + "." + MIN_TCL_MINOR_VERSION + ".x or higher required" ) self.tcl_Version = Tcl().eval("info patchlevel") major, minor, patch = self.tcl_Version.split(".") if (int(major) < MIN_TCL_MAJOR_VERSION) or ( (int(major) == MIN_TCL_MAJOR_VERSION) and (int(minor) < MIN_TCL_MINOR_VERSION) ): raise Exception( "TCL Version " + MIN_TCL_MAJOR_VERSION + "." + MIN_TCL_MINOR_VERSION + ".x or higher required" ) except: raise def __setup(self): try: self.option_add("*tearOFF", FALSE) self.geometry("1024x640+10+10") self.configure(title="Extended PTC Gateway") pass except: pass else: pass def __create_children(self): try: self.__create_menue() pass except: raise else: pass def __create_menue(self): try: self.frm_menu = ttk.Frame(self, name="menu") ttk.Button(self.frm_menu, name="btn_new_file", text="New", command=self.__on_menu_new_file).pack(side=LEFT) ttk.Button(self.frm_menu, name="btn_open_file", text="Open", command=self.__on_menu_open_file).pack( side=LEFT ) ttk.Button( self.frm_menu, name="btn_save_file", text="Save", state="disabled", command=self.__on_menu_save_file ).pack(side=LEFT) ttk.Button( self.frm_menu, name="btn_save_as_file", text="SaveAs", state="disabled", command=self.__on_menu_save_as_file, ).pack(side=LEFT) self.frm_menu.pack(side=TOP, fill=X) pass except: raise else: pass def __create_client(self, savedata=None): try: try: self.frm_client.destroy() except: pass self.frm_client = c_clientFrame(self, savedata=savedata, name="client") self.frm_client.pack(side=TOP, fill=BOTH, expand=True) self.__save_enable() pass except: raise def __on_menu_open_file(self): try: filename = filedialog.askopenfilename( filetypes=[("ExtGatewayConfig", SAVE_FILE_ENDING)], title="Select Configuration File" ) if filename: self.__load(filename) pass except: raise def __on_menu_new_file(self): try: self.__create_client() pass except: raise def __on_menu_save_file(self): try: self.__save(self.filename) pass except: self.__on_menu_save_as_file() def __on_menu_save_as_file(self): try: filename = filedialog.asksaveasfilename( filetypes=[("ExtGatewayConfig", SAVE_FILE_ENDING)], title="Select Configuration File" ) if filename: if filename[-len(SAVE_FILE_ENDING) :] != SAVE_FILE_ENDING: filename += SAVE_FILE_ENDING self.__save(filename) pass except: raise def cbk_menue_disable(self): try: self.children["menu"].children["btn_save_file"].config(state="disabled") self.children["menu"].children["btn_save_as_file"].config(state="disabled") self.children["menu"].children["btn_new_file"].config(state="disabled") self.children["menu"].children["btn_open_file"].config(state="disabled") pass except: raise def cbk_menue_enable(self): try: self.children["menu"].children["btn_save_file"].config(state="normal") self.children["menu"].children["btn_save_as_file"].config(state="normal") self.children["menu"].children["btn_new_file"].config(state="normal") self.children["menu"].children["btn_open_file"].config(state="normal") pass except: raise def __save_enable(self): self.children["menu"].children["btn_save_file"].config(state="normal") self.children["menu"].children["btn_save_as_file"].config(state="normal") def __get_save_data(self): return self.frm_client.get_save_data() def __restore_data(self, savedata): self.__create_client(savedata) pass def __save(self, filename): try: savedata = self.__get_save_data() self.filename = filename f = open(filename, mode="wb") s = pickle.dumps(savedata) f.write(s) f.close() pass except: raise def __load(self, filename): try: self.filename = filename f = open(filename, mode="rb") s = f.read() f.close() savedata = pickle.loads(s) self.__restore_data(savedata) pass except: raise def __mystyle(self): self.style = ttk.Style() self.style.configure("TFrame", padding=5, relief=RIDGE) self.style.configure("TButton", padding=3, relief=FLAT, padx=2, pady=2) self.style.configure("TLable", padding=2, relief=FLAT, padx=2, pady=2) self.style.configure("TEntry", padding=2, relief=RIDGE, padx=2, pady=2) self.style.configure("TCheckbutton", padding=2, relief=RIDGE, padx=2, pady=2) self.style.configure( "ok.TEntry", foreground="green", background="green", padding=3, relief=RIDGE, padx=2, pady=2 ) self.style.configure("err.TEntry", foreground="red", background="red", padding=3, relief=RIDGE, padx=2, pady=2) self.style.configure( "tbd.TButton", foreground="gray", background="gray", padding=3, relief=FLAT, padx=2, pady=2 ) self.style.configure( "warn.TButton", foreground="yellow", background="yellow", padding=3, relief=FLAT, padx=2, pady=2 ) self.style.configure( "ok.TButton", foreground="green", background="green", padding=3, relief=FLAT, padx=2, pady=2 ) self.style.configure("err.TButton", foreground="red", background="red", padding=3, relief=FLAT, padx=2, pady=2) self.style.configure( "option.TButton", foreground="blue", background="blue", padding=3, relief=FLAT, padx=2, pady=2 )
def setUpModule(): if support.verbose: tcl = Tcl() print("patchlevel =", tcl.call("info", "patchlevel"))
def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects()
import os import shutil from tkinter import Tcl m = 50000 n = 5000 src_dir = "C:/Users/shubh/Downloads/Shubh_mypy_proj/comp_vision/train/traintemp" dst_dir = "C:/Users/shubh/Desktop/thisone" file_list = os.listdir(src_dir) file_list = (Tcl().call('lsort', '-dict', file_list)) for i in range(0, m, n): for j in range(i, i + 100): shutil.copy(file_list[j], dst_dir)
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() def testEval(self): tcl = self.interp tcl.eval("set a 1") self.assertEqual(tcl.eval("set a"), "1") def testEvalException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "set a") def testEvalException2(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "this is wrong") def testCall(self): tcl = self.interp tcl.call("set", "a", "1") self.assertEqual(tcl.call("set", "a"), "1") def testCallException(self): tcl = self.interp self.assertRaises(TclError, tcl.call, "set", "a") def testCallException2(self): tcl = self.interp self.assertRaises(TclError, tcl.call, "this", "is", "wrong") def testSetVar(self): tcl = self.interp tcl.setvar("a", "1") self.assertEqual(tcl.eval("set a"), "1") def testSetVarArray(self): tcl = self.interp tcl.setvar("a(1)", "1") self.assertEqual(tcl.eval("set a(1)"), "1") def testGetVar(self): tcl = self.interp tcl.eval("set a 1") self.assertEqual(tcl.getvar("a"), "1") def testGetVarArray(self): tcl = self.interp tcl.eval("set a(1) 1") self.assertEqual(tcl.getvar("a(1)"), "1") def testGetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, "a") def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, "a(1)") def testUnsetVar(self): tcl = self.interp tcl.setvar("a", 1) self.assertEqual(tcl.eval("info exists a"), "1") tcl.unsetvar("a") self.assertEqual(tcl.eval("info exists a"), "0") def testUnsetVarArray(self): tcl = self.interp tcl.setvar("a(1)", 1) tcl.setvar("a(2)", 2) self.assertEqual(tcl.eval("info exists a(1)"), "1") self.assertEqual(tcl.eval("info exists a(2)"), "1") tcl.unsetvar("a(1)") self.assertEqual(tcl.eval("info exists a(1)"), "0") self.assertEqual(tcl.eval("info exists a(2)"), "1") def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.unsetvar, "a") def testEvalFile(self): tcl = self.interp filename = "testEvalFile.tcl" fd = open(filename, "w") script = """set a 1 set b 2 set c [ expr $a + $b ] """ fd.write(script) fd.close() tcl.evalfile(filename) os.remove(filename) self.assertEqual(tcl.eval("set a"), "1") self.assertEqual(tcl.eval("set b"), "2") self.assertEqual(tcl.eval("set c"), "3") def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError, tcl.evalfile, filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, "package require DNE") @unittest.skipUnless(sys.platform == "win32", "Requires Windows") def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ":": raise unittest.SkipTest("Absolute path should have drive part") unc_name = r"\\%s\%s$\%s" % (os.environ["COMPUTERNAME"], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest("Cannot connect to UNC Path") with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name,)) self.assertIn("tkinter", f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_passing_values(self): def passValue(value): return self.interp.call("set", "_", value) self.assertEqual(passValue(True), True) self.assertEqual(passValue(False), False) self.assertEqual(passValue("string"), "string") self.assertEqual(passValue("string\u20ac"), "string\u20ac") for i in (0, 1, -1, 2 ** 31 - 1, -2 ** 31): self.assertEqual(passValue(i), i) for f in ( 0.0, 1.0, -1.0, 1 / 3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max, ): self.assertEqual(passValue(f), f) for f in float("nan"), float("inf"), -float("inf"): if f != f: # NaN self.assertNotEqual(passValue(f), f) else: self.assertEqual(passValue(f), f) self.assertEqual(passValue((1, "2", (3.4,))), (1, "2", (3.4,))) def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, "a", "b") self.assertRaises(TypeError, splitlist, 2) testcases = [ ("2", ("2",)), ("", ()), ("{}", ("",)), ('""', ("",)), ("a\n b\t\r c\n ", ("a", "b", "c")), (b"a\n b\t\r c\n ", ("a", "b", "c")), ("a \u20ac", ("a", "\u20ac")), (b"a \xe2\x82\xac", ("a", "\u20ac")), ("a {b c}", ("a", "b c")), (r"a b\ c", ("a", "b c")), (("a", "b c"), ("a", "b c")), ("a 2", ("a", "2")), (("a", 2), ("a", 2)), ("a 3.4", ("a", "3.4")), (("a", 3.4), ("a", 3.4)), ((), ()), (call("list", 1, "2", (3.4,)), (1, "2", (3.4,))), ] if tcl_version >= (8, 5): testcases += [ (call("dict", "create", 1, "\u20ac", b"\xe2\x82\xac", (3.4,)), (1, "\u20ac", "\u20ac", (3.4,))) ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, "{") def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, "a", "b") self.assertRaises(TypeError, split, 2) testcases = [ ("2", "2"), ("", ""), ("{}", ""), ('""', ""), ("{", "{"), ("a\n b\t\r c\n ", ("a", "b", "c")), (b"a\n b\t\r c\n ", ("a", "b", "c")), ("a \u20ac", ("a", "\u20ac")), (b"a \xe2\x82\xac", ("a", "\u20ac")), ("a {b c}", ("a", ("b", "c"))), (r"a b\ c", ("a", ("b", "c"))), (("a", b"b c"), ("a", ("b", "c"))), (("a", "b c"), ("a", ("b", "c"))), ("a 2", ("a", "2")), (("a", 2), ("a", 2)), ("a 3.4", ("a", "3.4")), (("a", 3.4), ("a", 3.4)), (("a", (2, 3.4)), ("a", (2, 3.4))), ((), ()), (call("list", 1, "2", (3.4,)), (1, "2", (3.4,))), ] if tcl_version >= (8, 5): testcases += [ (call("dict", "create", 12, "\u20ac", b"\xe2\x82\xac", (3.4,)), (12, "\u20ac", "\u20ac", (3.4,))) ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg)
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'),'1') def test_eval_null_in_result(self): tcl = self.interp self.assertEqual(tcl.eval('set a "a\\0b"'), 'a\x00b') def testEvalException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'this is wrong') def testCall(self): tcl = self.interp tcl.call('set','a','1') self.assertEqual(tcl.call('set','a'),'1') def testCallException(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'set','a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'this','is','wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a','1') self.assertEqual(tcl.eval('set a'),'1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)','1') self.assertEqual(tcl.eval('set a(1)'),'1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'),'1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'),'1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a',1) self.assertEqual(tcl.eval('info exists a'),'1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'),'0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)',1) tcl.setvar('a(2)',2) self.assertEqual(tcl.eval('info exists a(1)'),'1') self.assertEqual(tcl.eval('info exists a(2)'),'1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'),'0') self.assertEqual(tcl.eval('info exists a(2)'),'1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.unsetvar,'a') def get_integers(self): integers = (0, 1, -1, 2**31-1, -2**31, 2**31, -2**31-1, 2**63-1, -2**63) # bignum was added in Tcl 8.5, but its support is able only since 8.5.8 if (get_tk_patchlevel() >= (8, 6, 0, 'final') or (8, 5, 8) <= get_tk_patchlevel() < (8, 6)): integers += (2**63, -2**63-1, 2**1000, -2**1000) return integers def test_getint(self): tcl = self.interp.tk for i in self.get_integers(): self.assertEqual(tcl.getint(' %d ' % i), i) if tcl_version >= (8, 5): self.assertEqual(tcl.getint(' %#o ' % i), i) self.assertEqual(tcl.getint((' %#o ' % i).replace('o', '')), i) self.assertEqual(tcl.getint(' %#x ' % i), i) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.getint, str(2**1000)) self.assertEqual(tcl.getint(42), 42) self.assertRaises(TypeError, tcl.getint) self.assertRaises(TypeError, tcl.getint, '42', '10') self.assertRaises(TypeError, tcl.getint, b'42') self.assertRaises(TypeError, tcl.getint, 42.0) self.assertRaises(TclError, tcl.getint, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getint, '42\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getint, '42\ud800') def test_getdouble(self): tcl = self.interp.tk self.assertEqual(tcl.getdouble(' 42 '), 42.0) self.assertEqual(tcl.getdouble(' 42.5 '), 42.5) self.assertEqual(tcl.getdouble(42.5), 42.5) self.assertEqual(tcl.getdouble(42), 42.0) self.assertRaises(TypeError, tcl.getdouble) self.assertRaises(TypeError, tcl.getdouble, '42.5', '10') self.assertRaises(TypeError, tcl.getdouble, b'42.5') self.assertRaises(TclError, tcl.getdouble, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getdouble, '42.5\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getdouble, '42.5\ud800') def test_getboolean(self): tcl = self.interp.tk self.assertIs(tcl.getboolean('on'), True) self.assertIs(tcl.getboolean('1'), True) self.assertIs(tcl.getboolean(42), True) self.assertIs(tcl.getboolean(0), False) self.assertRaises(TypeError, tcl.getboolean) self.assertRaises(TypeError, tcl.getboolean, 'on', '1') self.assertRaises(TypeError, tcl.getboolean, b'on') self.assertRaises(TypeError, tcl.getboolean, 1.0) self.assertRaises(TclError, tcl.getboolean, 'a') self.assertRaises((TypeError, ValueError, TclError), tcl.getboolean, 'on\0') self.assertRaises((UnicodeEncodeError, ValueError, TclError), tcl.getboolean, 'on\ud800') def testEvalFile(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write("""set a 1 set b 2 set c [ expr $a + $b ] """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'),'1') self.assertEqual(tcl.eval('set b'),'2') self.assertEqual(tcl.eval('set c'),'3') def test_evalfile_null_in_result(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write(""" set a "a\0b" set b "a\\0b" """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'), 'a\x00b') self.assertEqual(tcl.eval('set b'), 'a\x00b') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError,tcl.evalfile,filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") stdout = subprocess.check_output( [unc_name, '-c', 'import tkinter; print(tkinter)']) self.assertIn(b'tkinter', stdout) def test_exprstring(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprstring(expr) self.assertEqual(result, expected) self.assertIsInstance(result, str) self.assertRaises(TypeError, tcl.exprstring) self.assertRaises(TypeError, tcl.exprstring, '8.2', '+6') self.assertRaises(TypeError, tcl.exprstring, b'8.2 + 6') self.assertRaises(TclError, tcl.exprstring, 'spam') check('', '0') check('8.2 + 6', '14.2') check('3.1 + $a', '6.1') check('2 + "$a.$b"', '5.6') check('4*[llength "6 2"]', '8') check('{word one} < "word $a"', '0') check('4*2 < 7', '0') check('hypot($a, 4)', '5.0') check('5 / 4', '1') check('5 / 4.0', '1.25') check('5 / ( [string length "abcd"] + 0.0 )', '1.25') check('20.0/5.0', '4.0') check('"0x03" > "2"', '1') check('[string length "a\xbd\u20ac"]', '3') check(r'[string length "a\xbd\u20ac"]', '3') check('"abc"', 'abc') check('"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\0b"', 'a\x00b') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', str(2**64)) def test_exprdouble(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprdouble(expr) self.assertEqual(result, expected) self.assertIsInstance(result, float) self.assertRaises(TypeError, tcl.exprdouble) self.assertRaises(TypeError, tcl.exprdouble, '8.2', '+6') self.assertRaises(TypeError, tcl.exprdouble, b'8.2 + 6') self.assertRaises(TclError, tcl.exprdouble, 'spam') check('', 0.0) check('8.2 + 6', 14.2) check('3.1 + $a', 6.1) check('2 + "$a.$b"', 5.6) check('4*[llength "6 2"]', 8.0) check('{word one} < "word $a"', 0.0) check('4*2 < 7', 0.0) check('hypot($a, 4)', 5.0) check('5 / 4', 1.0) check('5 / 4.0', 1.25) check('5 / ( [string length "abcd"] + 0.0 )', 1.25) check('20.0/5.0', 4.0) check('"0x03" > "2"', 1.0) check('[string length "a\xbd\u20ac"]', 3.0) check(r'[string length "a\xbd\u20ac"]', 3.0) self.assertRaises(TclError, tcl.exprdouble, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', float(2**64)) def test_exprlong(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprlong(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertRaises(TypeError, tcl.exprlong) self.assertRaises(TypeError, tcl.exprlong, '8.2', '+6') self.assertRaises(TypeError, tcl.exprlong, b'8.2 + 6') self.assertRaises(TclError, tcl.exprlong, 'spam') check('', 0) check('8.2 + 6', 14) check('3.1 + $a', 6) check('2 + "$a.$b"', 5) check('4*[llength "6 2"]', 8) check('{word one} < "word $a"', 0) check('4*2 < 7', 0) check('hypot($a, 4)', 5) check('5 / 4', 1) check('5 / 4.0', 1) check('5 / ( [string length "abcd"] + 0.0 )', 1) check('20.0/5.0', 4) check('"0x03" > "2"', 1) check('[string length "a\xbd\u20ac"]', 3) check(r'[string length "a\xbd\u20ac"]', 3) self.assertRaises(TclError, tcl.exprlong, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.exprlong, '2**64') def test_exprboolean(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprboolean(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertNotIsInstance(result, bool) self.assertRaises(TypeError, tcl.exprboolean) self.assertRaises(TypeError, tcl.exprboolean, '8.2', '+6') self.assertRaises(TypeError, tcl.exprboolean, b'8.2 + 6') self.assertRaises(TclError, tcl.exprboolean, 'spam') check('', False) for value in ('0', 'false', 'no', 'off'): check(value, False) check('"%s"' % value, False) check('{%s}' % value, False) for value in ('1', 'true', 'yes', 'on'): check(value, True) check('"%s"' % value, True) check('{%s}' % value, True) check('8.2 + 6', True) check('3.1 + $a', True) check('2 + "$a.$b"', True) check('4*[llength "6 2"]', True) check('{word one} < "word $a"', False) check('4*2 < 7', False) check('hypot($a, 4)', True) check('5 / 4', True) check('5 / 4.0', True) check('5 / ( [string length "abcd"] + 0.0 )', True) check('20.0/5.0', True) check('"0x03" > "2"', True) check('[string length "a\xbd\u20ac"]', True) check(r'[string length "a\xbd\u20ac"]', True) self.assertRaises(TclError, tcl.exprboolean, '"abc"') if tcl_version >= (8, 5): # bignum was added in Tcl 8.5 check('2**64', True) @unittest.skipUnless(tcl_version >= (8, 5), 'requires Tcl version >= 8.5') def test_booleans(self): tcl = self.interp def check(expr, expected): result = tcl.call('expr', expr) if tcl.wantobjects(): self.assertEqual(result, expected) self.assertIsInstance(result, int) else: self.assertIn(result, (expr, str(int(expected)))) self.assertIsInstance(result, str) check('true', True) check('yes', True) check('on', True) check('false', False) check('no', False) check('off', False) check('1 < 2', True) check('1 > 2', False) def test_expr_bignum(self): tcl = self.interp for i in self.get_integers(): result = tcl.call('expr', str(i)) if self.wantobjects: self.assertEqual(result, i) self.assertIsInstance(result, int) else: self.assertEqual(result, str(i)) self.assertIsInstance(result, str) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 self.assertRaises(TclError, tcl.call, 'expr', str(2**1000)) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True if self.wantobjects else '1') self.assertEqual(passValue(False), False if self.wantobjects else '0') self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') self.assertEqual(passValue('str\x00ing'), 'str\x00ing') self.assertEqual(passValue('str\x00ing\xbd'), 'str\x00ing\xbd') self.assertEqual(passValue('str\x00ing\u20ac'), 'str\x00ing\u20ac') self.assertEqual(passValue(b'str\x00ing'), b'str\x00ing' if self.wantobjects else 'str\x00ing') self.assertEqual(passValue(b'str\xc0\x80ing'), b'str\xc0\x80ing' if self.wantobjects else 'str\xc0\x80ing') self.assertEqual(passValue(b'str\xbding'), b'str\xbding' if self.wantobjects else 'str\xbding') for i in self.get_integers(): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 self.assertEqual(passValue(2**1000), str(2**1000)) for f in (0.0, 1.0, -1.0, 1/3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float('nan')) self.assertNotEqual(f, f) self.assertEqual(passValue(float('inf')), float('inf')) self.assertEqual(passValue(-float('inf')), -float('inf')) else: self.assertEqual(float(passValue(float('inf'))), float('inf')) self.assertEqual(float(passValue(-float('inf'))), -float('inf')) # XXX NaN representation can be not parsable by float() self.assertEqual(passValue((1, '2', (3.4,))), (1, '2', (3.4,)) if self.wantobjects else '1 2 3.4') self.assertEqual(passValue(['a', ['b', 'c']]), ('a', ('b', 'c')) if self.wantobjects else 'a {b c}') def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand('testfunc', testfunc) self.addCleanup(self.interp.tk.deletecommand, 'testfunc') def check(value, expected=None, *, eq=self.assertEqual): if expected is None: expected = value nonlocal result result = None r = self.interp.call('testfunc', value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) check(True, '1') check(False, '0') check('string') check('string\xbd') check('string\u20ac') check('') check(b'string', 'string') check(b'string\xe2\x82\xac', 'string\xe2\x82\xac') check(b'string\xbd', 'string\xbd') check(b'', '') check('str\x00ing') check('str\x00ing\xbd') check('str\x00ing\u20ac') check(b'str\x00ing', 'str\x00ing') check(b'str\xc0\x80ing', 'str\xc0\x80ing') check(b'str\xc0\x80ing\xe2\x82\xac', 'str\xc0\x80ing\xe2\x82\xac') for i in self.get_integers(): check(i, str(i)) if tcl_version < (8, 5): # bignum was added in Tcl 8.5 check(2**1000, str(2**1000)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1/3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, eq=float_eq) check(float('inf'), eq=float_eq) check(-float('inf'), eq=float_eq) # XXX NaN representation can be not parsable by float() check((), '') check((1, (2,), (3, 4), '5 6', ()), '1 2 {3 4} {5 6} {}') check([1, [2,], [3, 4], '5 6', []], '1 2 {3 4} {5 6} {}') def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2',)), ('', ()), ('{}', ('',)), ('""', ('',)), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), ([], ()), (['a', ['b', 'c']], ('a', ['b', 'c'])), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] tk_patchlevel = get_tk_patchlevel() if tcl_version >= (8, 5): if not self.wantobjects or tk_patchlevel < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\xe2\x82\xac', '3.4') else: expected = (12, '\u20ac', b'\xe2\x82\xac', (3.4,)) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)), expected), ] dbg_info = ('want objects? %s, Tcl version: %s, Tk patchlevel: %s' % (self.wantobjects, tcl_version, tk_patchlevel)) for arg, res in testcases: self.assertEqual(splitlist(arg), res, 'arg=%a, %s' % (arg, dbg_info)) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b', 'a\x00b'), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), (b'{a\xc0\x80b c\xc0\x80d', '{a\x00b c\x00d'), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), ([], ()), (['a', 'b c'], ('a', ('b', 'c'))), (['a', ['b', 'c']], ('a', ('b', 'c'))), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\xe2\x82\xac', '3.4') else: expected = (12, '\u20ac', b'\xe2\x82\xac', (3.4,)) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)), expected), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg) def test_splitdict(self): splitdict = tkinter._splitdict tcl = self.interp.tk arg = '-a {1 2 3} -something foo status {}' self.assertEqual(splitdict(tcl, arg, False), {'-a': '1 2 3', '-something': 'foo', 'status': ''}) self.assertEqual(splitdict(tcl, arg), {'a': '1 2 3', 'something': 'foo', 'status': ''}) arg = ('-a', (1, 2, 3), '-something', 'foo', 'status', '{}') self.assertEqual(splitdict(tcl, arg, False), {'-a': (1, 2, 3), '-something': 'foo', 'status': '{}'}) self.assertEqual(splitdict(tcl, arg), {'a': (1, 2, 3), 'something': 'foo', 'status': '{}'}) self.assertRaises(RuntimeError, splitdict, tcl, '-a b -c ') self.assertRaises(RuntimeError, splitdict, tcl, ('-a', 'b', '-c')) arg = tcl.call('list', '-a', (1, 2, 3), '-something', 'foo', 'status', ()) self.assertEqual(splitdict(tcl, arg), {'a': (1, 2, 3) if self.wantobjects else '1 2 3', 'something': 'foo', 'status': ''}) if tcl_version >= (8, 5): arg = tcl.call('dict', 'create', '-a', (1, 2, 3), '-something', 'foo', 'status', ()) if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = {'a': '1 2 3', 'something': 'foo', 'status': ''} else: expected = {'a': (1, 2, 3), 'something': 'foo', 'status': ''} self.assertEqual(splitdict(tcl, arg), expected)
def setUp(self): self.interp = Tcl()
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'),'1') def testEvalException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'this is wrong') def testCall(self): tcl = self.interp tcl.call('set','a','1') self.assertEqual(tcl.call('set','a'),'1') def testCallException(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'set','a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError,tcl.call,'this','is','wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a','1') self.assertEqual(tcl.eval('set a'),'1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)','1') self.assertEqual(tcl.eval('set a(1)'),'1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'),'1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'),'1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError,tcl.getvar,'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a',1) self.assertEqual(tcl.eval('info exists a'),'1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'),'0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)',1) tcl.setvar('a(2)',2) self.assertEqual(tcl.eval('info exists a(1)'),'1') self.assertEqual(tcl.eval('info exists a(2)'),'1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'),'0') self.assertEqual(tcl.eval('info exists a(2)'),'1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError,tcl.unsetvar,'a') def testEvalFile(self): tcl = self.interp filename = "testEvalFile.tcl" fd = open(filename,'w') script = """set a 1 set b 2 set c [ expr $a + $b ] """ fd.write(script) fd.close() tcl.evalfile(filename) os.remove(filename) self.assertEqual(tcl.eval('set a'),'1') self.assertEqual(tcl.eval('set b'),'2') self.assertEqual(tcl.eval('set c'),'3') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError,tcl.evalfile,filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError,tcl.eval,'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name,)) self.assertIn('tkinter', f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True if self.wantobjects else '1') self.assertEqual(passValue(False), False if self.wantobjects else '0') self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') for i in (0, 1, -1, 2**31-1, -2**31): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) for f in (0.0, 1.0, -1.0, 1/3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float('nan')) self.assertNotEqual(f, f) self.assertEqual(passValue(float('inf')), float('inf')) self.assertEqual(passValue(-float('inf')), -float('inf')) else: f = float(passValue(float('nan'))) self.assertNotEqual(f, f) self.assertEqual(float(passValue(float('inf'))), float('inf')) self.assertEqual(float(passValue(-float('inf'))), -float('inf')) self.assertEqual(passValue((1, '2', (3.4,))), (1, '2', (3.4,)) if self.wantobjects else '1 2 3.4') def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand('testfunc', testfunc) def check(value, expected, eq=self.assertEqual): r = self.interp.call('testfunc', value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): expected = float(expected) self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) def nan_eq(actual, expected): actual = float(actual) self.assertNotEqual(actual, actual) check(True, '1') check(False, '0') check('string', 'string') check('string\xbd', 'string\xbd') check('string\u20ac', 'string\u20ac') for i in (0, 1, -1, 2**31-1, -2**31): check(i, str(i)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1/3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, f, eq=float_eq) check(float('inf'), 'Inf', eq=float_eq) check(-float('inf'), '-Inf', eq=float_eq) check(float('nan'), 'NaN', eq=nan_eq) check((), '') check((1, (2,), (3, 4), '5 6', ()), '1 2 {3 4} {5 6} {}') def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2',)), ('', ()), ('{}', ('',)), ('""', ('',)), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): testcases += [ (call('dict', 'create', 1, '\u20ac', b'\xe2\x82\xac', (3.4,)), (1, '\u20ac', '\u20ac', (3.4,)) if self.wantobjects else ('1', '\u20ac', '\u20ac', '3.4')), ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), (call('list', 1, '2', (3.4,)), (1, '2', (3.4,)) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)), (12, '\u20ac', '\u20ac', (3.4,)) if self.wantobjects else ('12', '\u20ac', '\u20ac', '3.4')), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg) def test_merge(self): with support.check_warnings(('merge is deprecated', DeprecationWarning)): merge = self.interp.tk.merge call = self.interp.tk.call testcases = [ ((), ''), (('a',), 'a'), ((2,), '2'), (('',), '{}'), ('{', '\\{'), (('a', 'b', 'c'), 'a b c'), ((' ', '\t', '\r', '\n'), '{ } {\t} {\r} {\n}'), (('a', ' ', 'c'), 'a { } c'), (('a', '€'), 'a €'), (('a', '\U000104a2'), 'a \U000104a2'), (('a', b'\xe2\x82\xac'), 'a €'), (('a', ('b', 'c')), 'a {b c}'), (('a', 2), 'a 2'), (('a', 3.4), 'a 3.4'), (('a', (2, 3.4)), 'a {2 3.4}'), ((), ''), ((call('list', 1, '2', (3.4,)),), '{1 2 3.4}'), ] if tcl_version >= (8, 5): testcases += [ ((call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)),), '{12 € € 3.4}'), ] for args, res in testcases: self.assertEqual(merge(*args), res, msg=args) self.assertRaises(UnicodeDecodeError, merge, b'\x80') self.assertRaises(UnicodeEncodeError, merge, '\udc80')
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'), '1') def testEvalException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'this is wrong') def testCall(self): tcl = self.interp tcl.call('set', 'a', '1') self.assertEqual(tcl.call('set', 'a'), '1') def testCallException(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'set', 'a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'this', 'is', 'wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a', '1') self.assertEqual(tcl.eval('set a'), '1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)', '1') self.assertEqual(tcl.eval('set a(1)'), '1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'), '1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'), '1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a', 1) self.assertEqual(tcl.eval('info exists a'), '1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'), '0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)', 1) tcl.setvar('a(2)', 2) self.assertEqual(tcl.eval('info exists a(1)'), '1') self.assertEqual(tcl.eval('info exists a(2)'), '1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'), '0') self.assertEqual(tcl.eval('info exists a(2)'), '1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.unsetvar, 'a') def testEvalFile(self): tcl = self.interp filename = "testEvalFile.tcl" fd = open(filename, 'w') script = """set a 1 set b 2 set c [ expr $a + $b ] """ fd.write(script) fd.close() tcl.evalfile(filename) os.remove(filename) self.assertEqual(tcl.eval('set a'), '1') self.assertEqual(tcl.eval('set b'), '2') self.assertEqual(tcl.eval('set c'), '3') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError, tcl.evalfile, filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name, )) self.assertIn('tkinter', f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True) self.assertEqual(passValue(False), False) self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') for i in (0, 1, -1, 2**31 - 1, -2**31): self.assertEqual(passValue(i), i) for f in (0.0, 1.0, -1.0, 1 / 3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): self.assertEqual(passValue(f), f) for f in float('nan'), float('inf'), -float('inf'): if f != f: # NaN self.assertNotEqual(passValue(f), f) else: self.assertEqual(passValue(f), f) self.assertEqual(passValue((1, '2', (3.4, ))), (1, '2', (3.4, ))) def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2', )), ('', ()), ('{}', ('', )), ('""', ('', )), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, ))), ] if tcl_version >= (8, 5): testcases += [ (call('dict', 'create', 1, '\u20ac', b'\xe2\x82\xac', (3.4, )), (1, '\u20ac', '\u20ac', (3.4, ))), ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, ))), ] if tcl_version >= (8, 5): testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4, )), (12, '\u20ac', '\u20ac', (3.4, ))), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg)
class TclTest(unittest.TestCase): def setUp(self): self.interp = Tcl() self.wantobjects = self.interp.tk.wantobjects() def testEval(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.eval('set a'), '1') def test_eval_null_in_result(self): tcl = self.interp self.assertEqual(tcl.eval('set a "a\\0b"'), 'a\x00b') def testEvalException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'set a') def testEvalException2(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'this is wrong') def testCall(self): tcl = self.interp tcl.call('set', 'a', '1') self.assertEqual(tcl.call('set', 'a'), '1') def testCallException(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'set', 'a') def testCallException2(self): tcl = self.interp self.assertRaises(TclError, tcl.call, 'this', 'is', 'wrong') def testSetVar(self): tcl = self.interp tcl.setvar('a', '1') self.assertEqual(tcl.eval('set a'), '1') def testSetVarArray(self): tcl = self.interp tcl.setvar('a(1)', '1') self.assertEqual(tcl.eval('set a(1)'), '1') def testGetVar(self): tcl = self.interp tcl.eval('set a 1') self.assertEqual(tcl.getvar('a'), '1') def testGetVarArray(self): tcl = self.interp tcl.eval('set a(1) 1') self.assertEqual(tcl.getvar('a(1)'), '1') def testGetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a') def testGetVarArrayException(self): tcl = self.interp self.assertRaises(TclError, tcl.getvar, 'a(1)') def testUnsetVar(self): tcl = self.interp tcl.setvar('a', 1) self.assertEqual(tcl.eval('info exists a'), '1') tcl.unsetvar('a') self.assertEqual(tcl.eval('info exists a'), '0') def testUnsetVarArray(self): tcl = self.interp tcl.setvar('a(1)', 1) tcl.setvar('a(2)', 2) self.assertEqual(tcl.eval('info exists a(1)'), '1') self.assertEqual(tcl.eval('info exists a(2)'), '1') tcl.unsetvar('a(1)') self.assertEqual(tcl.eval('info exists a(1)'), '0') self.assertEqual(tcl.eval('info exists a(2)'), '1') def testUnsetVarException(self): tcl = self.interp self.assertRaises(TclError, tcl.unsetvar, 'a') def testEvalFile(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write("""set a 1 set b 2 set c [ expr $a + $b ] """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'), '1') self.assertEqual(tcl.eval('set b'), '2') self.assertEqual(tcl.eval('set c'), '3') def test_evalfile_null_in_result(self): tcl = self.interp with open(support.TESTFN, 'w') as f: self.addCleanup(support.unlink, support.TESTFN) f.write(""" set a "a\0b" set b "a\\0b" """) tcl.evalfile(support.TESTFN) self.assertEqual(tcl.eval('set a'), 'a\x00b') self.assertEqual(tcl.eval('set b'), 'a\x00b') def testEvalFileException(self): tcl = self.interp filename = "doesnotexists" try: os.remove(filename) except Exception as e: pass self.assertRaises(TclError, tcl.evalfile, filename) def testPackageRequireException(self): tcl = self.interp self.assertRaises(TclError, tcl.eval, 'package require DNE') @unittest.skipUnless(sys.platform == 'win32', 'Requires Windows') def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': raise unittest.SkipTest('Absolute path should have drive part') unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) if not os.path.exists(unc_name): raise unittest.SkipTest('Cannot connect to UNC Path') with support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") f = os.popen('%s -c "import tkinter; print(tkinter)"' % (unc_name, )) self.assertIn('tkinter', f.read()) # exit code must be zero self.assertEqual(f.close(), None) def test_exprstring(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprstring(expr) self.assertEqual(result, expected) self.assertIsInstance(result, str) self.assertRaises(TypeError, tcl.exprstring) self.assertRaises(TypeError, tcl.exprstring, '8.2', '+6') self.assertRaises(TypeError, tcl.exprstring, b'8.2 + 6') self.assertRaises(TclError, tcl.exprstring, 'spam') check('', '0') check('8.2 + 6', '14.2') check('3.1 + $a', '6.1') check('2 + "$a.$b"', '5.6') check('4*[llength "6 2"]', '8') check('{word one} < "word $a"', '0') check('4*2 < 7', '0') check('hypot($a, 4)', '5.0') check('5 / 4', '1') check('5 / 4.0', '1.25') check('5 / ( [string length "abcd"] + 0.0 )', '1.25') check('20.0/5.0', '4.0') check('"0x03" > "2"', '1') check('[string length "a\xbd\u20ac"]', '3') check(r'[string length "a\xbd\u20ac"]', '3') check('"abc"', 'abc') check('"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\xbd\u20ac"', 'a\xbd\u20ac') check(r'"a\0b"', 'a\x00b') if tcl_version >= (8, 5): check('2**64', str(2**64)) def test_exprdouble(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprdouble(expr) self.assertEqual(result, expected) self.assertIsInstance(result, float) self.assertRaises(TypeError, tcl.exprdouble) self.assertRaises(TypeError, tcl.exprdouble, '8.2', '+6') self.assertRaises(TypeError, tcl.exprdouble, b'8.2 + 6') self.assertRaises(TclError, tcl.exprdouble, 'spam') check('', 0.0) check('8.2 + 6', 14.2) check('3.1 + $a', 6.1) check('2 + "$a.$b"', 5.6) check('4*[llength "6 2"]', 8.0) check('{word one} < "word $a"', 0.0) check('4*2 < 7', 0.0) check('hypot($a, 4)', 5.0) check('5 / 4', 1.0) check('5 / 4.0', 1.25) check('5 / ( [string length "abcd"] + 0.0 )', 1.25) check('20.0/5.0', 4.0) check('"0x03" > "2"', 1.0) check('[string length "a\xbd\u20ac"]', 3.0) check(r'[string length "a\xbd\u20ac"]', 3.0) self.assertRaises(TclError, tcl.exprdouble, '"abc"') if tcl_version >= (8, 5): check('2**64', float(2**64)) def test_exprlong(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprlong(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertRaises(TypeError, tcl.exprlong) self.assertRaises(TypeError, tcl.exprlong, '8.2', '+6') self.assertRaises(TypeError, tcl.exprlong, b'8.2 + 6') self.assertRaises(TclError, tcl.exprlong, 'spam') check('', 0) check('8.2 + 6', 14) check('3.1 + $a', 6) check('2 + "$a.$b"', 5) check('4*[llength "6 2"]', 8) check('{word one} < "word $a"', 0) check('4*2 < 7', 0) check('hypot($a, 4)', 5) check('5 / 4', 1) check('5 / 4.0', 1) check('5 / ( [string length "abcd"] + 0.0 )', 1) check('20.0/5.0', 4) check('"0x03" > "2"', 1) check('[string length "a\xbd\u20ac"]', 3) check(r'[string length "a\xbd\u20ac"]', 3) self.assertRaises(TclError, tcl.exprlong, '"abc"') if tcl_version >= (8, 5): self.assertRaises(TclError, tcl.exprlong, '2**64') def test_exprboolean(self): tcl = self.interp tcl.call('set', 'a', 3) tcl.call('set', 'b', 6) def check(expr, expected): result = tcl.exprboolean(expr) self.assertEqual(result, expected) self.assertIsInstance(result, int) self.assertNotIsInstance(result, bool) self.assertRaises(TypeError, tcl.exprboolean) self.assertRaises(TypeError, tcl.exprboolean, '8.2', '+6') self.assertRaises(TypeError, tcl.exprboolean, b'8.2 + 6') self.assertRaises(TclError, tcl.exprboolean, 'spam') check('', False) for value in ('0', 'false', 'no', 'off'): check(value, False) check('"%s"' % value, False) check('{%s}' % value, False) for value in ('1', 'true', 'yes', 'on'): check(value, True) check('"%s"' % value, True) check('{%s}' % value, True) check('8.2 + 6', True) check('3.1 + $a', True) check('2 + "$a.$b"', True) check('4*[llength "6 2"]', True) check('{word one} < "word $a"', False) check('4*2 < 7', False) check('hypot($a, 4)', True) check('5 / 4', True) check('5 / 4.0', True) check('5 / ( [string length "abcd"] + 0.0 )', True) check('20.0/5.0', True) check('"0x03" > "2"', True) check('[string length "a\xbd\u20ac"]', True) check(r'[string length "a\xbd\u20ac"]', True) self.assertRaises(TclError, tcl.exprboolean, '"abc"') if tcl_version >= (8, 5): check('2**64', True) def test_passing_values(self): def passValue(value): return self.interp.call('set', '_', value) self.assertEqual(passValue(True), True if self.wantobjects else '1') self.assertEqual(passValue(False), False if self.wantobjects else '0') self.assertEqual(passValue('string'), 'string') self.assertEqual(passValue('string\u20ac'), 'string\u20ac') self.assertEqual(passValue('str\x00ing'), 'str\x00ing') self.assertEqual(passValue('str\x00ing\xbd'), 'str\x00ing\xbd') self.assertEqual(passValue('str\x00ing\u20ac'), 'str\x00ing\u20ac') self.assertEqual(passValue(b'str\x00ing'), 'str\x00ing') self.assertEqual(passValue(b'str\xc0\x80ing'), 'str\x00ing') for i in (0, 1, -1, 2**31 - 1, -2**31): self.assertEqual(passValue(i), i if self.wantobjects else str(i)) for f in (0.0, 1.0, -1.0, 1 / 3, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): if self.wantobjects: self.assertEqual(passValue(f), f) else: self.assertEqual(float(passValue(f)), f) if self.wantobjects: f = passValue(float('nan')) self.assertNotEqual(f, f) self.assertEqual(passValue(float('inf')), float('inf')) self.assertEqual(passValue(-float('inf')), -float('inf')) else: f = float(passValue(float('nan'))) self.assertNotEqual(f, f) self.assertEqual(float(passValue(float('inf'))), float('inf')) self.assertEqual(float(passValue(-float('inf'))), -float('inf')) self.assertEqual(passValue((1, '2', (3.4, ))), (1, '2', (3.4, )) if self.wantobjects else '1 2 3.4') def test_user_command(self): result = None def testfunc(arg): nonlocal result result = arg return arg self.interp.createcommand('testfunc', testfunc) def check(value, expected, eq=self.assertEqual): r = self.interp.call('testfunc', value) self.assertIsInstance(result, str) eq(result, expected) self.assertIsInstance(r, str) eq(r, expected) def float_eq(actual, expected): expected = float(expected) self.assertAlmostEqual(float(actual), expected, delta=abs(expected) * 1e-10) def nan_eq(actual, expected): actual = float(actual) self.assertNotEqual(actual, actual) check(True, '1') check(False, '0') check('string', 'string') check('string\xbd', 'string\xbd') check('string\u20ac', 'string\u20ac') check(b'string', 'string') check(b'string\xe2\x82\xac', 'string\u20ac') check('str\x00ing', 'str\x00ing') check('str\x00ing\xbd', 'str\x00ing\xbd') check('str\x00ing\u20ac', 'str\x00ing\u20ac') check(b'str\xc0\x80ing', 'str\x00ing') check(b'str\xc0\x80ing\xe2\x82\xac', 'str\x00ing\u20ac') for i in (0, 1, -1, 2**31 - 1, -2**31): check(i, str(i)) for f in (0.0, 1.0, -1.0): check(f, repr(f)) for f in (1 / 3.0, sys.float_info.min, sys.float_info.max, -sys.float_info.min, -sys.float_info.max): check(f, f, eq=float_eq) check(float('inf'), 'Inf', eq=float_eq) check(-float('inf'), '-Inf', eq=float_eq) check(float('nan'), 'NaN', eq=nan_eq) check((), '') check((1, (2, ), (3, 4), '5 6', ()), '1 2 {3 4} {5 6} {}') def test_splitlist(self): splitlist = self.interp.tk.splitlist call = self.interp.tk.call self.assertRaises(TypeError, splitlist) self.assertRaises(TypeError, splitlist, 'a', 'b') self.assertRaises(TypeError, splitlist, 2) testcases = [ ('2', ('2', )), ('', ()), ('{}', ('', )), ('""', ('', )), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), ('a {b c}', ('a', 'b c')), (r'a b\ c', ('a', 'b c')), (('a', 'b c'), ('a', 'b c')), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), ((), ()), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, )) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\u20ac', '3.4') else: expected = (12, '\u20ac', '\u20ac', (3.4, )) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4, )), expected), ] for arg, res in testcases: self.assertEqual(splitlist(arg), res, msg=arg) self.assertRaises(TclError, splitlist, '{') def test_split(self): split = self.interp.tk.split call = self.interp.tk.call self.assertRaises(TypeError, split) self.assertRaises(TypeError, split, 'a', 'b') self.assertRaises(TypeError, split, 2) testcases = [ ('2', '2'), ('', ''), ('{}', ''), ('""', ''), ('{', '{'), ('a\n b\t\r c\n ', ('a', 'b', 'c')), (b'a\n b\t\r c\n ', ('a', 'b', 'c')), ('a \u20ac', ('a', '\u20ac')), (b'a \xe2\x82\xac', ('a', '\u20ac')), (b'a\xc0\x80b', 'a\x00b'), (b'a\xc0\x80b c\xc0\x80d', ('a\x00b', 'c\x00d')), (b'{a\xc0\x80b c\xc0\x80d', '{a\x00b c\x00d'), ('a {b c}', ('a', ('b', 'c'))), (r'a b\ c', ('a', ('b', 'c'))), (('a', b'b c'), ('a', ('b', 'c'))), (('a', 'b c'), ('a', ('b', 'c'))), ('a 2', ('a', '2')), (('a', 2), ('a', 2)), ('a 3.4', ('a', '3.4')), (('a', 3.4), ('a', 3.4)), (('a', (2, 3.4)), ('a', (2, 3.4))), ((), ()), (call('list', 1, '2', (3.4, )), (1, '2', (3.4, )) if self.wantobjects else ('1', '2', '3.4')), ] if tcl_version >= (8, 5): if not self.wantobjects or get_tk_patchlevel() < (8, 5, 5): # Before 8.5.5 dicts were converted to lists through string expected = ('12', '\u20ac', '\u20ac', '3.4') else: expected = (12, '\u20ac', '\u20ac', (3.4, )) testcases += [ (call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4, )), expected), ] for arg, res in testcases: self.assertEqual(split(arg), res, msg=arg)
default='DeepGlint', type=str, help='save name') parser.add_argument('-r', '--ratio', default=0.2, type=float, help='How many images do you want to use in validation') parser.add_argument('-s', '--set', default=['train', 'val']) args = parser.parse_args() root = os.path.join('/home/ubuntu/data/', args.project) # root = os.path.join('datasets', args.project) ids = os.listdir(root) ids = Tcl().call('lsort', '-dict', ids) print('Total_ids :', len(ids)) min_n = 0 max_n = 0 cn = 0 for id in ids: images = os.listdir(os.path.join(root, id)) if min_n == 0: min_n = len(images) max_n = max([max_n, len(images)]) min_n = min([min_n, len(images)]) if len(images) < 11: # print('id :', id)