?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. // Copyright 2008, Google Inc.
  2. // All rights reserved.
  3. //
  4. // Redistribution and use in source and binary forms, with or without
  5. // modification, are permitted provided that the following conditions are
  6. // met:
  7. //
  8. //     * Redistributions of source code must retain the above copyright
  9. // notice, this list of conditions and the following disclaimer.
  10. //     * Redistributions in binary form must reproduce the above
  11. // copyright notice, this list of conditions and the following disclaimer
  12. // in the documentation and/or other materials provided with the
  13. // distribution.
  14. //     * Neither the name of Google Inc. nor the names of its
  15. // contributors may be used to endorse or promote products derived from
  16. // this software without specific prior written permission.
  17. //
  18. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  
  30.  
  31. // Tests the --gtest_repeat=number flag.
  32.  
  33. #include <stdlib.h>
  34. #include <iostream>
  35. #include "gtest/gtest.h"
  36. #include "src/gtest-internal-inl.h"
  37.  
  38. namespace testing {
  39.  
  40. GTEST_DECLARE_string_(death_test_style);
  41. GTEST_DECLARE_string_(filter);
  42. GTEST_DECLARE_int32_(repeat);
  43.  
  44. }  // namespace testing
  45.  
  46. using testing::GTEST_FLAG(death_test_style);
  47. using testing::GTEST_FLAG(filter);
  48. using testing::GTEST_FLAG(repeat);
  49.  
  50. namespace {
  51.  
  52. // We need this when we are testing Google Test itself and therefore
  53. // cannot use Google Test assertions.
  54. #define GTEST_CHECK_INT_EQ_(expected, actual) \
  55.   do {\
  56.     const int expected_val = (expected);\
  57.     const int actual_val = (actual);\
  58.     if (::testing::internal::IsTrue(expected_val != actual_val)) {\
  59.       ::std::cout << "Value of: " #actual "\n"\
  60.                   << "  Actual: " << actual_val << "\n"\
  61.                   << "Expected: " #expected "\n"\
  62.                   << "Which is: " << expected_val << "\n";\
  63.       ::testing::internal::posix::Abort();\
  64.     }\
  65.   } while (::testing::internal::AlwaysFalse())
  66.  
  67.  
  68. // Used for verifying that global environment set-up and tear-down are
  69. // inside the --gtest_repeat loop.
  70.  
  71. int g_environment_set_up_count = 0;
  72. int g_environment_tear_down_count = 0;
  73.  
  74. class MyEnvironment : public testing::Environment {
  75.  public:
  76.   MyEnvironment() {}
  77.   virtual void SetUp() { g_environment_set_up_count++; }
  78.   virtual void TearDown() { g_environment_tear_down_count++; }
  79. };
  80.  
  81. // A test that should fail.
  82.  
  83. int g_should_fail_count = 0;
  84.  
  85. TEST(FooTest, ShouldFail) {
  86.   g_should_fail_count++;
  87.   EXPECT_EQ(0, 1) << "Expected failure.";
  88. }
  89.  
  90. // A test that should pass.
  91.  
  92. int g_should_pass_count = 0;
  93.  
  94. TEST(FooTest, ShouldPass) {
  95.   g_should_pass_count++;
  96. }
  97.  
  98. // A test that contains a thread-safe death test and a fast death
  99. // test.  It should pass.
  100.  
  101. int g_death_test_count = 0;
  102.  
  103. TEST(BarDeathTest, ThreadSafeAndFast) {
  104.   g_death_test_count++;
  105.  
  106.   GTEST_FLAG(death_test_style) = "threadsafe";
  107.   EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
  108.  
  109.   GTEST_FLAG(death_test_style) = "fast";
  110.   EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
  111. }
  112.  
  113. int g_param_test_count = 0;
  114.  
  115. const int kNumberOfParamTests = 10;
  116.  
  117. class MyParamTest : public testing::TestWithParam<int> {};
  118.  
  119. TEST_P(MyParamTest, ShouldPass) {
  120.   // FIXME: Make parameter value checking robust WRT order of tests.
  121.   GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
  122.   g_param_test_count++;
  123. }
  124. INSTANTIATE_TEST_CASE_P(MyParamSequence,
  125.                         MyParamTest,
  126.                         testing::Range(0, kNumberOfParamTests));
  127.  
  128. // Resets the count for each test.
  129. void ResetCounts() {
  130.   g_environment_set_up_count = 0;
  131.   g_environment_tear_down_count = 0;
  132.   g_should_fail_count = 0;
  133.   g_should_pass_count = 0;
  134.   g_death_test_count = 0;
  135.   g_param_test_count = 0;
  136. }
  137.  
  138. // Checks that the count for each test is expected.
  139. void CheckCounts(int expected) {
  140.   GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
  141.   GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
  142.   GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
  143.   GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
  144.   GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
  145.   GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
  146. }
  147.  
  148. // Tests the behavior of Google Test when --gtest_repeat is not specified.
  149. void TestRepeatUnspecified() {
  150.   ResetCounts();
  151.   GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
  152.   CheckCounts(1);
  153. }
  154.  
  155. // Tests the behavior of Google Test when --gtest_repeat has the given value.
  156. void TestRepeat(int repeat) {
  157.   GTEST_FLAG(repeat) = repeat;
  158.  
  159.   ResetCounts();
  160.   GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
  161.   CheckCounts(repeat);
  162. }
  163.  
  164. // Tests using --gtest_repeat when --gtest_filter specifies an empty
  165. // set of tests.
  166. void TestRepeatWithEmptyFilter(int repeat) {
  167.   GTEST_FLAG(repeat) = repeat;
  168.   GTEST_FLAG(filter) = "None";
  169.  
  170.   ResetCounts();
  171.   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
  172.   CheckCounts(0);
  173. }
  174.  
  175. // Tests using --gtest_repeat when --gtest_filter specifies a set of
  176. // successful tests.
  177. void TestRepeatWithFilterForSuccessfulTests(int repeat) {
  178.   GTEST_FLAG(repeat) = repeat;
  179.   GTEST_FLAG(filter) = "*-*ShouldFail";
  180.  
  181.   ResetCounts();
  182.   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
  183.   GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
  184.   GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
  185.   GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
  186.   GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
  187.   GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
  188.   GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
  189. }
  190.  
  191. // Tests using --gtest_repeat when --gtest_filter specifies a set of
  192. // failed tests.
  193. void TestRepeatWithFilterForFailedTests(int repeat) {
  194.   GTEST_FLAG(repeat) = repeat;
  195.   GTEST_FLAG(filter) = "*ShouldFail";
  196.  
  197.   ResetCounts();
  198.   GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
  199.   GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
  200.   GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
  201.   GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
  202.   GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
  203.   GTEST_CHECK_INT_EQ_(0, g_death_test_count);
  204.   GTEST_CHECK_INT_EQ_(0, g_param_test_count);
  205. }
  206.  
  207. }  // namespace
  208.  
  209. int main(int argc, char **argv) {
  210.   testing::InitGoogleTest(&argc, argv);
  211.  
  212.   testing::AddGlobalTestEnvironment(new MyEnvironment);
  213.  
  214.   TestRepeatUnspecified();
  215.   TestRepeat(0);
  216.   TestRepeat(1);
  217.   TestRepeat(5);
  218.  
  219.   TestRepeatWithEmptyFilter(2);
  220.   TestRepeatWithEmptyFilter(3);
  221.  
  222.   TestRepeatWithFilterForSuccessfulTests(3);
  223.  
  224.   TestRepeatWithFilterForFailedTests(4);
  225.  
  226.   // It would be nice to verify that the tests indeed loop forever
  227.   // when GTEST_FLAG(repeat) is negative, but this test will be quite
  228.   // complicated to write.  Since this flag is for interactive
  229.   // debugging only and doesn't affect the normal test result, such a
  230.   // test would be an overkill.
  231.  
  232.   printf("PASS\n");
  233.   return 0;
  234. }
  235.