def testRecursiveAttach_03_recursive_with_linked_nodes(self):
p = TreeDict()
p.a = p.adef.a
p.adef.a.v = 1
p.attach(recursive=True)
def testhashes_15_attaching(self):
p1 = TreeDict('root')
p1.b1 = TreeDict('b1')
h = p1.hash()
p1.attach(copy = False, recursive = True)
self.assert_(p1.hash() != h)
def testAttaching_12_propegatingFrozenFlags(self):
p1 = TreeDict()
p1.a.b = TreeDict()
p1.freeze(values_only = True)
p1.attach('c', TreeDict() )
self.assert_(p1.c.valuesAreFrozen())
def testAttaching_01(self):
p1 = TreeDict('root')
p2 = TreeDict('node')
p2.a = 123
p1.attach(p2)
self.assert_(p1.node.a == 123)
self.assert_(p1.node.rootNode() is p1)
self.assert_(p2.rootNode() is p2)
def testAttaching_03(self):
p1 = TreeDict('root')
p2 = TreeDict('node')
p2.a = 123
p1.attach('attachnode', p2)
self.assert_(p1.attachnode.a == 123)
self.assert_(p1.attachnode.rootNode() is p1)
self.assert_(p1.attachnode == p2)
self.assert_(p1.attachnode.branchName(True,True) == "root.attachnode")
self.assert_(p2.rootNode() is p2)
def testAttaching_09_frozen_2(self):
p = TreeDict('p')
p.b.c = 1
p.freeze()
p2 = TreeDict()
p2.attach(p, copy=True)
self.assert_(p2.p.b.c == 1)
self.assert_(not p2.p.isFrozen())
self.assert_(not p2.p.b.isFrozen())
self.assert_(not p2.isFrozen())
def testAttaching_11_equalityTesting_01(self):
p1 = TreeDict('root')
p1.b1 = TreeDict('new_branch')
p1.b1.b2 = TreeDict('new_branch')
p1.b1.b2.b3 = TreeDict('new_branch')
p2 = p1.copy()
self.assert_(p2 == p1)
p1.attach(copy=False, recursive=True)
self.assert_(p2 != p1)
def testRecursiveAttach_05_ValueFrozen(self):
# Disable; not sure it's best anyway
return
p1 = TreeDict('root')
p1.b1 = TreeDict('new_branch')
p1.freeze(values_only = True)
self.assert_(p1.b1.isRoot())
self.assert_(p1.b1.branchName(True,True) == 'new_branch')
p1.attach(copy=True, recursive=True)
self.assert_(p1.b1.rootNode() is p1)
self.assert_(p1.b1.branchName(True,True) == 'root.b1')
def testBranchStructureFrozen_01(self):
p = TreeDict()
p.a = TreeDict(x = 1)
p.freeze(structure_only = True)
self.assertRaises(TypeError, lambda: p.attach(recursive = True))
def testAttaching_10_Atomic_01_noImplicitOverwrite(self):
p = TreeDict()
p.a.b = 1
self.assertRaises(TypeError, lambda: p.attach("a.b.c.d", TreeDict(x = 1),
protect_structure=True))
self.assert_(p.a.b == 1)
def testRecursiveAttach_04_error_on_frozen(self):
p = TreeDict()
p.b = TreeDict(x = 1)
p.freeze()
self.assertRaises(TypeError, lambda: p.attach(recursive = True))
self.assert_(p.b.isRoot())
self.assert_(p.b not in p.branches())
self.assert_(p.size() == 1)
def testRecursiveAttach_01(self):
p1 = TreeDict('root')
p1.b1 = TreeDict('new_branch')
p1.b1.b2 = TreeDict('new_branch')
p1.b1.b2.b3 = TreeDict('new_branch')
self.assert_(p1.b1.isRoot())
self.assert_(p1.b1.b2.isRoot())
self.assert_(p1.b1.b2.b3.isRoot())
self.assert_(p1.b1.branchName(True,True) == 'new_branch')
self.assert_(p1.b1.b2.branchName(True,True) == 'new_branch')
self.assert_(p1.b1.b2.b3.branchName(True,True) == 'new_branch')
p1.attach(copy=True, recursive=True)
self.assert_(p1.b1.rootNode() is p1)
self.assert_(p1.b1.b2.rootNode() is p1)
self.assert_(p1.b1.b2.b3.rootNode() is p1)
self.assert_(p1.b1.branchName(True,True) == 'root.b1')
self.assert_(p1.b1.b2.branchName(True,True) == 'root.b1.b2')
self.assert_(p1.b1.b2.b3.branchName(True,True) == 'root.b1.b2.b3')
def testAttaching_10_Atomic_02_noImplicitOverwrite(self):
p = TreeDict()
p.makeBranch('a')
p.freeze()
self.assert_('a' in p.keys(branch_mode = 'only', recursive=False))
self.assertRaises(TypeError, lambda: p.attach("a.b.c.d", TreeDict(x = 1),
protect_structure=True))
self.assert_('a' in p.keys(branch_mode = 'only', recursive=False))
self.assert_(p.a.size() == 0)
def testAttaching_11_BadParameters_04(self):
p = TreeDict()
self.assertRaises(TypeError, lambda: p.attach(copy = False))
# for set
from treedict import TreeDict
t = TreeDict()
t.set("x", 1)
print t.makeReport()
t.set("a", 3, "b", 4, "1badvalue", 5)
print t.makeReport()
# For attach
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1')
t.attach(t1, copy=True)
t1.rootNode()
t.t1 is t1
t.t1.rootNode()
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1')
t.attach(t1, name="new_t1", copy=False)
t1.rootNode()
t.new_t1 is t1
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1', x1=1, y1=2)
t2 = TreeDict('t2', x2=10, y2=20)
def testAttaching_11_BadParameters_02(self):
p = TreeDict()
self.assertRaises(TypeError, lambda: p.attach(TreeDict(), TreeDict()))
# for set
from treedict import TreeDict
t = TreeDict()
t.set("x", 1)
print t.makeReport()
t.set("a", 3, "b", 4, "1badvalue", 5)
print t.makeReport()
# For attach
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1')
t.attach(t1, copy = True)
t1.rootNode()
t.t1 is t1
t.t1.rootNode()
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1')
t.attach(t1, name = "new_t1", copy = False)
t1.rootNode()
t.new_t1 is t1
from treedict import TreeDict
t = TreeDict('root')
t1 = TreeDict('t1', x1 = 1, y1 = 2)
t2 = TreeDict('t2', x2 = 10, y2 = 20)
def _check_RTE(self, keys, recursive, branch_mode, mode):
p = TreeDict()
for k in keys:
p[k] = 1
# Get a list of what will occur next
key_list = p.keys(recursive, branch_mode)
def test_it(action, isokay = False):
for ret_mode in ["keys", "items"]:
def f():
n = p.size(recursive, branch_mode)
if ret_mode == "keys":
kiter = p.iterkeys(recursive, branch_mode)
for i, t in enumerate(kiter):
action(i, n, t)
if ret_mode == "items":
iiter = p.iteritems(recursive, branch_mode)
for i, (t,v) in enumerate(iiter):
action(i, n, t)
if isokay:
f()
else:
if p.size(recursive, branch_mode) != 0:
self.assertRaises(RuntimeError, f)
if mode == "delete_all":
def action(i,n,t):
del p[t]
test_it(action)
if mode == "delete_last":
def action(i,n,t):
if i == n-1:
del p[t]
test_it(action, True)
if mode == "insert_each":
def action(i,n,t):
tn = unique_name()
p[tn] = 1
test_it(action)
if mode == "insert_last":
def action(i,n,t):
if i == n-1:
tn = unique_name()
p[tn] = 1
test_it(action, True)
if mode == "insert_middle":
def action(i,n,t):
if i >= n // 2:
tn = unique_name()
p[tn] = 1
test_it(action)
if mode == "attach_branch":
np = TreeDict(unique_name())
np.a.b.c = 1
def action(i,n,t):
if i == n//2:
p.attach(np)
test_it(action)
if mode == "attach_recursive":
np = TreeDict(unique_name())
np.a.b.c = 1
p.attach(np)
def action(i,n,t):
if i == n//2:
p.attach(recursive=True)
test_it(action)
if mode == "pop":
def action(i,n,t):
if i == n//2:
p.pop(key_list[i+1])
test_it(action)
if mode == "clear":
def action(i,n,t):
if i == n//2:
p.clear()
test_it(action)
if mode == "freeze":
# should not raise error
def action(i,n,t):
if i == n//2:
p.freeze()
test_it(action, True)
if mode == "copy":
# should not raise error
def action(i,n,t):
if i == n//2:
pn = p.copy()
test_it(action, True)
if mode == "branch":
def action(i,n,t):
if i == n//2:
b = p.makeBranch(unique_name())
test_it(action)
if mode == "size_called":
# should not raise error
def action(i,n,t):
if i == n//2:
s = p.size()
test_it(action, True)
if mode == "nested_iter":
# should not raise error
def action(i,n,t):
if i == n//2:
for k in p.iterkeys():
for v in p.itervalues():
pass
test_it(action, True)
# Now verify all are okay
#print "p._iteratorRefCount() =", p._iteratorRefCount()
p.asdfasdfafds = None
if mode == "nested_iter_bad":
# should not raise error
def action(i,n,t):
if i == n//2:
for k in p.iterkeys():
for v in p.itervalues():
pass
del p[key_list[i+1]] # Make sure the flag is not turned off
test_it(action)
# Now verify all are okay
#print "p._iteratorRefCount() =", p._iteratorRefCount()
p.asdfasdfafds = None
if mode == "nested_iter_bad_later":
# should not raise error
def action(i,n,t):
if i == 0:
for k in p.iterkeys():
for v in p.itervalues():
pass
else:
del p[t] # Make sure the flag is not turned off
test_it(action)
if mode == "nested_list":
# should not raise error
def action(i,n,t):
if i == n//2:
p.keys()
test_it(action, True)
if mode == "nested_list_bad":
def action(i,n,t):
assert key_list[i] == t
if i == n//2:
k = p.keys()
del p[key_list[i+1]] # Make sure the flag is not turned off
test_it(action)
if mode == "nested_list_bad_later":
def action(i,n,t):
if i == 0:
k = p.keys()
else:
del p[t] # Make sure the flag is not turned off
test_it(action)
if mode == "action_on_subbranches_okay":
tn = unique_name()
p[tn +'.a'] = 1
p[tn +'.b'] = 1
p[tn +'.c'] = 1
has_seen_tn = [False]
def action(i,n,t):
if i == 0:
has_seen_tn[0] = False
if t.startswith(tn):
has_seen_tn[0] = True
if (not t.startswith(tn)) and has_seen_tn[0]:
p[tn].pop('a')
p[tn].a = 1
test_it(action, True)
if mode == "action_on_subbranches_okay_control":
tn = unique_name()
p[tn +'.a'] = 1
p[tn +'.b'] = 1
p[tn +'.c'] = 1
def action(i,n,t):
if t.startswith(tn):
p[tn].pop('a')
p[tn].a = 1
test_it(action)
def testAttaching_12_defaultName_RecursiveAttach(self):
p1 = TreeDict()
p1.p2 = TreeDict()
p1.attach(recursive = True)
