• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "Vector_test"
18 
19 #define __STDC_LIMIT_MACROS
20 #include <stdint.h>
21 #include <utils/Vector.h>
22 #include <cutils/log.h>
23 #include <gtest/gtest.h>
24 #include <unistd.h>
25 
26 namespace android {
27 
28 class VectorTest : public testing::Test {
29 protected:
SetUp()30     virtual void SetUp() {
31     }
32 
TearDown()33     virtual void TearDown() {
34     }
35 
36 public:
37 };
38 
39 
TEST_F(VectorTest,CopyOnWrite_CopyAndAddElements)40 TEST_F(VectorTest, CopyOnWrite_CopyAndAddElements) {
41 
42     Vector<int> vector;
43     Vector<int> other;
44     vector.setCapacity(8);
45 
46     vector.add(1);
47     vector.add(2);
48     vector.add(3);
49 
50     EXPECT_EQ(3U, vector.size());
51 
52     // copy the vector
53     other = vector;
54 
55     EXPECT_EQ(3U, other.size());
56 
57     // add an element to the first vector
58     vector.add(4);
59 
60     // make sure the sizes are correct
61     EXPECT_EQ(4U, vector.size());
62     EXPECT_EQ(3U, other.size());
63 
64     // add an element to the copy
65     other.add(5);
66 
67     // make sure the sizes are correct
68     EXPECT_EQ(4U, vector.size());
69     EXPECT_EQ(4U, other.size());
70 
71     // make sure the content of both vectors are correct
72     EXPECT_EQ(vector[3], 4);
73     EXPECT_EQ(other[3], 5);
74 }
75 
76 // TODO: gtest isn't capable of parsing Abort messages formatted by
77 // Android (fails differently on host and target), so we always need to
78 // use an empty error message for death tests.
TEST_F(VectorTest,SetCapacity_Overflow)79 TEST_F(VectorTest, SetCapacity_Overflow) {
80   Vector<int> vector;
81   EXPECT_DEATH(vector.setCapacity(SIZE_MAX / sizeof(int) + 1), "");
82 }
83 
TEST_F(VectorTest,SetCapacity_ShrinkBelowSize)84 TEST_F(VectorTest, SetCapacity_ShrinkBelowSize) {
85   Vector<int> vector;
86   vector.add(1);
87   vector.add(2);
88   vector.add(3);
89   vector.add(4);
90 
91   vector.setCapacity(8);
92   ASSERT_EQ(8, vector.capacity());
93   vector.setCapacity(2);
94   ASSERT_EQ(8, vector.capacity());
95 }
96 
97 // NOTE: All of the tests below are useless because of the "TODO" above.
98 // We have no way of knowing *why* the process crashed. Given that we're
99 // inserting a NULL array, we'll fail with a SIGSEGV eventually. We need
100 // the ability to make assertions on the abort message to make sure we're
101 // failing for the right reasons.
TEST_F(VectorTest,_grow_OverflowSize)102 TEST_F(VectorTest, _grow_OverflowSize) {
103   Vector<int> vector;
104   vector.add(1);
105 
106   // Checks that the size calculation (not the capacity calculation) doesn't
107   // overflow : the size here will be (1 + SIZE_MAX).
108   //
109   // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, SIZE_MAX), "new_size_overflow");
110   EXPECT_DEATH(vector.insertArrayAt(NULL, 0, SIZE_MAX), "");
111 }
112 
TEST_F(VectorTest,_grow_OverflowCapacityDoubling)113 TEST_F(VectorTest, _grow_OverflowCapacityDoubling) {
114   Vector<int> vector;
115 
116   // This should fail because the calculated capacity will overflow even though
117   // the size of the vector doesn't.
118   //
119   // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX - 1)), "new_capacity_overflow");
120   EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX - 1)), "");
121 }
122 
TEST_F(VectorTest,_grow_OverflowBufferAlloc)123 TEST_F(VectorTest, _grow_OverflowBufferAlloc) {
124   Vector<int> vector;
125   // This should fail because the capacity * sizeof(int) overflows, even
126   // though the capacity itself doesn't.
127   //
128   // EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX / 2)), "new_alloc_size overflow");
129   EXPECT_DEATH(vector.insertArrayAt(NULL, 0, (SIZE_MAX / 2)), "");
130 }
131 
TEST_F(VectorTest,editArray_Shared)132 TEST_F(VectorTest, editArray_Shared) {
133   Vector<int> vector1;
134   vector1.add(1);
135   vector1.add(2);
136   vector1.add(3);
137   vector1.add(4);
138 
139   Vector<int> vector2 = vector1;
140   ASSERT_EQ(vector1.array(), vector2.array());
141   // We must make a copy here, since we're not the exclusive owners
142   // of this array.
143   ASSERT_NE(vector1.editArray(), vector2.editArray());
144 
145   // Vector doesn't implement operator ==.
146   ASSERT_EQ(vector1.size(), vector2.size());
147   for (size_t i = 0; i < vector1.size(); ++i) {
148     EXPECT_EQ(vector1[i], vector2[i]);
149   }
150 }
151 
152 } // namespace android
153