Exemplo n.º 1
0
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);
    }
}
Exemplo n.º 2
0
void profile_for_type(const T& elem, const std::string& type,
  const int add_flops, const int multiply_flops)
{
  std::cout << "Profiling for array type " << type << "." << std::endl;

  unsigned int n = 100;
  pyQCD::LexicoLayout layout(std::vector<unsigned int>{n});
  pyQCD::Lattice<T, Alloc> array1(layout, elem);
  decltype(array1) array2(layout, elem);
  decltype(array1) array3(layout, elem);
  decltype(array1) result(layout, elem);

  std::cout << "Profiling f(x, y, z) = x + y + z:" << std::endl;
  benchmark([&] () {
    result = array1 + array2 + array3;
  }, 2 * add_flops * n, 1000000);

  std::cout << "Profiling f(x, y) = 5.0 * x + y:" << std::endl;
  benchmark([&] () {
    result = 5.0 * array1 + array2;
  }, 2 * add_flops * n, 1000000);

  std::cout << "Profiling f(x, y, z) = x * y + z:" << std::endl;
  benchmark([&] () {
    result = array1 * array2 + array3;
  }, (add_flops + multiply_flops) * n, 1000000);
  
  std::cout << std::endl;
}
Exemplo n.º 3
0
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);
}
Exemplo n.º 4
0
void UT_array_erase(const char* params)
{
	Lumix::DefaultAllocator allocator;
	Lumix::Array<int> array1(allocator);

	for (int i = 0; i < 20; ++i)
	{
		array1.push(i * 5);
	}

	array1.eraseItem(25);
	LUMIX_EXPECT(array1.size() == 19);
	for (int i = 0; i < 18; ++i)
	{
		LUMIX_EXPECT(array1[i] < array1[i + 1]);
	}

	array1.erase(10);
	for (int i = 0; i < 17; ++i)
	{
		LUMIX_EXPECT(array1[i] < array1[i + 1]);
	}
	LUMIX_EXPECT(array1.size() == 18);

	array1.eraseFast(7);
	LUMIX_EXPECT(array1.size() == 17);

	array1.eraseItemFast(30);
	LUMIX_EXPECT(array1.size() == 16);

	array1.pop();
	LUMIX_EXPECT(array1.size() == 15);
}
Exemplo n.º 5
0
void merge_sort(std::vector<T>& array) {
    if (1 < array.size()) {
        std::vector<T> array1(array.begin(), array.begin() + array.size() / 2);
        merge_sort(array1);
        std::vector<T> array2(array.begin() + array.size() / 2, array.end());
        merge_sort(array2);
        merge(array, array1, array2);
    }
}
TEST(ArrayTypeTest, MoveConstructor) {

	type::const_t_array<float> array1({1, 2, 3});
	type::const_t_array<float> array2(std::move(array1));
	auto read_array(type::read(array2));
	EXPECT_EQ(1, read_array[0]);
	EXPECT_EQ(2, read_array[1]);
	EXPECT_EQ(3, read_array[2]);
	ASSERT_EQ(3, array2.size());
	ASSERT_EQ(0, array1.size());
}
Exemplo n.º 7
0
void computeTest(GLuint a_prog)
{
  int N = 1024;
  std::vector<float> array1(N);
  std::vector<float> array2(N);

  for(int i=0;i<array1.size();i++)
  {
    array1[i] = float(i)/10.0f;
    array2[i] = 0.0f;
  }

  // create buffers
  //
  GLuint buf1;
  glGenBuffers(1, &buf1);
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, buf1);                                                     CHECK_GL_ERRORS;
  glBufferData(GL_SHADER_STORAGE_BUFFER, array1.size()*sizeof(float), &array1[0], GL_STATIC_DRAW ); CHECK_GL_ERRORS; // copy data from CPU to GPU

  GLuint buf2;
  glGenBuffers(1, &buf2);
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, buf2);                                                    CHECK_GL_ERRORS;
  glBufferData(GL_SHADER_STORAGE_BUFFER, array2.size()*sizeof(float), &array2[0], GL_STATIC_DRAW); CHECK_GL_ERRORS; // copy data from CPU to GPU
  //glBufferData(GL_SHADER_STORAGE_BUFFER, array2.size()*sizeof(float), NULL, GL_STATIC_DRAW ); CHECK_GL_ERRORS; // don't do that! Seems to be an OpenGL driver bug


  // launch threads
  //
  glUseProgram(a_prog);  CHECK_GL_ERRORS;

  glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, buf1);  CHECK_GL_ERRORS; 
  glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buf2);  CHECK_GL_ERRORS; 
  
  glDispatchCompute(array1.size()/256, 1, 1);     CHECK_GL_ERRORS; // 256 is a worgroup size of g_programCompute.program
  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT); CHECK_GL_ERRORS; // seems not really needed but it will be better call this function before you read data

  // read back data
  //
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, buf2); 
  void* resultData = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, array2.size()*sizeof(float), GL_MAP_READ_BIT); CHECK_GL_ERRORS;
  memcpy(&array2[0], resultData, array2.size()*sizeof(float));
  glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); CHECK_GL_ERRORS;

  // print results
  //
  std::cout << "CS, output buffer values: " << std::endl;
  for(int i=0;i<10;i++)
    std::cout << array2[i] << std::endl;
  
  // delete resources
  //
  glDeleteBuffers(1, &buf1); CHECK_GL_ERRORS;
  glDeleteBuffers(1, &buf2); CHECK_GL_ERRORS;
}
Exemplo n.º 8
0
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);
}
Exemplo n.º 9
0
void UT_array(const char* params)
{
	Lumix::DefaultAllocator allocator;

	Lumix::Array<int> array1(allocator);
	LUMIX_EXPECT(array1.empty());
	LUMIX_EXPECT(array1.size() == 0);
	array1.reserve(128);
	LUMIX_EXPECT(array1.size() == 0);
	LUMIX_EXPECT(array1.capacity() == 128);
	array1.reserve(256);
	LUMIX_EXPECT(array1.capacity() == 256);
	array1.reserve(64);
	LUMIX_EXPECT(array1.capacity() >= 64);
	LUMIX_EXPECT(array1.size() == 0);

	for (int i = 0; i < 10; ++i)
	{
		array1.push(i * 2);
		LUMIX_EXPECT(array1[i] == i * 2);
		LUMIX_EXPECT(array1.back() == i * 2);
		LUMIX_EXPECT(array1.indexOf(i*2) == i);
	}
	LUMIX_EXPECT(array1.size() == 10);

	for (int i = 0; i < 10; ++i)
	{
		LUMIX_EXPECT(array1[i] == i * 2);
	}

	array1.clear();
	LUMIX_EXPECT(array1.size() == 0);
	LUMIX_EXPECT(array1.empty());

	array1.resize(10);
	LUMIX_EXPECT(array1.size() == 10);

	array1.insert(0, 123);
	LUMIX_EXPECT(array1.size() == 11);
	LUMIX_EXPECT(array1[0] == 123);

	Lumix::Array<int> array2(allocator);
	array1.swap(array2);
	LUMIX_EXPECT(array2.size() == 11);
	LUMIX_EXPECT(array1.size() == 0);
}
Exemplo n.º 10
0
int main(void){
	//Stack allocated array raw1 and its stack allocated Base objects.
	Base raw1[]={Base("one"),Base("two")};
	//Heap allocated array raw2 and its heap allocated Base objects
	Base* raw2=new Base[3];
	std::cout<<"3 dtor calls will follow shortly."<<std::endl;
	//forgetting to delete with [] operator will leak the all but raw2[0]
	delete [] raw2;

	std::cout<<"scoped_array init #1"<<std::endl;
	boost::scoped_array<Base> array1(new Base[2]);
	std::cout<<"scoped_array init #2"<<std::endl;
	Base *raw3=new Base[2];
	boost::scoped_array<Base> array2(raw3);

	std::cout<<"exiting main..."<<std::endl;
	return 0;
} 
Exemplo n.º 11
0
int main() {
	RLIdentRegister* iregister = new RLIdentRegister();
    RLType::setRegister(iregister);

    RLArray array1(RLType::Number);
    RLArray array2(RLType::Number);

    array1.setElem(1,&RLNumber(100));
    array1.setElem(2,&RLNumber(101));

    array2.applyBinary(assign,&array1);

    array1.getElem(1)->applyUnary(increment);

    array1.print();
    array2.print();

	delete iregister;
}
        pilo::i32_t functional_test_construct(void* param)
        {
            M_UNUSED(param);

            fixed_array<testing_pod_info,13>      array;
            if (array.size() != 0)
            {
                return -1;
            }

            testing_pod_info  info[13];
            for (int i = 0; i < 13; i++)
            {
                info[i].m_id = i;
            }
            fixed_array<testing_pod_info, 13>      array1(info, 13, false);
            if (array1.size() != 13)
            {
                return -20;
            }
            for (int i = 0; i < (int) array1.size(); i++)
            {
                if (array1[i].m_id != i)
                {
                    return -1000 + i;
                }
            }
           
            fixed_array<testing_pod_info, 12>      array2(info, 13, true);
            if (array2.size() != 12)
            {
                return -30;
            }
            for (int i = 0; i < (int) array2.size(); i++)
            {
                if (array2[i].m_id != i)
                {
                    return -2000 + i;
                }
            }
          
            return 0;
        }
