| // Copyright (C) 2013 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 MINITEST_MINITEST_H |
| #define MINITEST_MINITEST_H |
| |
| // Minitest is a minimalistic unit testing framework designed specifically |
| // for the Android support library. |
| // |
| // - Unit tests must be written in C++, but no C++ runtime implementation |
| // is either required or _supported_. This is by design. |
| // |
| // _ Inspired by GoogleTest, you can use the TEST macro to define a new |
| // test case easily, and it can contain EXPECT_XX|ASSERT_XX statements. |
| // |
| // For example: |
| // |
| // TEST(stdio, strlen) { |
| // EXPECT_EQ(3, strlen("foo")); |
| // EXPECT_EQ(1, srlen("a")); |
| // } |
| // |
| // However, there are important differences / limitations: |
| // |
| // o You cannot stream strings into an except or assert statement. |
| // Minitest provides a TEST_TEXT macro to do that instead. |
| // |
| // In other words, replace: |
| // |
| // EXPECT_EQ(expected, expression) << "When checking 'foo'"; |
| // |
| // With: |
| // TEST_TEXT << "When checking 'foo'"; |
| // EXPECT_EQ(expected, expression); |
| // |
| // The context text is only printed on failure. |
| // |
| // o TEST_F() is not supported (for now). |
| // |
| // o EXPECT/ASSERT statements only work inside a TESET() function, not |
| // in a function called by it. |
| // |
| // o No test death detection. |
| // |
| // - You can use minitest::Format() to stream formatted output into |
| // a TEST_TEXT context, as in: |
| // |
| // for (size_t n = 0; n < kMaxCount; n++) { |
| // TEST_TEXT << "Checking string : " |
| // << minitest;:Format("%z/%z", n+1, kMaxCount); |
| // EXPECT_EQ(kExpected[n], Foo(kString[n])); |
| // } |
| // |
| #include <stdio.h> |
| #include <string.h> |
| |
| namespace minitest { |
| |
| namespace internal { |
| |
| // AddConst<T>::type adds a 'const' qualifier to type T. |
| // Examples: |
| // int -> const int |
| // char* -> const char* const |
| // const char* -> const char* const |
| // char* const -> const char* const |
| template <typename T> |
| struct AddConst { |
| typedef const T type; |
| }; |
| template <typename T> |
| struct AddConst<const T> { |
| typedef const T type; |
| }; |
| template <typename T> |
| struct AddConst<T*> { |
| typedef const T* const type; |
| }; |
| template <typename T> |
| struct AddConst<const T*> { |
| typedef const T* const type; |
| }; |
| |
| // String class used to accumulate error messages. |
| // Very similar to std::string but also supports streaming into it |
| // for easier formatted output, as in: |
| // |
| // String str; |
| // int x = 42; |
| // str << "x is '" << x << "'\n"; |
| // |
| // You can also use minitest::Format() as in: |
| // |
| // str << minitest::Format("Hex value %08x\n", x); |
| // |
| class String { |
| public: |
| String() : str_(NULL), size_(0), capacity_(0) {} |
| String(const char* str, size_t len); |
| |
| explicit String(const char* str) { String(str, ::strlen(str)); } |
| |
| String(const String& other) { String(other.str_, other.size_); } |
| |
| String& operator=(const String& other) { |
| (*this) += other; |
| return *this; |
| } |
| |
| char& operator[](size_t index) { return str_[index]; } |
| |
| ~String() { Clear(); } |
| |
| const char* c_str() const { return str_; } |
| const char* data() const { return str_; } |
| size_t size() const { return size_; } |
| bool empty() const { return size_ == 0; } |
| |
| String& operator+=(const String& other); |
| String& operator+=(const char* str); |
| String& operator+=(char ch); |
| |
| String operator+(const String& other) const { |
| String result(*this); |
| result += other; |
| return result; |
| } |
| |
| String operator+(const char* str) const { |
| String result(*this); |
| result += str; |
| return result; |
| } |
| |
| // Basic formatting operators. |
| String& operator<<(const String& other); |
| String& operator<<(const char* str); |
| |
| #define MINITEST_OPERATOR_LL_(ParamType) String& operator<<(ParamType v) |
| |
| MINITEST_OPERATOR_LL_(bool); |
| MINITEST_OPERATOR_LL_(char); |
| MINITEST_OPERATOR_LL_(signed char); |
| MINITEST_OPERATOR_LL_(short); |
| MINITEST_OPERATOR_LL_(int); |
| MINITEST_OPERATOR_LL_(long); |
| MINITEST_OPERATOR_LL_(long long); |
| MINITEST_OPERATOR_LL_(unsigned char); |
| MINITEST_OPERATOR_LL_(unsigned short); |
| MINITEST_OPERATOR_LL_(unsigned int); |
| MINITEST_OPERATOR_LL_(unsigned long); |
| MINITEST_OPERATOR_LL_(unsigned long long); |
| MINITEST_OPERATOR_LL_(float); |
| MINITEST_OPERATOR_LL_(double); |
| MINITEST_OPERATOR_LL_(long double); |
| MINITEST_OPERATOR_LL_(const void*); |
| |
| #undef MINITEST_OPERATOR_LL_ |
| |
| void Clear(); |
| void Resize(size_t new_size); |
| |
| private: |
| void Reserve(size_t new_capacity); |
| char* str_; |
| size_t size_; |
| size_t capacity_; |
| }; |
| |
| } // namespace internal |
| |
| // A helper function that can be used to generate formatted output |
| // as a temporary string. Use like printf(), but returns a new String |
| // object. Useful to stream into TEST_TEXT() objects, as in: |
| // |
| // TEST_TEXT << "Using " |
| // << minitest::Format("%08d", bytes) |
| // << " bytes"; |
| // |
| internal::String Format(const char* format, ...); |
| |
| class TestCase { |
| public: |
| enum Result { |
| PASS = 0, |
| FAIL, |
| FATAL |
| }; |
| |
| TestCase() : result_(PASS) {} |
| ~TestCase() {} |
| |
| void Failure(); |
| void FatalFailure(); |
| |
| Result result() { return result_; } |
| |
| internal::String& GetText(); |
| |
| private: |
| Result result_; |
| internal::String text_; |
| }; |
| |
| // Type of a function defined through the TEST(<test>,<case>) macro. |
| typedef void(TestFunction)(TestCase* testcase); |
| |
| // Used internally to register new test functions. |
| void RegisterTest(const char* test_name, |
| const char* case_name, |
| TestFunction* test_function); |
| |
| #define MINITEST_TEST_FUNCTION(testname, casename) \ |
| MINITEST_TEST_FUNCTION_(testname, casename) |
| |
| #define MINITEST_TEST_FUNCTION_(testname, casename) \ |
| minitest_##testname##_##casename |
| |
| #define TEST(testname, casename) \ |
| static void MINITEST_TEST_FUNCTION(testname, casename)(minitest::TestCase*); \ |
| static void \ |
| __attribute__((constructor)) RegisterMiniTest##testname##_##casename() { \ |
| minitest::RegisterTest( \ |
| #testname, #casename, &MINITEST_TEST_FUNCTION(testname, casename)); \ |
| } \ |
| void MINITEST_TEST_FUNCTION(testname, \ |
| casename)(minitest::TestCase* minitest_testcase) |
| |
| // Use this macro to add context text before an EXPECT or ASSERT statement |
| // For example: |
| // |
| // for (size_t n = 0; n < MAX; ++n) { |
| // TEST_TEXT << "When checking " << kStrings[n]; |
| // EXPECT_STREQ(kExpected[n], kStrings[n]); |
| // } |
| // |
| // The text will only be printed in case of failure in the next |
| // EXPECT/ASSERT statement. |
| // |
| #define TEST_TEXT minitest_testcase->GetText() |
| |
| // EXPECT_TRUE() must evaluate to something that supports the << operator |
| // to receive debugging strings only in case of failure. |
| #define EXPECT_TRUE(expression) \ |
| do { \ |
| if (!(expression)) { \ |
| printf( \ |
| "EXPECT_TRUE:%s:%d: expression '%s' returned 'false', expected " \ |
| "'true'\n", \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->Failure(); \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_FALSE(expression) \ |
| do { \ |
| if (!!(expression)) { \ |
| printf( \ |
| "EXPECT_FALSE:%s:%d: expression '%s' returned 'true', expected " \ |
| "'false'\n", \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->Failure(); \ |
| } \ |
| } while (0) |
| |
| #define MINITEST_DEFINE_LOCAL_EXPR_(varname, expr) \ |
| typedef minitest::internal::AddConst<__typeof__(expr)>::type varname##Type; \ |
| const varname##Type varname = (expr); |
| |
| #define MINITEST_EXPECT_ASSERT_BINOP_( \ |
| opname, op, expected, expression, is_assert) \ |
| do { \ |
| MINITEST_DEFINE_LOCAL_EXPR_(minitest_expected, expected); \ |
| MINITEST_DEFINE_LOCAL_EXPR_(minitest_actual, expression); \ |
| if (!(minitest_actual op minitest_expected)) { \ |
| printf("%s" #opname ":%s:%d: with expression '%s'\n", \ |
| is_assert ? "ASSERT_" : "EXPECT_", \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest::internal::String minitest_str; \ |
| minitest_str << minitest_actual; \ |
| printf("actual : %s\n", minitest_str.c_str()); \ |
| minitest_str.Clear(); \ |
| minitest_str << minitest_expected; \ |
| printf("expected : %s\n", minitest_str.c_str()); \ |
| if (is_assert) { \ |
| minitest_testcase->FatalFailure(); \ |
| return; \ |
| } \ |
| minitest_testcase->Failure(); \ |
| } \ |
| } while (0) |
| |
| #define MINITEST_EXPECT_BINOP_(opname, op, expected, expression) \ |
| MINITEST_EXPECT_ASSERT_BINOP_(opname, op, expected, expression, false) |
| |
| #define EXPECT_EQ(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(EQ, ==, expected, expression) |
| |
| #define EXPECT_NE(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(NE, !=, expected, expression) |
| |
| #define EXPECT_LE(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(LE, <=, expected, expression) |
| |
| #define EXPECT_LT(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(LT, <, expected, expression) |
| |
| #define EXPECT_GE(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(GE, >=, expected, expression) |
| |
| #define EXPECT_GT(expected, expression) \ |
| MINITEST_EXPECT_BINOP_(GT, >, expected, expression) |
| |
| #define MINITEST_EXPECT_ASSERT_STR_(expected, expression, is_eq, is_assert) \ |
| do { \ |
| const char* minitest_prefix = is_assert ? "ASSERT_STR" : "EXPECT_STR"; \ |
| const char* minitest_suffix = is_eq ? "EQ" : "NEQ"; \ |
| const char* minitest_expected = (expected); \ |
| const char* minitest_actual = (expression); \ |
| if (minitest_actual == NULL) { \ |
| printf("%s%s:%s:%d: expression '%s' is NULL!\n", \ |
| minitest_prefix, \ |
| minitest_suffix, \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->Failure(); \ |
| } else { \ |
| bool minitest_eq = !strcmp(minitest_expected, minitest_actual); \ |
| if (minitest_eq != is_eq) { \ |
| printf("%s%s:%s:%d: with expression '%s'\n", \ |
| minitest_prefix, \ |
| minitest_suffix, \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| printf("actual : %s\n", minitest_actual); \ |
| printf("expected : %s\n", minitest_expected); \ |
| minitest_testcase->Failure(); \ |
| } \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_STREQ(expected, expression) \ |
| MINITEST_EXPECT_ASSERT_STR_(expected, expression, true, false) |
| |
| #define EXPECT_STRNEQ(expected, expression) \ |
| MINITEST_EXPECT_ASSERT_STR_(expected, expression, false, false) |
| |
| #define MINITEST_EXPECT_ASSERT_MEM_( \ |
| expected, expected_len, expression, expression_len, is_eq, is_assert) \ |
| do { \ |
| const char* minitest_prefix = is_assert ? "ASSERT_MEM" : "EXPECT_MEM"; \ |
| const char* minitest_suffix = is_eq ? "EQ" : "NEQ"; \ |
| const char* minitest_expected = (expected); \ |
| size_t minitest_expected_len = static_cast<size_t>(expected_len); \ |
| const char* minitest_actual = (expression); \ |
| size_t minitest_actual_len = static_cast<size_t>(expression_len); \ |
| if (minitest_actual == NULL) { \ |
| printf("%s%s:%s:%d: expression '%s' is NULL!\n", \ |
| minitest_prefix, \ |
| minitest_suffix, \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->Failure(); \ |
| } else if (minitest_actual_len != minitest_expected_len) { \ |
| printf("%s:%s:%s:%d: size mistmatch for expression '%s'\n", \ |
| minitest_prefix, \ |
| minitest_suffix, \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| printf("actual size : %zu (0x%zx)\n", \ |
| minitest_actual_len, \ |
| minitest_actual_len); \ |
| printf("expected size : %zu (0x%zx)\n", \ |
| minitest_expected_len, \ |
| minitest_expected_len); \ |
| minitest_testcase->Failure(); \ |
| } else { \ |
| bool minitest_eq = \ |
| !memcmp(minitest_expected, minitest_actual, minitest_expected_len); \ |
| if (minitest_eq != is_eq) { \ |
| printf("%s%s:%s:%d: with expression '%s' of %zu bytes\n", \ |
| minitest_prefix, \ |
| minitest_suffix, \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression, \ |
| minitest_expected_len); \ |
| printf("actual : '%.*s'\n", (int)minitest_expected_len, \ |
| minitest_actual); \ |
| printf( \ |
| "expected : '%.*s'\n", (int)minitest_expected_len, \ |
| minitest_expected); \ |
| minitest_testcase->Failure(); \ |
| } \ |
| } \ |
| } while (0) |
| |
| #define EXPECT_MEMEQ(expected, expected_len, expression, expression_len) \ |
| MINITEST_EXPECT_ASSERT_MEM_( \ |
| expected, expected_len, expression, expression_len, true, false) |
| |
| #define EXPECT_MEMNEQ(expected, expected_len, expression, expression_len) \ |
| MINITEST_EXPECT_ASSERT_MEM_( \ |
| expected, expected_len, expression, expression_len, false, false) |
| |
| #define ASSERT_TRUE(expression) \ |
| do { \ |
| if (!(expression)) { \ |
| printf( \ |
| "ASSERT_TRUE:%s:%d: expression '%s' return 'false', expected " \ |
| "'true'\n", \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->FatalFailure(); \ |
| return; \ |
| } \ |
| } while (0) |
| |
| #define ASSERT_FALSE(expression) \ |
| do { \ |
| if (!!(expression)) { \ |
| printf( \ |
| "ASSERT_FALSE:%s:%d: expression '%s' return 'true', expected " \ |
| "'false'\n", \ |
| __FILE__, \ |
| __LINE__, \ |
| #expression); \ |
| minitest_testcase->FatalFailure(); \ |
| return; \ |
| } \ |
| } while (0) |
| |
| #define MINITEST_ASSERT_BINOP_(opname, op, expected, expression) \ |
| MINITEST_EXPECT_ASSERT_BINOP_(opname, op, expected, expression, true) |
| |
| #define ASSERT_EQ(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(EQ, ==, expected, expression) |
| |
| #define ASSERT_NE(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(NE, !=, expected, expression) |
| |
| #define ASSERT_LE(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(LE, <=, expected, expression) |
| |
| #define ASSERT_LT(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(LT, <, expected, expression) |
| |
| #define ASSERT_GE(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(GE, >=, expected, expression) |
| |
| #define ASSERT_GT(expected, expression) \ |
| MINITEST_ASSERT_BINOP_(GT, >, expected, expression) |
| |
| #define ASSERT_STREQ(expected, expression) \ |
| MINITEST_EXPECT_ASSERT_STR_(expected, expression, true, true) |
| |
| #define ASSERT_STRNEQ(expected, expression) \ |
| MINITEST_EXPECT_ASSERT_STR_(expected, expression, false, true) |
| |
| #define ASSERT_MEMEQ(expected, expected_len, expression, expression_len) \ |
| MINITEST_EXPECT_ASSERT_MEM_( \ |
| expected, expected_len, expression, expression_len, true, true) |
| |
| #define ASSERT_MEMNEQ(expected, expected_len, expression, expression_len) \ |
| MINITEST_EXPECT_ASSERT_MEM_( \ |
| expected, expected_len, expression, expression_len, false, true) |
| |
| #define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0])) |
| |
| } // namespace minitest |
| |
| #endif // MINITEST_MINITEST_H |
