def test_insert_node_with_invalid_ref(self):
ll = dllist()
self.assertRaises(TypeError, ll.insertnode, dllistnode(10), 1)
self.assertRaises(TypeError, ll.insertnode, dllistnode(10), 'abc')
self.assertRaises(TypeError, ll.insertnode, dllistnode(10), [])
self.assertRaises(ValueError, ll.insertnode, dllistnode(10),
dllistnode())
def test_insertnodeafter_with_invalid_type_of_ref_node(self):
ll = dllist([0])
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
None)
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
'not a dllist node')
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
sllistnode(1234))
def test_insertnodeafter_returns_inserted_node(self):
ll = dllist([0])
inserted_value = 'inserted value'
inserted_node = dllistnode(inserted_value)
returned_node = ll.insertnodeafter(inserted_node, ll.first)
self.assertIs(returned_node, inserted_node)
self.assertIs(returned_node.value, inserted_value)
def test_insertafter_with_invalid_ref_node(self):
ll = dllist()
other_list = dllist(['node in other list'])
self.assertRaises(TypeError, ll.insertafter, 1234, None)
self.assertRaises(TypeError, ll.insertafter, 1234, 'not a dllist node')
self.assertRaises(ValueError, ll.insertafter, 1234, dllistnode())
self.assertRaises(ValueError, ll.insertafter, 1234, other_list.first)
def delete(dllist, value):
if len(dllist) > 0 and isinstance(find(dllist, value), Point):
node = linked_list.dllistnode(value)
node_find = contains(dllist, node)
dllist.remove(node_find)
else:
raise ValueError("Element not found!")
def test_insertnodeafter_adds_node_in_correct_position(self):
ll = dllist([0, 1, 2, 3, 4])
inserted_node = dllistnode(1234)
ref_node = ll.nodeat(2)
ll.insertnodeafter(inserted_node, ref_node)
self.assertIs(ll.nodeat(3), inserted_node)
self.assertIs(ll.nodeat(3).value, inserted_node.value)
self.assertEqual(ll, dllist([0, 1, 2, 1234, 3, 4]))
def test_cyclic_list_destruction_does_not_release_extra_None_refs(self):
original_ref_count = sys.getrefcount(None)
for _ in range(original_ref_count * 10):
ll = dllist()
ll.append(dllistnode(ll))
del ll
self.assertGreater(sys.getrefcount(None), 0)
def test_node_readonly_attributes(self):
if sys.hexversion >= 0x03000000:
expected_error = AttributeError
else:
expected_error = TypeError
ll = dllistnode()
self.assertRaises(expected_error, setattr, ll, 'prev', None)
self.assertRaises(expected_error, setattr, ll, 'next', None)
def test_insertnodeafter_correctly_links_items(self):
ll = dllist([0, 1, 2, 3])
prev_node = ll.nodeat(1)
next_node = ll.nodeat(2)
inserted_node = dllistnode(1234)
ll.insertnodeafter(inserted_node, prev_node)
self.assertIs(inserted_node.prev, prev_node)
self.assertIs(prev_node.next, inserted_node)
self.assertIs(inserted_node.next, next_node)
self.assertIs(next_node.prev, inserted_node)
def test_insertafter_extracts_value_from_inserted_node(self):
ll = dllist([0])
free_node = dllistnode('free node')
other_list = dllist(['node in other list'])
new_node = ll.insertafter(free_node, ll.first)
self.assertIsNot(new_node, free_node)
self.assertIs(new_node.value, free_node.value)
new_node = ll.insertafter(other_list.first, ll.first)
self.assertIsNot(new_node, other_list.first)
self.assertIs(new_node.value, other_list.first.value)
def test_appendleft(self):
ll = dllist(py23_xrange(4))
ref = dllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = dllistnode(10)
new_node = ll.appendleft(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, None)
self.assertEqual(new_node.next, next)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll.first, new_node)
self.assertEqual(ll, ref)
def test_insert_node_value_before_first(self):
ll = dllist(py23_xrange(4))
ref = dllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = dllistnode(10)
new_node = ll.insertnode(arg_node, ll.nodeat(0))
self.assertEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, None)
self.assertEqual(new_node.next, next)
self.assertEqual(next.prev, new_node)
self.assertEqual(new_node, ll.first)
self.assertEqual(ll, ref)
def test_appendright(self):
ll = dllist(py23_xrange(4))
ref = dllist([0, 1, 2, 3, 10])
prev = ll.nodeat(-1)
arg_node = dllistnode(10)
new_node = ll.appendright(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll.last, new_node)
self.assertEqual(ll, ref)
def test_insert_node_value_before(self):
ll = dllist(py23_xrange(4))
ref = dllist([0, 1, 10, 2, 3])
prev = ll.nodeat(1)
next = ll.nodeat(2)
arg_node = dllistnode(10)
new_node = ll.insertnode(arg_node, ll.nodeat(2))
self.assertEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, next)
self.assertEqual(prev.next, new_node)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll, ref)
def order_modules(self, action, mod_name_list_arg: List):
mod_name_list = [dllistnode(x) for x in mod_name_list_arg]
# this is dumb... i was trying to save time using a llist library, and it was a travesty. there is no point
# to that library. you have to implement the logic of getting the node before you can do anyting with it
# which isnt' hard but is really annoying to have to discover from the terrible docs.
# should have used ordered dict
if action == 'remove':
for mod_name in mod_name_list:
self.ordered_mods.remove(mod_name)
elif action == 'include':
last_node = mod_name_list.pop()
if last_node.value not in self.ordered_mods:
self.ordered_mods.appendright(last_node)
before_node = self.ordered_mods.last
else:
index = 0
for sob in self.ordered_mods:
if last_node.value == sob:
before_node = self.ordered_mods.nodeat(index)
break
index += 1
for mod_name in mod_name_list:
index = 0
# remove modules from their previous order and place in front of last node
for sob in self.ordered_mods:
if mod_name.value == sob:
node = self.ordered_mods.nodeat(index)
self.ordered_mods.remove(node)
index = 0
continue
index += 1
for mod_name in mod_name_list:
self.ordered_mods.insert(mod_name, before_node)
write_list = [x for x in self.ordered_mods]
modorder_dict = dict()
# to keep mod order consistent in and out of interactive sessions
for m in write_list:
mod = self.modules.get(m)
modorder_dict.update({m: dict(mod.play_order)})
with open(self.name + '/mod_order.yml', 'w+') as f:
yaml.safe_dump({'module_order': modorder_dict},
default_flow_style=False,
sort_keys=False,
stream=f)
def put(self, key, val):
"""
associate the value with the key, and put the entry into cache.
args:
key: the key associated with val
val: the value associating with key
returns:
None.
"""
v = dllistnode(val)
if key in self.__hashmap:
self.__cache.remove(self.__hashmap[key])
if self.__hashmap[key] != v: self.__hashmap[key] = v
elif self.size < self.capacity:
self.__hashmap[key] = v
self.size += 1
else:
self.__hashmap.remove(self.__cache.pop())
self.__cache.appendleft(v)
def qh_helper(points, hull, P, Q):
"""
Recursive helper method to find next point on the hull.
P and Q represent an edge on the current hull.
points is all points in between P and Q with respect to x-coordinate.
This method updates the convex hull and returns.
"""
if not points:
return
max_dist = float('-Inf')
max_dist_point = None
# Find the point that is the farthest distance from the line formed P and Q.
for point in points:
dist = pseudo_distance(P.value, Q.value, point)
if dist > max_dist:
max_dist = dist
max_dist_point = point
# The point that is the farther distance is clearly on the convex hull.
# We add it between P and Q.
C = dllistnode(max_dist_point)
hull.insertnode(C, Q)
# Separate the points into those between P and C and those between C and Q.
# Discard all points below either of these edges since they obviously
# will not be on the hull.
left = []
right = []
for point in points:
if orient(P.value, C.value, point) > 0:
left.append(point)
elif orient(C.value, Q.value, point) > 0:
right.append(point)
# Recursively compute the rest of the hull and return.
qh_helper(left, hull, P, C)
qh_helper(right, hull, C, Q)
return
def test_insertnodeafter_with_unowned_ref_node(self):
ll = dllist([0])
self.assertRaises(ValueError, ll.insertnodeafter, dllistnode(1234),
dllistnode())
def test_appendnode_refcount_update(self):
ll = dllist()
node = ll.appendnode(dllistnode(1234))
self.assertGreaterEqual(sys.getrefcount(node), 3)
def test_appendnode(self):
ll = dllist([1, 2, 3, 4])
node = dllistnode(5)
ll.appendnode(node)
self.assertEqual([1, 2, 3, 4, 5], list(ll))
self.assertIs(node, ll.last)
def test_insertnodebefore_after_first_item_does_not_update_list_head(self):
ll = dllist([0, 1])
original_head = ll.first
inserted_node = dllistnode(1234)
ll.insertnodebefore(inserted_node, ll.last)
self.assertIs(ll.first, original_head)
def test_insertnodeafter_updates_list_length(self):
ll = dllist([0])
self.assertEqual(len(ll), 1)
ll.insertnodeafter(dllistnode(1234), ll.first)
self.assertEqual(len(ll), 2)
def test_insertnodeafter_does_not_update_list_head(self):
ll = dllist([0])
original_head = ll.first
inserted_node = dllistnode(1234)
ll.insertnodeafter(inserted_node, ll.first)
self.assertIs(ll.first, original_head)
def test_insertnodeafter_before_last_item_does_not_update_list_tail(self):
ll = dllist([0, 1])
original_tail = ll.last
inserted_node = dllistnode(1234)
ll.insertnodeafter(inserted_node, ll.first)
self.assertIs(ll.last, original_tail)
def test_insertnodeafter_updates_list_tail_if_inserted_node_becomes_tail(
self):
ll = dllist([0])
inserted_node = dllistnode(1234)
new_node = ll.insertnodeafter(inserted_node, ll.last)
self.assertIs(ll.last, inserted_node)
def test_insertnodeafter_sets_next_in_inserted_node_to_none_if_it_becomes_tail(
self):
ll = dllist([0])
inserted_node = dllistnode(1234)
ll.insertnodeafter(inserted_node, ll.last)
self.assertIs(inserted_node.next, None)
def test_insertnodebefore_does_not_update_list_tail(self):
ll = dllist([0])
original_tail = ll.last
inserted_node = dllistnode(1234)
ll.insertnodebefore(inserted_node, ll.last)
self.assertIs(ll.last, original_tail)
def make_recursive_node_list(self):
ll = dllist()
node = dllistnode()
node.value = node
ll.append(node)
return ll
def test_insertnodeafter_without_ref_node(self):
ll = dllist([0])
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234))
def test_insertnodeafter_with_ref_node_from_different_list(self):
ll = dllist([0])
other_list = dllist(['node in other list'])
self.assertRaises(ValueError, ll.insertnodeafter, dllistnode(1234),
other_list.first)
