class TestUnorderedList(unittest.TestCase):
"initiation of test class."
node_1 = 1
node_2 = 2
node_3 = 3
def setUp(self):
""" Create object for all tests """
self.node_list = UnorderedList()
def tearDown(self):
""" Remove dependencies after test """
self.node_list = None
def test_append(self):
"""
Test that one can add a node to the list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.assertIsInstance(self.node_list.head, Node)
self.assertEqual(self.node_list.head.data, TestUnorderedList.node_3)
def test_set_correct(self):
"""
Test that one can change value of node in list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.set(1, 10)
self.assertEqual(self.node_list.head.next.data, 10)
def test_set_fail(self):
"""
Test that exception raises when changing value for empty list
and when index not exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.set(1, 10)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(IndexErrorException) as _:
self.node_list.set(5, 10)
def test_get_correct(self):
"""
Test that get method returns the correct value of index.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.get(1)
self.assertEqual(self.node_list.get(1), TestUnorderedList.node_2)
def test_get_fail(self):
"""
Test that get method raises exeptions when list empty and index dont exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.get(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(IndexErrorException) as _:
self.node_list.get(4)
def test_index_of_correct(self):
"""
Test that index_of method returns the correct value.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.assertEqual(self.node_list.index_of(1), 2)
def test_index_of_fail(self):
"""
Test that that index_of method raises exeptions,
when list empty and value dont exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.index_of(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(KeyErrorException) as _:
self.node_list.index_of(5)
def test_remove_correct_onenode(self):
"""
Test that remove method returns correct with one node in list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.remove(1)
self.assertEqual(self.node_list.head, None)
self.assertEqual(self.node_list.last, None)
def test_remove_correct_nodelist(self):
"""
Test that remove method returns the correct value in list of nodes.
when removing first, middle and last node. """
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.remove(3)
self.assertEqual(self.node_list.head.data, 2)
self.node_list.append(3)
self.node_list.remove(2)
self.assertEqual(self.node_list.head.next.data, 1)
self.node_list.append(2)
self.node_list.remove(1)
self.assertEqual(self.node_list.last.data, 3)
def test_remove_fail(self):
"""
Test that remove method raises exception when list empty and value
not found."""
with self.assertRaises(EmptyListException) as _:
self.node_list.remove(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(KeyErrorException) as _:
self.node_list.remove(5)
def test_recursive_sort_correct(self):
"""
Test that recursive insertion sort function returns correct.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
n = self.node_list.size()
recursive_insertion_sort(self.node_list, n)
self.assertEqual(self.node_list.print_list(), [1, 2, 3])
def test_recursive_sort_empty(self):
"""
Test that recursive insertion sort function returns correct,
when list empty.
"""
n = self.node_list.size()
self.assertEqual(recursive_insertion_sort(self.node_list, n), None)
def test_recursive_sort_one_element(self):
"""
Test that recursive insertion sort function returns correct,
when list has 1 element.
"""
self.node_list.append(TestUnorderedList.node_1)
n = self.node_list.size()
self.assertEqual(recursive_insertion_sort(self.node_list, n), None)
class Handler:
""" Handler class """
_OPTIONS = {
"1": "append",
"2": "set",
"3": "size",
"4": "get",
"5": "index_of",
"6": "print_list",
"7": "remove",
"q": "quit"
}
def __init__(self):
""" Initialize class """
self.list = UnorderedList()
self.start()
def _get_method(self, method_name):
"""
Uses function getattr() to dynamically get value of an attribute.
"""
return getattr(self, self._OPTIONS[method_name])
def _print_menu(self):
"""
Use docstring from methods to print options for the program.
"""
menu = ""
for key in sorted(self._OPTIONS):
method = self._get_method(key)
docstring = inspect.getdoc(method)
menu += "{choice}: {explanation}\n".format(choice=key,
explanation=docstring)
print(chr(27) + "[2J" + chr(27) + "[;H")
print(menu)
def append(self):
""" Adds a node to the list. """
value = input("\nAdd a value: \n>>> ")
self.list.append(value)
print(f"{value} has been added.")
# print("Head.data: '" + self.list.head.data + "'")
def set(self):
"""Replace value (data) for the node on the index place."""
index = input("\nIndex: ")
value = input("Value: ")
try:
self.list.set(index, value)
print(f"{value} has been changed.")
except ListIndexError as e:
print(f"Error: {e}")
def size(self):
""" Shows the list length. """
print(self.list.size())
def get(self):
"""Get data on the index position."""
index = input("\nEnter index value: ")
try:
print(self.list.get(index))
except ListIndexError as e:
print(f"Error: {e}")
def index_of(self):
"""Get the first index of the data."""
value = input("\nEnter data value: ")
try:
print(self.list.index_of(value))
except ListValueError as e:
print(f"Error: {e}")
def print_list(self):
"""Print all nodes in the list."""
print(self.list.print_list())
def remove(self):
""" Removes the first node from the list. """
value = input("\nEnter data value: ")
try:
self.list.remove(value)
print(f"{value} has been removed.")
except (ListIndexError, ListValueError) as e:
print(f"Error: {e}")
@staticmethod
def quit():
""" Quit the program """
sys.exit()
def start(self):
""" Start method """
while True:
self._print_menu()
choice = input("Enter menu selection:\n-> ")
try:
self._get_method(choice.lower())()
except KeyError:
print("Invalid choice!")
input("\nPress any key to continue ...")
class Handler():
"""initiation of Handler class, containging a infinity while loop,
contaninga meny of all methods in the unorderedlist class"""
def __init__(self):
"init method, creats list class"
self.node_list = UnorderedList()
while True:
self.menu()
choice = input("Välj ett alternativ ")
while not self.try_input(choice):
print(" input måste vara en siffra")
choice = input("Välj ett alternativ ")
choice = int(choice)
if choice == 1:
self.choice_one()
if choice == 2:
self.choice_two()
if choice == 3:
self.choice_three()
if choice == 4:
self.choice_four()
if choice == 5:
self.choice_five()
if choice == 6:
self.choice_six()
if choice == 7:
self.choice_seven()
if choice == 8:
self.choice_eight()
if choice == 9:
self.choice_nine()
if choice == 10:
break
@staticmethod
def menu():
"meny method, gets printed in while loop"
print('1. Lägg till värde')
print('2. tar bort en Nod')
print('3. ändra data för nod')
print('4. storlek på listan')
print('5. Returnerar värde på index')
print('6. Returnerar index av värde')
print('7. skriver ut listans innehåll')
print('8. Sortera lista')
print('9. Sortera lista rekursivt')
print('10. Avsluta')
@staticmethod
def try_input(choice):
"error handler, checks that input for variable 'choice' is int"
try:
int(choice)
return True
except ValueError:
return False
def choice_one(self):
""" method for appending element to list"""
data = input("värde ")
self.node_list.append(data)
def choice_two(self):
""" method for removing element to list"""
data = input("värde ")
try:
self.node_list.remove(data)
except (KeyErrorException, EmptyListException):
print("Error: lista tom eller data existerar ej, försök igen")
def choice_three(self):
""" method for change value of index element """
try:
index = int(input('skriv index på nod du vill byta data på '))
data = input(' skriv data du vill ändra värdet på ')
except ValueError:
print(" value input måste vara siffra ")
return
try:
self.node_list.set(index, data)
except (IndexErrorException, EmptyListException):
print("Error: lista tom eller index existerar ej, försök igen")
def choice_four(self):
""" method for printing out size of list element to list"""
print("size ", self.node_list.size())
def choice_five(self):
""" returning value of input index"""
try:
index = int(input('skriv index på nod du vill returnera värde '))
except ValueError:
print("index måste vara en siffra")
return
try:
print(self.node_list.get(index))
except (IndexErrorException, EmptyListException):
print("Error: lista tom eller data existerar ej, försök igen")
def choice_six(self):
""" returning index of input element"""
value = input(' skriv värde vars index ska returneras ')
try:
print(self.node_list.index_of(value))
except (KeyErrorException, EmptyListException):
print("Error: lista tom eller index existerar ej, försök igen")
def choice_seven(self):
""" method for printing out all elements in list"""
print("lista: ", self.node_list.print_list())
def choice_eight(self):
""" method for sorting list with insertion_sort"""
insertion_sort(self.node_list)
print(self.node_list.print_list())
def choice_nine(self):
""" method for sorting list with recursive_insertion_sort"""
recursive_insertion_sort(self.node_list, self.node_list.size())
print(self.node_list.print_list())
class TestList(unittest.TestCase):
""" Submodule for unittests, derives from unittest.TestCase. """
first_node_value = "one"
second_node_value = "two"
third_node_value = "three"
fourth_node_value = "four"
test_list1 = [5, 3, 4, 1, 2]
test_list2 = ["a", "d", "b", "e", "c"]
test_list3 = ["a", 5, 3, "e", 1, "abc", 10, 6]
test_list1_sorted = [1, 2, 3, 4, 5]
test_list2_sorted = ["a", "b", "c", "d", "e"]
test_list3_sorted = [1, 3, 5, 6, 10, 'a', 'abc', 'e']
def setUp(self):
""" Create object for all tests """
# Arrange
self.list = UnorderedList()
def tearDown(self):
""" Remove dependencies after test """
self.list = None
def test_list_append(self):
"""Test append node."""
self.list.append(TestList.first_node_value)
self.assertIsInstance(self.list.head, Node)
self.list.append(TestList.second_node_value)
self.assertIsInstance(self.list.tail, Node)
self.assertEqual(
self.list.head.data,
TestList.first_node_value,
msg='Head.data: {0}'.format(self.list.head.data)
)
self.assertEqual(self.list.tail.data, TestList.second_node_value)
self.assertIs(self.list.head.next, self.list.tail)
def test_list_set_valid(self):
"""Test set node with valid index."""
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
self.list[0] = TestList.fourth_node_value
self.assertEqual(
self.list.head.data,
TestList.fourth_node_value,
msg='Head.data: {0}'.format(self.list.head.data)
)
# self.assertEqual(self.list.tail.data, TestList.second_node_value)
def test_list_set_invalid(self):
"""Test set node with invalid index."""
with self.assertRaises(ListIndexError) as _:
self.list[0] = TestList.first_node_value
self.list.append(TestList.first_node_value)
with self.assertRaises(ListIndexError) as _:
self.list[1] = ""
def test_list_get(self):
"""Test get node."""
with self.assertRaises(ListIndexError) as _:
print(self.list[0])
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
with self.assertRaises(ListIndexError) as _:
print(self.list[3])
self.assertEqual(self.list[2], TestList.third_node_value)
def test_list_index_of(self):
"""Test index_of."""
with self.assertRaises(ListValueError) as _:
self.list.index_of("a")
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
self.assertEqual(self.list.index_of(TestList.third_node_value), 2)
with self.assertRaises(ListValueError) as _:
self.list.index_of("a")
def test_list_remove(self):
"""Test remove element."""
with self.assertRaises(ListIndexError) as _:
self.list.remove("a")
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
# remove middle value and test if shifted to the left
self.list.remove(TestList.second_node_value)
self.assertEqual(self.list.index_of(TestList.third_node_value), 1)
with self.assertRaises(ListValueError) as _:
self.list.remove(TestList.second_node_value)
# test adding again (had problem with it before)
self.list.append(TestList.fourth_node_value)
self.assertEqual(self.list.index_of(TestList.fourth_node_value), 2)
def test_list_insertionsort_all_numeric(self):
"""test_list_insertionsort_all_numeric"""
for node in self.test_list1:
self.list.append(node)
self.list.insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list1_sorted, res_list)
def test_list_insertionsort_all_strings(self):
"""test_list_insertionsort_all_strings"""
for node in self.test_list2:
self.list.append(node)
self.list.insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list2_sorted, res_list)
def test_list_insertionsort_mixed(self):
"""test_list_insertionsort_mixed"""
for node in self.test_list3:
self.list.append(node)
self.list.insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list3_sorted, res_list)
def test_list_recursive_insertionsort_all_numeric(self):
"""test_list_recursive_insertionsort_all_numeric"""
for node in self.test_list1:
self.list.append(node)
self.list.recursive_insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list1_sorted, res_list)
def test_list_recursive_insertionsort_all_strings(self):
"""test_list_recursive_insertionsort_all_strings"""
for node in self.test_list2:
self.list.append(node)
self.list.recursive_insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list2_sorted, res_list)
def test_list_recursive_insertionsort_mixed(self):
"""test_list_recursive_insertionsort_mixed"""
for node in self.test_list3:
self.list.append(node)
self.list.recursive_insertionsort()
res_list = []
for i in range(len(self.list)):
res_list.append(self.list[i])
self.assertEqual(self.test_list3_sorted, res_list)
recursive_insertion_sort(items, n-1)
# tilldelar sista och näst sita elementet temp-variabler
last = items.get(n-1)
j = n-2
while j >= 0 and items.get(j) > last:
value_j = items.get(j)
#value_jplus = items.get(j+1)
items.set(j+1, value_j)
j -= 1
items.set(j+1, last)
return items
if __name__ == "__main__":
lista = UnorderedList()
lista.append(1)
lista.append(2)
lista.append(1)
lista.append(4)
lista.append(5)
print(lista.print_list())
new = (insertion_sort(lista))
print(new.print_list())
class TestList(unittest.TestCase):
""" Submodule for unittests, derives from unittest.TestCase. """
first_node_value = "one"
second_node_value = "two"
third_node_value = "three"
fourth_node_value = "four"
def setUp(self):
""" Create object for all tests """
# Arrange
self.list = UnorderedList()
def tearDown(self):
""" Remove dependencies after test """
self.list = None
def test_list_append(self):
"""Test append node."""
self.list.append(TestList.first_node_value)
self.assertIsInstance(self.list.head, Node)
self.list.append(TestList.second_node_value)
self.assertIsInstance(self.list.tail, Node)
self.assertEqual(self.list.head.data,
TestList.first_node_value,
msg='Head.data: {0}'.format(self.list.head.data))
self.assertEqual(self.list.tail.data, TestList.second_node_value)
self.assertIs(self.list.head.next, self.list.tail)
def test_list_set_valid(self):
"""Test set node with valid index."""
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
self.list[0] = TestList.fourth_node_value
self.assertEqual(self.list.head.data,
TestList.fourth_node_value,
msg='Head.data: {0}'.format(self.list.head.data))
# self.assertEqual(self.list.tail.data, TestList.second_node_value)
def test_list_set_invalid(self):
"""Test set node with invalid index."""
with self.assertRaises(ListIndexError) as _:
self.list[0] = TestList.first_node_value
self.list.append(TestList.first_node_value)
with self.assertRaises(ListIndexError) as _:
self.list[1] = ""
def test_list_get(self):
"""Test get node."""
with self.assertRaises(ListIndexError) as _:
print(self.list[0])
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
with self.assertRaises(ListIndexError) as _:
print(self.list[3])
self.assertEqual(self.list[2], TestList.third_node_value)
def test_list_index_of(self):
"""Test index_of."""
with self.assertRaises(ListValueError) as _:
self.list.index_of("a")
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
self.assertEqual(self.list.index_of(TestList.third_node_value), 2)
with self.assertRaises(ListValueError) as _:
self.list.index_of("a")
def test_list_remove(self):
"""Test index_of."""
with self.assertRaises(ListIndexError) as _:
self.list.remove("a")
self.list.append(TestList.first_node_value)
self.list.append(TestList.second_node_value)
self.list.append(TestList.third_node_value)
# remove middle value and test if shifted to the left
self.list.remove(TestList.second_node_value)
self.assertEqual(self.list.index_of(TestList.third_node_value), 1)
with self.assertRaises(ListValueError) as _:
self.list.remove(TestList.second_node_value)
# test adding again (had problem with it before)
self.list.append(TestList.fourth_node_value)
self.assertEqual(self.list.index_of(TestList.fourth_node_value), 2)
class Handler:
""" Handler class """
_OPTIONS = {
"1": "append",
"2": "set",
"3": "size",
"4": "get",
"5": "index_of",
"6": "print_list",
"7": "remove",
"8": "sort",
"9": "recursive_sort",
"a": "recursive_bubblesort",
"f": "gen_test_list",
"q": "quit"
}
# test_list = [5, 3, 4, 1, 2]
# test_list = ["a", "d", "b", "e", "c"]
test_list = ["a", 5, 3, "e", 1, "abc", 10, 6]
def __init__(self):
""" Initialize class """
self.list = UnorderedList()
self.start()
def _get_method(self, method_name):
"""
Uses function getattr() to dynamically get value of an attribute.
"""
return getattr(self, self._OPTIONS[method_name])
def _print_menu(self):
"""
Use docstring from methods to print options for the program.
"""
menu = ""
for key in sorted(self._OPTIONS):
method = self._get_method(key)
docstring = inspect.getdoc(method)
menu += "{choice}: {explanation}\n".format(choice=key,
explanation=docstring)
print(chr(27) + "[2J" + chr(27) + "[;H")
print(menu)
def append(self):
"""Adds a node to the list."""
value = input("\nAdd a value: \n>>> ")
if value.isnumeric():
value = int(value)
else:
try:
value = float(value)
except ValueError:
pass
self.list.append(value)
print(f"{value} has been added.")
# print("Head.data: '" + self.list.head.data + "'")
def set(self):
"""Replace value (data) for the node on the index place."""
index = input("\nIndex: ")
value = input("Value: ")
try:
self.list.set(index, value)
print(f"{value} has been changed.")
except ListIndexError as e:
print(f"Error: {e}")
def size(self):
""" Shows the list length. """
print(self.list.size())
def get(self):
"""Get data on the index position."""
index = input("\nEnter index value: ")
try:
print(self.list.get(index))
except ListIndexError as e:
print(f"Error: {e}")
def index_of(self):
"""Get the first index of the data."""
value = input("\nEnter data value: ")
try:
print(self.list.index_of(value))
except ListValueError as e:
print(f"Error: {e}")
def print_list(self):
"""Print all nodes in the list."""
print(self.list.print_list())
def remove(self):
""" Removes the first node from the list. """
value = input("\nEnter data value: ")
try:
self.list.remove(value)
print(f"{value} has been removed.")
except (ListIndexError, ListValueError) as e:
print(f"Error: {e}")
def sort(self):
"""Sort list (insert)."""
print("Sorted list: ")
print(self.list.insertionsort())
def recursive_sort(self):
"""Sort list Recursively (insert)."""
print(self.list)
print("Recursively sorted list: ")
print(self.list.recursive_insertionsort())
def recursive_bubblesort(self):
"""Bubblesort list Recursively."""
print(self.list)
print("Recursively bubblesorted list: ")
print(self.list.recursive_bubblesort())
def gen_test_list(self):
"""Generate test list."""
if len(self.list) > 0:
for i in range(len(self.list) - 1, -1, -1):
self.list.remove(self.list[i])
for node in self.test_list:
self.list.append(node)
print("Generated list: ", self.list)
@staticmethod
def quit():
""" Quit the program """
sys.exit()
def start(self):
""" Start method """
while True:
self._print_menu()
choice = input("Enter menu selection:\n-> ")
try:
self._get_method(choice.lower())()
except KeyError:
print("Invalid choice!")
input("\nPress any key to continue ...")
class Handler():
""" Class handling menu etc """
def __init__(self):
self.list = UnorderedList()
self.menu = """Menu:
=======================================
<input> Add value
1 - add: Add number or menu keyword
2 - remove: Remove value
3 - re_index Remove index
4 - len: Length of list
5 - view Show list
6 - search: Value index
7 - empty: List is empty?
8 - help, menu: Show menu
9 - exit, quit: Quit the program
======================================="""
#pylint:disable=too-many-branches
def choice(self, inp):
""" User request """
str(inp.lower())
if inp in ("1", "add"):
app_value = input("Value to append: ")
print("Appended:", self.list.append(app_value))
elif inp in ("2", "remove"):
rem_value = input("Value to remove: ")
num_removed = self.list.remove_value(rem_value)
if num_removed == 0:
print("No such value in list")
else:
print("Removed:", num_removed, "instances.")
elif inp in ("3", "re_index"):
try:
rem_index = int(input("Index to remove:"))
print("Removed: ", self.list.remove_index(rem_index))
except TypeError:
print("Input integer only")
except IndexError:
print("Index not in list")
elif inp in ("4", "len"):
print("List size:", self.list.list_len())
elif inp in ("5", "view"):
try:
print("List:", self.list.print_list())
except ListEmpty:
print("List is empty")
elif inp in ("6", "search"):
val = input("Value to search for: ")
try:
print("Index of", val, ":", self.list.search(val))
except ValErr:
print("Value not in list")
except ListEmpty:
print("List is empty")
elif inp in ("7", "empty"):
print("List empty:", self.list.empty_list())
elif inp in ("8", "menu", "help"):
self.show_menu()
elif inp in ("9", "exit", "quit"):
self.end_queue()
else:
self.list.append(inp)
def show_menu(self):
""" Show the menu """
print(self.menu)
@classmethod
def end_queue(cls):
""" End game in graceful manner """
print("Done!")
sys.exit()