def test_list_as_generator(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(10,100,10)
singlyLinkedListObject.populate(inputList)
for index, data in enumerate(singlyLinkedListObject):
self.assertTrue(data == inputList[index], "Data mismatch. Expected data: %s, Got: %s" %(inputList[index], data))
def test_length_of_list_after_list_change_operations(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(10)
singlyLinkedListObject.populate(inputList)
expectedLength = len(inputList)
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
singlyLinkedListObject.deleteHead()
expectedLength -= 1
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
singlyLinkedListObject.insertAtHead(200)
expectedLength += 1
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
singlyLinkedListObject.insertAtHead(200)
expectedLength += 1
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
def test_delete_head_with_one_element_list(self):
singlyLinkedListObject = SinglyLinkedList()
singlyLinkedListObject.populate([1])
singlyLinkedListObject.deleteHead()
outputList = singlyLinkedListObject.returnLinkedListAsList()
self.assertTrue(len(outputList) == 0, "After deleting the only element in the list, Output List must be empty")
def test_populate(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(20)
singlyLinkedListObject.populate(inputList)
outputList = singlyLinkedListObject.returnLinkedListAsList()
self.assertTrue(inputList == outputList, "Input List: %s and Output List: %s don't match" %(inputList, outputList))
def test_reverse_a_list_with_two_elements(self):
givenList = SinglyLinkedList()
inputList = [10, 20]
givenList.populate(inputList)
s = Solution()
s.printReverseUsingRecursion(givenList.head)
def test_reverse_a_list_with_many_elements(self):
givenList = SinglyLinkedList()
inputList = range(10,101,10)
givenList.populate(inputList)
s = Solution()
s.printReverseUsingRecursion(givenList.head)
def test_yield_reverse_list_with_three_elements(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = [1, 2, 3]
singlyLinkedListObject.populate(inputList)
s = Solution()
for i in s.yieldListDataInReversedOrderUsingRecursion(singlyLinkedListObject.head):
print i
def test_delete_head_of_list_with_one_item(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = [1]
singlyLinkedListObject.populate(inputList)
singlyLinkedListObject.deleteHead()
self.assertTrue(singlyLinkedListObject.isHeadNone(), "Now that the only element in the list is deleted, Head of empty list must be None")
singlyLinkedListObject.deleteHead()
self.assertTrue(singlyLinkedListObject.isHeadNone(), "Now that the only element in the list is deleted, Head of empty list must be None")
def test_length_of_list_with_many_elements(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(100000)
singlyLinkedListObject.populate(inputList)
expectedLength = len(inputList)
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
def test_return_centre_of_list_with_many_even_elements(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(40000)
singlyLinkedListObject.populate(inputList)
centreIndex = (len(inputList)-1)/2
expectedCentre = inputList[centreIndex]
actualCentre = singlyLinkedListObject.returnCentreOfTheLinkedList()
self.assertTrue(expectedCentre == actualCentre.data, "Expected centre if linked list: %s, Got: %s" %(expectedCentre, actualCentre))
def test_reverse_a_list_with_two_elements(self):
originalList = SinglyLinkedList()
inputList = [10, 20]
originalList.populate(inputList)
s = Solution()
s.reverseOriginalLinkedList_Recursive(originalList)
expectedList = inputList[::-1]
returnedList = originalList.returnLinkedListAsList()
self.assertTrue(expectedList == returnedList, "Expected: %s, Got: %s" %(expectedList, returnedList))
def test_returnNodeAtBeginingOfLinkedListLoop(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(1,12)
singlyLinkedListObject.populate(inputList)
s = Solution(singlyLinkedListObject)
# Insert a loop at 4th position
singlyLinkedListObject.tail.nextPointer = singlyLinkedListObject.head.nextPointer.nextPointer.nextPointer
s.returnNodeAtBeginingOfLinkedListLoop()
def test_returnNodeAtBeginingOfLinkedListLoop(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(1, 12)
singlyLinkedListObject.populate(inputList)
s = Solution(singlyLinkedListObject)
# Insert a loop at 4th position
singlyLinkedListObject.tail.nextPointer = singlyLinkedListObject.head.nextPointer.nextPointer.nextPointer
s.returnNodeAtBeginingOfLinkedListLoop()
def test_add_without_carry_basic_case_second_list_empty_first_list_has_more_than_one_element(self):
firstList = SinglyLinkedList()
inputValue = range(10)
firstList.populate(inputValue)
secondList = SinglyLinkedList()
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList()
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = inputValue
self.assertTrue(outputValue == expectedValue, "Expected: %s, Got: %s" %(expectedValue, outputValue))
def test_list_with_four_values_not_a_palindrome(self):
singlyLinkedList = SinglyLinkedList()
inputList = [1, 2, 1, 2]
singlyLinkedList.populate(inputList)
s = Solution(singlyLinkedList)
expectedValue = False # Considering empty list is a palindrome
receivedValue = s.method1()
self.assertTrue(
expectedValue == receivedValue,
"Expected: %s, Received: %s" % (expectedValue, receivedValue))
def test_list_with_one_value(self):
singlyLinkedList = SinglyLinkedList()
inputList = [1]
singlyLinkedList.populate(inputList)
s = Solution(singlyLinkedList)
expectedValue = True # Considering empty list is a palindrome
receivedValue = s.method2()
self.assertTrue(
expectedValue == receivedValue,
"Expected: %s, Received: %s" % (expectedValue, receivedValue))
def test_reverse_a_list_with_many_elements(self):
givenList = SinglyLinkedList()
inputList = range(10,101,10)
givenList.populate(inputList)
s = Solution()
outputLinkedList = SinglyLinkedList()
s.returnReversedListUsingRecursion(givenList.head, outputLinkedList)
expectedList = inputList[::-1]
returnedList = outputLinkedList.returnLinkedListAsList()
self.assertTrue(expectedList == returnedList, "Expected: %s, Got: %s" %(expectedList, returnedList))
def test_reverse_a_list_with_many_elements(self):
originalList = SinglyLinkedList()
inputList = range(10,101,10)
originalList.populate(inputList)
s = Solution()
s.reverseOriginalList_Iterative(originalList)
expectedList = inputList[::-1]
returnedList = originalList.returnLinkedListAsList()
self.assertTrue(expectedList == returnedList, "Expected: %s, Got: %s" %(expectedList, returnedList))
def test_append_when_list_has_at_least_one_element(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(10)
singlyLinkedListObject.populate(inputList)
inputVal = 10
singlyLinkedListObject.appendToListUsingTail(inputVal)
self.assertTrue(singlyLinkedListObject.tail.data == inputVal, "Expected Tail data: %s, Got: %s" %(inputVal, singlyLinkedListObject.tail.data))
outputList = singlyLinkedListObject.returnLinkedListAsList()
outputVal = outputList[-1]
self.assertTrue(inputVal == outputVal, "Expected tail value: %s, Got: %s" %(inputVal, outputVal))
def test_delete_head_from_a_list_with_more_than_two_elements(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(20)
singlyLinkedListObject.populate(inputList)
# Deleting the first element from the inputList. this will help in assertion
inputList.pop(0)
singlyLinkedListObject.deleteHead()
outputList = singlyLinkedListObject.returnLinkedListAsList()
self.assertTrue(inputList == outputList, "Expecting one lesser value in the Output List but got different. Expected: %s, Got: %s" %(inputList, outputList))
self.assertTrue(singlyLinkedListObject.head != singlyLinkedListObject.tail, "Tail and Head must NOT be the same after only 1 element remains in the list")
def test_add_with_carry_forever_carry_till_last(self):
firstList = SinglyLinkedList()
firstList.populate([9,9,9,9,9,9,9])
secondList = SinglyLinkedList()
secondList.populate([1])
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList()
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = [0,0,0,0,0,0,0,1]
self.assertTrue(outputValue == expectedValue, "Expected: %s, Got: %s" %(expectedValue, outputValue))
def test_add_without_carry_both_lists_have_unequal_items(self):
firstList = SinglyLinkedList()
firstList.populate([7,1,6,9])
secondList = SinglyLinkedList()
secondList.populate([5,9,2])
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList()
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = [2,1,9,9]
self.assertTrue(outputValue == expectedValue, "Expected: %s, Got: %s" %(expectedValue, outputValue))
def test_without_carry_best_case_equal_elements_three_in_length(self):
firstList = SinglyLinkedList()
secondList = SinglyLinkedList()
outputList = SinglyLinkedList()
firstList.populate([1, 1, 8])
secondList.populate([4, 3, 1])
s = Solution(firstList, secondList, outputList)
s.addTwoNonReversedIntegersAsLinkedListsAndCreateNewList()
outputValue = outputList.returnLinkedListAsList()
expectedValue = [5, 4, 9]
self.assertTrue(outputValue == expectedValue, "Expected: %s, Got: %s" %(expectedValue, outputValue))
def test_partition_number_present_in_middle_of_list(self):
inputList = [38, 76, 72, 44, 17, 65, 24, 59, 47, 76]
givenSinglyLinkedList = SinglyLinkedList()
givenSinglyLinkedList.populate(inputList)
s = Solution(givenSinglyLinkedList)
returnList = s.partitionLinkedListBasedOnAGivenNumber_createNewList(38)
outputList = [17, 24, 38, 76, 72, 44, 65, 59, 47, 76]
returnedList = returnList.returnLinkedListAsList()
self.assertTrue(returnedList == outputList,
"Expected: %s, Got: %s" % (outputList, returnedList))
def test_add_with_carry_forever_carry_till_last(self):
firstList = SinglyLinkedList()
firstList.populate([9, 9, 9, 9, 9, 9, 9])
secondList = SinglyLinkedList()
secondList.populate([1])
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList(
)
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = [0, 0, 0, 0, 0, 0, 0, 1]
self.assertTrue(outputValue == expectedValue,
"Expected: %s, Got: %s" % (expectedValue, outputValue))
def test_add_without_carry_both_lists_have_equal_items(self):
firstList = SinglyLinkedList()
firstList.populate([7, 1, 6])
secondList = SinglyLinkedList()
secondList.populate([5, 9, 2])
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList(
)
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = [2, 1, 9]
self.assertTrue(outputValue == expectedValue,
"Expected: %s, Got: %s" % (expectedValue, outputValue))
def test_changing_list_length_during_delete_head_operation(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = range(10)
singlyLinkedListObject.populate(inputList)
expectedLength = len(inputList)
actualLength = len(singlyLinkedListObject)
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
for data in inputList:
singlyLinkedListObject.deleteHead()
actualLength = len(singlyLinkedListObject)
expectedLength -= 1 # Because a new element has been added to the list.
self.assertTrue(expectedLength == actualLength, "Expected length: %s, Actual Length: %s" %(expectedLength, actualLength))
def test_add_without_carry_basic_case_second_list_empty_first_list_has_more_than_one_element(
self):
firstList = SinglyLinkedList()
inputValue = range(10)
firstList.populate(inputValue)
secondList = SinglyLinkedList()
s = Solution(firstList, secondList)
returnLinkedList = s.addTwoReversedIntegersAsLinkedListsAndCreateNewList(
)
outputValue = returnLinkedList.returnLinkedListAsList()
expectedValue = inputValue
self.assertTrue(outputValue == expectedValue,
"Expected: %s, Got: %s" % (expectedValue, outputValue))
def test_without_carry_best_case_equal_elements_three_in_length(self):
firstList = SinglyLinkedList()
secondList = SinglyLinkedList()
outputList = SinglyLinkedList()
firstList.populate([1, 1, 8])
secondList.populate([4, 3, 1])
s = Solution(firstList, secondList, outputList)
s.addTwoNonReversedIntegersAsLinkedListsAndCreateNewList()
outputValue = outputList.returnLinkedListAsList()
expectedValue = [5, 4, 9]
self.assertTrue(outputValue == expectedValue,
"Expected: %s, Got: %s" % (expectedValue, outputValue))
def test_delete_head_of_list_with_more_than_one_item(self):
singlyLinkedListObject = SinglyLinkedList()
inputList = [1, 2, 3]
singlyLinkedListObject.populate(inputList)
singlyLinkedListObject.deleteHead()
self.assertFalse(singlyLinkedListObject.isHeadNone(), "Head of non-empty list must NOT be None")
self.assertFalse(singlyLinkedListObject.head == 2, "Expected hea data: %s, Actual head data: %s" %(2, singlyLinkedListObject.head))
singlyLinkedListObject.deleteHead()
self.assertFalse(singlyLinkedListObject.isHeadNone(), "Head of non-empty list must NOT be None")
self.assertFalse(singlyLinkedListObject.head == 3, "Expected hea data: %s, Actual head data: %s" %(3, singlyLinkedListObject.head))
singlyLinkedListObject.deleteHead()
self.assertTrue(singlyLinkedListObject.isHeadNone(), "Head of Empty list must be None")