base/containers/stack_container_unittest.cc

   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
  13 namespace base {
  14
  15 namespace {
  16
  17 class 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
  35 TEST(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
  77 TEST(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
 102 namespace {
 103
 104 template <size_t alignment>
 105 class 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
 117 TEST(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
 139 template class StackVector<int, 2>;
 140 template class StackVector<scoped_refptr<Dummy>, 2>;
 141
 142 }  // namespace base