class TestLinkedListCursorGetterMethods(unittest.TestCase):


    def setUp(self):
        # empty list testing empty gets
        self.emptylinkedlist = LinkedListCursor()
        # populated list for testing populated gets
        self.poplinkedlist = LinkedListCursor(range(0, 10))


    def testGetItemAtHeadEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.itemAtHead)


    def testGetItemAtHeadPopulated(self):
        item = self.poplinkedlist.itemAtHead()
        self.assertEqual(item, 0)


    def testGetItemAtCursorEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.itemAtCursor)


    def testGetItemAtCursorPopulated(self):
        item = self.poplinkedlist.itemAtCursor()
        self.assertEqual(item, 1)


    def testGetItemAtTailEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.itemAtTail)


    def testGetItemAtTailPopulated(self):
        item = self.poplinkedlist.itemAtTail()
        self.assertEqual(item, 9)
class TestLinkedListCursorRemoveMethods(unittest.TestCase):


    def setUp(self):
        # empty list testing empty removals
        self.emptylinkedlist = LinkedListCursor()
        # populated list for testing populated removals
        self.poplinkedlist = LinkedListCursor(range(0, 10))


    def testRemoveItemAtHeadEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.removeItemAtHead)
        self.assertEqual(len(self.emptylinkedlist), 0)


    def testRemoveItemAtHeadPopulated(self):
        item = self.poplinkedlist.removeItemAtHead()
        self.assertEqual(item, 0)
        self.assertEqual(self.poplinkedlist.head.item, 1)
        self.assertEqual(len(self.poplinkedlist), 9)


    def testRemoveItemAtCursorEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.removeItemAtCursor)
        self.assertEqual(len(self.emptylinkedlist), 0)


    def testRemoveItemAtCursorPopulated(self):
        item = self.poplinkedlist.removeItemAtCursor()
        self.assertEqual(item, 1)
        self.assertEqual(self.poplinkedlist.cursor.item, 2)
        self.assertEqual(len(self.poplinkedlist), 9)
        # make sure if the cursor is at the tail it removes it
        # and sets it to the previous node
        self.poplinkedlist.cursor = self.poplinkedlist.tail
        item = self.poplinkedlist.removeItemAtCursor()
        self.assertEqual(item, 9)
        self.assertEqual(self.poplinkedlist.cursor.item, 8)
        self.assertEqual(len(self.poplinkedlist), 8)


    def testRemoveItemAtTailEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.removeItemAtTail)
        self.assertEqual(len(self.emptylinkedlist), 0)


    def testRemoveItemAtTailPopulated(self):
        item = self.poplinkedlist.removeItemAtTail()
        self.assertEqual(item, 9)
        self.assertEqual(self.poplinkedlist.tail.item, 8)
        self.assertEqual(len(self.poplinkedlist), 9)
class TestLinkedListCursorSizeMethods(unittest.TestCase):


    def setUp(self):
        self.linkedlist = LinkedListCursor([1,2,3])


    def testSizeMethod(self):
        self.assertEqual(self.linkedlist.size(), 3)


    def testLenFunction(self):
        self.assertEqual(len(self.linkedlist), 3)
class TestLinkedListCursorMoveMethods(unittest.TestCase):


    def setUp(self):
        self.linkedlist = LinkedListCursor(range(0, 10))


    def testCursorToStart(self):
        result = self.linkedlist.cursorToStart()
        self.assertEqual(self.linkedlist.head, self.linkedlist.cursor)


    def testCursorForward(self):
        # test normal case
        result = self.linkedlist.cursorForward()
        self.assertEqual(result, True)
        self.assertEqual(self.linkedlist.cursor.item, 2)
        # test if cursor is on tail
        self.linkedlist.cursor = self.linkedlist.tail
        result = self.linkedlist.cursorForward()
        self.assertEqual(result, False)
        self.assertEqual(self.linkedlist.cursor, self.linkedlist.tail)


    def testCursorBackward(self):
        # test normal case
        result = self.linkedlist.cursorBackward()
        self.assertEqual(result, True)
        self.assertEqual(self.linkedlist.cursor.item, 0)
        # test if cursor is on head
        self.linkedlist.cursor = self.linkedlist.head
        result = self.linkedlist.cursorBackward()
        self.assertEqual(result, False)
        self.assertEqual(self.linkedlist.cursor.item, 0)


    def testSetCursorToIndex(self):
        self.linkedlist.setCursorToIndex(-1)
        self.assertEqual(self.linkedlist.cursor.item, 9)
        # test if the index is out of range
        self.assertRaises(IndexError, self.linkedlist.setCursorToIndex, 20)
 def setUp(self):
     # empty list testing empty inserts
     self.emptylinkedlist = LinkedListCursor()
     # populated list for testing populated inserts
     self.poplinkedlist = LinkedListCursor(range(0, 10))
class TestLinkedListInsertMethods(unittest.TestCase):


    def setUp(self):
        # empty list testing empty inserts
        self.emptylinkedlist = LinkedListCursor()
        # populated list for testing populated inserts
        self.poplinkedlist = LinkedListCursor(range(0, 10))


    def testInsertAtHeadEmpty(self):
        self.emptylinkedlist.insertAtHead(1)
        self.assertEqual(self.emptylinkedlist.head.item, 1)
        self.assertEqual(len(self.emptylinkedlist), 1)


    def testInsertAtHeadPopulated(self):
        self.poplinkedlist.insertAtHead(-1)
        self.assertEqual(self.poplinkedlist.head.item, -1)
        self.assertEqual(self.poplinkedlist.head.link.item, 0)
        self.assertEqual(len(self.poplinkedlist), 11)


    def testInsertAfterCursorEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.insertAfterCursor, 0)
        self.assertEqual(len(self.emptylinkedlist), 0)


    def testInsertAfterCursorPopulated(self):
        self.poplinkedlist.insertAfterCursor(1.5)
        self.assertEqual(self.poplinkedlist.cursor.link.item, 1.5)
        self.assertEqual(len(self.poplinkedlist), 11)


    def testInsertBeforeCursorEmpty(self):
        self.assertRaises(IndexError, self.emptylinkedlist.insertBeforeCursor, 0)
        self.assertEqual(len(self.emptylinkedlist), 0)


    def testInsertBeforeCursorPopulated(self):
        self.poplinkedlist.insertBeforeCursor(.5)
        self.assertEqual(self.poplinkedlist.head.link.item, .5)
        self.assertEqual(len(self.poplinkedlist), 11)


    def testInsertAtTailEmpty(self):
        self.emptylinkedlist.insertAtTail(1)
        self.assertEqual(self.emptylinkedlist.head.item, 1)
        self.assertEqual(len(self.emptylinkedlist), 1)
        # test that it sets the cursor
        self.emptylinkedlist.insertAtTail(2)
        self.assertEqual(self.emptylinkedlist.cursor.item, 2)
        self.assertEqual(len(self.emptylinkedlist), 2)
        # then finally test it sets the tail
        self.emptylinkedlist.insertAtTail(3)
        self.assertEqual(self.emptylinkedlist.tail.item, 3)
        self.assertEqual(len(self.emptylinkedlist), 3)


    def testInsertAtTailPopulated(self):
        self.poplinkedlist.insertAtTail(10)
        self.assertEqual(self.poplinkedlist.tail.item, 10)
        self.assertEqual(len(self.poplinkedlist), 11)
 def setUp(self):
     self.linkedlist = LinkedListCursor([1,2,3])
 def setUp(self):
     self.linkedlist = LinkedListCursor(range(0, 10))