am 8b5f35d0: Revert "Basic implementation of vector."

Merge commit '8b5f35d0aa39e39119dc1e3e2fc4d283995faa2a'

* commit '8b5f35d0aa39e39119dc1e3e2fc4d283995faa2a':
  Revert "Basic implementation of vector."

11 files changed, 40 insertions, 1062 deletions

diff --git a/include/algorithm b/include/algorithm
index e1930a1..55dfc54 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -199,7 +199,6 @@ inline char *fill_n(char *begin, size_t num, const char& value)
 // TODO: When we have a proper structure for iterator as opposed to
 // just pointers, we should be able to the get the type for the values
 // referenced by the iterator and default to memcmp for simple types.
-// TODO: equal should degrade to memcmp for pod.
 template<typename _InputIterator1, typename _InputIterator2>
 inline bool equal(_InputIterator1 begin1, _InputIterator1 end1,
                   _InputIterator2 begin2)
diff --git a/include/memory b/include/memory
deleted file mode 100644
index d83851f..0000000
--- a/include/memory
+++ /dev/null
@@ -1,136 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * 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.
- *
- * 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.
- */
-
-#ifndef ANDROID_ASTL_MEMORY__
-#define ANDROID_ASTL_MEMORY__
-
-#include "type_traits.h"
-#include <new>  // for placement new
-#include <cstring>
-#include <algorithm>
-
-#if defined(_InputIterator) || defined(_ForwardIterator)
-#error "_InputIterator or _ForwardIterator are already defined."
-#endif
-
-namespace std {
-
-// uninitialized_copy is used when memory allocation and object
-// construction need to happen in separate steps. For each instance in
-// the input range a copy is created and placed in the corresponding
-// memory pointed by dest.
-// If the input range is made of pod instances, uninitialized_copy
-// degrades to a memmove call.
-
-template<bool> struct __uninitialized_copy
-{
-    template<typename _InputIterator, typename _ForwardIterator>
-    static _ForwardIterator *uninitialized_copy(const _InputIterator *begin,
-                                                const _InputIterator *end,
-                                                _ForwardIterator *dest)
-    {
-        _ForwardIterator *result = dest;
-        for (; begin < end; ++begin, ++dest)
-            new (static_cast<void*>(dest)) _ForwardIterator(*begin);
-        return result;
-    }
-};
-
-template<> struct __uninitialized_copy<true>
-{
-    template<typename _InputIterator, typename _ForwardIterator>
-    static _ForwardIterator *uninitialized_copy(const _InputIterator *begin,
-                                                const _InputIterator *end,
-                                                _ForwardIterator *dest)
-    {
-        const ptrdiff_t len = end - begin;
-        const size_t kMaxSizeT = ~((size_t)0);
-        const size_t kSize = sizeof(_InputIterator);
-
-        if (len > 0 && kMaxSizeT / kSize > static_cast<size_t>(len))
-        {
-            std::memmove(static_cast<void*>(dest),
-                         static_cast<const void*>(begin), kSize * len);
-        }
-        return dest;
-    }
-};
-
-// The real STL takes iterators, we take pointers for now.
-template<typename _InputIterator, typename _ForwardIterator>
-inline _ForwardIterator* uninitialized_copy(const _InputIterator *begin,
-                                            const _InputIterator *end,
-                                            _ForwardIterator *dest)
-{
-    const bool both_pod =
-            is_pod<_InputIterator>::value && is_pod<_ForwardIterator>::value;
-    return __uninitialized_copy<both_pod>::uninitialized_copy(begin, end, dest);
-}
-
-// uninitialized_fill is used when memory allocation and object
-// construction need to happen in separate steps. uninitialized_fill
-// creates a copy of 'obj' in the location pointed by the interator,
-// using the object's class copy constructor.
-
-template<bool> struct __uninitialized_fill
-{
-    template<typename _ForwardIterator, typename _T>
-    static void uninitialized_fill(_ForwardIterator *begin,
-                                   _ForwardIterator *end,
-                                   const _T& val)
-    {
-        for (; begin < end; ++begin)
-            new (static_cast<void*>(begin)) _ForwardIterator(val);
-    }
-};
-
-template<> struct __uninitialized_fill<true>
-{
-    template<typename _ForwardIterator, typename _T>
-    static void uninitialized_fill(_ForwardIterator *begin,
-                                   _ForwardIterator *end,
-                                   const _T& val)
-    {
-        std::fill(begin, end, val);
-    }
-};
-
-// The real STL takes iterators, we take pointers for now.
-template<typename _ForwardIterator, typename _T>
-inline void uninitialized_fill(_ForwardIterator *begin,
-                               _ForwardIterator *end,
-                               const _T& val)
-{
-    const bool pod = is_pod<_ForwardIterator>::value;
-    return __uninitialized_fill<pod>::uninitialized_fill(begin, end, val);
-}
-
-}  // namespace std
-
-#endif  // ANDROID_ASTL_MEMORY__
diff --git a/include/vector b/include/vector
deleted file mode 100644
index 1e65d54..0000000
--- a/include/vector
+++ /dev/null
@@ -1,320 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * 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.
- *
- * 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.
- */
-
-#ifndef ANDROID_ASTL_VECTOR__
-#define ANDROID_ASTL_VECTOR__
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <algorithm>
-#include <memory>
-#include <type_traits.h>
-
-namespace std {
-
-#ifdef _T
-#error "_T is a macro."
-#endif
-
-// Simple vector implementation. Its purpose is to be able to compile code that
-// uses the STL and requires std::vector.
-//
-// IMPORTANT:
-// . This class it is not fully STL compliant. Some constructors/methods maybe
-// missing, they will be added on demand.
-// . A standard container which offers fixed time access to individual
-// elements in any order.
-//
-// TODO: Use the stack for the default constructor. When the capacity
-// grows beyond that move the data to the heap.
-
-template<typename _T>
-class vector
-{
-  public:
-    typedef _T         value_type;
-    typedef _T*        pointer;
-    typedef const _T*  const_pointer;
-    typedef _T&        reference;
-    typedef const _T&  const_reference;
-
-    typedef pointer iterator;
-    typedef const_pointer const_iterator;
-
-    typedef size_t    size_type;
-    typedef ptrdiff_t difference_type;
-
-    vector();
-
-    // Create a vector with bitwise copies of an exemplar element.
-    // @param num The number of elements to create.
-    // @param init_value The element to copy.
-    explicit vector(const size_type num, const value_type& init_value = value_type());
-
-    ~vector() { clear(); }
-
-    // @return true if the vector is empty, false otherwise.
-    bool empty() const { return mLength == 0; }
-    size_type size() const { return mLength; }
-
-    // @return the maximum size for a vector.
-    size_type max_size() const { return size_type(-1) / sizeof(value_type); }
-
-    // Change the capacity to new_size. 0 means shrink to fit.
-    // @param new_size number of element to be allocated.
-    // @return true if successful. The STL version returns nothing.
-    bool reserve(size_type new_size = 0);
-
-    // @return The total number of elements that the vector can hold
-    // before more memory gets allocated.
-    size_type capacity() const { return mCapacity; }
-
-    reference front() { return *mBegin; }
-    const_reference front() const { return *mBegin; }
-
-    reference back() { return mLength ? *(mBegin + mLength - 1) : front(); }
-    const_reference back() const { return mLength ? *(mBegin + mLength - 1) : front(); }
-
-    // Subscript access to the vector's elements. Don't do boundary
-    // check. Use at() for checked access.
-    // @param index Of the element (0-based).
-    // @return A const reference to the element.
-    const_reference operator[](size_type index) const { return *(mBegin + index); }
-
-    // @param index Of the element (0-based).
-    // @return A reference to the element.
-    reference operator[](size_type index) { return *(mBegin + index); }
-
-    // We don't have iterator, use pointers for now.  begin and end
-    // return NULL if the vector has been cleared or not initialized.
-    iterator begin() { return mBegin; }
-    iterator end() { return mBegin + mLength; }
-
-    const_iterator begin() const { return mBegin; }
-    const_iterator end() const { return mBegin + mLength; }
-
-    // Add data at the end of the vector. Constant in time if the
-    // memory has been preallocated (e.g using reserve).
-    // @param elt To be added.
-    void push_back(const value_type& elt);
-
-    // Remove the last element. However, no memory is reclaimed from
-    // the internal buffer: you need to call reserve() to recover it.
-    void pop_back();
-
-    // Empty the vector on return. Release the internal buffer. Length
-    // and capacity are both 0 on return. If you want to keep the
-    // internal buffer around for reuse, call 'resize'/'erase' instead.
-    void clear();
-
-    void swap(vector& other);
-  private:
-    // @return New internal buffer size when it is adjusted automatically.
-    size_type grow() const;
-
-    // Calls the class' deallocator explicitely on each instance in
-    // the vector.
-    void deallocate();
-
-    pointer mBegin;
-    size_type mCapacity;
-    size_type mLength;
-    static const size_type kDefaultCapacity = 4;
-    static const size_type kExponentialFactor = 2;
-    static const size_type kExponentialLimit = 256;
-    static const size_type kLinearIncrement = 256;
-};
-
-
-// The implementation uses malloc instead of new because Posix states that:
-// The pointer returned if the allocation succeeds shall be suitably
-// aligned so that it may be assigned to a pointer to any type of
-// object and then used to access such an object in the space
-// allocated
-// So as long as we malloc() more than 4 bytes, the returned block
-// must be able to contain a pointer, and thus will be 32-bit
-// aligned. I believe the bionic implementation uses a minimum of 8 or 16.
-//
-// Invariant: mLength <= mCapacity <= max_size()
-
-template<typename _T>
-vector<_T>::vector()
-    :mBegin(NULL), mCapacity(0), mLength(0) { }
-
-template<typename _T>
-vector<_T>::vector(const size_type num, const value_type& init_value)
-{
-    if (num < max_size())
-    {
-        mBegin = static_cast<pointer>(malloc(num * sizeof(value_type)));
-        if (mBegin)
-        {
-            mLength = mCapacity =  num;
-            std::uninitialized_fill(mBegin, mBegin + mLength, init_value);
-            return;
-        }
-    }
-    mBegin = NULL;
-    mLength = mCapacity =  0;
-}
-
-template<typename _T>
-bool vector<_T>::reserve(size_type new_size)
-{
-    if (new_size == 0)
-    {
-        new_size = mLength ? mLength : kDefaultCapacity;
-    }
-    else if (new_size < mLength || new_size > max_size())
-    {
-        return false;
-    }
-
-    if (is_pod<value_type>::value)
-    {
-        pointer oldBegin = mBegin;
-        mBegin = static_cast<pointer>(realloc(mBegin, new_size * sizeof(value_type)));
-        if (!mBegin)
-        {
-            mBegin = oldBegin;
-            return false;
-        }
-    }
-    else
-    {
-        pointer newBegin =  static_cast<pointer>(malloc(new_size * sizeof(value_type)));
-        if (!newBegin) return false;
-
-        std::uninitialized_copy(mBegin, mBegin + mLength, newBegin);
-        if (mBegin) deallocate();
-        mBegin = newBegin;
-    }
-    mCapacity = new_size;
-    return true;
-}
-
-template<typename _T>
-void vector<_T>::push_back(const value_type& elt)
-{
-    if (max_size() == mLength) return;
-    if (mCapacity == mLength)
-    {
-        const size_type new_capacity = grow();
-        if (0 == new_capacity || !reserve(new_capacity)) return;
-    }
-    // mLength < mCapacity
-    *(mBegin + mLength) = elt;
-    ++mLength;
-}
-
-template<typename _T>
-void vector<_T>::pop_back()
-{
-    if (mLength > 0)
-    {
-        --mLength;
-    }
-}
-
-template<typename _T>
-void vector<_T>::clear()
-{
-    if(mBegin)
-    {
-        if (is_pod<value_type>::value)
-        {
-            free(mBegin);
-        }
-        else
-        {
-            deallocate();
-        }
-    }
-    mBegin = NULL;
-    mCapacity = 0;
-    mLength = 0;
-}
-
-template<typename _T>
-void vector<_T>::swap(vector& other)
-{
-    std::swap(mBegin, other.mBegin);
-    std::swap(mCapacity, other.mCapacity);
-    std::swap(mLength, other.mLength);
-}
-
-// Grow the capacity. Use exponential until kExponentialLimit then
-// linear until it reaches max_size().
-template<typename _T>
-typename vector<_T>::size_type vector<_T>::grow() const
-{
-    if (mCapacity < kDefaultCapacity)
-    {
-        return kDefaultCapacity;
-    }
-
-    size_type new_capacity;
-    if (mCapacity > kExponentialLimit)
-    {
-        new_capacity = mCapacity + kLinearIncrement;
-    }
-    else
-    {
-        new_capacity = mCapacity * kExponentialFactor;
-    }
-    if (mCapacity > new_capacity)
-    {  // overflow
-        return 0;  // overflow
-    }
-    else if (new_capacity > max_size())
-    { // cap at max_size() if not there already.
-        new_capacity = mCapacity == max_size() ? 0 : max_size();
-    }
-    return  new_capacity;
-}
-
-
-// mBegin should not be NULL.
-template<typename _T>
-void vector<_T>::deallocate()
-{
-    pointer begin = mBegin;
-    pointer end = mBegin + mLength;
-
-    for (; begin != end; ++begin)
-    {
-        begin->~_T();
-    }
-    free(mBegin);
-}
-
-}  // namespace std
-
-#endif  // ANDROID_ASTL_VECTOR__
diff --git a/src/Android.mk b/src/Android.mk
index bdadc95..0e1fb71 100644
--- a/src/Android.mk
+++ b/src/Android.mk
@@ -35,18 +35,3 @@ LOCAL_SYSTEM_SHARED_LIBRARIES := libc libstdc++ libutils
 LOCAL_MODULE:= libastl
 
 include $(BUILD_STATIC_LIBRARY)
