def test_insert_invalid_ref(self):
ll = sllist([1, 2, 3, 4])
self.assertRaises(TypeError, ll.insertafter, 10, 1)
self.assertRaises(TypeError, ll.insertafter, 10, 'abc')
self.assertRaises(TypeError, ll.insertafter, 10, [])
self.assertRaises(ValueError, ll.insertafter, 10, sllistnode())
self.assertRaises(TypeError, ll.insertbefore, 10, 1)
self.assertRaises(TypeError, ll.insertbefore, 10, 'abc')
self.assertRaises(TypeError, ll.insertbefore, 10, [])
self.assertRaises(ValueError, ll.insertbefore, 10, sllistnode())
def test_insert_node_with_invalid_ref(self):
ll = sllist([1, 2, 3, 4])
self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), 1)
self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), 'abc')
self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(10), [])
self.assertRaises(
ValueError, ll.insertnodeafter, sllistnode(10), sllistnode())
self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), 1)
self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), 'abc')
self.assertRaises(TypeError, ll.insertnodebefore, sllistnode(10), [])
self.assertRaises(
ValueError, ll.insertnodebefore, sllistnode(10), sllistnode())
def test_remove_from_n_elem(self):
ll = sllist()
nn = sllistnode()
ll.append(nn)
to_del = ll.nodeat(0)
ll.remove(to_del)
self.assertEqual(None, None)
def test_insertnodeafter_with_invalid_type_of_inserted_node(self):
ll = dllist([0])
self.assertRaises(TypeError, ll.insertnodeafter, None, ll.first)
self.assertRaises(TypeError, ll.insertnodeafter, 'non-node argument',
ll.first)
self.assertRaises(TypeError, ll.insertnodeafter, sllistnode(1234),
ll.first)
def distribute(Arr, d, sll):
reminder = [0] * (len(Arr))
for i in range(0, len(Arr)):
# to get digits in the position we want we use
r = (Arr[i] / 10**d) % 10
reminder[i] = r
# print reminder
# now distribute these values in single linked list
for n in range(9, -1, -1):
for m in range(len(Arr) - 1, -1, -1):
if sll.size == 0 and reminder[m] == n:
sll.append(Arr[m])
Arr.pop(m)
reminder.pop(m)
elif sll.size > 0 and reminder[m] == n:
new_node = sllistnode(Arr[m])
sll.appendleft(new_node)
Arr.pop(m)
reminder.pop(m)
# print sll
m -= 1
return sll
def test_node_readonly_attributes(self):
if sys.hexversion >= 0x03000000:
expected_error = AttributeError
else:
expected_error = TypeError
ll = sllistnode()
self.assertRaises(expected_error, setattr, ll, 'next', None)
def test_insertnodeafter_with_invalid_type_of_ref_node(self):
ll = dllist([0])
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
None)
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
'not a dllist node')
self.assertRaises(TypeError, ll.insertnodeafter, dllistnode(1234),
sllistnode(1234))
def test_cyclic_list_destruction_does_not_release_extra_None_refs(self):
original_ref_count = sys.getrefcount(None)
for _ in range(original_ref_count * 10):
ll = sllist()
ll.append(sllistnode(ll))
del ll
self.assertGreater(sys.getrefcount(None), 0)
def test_insert_node_before_first(self):
ll = sllist(py23_xrange(4))
ref = sllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = sllistnode(10)
new_node = ll.insertnodebefore(arg_node, ll.nodeat(0))
self.assertEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, next)
self.assertEqual(new_node, ll.first)
self.assertEqual(ll, ref)
def test_appendleft(self):
ll = sllist(py23_xrange(4))
ref = sllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = sllistnode(10)
new_node = ll.appendleft(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, next)
self.assertEqual(ll.first, new_node)
self.assertEqual(ll, ref)
def test_insert_value_after(self):
ll = sllist(py23_xrange(4))
ref = sllist([0, 1, 2, 10, 3])
prev = ll.nodeat(2)
next = ll.nodeat(3)
arg_node = sllistnode(10)
new_node = ll.insertafter(arg_node, ll.nodeat(2))
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, next)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll, ref)
def test_appendright(self):
ll = sllist(py23_xrange(4))
ref = sllist([0, 1, 2, 3, 10])
prev = ll.nodeat(-1)
arg_node = sllistnode(10)
new_node = ll.appendright(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll.last, new_node)
self.assertEqual(ll, ref)
def test_insert_node_before_another(self):
ll = sllist(py23_xrange(4))
ref = sllist([0, 1, 10, 2, 3])
prev = ll.nodeat(1)
next = ll.nodeat(2)
arg_node = sllistnode(10)
new_node = ll.insertnodebefore(arg_node, ll.nodeat(2))
self.assertEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, next)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll, ref)
def test_insert_node_after_last(self):
ll = sllist(py23_xrange(4))
ref = sllist([0, 1, 2, 3, 10])
prev = ll.nodeat(3)
arg_node = sllistnode(10)
new_node = ll.insertnodeafter(arg_node, ll.nodeat(-1))
self.assertEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(new_node, ll.last)
self.assertEqual(ll, ref)
def addTwoNumbers(l1, l2):
dummy = sllist()
carry = 0
n1 = l1.first
n2 = l2.first
sum = dummy.first
while n1 or n2 or carry:
if n1:
carry += n1.value
n1 = n1.next
if n2:
carry += n2.value
n2 = n2.next
sum = dummy.append(sllistnode(carry % 10))
carry //= 10
sum = sum.next
return dummy
def test_appendnode(self):
ll = sllist([1, 2, 3, 4])
node = sllistnode(5)
ll.appendnode(node)
self.assertEqual([1, 2, 3, 4, 5], list(ll))
self.assertIs(node, ll.last)
def test_insert_node_before_refcount_update(self):
ll = sllist([1234])
node = ll.insertnodebefore(sllistnode(5678), ll.nodeat(0))
self.assertGreaterEqual(sys.getrefcount(node), 3)
def test_appendnode_refcount_update(self):
ll = sllist()
node = ll.appendnode(sllistnode(1234))
self.assertGreaterEqual(sys.getrefcount(node), 3)
def test_repr_recursive_list(self):
ll = sllist()
ll.append(sllistnode(ll))
self.assertEqual(repr(ll), 'sllist([sllist(<...>)])')
def test_remove_from_empty_list(self):
ll = sllist()
self.assertRaises(ValueError, ll.remove, sllistnode())
def make_recursive_node_list(self):
ll = sllist()
node = sllistnode()
node.value = node
ll.append(node)
return ll
def test_insert_node_after_first(self):
ll = sllist([1, 3, '123'])
arg_node = sllistnode(100)
new_node = ll.insertnodeafter(arg_node, ll.first)
self.assertEqual([1, 100, 3, '123'], list(ll))
self.assertEqual(new_node, arg_node);
def test_remove_invalid_node(self):
ll = sllist([1, 2, 3, 4])
self.assertRaises(ValueError, ll.remove, sllistnode())
self.assertEqual(len(ll), 4)
def test_insert_node_before_first(self):
ll = sllist([1, 3, '123'])
arg_node = sllistnode(100)
new_node = ll.insertnodebefore(arg_node, ll.first)
self.assertEqual([100, 1, 3, '123'], list(ll))
self.assertEqual(new_node, arg_node);
