/Windows/Python3.8/WPy64-3830/WPy64-3830/python-3.8.3.amd64/Lib/tkinter/test/test_tkinter/test_variables.py

import unittest

import gc

from tkinter import (Variable, StringVar, IntVar, DoubleVar, BooleanVar, Tcl,

                     TclError)





class Var(Variable):



    _default = "default"

    side_effect = False



    def set(self, value):

        self.side_effect = True

        super().set(value)





class TestBase(unittest.TestCase):



    def setUp(self):

        self.root = Tcl()



    def tearDown(self):

        del self.root





class TestVariable(TestBase):



    def info_exists(self, *args):

        return self.root.getboolean(self.root.call("info", "exists", *args))



    def test_default(self):

        v = Variable(self.root)

        self.assertEqual("", v.get())

        self.assertRegex(str(v), r"^PY_VAR(\d+)$")



    def test_name_and_value(self):

        v = Variable(self.root, "sample string", "varname")

        self.assertEqual("sample string", v.get())

        self.assertEqual("varname", str(v))



    def test___del__(self):

        self.assertFalse(self.info_exists("varname"))

        v = Variable(self.root, "sample string", "varname")

        self.assertTrue(self.info_exists("varname"))

        del v

        self.assertFalse(self.info_exists("varname"))



    def test_dont_unset_not_existing(self):

        self.assertFalse(self.info_exists("varname"))

        v1 = Variable(self.root, name="name")

        v2 = Variable(self.root, name="name")

        del v1

        self.assertFalse(self.info_exists("name"))

        # shouldn't raise exception

        del v2

        self.assertFalse(self.info_exists("name"))



    def test___eq__(self):

        # values doesn't matter, only class and name are checked

        v1 = Variable(self.root, name="abc")

        v2 = Variable(self.root, name="abc")

        self.assertEqual(v1, v2)



        v3 = Variable(self.root, name="abc")

        v4 = StringVar(self.root, name="abc")

        self.assertNotEqual(v3, v4)



    def test_invalid_name(self):

        with self.assertRaises(TypeError):

            Variable(self.root, name=123)



    def test_null_in_name(self):

        with self.assertRaises(ValueError):

            Variable(self.root, name='var\x00name')

        with self.assertRaises(ValueError):

            self.root.globalsetvar('var\x00name', "value")

        with self.assertRaises(ValueError):

            self.root.globalsetvar(b'var\x00name', "value")

        with self.assertRaises(ValueError):

            self.root.setvar('var\x00name', "value")

        with self.assertRaises(ValueError):

            self.root.setvar(b'var\x00name', "value")



    def test_initialize(self):

        v = Var(self.root)

        self.assertFalse(v.side_effect)

        v.set("value")

        self.assertTrue(v.side_effect)



    def test_trace_old(self):

        # Old interface

        v = Variable(self.root)

        vname = str(v)

        trace = []

        def read_tracer(*args):

            trace.append(('read',) + args)

        def write_tracer(*args):

            trace.append(('write',) + args)

        cb1 = v.trace_variable('r', read_tracer)

        cb2 = v.trace_variable('wu', write_tracer)

        self.assertEqual(sorted(v.trace_vinfo()), [('r', cb1), ('wu', cb2)])

        self.assertEqual(trace, [])



        v.set('spam')

        self.assertEqual(trace, [('write', vname, '', 'w')])



        trace = []

        v.get()

        self.assertEqual(trace, [('read', vname, '', 'r')])



        trace = []

        info = sorted(v.trace_vinfo())

        v.trace_vdelete('w', cb1)  # Wrong mode

        self.assertEqual(sorted(v.trace_vinfo()), info)

        with self.assertRaises(TclError):

            v.trace_vdelete('r', 'spam')  # Wrong command name

        self.assertEqual(sorted(v.trace_vinfo()), info)

        v.trace_vdelete('r', (cb1, 43)) # Wrong arguments

        self.assertEqual(sorted(v.trace_vinfo()), info)

        v.get()

        self.assertEqual(trace, [('read', vname, '', 'r')])



        trace = []

        v.trace_vdelete('r', cb1)

        self.assertEqual(v.trace_vinfo(), [('wu', cb2)])

        v.get()

        self.assertEqual(trace, [])



        trace = []

        del write_tracer

        gc.collect()

        v.set('eggs')

        self.assertEqual(trace, [('write', vname, '', 'w')])



        trace = []

        del v

        gc.collect()

        self.assertEqual(trace, [('write', vname, '', 'u')])



    def test_trace(self):

        v = Variable(self.root)

        vname = str(v)

        trace = []

        def read_tracer(*args):

            trace.append(('read',) + args)

        def write_tracer(*args):

            trace.append(('write',) + args)

        tr1 = v.trace_add('read', read_tracer)

        tr2 = v.trace_add(['write', 'unset'], write_tracer)

        self.assertEqual(sorted(v.trace_info()), [

                         (('read',), tr1),

                         (('write', 'unset'), tr2)])

        self.assertEqual(trace, [])



        v.set('spam')

        self.assertEqual(trace, [('write', vname, '', 'write')])



        trace = []

        v.get()

        self.assertEqual(trace, [('read', vname, '', 'read')])



        trace = []

        info = sorted(v.trace_info())

        v.trace_remove('write', tr1)  # Wrong mode

        self.assertEqual(sorted(v.trace_info()), info)

        with self.assertRaises(TclError):

            v.trace_remove('read', 'spam')  # Wrong command name

        self.assertEqual(sorted(v.trace_info()), info)

        v.get()

        self.assertEqual(trace, [('read', vname, '', 'read')])



        trace = []

        v.trace_remove('read', tr1)

        self.assertEqual(v.trace_info(), [(('write', 'unset'), tr2)])

        v.get()

        self.assertEqual(trace, [])



        trace = []

        del write_tracer

        gc.collect()

        v.set('eggs')

        self.assertEqual(trace, [('write', vname, '', 'write')])



        trace = []

        del v

        gc.collect()

        self.assertEqual(trace, [('write', vname, '', 'unset')])