-
-# Build the host lib
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := $(astl_common_src_files)
-
-LOCAL_C_INCLUDES := external/astl/include
-
-LOCAL_CFLAGS += -I bionic/libstdc++/include -I external/astl/include
-
-LOCAL_SYSTEM_SHARED_LIBRARIES := libc libstdc++ libutils
-
-LOCAL_MODULE:= libastl
-
-include $(BUILD_HOST_STATIC_LIBRARY)
diff --git a/tests/Android.mk b/tests/Android.mk
index 432dece..8451b23 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -44,32 +44,30 @@ endef
 # same as 'device-test' but builds a host executable instead
 # you can use EXTRA_LDLIBS to indicate additional linker flags
 #
-define host-test
-  $(foreach file,$(1), \
-    $(eval include $(CLEAR_VARS)) \
-    $(eval LOCAL_SRC_FILES := $(file)) \
-    $(eval LOCAL_MODULE := $(notdir $(file:%.cpp=%))) \
-    $(eval $(info LOCAL_MODULE=$(LOCAL_MODULE) file=$(file))) \
-    $(eval LOCAL_CFLAGS += $(EXTRA_CFLAGS))  \
-    $(eval LOCAL_LDLIBS += $(EXTRA_LDLIBS)) \
-    $(eval LOCAL_MODULE_TAGS := eng tests) \
-    $(eval LOCAL_STATIC_LIBRARIES := libastl) \
-    $(eval include $(BUILD_HOST_EXECUTABLE)) \
-  ) \
-  $(eval EXTRA_CFLAGS :=) \
-  $(eval EXTRA_LDLIBS :=)
-endef
+# define host-test
+#   $(foreach file,$(1), \
+#     $(eval include $(CLEAR_VARS)) \
+#     $(eval LOCAL_SRC_FILES := $(file)) \
+#     $(eval LOCAL_MODULE := $(notdir $(file:%.cpp=%))) \
+#     $(eval $(info LOCAL_MODULE=$(LOCAL_MODULE) file=$(file))) \
+#     $(eval LOCAL_CFLAGS += $(EXTRA_CFLAGS))  \
+#     $(eval LOCAL_LDLIBS += $(EXTRA_LDLIBS)) \
+#     $(eval LOCAL_MODULE_TAGS := eng tests) \
+#     $(eval LOCAL_STATIC_LIBRARIES := libastl) \
+#     $(eval include $(BUILD_HOST_EXECUTABLE)) \
+#   ) \
+#   $(eval EXTRA_CFLAGS :=) \
+#   $(eval EXTRA_LDLIBS :=)
+# endef
 
 sources := \
     test_algorithm.cpp \
     test_string.cpp \
