arrays_mem_check.cpp

Go to the documentation of this file.

 
/*****************************************************************************
** Macros
*****************************************************************************/
 
#define ECL_MEM_CHECK_ARRAYS // Make sure we use mem checking arrays, not regular
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <iostream>
#include <gtest/gtest.h>
#include "../../include/ecl/containers/array.hpp"
 
/*****************************************************************************
** Using
*****************************************************************************/
 
using ecl::Array;
using ecl::blueprints::ArrayFactory;
using ecl::blueprints::ConstantArray;
using ecl::StandardException;
 
/*****************************************************************************
** Tests
*****************************************************************************/
 
TEST(ArrayMemCheckTests,constructors) {
    Array<int,4> array1 = Array<int,4>::Constant(3);
    EXPECT_EQ(3,array1[0]);
    EXPECT_EQ(3,array1[1]);
    EXPECT_EQ(3,array1[2]);
    EXPECT_EQ(3,array1[3]);
    Array<int,4> array2 = ArrayFactory<int,4>::Constant(4);
    EXPECT_EQ(4,array2[0]);
    EXPECT_EQ(4,array2[1]);
    EXPECT_EQ(4,array2[2]);
    EXPECT_EQ(4,array2[3]);
    Array<int,4> array3 = ConstantArray<int,4>(3);
    EXPECT_EQ(3,array3[0]);
    EXPECT_EQ(3,array3[1]);
    EXPECT_EQ(3,array3[2]);
    EXPECT_EQ(3,array3[3]);
//    std::cout << "Constant array [fixed]  : " << array1 << std::endl;
    Array<int> darray1 = Array<int>::Constant(4,3);
    EXPECT_EQ(3,darray1[0]);
    EXPECT_EQ(3,darray1[1]);
    EXPECT_EQ(3,darray1[2]);
    EXPECT_EQ(3,darray1[3]);
//    std::cout << "Constant array [dynamic]  : " << darray1 << std::endl;
}
 
TEST(ArrayMemCheckTests,copyConstructors) {
 
    Array<int,4> array1 = Array<int,4>::Constant(3);
    Array<int> darray1 = Array<int>::Constant(4,3);
 
    Array<int,4> array2(array1);
        Array<int> darray2(darray1);
 
    EXPECT_EQ(3,array2[0]);
    EXPECT_EQ(3,array2[1]);
    EXPECT_EQ(3,array2[2]);
    EXPECT_EQ(3,array2[3]);
 
    EXPECT_EQ(3,darray2[0]);
    EXPECT_EQ(3,darray2[1]);
    EXPECT_EQ(3,darray2[2]);
    EXPECT_EQ(3,darray2[3]);
}
 
TEST(ArrayMemCheckTests,blueprintAssignment) {
 
        Array<int,4> array;
        array = Array<int,4>::Constant(3);
 
    EXPECT_EQ(3,array[0]);
    EXPECT_EQ(3,array[1]);
    EXPECT_EQ(3,array[2]);
    EXPECT_EQ(3,array[3]);
}
TEST(ArrayMemCheckTests,commaInitialisation) {
 
        Array<int,4> array;
    Array<int> darray(4);
        array << 1,2,3,4;
        darray << 1,2,3,4;
 
    EXPECT_EQ(1,array[0]);
    EXPECT_EQ(2,array[1]);
    EXPECT_EQ(3,array[2]);
    EXPECT_EQ(4,array[3]);
 
    EXPECT_EQ(1,darray[0]);
    EXPECT_EQ(2,darray[1]);
    EXPECT_EQ(3,darray[2]);
    EXPECT_EQ(4,darray[3]);
}
TEST(ArrayMemCheckTests,Accessors) {
 
        int j;
        Array<int,4> array;
    Array<int> darray(4);
        array << 1,2,3,4;
        darray << 1,2,3,4;
 
        j = array[2];
        EXPECT_EQ(3,j);
        j = array.at(1);
        EXPECT_EQ(2,j);
        j = darray[2];
        EXPECT_EQ(3,j);
        j = darray.at(1);
        EXPECT_EQ(2,j);
}
 
