Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*
     18  * This is a minimal set of stubs to compile nvram_manager_test.cpp in
     19  * environments where googletest is not available. The test status output isn't
     20  * as pretty, but good enough to follow test progress and pinpoint test
     21  * failures.
     22  */
     23 
     24 extern "C" {
     25 #include <stdio.h>
     26 }  // extern "C"
     27 
     28 namespace testing {
     29 
     30 // Global test status.
     31 extern bool g_test_status;
     32 
     33 #define ASSERT_MSG(cond)                              \
     34   if (!(cond)) {                                      \
     35     testing::g_test_status = false;                   \
     36     fprintf(stderr, "Assertion failed: " #cond "\n"); \
     37     return;                                           \
     38   }
     39 #define ASSERT_TRUE(cond) ASSERT_MSG(cond)
     40 #define ASSERT_EQ(expected, actual) ASSERT_MSG(expected == actual)
     41 
     42 #define EXPECT_MSG(cond)                                \
     43   if (!(cond)) {                                        \
     44     testing::g_test_status = false;                     \
     45     fprintf(stderr, "Expectation failed: " #cond "\n"); \
     46   }
     47 #define EXPECT_TRUE(cond) EXPECTED_MSG(cond)
     48 #define EXPECT_EQ(expected, actual) EXPECT_MSG((expected) == (actual))
     49 #define EXPECT_NE(expected, actual) EXPECT_MSG((expected) != (actual))
     50 
     51 // Test fixture base class.
     52 class Test {};
     53 
     54 namespace detail {
     55 
     56 // A polymorphic wrapper around test instances. This is the base class that
     57 // defines the common interface.
     58 class TestInstanceBase {
     59  public:
     60   virtual ~TestInstanceBase() = default;
     61   virtual void Run() = 0;
     62 };
     63 
     64 // Test-specific subclass that holds an instance of the test.
     65 template<typename TestCase>
     66 class TestInstance : public TestInstanceBase  {
     67  public:
     68   ~TestInstance() override = default;
     69 
     70   static TestInstanceBase* Create() {
     71     return new TestInstance<TestCase>;
     72   }
     73 
     74  private:
     75   void Run() override {
     76     test_.Run();
     77   }
     78 
     79   TestCase test_;
     80 };
     81 
     82 struct TestDeclarationBase;
     83 using CreateTestInstanceFunction = TestInstanceBase*(void);
     84 
     85 // |TestRegistry| keeps track of all registered tests.
     86 class TestRegistry {
     87  public:
     88   static TestRegistry* instance() { return &g_instance; }
     89 
     90   void RunAllTests();
     91   void Register(TestDeclarationBase* test_declaration);
     92 
     93  private:
     94   TestDeclarationBase* tests_ = nullptr;
     95 
     96   static TestRegistry g_instance;
     97 };
     98 
     99 struct TestDeclarationBase {
    100   TestDeclarationBase(const char* name,
    101                       CreateTestInstanceFunction* create_function)
    102       : name(name), create_function(create_function) {
    103     TestRegistry::instance()->Register(this);
    104   }
    105 
    106   const char* name;
    107   CreateTestInstanceFunction* create_function;
    108   TestDeclarationBase* next;
    109 };
    110 
    111 }  // namespace detail
    112 
    113 // Registers |TestCase| with |TestRegistry|.
    114 template <typename TestCase>
    115 struct TestDeclaration : public detail::TestDeclarationBase {
    116   TestDeclaration(const char* name)
    117       : TestDeclarationBase(name, &detail::TestInstance<TestCase>::Create) {}
    118 };
    119 
    120 #define TEST_F(fixture, name)                       \
    121   class fixture##_##name : public fixture {         \
    122    public:                                          \
    123     void Run();                                     \
    124   };                                                \
    125   static testing::TestDeclaration<fixture##_##name> \
    126       g_##fixture##_##name##_declaration(#name);    \
    127   void fixture##_##name::Run()
    128 
    129 }  // namespace testing
    130