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

//

// Author: wan@google.com (Zhanyong Wan)

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

//

// This file tests the built-in cardinalities.

#include "gmock/gmock.h"

#include "gtest/gtest.h"

#include "gtest/gtest-spi.h"

namespace {

using std::stringstream;

using testing::AnyNumber;

using testing::AtLeast;

using testing::AtMost;

using testing::Between;

using testing::Cardinality;

using testing::CardinalityInterface;

using testing::Exactly;

using testing::IsSubstring;

using testing::MakeCardinality;

class MockFoo {

 public:

  MockFoo() {}

  MOCK_METHOD0(Bar, int());  // NOLINT

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);

};

// Tests that Cardinality objects can be default constructed.

TEST(CardinalityTest, IsDefaultConstructable) {

  Cardinality c;

}

// Tests that Cardinality objects are copyable.

TEST(CardinalityTest, IsCopyable) {

  // Tests the copy constructor.

  Cardinality c = Exactly(1);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));

  EXPECT_TRUE(c.IsSaturatedByCallCount(1));

  // Tests the assignment operator.

  c = Exactly(2);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_TRUE(c.IsSaturatedByCallCount(2));

}

TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {

  const Cardinality c = AtMost(5);

  EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));

  EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));

  EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));

}

// Tests that Cardinality::DescribeActualCallCountTo() creates the

// correct description.

TEST(CardinalityTest, CanDescribeActualCallCount) {

  stringstream ss0;

  Cardinality::DescribeActualCallCountTo(0, &ss0;;

  EXPECT_EQ("never called", ss0.str());

  stringstream ss1;

  Cardinality::DescribeActualCallCountTo(1, &ss1;;

  EXPECT_EQ("called once", ss1.str());

  stringstream ss2;

  Cardinality::DescribeActualCallCountTo(2, &ss2;;

  EXPECT_EQ("called twice", ss2.str());

  stringstream ss3;

  Cardinality::DescribeActualCallCountTo(3, &ss3;;

  EXPECT_EQ("called 3 times", ss3.str());

}

// Tests AnyNumber()

TEST(AnyNumber, Works) {

  const Cardinality c = AnyNumber();

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));

  EXPECT_FALSE(c.IsSaturatedByCallCount(1));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(9));

  EXPECT_FALSE(c.IsSaturatedByCallCount(9));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",

                      ss.str());

}

TEST(AnyNumberTest, HasCorrectBounds) {

  const Cardinality c = AnyNumber();

  EXPECT_EQ(0, c.ConservativeLowerBound());

  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());

}

// Tests AtLeast(n).

TEST(AtLeastTest, OnNegativeNumber) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    AtLeast(-1);

  }, "The invocation lower bound must be >= 0");

}

TEST(AtLeastTest, OnZero) {

  const Cardinality c = AtLeast(0);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));

  EXPECT_FALSE(c.IsSaturatedByCallCount(1));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",

                      ss.str());

}

TEST(AtLeastTest, OnPositiveNumber) {

  const Cardinality c = AtLeast(2);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));

  EXPECT_FALSE(c.IsSaturatedByCallCount(1));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_FALSE(c.IsSaturatedByCallCount(2));

  stringstream ss1;

  AtLeast(1).DescribeTo(&ss1;;

  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",

                      ss1.str());

  stringstream ss2;

  c.DescribeTo(&ss2;;

  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",

                      ss2.str());

  stringstream ss3;

  AtLeast(3).DescribeTo(&ss3;;

  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",

                      ss3.str());

}

TEST(AtLeastTest, HasCorrectBounds) {

  const Cardinality c = AtLeast(2);

  EXPECT_EQ(2, c.ConservativeLowerBound());

  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());

}

// Tests AtMost(n).

TEST(AtMostTest, OnNegativeNumber) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    AtMost(-1);

  }, "The invocation upper bound must be >= 0");

}

TEST(AtMostTest, OnZero) {

  const Cardinality c = AtMost(0);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_TRUE(c.IsSaturatedByCallCount(0));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));

  EXPECT_TRUE(c.IsSaturatedByCallCount(1));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "never called",

                      ss.str());

}

TEST(AtMostTest, OnPositiveNumber) {

  const Cardinality c = AtMost(2);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));

  EXPECT_FALSE(c.IsSaturatedByCallCount(1));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_TRUE(c.IsSaturatedByCallCount(2));

  stringstream ss1;

  AtMost(1).DescribeTo(&ss1;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",

                      ss1.str());

  stringstream ss2;

  c.DescribeTo(&ss2;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",

                      ss2.str());

  stringstream ss3;

  AtMost(3).DescribeTo(&ss3;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",

                      ss3.str());

}

