1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/stack_container.h"
#include <algorithm>
#include "base/memory/aligned_memory.h"
#include "base/memory/ref_counted.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
class Dummy : public base::RefCounted<Dummy> {
public:
explicit Dummy(int* alive) : alive_(alive) {
++*alive_;
}
private:
friend class base::RefCounted<Dummy>;
~Dummy() {
--*alive_;
}
int* const alive_;
};
} // namespace
TEST(StackContainer, Vector) {
const int stack_size = 3;
StackVector<int, stack_size> vect;
const int* stack_buffer = &vect.stack_data().stack_buffer()[0];
// The initial |stack_size| elements should appear in the stack buffer.
EXPECT_EQ(static_cast<size_t>(stack_size), vect.container().capacity());
for (int i = 0; i < stack_size; i++) {
vect.container().push_back(i);
EXPECT_EQ(stack_buffer, &vect.container()[0]);
EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
}
// Adding more elements should push the array onto the heap.
for (int i = 0; i < stack_size; i++) {
vect.container().push_back(i + stack_size);
EXPECT_NE(stack_buffer, &vect.container()[0]);
EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
}
// The array should still be in order.
for (int i = 0; i < stack_size * 2; i++)
EXPECT_EQ(i, vect.container()[i]);
// Resize to smaller. Our STL implementation won't reallocate in this case,
// otherwise it might use our stack buffer. We reserve right after the resize
// to guarantee it isn't using the stack buffer, even though it doesn't have
// much data.
vect.container().resize(stack_size);
vect.container().reserve(stack_size * 2);
EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
// Copying the small vector to another should use the same allocator and use
// the now-unused stack buffer. GENERALLY CALLERS SHOULD NOT DO THIS since
// they have to get the template types just right and it can cause errors.
std::vector<int, StackAllocator<int, stack_size> > other(vect.container());
EXPECT_EQ(stack_buffer, &other.front());
EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
for (int i = 0; i < stack_size; i++)
EXPECT_EQ(i, other[i]);
}
TEST(StackContainer, VectorDoubleDelete) {
// Regression testing for double-delete.
typedef StackVector<scoped_refptr<Dummy>, 2> Vector;
typedef Vector::ContainerType Container;
Vector vect;
int alive = 0;
scoped_refptr<Dummy> dummy(new Dummy(&alive));
EXPECT_EQ(alive, 1);
vect->push_back(dummy);
EXPECT_EQ(alive, 1);
Dummy* dummy_unref = dummy.get();
dummy = NULL;
EXPECT_EQ(alive, 1);
Container::iterator itr = std::find(vect->begin(), vect->end(), dummy_unref);
EXPECT_EQ(itr->get(), dummy_unref);
vect->erase(itr);
EXPECT_EQ(alive, 0);
// Shouldn't crash at exit.
}
namespace {
template <size_t alignment>
class AlignedData {
public:
AlignedData() { memset(data_.void_data(), 0, alignment); }
~AlignedData() {}
base::AlignedMemory<alignment, alignment> data_;
};
} // anonymous namespace
#define EXPECT_ALIGNED(ptr, align) \
EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
TEST(StackContainer, BufferAlignment) {
StackVector<wchar_t, 16> text;
text->push_back(L'A');
EXPECT_ALIGNED(&text[0], ALIGNOF(wchar_t));
StackVector<double, 1> doubles;
doubles->push_back(0.0);
EXPECT_ALIGNED(&doubles[0], ALIGNOF(double));
StackVector<AlignedData<16>, 1> aligned16;
aligned16->push_back(AlignedData<16>());
EXPECT_ALIGNED(&aligned16[0], 16);
#if !defined(OS_ANDROID)
// It seems that android doesn't respect greater than 16 byte alignment for
// non-POD data on the stack, even though ALIGNOF(aligned256) == 256.
StackVector<AlignedData<256>, 1> aligned256;
aligned256->push_back(AlignedData<256>());
EXPECT_ALIGNED(&aligned256[0], 256);
#endif
}
template class StackVector<int, 2>;
template class StackVector<scoped_refptr<Dummy>, 2>;
|
