The Tor Browser / file revision

 // Copyright 2009 Google Inc. 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.

 //     * Neither the name of Google Inc. nor the names of its

 // contributors may be used to endorse or promote products derived from

 // this software without specific prior written permission.

 //

 // 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.

 //

 // Author: vladl@google.com (Vlad Losev)

 // This sample shows how to use Google Test listener API to implement

 // a primitive leak checker.

 #include <stdio.h>

 #include <stdlib.h>

 #include "gtest/gtest.h"

 using ::testing::EmptyTestEventListener;

 using ::testing::InitGoogleTest;

 using ::testing::Test;

 using ::testing::TestCase;

 using ::testing::TestEventListeners;

 using ::testing::TestInfo;

 using ::testing::TestPartResult;

 using ::testing::UnitTest;

 namespace {

 // We will track memory used by this class.

 class Water {

  public:

   // Normal Water declarations go here.

   // operator new and operator delete help us control water allocation.

   void* operator new(size_t allocation_size) {

     allocated_++;

     return malloc(allocation_size);

   }

   void operator delete(void* block, size_t /* allocation_size */) {

     allocated_--;

     free(block);

   }

   static int allocated() { return allocated_; }

  private:

   static int allocated_;

 };

 int Water::allocated_ = 0;

 // This event listener monitors how many Water objects are created and

 // destroyed by each test, and reports a failure if a test leaks some Water

 // objects. It does this by comparing the number of live Water objects at

 // the beginning of a test and at the end of a test.

 class LeakChecker : public EmptyTestEventListener {

  private:

   // Called before a test starts.

   virtual void OnTestStart(const TestInfo& /* test_info */) {

     initially_allocated_ = Water::allocated();

   }

   // Called after a test ends.

   virtual void OnTestEnd(const TestInfo& /* test_info */) {

     int difference = Water::allocated() - initially_allocated_;

     // You can generate a failure in any event handler except

     // OnTestPartResult. Just use an appropriate Google Test assertion to do

     // it.

     EXPECT_LE(difference, 0) << "Leaked " << difference << " unit(s) of Water!";

   }

   int initially_allocated_;

 };

 TEST(ListenersTest, DoesNotLeak) {

   Water* water = new Water;

   delete water;

 }

 // This should fail when the --check_for_leaks command line flag is

 // specified.

 TEST(ListenersTest, LeaksWater) {

   Water* water = new Water;

   EXPECT_TRUE(water != NULL);

 }

 }  // namespace

 int main(int argc, char **argv) {

   InitGoogleTest(&argc, argv);

   bool check_for_leaks = false;

   if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 )

     check_for_leaks = true;

   else

     printf("%s\n", "Run this program with --check_for_leaks to enable "

            "custom leak checking in the tests.");

   // If we are given the --check_for_leaks command line flag, installs the

   // leak checker.

   if (check_for_leaks) {

     TestEventListeners& listeners = UnitTest::GetInstance()->listeners();

     // Adds the leak checker to the end of the test event listener list,

     // after the default text output printer and the default XML report

     // generator.

     //

     // The order is important - it ensures that failures generated in the

     // leak checker's OnTestEnd() method are processed by the text and XML

     // printers *before* their OnTestEnd() methods are called, such that

     // they are attributed to the right test. Remember that a listener

     // receives an OnXyzStart event *after* listeners preceding it in the

     // list received that event, and receives an OnXyzEnd event *before*

     // listeners preceding it.

     //

     // We don't need to worry about deleting the new listener later, as

     // Google Test will do it.

     listeners.Append(new LeakChecker);

   }

   return RUN_ALL_TESTS();

 }