class TestStringVar(TestBase):



    def test_default(self):

        v = StringVar(self.root)

        self.assertEqual("", v.get())



    def test_get(self):

        v = StringVar(self.root, "abc", "name")

        self.assertEqual("abc", v.get())

        self.root.globalsetvar("name", "value")

        self.assertEqual("value", v.get())



    def test_get_null(self):

        v = StringVar(self.root, "abc\x00def", "name")

        self.assertEqual("abc\x00def", v.get())

        self.root.globalsetvar("name", "val\x00ue")

        self.assertEqual("val\x00ue", v.get())





class TestIntVar(TestBase):



    def test_default(self):

        v = IntVar(self.root)

        self.assertEqual(0, v.get())



    def test_get(self):

        v = IntVar(self.root, 123, "name")

        self.assertEqual(123, v.get())

        self.root.globalsetvar("name", "345")

        self.assertEqual(345, v.get())

        self.root.globalsetvar("name", "876.5")

        self.assertEqual(876, v.get())



    def test_invalid_value(self):

        v = IntVar(self.root, name="name")

        self.root.globalsetvar("name", "value")

        with self.assertRaises((ValueError, TclError)):

            v.get()





class TestDoubleVar(TestBase):



    def test_default(self):

        v = DoubleVar(self.root)

        self.assertEqual(0.0, v.get())



    def test_get(self):

        v = DoubleVar(self.root, 1.23, "name")

        self.assertAlmostEqual(1.23, v.get())

        self.root.globalsetvar("name", "3.45")

        self.assertAlmostEqual(3.45, v.get())



    def test_get_from_int(self):

        v = DoubleVar(self.root, 1.23, "name")

        self.assertAlmostEqual(1.23, v.get())

        self.root.globalsetvar("name", "3.45")

        self.assertAlmostEqual(3.45, v.get())

        self.root.globalsetvar("name", "456")

        self.assertAlmostEqual(456, v.get())



    def test_invalid_value(self):

        v = DoubleVar(self.root, name="name")

        self.root.globalsetvar("name", "value")

        with self.assertRaises((ValueError, TclError)):

            v.get()





class TestBooleanVar(TestBase):



    def test_default(self):

        v = BooleanVar(self.root)

        self.assertIs(v.get(), False)



    def test_get(self):

        v = BooleanVar(self.root, True, "name")

        self.assertIs(v.get(), True)

        self.root.globalsetvar("name", "0")

        self.assertIs(v.get(), False)

        self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)

        self.assertIs(v.get(), True)

        self.root.globalsetvar("name", 0)

        self.assertIs(v.get(), False)

        self.root.globalsetvar("name", "on")

        self.assertIs(v.get(), True)



    def test_set(self):

        true = 1 if self.root.wantobjects() else "1"

        false = 0 if self.root.wantobjects() else "0"

        v = BooleanVar(self.root, name="name")

        v.set(True)

        self.assertEqual(self.root.globalgetvar("name"), true)

        v.set("0")

        self.assertEqual(self.root.globalgetvar("name"), false)

        v.set(42)

        self.assertEqual(self.root.globalgetvar("name"), true)

        v.set(0)

        self.assertEqual(self.root.globalgetvar("name"), false)

        v.set("on")

        self.assertEqual(self.root.globalgetvar("name"), true)



    def test_invalid_value_domain(self):

        false = 0 if self.root.wantobjects() else "0"

        v = BooleanVar(self.root, name="name")

        with self.assertRaises(TclError):

            v.set("value")

        self.assertEqual(self.root.globalgetvar("name"), false)

        self.root.globalsetvar("name", "value")

        with self.assertRaises(ValueError):

            v.get()

        self.root.globalsetvar("name", "1.0")

        with self.assertRaises(ValueError):

            v.get()





tests_gui = (TestVariable, TestStringVar, TestIntVar,

             TestDoubleVar, TestBooleanVar)





if __name__ == "__main__":

    from test.support import run_unittest

    run_unittest(*tests_gui)