class TestEx(unittest.TestCase): """test exeptions in method in undorderlist.py""" def setUp(self): """setup object to test""" self.ll = UnorderedList() #create a list with max index 3 self.ll.add("ett") self.ll.add("två") self.ll.add("tre") #insert, set, get, index_of och remove. def test_insert(self): """test exceptions in method insert""" #test insert value at index 4 with self.assertRaises(AttError): self.ll.insert("fjärde värdet", 4) def test_set(self): """test exception in method set """ #test replace at index 4. with self.assertRaises(AttError): self.ll.set("new fourth value", 4) def test_get(self): """test exception in method get """ #test get data from index 4 with self.assertRaises(OutOfIndex): self.ll.get(4) def test_index_of(self): """test exception method index_of""" #test with random value with self.assertRaises(NoValue): self.ll.index_of("find me") def test_remove(self): """test exception method remove""" #test with no value with self.assertRaises(NoValue): self.ll.remove("remove me") #add the value self.ll.add("remove me") with self.assertRaises(NoValue): #remove the value. should result in fail in test. self.ll.remove("remove me")
class TestUnorderedList(unittest.TestCase): """ Submodule for unittests, derives from unittest.TestCase """ def setUp(self): """ Create object for all tests """ self.unordered_list = UnorderedList() self.unordered_list.add("Patrik") self.unordered_list.add("Karlsson") def tearDown(self): """ Remove dependencies after test """ self.unordered_list = None def test_insert(self): """ Test method insert """ # List looks like this 0: Patrik 1: Karlsson # Trying to insert new value at index 3 and -1 should raise exception self.assertRaises(IndexErrorException, self.unordered_list.insert, int(3), "test") self.assertRaises(IndexErrorException, self.unordered_list.insert, int(-1), "test") # Trying to insert new value at index 0 should work and not raise # exception self.unordered_list.insert(int(0), "test") # 0: test 1: Patrik 2: Karlsson # Trying to insert new value at index 3 should work and not raise # exception self.unordered_list.insert(int(3), "test2") # 0: test 1: Patrik 2: Karlsson 3: test2 # Check if index 0 == test and index 3 = test2 self.assertEqual(self.unordered_list.get(int(0)), "test") self.assertEqual(self.unordered_list.get(int(3)), "test2") def test_set(self): """ Test method set """ # Trying to replace new value at index 2 or -1 should raise exception self.assertRaises(IndexErrorException, self.unordered_list.set, int(2), "test") self.assertRaises(IndexErrorException, self.unordered_list.set, int(-1), "test") # Replace a valid index value and check so that the value = new value self.unordered_list.set(int(0), "test") self.assertEqual(self.unordered_list.get(0), "test") def test_get(self): """ Test method get """ # Trying to get value at index 2 or -1 should raise exception self.assertRaises(IndexErrorException, self.unordered_list.get, int(2)) self.assertRaises(IndexErrorException, self.unordered_list.get, int(-1)) # Test get value at indec 0 and 1 should return Patrik and Karlsson self.assertEqual(self.unordered_list.get(int(0)), "Patrik") self.assertEqual(self.unordered_list.get(int(1)), "Karlsson") def test_index_of(self): """ Test index_of method """ # Trying to get value at index 2 or -1 should raise exception self.assertRaises(ValueErrorException, self.unordered_list.index_of, "Patrik_test") self.assertRaises(ValueErrorException, self.unordered_list.index_of, "Karlsson_test") # Test get index for Patrik and Karlsson should return 0 and 1 self.assertEqual(self.unordered_list.index_of("Patrik"), 0) self.assertEqual(self.unordered_list.index_of("Karlsson"), 1) def test_remove(self): """ Test remove method """ # Trying to remove a value that doesnt exist should raise exception self.assertRaises(ValueErrorException, self.unordered_list.remove, "test") # Before removing items in list should be 2 self.assertEqual(self.unordered_list.size(), 2) self.unordered_list.remove("Patrik") # After removing items in list should be 1 self.assertEqual(self.unordered_list.size(), 1) # After removing last item in list, the list shall be emtpy self.unordered_list.remove("Karlsson") self.assertEqual(self.unordered_list.is_empty(), True)
class TestSort(unittest.TestCase): """ Submodule for unittests, derives from unittest.TestCase """ def setUp(self): """ Create list """ self.unordered_list = UnorderedList() def tearDown(self): """ Remove dependencies after test """ self.unordered_list = [] def test_list_ordered(self): """ Test Bubble Sort """ self.unordered_list.add(8) self.unordered_list.add(2) self.unordered_list.add(4) # First test so the unordered list is following the pattern # 8 -> 2 -> 4 current_node = self.unordered_list.head self.assertEqual(current_node.data, 8) current_node = current_node.next self.assertEqual(current_node.data, 2) current_node = current_node.next self.assertEqual(current_node.data, 4) # Bubble sort the list order should now be # 2 -> 4 -> 8 bubble_sort(self.unordered_list) current_node = self.unordered_list.head self.assertEqual(current_node.data, 2) current_node = current_node.next self.assertEqual(current_node.data, 4) current_node = current_node.next self.assertEqual(current_node.data, 8) def test_list_ordered_str(self): """ Test Bubble Sort with string values """ self.unordered_list.add("c") self.unordered_list.add("b") self.unordered_list.add("a") # First test so the unordered list is following the pattern # c -> b -> a current_node = self.unordered_list.head self.assertEqual(current_node.data, "c") current_node = current_node.next self.assertEqual(current_node.data, "b") current_node = current_node.next self.assertEqual(current_node.data, "a") # Bubble sort the list order should now be # a -> b -> c bubble_sort(self.unordered_list) current_node = self.unordered_list.head self.assertEqual(current_node.data, "a") current_node = current_node.next self.assertEqual(current_node.data, "b") current_node = current_node.next self.assertEqual(current_node.data, "c")
class Handler(): """handle the linked list""" def __init__(self): """initate object""" self.uol = UnorderedList() # self.uol.add(3) # self.uol.add(1) # self.uol.add(2) # self.uol.add("anna") # self.uol.add("cindy") # self.uol.add("bertil") def handle_is_empty(self): """1 is_empty: Returnera True/False för om listan är tom eller inte.""" print('Is list empty? {}'.format(self.uol.is_empty())) return True def handle_add(self): """ 2 add: Lägg till nytt element/nod sist i listan.""" value = (input('Add: ')) self.uol.add(value) return True def handle_insert(self): """3 insert: Lägg till nytt element/nod på specifikt index. Om index inte finns lyft exception.""" value = (input("New value: ")) try: i = int(input("At index: ")) self.uol.insert(value, i) except (ValueError, WrongType): print("Not an integer, try again!") except AttError: print("No value at that index.") return True def handle_set(self): """4 set: Skriv över element med ny data som finns på index. Om index inte finns lyft exception.""" value = (input("New value: ")) try: i = int(input("At index: ")) self.uol.set(value, i) except (ValueError, WrongType): print("Not an integer, try again!") except AttError: print("No element at that index.") def handle_size(self): """5 size: Returnera antaler element i listan.""" print('Number of elements in list: {}'.\ format(self.uol.size())) def handle_get(self): """6 get: Returnera värde på index. Om index inte finns lyft exception.""" try: i = int(input('Get element at index: ')) element = self.uol.get(i) if element: print('Data at index: {}, is: {}'.\ format(i, element)) except (TypeError, ValueError): print("Not an integer, try again!") except OutOfIndex: print("Out of index.") def handle_index_of(self): """7 index_of: Om data finns i listan returnera dess index. Om nod med data inte finns lyft exception.""" value = str(input("Get index of: ")) value.strip() try: index = self.uol.index_of(value) if index: print('Your word is at index: {}'.\ format(index)) except NoValue: print('Could not find your word {}'.\ format(value)) def handle_print_list(self): """8 print_list: Skriv ut listans innehåll.""" print(self.uol.print_list()) def handle_remove(self): """9 remove: Ta bort nod med samma data. Om nod med data inte finns lyft exception.""" value = input("Remove: ") value.strip() #remove whitespace try: self.uol.remove(value) print('Removed {}'.format(value)) except NoValue: print('Could not remove {}'.\ format(value)) def handle_print_el(self): """print elements""" self.uol.print_el() def handle_insertion_sort(self): """sort with insertion_sort() function""" print(insertion_sort(self.uol)) def handle_bubble_sort(self): """sort with bubble_sort() function""" try: print(bubble_sort(self.uol)) except WrongType: return print("Can't sort string.") except NoValue: return print("There are no elements to sort.") def handle_input(self, choice): """handle user input""" if choice == "1": self.handle_is_empty() elif choice == "2": self.handle_add() elif choice == "3": self.handle_insert() elif choice == "4": self.handle_set() elif choice == "5": self.handle_size() elif choice == "6": self.handle_get() elif choice == "7": self.handle_index_of() elif choice == "8": self.handle_print_list() elif choice == "9": self.handle_remove() elif choice == "10": self.handle_insertion_sort() elif choice == "11": self.handle_bubble_sort() else: print("invalid choice.") def start(self): """eternal loop for menu until user shoose q or keyinterrupt""" while True: print("--------------------------\n" + "1) check if list is empty. Return True/False.\n" + "2) add a new value to the end of the list.\n" + "3) insert new value at a specific index.\n" + "4) replace a value at a specific index.\n" + "5) get number of values in list.\n" + "6) get value at a specific index.\n" + "7) get index of specific value.\n" + "8) print the entire list.\n" + "9) remove node with your value.\n" + "10) sort list using insert_sort.\n" + "11) sort list using bubble.\n" + "q) quit.\n") choice = (input("--> ")) if choice == "q": break elif choice is None: print("please enter your choice") continue elif choice == "p": self.handle_print_el() else: self.handle_input(choice)
class TestUnorderedList(unittest.TestCase): """ Test class for UnorderedList. """ def setUp(self): """ Setup the objects. """ self.ulist = UnorderedList() self.ulist.add("test node") def tearDown(self): """ Remove the objects. """ self.ulist = None def test_insert(self): """ Test insert method. """ # Raise ValueExistentError. self.ulist = UnorderedList() with self.assertRaises(ValueExistentError): self.ulist.insert(0, "test") # Raise IndexOutOfRangeError. self.ulist.add("test node") with self.assertRaises(IndexOutOfRangeError): self.ulist.insert(-1, "test") with self.assertRaises(IndexOutOfRangeError): self.ulist.insert(1, "test") def test_set(self): """ Test set method. """ with self.assertRaises(IndexOutOfRangeError): self.ulist.set(-1, "test") with self.assertRaises(IndexOutOfRangeError): self.ulist.set(1, "test") def test_get(self): """ Test get method. """ with self.assertRaises(IndexOutOfRangeError): self.ulist.get(-1) with self.assertRaises(IndexOutOfRangeError): self.ulist.get(1) def test_index_of(self): """ Test index_of method. """ with self.assertRaises(ValueExistentError): self.ulist.index_of("test node ") def test_remove(self): """ Test remove method. """ with self.assertRaises(ValueExistentError): self.ulist.index_of(" test node") def test_populated_list_bubble_sort(self): """ Test lists are same after sorting. """ print() lst = [1, 3, 4, 8, 9] self.ulist.remove("test node") self.ulist.add(9) self.ulist.add(1) self.ulist.add(4) self.ulist.add(3) self.ulist.add(8) sort.bubble_sort(self.ulist) current_node = self.ulist.head for item in lst: if current_node.next != None: self.assertEqual(item, current_node.data) current_node = current_node.next def test_empty_list_bubble_sort(self): """ Test if list is empty after sorting. """ self.ulist.remove("test node") sort.bubble_sort(self.ulist) self.assertTrue(self.ulist.is_empty())
class Handler: """ Handler class """ def __init__(self): """ Initialize Unordered List class and start""" self.my_list = UnorderedList() self.start() def start(self): """ Start """ while True: print(""" [1] Check if the list is empty [2] Add value last in list [3] Insert value at a specific index [4] Replace value at a specific index [5] Show size of list [6] Show value at a specific index [7] Show index of a specific value [8] Show all values in the list [9] Remove node that match value [exit] Exit """) val = input('Choice: \n>>> ') if val == "1": print("\nCheck if the list is empty:") print(self.my_list.is_empty()) elif val == "2": print("\nAdd value last in list:") data = input("Value: ") self.my_list.add(data) elif val == "3": print("\nInsert value at a specific index:") index = input("Index: ") data = input("Value: ") try: self.my_list.insert(int(index), data) except IndexErrorException as e: print(e) elif val == "4": print("\nReplace value at a specific index:") index = input("Index: ") data = input("Value: ") try: self.my_list.set(int(index), data) except IndexErrorException as e: print(e) elif val == "5": print("\nShow size of list:") res = self.my_list.size() print(res) elif val == "6": print("\nShow value at a specific index:") data = input("Index: ") try: res = self.my_list.get(int(data)) print(res) except IndexErrorException as e: print(e) elif val == "7": print("\nShow index by value:") data = input("Value: ") try: res = self.my_list.index_of(data) print(res) except ValueErrorException as e: print(e) elif val == "8": print("\nShow all values in the list:") self.my_list.print_list() print(" ") elif val == "9": print("\nRemove node by value:") data = input("Value: ") try: self.my_list.remove(data) except ValueErrorException as e: print(e) elif val == "exit": sys.exit() else: print("No choice that match! try again")
#!/usr/bin/env python3 """ Main file for testing """ # Imports from my_bubblesort import bubble_sort from unorderedlist import UnorderedList # Create a new list my_list = UnorderedList() # Add 10 numbers to the list my_list.add(56) my_list.add(89) my_list.add(34) my_list.add(76) my_list.add(78) my_list.add(13) my_list.add(32) my_list.add(234) my_list.add(2) my_list.add(1) # Checks that the list is unsorted in the beginning my_list.print_list() # Sort the list bubble_sort(my_list) # Checks the structure of the list
#!/usr/bin/env python3 """ Main file """ from unorderedlist import UnorderedList ul = UnorderedList() ul.add(20) ul.add(10) ul.add(30) ul.add(40) ul.add(50) ul.print_list()