test/Array.cpp

   1 #include <gtest/gtest.h>
   2 #include <Sylph/Core/Array.h>
   3 #include <Sylph/Core/Debug.h>
   4
   5 using namespace Sylph;
   6
   7 struct Dummy {
   8 };
   9
  10 namespace {
  11
  12     class TestArray : public ::testing::Test {
  13     protected:
  14
  15         virtual void SetUp() {
  16             testObj1 = new Array<int>((size_t) 5);
  17             testObj2 = new Array<Dummy > (4);
  18             ar1 = new Array<int>((size_t) 4);
  19             ar2 = new Array<int>((size_t) 4);
  20             ar3 = new Array<int>((size_t) 7);
  21             arfilled1 = {5, 2, 9, 1, 7};
  22             arfilled2 = {8, 0, 2, 3, 4, 6};
  23             arfilled3 = {8, 0, 2, 3, 4, 6};
  24         }
  25
  26         virtual void TearDown() {
  27             delete testObj1;
  28             delete testObj2;
  29             delete ar1;
  30             delete ar2;
  31             delete ar3;
  32         }
  33         Array<int> * testObj1;
  34         Array<Dummy> * testObj2;
  35         Array<int> * ar1;
  36         Array<int> * ar2;
  37         Array<int> * ar3;
  38         Array<int> arfilled1;
  39         Array<int> arfilled2;
  40         Array<int> arfilled3;
  41     };
  42
  43     TEST_F(TestArray, testCorrectConstructed) {
  44         EXPECT_EQ(5, testObj1->length);
  45         EXPECT_EQ(4, testObj2->length);
  46         EXPECT_EQ(4, ar1->length);
  47         EXPECT_EQ(4, ar2->length);
  48         EXPECT_EQ(7, ar3->length);
  49         EXPECT_EQ(5, arfilled1.length);
  50         EXPECT_EQ(6, arfilled2.length);
  51         EXPECT_EQ(6, arfilled3.length);
  52     }
  53
  54     TEST_F(TestArray, testNulled) {
  55         EXPECT_EQ(0, (*testObj1)[0]);
  56         EXPECT_EQ(0, (*testObj1)[1]);
  57         EXPECT_EQ(0, (*testObj1)[2]);
  58         EXPECT_EQ(0, (*testObj1)[3]);
  59         EXPECT_EQ(0, (*testObj1)[4]);
  60     }
  61
  62     TEST_F(TestArray, testInEqOut) {
  63         // first
  64         (*testObj1)[0] = 3;
  65         EXPECT_EQ(3, (*testObj1)[0]);
  66         // last
  67         (*testObj1)[4] = 7;
  68         EXPECT_EQ(7, (*testObj1)[4]);
  69         // middle
  70         (*testObj1)[2] = 2;
  71         EXPECT_EQ(2, (*testObj1)[2]);
  72     }
  73
  74     TEST_F(TestArray, testInitlistFill) {
  75         ASSERT_EQ(5, arfilled1.length);
  76         EXPECT_EQ(5, arfilled1[0]);
  77         EXPECT_EQ(2, arfilled1[1]);
  78         EXPECT_EQ(9, arfilled1[2]);
  79         EXPECT_EQ(1, arfilled1[3]);
  80         EXPECT_EQ(7, arfilled1[4]);
  81     }
  82
  83     TEST_F(TestArray, testOverflow) {
  84         ASSERT_THROW((*testObj1)[7] = 1, ArrayException);
  85     }
  86
  87     TEST_F(TestArray, testLength) {
  88         Array<bool> lengthtest((size_t) 6);
  89         ASSERT_EQ(6, lengthtest.length);
  90     }
  91
  92     TEST_F(TestArray, testLengthOverflow) {
  93         Array<bool> lengthtest((size_t) 6);
  94         ASSERT_THROW(lengthtest[6] = false, ArrayException);
  95     }
  96
  97     TEST_F(TestArray, testSelfEquality) {
  98         ASSERT_EQ(*ar1, *ar1);
  99     }
 100
 101     TEST_F(TestArray, testEmptyEquality) {
 102         EXPECT_TRUE(*ar1 == *ar2);
 103         EXPECT_FALSE(*ar1 == *ar3);
 104     }
 105
 106     TEST_F(TestArray, testRealEquality) {
 107         EXPECT_TRUE(arfilled3 == arfilled2);
 108         EXPECT_TRUE(arfilled3 != arfilled1);
 109     }
 110
 111     TEST_F(TestArray, testComparisons) {
 112         Array<char> ar4 = {'h', 'e', 'l', 'l', 'o'};
 113         Array<char> ar5 = {'h', 'e', 'l', 'm', 'e', 't'};
 114         EXPECT_TRUE(ar4 < ar5);
 115         EXPECT_FALSE(ar5 < ar4);
 116     }
 117
 118     TEST_F(TestArray, testCopyEquality) {
 119         Array<int> arcopy = arfilled1.copy();
 120         EXPECT_TRUE(arfilled1 == arcopy);
 121     }
 122
 123     TEST_F(TestArray, testIterator) {
 124         idx_t cur = 0;
 125
 126         for (Array<int>::iterator it = arfilled1.begin();
 127                 it != arfilled1.end(); ++it) {
 128                 EXPECT_EQ(*it, arfilled1[cur]);
 129                 cur++;
 130             }
 131     }
 132
 133     TEST_F(TestArray, testNegativeIndices) {
 134         EXPECT_EQ(7, arfilled1[-1]);
 135         EXPECT_EQ(1, arfilled1[-2]);
 136         EXPECT_EQ(arfilled1[0], arfilled1[-arfilled1.length]);
 137     }
 138
 139     TEST_F(TestArray, testNegativeOverflow) {
 140         ASSERT_THROW(arfilled1[-(arfilled1.length + 1)] = 3, ArrayException);
 141     }
 142
 143     TEST_F(TestArray, testRanges) {
 144         Array<int> section = arfilled2[range(2, 4)];
 145         ASSERT_EQ(3, section.length);
 146         EXPECT_EQ(2, section[0]);
 147         EXPECT_EQ(3, section[1]);
 148         EXPECT_EQ(4, section[2]);
 149     }
 150
 151     TEST_F(TestArray, testRefcounted) {
 152         Array<int> tmp = arfilled1;
 153         ASSERT_EQ(arfilled1.carray(), tmp.carray());
 154     }
 155
 156 } // namespace