template<typename Array> static void test_reserve(skiatest::Reporter* reporter) { // Test that our allocated space stays >= to the reserve count until the array is filled to // the reserve count for (int reserveCount : {1, 2, 10, 100}) { // Test setting reserve in constructor. Array array1(reserveCount); test_array_reserve(reporter, &array1, reserveCount); // Test setting reserve after constructor. Array array2; array2.reserve(reserveCount); test_array_reserve(reporter, &array2, reserveCount); // Test increasing reserve after constructor. Array array3(reserveCount/2); array3.reserve(reserveCount); test_array_reserve(reporter, &array3, reserveCount); // Test setting reserve on non-empty array. Array array4; array4.push_back_n(reserveCount); array4.reserve(reserveCount); array4.pop_back_n(reserveCount); test_array_reserve(reporter, &array4, 2 * reserveCount); } }
void slavep(int msize){ int srows, i, j, k; MPI_Request reqs[1]; matrix<int> array2(w, w); MPI_Bcast(array2.arrptr(), w*w, MPI_INT, 0, MPI_COMM_WORLD); MPI_Irecv(&srows, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]); MPI_Wait(reqs, MPI_STATUSES_IGNORE); matrix<int> array1(w, w); matrix<int> array3(w, w); MPI_Irecv(array1.arrptr(), srows*w, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]); MPI_Wait(reqs, MPI_STATUSES_IGNORE); for (i = 0; i < srows; i++) { for (j = 0; j < w; j++){ array3[i][j] = 0; for (k = 0; k < w; k++){ array3[i][j] += array1[i][k] * array2[k][j]; } } } MPI_Isend(array3.arrptr(), srows*w, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]); MPI_Wait(&reqs[0], MPI_STATUSES_IGNORE); }
void masterp(int msize, int size){ int workload, extra, offset, srows; int i, j, k; MPI_Request *reqs = new MPI_Request[2 * size]; struct timeval tim1, tim2; matrix<int> array1(msize, msize); matrix<int> array2(msize, msize); matrix<int> array3(msize, msize); for(i = 0; i < msize; i++){ for(j = 0; j < msize; j++){ array1[i][j] = rand()%10; array2[i][j] = rand()%10; } } MPI_Bcast(array2.arrptr(), msize*msize, MPI_INT, MASTER, MPI_COMM_WORLD); workload = msize/(size-1); extra = msize%(size-1); offset = 0; gettimeofday(&tim1, NULL); double t1 = tim1.tv_sec+(tim1.tv_usec/1000000.0); for(i = 1; i < size; i++){ srows = (i <= extra) ? workload+1 : workload; MPI_Isend(&srows, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &reqs[2* i]); MPI_Isend(&array1[offset][0], srows*msize, MPI_INT, i, 0, MPI_COMM_WORLD, &reqs[2*i+1]); offset+=srows; } MPI_Waitall(2 * size -2, reqs + 2, MPI_STATUSES_IGNORE); offset = 0; for(i = 1; i < size; i++){ srows = (i <= extra) ? workload+1 : workload; MPI_Irecv(array3.arrptr() + offset * w, srows * w, MPI_INT, i, 0, MPI_COMM_WORLD, &reqs[i]); offset += srows; } MPI_Waitall(size - 1, reqs + 1, MPI_STATUSES_IGNORE); gettimeofday(&tim2, NULL); double t2 = tim2.tv_sec+(tim2.tv_usec/1000000.0); printf("Total time taken in seconds: %f\n", t2-t1); }
void tst_QVectorArray::create4DArray() { QVector4DArray array; QVERIFY(array.isEmpty()); array.append(1.0f, 2.0f, 3.0f, 4.0f); array.append(3.0f, 4.0f, 5.0f, 6.0f); array.append(QVector4D(5.0f, 6.0f, 7.0f, 8.0f)); QCOMPARE(array.size(), 3); QVERIFY(array[0] == QVector4D(1.0f, 2.0f, 3.0f, 4.0f)); QVERIFY(array[1] == QVector4D(3.0f, 4.0f, 5.0f, 6.0f)); QVERIFY(array[2] == QVector4D(5.0f, 6.0f, 7.0f, 8.0f)); array.append(QVector4D(7.0f, 8.0f, 9.0f, 10.0f), QVector4D(9.0f, 10.0f, 11.0f, 12.0f)); array.append(QVector4D(11.0f, 12.0f, 13.0f, 14.0f), QVector4D(13.0f, 14.0f, 15.0f, 16.0f), QVector4D(15.0f, 16.0f, 17.0f, 18.0f)); array.append(QVector4D(17.0f, 18.0f, 19.0f, 20.0f), QVector4D(19.0f, 20.0f, 21.0f, 22.0f), QVector4D(21.0f, 22.0f, 23.0f, 24.0f)); for (int index = 0; index < array.size(); ++index) { QVERIFY(array[index] == QVector4D(index * 2 + 1, index * 2 + 2, index * 2 + 3, index * 2 + 4)); } QVector4DArray array2(34); QCOMPARE(array2.size(), 34); for (int index = 0; index < array2.size(); ++index) QCOMPARE(array2[index], QVector4D(0.0f, 0.0f, 0.0f, 0.0f)); QVector4DArray array3(15, QVector4D(1.0f, 2.0f, 3.0f, 4.0f)); QCOMPARE(array3.size(), 15); for (int index = 0; index < array3.size(); ++index) QCOMPARE(array3[index], QVector4D(1.0f, 2.0f, 3.0f, 4.0f)); }
void tst_QVectorArray::create2DArray() { QVector2DArray array; QVERIFY(array.isEmpty()); array.append(1.0f, 2.0f); array.append(3.0f, 4.0f); array.append(QVector2D(5.0f, 6.0f)); array.append(QPointF(7.0f, 8.0f)); array.append(QPoint(9, 10)); QCOMPARE(array.size(), 5); QVERIFY(array[0] == QVector2D(1.0f, 2.0f)); QVERIFY(array[1] == QVector2D(3.0f, 4.0f)); QVERIFY(array[2] == QVector2D(5.0f, 6.0f)); QVERIFY(array[3] == QVector2D(7.0f, 8.0f)); QVERIFY(array[4] == QVector2D(9.0f, 10.0f)); array.append(QVector2D(11.0f, 12.0f), QVector2D(13.0f, 14.0f)); array.append(QVector2D(15.0f, 16.0f), QVector2D(17.0f, 18.0f), QVector2D(19.0f, 20.0f)); array.append(QVector2D(21.0f, 22.0f), QVector2D(23.0f, 24.0f), QVector2D(25.0f, 26.0f)); for (int index = 0; index < array.size(); ++index) QVERIFY(array[index] == QVector2D(index * 2 + 1, index * 2 + 2)); QVector2DArray array2(34); QCOMPARE(array2.size(), 34); for (int index = 0; index < array2.size(); ++index) QCOMPARE(array2[index], QVector2D(0.0f, 0.0f)); QVector2DArray array3(15, QVector2D(1.0f, 2.0f)); QCOMPARE(array3.size(), 15); for (int index = 0; index < array3.size(); ++index) QCOMPARE(array3[index], QVector2D(1.0f, 2.0f)); }
void tst_QCustomDataArray::create() { QCustomDataArray array1; QVERIFY(array1.elementType() == QCustomDataArray::Float); QVERIFY(array1.elementSize() == sizeof(float)); QCOMPARE(array1.size(), 0); QCOMPARE(array1.count(), 0); QVERIFY(array1.isEmpty()); array1.setElementType(QCustomDataArray::Vector3D); QVERIFY(array1.elementType() == QCustomDataArray::Vector3D); QVERIFY(array1.elementSize() == sizeof(QVector3D)); QCOMPARE(array1.size(), 0); QCOMPARE(array1.count(), 0); QVERIFY(array1.isEmpty()); QCustomDataArray array2(QCustomDataArray::Vector2D); QVERIFY(array2.elementType() == QCustomDataArray::Vector2D); QVERIFY(array2.elementSize() == sizeof(QVector2D)); QCOMPARE(array2.size(), 0); QCOMPARE(array2.count(), 0); QVERIFY(array2.isEmpty()); QCustomDataArray array3(QCustomDataArray::Vector3D, 20); QVERIFY(array3.elementType() == QCustomDataArray::Vector3D); QVERIFY(array3.elementSize() == sizeof(QVector3D)); QCOMPARE(array3.size(), 20); QCOMPARE(array3.count(), 20); QVERIFY(!array3.isEmpty()); QVERIFY(array3.capacity() >= 20); QCustomDataArray array4(QCustomDataArray::Vector4D, 20); QVERIFY(array4.elementType() == QCustomDataArray::Vector4D); QVERIFY(array4.elementSize() == sizeof(QVector4D)); QCOMPARE(array4.size(), 20); QCOMPARE(array4.count(), 20); QVERIFY(!array4.isEmpty()); array4.append(QVector4D(1.0f, 2.0f, 3.0f, 4.0f)); QCustomDataArray array5(QCustomDataArray::Color, 10); QVERIFY(array5.elementType() == QCustomDataArray::Color); QVERIFY(array5.elementSize() == sizeof(QColor4ub)); QCOMPARE(array5.size(), 10); QCOMPARE(array5.count(), 10); QVERIFY(!array5.isEmpty()); array5.append(Qt::red); array5.setAt(4, Qt::green); QVERIFY(array5.colorAt(4) == Qt::green); QCustomDataArray array6(array5); QVERIFY(array6.elementType() == QCustomDataArray::Color); QVERIFY(array6.elementSize() == sizeof(QColor4ub)); QCOMPARE(array6.size(), 11); QCOMPARE(array6.count(), 11); QVERIFY(!array6.isEmpty()); QVERIFY(array6.colorAt(10) == Qt::red); // Changes element type from Color to Vector4D. array6 = array4; QVERIFY(array6.elementType() == QCustomDataArray::Vector4D); QVERIFY(array6.elementSize() == sizeof(QVector4D)); QCOMPARE(array6.size(), 21); QCOMPARE(array6.count(), 21); QVERIFY(!array6.isEmpty()); QVERIFY(array6.vector4DAt(20) == QVector4D(1.0f, 2.0f, 3.0f, 4.0f)); array6.clear(); QVERIFY(array6.elementType() == QCustomDataArray::Vector4D); QVERIFY(array6.elementSize() == sizeof(QVector4D)); QCOMPARE(array6.size(), 0); QCOMPARE(array6.count(), 0); QVERIFY(array6.isEmpty()); array6.setElementType(QCustomDataArray::Vector3D); QVERIFY(array6.elementType() == QCustomDataArray::Vector3D); QVERIFY(array6.elementSize() == sizeof(QVector3D)); QCOMPARE(array6.size(), 0); QCOMPARE(array6.count(), 0); QVERIFY(array6.isEmpty()); }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Collection_Test")); deletion_func NO_DFUNC = (deletion_func)0; DummyFunctor dummyfunc; { UNBOUNDED_SET unbounded_set; unbounded_set.insert (UglyThing ((void*)&unbounded_set, NO_DFUNC)); unbounded_set.insert (UglyThing ((void*)&dummyfunc, NO_DFUNC)); { for (UNBOUNDED_SET::iterator iterator = unbounded_set.begin (); iterator != unbounded_set.end (); ++iterator) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%x,%x\n"), (*iterator).alloc_, (*iterator).dfunc_)); } } unbounded_set.insert (UglyThing (0, NO_DFUNC)); unbounded_set.remove (UglyThing ((void*)&dummyfunc, NO_DFUNC)); { UNBOUNDED_SET_ITERATOR iterator (unbounded_set); while (!iterator.done ()) { DATA *data = 0; iterator.next (data); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%x,%x\n"), data->alloc_, data->dfunc_)); iterator.advance (); } } iterate_const (unbounded_set); unbounded_set.reset (); { DATA *data; UNBOUNDED_SET_ITERATOR i (unbounded_set); while (i.next (data) != 0) { ACE_DEBUG ((LM_DEBUG, "%x,%x\n", data->alloc_, data->dfunc_)); i.advance (); } } iterate_const (unbounded_set); } { ARRAY array; } { ARRAY array (0); } { ARRAY array1; array1.size (2); array1[0] = 4; array1[1] = 4; ARRAY array2 (2, 4); ARRAY array3 (array2); ARRAY array4; array4 = array2; ACE_TEST_ASSERT (array1 == array2); ACE_TEST_ASSERT (array1 == array3); ACE_TEST_ASSERT (array1 == array4); { for (size_t i = 0; i != array1.size (); ++i) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d\n"), array1[i])); ACE_TEST_ASSERT (array1[i] == 4); } } { ARRAY_ITERATOR iterator (array1); while (!iterator.done ()) { ARRAY_DATA *data = 0; iterator.next (data); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d\n"), (*data))); ACE_TEST_ASSERT (*data == 4); iterator.advance (); } } } ACE_END_TEST; return 0; }
void UnitTestDynamicArray::DoTest() { UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array(3); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array.At(0) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array.Capacity() == 3, "DynamicArray()"); UNIT_TEST_POSITIVE(array.Size() == 0, "DynamicArray()"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); int* ptr = NULL; Dia::Core::Containers::DynamicArray<int> array0(ptr, 3); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array1(&cArray1[0], 3); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array2(&cArray2[0], 3); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> array3(&cArray3[0], 2); UNIT_TEST_POSITIVE(array3.Capacity() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(ConstReference data, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray3(cArray3, 2); Dia::Core::Containers::DynamicArray<int> array3(tempArray3); UNIT_TEST_POSITIVE(array3.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.Capacity() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray(cArray, 5); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(tempArray, 2, 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(tempArray, 5, 2); UNIT_TEST_ASSERT_EXPECTED_END(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(tempArray1, 1, 3); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(0) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(1) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(2) == 4, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(tempArray2, 1, 2); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements"); UNIT_TEST_POSITIVE(array2.Capacity() == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int>::ConstIterator iter1(tempArray1.Begin()); Dia::Core::Containers::DynamicArray<int> array1(3, iter1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3, tempArray2.BeginConst()); UNIT_TEST_POSITIVE(!array2.IsFull(), "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3, tempArray1.EndConst()); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 1, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3, tempArray2.EndConst()); UNIT_TEST_POSITIVE(!array2.IsFull(), "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 1, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class AboveTwoFilter { public: bool Evaluate(const int& currentIter)const { return (currentIter > 2); }; }; AboveTwoFilter filter1; int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5, tempArray1.BeginConst(), filter1); UNIT_TEST_POSITIVE(!array1.IsFull(), "DynamicArray(ConstIterator& iter, const EvaluateFunctor& filter)"); UNIT_TEST_POSITIVE(array1.Capacity() == 5, "DynamicArray(ConstIterator& iter, const EvaluateFunctor& filter)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor& filter )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(1) == 4, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(2) == 5, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(4) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); int* ptr = NULL; Dia::Core::Containers::DynamicArray<int> array0(3); array0.Assign(ptr, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(&cArray1[0], 10); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(&cArray1[0], 3); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(&cArray2[0], 3); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> array3(3); array3.Assign(&cArray3[0], 2); UNIT_TEST_POSITIVE(!array3.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(cArray1, 10); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> tempArray1; tempArray1.Reserve(3); tempArray1.Assign(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray3; tempArray3.Reserve(3); tempArray3.Assign(cArray3, 2); Dia::Core::Containers::DynamicArray<int> array3(tempArray3); UNIT_TEST_POSITIVE(!array3.IsFull(), "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 3, "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1; array1.Reserve(5); array1.Assign(tempArray1); UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray(cArray, 5); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 2, 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 5, 2); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 2, 10); UNIT_TEST_ASSERT_EXPECTED_END(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1, 1, 3); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(0) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(1) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(2) == 4, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2, 1, 2); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1.BeginConst()); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2.BeginConst()); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1.EndConst()); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2.EndConst()); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class AboveTwoFilter { public: bool Evaluate(const int& currentIter)const { return (currentIter > 2); }; }; AboveTwoFilter filter1; int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5); array1.Assign(tempArray1.BeginConst(), filter1); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(1) == 4, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(2) == 5, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(4) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5); array1 = tempArray1; UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray opertor="); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2 = tempArray2; UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray opertor="); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array2(array1); Dia::Core::Containers::DynamicArray<int> array3(array1, 1, 3); UNIT_TEST_POSITIVE(array1 == array2, "DynamicArray opertor=="); UNIT_TEST_NEGATIVE(array1 == array3, "DynamicArray opertor=="); UNIT_TEST_POSITIVE(array1 != array3, "DynamicArray opertor!="); UNIT_TEST_NEGATIVE(array1 != array2, "DynamicArray opertor!="); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1[-1]; UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1[6]; UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1.At(-1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1.At(6); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1[0] == array1.At(0), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[1] == array1.At(1), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[2] == array1.At(2), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[3] == array1.At(3), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[4] == array1.At(4), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1.Front() == array1.At(0), "DynamicArray Front"); UNIT_TEST_POSITIVE(array1.Back() == array1.At(4), "DynamicArray Back"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); UNIT_TEST_POSITIVE(&array1[0] == array1.IteratorAt(0).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[1] == array1.IteratorAt(1).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[2] == array1.IteratorAt(2).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[3] == array1.IteratorAt(3).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[4] == array1.IteratorAt(4).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(array1.Begin() == array1.IteratorAt(0), "DynamicArray Begin"); UNIT_TEST_POSITIVE(array1.BeginConst() == array1.IteratorAtConst(0), "DynamicArray BeginConst"); UNIT_TEST_POSITIVE(&array1[0] == array1.ReverseIteratorAt(0).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[1] == array1.ReverseIteratorAt(1).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[2] == array1.ReverseIteratorAt(2).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[3] == array1.ReverseIteratorAt(3).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[4] == array1.ReverseIteratorAt(4).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(array1.End() == array1.ReverseIteratorAt(4), "DynamicArray End"); UNIT_TEST_POSITIVE(array1.EndConst() == array1.ReverseIteratorAtConst(4), "DynamicArray EndConst"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 1, 3, 3, 3, 4}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(1) == 2, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(2) == 1, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(3) == 4, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(4) == 2, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(5) == 1, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(6) == 0, "DynamicArray FrequencyOfElement"); Dia::Core::Containers::DynamicArray<int> arrayUnique(10); array1.UniqueElements(arrayUnique); UNIT_TEST_POSITIVE(arrayUnique.Size() == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[0] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[1] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[2] == 3, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[3] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[4] == 5, "DynamicArray numberOfUniqueElements"); Dia::Core::Containers::DynamicArray<int> arrayFreqUnique(10); Dia::Core::Containers::DynamicArray<int> arrayFreq(10); array1.FrequencyUniqueElements(arrayFreqUnique, arrayFreq); UNIT_TEST_POSITIVE(arrayFreqUnique.Size() == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[0] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[1] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[2] == 3, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[3] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[4] == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[0] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[1] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[2] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[3] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[4] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class IncreasingOrder { public: bool GreaterThen(const int& object1, const int& object2)const { return (object1 > object2); } bool LessThen(const int& object1, const int& object2)const { return (object1 < object2); } bool Equal(const int& object1, const int& object2)const { return (object1 == object2); } }; IncreasingOrder order; int cArray1[10] = {1, 2, 3, 4, 5, 1, 3, 3, 3, 4}; int cArray2[5] = {4, 2, 5, 1, 3}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); Dia::Core::Containers::DynamicArray<int> array2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array3(cArray1, 10); Dia::Core::Containers::DynamicArray<int> array4(cArray2, 5); array1.Sort(order); UNIT_TEST_POSITIVE(array1[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[1] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[2] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[3] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[4] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[5] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[6] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[7] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[8] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[9] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1.IsSorted(order), "DynamicArray Sort"); array2.Sort(order); UNIT_TEST_POSITIVE(array2[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[1] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[2] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[3] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[4] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2.IsSorted(order), "DynamicArray Sort"); array3.Sort(); UNIT_TEST_POSITIVE(array3[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[1] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[2] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[3] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[4] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[5] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[6] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[7] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[8] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[9] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3.IsSorted(), "DynamicArray Sort"); array4.Sort(); UNIT_TEST_POSITIVE(array4[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[1] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[2] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[3] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[4] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4.IsSorted(), "DynamicArray Sort"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; int cArray2[5] = {4, 2, 5, 1, 3}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array2(cArray2, 5); array1.Swap(array2); UNIT_TEST_POSITIVE(array1[0] == 4, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[1] == 2, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[2] == 5, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[3] == 1, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[4] == 3, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[0] == 1, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[1] == 2, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[2] == 3, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[3] == 4, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[4] == 5, "DynamicArray Swap"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); class OneLess { public: bool Equal(const int& object1, const int& object2)const { return (object1 == (object2 - 1)); } }; OneLess oneLess; UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, -2, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, 3, 1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, 0, 17); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1.FindIndex(5) == 4 , "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(7) == 9, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(10) == -1, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, 0, 7) == 4 , "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, 6, 9) == 8, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(1, 6, 9) == -1, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(5, oneLess) == 3 , "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(7, oneLess) == 5, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(10, oneLess) == -1, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, oneLess, 0, 7) == 3 , "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, oneLess, 6, 9) == 7, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(1, oneLess, 6, 9) == -1, "DynamicArray FindBetweenIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); class OneLess { public: bool Equal(const int& object1, const int& object2)const { return (object1 == (object2 - 1)); } }; OneLess oneLess; UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, -2, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, 3, 1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, 0, 17); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1.FindLastIndex(5) == 8 , "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(3) == 6, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(10) == -1, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(4, 0, 7) == 7 , "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, 6, 9) == 8, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(1, 6, 9) == -1, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(5, oneLess) == 7 , "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(7, oneLess) == 5, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(10, oneLess) == -1, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, oneLess, 0, 7) == 7 , "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, oneLess, 6, 9) == 7, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(1, oneLess, 6, 9) == -1, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); array1.Sort(); class Equality { public: bool GreaterThen(const int& object1, const int& object2)const { return (object1 > object2); } bool LessThen(const int& object1, const int& object2)const { return (object1 < object2); } bool Equal(const int& object1, const int& object2)const { return (object1 == object2); } }; Equality equality; UNIT_TEST_POSITIVE(array1.IsSorted(), "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(5) == 6 , "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(3) == 2, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(10) == -1, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(4) == 5 , "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(5) == 7, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(10) == -1, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(5, equality) == 6 , "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(3, equality) == 2, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(10, equality) == -1, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(4, equality) == 5 , "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(5, equality) == 7, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(10, equality) == -1, "DynamicArray FindLastSortedIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class Eval { public: float Evaluate(const int& object1)const { return static_cast<float>(object1); }; }; Eval eval; int cArray1[10] = {1, 2, 3, 9, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); UNIT_TEST_POSITIVE(array1.HighestEvalutionIndex(eval) == 3, "DynamicArray HighestEvalutionIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class Foo { public: Foo(): mSomeData(true), mMoreData(21.0f){} bool SomeData(){return mSomeData;} float MoreData(){return mMoreData;} bool mSomeData; float mMoreData; }; Foo cArray1[3]; Dia::Core::Containers::DynamicArray<Foo> array1(cArray1, 3); cArray1[0].mSomeData = false; cArray1[0].mMoreData = 11.0f; UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(0).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(1).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(2).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(0).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(1).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(2).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Add(1); array1.AddDefault(); array1.Add(2); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray Add"); UNIT_TEST_POSITIVE(array1.At(1) == 0, "DynamicArray AddDefault"); UNIT_TEST_POSITIVE(array1.At(2) == 2, "DynamicArray Add"); Dia::Core::Containers::DynamicArray<int> array2(3); array2.FillDefault(); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array2.At(0) == 0, "DynamicArray FillDefault"); UNIT_TEST_POSITIVE(array2.At(1) == 0, "DynamicArray FillDefault"); UNIT_TEST_POSITIVE(array2.At(2) == 0, "DynamicArray FillDefault"); Dia::Core::Containers::DynamicArray<int> array3(3); array3.Fill(11); UNIT_TEST_POSITIVE(array3.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array3.At(0) == 11, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array3.At(1) == 11, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array3.At(2) == 11, "DynamicArray Fill"); Dia::Core::Containers::DynamicArray<int> array4(3); array4.FillDefault(); UNIT_TEST_POSITIVE(array4.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array4.At(0) == 0, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array4.At(1) == 0, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array4.At(2) == 0, "DynamicArray Fill"); Dia::Core::Containers::DynamicArray<int> array5(5); array5.AddDefault(); array5.AddAt(1, 0); array5.AddAt(2, 1); array5.AddAt(3, 1); array5.AddAt(4, 3); UNIT_TEST_POSITIVE(array5.Size() == 5, "DynamicArray Add"); UNIT_TEST_POSITIVE(array5.At(0) == 1, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(1) == 3, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(2) == 2, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(3) == 4, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(4) == 0, "DynamicArray Fill"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Fill(11); array1.Remove(); UNIT_TEST_POSITIVE(array1.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array1.At(0) == 11, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array1.At(1) == 11, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Add(1); array2.Add(2); array2.Add(3); array2.RemoveAt(1); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array3(3); array3.Add(1); array3.Add(2); array3.Add(3); array3.RemoveFirst(2); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array3.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array4(3); array4.Add(1); array4.Add(2); array4.Add(3); array4.RemoveLast(2); UNIT_TEST_POSITIVE(array4.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array4.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array4.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array4.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array5(3); array5.Add(1); array5.Add(2); array5.Add(3); array5.RemoveAll(); UNIT_TEST_POSITIVE(array5.Size() == 0, "DynamicArray Remove"); Dia::Core::Containers::DynamicArray<int> array6(5); array6.Add(1); array6.Add(2); array6.Add(3); array6.Add(2); array6.Add(3); array6.RemoveAll(2); UNIT_TEST_POSITIVE(array6.Size() == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(2) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array6.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); class Comparisson { public: bool Evaluate(const int&a)const { return (a == 2); }; }; Comparisson compare; Dia::Core::Containers::DynamicArray<int> array7(5); array7.Add(1); array7.Add(2); array7.Add(3); array7.Add(2); array7.Add(3); array7.RemoveAll(compare); UNIT_TEST_POSITIVE(array7.Size() == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(2) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array7.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); mState = kFinished; }