-    test_type_traits.cpp \
-	test_uninitialized.cpp \
-    test_vector.cpp
+    test_type_traits.cpp
 
 # Disable all optimization for the host target to help test tools (valgrind...)
-EXTRA_CFLAGS := -I bionic/libstdc++/include -I external/astl/include -g -O0
-$(call host-test, $(sources))
+# EXTRA_CFLAGS := -I bionic/libstdc++/include -I external/astl/include -g -O0
+# $(call host-test, $(sources))
 
 EXTRA_CFLAGS := -I bionic/libstdc++/include -I external/astl/include
 $(call device-test, $(sources))
diff --git a/tests/common.h b/tests/macros.h
index 1942018..1ef577f 100644
--- a/tests/common.h
+++ b/tests/macros.h
@@ -27,65 +27,27 @@
  * SUCH DAMAGE.
  */
 
-#ifndef ANDROID_ASTL_TESTS_COMMON__
-#define ANDROID_ASTL_TESTS_COMMON__
+#ifndef ANDROID_ASTL_TESTS_MACROS__
+#define ANDROID_ASTL_TESTS_MACROS__
+
+// Common macros for tests.
 #include <cstdio>
 
-// Classes and macros used in tests.
 namespace {
-const size_t kMaxSizeT = ~((size_t)0);
 const int kPassed = 0;
 const int kFailed = 1;
 #define FAIL_UNLESS(v) if (!android::v()) return kFailed;
 
-#define EXPECT_TRUE(expr)                                   \
-    if (!(expr)) {                                          \
+#define EXPECT_TRUE(expr)                                       \
+    if (!(expr)) {                                              \
         std::fprintf(stderr, "%d: %s\n", __LINE__, #expr);	\
-        return false;                                       \
+        return false;                                           \
     }
 
 #ifndef ARRAYSIZE
 #define ARRAYSIZE(array) (sizeof(array)/sizeof(array[0]))
 #endif
 
-// Cannot be copied.
-struct NoCopy {
-  private:
-    NoCopy(const NoCopy& nc) {}
-};
-
-// Count the number of assignement.
-struct CopyCounter {
-    static size_t mCount;
-
-    CopyCounter() { }
-    CopyCounter& operator=(const CopyCounter& cc) {return *this; }
-    CopyCounter(const CopyCounter& nc) {++mCount;}
-  private:
-};
-
-class CtorDtorCounter {
-  public:
-    static size_t mCtorCount;
-    static size_t mCopyCtorCount;
-    static size_t mAssignCount;
-    static size_t mDtorCount;
-
-    CtorDtorCounter() {++mCtorCount;}
-    CtorDtorCounter(const CtorDtorCounter& nc) {++mCopyCtorCount;}
-    CtorDtorCounter& operator=(const CtorDtorCounter& nc) {++mAssignCount; return *this;}
-    ~CtorDtorCounter() {++mDtorCount;}
-    static void reset() {mCtorCount = 0; mCopyCtorCount = 0; mAssignCount = 0; mDtorCount = 0;}
-  private:
-};
-
-size_t CopyCounter::mCount;
-size_t CtorDtorCounter::mCtorCount;
-size_t CtorDtorCounter::mCopyCtorCount;
-size_t CtorDtorCounter::mAssignCount;
-size_t CtorDtorCounter::mDtorCount;
-
 }  // anonymous namespace
 
-
-#endif  // ANDROID_ASTL_TEST_COMMON__
+#endif  // ANDROID_ASTL_TEST_MACROS__
diff --git a/tests/test_algorithm.cpp b/tests/test_algorithm.cpp
index e00bb67..831e1fd 100644
--- a/tests/test_algorithm.cpp
+++ b/tests/test_algorithm.cpp
@@ -31,7 +31,7 @@
 #ifndef ANDROID_ASTL_ALGORITHM__
 #error "Wrong header included!!"
 #endif
-#include "common.h"
+#include "macros.h"
 
 namespace android {
 
diff --git a/tests/test_string.cpp b/tests/test_string.cpp
index bd69a46..130f98b 100644
--- a/tests/test_string.cpp
+++ b/tests/test_string.cpp
@@ -33,8 +33,11 @@
 #endif
 #include <climits>
 #include <cstring>
-#include "common.h"
+#include "macros.h"
 
+#ifndef MAX_SIZE_T
+#define MAX_SIZE_T           (~(size_t)0)
+#endif
 
 namespace android {
 using std::string;
@@ -318,7 +321,7 @@ bool testReserve()
     str07.reserve(10);
     EXPECT_TRUE(str07.capacity() == 10);
 
-    str07.reserve(kMaxSizeT);
+    str07.reserve(MAX_SIZE_T);
 
     EXPECT_TRUE(str07.capacity() == 10);
 
@@ -380,9 +383,9 @@ bool testAppend()
     string str12("original");
     char dummy[] = "unused";
     // We lie about the size but that is ok. Since the lenght of the new string
-    // is going to be kMaxSizeT, the call will have not effect (there is no
+    // is going to be MAX_SIZE_T, the call will have not effect (there is no
     // space for the trailing '\0').
-    str12.append(dummy, kMaxSizeT);
+    str12.append(dummy, MAX_SIZE_T);
     EXPECT_TRUE(str12 == "original");
 
     return true;
@@ -796,11 +799,11 @@ bool testErase()
     EXPECT_TRUE(empty_string.capacity() == 0);
     EXPECT_TRUE(empty_string.size() == 0);
 
-    empty_string.erase(kMaxSizeT);
+    empty_string.erase(MAX_SIZE_T);
     EXPECT_TRUE(empty_string.capacity() == 0);
     EXPECT_TRUE(empty_string.size() == 0);
 
-    empty_string.erase(kMaxSizeT, kMaxSizeT);
+    empty_string.erase(MAX_SIZE_T, MAX_SIZE_T);
     EXPECT_TRUE(empty_string.capacity() == 0);
     EXPECT_TRUE(empty_string.size() == 0);
   }
@@ -816,7 +819,7 @@ bool testErase()
   {
     string str02("a");
 
-    str02.erase(kMaxSizeT);
+    str02.erase(MAX_SIZE_T);
     EXPECT_TRUE(str02.capacity() == 1);
     EXPECT_TRUE(str02.size() == 1);
   }
@@ -824,7 +827,7 @@ bool testErase()
   {
     string str03("a");
 
-    str03.erase(0, kMaxSizeT);
+    str03.erase(0, MAX_SIZE_T);
     EXPECT_TRUE(str03.capacity() == 1);
     EXPECT_TRUE(str03.size() == 0);
   }
@@ -832,7 +835,7 @@ bool testErase()
   {
     string str04("a");
 
-    str04.erase(1, kMaxSizeT);
+    str04.erase(1, MAX_SIZE_T);
     EXPECT_TRUE(str04.capacity() == 1);
     EXPECT_TRUE(str04.size() == 1);
   }
diff --git a/tests/test_type_traits.cpp b/tests/test_type_traits.cpp
index ef3690b..a5bba4c 100644
--- a/tests/test_type_traits.cpp
+++ b/tests/test_type_traits.cpp
@@ -31,7 +31,7 @@
 #error "Wrong header included!!"
 #endif
 
-#include "common.h"
+#include "macros.h"
 
 namespace android {
 
diff --git a/tests/test_uninitialized.cpp b/tests/test_uninitialized.cpp
deleted file mode 100644
index 808e836..0000000
--- a/tests/test_uninitialized.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * 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.
- *
- * 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 "../include/memory"
-#ifndef ANDROID_ASTL_MEMORY__
-#error "Wrong header included!!"
-#endif
-#include "common.h"
-#include <algorithm>
-#include <cstdlib>
-
-namespace android {
-using std::uninitialized_copy;
-using std::uninitialized_fill;
-
-bool testCopyPod()
-{
-    int src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-    const int size = ARRAYSIZE(src);
-    int dest[size] = {0, };
-
-    EXPECT_TRUE(uninitialized_copy(src, src + size, dest) == dest);
-
-    EXPECT_TRUE(std::equal(src, src + size, dest));
-    return true;
-}
-
-
-bool testCopyPodOverflow()
-{
-    int src, dest;
-
-    // Should not crash
-    EXPECT_TRUE(uninitialized_copy(&src, &src + kMaxSizeT / sizeof(src) + 1, &dest) == &dest);
-    return true;
-}
-
-bool testCopyClass()
-{
-    const size_t kSize = 100;
-    CtorDtorCounter::reset();
-
-    CtorDtorCounter src[kSize];
-    CtorDtorCounter *dest = static_cast<CtorDtorCounter*>(malloc(kSize * sizeof(CtorDtorCounter)));
-
-    EXPECT_TRUE(CtorDtorCounter::mCtorCount == kSize);
-    EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-
-    CtorDtorCounter::reset();
-
-    EXPECT_TRUE(uninitialized_copy(src, src + kSize, dest) == dest);
-
-    EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
-    EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == kSize);
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-    free(dest);
-    return true;
-}
-
-struct A {};
-bool testCopyArray()
-{
-    {
-        const A src[] = {A()};
-        A one;
-        A *dest = &one;
-
-        EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest);
-    }
-    {
-        A src[] = {A()};
-        A one;
-        A *dest = &one;
-
-        EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest);
-    }
-    {
-        const A src[] = {A()};
-        A dest[1];
-
-        EXPECT_TRUE(uninitialized_copy(src, src + 1, dest) == dest);
-    }
-    return true;
-}
-
-bool testFillChar()
-{
-    const char src[] = {'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a'};
-    const int size = ARRAYSIZE(src);
-    char dest[size];
-
-    uninitialized_fill(dest, dest + size, 'a');
-
-    EXPECT_TRUE(std::equal(dest, dest + size, src));
-    return true;
-}
-
-bool testFillPod()
-{
-    const int src[] = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
-    const int size = ARRAYSIZE(src);
-    int dest[size];
-
-    uninitialized_fill(dest, dest + size, 10);
-
-    EXPECT_TRUE(std::equal(dest, dest + size, src));
-    return true;
-}
-
-bool testFillClass()
-{
-    const size_t kSize = 100;
-    CtorDtorCounter::reset();
-
-    CtorDtorCounter src;
-    CtorDtorCounter *dest = static_cast<CtorDtorCounter*>(malloc(kSize * sizeof(CtorDtorCounter)));
-
-    EXPECT_TRUE(CtorDtorCounter::mCtorCount == 1);
-    EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-
-    CtorDtorCounter::reset();
-
-    uninitialized_fill(dest, dest + kSize, src);
-
-    EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
-    EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == kSize);
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-    free(dest);
-    return true;
-}
-
-
-}  // namespace android
-
-int main(int argc, char **argv)
-{
-    // copy
-    FAIL_UNLESS(testCopyPod);
-    FAIL_UNLESS(testCopyPodOverflow);
-    FAIL_UNLESS(testCopyClass);
-    FAIL_UNLESS(testCopyArray);
-    // fill
-    FAIL_UNLESS(testFillChar);
-    FAIL_UNLESS(testFillPod);
-    FAIL_UNLESS(testFillClass);
-
-    return kPassed;
-}
diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
deleted file mode 100644
index 01b3b10..0000000
--- a/tests/test_vector.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- * 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.
- *
- * 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 "../include/vector"
-#ifndef ANDROID_ASTL_VECTOR__
-#error "Wrong header included!!"
-#endif
-#include <climits>
-#include <cstring>
-#include "common.h"
-
-namespace android {
-using std::vector;
-static const size_t kDefaultCapacity = 4;
-static const size_t kExponentialFactor = 2;
-bool testConstructorInt()
-{
-    {
-        vector<int> vec1;
-        EXPECT_TRUE(vec1.empty());
-        EXPECT_TRUE(vec1.size() == 0);
-        EXPECT_TRUE(vec1.capacity() == 0);
-    }
-    {
-        vector<int> vec2(100);
-        EXPECT_TRUE(!vec2.empty());
-        EXPECT_TRUE(vec2.size() == 100);
-        EXPECT_TRUE(vec2.capacity() == 100);
-        for (size_t i = 0; i < 100; ++i)
-        {
-            EXPECT_TRUE(vec2[i] == 0);
-        }
-    }
-    {
-        vector<int> vec3(200, 0xaa);
-        EXPECT_TRUE(!vec3.empty());
-        EXPECT_TRUE(vec3.size() == 200);
-        EXPECT_TRUE(vec3.capacity() == 200);
-        for (size_t i = 0; i < 200; ++i)
-        {
-            EXPECT_TRUE(vec3[i] == 0xaa);
-        }
-    }
-    return true;
-}
-
-typedef enum { ONE = 10, TWO} TestEnum;
-
-template<typename T> struct A { };
-struct B { };
-
-bool testConstructorRepeat()
-{
-    {
-        const vector<int> vec1(100, 10);
-
-        EXPECT_TRUE(vec1.end() - vec1.begin() == 100);
-        for (int i = 0; i < 100; ++i)
-        {
-            EXPECT_TRUE(vec1[i] == 10);
-        }
-    }
-    {
-        const vector<float> vec2(100, 10.0f);
-
-        for (int i = 0; i < 100; ++i)
-        {
-            EXPECT_TRUE(vec2[i] == 10.0f);
-        }
-    }
-    {
-        const vector<TestEnum> vec3(100, ONE);
-
-        for (int i = 0; i < 100; ++i)
-        {
-            EXPECT_TRUE(vec3[i] == ONE);
-        }
-    }
-    {
-        const vector< A<B> > vec4;
-        const vector< A<B> > vec5(10);
-
-        EXPECT_TRUE(vec4.size() == 0);
-        EXPECT_TRUE(vec5.size() == 10);
-    }
-    return true;
-}
-
-
-bool testReserve()
-{
-    { // basic reserve + shrink.
-        vector<int> vec1(100, 10);
-
-        EXPECT_TRUE(vec1.capacity() == 100);
-        EXPECT_TRUE(vec1.reserve(200));
-        EXPECT_TRUE(vec1.capacity() == 200);
-        EXPECT_TRUE(vec1.size() == 100);
-
-        EXPECT_TRUE(vec1.reserve());
-        EXPECT_TRUE(vec1.capacity() == 100);
-        EXPECT_TRUE(vec1.size() == 100);
-    }
-    {
-        vector<int> vec2;
-
-        EXPECT_TRUE(vec2.capacity() == 0);
-        vec2.reserve(200);
-        EXPECT_TRUE(vec2.capacity() == 200);
-        vec2.reserve();
-        EXPECT_TRUE(vec2.capacity() == kDefaultCapacity);
-        vec2.push_back(3);
-        EXPECT_TRUE(vec2.capacity() == kDefaultCapacity);
-    }
-    {
-        vector<int> vec3;
-
-        vec3.push_back(5);
-        vec3.reserve();
-        EXPECT_TRUE(vec3.capacity() == 1);
-        vec3.push_back(3);
-        EXPECT_TRUE(vec3.capacity() == kDefaultCapacity);
-        for (int i = 0; i < 2; ++i) vec3.push_back(3);
-        EXPECT_TRUE(vec3.size() == kDefaultCapacity);
-        EXPECT_TRUE(vec3.capacity() == kDefaultCapacity);
-
-        // exp increment.
-        vec3.push_back(10);
-        EXPECT_TRUE(vec3.capacity() == kExponentialFactor * kDefaultCapacity);
-    }
-    {
-        CopyCounter c;
-
-        c.mCount = 0;
-        vector<CopyCounter> vec4(100, c);
-        EXPECT_TRUE(c.mCount == 100);
-        // Resizing does not do any copy via the copy assignement op.
-        vec4.reserve(1000);
-        EXPECT_TRUE(c.mCount == 200);
-        vec4.reserve(50); // reserving less than length is a nop.
-        EXPECT_TRUE(c.mCount == 200);
-    }
-    {
-        vector<unsigned short> vec5;
-
-        EXPECT_TRUE(!vec5.reserve(vec5.max_size() + 1));
-        EXPECT_TRUE(vec5.capacity() == 0);
-    }
-    return true;
-}
-
-
-bool testPushBack()
-{
-    {
-        vector<CtorDtorCounter> vec1;
-        CtorDtorCounter c;
-
-        c.reset();
-        for (int i = 0; i < 1000; ++i)
-        {
-            vec1.push_back(c);
-        }
-        EXPECT_TRUE(vec1.capacity() == 1024);
-        EXPECT_TRUE(vec1.size() == 1000);
-        EXPECT_TRUE(c.mAssignCount == 1000);
-        // Due to the multiple augmentation of the capacity, the copy
-        // constructor has been invoked.
-        EXPECT_TRUE(c.mCopyCtorCount > 0);
-        EXPECT_TRUE(c.mCtorCount == 0);
-    }
-    {
-        vector<int> vec2;
-
-        vec2.push_back(10);
-        EXPECT_TRUE(vec2.front() == 10);
-        EXPECT_TRUE(vec2.back() == 10);
-        EXPECT_TRUE(vec2.size() == 1);
-        vec2.push_back(20);
-        EXPECT_TRUE(vec2.front() == 10);
-        EXPECT_TRUE(vec2.back() == 20);
-        EXPECT_TRUE(vec2.size() == 2);
-    }
-    return true;
-}
-
-
-bool testPopBack()
-{
-    vector<int> vec1(10, 0xdeadbeef);;
-
-    EXPECT_TRUE(vec1.capacity() == 10);
-    EXPECT_TRUE(vec1.size() == 10);
-
-    for(size_t i = 10; i > 0; --i)
-    {
-        EXPECT_TRUE(vec1.capacity() == 10);
-        EXPECT_TRUE(vec1.size() == i);
-        vec1.pop_back();
-    }
-    EXPECT_TRUE(vec1.empty());
-    EXPECT_TRUE(vec1.begin() == vec1.end());
-    vec1.pop_back(); // pop_back on empty vector
-    EXPECT_TRUE(vec1.size() == 0);
-    EXPECT_TRUE(vec1.capacity() == 10);
-
-    vec1.clear();
-    vec1.pop_back(); // pop_back on empty vector
-    EXPECT_TRUE(vec1.size() == 0);
-    EXPECT_TRUE(vec1.capacity() == 0);
-    EXPECT_TRUE(vec1.begin() == vec1.end());
-    EXPECT_TRUE(vec1.begin() == NULL);
-    return true;
-}
-
-
-bool testSwap()
-{
-    vector<int> vec1(100, 10);
-    vector<int> vec2;
-
-    vec1.swap(vec2);
-
-    EXPECT_TRUE(vec1.capacity() == 0);
-    EXPECT_TRUE(vec2.capacity() == 100);
-
-    EXPECT_TRUE(vec1.size() == 0);
-    EXPECT_TRUE(vec2.size() == 100);
-
-    EXPECT_TRUE(vec1.begin() == vec1.end());
-    EXPECT_TRUE(vec2.begin() != vec2.end());
-    return true;
-}
-
-
-bool testIterators()
-{
-    vector<int> vec1(10);
-
-    for (size_t i = 0; i < 10; ++i)
-    {
-        vec1[i] = i;
-    }
-
-    vector<int>::iterator i = vec1.begin();
-    for (int c = 0; i != vec1.end(); ++i, ++c)
-    {
-        EXPECT_TRUE(c == *i);
-    }
-
-    vector<int>::const_iterator j = vec1.begin();
-    for (int c = 0; j != vec1.end(); ++j, ++c)
-    {
-        EXPECT_TRUE(c == *j);
-    }
-    return true;
-}
-
-bool testCtorDtorForNonPod()
-{
-    {  // empty vector, no construction should happen.
-        CtorDtorCounter::reset();
-        vector<CtorDtorCounter> vec1;
-
-        EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
-        EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
-    }
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-
-    {
-        CtorDtorCounter instance;
-        EXPECT_TRUE(CtorDtorCounter::mCtorCount == 1);
-        CtorDtorCounter::reset();
-
-        vector<CtorDtorCounter> vec2(200, instance);
-
-        // 200 copies by assignement of the sample instance
-        EXPECT_TRUE(CtorDtorCounter::mAssignCount == 0);
-        EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
-        EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 200);
-        EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
-
-        CtorDtorCounter::reset();
-        vec2.reserve(400);
-
-        // 200 moves: 200 copies by copy constructor and 200 destructions.
-        EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 200);
-        EXPECT_TRUE(CtorDtorCounter::mDtorCount == 200);
-        EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
-        EXPECT_TRUE(CtorDtorCounter::mAssignCount == 0);
-
-        CtorDtorCounter::reset();
-    }
-    // 200 + 1 for the instance
-    EXPECT_TRUE(CtorDtorCounter::mDtorCount == 201);
-    return true;
-}
-}  // namespace android
-
-int main(int argc, char **argv)
-{
-    FAIL_UNLESS(testConstructorInt);
-    FAIL_UNLESS(testConstructorRepeat);
-    FAIL_UNLESS(testReserve);
-    FAIL_UNLESS(testPushBack);
-    FAIL_UNLESS(testPopBack);
-    FAIL_UNLESS(testSwap);
-    FAIL_UNLESS(testIterators);
-    FAIL_UNLESS(testCtorDtorForNonPod);
-    return kPassed;
-}