2 * Copyright 2014 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * This file is supposed to be included from within
19 * FBVectorTest. Do not use otherwise.
22 TESTFUN(clause_23_3_6_1_1) {
24 EXPECT_TRUE(v.empty());
25 VECTOR::allocator_type a;
27 EXPECT_TRUE(v1.empty());
30 TESTFUN(clause_23_3_6_1_3) {
31 auto const n = random(0U, 10000U);
33 EXPECT_EQ(v.size(), n);
35 EXPECT_EQ(*i, VECTOR::value_type());
39 TESTFUN(clause_23_3_6_1_9) {
40 // Insert with iterators
41 list<VECTOR::value_type> lst;
42 auto const n = random(0U, 10000U);
43 FOR_EACH_RANGE (i, 0, n) {
44 lst.push_back(randomObject<VECTOR::value_type>());
46 VECTOR v(lst.begin(), lst.end());
47 EXPECT_EQ(v.size(), lst.size());
50 EXPECT_EQ(v[j++], *i);
54 TESTFUN(clause_23_3_6_1_11) {
55 // assign with iterators
56 list<VECTOR::value_type> lst;
57 auto const n = random(0U, 10000U);
58 FOR_EACH_RANGE (i, 0, n) {
59 lst.push_back(randomObject<VECTOR::value_type>());
62 v.assign(lst.begin(), lst.end());
63 EXPECT_EQ(v.size(), lst.size());
66 EXPECT_EQ(v[j++], *i);
70 v.assign(v.begin(), v.begin() + v.size() / 2);
71 EXPECT_EQ(v.size(), lst.size() / 2);
74 if (j == v.size()) break;
75 EXPECT_EQ(v[j++], *i);
79 TESTFUN(clause_23_3_6_1_12) {
81 auto const n = random(0U, 10000U);
82 auto const obj = randomObject<VECTOR::value_type>();
84 EXPECT_EQ(v.size(), n);
90 TESTFUN(clause_23_3_6_2_1) {
92 auto const n = random(0U, 10000U);
94 EXPECT_GE(v.capacity(), n);
97 TESTFUN(clause_23_3_6_2_7) {
98 auto const n1 = random(0U, 10000U);
99 auto const n2 = random(0U, 10000U);
100 auto const obj1 = randomObject<VECTOR::value_type>();
101 auto const obj2 = randomObject<VECTOR::value_type>();
102 VECTOR v1(n1, obj1), v2(n2, obj2);
104 EXPECT_EQ(v1.size(), n2);
105 EXPECT_EQ(v2.size(), n1);
114 TESTFUN(clause_23_3_6_2_9) {
116 auto const n1 = random(0U, 10000U);
119 EXPECT_EQ(*i, VECTOR::value_type());
121 auto const n2 = random(0U, 10000U);
123 EXPECT_EQ(*i, VECTOR::value_type());
127 TESTFUN(clause_23_3_6_2_11) {
129 auto const n1 = random(0U, 10000U);
130 auto const obj1 = randomObject<VECTOR::value_type>();
135 auto const n2 = random(0U, 10000U);
136 auto const obj2 = randomObject<VECTOR::value_type>();
139 FOR_EACH_RANGE (i, n1, n2) {
140 EXPECT_EQ(v[i], obj2);
145 TESTFUN(clause_absent_element_access) {
147 auto const n1 = random(1U, 10000U);
148 auto const obj1 = randomObject<VECTOR::value_type>();
150 auto const n = random(0U, v.size() - 1);
151 EXPECT_EQ(v[n], v.at(n));
152 auto const obj2 = randomObject<VECTOR::value_type>();
154 EXPECT_EQ(v[n], v.at(n));
155 EXPECT_EQ(v[n], obj2);
156 auto const obj3 = randomObject<VECTOR::value_type>();
158 EXPECT_EQ(v[n], v.at(n));
159 EXPECT_EQ(v[n], obj3);
162 TESTFUN(clause_23_3_6_3_1) {
164 auto const n1 = random(1U, 10000U);
165 auto const obj1 = randomObject<VECTOR::value_type>();
167 EXPECT_EQ(v.data(), &v.front());
170 TESTFUN(clause_23_3_6_4_1_a) {
172 auto const n1 = random(1U, 10000U);
173 FOR_EACH_RANGE (i, 0, n1) {
174 auto const obj1 = randomObject<VECTOR::value_type>();
178 auto const n2 = random(0U, n1 - 1);
179 auto pos = v.begin() + n2;
180 auto const obj2 = randomObject<VECTOR::value_type>();
182 auto r = v.insert(pos, obj2);
184 EXPECT_EQ(v.size(), w.size() + 1);
185 EXPECT_EQ(r - v.begin(), n2);
187 FOR_EACH_RANGE (i, 0, r - v.begin()) {
188 EXPECT_EQ(v[i], w[i]);
190 FOR_EACH_RANGE (i, r - v.begin() + 1, v.size()) {
191 EXPECT_EQ(v[i], w[i - 1]);
195 TESTFUN(clause_23_3_6_4_1_c) {
196 // This test only works for fbvector
197 fbvector<VECTOR::value_type> v, w;
198 auto const n1 = random(1U, 10000U);
199 FOR_EACH_RANGE (i, 0, n1) {
200 auto const obj1 = randomObject<VECTOR::value_type>();
204 auto const n2 = random(0U, n1-1);
205 auto pos = v.begin() + n2;
206 auto const obj2 = randomObject<VECTOR::value_type>();
207 auto const n3 = random(0U, 10000U);
209 auto r = v.insert(pos, n3, obj2);
211 EXPECT_EQ(v.size(), w.size() + n3);
212 EXPECT_EQ(r - v.begin(), n2);
213 FOR_EACH_RANGE (i, 0, r - v.begin()) {
214 EXPECT_EQ(v[i], w[i]);
216 FOR_EACH_RANGE (i, r - v.begin(), r - v.begin() + n3) {
217 EXPECT_EQ(v[i], obj2);
219 FOR_EACH_RANGE (i, r - v.begin() + n3, v.size()) {
220 EXPECT_EQ(v[i], w[i - n3]);
224 TESTFUN(clause_23_3_6_4_1_d) {
226 auto const n1 = random(0U, 10000U);
227 FOR_EACH_RANGE (i, 0, n1) {
228 auto const obj1 = randomObject<VECTOR::value_type>();
232 EXPECT_EQ(v.size(), n1);
234 auto const obj2 = randomObject<VECTOR::value_type>();
236 EXPECT_EQ(v.back(), obj2);
237 EXPECT_EQ(v.size(), w.size() + 1);
239 FOR_EACH_RANGE (i, 0, w.size()) {
240 EXPECT_EQ(v[i], w[i]);
244 TESTFUN(clause_23_3_6_4_3) {
246 auto const n1 = random(1U, 10000U);
247 FOR_EACH_RANGE (i, 0, n1) {
248 auto const obj1 = randomObject<VECTOR::value_type>();
252 EXPECT_EQ(v.size(), n1);
254 auto const n2 = random(0U, n1 - 1);
255 auto it = v.erase(v.begin() + n2);
256 EXPECT_EQ(v.size() + 1, w.size());
258 FOR_EACH_RANGE (i, 0, it - v.begin()) {
259 EXPECT_EQ(v[i], w[i]);
262 FOR_EACH_RANGE (i, it - v.begin(), v.size()) {
263 EXPECT_EQ(v[i], w[i + 1]);
267 TESTFUN(clause_23_3_6_4_4) {
269 auto const n1 = random(1U, 10000U);
270 FOR_EACH_RANGE (i, 0, n1) {
271 auto const obj1 = randomObject<VECTOR::value_type>();
275 EXPECT_EQ(v.size(), n1);
277 auto const n2 = random(0U, n1 - 1);
278 auto const n3 = random(n2, n1 - 1);
279 auto it = v.erase(v.begin() + n2, v.begin() + n3);
280 EXPECT_EQ(v.size() + (n3 - n2), w.size());
282 FOR_EACH_RANGE (i, 0, it - v.begin()) {
283 EXPECT_EQ(v[i], w[i]);
286 FOR_EACH_RANGE (i, it - v.begin(), v.size()) {
287 EXPECT_EQ(v[i], w[i + (n3 - n2)]);
291 TESTFUN(clause_23_3_6_4_clear) {
294 EXPECT_TRUE(v.empty());
295 v.resize(random(0U, 10000U));
296 auto c = v.capacity();
298 EXPECT_TRUE(v.empty());
299 EXPECT_EQ(v.capacity(), c);
302 BENCHMARK(BENCHFUN(zzInitRNG), iters) {
303 //LOG(INFO) << "\nTesting with type " << typeid(VECTOR).name() << "\n";
307 BENCHMARK(BENCHFUN(defaultCtor), iters) {
308 FOR_EACH_RANGE (i, 0, iters) {
310 doNotOptimizeAway(&v);
314 void BENCHFUN(sizeCtor)(int iters, int size) {
315 FOR_EACH_RANGE (i, 0, iters) {
317 doNotOptimizeAway(&v);
320 BENCHMARK_PARAM(BENCHFUN(sizeCtor), 128);
321 BENCHMARK_PARAM(BENCHFUN(sizeCtor), 1024);
322 BENCHMARK_PARAM(BENCHFUN(sizeCtor), 1048576);
324 void BENCHFUN(fillCtor)(int iters, int size) {
325 FOR_EACH_RANGE (i, 0, iters) {
326 VECTOR v(size_t(size), randomObject<VECTOR::value_type>());
327 doNotOptimizeAway(&v);
330 BENCHMARK_PARAM(BENCHFUN(fillCtor), 128);
331 BENCHMARK_PARAM(BENCHFUN(fillCtor), 1024);
332 BENCHMARK_PARAM(BENCHFUN(fillCtor), 10240);
334 void BENCHFUN(pushBack)(int iters, int size) {
335 auto const obj = randomObject<VECTOR::value_type>();
336 FOR_EACH_RANGE (i, 0, iters) {
338 FOR_EACH_RANGE (j, 0, size) {
343 BENCHMARK_PARAM(BENCHFUN(pushBack), 128);
344 BENCHMARK_PARAM(BENCHFUN(pushBack), 1024);
345 BENCHMARK_PARAM(BENCHFUN(pushBack), 10240);
346 BENCHMARK_PARAM(BENCHFUN(pushBack), 102400);
347 BENCHMARK_PARAM(BENCHFUN(pushBack), 512000);
349 void BENCHFUN(reserve)(int iters, int size) {
350 auto const obj = randomObject<VECTOR::value_type>();
351 VECTOR v(random(0U, 10000U), obj);
352 FOR_EACH_RANGE (i, 0, iters) {
353 v.reserve(random(0U, 100000U));
356 BENCHMARK_PARAM(BENCHFUN(reserve), 128);
357 BENCHMARK_PARAM(BENCHFUN(reserve), 1024);
358 BENCHMARK_PARAM(BENCHFUN(reserve), 10240);
360 void BENCHFUN(insert)(int iters, int size) {
361 auto const obj1 = randomObject<VECTOR::value_type>();
362 auto const obj2 = randomObject<VECTOR::value_type>();
363 VECTOR v(random(0U, 1U), obj1);
364 FOR_EACH_RANGE (i, 0, iters / 100) {
365 v.insert(v.begin(), obj2);
368 BENCHMARK_PARAM(BENCHFUN(insert), 100);
370 void BENCHFUN(erase)(int iters, int size) {
371 auto const obj1 = randomObject<VECTOR::value_type>();
372 VECTOR v(random(0U, 100U), obj1);
373 FOR_EACH_RANGE (i, 0, iters) {
374 if (v.empty()) continue;
378 BENCHMARK_PARAM(BENCHFUN(erase), 1024);