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