def test_get_value(self):
"""
Returns the value of the current node
"""
node = Node("test value")
result = node.get_value()
self.assertEqual(result, "test value")
def test_instantiates_with_none_default(self):
"""
Instantiates with None as default if no value is given
"""
node = Node()
result = node.get_value()
self.assertEqual(result, None)
def test_delete_and_return_value(self):
"""
Deletes a node and returns the deleted node's value
"""
node = Node(1)
result = node.delete()
self.assertEqual(result, 1)
def test_add_value_to_end(self):
"""
Adds a new value to the end of the linked list
"""
node = Node(1)
node.add_value(2)
result = node._next.get_value()
self.assertEqual(result, 2)
def test_node():
our_node = Node("first")
assert our_node.data == "first"
assert our_node.next is None
our_next_node = Node("second", our_node)
assert our_next_node.data == "second"
assert our_next_node.next is our_node
def test_5(self):
"""test to check len method works"""
n1 = Node('A')
n2 = Node('B')
q = Queue()
q.enqueue(n1)
q.enqueue(n2)
self.assertEqual(len(q), 2)
def test_get_value_none(self):
"""
Returns None when get_value is invoked if no value
was passed to the node when instantiated
"""
node = Node()
result = node.get_value()
self.assertEqual(result, None)
def test_3(self):
"""test enqueue"""
n1 = Node('A')
n2 = Node('B')
q = Queue()
q.enqueue(n1) #A goes in queue first
q.enqueue(n2) #B goes in queue second, so end of the queue
self.assertEqual(q.front._next._value,
'B') #test that the head, A's next property is B
def test_4(self):
"""test dequeue"""
n1 = Node('A')
n2 = Node('B')
q = Queue()
q.enqueue(n1) #A goes into queue first
q.enqueue(n2) #B goes second
q.dequeue() #dequeue removes A
self.assertEqual(q.front._value,
'B') #tests that B is fron of the queue
def create_list(length):
"""
Creates a new linked list of specified length
"""
l = None
for i in range(1, length + 1):
if l == None:
l = Node(i)
else:
l.add_value(i)
return l
def test_init_node(self):
"""
Tests initialization of Node
"""
n1 = Node('data')
self.assertIsInstance(n1, Node)
self.assertEqual(n1.data, 'data')
self.assertIsNone(n1.next)
# make sure 'value' is writeable
n1.data = "new_val"
self.assertEqual(n1.data, 'new_val')
# make sure 'next' is writeable
n2 = Node('new_node')
n1.next = n2
def test_node():
"""
Ensure Node() is correctly constructed
"""
node = Node(500)
assert node.value == 500
assert node.next_node is None
def test_instantiates_with_none_next_and_previous(self):
"""
Instantiates with None as default for next and previous nodes
if value is given
"""
node = Node("test")
next_node = node._next
previous_node = node._previous
self.assertEqual(next_node, None)
self.assertEqual(previous_node, None)
def enqueue_back(self, item):
node = Node(item)
self.tail.pointer = node
self.tail = node
self.count +=1
def simulate_banking_cash_counter():
"""initially bank balance"""
cash_balance=100000
deposit=0
withdraw=0
while True:
print("Welcome sir,We have following services!!")
print("1.Deposit amount!!")
print("2.withdraw amount!!")
print("3.Exit")
while True:
try:
choice=int(input("Enter a appropriate choice :"))
if choice==1 or choice==2 or choice==3:
break
else:
print("Enter a valid choice!!")
except ValueError:
print("Enter a valid choice!!")
if choice==1:
"""Adding the person into queue"""
add=Node(1)
obj.enqueqe(add)
while True:
try:
amount=int(input("Enter the amount to be deposited:"))
if amount > 0:
break
else:
print("Amount should be more then zero!!")
except ValueError:
print("Invalid input!!")
"""Updating bank balance"""
cash_balance+=amount
deposit+=amount
print(f"You have successfully deposited :{amount}rs")
obj.dequeue()
elif choice==2:
"""Adding the person into queue"""
add=Node(1)
obj.enqueqe(add)
while True:
try:
amount_withdraw=int(input("Enter the amount to be withdraw:"))
if amount_withdraw > 0:
break
else:
print("Amount should be more then zero!!")
except ValueError:
print("Invalid input!!")
if cash_balance >= amount_withdraw:
"""Updating bamk balance"""
cash_balance-=amount_withdraw
withdraw+=amount_withdraw
print(f"You have successfully withdraw :{amount_withdraw}rs")
obj.dequeue()
else:
print("Sorry Insufficient balance!! ")
obj.dequeue()
else:
return False
def test_node_init():
b = Node(u'a')
assert b.data == u'a'
c = Node(u'a', b)
assert c.next.data == u'a'
def test_1(self):
"""test creating a node"""
n1 = Node('A')
self.assertEqual(n1._value, 'A')
def test_Node(request):
assert Node(5).val == 5
i += 1
while s.isEmpty() is False:
#print(s)
input_string.enqueue(s.peek())
print(input_string)
s.pop()
return input_string
#turn list into a string and then turn each string into an integer
_str = input("Enter the list of numbers: ")
_list = _str.replace(" ", "").split(",")
for i in range(len(_list)):
_list[i] = int(_list[i])
k = int(input("Enter k: "))
#print(_list)
n = queue(Node(_list[0]))
i = 1
while i < len(_list):
n.enqueue(_list[i])
i += 1
#print(n)
print(revKElements(n, k))
from queue import Node from queue import queue obj = queue(Node(5)) obj.enqueue(10) obj.enqueue(12) obj.enqueue(22) obj.enqueue(1249) #obj.dequeue() print(obj) print(obj.isEmpty()) print(obj.front()) print(obj.size)
def test_instantiates(self):
"""
Instantiates a new version of the Node class
"""
node = Node("test")
self.assertIsInstance(node, Node)
in a Queue using the Linked List and Print the Anagrams from the Queue.
Note no Collection Library can be used.
"""
from queue import Queue, Node
from primeclass import Prime
"""Creating object of queue class"""
obj = Queue()
"""Creating object of prime class"""
prime_obj = Prime()
"""Creating prime_anagram list"""
prime_anagram = []
"""Creating list of prime number in given range"""
prime_list = prime_obj.prime(0, 1000)
"""Checking prime number anagran or not"""
for num in prime_list:
if num <= 10:
continue
number = prime_obj.anagram(num)
if prime_obj.prime_check(number) and 0 <= number <= 1000:
prime_anagram.append(number)
prime_anagram.append(num)
prime_list.remove(number)
"""finding the length of prime anagram list"""
length = len(prime_anagram)
"""Adding the prime anagram in to queue"""
for number in range(length):
num = Node(prime_anagram[number])
obj.enqueqe(num)
"""Printind the anagram from queue """
obj.traverse()
def test_2(self):
"""test enqueue"""
n1 = Node('A')
q = Queue()
q.enqueue(n1)
self.assertEqual(q.front._value, 'A')
