def setUp(self):
self.easy = Daikyu( x=1, y=1, z=0)
self.easy_too = Daikyu( x=0, y=-2, o=0)
self.a_tree = dict(
a = 1,
b = dict(
c = 3.0,
d = dict(e=True)
),
point = self.easy
)
self.cplx = bowyer(Daikyu,self.a_tree)
def setUp(self):
self.easy = VectorDict(int, dict(x=1, y=1, z=0))
self.easy_too = VectorDict(int, dict(x=0, y=-2, o=0))
self.a_tree = dict(
a = 1,
b = dict(
c = 3.0,
d = dict(e=True)
),
point = self.easy
)
self.cplx = convert_tree(self.a_tree)
def test_bug_boolean_not_commutative(self):
"""bug #11: a xor b != ! ( a xand b )"""
a = VectorDict(bool,
dict(tt=True, tf=True, ft=False, ff=False, not_in_b=False)
)
b = VectorDict(bool,
dict(tt=True, tf=False, ft=True, ff=False, not_in_a=True)
)
self.assertEqual(
(a & b.__not__()) | (a.__not__() & b),
((a | b.__not__()) & (a.__not__() | b)).__not__()
)
class TestDaikyu(unittest.TestCase):
def setUp(self):
self.easy = Daikyu( x=1, y=1, z=0)
self.easy_too = Daikyu( x=0, y=-2, o=0)
self.a_tree = dict(
a = 1,
b = dict(
c = 3.0,
d = dict(e=True)
),
point = self.easy
)
self.cplx = bowyer(Daikyu,self.a_tree)
def test_bug_1(self):
"""bug #1 : * returns a copy where a reference is needed"""
pt = self.easy
pt *= -1
self.assertEqual(
self.easy,
pt
)
def test_bug_2(self):
"""bug #2 : self * other without affectation should not modify self.
"""
self.easy *= -1
a_copy = self.easy.copy()
self.easy * a_copy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_4(self):
"""bug #4 : self / other without affectation should not modify self.
"""
del(self.easy['z'])
self.easy /= -1
a_copy = self.easy.copy()
self.easy / a_copy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_5(self):
"""bug #5 : int * dict without affectation should not modify self.
"""
a_copy = self.easy.copy()
2 * self.easy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_6(self):
"""bug #6 : int / dict without affectation should not modify self.
"""
del(self.easy['z'])
a_copy = self.easy.copy()
2.0 / self.easy
self.assertEqual(
self.easy,
a_copy
)
def test_for_fun(self):
"""just for fun """
a = self.easy
b = self.easy_too
aa = a.copy()
bb = b.copy()
self.assertEqual(
(a - b) * (a + b),
aa * aa - bb * bb
)
def test_for_fun2(self):
"""just for fun """
a = self.easy
b = self.easy_too
aa = a.copy()
bb = b.copy()
self.assertEqual(
-(a + b) * (a + b),
-1 * ((aa * aa) + 2 * aa * bb + (bb * bb))
)
def test_dyslexia_bug4(self):
"""counfonding right & left in all r(div/add/sub/mul) operator """
a = self.easy
self.assertEqual(
2/Daikyu({'a':1}),
{'a' : 2}
)
self.assertEqual(
2-a,
-(a-2)
)
def test_inplace_bug5(self):
"""a/b in place"""
a = self.easy*4
self.assertEqual(
a/{'x':2},
{'x' : 2}
)
class TestVectorDict(unittest.TestCase):
def setUp(self):
self.easy = VectorDict(int, dict(x=1, y=1, z=0))
self.easy_too = VectorDict(int, dict(x=0, y=-2, o=0))
self.a_tree = dict(
a = 1,
b = dict(
c = 3.0,
d = dict(e=True)
),
point = self.easy
)
self.cplx = convert_tree(self.a_tree)
def test_convert(self):
self.assertEqual(convert_tree({'a': {'b': 1}}),
VectorDict(VectorDict,
{'a': VectorDict(VectorDict, dict(b=1))}
)
)
def test_add_not_exists(self):
self.easy += dict(a=1)
self.assertEqual(self.easy['a'], 1)
def test_add_exists(self):
self.easy += dict(x=1)
self.assertEqual(self.easy['x'] , 2)
def test_clause_has_type(self):
self.assertEqual(
has_type(float)(3.0),
True
)
def test_is_leaf(self):
""" we need a is_leaf more specialized must have a bug somewhre
in find / match_tre
TODO have one that tells is not vector_dict
"""
self.assertEqual(
all([is_leaf(e) for e in [
set(),
frozenset(),
list(),
xrange(10),
3.0,
2,
False,
"ljlkjkl",
]]),
True
)
def test_is_container(self):
self.assertEqual(
all([is_container(e) for e in [
dict(),
set(),
frozenset(),
list(),
VectorDict(bool, {}),
xrange(10)
]]),
True
)
def test_match_tree(self):
self.assertEqual(
self.cplx["b"].match_tree(dict(c=3.0, d=dict(e=True))),
True
)
def test_match_tree2(self):
self.assertEqual(
self.cplx.match_tree(dict(
b=dict(c=3.0, d=anything))),
True
)
def test_match_tree3(self):
self.assertEqual(
self.cplx["b"].match_tree(
dict(
c=has_type(float),
d=anything
)),
True
)
def test_find1(self):
self.assertEqual(
[e for e in self.cplx.find(lambda p, v: (
not is_leaf(v) and v.match_tree(
dict(c=has_type(float), d=is_container)
)
))][0][0], ('b',))
def test_collision_build_path(self):
self.assertRaises(
ValueError,
self.easy.build_path, 'z', 1)
def test_collision_build_path2(self):
self.assertRaises(
ValueError,
self.cplx.build_path, 'b', 1)
def test_build_path(self):
self.cplx.build_path('b', "new", "whatever")
self.assertEqual(
self.cplx["b"]["new"],
"whatever")
# def test_add_path(self):
# self.cplx.add_path(['b', "new", "whatever"])
# self.cplx.add_path(['b', "new", "whatever"])
# self.assertEqual(
# self.cplx["b"]["new"],
# "whatever" * 2)
def test_at1(self):
self.assertRaises(
IndexError,
self.cplx.at, ['a', 'b', 'c'])
def test_at2_and_ope_mul(self):
self.assertEqual(
self.cplx.at(['b', 'c']),
3.0
)
def test_at3_and_ope_mul(self):
self.assertEqual(
self.cplx.at(['b', 'c'], mul(-1)),
-3.0
)
def test_at4(self):
self.assertRaises(
Exception,
self.cplx.at, 'a', 'b', 'c')
def test_at5_copy(self):
"""not sure I ever used it"""
self.assertIsNot(
self.cplx.at(['b'], None, True),
self.cplx["b"]
)
def test_get_at(self):
self.assertIs(
self.cplx.at( ['b', 'c' ] ),
self.cplx.get_at( 'b' , 'c' )
)
def test_dot(self):
self.assertEqual(
dot(
VectorDict(int, dict(x=1, y=1, z=0)),
VectorDict(int, dict(x=1, y=1, z=1)),
),
float(2.0)
)
def test_cos(self):
self.assertAlmostEqual(
cos(
VectorDict(int, dict(x=1, y=0)),
VectorDict(int, dict(x=1, y=1)),
),
float(sqrt(2) / 2)
)
def test_build_path_collision(self):
self.easy.build_path('ext', 'y', 1)
self.easy.build_path('ext', 'z', 1)
self.assertEqual(
len(self.easy['ext'].keys()),
2
)
def test_imul(self):
a_copy = self.easy.copy()
self.easy *= -1
self.assertEqual(
self.easy['x'],
-a_copy['x']
)
def test_bug_1(self):
"""bug #1 : * returns a copy where a reference is needed"""
pt = self.easy
pt *= -1
self.assertEqual(
self.easy,
pt
)
def test_bug_2(self):
"""bug #2 : self * other without affectation should not modify self.
"""
self.easy *= -1
a_copy = self.easy.copy()
self.easy * a_copy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_3(self):
"""bug #3 : / returns a copy where a reference is needed"""
self.easy.prune('z')
pt = self.easy.at([])
pt /= -1
self.assertEqual(
self.easy,
pt
)
def test_bug_4(self):
"""bug #4 : self / other without affectation should not modify self.
"""
self.easy.prune('z')
self.easy /= -1
a_copy = self.easy.copy()
self.easy / a_copy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_5(self):
"""bug #5 : int * dict without affectation should not modify self.
"""
a_copy = self.easy.copy()
2 * self.easy
self.assertEqual(
self.easy,
a_copy
)
def test_bug_6(self):
"""bug #6 : int / dict without affectation should not modify self.
"""
self.easy.prune('z')
a_copy = self.easy.copy()
2.0 / self.easy
self.assertEqual(
self.easy,
a_copy
)
def test_union_func_not_ok(self):
a_lot_of_type= convert_tree(
dict(
a="lkjlkjl",
b=dict(
e=set([1 , 2 , 3]),
f=lambda _, y: 2 * y,
),
p=dict(a="saint")
)
)
another_lot = convert_tree(
dict(a="lkjlkjl",
b=dict(
e=set([1 , 2 , 3]),
f=lambda _, y: 2 * y,
g=dict(),
),
pp=dict(a="serre")
),
)
cl = Exception('CollisionError', '')
self.assertRaises(
Exception,
a_lot_of_type.union, another_lot
)
def test_union_ok(self):
a_lot_of_type= convert_tree(
dict(
a="lkjlkjl",
b=dict(
e=set([1 , 2 , 3]),
f=123.123123123,
),
p=dict(a="saint")
)
)
another_lot = convert_tree(
dict(a="lkjlkjl",
b=dict(
h="f**k",
i=dict(a=1),
e=set([1 , 2 , 3, 5]),
f=123.123123123,
g=dict(),
),
pp=dict(a="serre")
),
)
un = a_lot_of_type.union(another_lot)
expected = convert_tree({
'a': 'lkjlkjl',
'p': {'a': 'saint'},
'pp': {'a': 'serre'},
'b': {
'i': {'a': 1},
'e': set([1, 2, 3, 5]),
'g': {},
'f': 123.123123123,
},
})
self.assertEqual(
un,
expected
)
def test_bug_convert_empty_mapping(self):
"""bug #8 : empty mapping intialisation dont work"""
bug = convert_tree(dict(a={}))
expected = VectorDict(None, {'a': {}})
self.assertEqual(
expected,
bug
)
def test_bug_boolean_not_commutative(self):
"""bug #11: a xor b != ! ( a xand b )"""
a = VectorDict(bool,
dict(tt=True, tf=True, ft=False, ff=False, not_in_b=False)
)
b = VectorDict(bool,
dict(tt=True, tf=False, ft=True, ff=False, not_in_a=True)
)
self.assertEqual(
(a & b.__not__()) | (a.__not__() & b),
((a | b.__not__()) & (a.__not__() | b)).__not__()
)
def test_for_fun(self):
"""just for fun """
a = self.easy
b = self.easy_too
aa = a.copy()
bb = b.copy()
self.assertEqual(
(a - b) * (a + b),
aa * aa - bb * bb
)
def test_for_fun2(self):
"""just for fun """
a = self.easy
b = self.easy_too
aa = a.copy()
bb = b.copy()
self.assertEqual(
-(a + b) * (a + b),
-1 * ((aa * aa) + 2 * aa * bb + (bb * bb))
)
