// Copyright 2008, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "base/stack_container.h" #include #include "testing/gtest/include/gtest/gtest.h" #include "base/ref_counted.h" namespace { class Dummy : public base::RefCounted { public: Dummy(int* alive) : alive_(alive) { ++*alive_; } ~Dummy() { --*alive_; } private: int* const alive_; }; } // namespace TEST(StackContainer, Vector) { const int stack_size = 3; StackVector 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(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 > 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, 2> Vector; typedef Vector::ContainerType Container; Vector vect; int alive = 0; scoped_refptr 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. } TEST(StackContainer, BufferAlignment) { StackVector text; text->push_back(L'A'); text->push_back(L'B'); text->push_back(L'C'); text->push_back(L'D'); text->push_back(L'E'); text->push_back(L'F'); text->push_back(0); const wchar_t* buffer = &text[1]; bool even_aligned = (0 == (((size_t)buffer) & 0x1)); EXPECT_EQ(even_aligned, true); } #ifdef COMPILER_MSVC // Make sure all the class compiles correctly. // TODO(pinkerton): i'm not sure why this doesn't compile on GCC, but // it doesn't. template StackVector; template StackVector, 2>; #endif