Bug 1761511 - Part 4: Remove the previous vendoring of gtest, r=ahal

Changes for 1.7.0:

* All new improvements in Google Test 1.7.0.

* New feature: matchers DoubleNear(), FloatNear(),

  NanSensitiveDoubleNear(), NanSensitiveFloatNear(),

  UnorderedElementsAre(), UnorderedElementsAreArray(), WhenSorted(),

  WhenSortedBy(), IsEmpty(), and SizeIs().

* Improvement: Google Mock can now be built as a DLL.

* Improvement: when compiled by a C++11 compiler, matchers AllOf()

  and AnyOf() can accept an arbitrary number of matchers.

* Improvement: when compiled by a C++11 compiler, matchers

  ElementsAreArray() can accept an initializer list.

* Improvement: when exceptions are enabled, a mock method with no

  default action now throws instead crashing the test.

* Improvement: added class testing::StringMatchResultListener to aid

  definition of composite matchers.

* Improvement: function return types used in MOCK_METHOD*() macros can

  now contain unprotected commas.

* Improvement (potentially breaking): EXPECT_THAT() and ASSERT_THAT()

  are now more strict in ensuring that the value type and the matcher

  type are compatible, catching potential bugs in tests.

* Improvement: Pointee() now works on an optional<T>.

* Improvement: the ElementsAreArray() matcher can now take a vector or

  iterator range as input, and makes a copy of its input elements

  before the conversion to a Matcher.

* Improvement: the Google Mock Generator can now generate mocks for

  some class templates.

* Bug fix: mock object destruction triggerred by another mock object's

  destruction no longer hangs.

* Improvement: Google Mock Doctor works better with newer Clang and

  GCC now.

* Compatibility fixes.

* Bug/warning fixes.

Changes for 1.6.0:

* Compilation is much faster and uses much less memory, especially

  when the constructor and destructor of a mock class are moved out of

  the class body.

* New matchers: Pointwise(), Each().

* New actions: ReturnPointee() and ReturnRefOfCopy().

* CMake support.

* Project files for Visual Studio 2010.

* AllOf() and AnyOf() can handle up-to 10 arguments now.

* Google Mock doctor understands Clang error messages now.

* SetArgPointee<> now accepts string literals.

* gmock_gen.py handles storage specifier macros and template return

  types now.

* Compatibility fixes.

* Bug fixes and implementation clean-ups.

* Potentially incompatible changes: disables the harmful 'make install'

  command in autotools.

Potentially breaking changes:

* The description string for MATCHER*() changes from Python-style

  interpolation to an ordinary C++ string expression.

* SetArgumentPointee is deprecated in favor of SetArgPointee.

* Some non-essential project files for Visual Studio 2005 are removed.

Changes for 1.5.0:

 * New feature: Google Mock can be safely used in multi-threaded tests

   on platforms having pthreads.

 * New feature: function for printing a value of arbitrary type.

 * New feature: function ExplainMatchResult() for easy definition of

   composite matchers.

 * The new matcher API lets user-defined matchers generate custom

   explanations more directly and efficiently.

 * Better failure messages all around.

 * NotNull() and IsNull() now work with smart pointers.

 * Field() and Property() now work when the matcher argument is a pointer

   passed by reference.

 * Regular expression matchers on all platforms.

 * Added GCC 4.0 support for Google Mock Doctor.

 * Added gmock_all_test.cc for compiling most Google Mock tests

   in a single file.

 * Significantly cleaned up compiler warnings.

 * Bug fixes, better test coverage, and implementation clean-ups.

 Potentially breaking changes:

 * Custom matchers defined using MatcherInterface or MakePolymorphicMatcher()

   need to be updated after upgrading to Google Mock 1.5.0; matchers defined

   using MATCHER or MATCHER_P* aren't affected.

 * Dropped support for 'make install'.

Changes for 1.4.0 (we skipped 1.2.* and 1.3.* to match the version of

Google Test):

 * Works in more environments: Symbian and minGW, Visual C++ 7.1.

 * Lighter weight: comes with our own implementation of TR1 tuple (no

   more dependency on Boost!).

 * New feature: --gmock_catch_leaked_mocks for detecting leaked mocks.

 * New feature: ACTION_TEMPLATE for defining templatized actions.

 * New feature: the .After() clause for specifying expectation order.

 * New feature: the .With() clause for specifying inter-argument

   constraints.

 * New feature: actions ReturnArg<k>(), ReturnNew<T>(...), and

   DeleteArg<k>().

 * New feature: matchers Key(), Pair(), Args<...>(), AllArgs(), IsNull(),

   and Contains().

 * New feature: utility class MockFunction<F>, useful for checkpoints, etc.

 * New feature: functions Value(x, m) and SafeMatcherCast<T>(m).

 * New feature: copying a mock object is rejected at compile time.

 * New feature: a script for fusing all Google Mock and Google Test

   source files for easy deployment.

 * Improved the Google Mock doctor to diagnose more diseases.

 * Improved the Google Mock generator script.

 * Compatibility fixes for Mac OS X and gcc.

 * Bug fixes and implementation clean-ups.

Changes for 1.1.0:

 * New feature: ability to use Google Mock with any testing framework.

 * New feature: macros for easily defining new matchers

 * New feature: macros for easily defining new actions.

 * New feature: more container matchers.

 * New feature: actions for accessing function arguments and throwing

   exceptions.

 * Improved the Google Mock doctor script for diagnosing compiler errors.

 * Bug fixes and implementation clean-ups.

