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"
