def testExtendByNonVector(self): vec1 = Vector() vec2 = Vector() vec1.extend(["a", "b"]) vec2.append("a") vec2.append("b") self.assertEqual(vec1, vec2)
def testExtendEmpty(self): vec = Vector() vec.extend(self.bigVec) self.assertEqual(self.bigVec, vec)
def testExtendEmptyByEmpty(self): vec = Vector() vec.extend(Vector()) self.assertEqual(vec, Vector())
class VectorTester(unittest.TestCase): """Test class for testing Vector methods. """ def setUp(self): """ Create several vectors that can be used by any test. """ Array.visible = False self.emptyVec = Vector() self.oneVec = Vector() self.oneVec.append(10) # Create two equal large vectors containing the numbers # 0-BIG_VEC_SIZE-1 We will call methods on bigVec. cleanBigVec # will be used for comparisons... to make sure that bigVec is # not altered by methods that should not change it. self.bigVec = Vector() self.cleanBigVec = Vector() for i in range(BIG_VEC_SIZE): self.bigVec.append(i) self.cleanBigVec.append(i) self.duplicatesVec = Vector() self.duplicatesVec.append("a") self.duplicatesVec.append("b") self.duplicatesVec.append("b") self.duplicatesVec.append("c") #-------------------------------------------------------- #TESTING METHODS FOR LENGTH (and APPEND) #-------------------------------------------------------- def testLengthEmpty(self): self.assertEquals(len(Vector()), 0, "Empty Vector should have length 0.") def testLengthAfterOneAppend(self): self.assertEquals(len(self.oneVec), 1) def testLengthAfterManyAppends(self): self.assertEquals(len(self.bigVec), BIG_VEC_SIZE) def testCorrectFirstItemAfterAppends(self): self.assertEquals(self.bigVec[0], 0) def testCorrectLastItemAfterAppends(self): self.assertEquals(self.bigVec[BIG_VEC_SIZE-1], BIG_VEC_SIZE-1) #-------------------------------------------------------- #TESTING METHODS FOR EQUAL AND NOT EQUAL #-------------------------------------------------------- def testEmptyVecsEqual(self): self.assertEqual(self.emptyVec, Vector()) def testEmptyVecsNotEqual(self): self.assertFalse(self.emptyVec != Vector()) def testEqualNonVec(self): self.assertFalse(self.emptyVec == []) def testNotEqualNonVec(self): self.assertNotEqual(self.emptyVec, []) def testNotEqualsOutOfOrder(self): vec1 = Vector() vec1.append("a") vec1.append("b") vec2 = Vector() vec2.append("b") vec2.append("a") self.assertNotEqual(vec1, vec2) def testEqualsOutOfOrder(self): vec1 = Vector() vec1.append("a") vec1.append("b") vec2 = Vector() vec2.append("b") vec2.append("a") self.assertFalse(vec1 == vec2) def testEqualsDifferentSizes(self): vec = Vector() for i in range(BIG_VEC_SIZE-1): vec.append(i) self.assertFalse(vec == self.bigVec) def testNotEqualsDifferentSizes(self): vec = Vector() for i in range(BIG_VEC_SIZE-1): vec.append(i) self.assertNotEqual(vec, self.bigVec) def testEqualsTrue(self): self.assertEqual(self.bigVec, self.cleanBigVec) def testNotEqualsTrue(self): self.assertFalse(self.bigVec != self.cleanBigVec) def testEqualsSame(self): self.assertEqual(self.bigVec, self.bigVec) def testNotEqualsSame(self): self.assertFalse(self.bigVec != self.bigVec) #-------------------------------------------------------- #TESTING METHODS FOR CONTAINS #-------------------------------------------------------- def testContainsOnEmpty(self): self.assertFalse(10 in self.emptyVec) def testContainsFalse(self): self.assertFalse("a" in self.bigVec) self.assertEqual(self.bigVec, self.cleanBigVec) def testContainsAtStart(self): self.assertTrue(0 in self.bigVec) self.assertEqual(self.bigVec, self.cleanBigVec) def testContainsAtEnd(self): self.assertTrue(BIG_VEC_SIZE - 1 in self.bigVec) self.assertEqual(self.bigVec, self.cleanBigVec) def testContainsMiddle(self): self.assertTrue(5 in self.bigVec) self.assertEqual(self.bigVec, self.cleanBigVec) #-------------------------------------------------------- #TESTING METHODS FOR GETITEM #-------------------------------------------------------- def testGetItemEmptyVec(self): self.assertRaises(IndexError, self.emptyVec.__getitem__, 0) def testGetItemIndexTooSmall(self): self.assertRaises(IndexError, self.bigVec.__getitem__, -BIG_VEC_SIZE - 1) self.assertEqual(self.bigVec, self.cleanBigVec) def testGetItemIndexTooBig(self): self.assertRaises(IndexError, self.bigVec.__getitem__, BIG_VEC_SIZE) self.assertEqual(self.bigVec, self.cleanBigVec) def testGetItemNegativeIndexStart(self): self.assertEqual(self.bigVec[-BIG_VEC_SIZE], 0) self.assertEqual(self.bigVec, self.cleanBigVec) def testGetItemNegativeIndexEnd(self): self.assertEqual(self.bigVec[-1], BIG_VEC_SIZE - 1) self.assertEqual(self.bigVec, self.cleanBigVec) #(tests for append check correct first and last items.) #-------------------------------------------------------- #TESTING METHODS FOR SETITEM #-------------------------------------------------------- def testSetItemEmptyVec(self): self.assertRaises(IndexError, self.emptyVec.__setitem__, 0, "a") def testSetIndexTooSmall(self): self.assertRaises(IndexError, self.bigVec.__setitem__, -BIG_VEC_SIZE - 1, "a") self.assertEqual(self.bigVec, self.cleanBigVec) def testSetIndexTooBig(self): self.assertRaises(IndexError, self.bigVec.__setitem__, BIG_VEC_SIZE, "a") self.assertEqual(self.bigVec, self.cleanBigVec) def testSetFirstItem(self): self.bigVec[0] = "a" self.assertEqual(self.bigVec[0], "a") self.assertEqual(len(self.bigVec), BIG_VEC_SIZE) def testSetLastItem(self): self.bigVec[BIG_VEC_SIZE - 1 ] = "a" self.assertEqual(self.bigVec[BIG_VEC_SIZE - 1], "a") self.assertEqual(len(self.bigVec), BIG_VEC_SIZE) def testSetNegativeIndexStart(self): self.bigVec[-BIG_VEC_SIZE] = "a" self.assertEqual(self.bigVec[-BIG_VEC_SIZE], "a") self.assertEqual(len(self.bigVec), BIG_VEC_SIZE) def testSetNegativeIndexEnd(self): self.bigVec[-1] = "a" self.assertEquals(self.bigVec[-1], "a") self.assertEqual(len(self.bigVec), BIG_VEC_SIZE) #-------------------------------------------------------- #TESTING METHODS FOR STRING #-------------------------------------------------------- def testStringEmpty(self): self.assertEqual(str(self.emptyVec), "[]") def testStringOneVal(self): self.assertEqual(str(self.oneVec), "[10]") def testStringBigVec(self): bigList = range(BIG_VEC_SIZE) self.assertEqual(str(self.bigVec), str(bigList)) #-------------------------------------------------------- #TESTING METHODS FOR GETSLICE #-------------------------------------------------------- def testSliceFirstIndexTooSmall(self): self.assertRaises(IndexError, self.bigVec.getSlice, -BIG_VEC_SIZE - 1, 1) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceFirstIndexTooBig(self): self.assertRaises(IndexError, self.bigVec.getSlice, BIG_VEC_SIZE, 1) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceSecondIndexTooSmall(self): self.assertRaises(IndexError, self.bigVec.getSlice, -BIG_VEC_SIZE - 1, 1) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceSecondIndexTooBig(self): self.assertRaises(IndexError, self.bigVec.getSlice, BIG_VEC_SIZE + 1, 1) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceOutOfOrder(self): self.assertEquals(self.bigVec.getSlice(2, 1), Vector()) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceOutOfOrderNegative(self): self.assertEquals(self.bigVec.getSlice(-1, -2), Vector()) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceSizeOneStart(self): vec = Vector() vec.append(0) self.assertEquals(self.bigVec.getSlice(0, 1), vec) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceSizeOneStartNegative(self): vec = Vector() vec.append(0) self.assertEquals(self.bigVec.getSlice(-BIG_VEC_SIZE,-BIG_VEC_SIZE+1), vec) self.assertEqual(self.bigVec, self.cleanBigVec) def testSliceSizeOneEnd(self): vec = Vector() vec.append(BIG_VEC_SIZE -1) self.assertEquals(self.bigVec.getSlice(BIG_VEC_SIZE-1, BIG_VEC_SIZE), vec) self.assertEqual(self.bigVec, self.cleanBigVec) def testBigSliceMiddle(self): vec = Vector() for i in range(10, BIG_VEC_SIZE - 10): vec.append(i) self.assertEquals(self.bigVec.getSlice(10, BIG_VEC_SIZE - 10), vec) self.assertEqual(self.bigVec, self.cleanBigVec) def testBigSliceMiddleNegative(self): vec = Vector() for i in range(10, BIG_VEC_SIZE - 10): vec.append(i) self.assertEquals(self.bigVec.getSlice(10 - BIG_VEC_SIZE, -10), vec) self.assertEqual(self.bigVec, self.cleanBigVec) #-------------------------------------------------------- #TESTING METHODS FOR ITERATOR #-------------------------------------------------------- def testIteratorBigVec(self): i = 0 for item in self.bigVec: #make sure the correct values are retrieved self.assertEquals(i, item) i += 1 #Make sure the right number of steps took place. self.assertEqual(i, BIG_VEC_SIZE) self.assertEqual(self.bigVec, self.cleanBigVec) def testIteratorBigVecDirectly(self): i = 0 it = iter(self.bigVec) for item in it: self.assertEquals(i, item) i += 1 self.assertEqual(i, BIG_VEC_SIZE) self.assertEqual(self.bigVec, self.cleanBigVec) def testIteratorEmptyVec(self): for _ in self.emptyVec: #Should never get here. Raise an exception if we do. self.assertTrue(False) #-------------------------------------------------------- #TESTING METHODS FOR EXTEND #-------------------------------------------------------- def testExtendByEmpty(self): vec = Vector() for i in range(BIG_VEC_SIZE): vec.append(i) self.bigVec.extend(Vector()) self.assertEqual(self.bigVec, vec) self.assertEqual(self.bigVec, self.cleanBigVec) def testExtendEmpty(self): vec = Vector() vec.extend(self.bigVec) self.assertEqual(self.bigVec, vec) def testExtendEmptyByEmpty(self): vec = Vector() vec.extend(Vector()) self.assertEqual(vec, Vector()) def testExtendBySelf(self): self.assertRaises(NotImplementedError,self.bigVec.extend, self.bigVec ) self.assertEqual(self.bigVec, self.cleanBigVec) def testExtendGood(self): vec = Vector() for i in range(BIG_VEC_SIZE): vec.append(i) vec.append(10) self.bigVec.extend(self.oneVec) self.assertEqual(self.bigVec, vec) def testExtendByNonVector(self): vec1 = Vector() vec2 = Vector() vec1.extend(["a", "b"]) vec2.append("a") vec2.append("b") self.assertEqual(vec1, vec2) #-------------------------------------------------------- #TESTING METHODS FOR INSERT #-------------------------------------------------------- def testInsertIndexTooSmall(self): self.assertRaises(IndexError, self.bigVec.insert, -BIG_VEC_SIZE - 1, "a") self.assertEqual(self.bigVec, self.cleanBigVec) def testInsertIndexTooBig(self): self.assertRaises(IndexError, self.bigVec.insert, BIG_VEC_SIZE + 1, "a") self.assertEqual(self.bigVec, self.cleanBigVec) def testInsertAtStart(self): self.bigVec.insert(0, "a") vec = Vector() vec.append("a") for i in range(BIG_VEC_SIZE): vec.append(i) self.assertEqual(self.bigVec, vec) def testInsertAtStartNegative(self): self.bigVec.insert(-BIG_VEC_SIZE, "a") vec = Vector() vec.append("a") for i in range(BIG_VEC_SIZE): vec.append(i) self.assertEqual(self.bigVec, vec) def testInsertAtEnd(self): self.bigVec.insert(BIG_VEC_SIZE, "a") vec = Vector() for i in range(BIG_VEC_SIZE): vec.append(i) vec.append("a") self.assertEqual(self.bigVec, vec) def testInsertMiddle(self): vec1 = Vector() vec1.append("a") vec1.append("b") vec1.append("c") vec2 = Vector() vec2.append("a") vec2.append("c") vec2.insert(1,"b") self.assertEqual(vec1, vec2) #-------------------------------------------------------- #TESTING METHODS FOR REMOVE #-------------------------------------------------------- def testRemoveEmpty(self): self.assertRaises(ValueError, self.emptyVec.remove, "a") self.assertEqual(len(self.emptyVec), 0) def testRemoveNotIn(self): self.assertRaises(ValueError, self.bigVec.remove, "a") self.assertEqual(self.bigVec, self.cleanBigVec) def testRemoveLast(self): self.oneVec.remove(10) self.assertEqual(self.oneVec, Vector()) def testRemoveAtStart(self): vec = Vector() for i in range(1,BIG_VEC_SIZE): vec.append(i) self.bigVec.remove(0) vec.remove(0) self.assertEqual(vec, self.bigVec) def testRemoveAtEnd(self): vec = Vector() for i in range(BIG_VEC_SIZE-1): vec.append(i) self.bigVec.remove(BIG_VEC_SIZE-1) self.assertEqual(vec, self.bigVec) def testManyRemoves(self): vec = Vector() for i in range(50, BIG_VEC_SIZE): vec.append(i) for i in range(50): self.bigVec.remove(i) self.assertEquals(vec, self.bigVec) def testRemoveWithDuplicates(self): vec = Vector() vec.append("a") vec.append("b") vec.append("c") self.duplicatesVec.remove("b") self.assertEquals(vec, self.duplicatesVec) #-------------------------------------------------------- #TESTING METHODS FOR INDEX #-------------------------------------------------------- def testIndexEmpty(self): self.assertRaises(ValueError, self.emptyVec.index, "a") self.assertEqual(len(self.emptyVec), 0) def testIndexNotIn(self): self.assertRaises(ValueError, self.bigVec.index, "a") self.assertEqual(len(self.emptyVec), 0) def testIndexAtStart(self): self.assertEqual(self.bigVec.index(0), 0) def testIndexAtEnd(self): self.assertEqual(self.bigVec.index(BIG_VEC_SIZE-1), BIG_VEC_SIZE -1) def testIndexDuplicate(self): #should return position of first match self.assertEqual(self.duplicatesVec.index("b"), 1) #-------------------------------------------------------- #TESTING METHODS FOR COUNT #-------------------------------------------------------- #NOT YET IMPLEMENTED! #-------------------------------------------------------- #TESTING METHODS FOR POP #-------------------------------------------------------- def testPop(self): testV = Vector() for i in range(BIG_VEC_SIZE): testV.append(i) testV.pop(5) self.bigVec.pop(5) for i in range(10,20): testV.pop(i) self.bigVec.pop(i) self.assertRaises(IndexError, testV.pop, -7) self.assertRaises(IndexError, testV.pop, BIG_VEC_SIZE + 5) self.assertEqual(testV, self.bigVec) #-------------------------------------------------------- #TESTING METHODS FOR REVERSE #-------------------------------------------------------- def testReverse(self): testV = Vector()