Changes for 1.0.0:

 * Initial Open Source release of Google Mock

# This file contains a list of people who've made non-trivial

# contribution to the Google C++ Mocking Framework project.  People

# who commit code to the project are encouraged to add their names

# here.  Please keep the list sorted by first names.

Benoit Sigoure <tsuna@google.com>

Bogdan Piloca <boo@google.com>

Chandler Carruth <chandlerc@google.com>

Dave MacLachlan <dmaclach@gmail.com>

David Anderson <danderson@google.com>

Dean Sturtevant

Gene Volovich <gv@cite.com>

Hal Burch <gmock@hburch.com>

Jeffrey Yasskin <jyasskin@google.com>

Jim Keller <jimkeller@google.com>

Joe Walnes <joe@truemesh.com>

Jon Wray <jwray@google.com>

Keir Mierle <mierle@gmail.com>

Keith Ray <keith.ray@gmail.com>

Kostya Serebryany <kcc@google.com>

Lev Makhlis

Manuel Klimek <klimek@google.com>

Mario Tanev <radix@google.com>

Mark Paskin

Markus Heule <markus.heule@gmail.com>

Matthew Simmons <simmonmt@acm.org>

Mike Bland <mbland@google.com>

Neal Norwitz <nnorwitz@gmail.com>

Nermin Ozkiranartli <nermin@google.com>

Owen Carlsen <ocarlsen@google.com>

Paneendra Ba <paneendra@google.com>

Paul Menage <menage@google.com>

Piotr Kaminski <piotrk@google.com>

Russ Rufer <russ@pentad.com>

Sverre Sundsdal <sundsdal@gmail.com>

Takeshi Yoshino <tyoshino@google.com>

Vadim Berman <vadimb@google.com>

Vlad Losev <vladl@google.com>

Wolfgang Klier <wklier@google.com>

Zhanyong Wan <wan@google.com>

Copyright 2008, 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.

// Copyright 2007, 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.

// Google Mock - a framework for writing C++ mock classes.

//

// This file implements some commonly used cardinalities.  More

// cardinalities can be defined by the user implementing the

// CardinalityInterface interface if necessary.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_

#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_

#include <limits.h>

#include <ostream>  // NOLINT

#include "gmock/internal/gmock-port.h"

#include "gtest/gtest.h"

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \

/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// To implement a cardinality Foo, define:

//   1. a class FooCardinality that implements the

//      CardinalityInterface interface, and

//   2. a factory function that creates a Cardinality object from a

//      const FooCardinality*.

//

// The two-level delegation design follows that of Matcher, providing

// consistency for extension developers.  It also eases ownership

// management as Cardinality objects can now be copied like plain values.

// The implementation of a cardinality.

class CardinalityInterface {

 public:

  virtual ~CardinalityInterface() {}

  // Conservative estimate on the lower/upper bound of the number of

  // calls allowed.

  virtual int ConservativeLowerBound() const { return 0; }

  virtual int ConservativeUpperBound() const { return INT_MAX; }

  // Returns true iff call_count calls will satisfy this cardinality.

  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;

  // Returns true iff call_count calls will saturate this cardinality.

  virtual bool IsSaturatedByCallCount(int call_count) const = 0;

  // Describes self to an ostream.

  virtual void DescribeTo(::std::ostream* os) const = 0;

};

// A Cardinality is a copyable and IMMUTABLE (except by assignment)

// object that specifies how many times a mock function is expected to

// be called.  The implementation of Cardinality is just a linked_ptr

// to const CardinalityInterface, so copying is fairly cheap.

// Don't inherit from Cardinality!

class GTEST_API_ Cardinality {

 public:

  // Constructs a null cardinality.  Needed for storing Cardinality

  // objects in STL containers.

  Cardinality() {}

  // Constructs a Cardinality from its implementation.

  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}

  // Conservative estimate on the lower/upper bound of the number of

  // calls allowed.

  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }

  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }

  // Returns true iff call_count calls will satisfy this cardinality.

  bool IsSatisfiedByCallCount(int call_count) const {

    return impl_->IsSatisfiedByCallCount(call_count);

  }

  // Returns true iff call_count calls will saturate this cardinality.

  bool IsSaturatedByCallCount(int call_count) const {

    return impl_->IsSaturatedByCallCount(call_count);

  }

  // Returns true iff call_count calls will over-saturate this

  // cardinality, i.e. exceed the maximum number of allowed calls.

  bool IsOverSaturatedByCallCount(int call_count) const {

    return impl_->IsSaturatedByCallCount(call_count) &&

        !impl_->IsSatisfiedByCallCount(call_count);

  }

  // Describes self to an ostream

  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }

  // Describes the given actual call count to an ostream.

  static void DescribeActualCallCountTo(int actual_call_count,

                                        ::std::ostream* os);

 private:

  internal::linked_ptr<const CardinalityInterface> impl_;

};

// Creates a cardinality that allows at least n calls.

GTEST_API_ Cardinality AtLeast(int n);

// Creates a cardinality that allows at most n calls.

GTEST_API_ Cardinality AtMost(int n);

// Creates a cardinality that allows any number of calls.

GTEST_API_ Cardinality AnyNumber();

// Creates a cardinality that allows between min and max calls.

GTEST_API_ Cardinality Between(int min, int max);

// Creates a cardinality that allows exactly n calls.

GTEST_API_ Cardinality Exactly(int n);

// Creates a cardinality from its implementation.

inline Cardinality MakeCardinality(const CardinalityInterface* c) {

  return Cardinality(c);

}

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_