File indexing completed on 2025-02-16 05:12:10

 /*
  * test/test.hpp
  * Copyright 2013 Google Inc. All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 
 #pragma once
 #ifndef H_54E531F7_9154_454B_BEB9_257408429470
 #define H_54E531F7_9154_454B_BEB9_257408429470
 
 #include <cstdio>
 #include <cstring>
 #include <exception>
 #include <sstream>
 #include <string>
 #include <vector>
 
 namespace test {
 
 struct AssertFailedError : std::exception {
   ~AssertFailedError() throw() {}
 
   AssertFailedError(const char *filename, int _line, const char *_errmsg)
       : basename(_basename(filename)), line(_line), errmsg(_errmsg) {}
 
   const char *what() const throw() {
     if (!_what.size()) {
       std::ostringstream ss;
       ss << "assertion failed (" << basename << ":" << line;
       ss << ") " << errmsg;
       _what = ss.str();
     }
     return _what.c_str();
   }
 
   const char *basename;
   int line;
   const char *errmsg;
 
   mutable std::string _what;
 
   static const char *_basename(const char *filename) {
     const char *basename = filename + strlen(filename);
     while (basename != filename && *basename != '/') {
       basename -= 1;
     }
     return basename + 1;
   }
 };
 
 enum TestStatus {
   SUCCESS = 0 << 0,
   FAILED = 1 << 0,
 
   ASSERT_FAIL = FAILED | 1 << 1,
   EXCEPTION_UNCAUGHT = FAILED | 2 << 1,
   SIGNAL_UNCAUGHT = FAILED | 3 << 1,
   SIGNAL_SEGFAULT = SIGNAL_UNCAUGHT | 1 << 3,
   SIGNAL_ABORT = SIGNAL_UNCAUGHT | 2 << 3,
   SIGNAL_DIVZERO = SIGNAL_UNCAUGHT | 2 << 3,
 
   STATUS_MASK = 0x1F
 };
 
 struct TestBase {
   const char *name;
   TestStatus expected_status;
 
   virtual ~TestBase() {}
   TestBase(const char *, TestStatus);
   virtual void do_test() = 0;
 
   TestStatus run() {
     try {
       do_test();
       return SUCCESS;
     } catch (const AssertFailedError &e) {
       printf("!! %s\n", e.what());
       return ASSERT_FAIL;
     } catch (const std::exception &e) {
       printf("!! exception: %s\n", e.what());
       return EXCEPTION_UNCAUGHT;
     } catch (...) {
       printf("!! unknown exception\n");
       return EXCEPTION_UNCAUGHT;
     }
   }
 };
 
 typedef std::vector<TestBase *> test_registry_t;
 inline test_registry_t &test_registry() {
   static test_registry_t reg;
   return reg;
 }
 
 inline TestBase::TestBase(const char *n, TestStatus s)
     : name(n), expected_status(s) {
   test_registry().push_back(this);
 }
 
 } // namespace test
 
 #define _TEST_STATUS(name, status)                                             \
   struct TEST_##name : ::test::TestBase {                                      \
     TEST_##name() : TestBase(#name, status) {}                                 \
     void do_test();                                                            \
   } TEST_##name;                                                               \
   void TEST_##name::do_test()
 
 #define TEST(name) _TEST_STATUS(name, ::test::SUCCESS)
 #define TEST_FAIL(name) _TEST_STATUS(name, ::test::FAILED)
 #define TEST_FAIL_ASSERT(name) _TEST_STATUS(name, ::test::ASSERT_FAIL)
 #define TEST_UNCAUGHT_EXCEPTION(name)                                          \
   _TEST_STATUS(name, ::test::EXCEPTION_UNCAUGHT)
 #define TEST_UNCAUGHT_SIGNAL(name) _TEST_STATUS(name, ::test::SIGNAL_UNCAUGHT)
 #define TEST_SEGFAULT(name) _TEST_STATUS(name, ::test::SIGNAL_SEGFAULT)
 #define TEST_ABORT(name) _TEST_STATUS(name, ::test::SIGNAL_ABORT)
 #define TEST_DIVZERO(name) _TEST_STATUS(name, ::test::SIGNAL_DIVZERO)
 
 #define ASSERT(expr)                                                           \
   (expr) ? static_cast<void>(0)                                                \
          : throw ::test::AssertFailedError(__FILE__, __LINE__, #expr)
 
 #define _ASSERT_BINOP(a, b, cmp)                                               \
   (!(a cmp b)) ? static_cast<void>(0)                                          \
                : throw ::test::AssertFailedError(                              \
                      __FILE__, __LINE__, "because " #a " " #cmp " " #b)
 
 #define ASSERT_EQ(a, b) _ASSERT_BINOP(a, b, !=)
 #define ASSERT_NE(a, b) _ASSERT_BINOP(a, b, ==)
 #define ASSERT_LT(a, b) _ASSERT_BINOP(a, b, >=)
 #define ASSERT_LE(a, b) _ASSERT_BINOP(a, b, >)
 #define ASSERT_GT(a, b) _ASSERT_BINOP(a, b, <=)
 #define ASSERT_GE(a, b) _ASSERT_BINOP(a, b, <)
 
 #define ASSERT_THROW(expr, e_type)                                             \
   do {                                                                         \
     try {                                                                      \
       expr                                                                     \
     } catch (const e_type &) {                                                 \
       break;                                                                   \
     }                                                                          \
     throw ::test::AssertFailedError(__FILE__, __LINE__,                        \
                                     "expected exception " #e_type);            \
   } while (0)
 
 #define ASSERT_ANY_THROW(expr)                                                 \
   do {                                                                         \
     try {                                                                      \
       expr                                                                     \
     } catch (...) {                                                            \
       break;                                                                   \
     }                                                                          \
     throw ::test::AssertFailedError(__FILE__, __LINE__,                        \
                                     "expected any exception");                 \
   } while (0)
 
 #define ASSERT_NO_THROW(expr)                                                  \
   try {                                                                        \
     expr                                                                       \
   } catch (...) {                                                              \
     throw ::test::AssertFailedError(__FILE__, __LINE__,                        \
                                     "no exception expected");                  \
   }
 
 #endif /* H_GUARD */