def test_tclobj_arithmetic4(self, x, y):
"""test tclobj <<="""
tx = tohil.tclobj(x)
ty = tohil.tclobj(y)
assert tx << y == x << y
assert tx << ty == x << y
assert x << ty == x << y
def test_tclobj_math10(self, i, j):
"""exercise tohil.tclobj "and" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti & j == i & j)
assert (ti & tj == i & j)
assert (i & tj == i & j)
def test_tclobj_math9(self, i, j):
"""exercise tohil.tclobj right shift math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti >> j == i >> j)
assert (ti >> tj == i >> j)
assert (i >> tj == i >> j)
def test_tclobj_math12(self, i, j):
"""exercise tohil.tclobj "xor" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti ^ j == i ^ j)
assert (ti ^ tj == i ^ j)
assert (i ^ tj == i ^ j)
def test_tclobj_math11(self, i, j):
"""exercise tohil.tclobj "or" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti | j == i | j)
assert (ti | tj == i | j)
assert (i | tj == i | j)
def test_tclobj_math21(self, i, j):
"""exercise tohil.tclobj "true divide" math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (abs(ti / j - i / j) < 1e-6)
assert (abs(ti / tj - i / j) < 1e-6)
assert (abs(i / tj - i / j) < 1e-6)
def test_tclobj_math22(self, i, j):
"""exercise tohil.tclobj "floor divide" math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti // j == i // j)
assert (ti // tj == i // j)
assert (i // tj == i // j)
def test_tclobj_arithmetic3(self, x, y):
"""test tclobj *="""
tx = tohil.tclobj(x)
ty = tohil.tclobj(y)
tx *= y
assert tx == x * y
tx = tohil.tclobj(x)
tx *= ty
assert tx == x * ty
def test_tclobj_arithmetic2(self, x, y):
"""test tclobj +="""
tx = tohil.tclobj(x)
ty = tohil.tclobj(y)
tx += y
assert tx == x + y
tx.set(x)
tx += ty
assert tx == x + y
def test_tclobj_math18(self, i, j):
"""exercise tohil.tclobj "true divide" math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti / j == i / j)
assert (ti / tj == i / j)
assert (i / tj == i / j)
def test_tclobj_arithmetic1(self, x, y):
"""test tclobj +"""
tx = tohil.tclobj(x)
ty = tohil.tclobj(y)
assert tx + y == x + y
assert x + ty == x + y
assert tx + ty == x + y
assert tx - y == x - y
assert x - ty == x - y
assert tx - ty == x - y
def test_tclobj25(self):
"""tohil.tclobj dict wrapping tests"""
# This isn't recommended (you should use the to= kwarg), but it works
self.assertEqual(dict(tohil.tclobj()), {})
# And here's why it's not recommended
with self.assertRaises(ValueError):
dict(tohil.tclobj("1 2"))
with self.assertRaises(TypeError):
# iterating on the tclobj gives us more tclobjs, which aren't
# hashable and so cannot be keys
dict(tohil.tclobj("{1 2}"))
def test_tclobj_math20(self, i, j):
"""exercise tohil.tclobj "inplace bitwise xor" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti ^= j
assert (ti == i ^ j)
ti = tohil.tclobj(i)
ti ^= tj
assert (ti == i ^ j)
def test_tclobj_math19(self, i, j):
"""exercise tohil.tclobj "inplace bitwise and" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti &= j
assert (ti == i & j)
ti = tohil.tclobj(i)
ti &= tj
assert (ti == i & j)
def test_tclobj_math18(self, i, j):
"""exercise tohil.tclobj "inplace bitwise or" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti |= j
assert (ti == i | j)
ti = tohil.tclobj(i)
ti |= tj
assert (ti == i | j)
def test_tclobj_math17(self, i, j):
"""exercise tohil.tclobj right shift math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti >>= j
assert (ti == i >> j)
ti = tohil.tclobj(i)
ti >>= tj
assert (ti == i >> j)
def test_tclobj_math15(self, i, j):
"""exercise tohil.tclobj "inplace multiply" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti *= j
assert (ti == i * j)
ti = tohil.tclobj(i)
ti *= tj
assert (ti == i * j)
def test_tclobj_math14(self, i, j):
"""exercise tohil.tclobj "inplace subtract" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti -= j
assert (ti == i - j)
ti = tohil.tclobj(i)
ti -= tj
assert (ti == i - j)
def test_tclobj_math8(self, i, j):
"""exercise tohil.tclobj left shift math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti << j == i << j)
assert (ti << tj == i << j)
assert (i << tj == i << j)
assert (ti << 4 == i << 4)
assert (4 << tj == 4 << j)
def test_tclobj_math26(self, u, v):
"""exercise tohil.tclobj "inplace remainder" float math ops"""
assume(v != 0)
tu = tohil.tclobj(u)
tv = tohil.tclobj(v)
tu %= v
assert (abs(tu - u % v) < 0.000001)
tu = tohil.tclobj(u)
tu %= tv
assert (abs(tu - u % v) < 0.000001)
def test_tclobj_math23(self, i, j):
"""exercise tohil.tclobj "inplace floor divide" integer math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti //= j
assert (ti == i // j)
ti = tohil.tclobj(i)
ti //= tj
assert (ti == i // j)
def test_tclobj_math19(self, i, j):
"""exercise tohil.tclobj "inplace true divide" math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti /= j
assert (abs(ti - i / j) < 1e-6)
ti = tohil.tclobj(i)
ti /= tj
assert (abs(ti - i / j) < 1e-6)
def test_tclobj_math5(self, u, v):
"""exercise tohil.tclobj multiply float math ops"""
t6 = tohil.tclobj('6.')
tu = tohil.tclobj(u)
tv = tohil.tclobj(v)
assert (tu * 6 == u * 6)
assert (tu * 6. == u * 6.)
assert (tu * t6 == u * 6.)
assert (tu * tu == u * u)
assert (tu * tv == u * v)
def test_tclobj_math25(self, i, j):
"""exercise tohil.tclobj "inplace remainder" integer math ops"""
assume(j != 0)
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti %= j
assert (ti == i % j)
ti = tohil.tclobj(i)
ti %= tj
assert (ti == i % j)
def test_tclobj_math24(self, u, v):
"""exercise tohil.tclobj "inplace floor divide" float math ops"""
assume(v < -0.1 or v > 0.1)
tu = tohil.tclobj(u)
tv = tohil.tclobj(v)
tu //= v
assert (tu == u // v)
tu = tohil.tclobj(u)
tu //= tv
assert (tu == u // v)
def test_tclobj_math30(self):
"""exercise tohil.tclobj integer remainder of by zero exceptions"""
t5 = tohil.tclobj(5)
t0 = tohil.tclobj(0)
with self.assertRaises(ZeroDivisionError):
t5 % 0
with self.assertRaises(ZeroDivisionError):
t5 % t0
with self.assertRaises(ZeroDivisionError):
5 % t0
def test_tclobj_math29(self):
"""exercise tohil.tclobj integer division by zero exceptions"""
t5 = tohil.tclobj(5)
t0 = tohil.tclobj(0)
with self.assertRaises(ZeroDivisionError):
t5 // 0
with self.assertRaises(ZeroDivisionError):
t5 // t0
with self.assertRaises(ZeroDivisionError):
5 // t0
def test_tclobj_math28(self):
"""exercise tohil.tclobj float division by zero exceptions"""
t5 = tohil.tclobj(5.)
t0 = tohil.tclobj(0.)
with self.assertRaises(ZeroDivisionError):
t5 / 0.
with self.assertRaises(ZeroDivisionError):
t5 / t0
with self.assertRaises(ZeroDivisionError):
5 / t0
def test_tclobj_math2(self, i, j):
"""exercise tohil.tclobj 'minus' math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
assert (ti - 3 == i - 3)
assert (ti - ti == 0)
assert (6 - ti == 6 - i)
assert (tj - 4. == j - 4.)
assert (tj - float(tj) == 0.)
assert (6. - ti == 6. - i)
assert (tj - ti == j - i)
def test_tclobj_math13(self, i, j):
"""exercise tohil.tclobj "inplace add" math ops"""
ti = tohil.tclobj(i)
tj = tohil.tclobj(j)
ti += j
assert (ti == i + j)
ti = tohil.tclobj(i)
ti += ti
assert (ti == i + i)
ti = tohil.tclobj(i)
ti += tj
assert (ti == i + j)
