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)