def test_number_averaging_normal(self):
self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5)
self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5)
self.assertEquals(number_average([0, 1, 2, 3, 4, 11], simple_func), 3.5)
list = LinkedList()
list.add_last(0)
self.assertEquals(number_average(list, simple_func), 0)
def test_number_averaging_normal(self):
self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5)
self.assertEquals(number_average([0.0, 1.0, 2.0, 3, 4, 5], simple_func), 2.5)
self.assertEquals(number_average([0, 1, 2, 3, 4, 11], simple_func), 3.5)
list = LinkedList()
list.add_last(0)
self.assertEquals(number_average(list, simple_func), 0)
def test_add_last(self):
tmp_list = LinkedList()
tmp_list.add_last(1)
tmp_list.add_last(3)
tmp_list.add_last(5)
self.assertEqual(3, len(tmp_list))
self.assertEqual(1, tmp_list.get_head().element)
self.assertEqual(5, tmp_list.find_tail().element)
class TestLinkedList(unittest.TestCase):
"""Test case used to test methods from LinkedList class"""
def setUp(self):
"""Test initialization"""
self.liste = LinkedList()
def test_newlist_empty(self):
"""2.1 test to check if a new created list is empty"""
#print(self.liste.empty_list())
#assertTrue checks if the empty_list() method returns True
self.assertTrue(self.liste.empty_list())
def test_add_notempty(self):
"""2.2 test to check that a list is not empty
if if we've just added an element """
new_node = Node("x")
self.liste.add_first(new_node)
#in this case we check that the list is not empty
self.assertTrue(not self.liste.empty_list())
def test_unchanged(self):
"""2.3 test if when we add and remove a new element,
the linked list remains unchanged"""
#list creation [a,b]
node_a, node_b = "a", "b"
self.liste.add_first(Node(node_a))
self.liste.add_after(node_a, Node(node_b))
#store the created list in a variable to be able to compared it later
first_list = self.liste
node_d = "d"
self.liste.add_last(Node(node_d))
self.liste.remove_node(node_d)
#assertEqual checks that two given objects are equal
self.assertEqual(self.liste, first_list)
def test_add_first(self):
"""2.4 test if an element added at the first position of the list
is the head of the list"""
node_e, node_b, node_c = "e", "b", "c"
self.liste.add_first(Node(node_b))
self.liste.add_after(node_b, Node(node_c))
#add the new head node e
self.liste.add_first(Node(node_e))
#comparison between the head of the list and the element inserted at the beginning
self.assertEqual(self.liste.head.__repr__(), node_e)
class LinkedListStack:
def __init__(self):
self.lst = LinkedList()
def push(self, value):
self.lst.add_last(value)
def pop(self):
return self.lst.remove_last()
def peek(self):
return self.lst.get_last()
def is_empty(self):
return self.lst.is_empty()
def test_linked_list(self):
for test_ob in self.test_cases:
list = LinkedList()
for val in test_ob['values']:
list.add_last(val)
r_list = LinkedList()
for val in list:
r_list.add_first(val)
i = 0
for val in list:
self.assertEqual(val, test_ob['values'][i])
i += 1
i = len(test_ob['values']) - 1
for val in r_list:
self.assertEqual(val, test_ob['values'][i])
i -= 1
def test_linked_list(self):
for test_ob in self.test_cases:
list = LinkedList()
for val in test_ob['values']:
list.add_last(val)
r_list = LinkedList()
for val in list:
r_list.add_first(val)
i = 0
for val in list:
self.assertEqual(val, test_ob['values'][i])
i += 1
i = len(test_ob['values']) - 1
for val in r_list:
self.assertEqual(val, test_ob['values'][i])
i -= 1
class LinkedListTestCase(unittest.TestCase):
def setUp(self):
self.list = LinkedList()
self.list.add_first(1)
self.list.add_first(3)
self.list.add_first(5)
def test_is_empty(self):
tmp_list = LinkedList()
self.assertTrue(tmp_list.is_empty())
def test_add_first(self):
self.assertEqual(3, len(self.list))
self.assertEqual(5, self.list.get_head().element)
self.assertEqual(1, self.list.find_tail().element)
def test_add_last(self):
tmp_list = LinkedList()
tmp_list.add_last(1)
tmp_list.add_last(3)
tmp_list.add_last(5)
self.assertEqual(3, len(tmp_list))
self.assertEqual(1, tmp_list.get_head().element)
self.assertEqual(5, tmp_list.find_tail().element)
def test_remove_first(self):
self.assertEqual(5, self.list.remove_first())
self.assertEqual(3, self.list.remove_first())
self.assertEqual(1, self.list.remove_first())
def test_get(self):
self.assertEqual(5, self.list.get(0))
self.assertEqual(3, self.list.get(1))
self.assertEqual(1, self.list.get(2))
def test_find_tail(self):
self.assertEqual(1, self.list.find_tail().element)
self.list.add_last(9)
self.assertEqual(9, self.list.find_tail().element)
tmp_list = LinkedList()
self.assertTrue(tmp_list.find_tail() is None)
class TestLinkedList(unittest.TestCase):
""" Class created to proceed tests on the linked list """
def setUp(self):
self.new_list = LinkedList()
def test_new_linked_list_is_empty(self):
"""
A method to test if the new linked list created is empty or not.
The head of a new linked list is None!
"""
self.assertIsNone(self.new_list.head)
def test_not_empty_after_insertion(self):
"""
A method to test if after the insertion wether the linked list is empty or not
"""
self.new_list.add_first(Node(5))
self.assertIsNotNone(self.new_list)
def test_unchangement(self):
"""
A method to test if after an adding and deleting node the linked list is unchanged.
Original list is created to compare it with the linked list
after the insertion and the deletion.
"""
original_list = self.new_list
self.new_list.add_last(Node(6))
self.new_list.remove_node(6)
self.assertEqual(self.new_list, original_list)
def test_head(self):
"""
A method to test if after the insertion of a data in the head, then the head == data
"""
new_head = "i'm the new head!!"
self.new_list.add_first(Node(new_head))
self.assertEqual(self.new_list.head.data, new_head)
print(*s, sep=' ', end='')
n = int(input(': '))
if 1 <= n <= len(Menu):
return Menu(n)
lst = LinkedList() # 연결 리스트를 생성
while True:
menu = select_Menu() # 메뉴 선택
if menu == Menu.머리에노드삽입: # 맨 앞에 노드 삽입
lst.add_first(int(input('머리에 넣을 값을 입력하세요.: ')))
elif menu == Menu.꼬리에노드삽입: # 맨 끝에 노드 삽입
lst.add_last(int(input('꼬리에 넣을 값을 입력하세요.: ')))
elif menu == Menu.머리노드삭제: # 맨 앞 노드 삭제
lst.remove_first()
elif menu == Menu.꼬리노드삭제: # 맨 끝 노드 삭제
lst.remove_last()
elif menu == Menu.주목노드출력: # 주목 노드 출력
lst.print_current_node()
elif menu == Menu.주목노드이동: # 주목 노드를 한 칸 뒤로 이동
lst.next()
elif menu == Menu.주목노드삭제: # 주목 노드 삭제
lst.remove_current_node()
while True:
print(*s, sep = ' ', end='')
n = int(input(': '))
if 1 <= n <= len(Menu):
return Menu(n)
lst = LinkedList() #연결 리스트 생성
while True:
menu = select_Menu()
if menu == Menu.머리에노드삽입:
lst.add_first(int(input('머리 노드에 넣을 값 입력 : ')))
elif menu == Menu.꼬리에노드삽입:
lst.add_last(int(input('꼬리 노드에 넣을 값 입력 : ')))
elif menu == Menu.머리노드삭제:
lst.remove_first()
elif menu == Menu.꼬리노드삭제:
lst.remove_last()
elif menu == Menu.주목노드출력:
lst.print_current_node()
elif menu == Menu.주목노드이동:
lst.next()
elif menu == Menu.주목노드삭제:
lst.remove_current_node()
# coding: utf-8
from linked_list import LinkedList
from linked_list import Node
if __name__ == "__main__":
"""Just to test the different methods of the LinkedList class"""
llist = LinkedList(["a", "b", "c", "d", "e"])
llist.add_last(Node("g"))
# llist.add_first(Node("z"))
# llist.add_before("z", Node("y"))
# llist.add_before("y", Node("x"))
# llist.add_before("g", Node("f"))
# llist.add_after("g", Node("h"))
# llist.add_before("q", Node("r"))
# llist.remove_node("q")
# llist.remove_node("a")
# print(llist)
# llist.remove_node("x")
# print(llist)
# new_list = LinkedList([])
# new_list.get(0)
print(llist.recurs(3, llist.head))
# create the linked list by passing in the nodes list
llist = LinkedList(list('abcde'))
print(llist)
# traversing through the linked list
for e in llist:
print(e)
# inserting an element to the first of the linked list
llist.add_first(Node('x'))
llist.add_first(Node('y'))
print(llist)
# inserting an element to the last of the linked list
llist.add_last(Node('f'))
llist.add_last(Node('g'))
print(llist)
# inserting a node in between
# adding to an empty linked list
llist = LinkedList()
# llist.add_after('a', Node('b')) # exception
print(llist)
# adding an element after a target node
llist = LinkedList(list('abcde'))
llist.add_after('c', Node('cc'))
print(llist)
# attempt to add after a non-existent target node
# llist.add_after('f', Node('g')) # exception
print(llist)
def test_add_last(self):
l = LinkedList()
l.add_last(1)
l.add_last(2)
self.assertEquals(2, len(l))
self.assertEquals("[1,2]", str(l))
