def test_insert(constructor_arg): max_index = len(constructor_arg) if constructor_arg else 0 idx = random.randint(0, max_index) # Test a valid index ll = LinkedList(constructor_arg) ll.insert(idx, 'test') assert ll._get(idx) == LinkedListNode('test') # Test some invalid cases if max_index: ll = LinkedList(constructor_arg) with pytest.raises(IndexError): ll.insert(2 * max_index, 'test') ll = LinkedList(constructor_arg) with pytest.raises(IndexError): ll.insert(-max_index, 'test') ll = LinkedList(constructor_arg) with pytest.raises(IndexError): ll.insert('Um, an index', 'test') ll = LinkedList(constructor_arg) with pytest.raises(IndexError): ll.insert(None, 'test')
def test_kth_from_end_under_range(): linked_list = LinkedList() values = ["apples", "bananas", "cucumbers"] for value in reversed(values): linked_list.insert(value) with pytest.raises(TargetError): linked_list.kth_from_end(-1)
def test_insert_non_empty_list_index_valid_repeating(self): linked_list = LinkedList() linked_list.insert(data='sample data', index=0) linked_list.insert(data='new sample data', index=0) self.assertEqual(len(linked_list), 2) self.assertNotEqual(linked_list.head, None) self.assertNotEqual(linked_list.tail, None)
def test_insert_after_missing(): linked_list = LinkedList() linked_list.insert("banana") with pytest.raises(TargetError): linked_list.insert_after("radish", "zucchinni")
def test_kth_from_end_zero(): linked_list = LinkedList() values = ["apples", "bananas", "cucumbers"] for value in reversed(values): linked_list.insert(value) actual = linked_list.kth_from_end(0) expected = "cucumbers" assert actual == expected
def test_includes_true(): linked_list = LinkedList() linked_list.insert("apple") linked_list.insert("banana") assert linked_list.includes("apple")
def test_pop_from_one_list(self): """Pop from a LinkedList with one node.""" ll = LinkedList() ll.insert(self.insert_string) self.assertEqual(ll.head.value, self.insert_string) node = ll.pop() self.assertEqual(node.value, self.insert_string) self.assertTrue(ll.head is None)
def test_insert_before_first(): linked_list = LinkedList() linked_list.insert("apple") linked_list.insert_before("apple", "cucumber") assert str(linked_list) == "{ cucumber } -> { apple } -> NULL"
def test_includes_false(): linked_list = LinkedList() linked_list.insert("apple") linked_list.insert("banana") assert not linked_list.includes("cucumber")
def test_insert_float_into_empty(self): """Insert into a LinkedList that is empty.""" ll = LinkedList() self.assertTrue(ll.head is None) ll.insert(self.insert_float) self.assertEqual(ll.head.value, self.insert_float) self.assertTrue(isinstance(ll.head.value, float)) self.assertTrue(ll.head.next is None)
def test_append(): linked_list = LinkedList() linked_list.insert("apple") linked_list.insert("banana") linked_list.append("cucumber") assert str(linked_list) == "{ banana } -> { apple } -> { cucumber } -> NULL"
def test_to_string_double(): linked_list = LinkedList() linked_list.insert("apple") assert str(linked_list) == "{ apple } -> NULL" linked_list.insert("banana") assert str(linked_list) == "{ banana } -> { apple } -> NULL"
def test_b_empty(): list_a = LinkedList() for value in reversed([1, 2, 3]): list_a.insert(value) list_b = LinkedList() actual = zip_lists(list_a, list_b) expected = LinkedList() for value in reversed([1, 2, 3]): expected.insert(value) assert str(actual) == str(expected)
def test_a_empty(): list_a = LinkedList() list_b = LinkedList() for value in reversed(["a", "b", "c"]): list_b.insert(value) actual = zip_lists(list_a, list_b) expected = LinkedList() for value in reversed(["a", "b", "c"]): expected.insert(value) assert str(actual) == str(expected)
def test_removing_head(): ll = LinkedList() ll.insert(1) ll.insert(2) ll.insert(3) ll.remove(1) assert len(ll) == 2 assert ll.head.value == 2 assert ll.head.next.value == 3 assert not ll.head.next.next assert not ll.find(1)
def test_removing_tail(): ll = LinkedList() ll.insert(1) ll.insert(2) ll.insert(3) ll.remove(3) assert len(ll) == 2 assert ll.tail.value == 2 assert not ll.tail.next assert not ll.head.next.next assert not ll.find(3)
def test_insert(self): lst = LinkedList([82, 57, 16, 20, 21, 84, 99, 56, 100, 46]) inserted = lst.insert(7, 555) self.assertTrue(inserted) inserted = lst.insert(2, 86) self.assertTrue(inserted) inserted = lst.insert(200, 86) self.assertFalse(inserted) self.assertEqual(list(lst), [82, 57, 86, 16, 20, 21, 84, 99, 555, 56, 100, 46])
class Stack(object): def __init__(self): self.linked_list = LinkedList() def push(self, value): self.linked_list.insert(0, value) def pop(self): head = self.linked_list._head.value self.linked_list.remove(0) return head def print(self): self.linked_list.print()
def test_works(): ll = LinkedList() elements = [random.randrange(-1000000, 1000000) for _ in range(1000)] for elem in elements: ll.insert(elem) assert len(elements) == len(ll) while elements: elem_to_delete = elements.pop() assert bool(ll.find(elem_to_delete)) ll.remove(elem_to_delete) assert len(elements) == len(ll) assert not elements assert ll.empty()
def test_insert_float_into_populated(self): """Insert into a LinkedList that is already populated with some values """ ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) self.assertEqual(ll.head.value, self.insert_string) ll.insert(self.insert_float) self.assertEqual(ll.head.value, self.insert_float) self.assertTrue(isinstance(ll.head.value, float)) self.assertEqual(ll.head.next.value, self.insert_string)
def test_creation(self): """Calling prepend, append and insert(0, data) on empty linked list.""" ll = LinkedList() self.assertEqual([], ll.to_list()), 'Linked List should be empty.' self.assertEqual(0, ll.size), 'Empty list should have size 0' # prepend ll.prepend(1) self.assertEqual([1], ll.to_list()), 'LL should have exactly one element.' self.assertEqual(1, ll.size), 'Should be size 1.' # append ll = LinkedList() ll.append(1) self.assertEqual([1], ll.to_list()), 'LL should have exactly one element.' self.assertEqual(1, ll.size), 'Should be size 1.' ll = LinkedList() # insert at zero ll.insert(1, 0) self.assertEqual([1], ll.to_list()), 'LL should have exactly one element.' self.assertEqual(1, ll.size), 'Should be size 1.'
def test_size_of_populated_list(self): """Get the size of a populated LinkedList.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) self.assertEqual(ll.head.value, self.insert_string) self.assertEqual(ll.size(), 3)
def test_search_list_without_value(self): """Search a populated LinkedList for a value it doesn't contain.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) node = ll.search(self.value_not_in_list) self.assertTrue(node is None)
def test_search_list_with_value_at_tail(self): """Search a populated LinkedList for a value it contains at its tail.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) node = ll.search(self.insert_float) self.assertTrue(isinstance(node, LinkedListNode)) self.assertEqual(node.value, self.insert_float)
def test_str_many_list(self): """Get the string representation of a LinkedList with many values.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) self.assertEqual(ll.__str__(), '(' + "'" + self.insert_string + "', " + str(self.insert_int) + ', ' + str(self.insert_float) + ')')
def test_pop_from_many_list(self): """Pop from a LinkedList with many nodes.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) self.assertEqual(ll.head.value, self.insert_string) node = ll.pop() self.assertEqual(node.value, self.insert_string) self.assertEqual(ll.head.value, self.insert_int)
def test_remove_list_without_value(self): """Remove from a populated LinkedList a value it doesn't contain.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) prestring = ll.__str__() ll.remove(self.value_not_in_list) poststring = ll.__str__() self.assertEqual(prestring, poststring)
def test_remove_list_with_value_at_tail(self): """Remove from a populated LinkedList a value it contains at its tail.""" ll = LinkedList() ll.insert(self.insert_float) ll.insert(self.insert_int) ll.insert(self.insert_string) ll.remove(self.insert_float) expected = '(' + "'" + self.insert_string + "'" + ', ' + \ str(self.insert_int) + ')' poststring = ll.__str__() self.assertEqual(expected, poststring)
class LinkedListTest(unittest.TestCase): def setUp(self): self.linked_list = LinkedList() def test_insert(self): self.linked_list.insert('test') self.assertEquals(self.linked_list.head.get_data(), 'test') def test_size(self): self.linked_list.insert('test') self.assertEquals(self.linked_list.size(), 1) def test_search(self): self.linked_list.insert('test') node = self.linked_list.search('test') self.assertEquals(node.get_data(), 'test') def test_delete(self): self.linked_list.insert('test') self.linked_list.delete('test') self.assertEquals(self.linked_list.size(), 0)
def test_b_shorter(): list_a = LinkedList() for value in reversed([1, 2, 3]): list_a.insert(value) list_b = LinkedList() for value in reversed(["a", "b"]): list_b.insert(value) actual = zip_lists(list_a, list_b) expected = LinkedList() for value in reversed([1, "a", 2, "b", 3]): expected.insert(value) assert str(actual) == str(expected)
def test_insert(self): linked_list = LinkedList() linked_list.insert(data='sample data', index=0) self.assertEqual(len(linked_list), 1) self.assertNotEqual(linked_list.head, None) self.assertNotEqual(linked_list.tail, None) linked_list = LinkedList() linked_list.insert(data=0, index=0) linked_list.insert(data=1, index=1) linked_list.insert(data=2, index=2) linked_list.insert(data=3, index=3) self.assertEqual(linked_list.length(), 4) self.assertEqual(linked_list.head.data, 0) self.assertEqual(linked_list.tail.data, 3) self.assertEqual(linked_list.head.next.data, 1) self.assertEqual(linked_list.tail.previous.data, 2) self.assertEqual(linked_list.head.next.next.data, 2) self.assertEqual(linked_list.tail.previous.previous.data, 1) self.assertEqual(linked_list.head.next.next.next.data, 3) self.assertEqual(linked_list.tail.previous.previous.previous.data, 0)
def test_kth_from_end_size_one(): linked_list = LinkedList() linked_list.insert("apples") actual = linked_list.kth_from_end(0) expected = "apples" assert actual == expected
def test_insert_empty_list_index_invalid(self): linked_list = LinkedList() with self.assertRaises(IndexError) as error: linked_list.insert(data='sample data', index=1)
def test_length_non_zero(self): linked_list = LinkedList() linked_list.insert(data='sample data', index=0) self.assertEqual(linked_list.length(), 1)
class TestLinky(unittest.TestCase): def setUp(self): self.linky = LinkedList() l = [1, 2, 3, 4] for i in l: self.linky.insert(i) def test_insert_to_empty(self): self.linky = LinkedList() self.linky.insert(1) self.assertEqual(1, self.linky.head.val) def test_insert_to_non_empty(self): self.linky.insert(5) self.assertEqual(5, self.linky.head.val) def test_pop_empty(self): self.linky = LinkedList() self.assertEqual(None, self.linky.pop()) def test_pop_non_empty(self): self.assertEqual(4, self.linky.pop()) def test_size_greater_than_one(self): self.assertEqual(4, self.linky.size()) def test_size_of_one(self): self.linky = LinkedList() self.linky.insert(1) self.assertEqual(1, self.linky.size()) def test_size_of_zero(self): self.linky = LinkedList() self.assertEqual(0, self.linky.size()) def test_search_exists(self): self.assertEqual(True, self.linky.search(3)) def test_search_not_exists(self): self.assertEqual(False, self.linky.search(5)) def test_remove_head(self): self.linky.remove(4) self.assertListEqual([3, 2, 1], self.linky.print_me()) def test_remove_middle(self): self.linky.remove(2) self.assertListEqual([4, 3, 1], self.linky.print_me()) def test_print_me(self): self.linky = LinkedList() self.assertListEqual([], self.linky.print_me()) def test_return_0th_from_4th(self): self.assertEqual(1, self.linky.return_kth_from_nth(0, 4)) def test_return_1st_from_4th(self): self.assertEqual(2, self.linky.return_kth_from_nth(1, 4)) def test_return_0th_from_2nd(self): self.assertEqual(3, self.linky.return_kth_from_nth(0, 2)) def test_return_1st_from_2nd(self): self.assertEqual(4, self.linky.return_kth_from_nth(1, 2)) def test_partition_around_x(self): self.linky = LinkedList() l = [1, 2, 3, 4, 5, 6, 7, 5, 8, 9, 10] for i in range(len(l)): self.linky.insert(l[i]) self.linky.partition_around_x(5) self.assertListEqual([1, 2, 3, 4, 5, 5, 10, 9, 8, 7, 6], self.linky.print_me()) def test_rem_dups(self): self.linky = LinkedList() self.linky.insert(1) self.linky.insert(1) self.linky.insert(2) self.linky.insert(2) self.linky.insert(3) self.linky.insert(3) self.linky.rem_dups() self.assertListEqual([3, 2, 1], self.linky.print_me())
def test_insert(): a_list = LinkedList() a_list.insert(1) assert list(a_list) == [1] assert a_list.size() == 1
class LinkedListTest(unittest.TestCase): def setUp(self): self.LinkedList = LinkedList() self.values = [-3.0, 'new', [], {'test': 1}] def filledList(self, value): self.LinkedList.insert(12) self.LinkedList.insert('same') self.LinkedList.insert(37) self.LinkedList.insert('tango') self.LinkedList.insert(value) return self.LinkedList.head.value def filledListWithList(self, values): for val in values: self.LinkedList.insert(val) return self.LinkedList def test_empty_list_insert(self): self.assertEqual( self.LinkedList.head, None, "Head: %s" % str(self.LinkedList.head)) def test_filled_list_insert(self): #Test floats, strings, lists, and dictionaries for values in self.values: self.assertEqual( self.filledList(values), self.LinkedList.head.value) def test_empty_list_pop(self): with self.assertRaises(IndexError): self.LinkedList.pop() def test_filled_list_pop(self): self.filledListWithList(self.values) for num in range(-len(self.values)): self.assertEqual(self.LinkedList.pop(), self.values[num]) def test_empty_list_size(self): self.assertEqual(self.LinkedList.size(), 0) def test_filled_list_size(self): for num in range(len(self.values)): self.LinkedList.insert(self.values[num]) self.assertEqual(self.LinkedList.size(), num + 1) def test_empty_list_search(self): for val in self.values: self.assertEqual(self.LinkedList.search(val), None) def test_filled_list_search(self): self.filledListWithList(self.values) for val in self.values: self.assertEqual(self.LinkedList.search(val).value, val) def test_empty_list_remove(self): for val in self.values: self.assertEqual(self.LinkedList.search(val), None) def test_filled_list_remove(self): self.filledListWithList(self.values) for val in self.values: self.assertEqual(self.LinkedList.search(val).value, val)
def test_str_one_list(self): """Get the string representation of a LinkedList with one value.""" ll = LinkedList() ll.insert(self.insert_float) self.assertEqual(ll.__str__(), '(' + str(self.insert_float) + ')')
def test_to_string_single(): linked_list = LinkedList() linked_list.insert("apple") assert str(linked_list) == "{ apple } -> NULL"
def test_populated_head(): linked = LinkedList() linked.insert("apple") assert linked.head.value == "apple"