TEST(AtMostTest, HasCorrectBounds) {

  const Cardinality c = AtMost(2);

  EXPECT_EQ(0, c.ConservativeLowerBound());

  EXPECT_EQ(2, c.ConservativeUpperBound());

}

// Tests Between(m, n).

TEST(BetweenTest, OnNegativeStart) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    Between(-1, 2);

  }, "The invocation lower bound must be >= 0, but is actually -1");

}

TEST(BetweenTest, OnNegativeEnd) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    Between(1, -2);

  }, "The invocation upper bound must be >= 0, but is actually -2");

}

TEST(BetweenTest, OnStartBiggerThanEnd) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    Between(2, 1);

  }, "The invocation upper bound (1) must be >= "

     "the invocation lower bound (2)");

}

TEST(BetweenTest, OnZeroStartAndZeroEnd) {

  const Cardinality c = Between(0, 0);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_TRUE(c.IsSaturatedByCallCount(0));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));

  EXPECT_TRUE(c.IsSaturatedByCallCount(1));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "never called",

                      ss.str());

}

TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {

  const Cardinality c = Between(0, 2);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_TRUE(c.IsSaturatedByCallCount(2));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));

  EXPECT_TRUE(c.IsSaturatedByCallCount(4));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",

                      ss.str());

}

TEST(BetweenTest, OnSameStartAndEnd) {

  const Cardinality c = Between(3, 3);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));

  EXPECT_FALSE(c.IsSaturatedByCallCount(2));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));

  EXPECT_TRUE(c.IsSaturatedByCallCount(3));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));

  EXPECT_TRUE(c.IsSaturatedByCallCount(4));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",

                      ss.str());

}

TEST(BetweenTest, OnDifferentStartAndEnd) {

  const Cardinality c = Between(3, 5);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));

  EXPECT_FALSE(c.IsSaturatedByCallCount(2));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));

  EXPECT_FALSE(c.IsSaturatedByCallCount(3));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(5));

  EXPECT_TRUE(c.IsSaturatedByCallCount(5));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(6));

  EXPECT_TRUE(c.IsSaturatedByCallCount(6));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",

                      ss.str());

}

TEST(BetweenTest, HasCorrectBounds) {

  const Cardinality c = Between(3, 5);

  EXPECT_EQ(3, c.ConservativeLowerBound());

  EXPECT_EQ(5, c.ConservativeUpperBound());

}

// Tests Exactly(n).

TEST(ExactlyTest, OnNegativeNumber) {

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    Exactly(-1);

  }, "The invocation lower bound must be >= 0");

}

TEST(ExactlyTest, OnZero) {

  const Cardinality c = Exactly(0);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));

  EXPECT_TRUE(c.IsSaturatedByCallCount(0));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));

  EXPECT_TRUE(c.IsSaturatedByCallCount(1));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_PRED_FORMAT2(IsSubstring, "never called",

                      ss.str());

}

TEST(ExactlyTest, OnPositiveNumber) {

  const Cardinality c = Exactly(2);

  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));

  EXPECT_FALSE(c.IsSaturatedByCallCount(0));

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_TRUE(c.IsSaturatedByCallCount(2));

  stringstream ss1;

  Exactly(1).DescribeTo(&ss1;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called once",

                      ss1.str());

  stringstream ss2;

  c.DescribeTo(&ss2;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",

                      ss2.str());

  stringstream ss3;

  Exactly(3).DescribeTo(&ss3;;

  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",

                      ss3.str());

}

TEST(ExactlyTest, HasCorrectBounds) {

  const Cardinality c = Exactly(3);

  EXPECT_EQ(3, c.ConservativeLowerBound());

  EXPECT_EQ(3, c.ConservativeUpperBound());

}

// Tests that a user can make his own cardinality by implementing

// CardinalityInterface and calling MakeCardinality().

class EvenCardinality : public CardinalityInterface {

 public:

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

  virtual bool IsSatisfiedByCallCount(int call_count) const {

    return (call_count % 2 == 0);

  }

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

  virtual bool IsSaturatedByCallCount(int /* call_count */) const {

    return false;

  }

  // Describes self to an ostream.

  virtual void DescribeTo(::std::ostream* ss) const {

    *ss << "called even number of times";

  }

};

TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {

  const Cardinality c = MakeCardinality(new EvenCardinality);

  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));

  EXPECT_FALSE(c.IsSatisfiedByCallCount(3));

  EXPECT_FALSE(c.IsSaturatedByCallCount(10000));

  stringstream ss;

  c.DescribeTo(&ss);

  EXPECT_EQ("called even number of times", ss.str());

}

}  // Unnamed namespace