TEST(ArrayMemCheckTests,rangeChecking) {
 
        Array<int,4> array = Array<int,4>::Constant(3);
    Array<int> darray = Array<int>::Constant(4,3);
        bool result = false;
        try {
        array.at(10);
    } catch ( StandardException &e ) {
        result = true;
//        std::cout << "Fixed:\n" << e.what() << std::endl;
    }
    EXPECT_TRUE(result);
    result = false;
    try {
        darray.at(10);
    } catch ( StandardException &e ) {
        result = true;
//        std::cout << "Dynamic:\n" << e.what() << std::endl;
    }
    EXPECT_TRUE(result);
}
 
TEST(ArrayMemCheckTests,iterators) {
 
    Array<int,4> array = Array<int,4>::Constant(3);
        Array<int,4>::iterator iterator;
        for ( iterator = array.begin(); iterator != array.end(); ++iterator ) {
                EXPECT_EQ(3,*iterator);
        }
}
 
TEST(ArrayMemCheckTests,resize) {
    Array<int> darray = Array<int>::Constant(4,3);
    darray.resize(10);
    darray << 0,1,2,3,4,5,6,7,8,9;
    int i = 0;
    Array<int>::iterator iterator;
        for ( iterator = darray.begin(); iterator != darray.end(); ++iterator ) {
                EXPECT_EQ(i,*iterator);
                ++i;
        }
        darray.clear();
}
 
TEST(ArrayMemCheckTests,bufferRuns) {
    int *istart = NULL;
    Array<int,4> array_ok; array_ok << 1, 2, 3, 4;
    Array<int,4> array_under; array_under << 1, 2, 3, 4;
    Array<int,4> array_over; array_over << 1, 2, 3, 4;
 
//    std::cout << "Fixed Arrays" << std::endl;
//    std::cout << "Array_under/over/ok: " << array_ok << std::endl;
//
 
//    std::cout << "Underrunning array_under." << std::endl;
    istart = &array_under[0];
    for ( unsigned int i = 0; i < 3; ++i ) {
        *(istart-i) = i;
    }
 
//    std::cout << "Overrunning array_over." << std::endl;
    istart = &array_over[0];
    for ( unsigned int i = 0; i < array_over.size() + 1; ++i ) {
        *(istart+i) = i;
    }
//
//    std::cout << "Buffer results: " << std::endl;
    EXPECT_TRUE(array_under.bufferUnderRun());
    EXPECT_FALSE(array_under.bufferOverRun());
 
    EXPECT_TRUE(array_over.bufferOverRun());
    EXPECT_FALSE(array_over.bufferUnderRun());
 
    EXPECT_FALSE(array_ok.bufferOverRun());
    EXPECT_FALSE(array_ok.bufferUnderRun());
 
//    std::cout << "Dynamic Arrays" << std::endl;
//    std::cout << std::endl;
//
    Array<int> darray_ok(4); darray_ok << 1, 2, 3, 4;
    Array<int> darray_under(4); darray_under << 1, 2, 3, 4;
    Array<int> darray_over(4); darray_over << 1, 2, 3, 4;
 
//    std::cout << "Array_under/over/ok: " << darray_ok << std::endl;
//
//    std::cout << "Underrunning array_under." << std::endl;
    istart = &darray_under[0];
    for ( unsigned int i = 0; i < darray_under.size()+1; ++i ) {
        *(istart+i-1) = i;
    }
//
//    std::cout << "Overrunning array_over." << std::endl;
    istart = &darray_over[0];
    for ( unsigned int i = 0; i < darray_over.size()+1; ++i ) {
        *(istart+i) = i;
    }
 
    EXPECT_TRUE(darray_under.bufferUnderRun());
    EXPECT_FALSE(darray_under.bufferOverRun());
 
    EXPECT_TRUE(darray_over.bufferOverRun());
    EXPECT_FALSE(darray_over.bufferUnderRun());
 
    EXPECT_FALSE(darray_ok.bufferOverRun());
    EXPECT_FALSE(darray_ok.bufferUnderRun());
}
 
/*****************************************************************************
** Main program
*****************************************************************************/
 
int main(int argc, char **argv) {
 
    testing::InitGoogleTest(&argc,argv);
    return RUN_ALL_TESTS();
}