?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. // Copyright 2009 Google Inc. All Rights Reserved.
  2. //
  3. // Redistribution and use in source and binary forms, with or without
  4. // modification, are permitted provided that the following conditions are
  5. // met:
  6. //
  7. //     * Redistributions of source code must retain the above copyright
  8. // notice, this list of conditions and the following disclaimer.
  9. //     * Redistributions in binary form must reproduce the above
  10. // copyright notice, this list of conditions and the following disclaimer
  11. // in the documentation and/or other materials provided with the
  12. // distribution.
  13. //     * Neither the name of Google Inc. nor the names of its
  14. // contributors may be used to endorse or promote products derived from
  15. // this software without specific prior written permission.
  16. //
  17. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28.  
  29.  
  30. // This sample shows how to use Google Test listener API to implement
  31. // a primitive leak checker.
  32.  
  33. #include <stdio.h>
  34. #include <stdlib.h>
  35.  
  36. #include "gtest/gtest.h"
  37. using ::testing::EmptyTestEventListener;
  38. using ::testing::InitGoogleTest;
  39. using ::testing::Test;
  40. using ::testing::TestEventListeners;
  41. using ::testing::TestInfo;
  42. using ::testing::TestPartResult;
  43. using ::testing::UnitTest;
  44.  
  45. namespace {
  46. // We will track memory used by this class.
  47. class Water {
  48.  public:
  49.   // Normal Water declarations go here.
  50.  
  51.   // operator new and operator delete help us control water allocation.
  52.   void* operator new(size_t allocation_size) {
  53.     allocated_++;
  54.     return malloc(allocation_size);
  55.   }
  56.  
  57.   void operator delete(void* block, size_t /* allocation_size */) {
  58.     allocated_--;
  59.     free(block);
  60.   }
  61.  
  62.   static int allocated() { return allocated_; }
  63.  
  64.  private:
  65.   static int allocated_;
  66. };
  67.  
  68. int Water::allocated_ = 0;
  69.  
  70. // This event listener monitors how many Water objects are created and
  71. // destroyed by each test, and reports a failure if a test leaks some Water
  72. // objects. It does this by comparing the number of live Water objects at
  73. // the beginning of a test and at the end of a test.
  74. class LeakChecker : public EmptyTestEventListener {
  75.  private:
  76.   // Called before a test starts.
  77.   virtual void OnTestStart(const TestInfo& /* test_info */) {
  78.     initially_allocated_ = Water::allocated();
  79.   }
  80.  
  81.   // Called after a test ends.
  82.   virtual void OnTestEnd(const TestInfo& /* test_info */) {
  83.     int difference = Water::allocated() - initially_allocated_;
  84.  
  85.     // You can generate a failure in any event handler except
  86.     // OnTestPartResult. Just use an appropriate Google Test assertion to do
  87.     // it.
  88.     EXPECT_LE(difference, 0) << "Leaked " << difference << " unit(s) of Water!";
  89.   }
  90.  
  91.   int initially_allocated_;
  92. };
  93.  
  94. TEST(ListenersTest, DoesNotLeak) {
  95.   Water* water = new Water;
  96.   delete water;
  97. }
  98.  
  99. // This should fail when the --check_for_leaks command line flag is
  100. // specified.
  101. TEST(ListenersTest, LeaksWater) {
  102.   Water* water = new Water;
  103.   EXPECT_TRUE(water != NULL);
  104. }
  105. }  // namespace
  106.  
  107. int main(int argc, char **argv) {
  108.   InitGoogleTest(&argc, argv);
  109.  
  110.   bool check_for_leaks = false;
  111.   if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 )
  112.     check_for_leaks = true;
  113.   else
  114.     printf("%s\n", "Run this program with --check_for_leaks to enable "
  115.            "custom leak checking in the tests.");
  116.  
  117.   // If we are given the --check_for_leaks command line flag, installs the
  118.   // leak checker.
  119.   if (check_for_leaks) {
  120.     TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
  121.  
  122.     // Adds the leak checker to the end of the test event listener list,
  123.     // after the default text output printer and the default XML report
  124.     // generator.
  125.     //
  126.     // The order is important - it ensures that failures generated in the
  127.     // leak checker's OnTestEnd() method are processed by the text and XML
  128.     // printers *before* their OnTestEnd() methods are called, such that
  129.     // they are attributed to the right test. Remember that a listener
  130.     // receives an OnXyzStart event *after* listeners preceding it in the
  131.     // list received that event, and receives an OnXyzEnd event *before*
  132.     // listeners preceding it.
  133.     //
  134.     // We don't need to worry about deleting the new listener later, as
  135.     // Google Test will do it.
  136.     listeners.Append(new LeakChecker);
  137.   }
  138.   return RUN_ALL_TESTS();
  139. }
  140.