Home | History | Annotate | Download | only in tests 
      1 /* -*- c++ -*- */
      2 /*
      3  * Copyright (C) 2009 The Android Open Source Project
      4  * All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  *  * Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  *  * Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in
     13  *    the documentation and/or other materials provided with the
     14  *    distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     19  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
     20  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     22  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
     23  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     24  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
     26  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     27  * SUCH DAMAGE.
     28  */
     29 
     30 #ifndef ANDROID_ASTL_TESTS_COMMON__
     31 #define ANDROID_ASTL_TESTS_COMMON__
     32 #include <cstdio>
     33 
     34 // Classes and macros used in tests.
     35 namespace {
     36 const size_t kMaxSizeT = ~((size_t)0);
     37 const int kPassed = 0;
     38 const int kFailed = 1;
     39 #define FAIL_UNLESS(v) if (!android::v()) return kFailed;
     40 
     41 #define EXPECT_TRUE(expr)                                   \
     42     if (!(expr)) {                                          \
     43         std::fprintf(stderr, "%d: %s\n", __LINE__, #expr);	\
     44         return false;                                       \
     45     }
     46 
     47 #define EXPECT_FALSE(expr) EXPECT_TRUE(!(expr))
     48 
     49 
     50 #ifndef ARRAYSIZE
     51 #define ARRAYSIZE(array) (sizeof(array)/sizeof(array[0]))
     52 #endif
     53 
     54 // Cannot be copied.
     55 struct NoCopy {
     56   private:
     57     NoCopy(const NoCopy& nc) {}
     58 };
     59 
     60 // Count the number of assignement.
     61 struct CopyCounter {
     62     static size_t mCount;
     63 
     64     CopyCounter() { }
     65     CopyCounter& operator=(const CopyCounter& cc) {return *this; }
     66     CopyCounter(const CopyCounter& nc) {++mCount;}
     67   private:
     68 };
     69 
     70 class CtorDtorCounter {
     71   public:
     72     static size_t mCtorCount;
     73     static size_t mCopyCtorCount;
     74     static size_t mAssignCount;
     75     static size_t mDtorCount;
     76 
     77     CtorDtorCounter() {++mCtorCount;}
     78     CtorDtorCounter(const CtorDtorCounter& nc) {++mCopyCtorCount;}
     79     CtorDtorCounter& operator=(const CtorDtorCounter& nc) {++mAssignCount; return *this;}
     80     ~CtorDtorCounter() {++mDtorCount;}
     81     static void reset() {mCtorCount = 0; mCopyCtorCount = 0; mAssignCount = 0; mDtorCount = 0;}
     82     static void printf() {
     83         std::fprintf(stderr, "CtorDtorCounter: %d %d %d %d\n",
     84                      mCtorCount, mCopyCtorCount, mAssignCount, mDtorCount);
     85     }
     86   private:
     87 };
     88 
     89 size_t CopyCounter::mCount;
     90 size_t CtorDtorCounter::mCtorCount;
     91 size_t CtorDtorCounter::mCopyCtorCount;
     92 size_t CtorDtorCounter::mAssignCount;
     93 size_t CtorDtorCounter::mDtorCount;
     94 
     95 // These class allocate chunks to detect memory leaks.
     96 template<typename T> struct A {
     97   public:
     98     A() {mChunk = new T[2046];}
     99     A(const A<T>& a) {mChunk = new T[2046];}
    100     virtual ~A() {delete [] mChunk;}
    101     A& operator=(const A& o) { return *this;}
    102     T *mChunk;
    103 };
    104 
    105 struct B {
    106   public:
    107     B() {mChunk = new char[2046];}
    108     B(const B& b) {mChunk = new char[2046];}
    109     virtual ~B() {delete [] mChunk;}
    110     B& operator=(const B& o) { return *this;}
    111     char *mChunk;
    112 };
    113 
    114 }  // anonymous namespace
    115 
    116 
    117 #endif  // ANDROID_ASTL_TEST_COMMON__
    118