Exemplo n.º 13
0
void testTransactionManager() {
	printf("%s\n", "testTransactionManager");

	// Insert a document in wal
	BaseTransaction* wal = new BaseTransaction(_controller);
	wal->dropNamespace("db", "mtx");

	TransactionManager* manager = new TransactionManager(wal);

	BSONObj testA;
	testA.add("cod", 1);
	testA.add("name", "William");
	wal->insert("db", "mtx", &testA);

	std::string* t1 = uuid();

	StdTransaction* transaction = manager->getTransaction(*t1);
	std::auto_ptr<BSONArrayObj> array(transaction->find("db", "mtx", "*", "$'cod' == 1"));
	BSONObj* obj1up = array->get(0);
	obj1up->add("lastName", "Shakespeare");
	transaction->update("db", "mtx", obj1up);

	std::auto_ptr<BSONArrayObj> array0(wal->find("db", "mtx", "*", "$'cod' == 1"));
	BSONObj* origin1 = array0->get(0); 
	TEST_ASSERT(!origin1->has("lastName"));

	std::auto_ptr<BSONArrayObj> array1(transaction->find("db", "mtx", "*", "$'cod' == 1"));
	BSONObj* objtx1 = array1->get(0);
	TEST_ASSERT(objtx1->has("lastName"));

	transaction->commit();
	manager->dropTransaction(*t1);

	std::auto_ptr<BSONArrayObj> array2(wal->find("db", "mtx", "*", "$'cod' == 1"));
	BSONObj* origin2 = array2->get(0);
	TEST_ASSERT(origin2->has("lastName"));

	delete t1;
	delete manager;
	printf("%s\n", "~testTransactionManager");
}
Exemplo n.º 14
0
FX_BOOL color::equal(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
{
	v8::Isolate* isolate = GetIsolate(cc);
	if (params.size() < 2) return FALSE;

	CJS_Array array1(isolate), array2(isolate);

	if (!params[0].ConvertToArray(array1)) return FALSE;
	if (!params[1].ConvertToArray(array2)) return FALSE;

	CPWL_Color color1;
	CPWL_Color color2;

	ConvertArrayToPWLColor(array1, color1);
	ConvertArrayToPWLColor(array2, color2);

	color1.ConvertColorType(color2.nColorType);

	vRet = color1 == color2;
	return TRUE;
}
Exemplo n.º 15
0
// a utility function to compare two parameter arrays
::testing::AssertionResult compareParameterArrays(std::shared_ptr<Region> region1,
                                                  std::shared_ptr<Region> region2,
                                                  std::string parameter,
                                                  NTA_BasicType type) {
  UInt32 *buf1;
  UInt32 *buf2;
  Real32 *buf3;
  Real32 *buf4;
  Real64 *buf5;
  Real64 *buf6;
  Byte   *buf7;
  Byte   *buf8;
  Array array1(type);
  Array array2(type);
  region1->getParameterArray(parameter, array1);
  region2->getParameterArray(parameter, array2);


  if (type != array1.getType())
    return ::testing::AssertionFailure()
           << "Failure: Original Array1 for parameter '" << parameter
           << "' is not the expected type. expected: "
           << BasicType::getName(type) << ", found: "
          << BasicType::getName(array1.getType());
  if (type != array2.getType())
    return ::testing::AssertionFailure()
           << "Failure: Restored Array2 for parameter '" << parameter
           << "' is not the expected type. expected: "
           << BasicType::getName(type) << ", found: "
          << BasicType::getName(array1.getType());

  size_t len1 = array1.getCount();
  size_t len2 = array2.getCount();
  if (len1 != len2) {
    return ::testing::AssertionFailure()
           << "Failure: Arrays for parameter '" << parameter
           << "' are not the same length.";
  }
  switch (type) {
  case NTA_BasicType_UInt32:
    buf1 = (UInt32 *)array1.getBuffer();
    buf2 = (UInt32 *)array2.getBuffer();
    for (size_t i = 0; i < len1; i++) {
      if (buf1[i] != buf2[i]) {
        return ::testing::AssertionFailure()
               << "Failure: Array element for parameter '" << parameter << "["
               << i << "]' is not the same after restore.";
      }
    }
    break;

  case NTA_BasicType_Real32:
    buf3 = (Real32 *)array1.getBuffer();
    buf4 = (Real32 *)array2.getBuffer();
    for (size_t i = 0; i < len1; i++) {
      if (buf3[i] != buf4[i]) {
        return ::testing::AssertionFailure()
               << "Failure: Array element for parameter '" << parameter << "["
               << i << "]' is not the same after restore.";
      }
    }
    break;

  case NTA_BasicType_Real64:
    buf5 = (Real64 *)array1.getBuffer();
    buf6 = (Real64 *)array2.getBuffer();
    for (size_t i = 0; i < len1; i++) {
      if (buf5[i] != buf6[i]) {
        return ::testing::AssertionFailure()
               << "Failure: Array element for parameter '" << parameter << "["
               << i << "]' is not the same after restore.";
      }
    }
    break;
  case NTA_BasicType_Byte:
  case NTA_BasicType_SDR:
    buf7 = (Byte *)array1.getBuffer();
    buf8 = (Byte *)array2.getBuffer();
    for (size_t i = 0; i < len1; i++) {
      if (buf7[i] != buf8[i]) {
        return ::testing::AssertionFailure()
               << "Failure: Array element for parameter '" << parameter << "["
               << i << "]' is not the same after restore.";
      }
    }
    break;
  default:
    break;
  } // end switch
  return ::testing::AssertionSuccess();
}
Exemplo n.º 16
0
DEF_TEST(SkSLMemoryLayout430Test, r) {
    SkSL::Context context;
    SkSL::MemoryLayout layout(SkSL::MemoryLayout::k430_Standard);

    // basic types
    REPORTER_ASSERT(r,  4 == layout.size(*context.fFloat_Type));
    REPORTER_ASSERT(r,  8 == layout.size(*context.fVec2_Type));
    REPORTER_ASSERT(r, 12 == layout.size(*context.fVec3_Type));
    REPORTER_ASSERT(r, 16 == layout.size(*context.fVec4_Type));
    REPORTER_ASSERT(r,  4 == layout.size(*context.fInt_Type));
    REPORTER_ASSERT(r,  8 == layout.size(*context.fIVec2_Type));
    REPORTER_ASSERT(r, 12 == layout.size(*context.fIVec3_Type));
    REPORTER_ASSERT(r, 16 == layout.size(*context.fIVec4_Type));
    REPORTER_ASSERT(r,  1 == layout.size(*context.fBool_Type));
    REPORTER_ASSERT(r,  2 == layout.size(*context.fBVec2_Type));
    REPORTER_ASSERT(r,  3 == layout.size(*context.fBVec3_Type));
    REPORTER_ASSERT(r,  4 == layout.size(*context.fBVec4_Type));
    REPORTER_ASSERT(r, 16 == layout.size(*context.fMat2x2_Type));
    REPORTER_ASSERT(r, 32 == layout.size(*context.fMat2x4_Type));
    REPORTER_ASSERT(r, 48 == layout.size(*context.fMat3x3_Type));
    REPORTER_ASSERT(r, 32 == layout.size(*context.fMat4x2_Type));
    REPORTER_ASSERT(r, 64 == layout.size(*context.fMat4x4_Type));
    REPORTER_ASSERT(r,  4 == layout.alignment(*context.fFloat_Type));
    REPORTER_ASSERT(r,  8 == layout.alignment(*context.fVec2_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fVec3_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fVec4_Type));
    REPORTER_ASSERT(r,  4 == layout.alignment(*context.fInt_Type));
    REPORTER_ASSERT(r,  8 == layout.alignment(*context.fIVec2_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fIVec3_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fIVec4_Type));
    REPORTER_ASSERT(r,  1 == layout.alignment(*context.fBool_Type));
    REPORTER_ASSERT(r,  2 == layout.alignment(*context.fBVec2_Type));
    REPORTER_ASSERT(r,  4 == layout.alignment(*context.fBVec3_Type));
    REPORTER_ASSERT(r,  4 == layout.alignment(*context.fBVec4_Type));
    REPORTER_ASSERT(r,  8 == layout.alignment(*context.fMat2x2_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fMat2x4_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fMat3x3_Type));
    REPORTER_ASSERT(r,  8 == layout.alignment(*context.fMat4x2_Type));
    REPORTER_ASSERT(r, 16 == layout.alignment(*context.fMat4x4_Type));

    // struct 1
    std::vector<SkSL::Type::Field> fields1;
    fields1.emplace_back(SkSL::Modifiers(), SkString("a"), context.fVec3_Type.get());
    SkSL::Type s1(SkSL::Position(), SkString("s1"), fields1);
    REPORTER_ASSERT(r, 16 == layout.size(s1));
    REPORTER_ASSERT(r, 16 == layout.alignment(s1));

    fields1.emplace_back(SkSL::Modifiers(), SkString("b"), context.fFloat_Type.get());
    SkSL::Type s2(SkSL::Position(), SkString("s2"), fields1);
    REPORTER_ASSERT(r, 16 == layout.size(s2));
    REPORTER_ASSERT(r, 16 == layout.alignment(s2));

    fields1.emplace_back(SkSL::Modifiers(), SkString("c"), context.fBool_Type.get());
    SkSL::Type s3(SkSL::Position(), SkString("s3"), fields1);
    REPORTER_ASSERT(r, 32 == layout.size(s3));
    REPORTER_ASSERT(r, 16 == layout.alignment(s3));

    // struct 2
    std::vector<SkSL::Type::Field> fields2;
    fields2.emplace_back(SkSL::Modifiers(), SkString("a"), context.fInt_Type.get());
    SkSL::Type s4(SkSL::Position(), SkString("s4"), fields2);
    REPORTER_ASSERT(r, 4 == layout.size(s4));
    REPORTER_ASSERT(r, 4 == layout.alignment(s4));

    fields2.emplace_back(SkSL::Modifiers(), SkString("b"), context.fVec3_Type.get());
    SkSL::Type s5(SkSL::Position(), SkString("s5"), fields2);
    REPORTER_ASSERT(r, 32 == layout.size(s5));
    REPORTER_ASSERT(r, 16 == layout.alignment(s5));

    // arrays
    SkSL::Type array1(SkString("float[4]"), SkSL::Type::kArray_Kind, *context.fFloat_Type, 4);
    REPORTER_ASSERT(r, 16 == layout.size(array1));
    REPORTER_ASSERT(r, 4 == layout.alignment(array1));
    REPORTER_ASSERT(r, 4 == layout.stride(array1));

    SkSL::Type array2(SkString("vec4[4]"), SkSL::Type::kArray_Kind, *context.fVec4_Type, 4);
    REPORTER_ASSERT(r, 64 == layout.size(array2));
    REPORTER_ASSERT(r, 16 == layout.alignment(array2));
    REPORTER_ASSERT(r, 16 == layout.stride(array2));
}
Exemplo n.º 17
0
//==============================================================================
int checkSharedOwnership(Epetra_Comm& Comm, bool verbose) {
	// check to make sure each function returns 1 when it should
	// check to make sure each function doesn't return 1 when it shouldn't
	int ierr = 0;

	// initialize Map
	const int NumMyElements = 10;
	const long long IndexBase = 0;
	Epetra_Map Map1((long long) -1, NumMyElements, IndexBase, Comm);
	// initialize Graphs
	const int NumIndicesPerRow = 5;
	Epetra_CrsGraph SoleOwner(Copy, Map1, Map1, NumIndicesPerRow);
	Epetra_CrsGraph SharedOrig(Copy, Map1, Map1, NumIndicesPerRow);
	Epetra_CrsGraph SharedOwner(SharedOrig);
	// arrays used by Insert & Remove
	Epetra_IntSerialDenseVector array1(2);
	array1[0] = NumIndicesPerRow / 2;
	array1[1] = array1[0] + 1;
	Epetra_LongLongSerialDenseVector array2(NumIndicesPerRow);
	for(int i = 0; i < NumIndicesPerRow; i++)
		array2[i] = i;
	// output variables (declaring them here lets us comment out indiv. tests)
	int soleOutput, sharedOutput;

	// InsertMyIndices
	if(verbose) cout << "InsertMyIndices..." << endl;
	soleOutput = SoleOwner.InsertMyIndices(0, 2, array1.Values());
	sharedOutput = SharedOwner.InsertMyIndices(0, 2, array1.Values());
	EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// SortIndices
	//if(verbose) cout << "SortIndices..." << endl;
	//soleOutput = SoleOwner.SortIndices();
	//sharedOutput = SharedOwner.SortIndices();
	//EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	//EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
	//if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// RemoveRedundantIndices
	//if(verbose) cout << "RemoveRedundantIndices..." << endl;
	//SoleOwner.InsertGlobalIndices(0, 1, array1.Values());
	//SharedOwner.InsertGlobalIndices(0, 1, array1.Values());
	//soleOutput = SoleOwner.RemoveRedundantIndices();
	//sharedOutput = SharedOwner.RemoveRedundantIndices();
	//EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	//EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
	//if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// FillComplete (#1)
	if(verbose) cout << "FillComplete..." << endl;
	soleOutput = SoleOwner.FillComplete();
	sharedOutput = SharedOwner.FillComplete();
	EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// OptimizeStorage
	if(verbose) cout << "OptimizeStorage..." << endl;
	soleOutput = SoleOwner.OptimizeStorage();
	sharedOutput = SharedOwner.OptimizeStorage();
	EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == 0), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// RemoveMyIndices (#1)
	if(verbose) cout << "RemoveMyIndices..." << endl;
	soleOutput = SoleOwner.RemoveMyIndices(0, 1, &array1[1]);
	sharedOutput = SharedOwner.RemoveMyIndices(0, 1, &array1[1]);
	EPETRA_TEST_ERR(!(soleOutput == -1), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == -1), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// RemoveMyIndices (#2)
	if(verbose) cout << "RemoveMyIndices(#2)..." << endl;
	soleOutput = SoleOwner.RemoveMyIndices(0);
	sharedOutput = SharedOwner.RemoveMyIndices(0);
	EPETRA_TEST_ERR(!(soleOutput == -1), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == -1), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	// FillComplete (#2)
	if(verbose) cout << "FillComplete(#2)..." << endl;
	soleOutput = SoleOwner.FillComplete(SoleOwner.DomainMap(), SoleOwner.RangeMap());
	sharedOutput = SharedOwner.FillComplete(SharedOwner.DomainMap(), SharedOwner.RangeMap());
	EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
	EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
	if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;

	{
		// make new Graphs so that we can insert Global instead of Local
		// inside of new scope so that we can use same names
		Epetra_CrsGraph SoleOwnerG(Copy, Map1, NumIndicesPerRow);
		Epetra_CrsGraph SharedOrigG(Copy, Map1, NumIndicesPerRow);
		Epetra_CrsGraph SharedOwnerG(SharedOrig);
		
		long long GlobalRow = SoleOwnerG.GRID64(0);

		// InsertGlobalIndices
		if(verbose) cout << "InsertGlobalIndices..." << endl;
		soleOutput = SoleOwnerG.InsertGlobalIndices(GlobalRow, 2, array2.Values());
		sharedOutput = SharedOwnerG.InsertGlobalIndices(GlobalRow, 2, array2.Values());
		EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
		EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
		if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;
		
		// RemoveGlobalIndices (#1)
		if(verbose) cout << "RemoveGlobalIndices..." << endl;
		soleOutput = SoleOwnerG.RemoveGlobalIndices(GlobalRow, 1, &array2[1]);
		sharedOutput = SharedOwnerG.RemoveGlobalIndices(GlobalRow, 1, &array2[1]);
		EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
		EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
		if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;
		
		// RemoveGlobalIndices (#2)
		if(verbose) cout << "RemoveGlobalIndices(#2)..." << endl;
		soleOutput = SoleOwnerG.RemoveGlobalIndices(GlobalRow);
		sharedOutput = SharedOwnerG.RemoveGlobalIndices(GlobalRow);
		EPETRA_TEST_ERR(!(soleOutput == 0), ierr);
		EPETRA_TEST_ERR(!(sharedOutput == 1), ierr);
		if(verbose && ierr > 0) cout << "soleOutput = " << soleOutput << " sharedOutput = " << sharedOutput << endl;
		}


	// *PROT* InsertIndices
	// *PROT* MakeIndicesLocal

	return(ierr);

}
Exemplo n.º 18
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;
	}