widevine-partner/ce_cdm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Source release 17.1.0

Browse Source
This commit is contained in:
John "Juce" Bruce
2022-07-07 17:14:31 -07:00
parent 8c17574083
commit 694cf6fb25
2233 changed files with 272026 additions and 223371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
third_party/googletest/googlemock/test/gmock-spec-builders_test.cc vendored
View File

@@ -26,8 +26,7 @@
// 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.
//
@@ -35,6 +34,7 @@
#include "gmock/gmock-spec-builders.h"
#include <memory>
#include <ostream> // NOLINT
#include <sstream>
#include <string>
@@ -69,15 +69,15 @@ using testing::AtMost;
using testing::Between;
using testing::Cardinality;
using testing::CardinalityInterface;
using testing::ContainsRegex;
using testing::Const;
using testing::ContainsRegex;
using testing::DoAll;
using testing::DoDefault;
using testing::Eq;
using testing::Expectation;
using testing::ExpectationSet;
using testing::GMOCK_FLAG(verbose);
using testing::Gt;
using testing::IgnoreResult;
using testing::InSequence;
using testing::Invoke;
using testing::InvokeWithoutArgs;
@@ -89,15 +89,17 @@ using testing::Mock;
using testing::NaggyMock;
using testing::Ne;
using testing::Return;
using testing::SaveArg;
using testing::Sequence;
using testing::SetArgPointee;
using testing::internal::ExpectationTester;
using testing::internal::FormatFileLocation;
using testing::internal::kAllow;
using testing::internal::kErrorVerbosity;
using testing::internal::kFail;
using testing::internal::kInfoVerbosity;
using testing::internal::kWarn;
using testing::internal::kWarningVerbosity;
using testing::internal::linked_ptr;
using testing::internal::string;
#if GTEST_HAS_STREAM_REDIRECTION
using testing::HasSubstr;
@@ -170,7 +172,7 @@ class ReferenceHoldingMock {
public:
ReferenceHoldingMock() {}
MOCK_METHOD1(AcceptReference, void(linked_ptr<MockA>*));
MOCK_METHOD1(AcceptReference, void(std::shared_ptr<MockA>*));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
@@ -388,7 +390,7 @@ TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
EXPECT_CALL(a, DoA(1))
.InSequence(s)
.Times(1);
}, ".Times() cannot appear after ");
}, ".Times() may only appear *before* ");
a.DoA(1);
}
@@ -692,6 +694,60 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
b.DoB();
}
TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
int original_behavior = GMOCK_FLAG_GET(default_mock_behavior);
GMOCK_FLAG_SET(default_mock_behavior, kAllow);
CaptureStdout();
{
MockA a;
a.DoA(0);
}
std::string output = GetCapturedStdout();
EXPECT_TRUE(output.empty()) << output;
GMOCK_FLAG_SET(default_mock_behavior, kWarn);
CaptureStdout();
{
MockA a;
a.DoA(0);
}
std::string warning_output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
warning_output);
GMOCK_FLAG_SET(default_mock_behavior, kFail);
EXPECT_NONFATAL_FAILURE({
MockA a;
a.DoA(0);
}, "Uninteresting mock function call");
// Out of bounds values are converted to kWarn
GMOCK_FLAG_SET(default_mock_behavior, -1);
CaptureStdout();
{
MockA a;
a.DoA(0);
}
warning_output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
warning_output);
GMOCK_FLAG_SET(default_mock_behavior, 3);
CaptureStdout();
{
MockA a;
a.DoA(0);
}
warning_output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
warning_output);
GMOCK_FLAG_SET(default_mock_behavior, original_behavior);
}
#endif // GTEST_HAS_STREAM_REDIRECTION
// Tests the semantics of ON_CALL().
@@ -1119,7 +1175,7 @@ TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
TEST(UndefinedReturnValueTest,
ReturnValueIsMandatoryWhenNotDefaultConstructible) {
MockA a;
// TODO(wan@google.com): We should really verify the output message,
// FIXME: We should really verify the output message,
// but we cannot yet due to that EXPECT_DEATH only captures stderr
// while Google Mock logs to stdout.
#if GTEST_HAS_EXCEPTIONS
@@ -1895,18 +1951,20 @@ TEST(DeletingMockEarlyTest, Failure2) {
class EvenNumberCardinality : public CardinalityInterface {
public:
// Returns true iff call_count calls will satisfy this cardinality.
virtual bool IsSatisfiedByCallCount(int call_count) const {
// Returns true if and only if call_count calls will satisfy this
// cardinality.
bool IsSatisfiedByCallCount(int call_count) const override {
return call_count % 2 == 0;
}
// Returns true iff call_count calls will saturate this cardinality.
virtual bool IsSaturatedByCallCount(int /* call_count */) const {
// Returns true if and only if call_count calls will saturate this
// cardinality.
bool IsSaturatedByCallCount(int /* call_count */) const override {
return false;
}
// Describes self to an ostream.
virtual void DescribeTo(::std::ostream* os) const {
void DescribeTo(::std::ostream* os) const override {
*os << "called even number of times";
}
};
@@ -1954,7 +2012,7 @@ class MockC {
public:
MockC() {}
MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
MOCK_METHOD6(VoidMethod, void(bool cond, int n, std::string s, void* p,
const Printable& x, Unprintable y));
MOCK_METHOD0(NonVoidMethod, int()); // NOLINT
@@ -1965,12 +2023,14 @@ class MockC {
class VerboseFlagPreservingFixture : public testing::Test {
protected:
VerboseFlagPreservingFixture()
: saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
: saved_verbose_flag_(GMOCK_FLAG_GET(verbose)) {}
~VerboseFlagPreservingFixture() { GMOCK_FLAG(verbose) = saved_verbose_flag_; }
~VerboseFlagPreservingFixture() override {
GMOCK_FLAG_SET(verbose, saved_verbose_flag_);
}
private:
const string saved_verbose_flag_;
const std::string saved_verbose_flag_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
};
@@ -1982,10 +2042,10 @@ class VerboseFlagPreservingFixture : public testing::Test {
// --gmock_verbose=warning is specified.
TEST(FunctionCallMessageTest,
UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
GMOCK_FLAG(verbose) = kWarningVerbosity;
GMOCK_FLAG_SET(verbose, kWarningVerbosity);
NaggyMock<MockC> c;
CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output);
@@ -1996,10 +2056,10 @@ TEST(FunctionCallMessageTest,
// --gmock_verbose=info is specified.
TEST(FunctionCallMessageTest,
UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
GMOCK_FLAG(verbose) = kInfoVerbosity;
GMOCK_FLAG_SET(verbose, kInfoVerbosity);
NaggyMock<MockC> c;
CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
@@ -2042,7 +2102,7 @@ TEST(FunctionCallMessageTest,
// A void mock function.
NaggyMock<MockC> c;
CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output2 = GetCapturedStdout();
EXPECT_THAT(output2.c_str(),
ContainsRegex(
@@ -2062,8 +2122,8 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
// contain the given function name in the stack trace. When it's
// false, the output should be empty.)
void VerifyOutput(const std::string& output, bool should_print,
const string& expected_substring,
const string& function_name) {
const std::string& expected_substring,
const std::string& function_name) {
if (should_print) {
EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
# ifndef NDEBUG
@@ -2113,11 +2173,13 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
// Tests how the flag affects uninteresting calls on a naggy mock.
void TestUninterestingCallOnNaggyMock(bool should_print) {
NaggyMock<MockA> a;
const string note =
const std::string note =
"NOTE: You can safely ignore the above warning unless this "
"call should not happen. Do not suppress it by blindly adding "
"an EXPECT_CALL() if you don't mean to enforce the call. "
"See https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#"
"See "
"https://github.com/google/googletest/blob/master/docs/"
"gmock_cook_book.md#"
"knowing-when-to-expect for details.";
// A void-returning function.
@@ -2150,7 +2212,7 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
// Tests that --gmock_verbose=info causes both expected and
// uninteresting calls to be reported.
TEST_F(GMockVerboseFlagTest, Info) {
GMOCK_FLAG(verbose) = kInfoVerbosity;
GMOCK_FLAG_SET(verbose, kInfoVerbosity);
TestExpectedCall(true);
TestUninterestingCallOnNaggyMock(true);
}
@@ -2158,7 +2220,7 @@ TEST_F(GMockVerboseFlagTest, Info) {
// Tests that --gmock_verbose=warning causes uninteresting calls to be
// reported.
TEST_F(GMockVerboseFlagTest, Warning) {
GMOCK_FLAG(verbose) = kWarningVerbosity;
GMOCK_FLAG_SET(verbose, kWarningVerbosity);
TestExpectedCall(false);
TestUninterestingCallOnNaggyMock(true);
}
@@ -2166,7 +2228,7 @@ TEST_F(GMockVerboseFlagTest, Warning) {
// Tests that --gmock_verbose=warning causes neither expected nor
// uninteresting calls to be reported.
TEST_F(GMockVerboseFlagTest, Error) {
GMOCK_FLAG(verbose) = kErrorVerbosity;
GMOCK_FLAG_SET(verbose, kErrorVerbosity);
TestExpectedCall(false);
TestUninterestingCallOnNaggyMock(false);
}
@@ -2174,7 +2236,7 @@ TEST_F(GMockVerboseFlagTest, Error) {
// Tests that --gmock_verbose=SOME_INVALID_VALUE has the same effect
// as --gmock_verbose=warning.
TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
GMOCK_FLAG(verbose) = "invalid"; // Treated as "warning".
GMOCK_FLAG_SET(verbose, "invalid"); // Treated as "warning".
TestExpectedCall(false);
TestUninterestingCallOnNaggyMock(true);
}
@@ -2207,21 +2269,21 @@ class GMockLogTest : public VerboseFlagPreservingFixture {
};
TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
GMOCK_FLAG(verbose) = kWarningVerbosity;
GMOCK_FLAG_SET(verbose, kWarningVerbosity);
EXPECT_CALL(helper_, Foo(_))
.WillOnce(Return(PrintMeNot()));
helper_.Foo(PrintMeNot()); // This is an expected call.
}
TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
GMOCK_FLAG(verbose) = kErrorVerbosity;
GMOCK_FLAG_SET(verbose, kErrorVerbosity);
EXPECT_CALL(helper_, Foo(_))
.WillOnce(Return(PrintMeNot()));
helper_.Foo(PrintMeNot()); // This is an expected call.
}
TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
GMOCK_FLAG(verbose) = kErrorVerbosity;
GMOCK_FLAG_SET(verbose, kErrorVerbosity);
ON_CALL(helper_, Foo(_))
.WillByDefault(Return(PrintMeNot()));
helper_.Foo(PrintMeNot()); // This should generate a warning.
@@ -2561,7 +2623,7 @@ TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
TEST(VerifyAndClearTest,
DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
linked_ptr<MockA> a(new MockA);
std::shared_ptr<MockA> a(new MockA);
ReferenceHoldingMock test_mock;
// EXPECT_CALL stores a reference to a inside test_mock.
@@ -2581,7 +2643,7 @@ TEST(VerifyAndClearTest,
TEST(VerifyAndClearTest,
DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
linked_ptr<MockA> a(new MockA);
std::shared_ptr<MockA> a(new MockA);
ReferenceHoldingMock test_mock;
// ON_CALL stores a reference to a inside test_mock.
@@ -2623,9 +2685,78 @@ TEST(SynchronizationTest, CanCallMockMethodInAction) {
// EXPECT_CALL() did not specify an action.
}
TEST(ParameterlessExpectationsTest, CanSetExpectationsWithoutMatchers) {
MockA a;
int do_a_arg0 = 0;
ON_CALL(a, DoA).WillByDefault(SaveArg<0>(&do_a_arg0));
int do_a_47_arg0 = 0;
ON_CALL(a, DoA(47)).WillByDefault(SaveArg<0>(&do_a_47_arg0));
a.DoA(17);
EXPECT_THAT(do_a_arg0, 17);
EXPECT_THAT(do_a_47_arg0, 0);
a.DoA(47);
EXPECT_THAT(do_a_arg0, 17);
EXPECT_THAT(do_a_47_arg0, 47);
ON_CALL(a, Binary).WillByDefault(Return(true));
ON_CALL(a, Binary(_, 14)).WillByDefault(Return(false));
EXPECT_THAT(a.Binary(14, 17), true);
EXPECT_THAT(a.Binary(17, 14), false);
}
TEST(ParameterlessExpectationsTest, CanSetExpectationsForOverloadedMethods) {
MockB b;
ON_CALL(b, DoB()).WillByDefault(Return(9));
ON_CALL(b, DoB(5)).WillByDefault(Return(11));
EXPECT_THAT(b.DoB(), 9);
EXPECT_THAT(b.DoB(1), 0); // default value
EXPECT_THAT(b.DoB(5), 11);
}
struct MockWithConstMethods {
public:
MOCK_CONST_METHOD1(Foo, int(int));
MOCK_CONST_METHOD2(Bar, int(int, const char*));
};
TEST(ParameterlessExpectationsTest, CanSetExpectationsForConstMethods) {
MockWithConstMethods mock;
ON_CALL(mock, Foo).WillByDefault(Return(7));
ON_CALL(mock, Bar).WillByDefault(Return(33));
EXPECT_THAT(mock.Foo(17), 7);
EXPECT_THAT(mock.Bar(27, "purple"), 33);
}
class MockConstOverload {
public:
MOCK_METHOD1(Overloaded, int(int));
MOCK_CONST_METHOD1(Overloaded, int(int));
};
TEST(ParameterlessExpectationsTest,
CanSetExpectationsForConstOverloadedMethods) {
MockConstOverload mock;
ON_CALL(mock, Overloaded(_)).WillByDefault(Return(7));
ON_CALL(mock, Overloaded(5)).WillByDefault(Return(9));
ON_CALL(Const(mock), Overloaded(5)).WillByDefault(Return(11));
ON_CALL(Const(mock), Overloaded(7)).WillByDefault(Return(13));
EXPECT_THAT(mock.Overloaded(1), 7);
EXPECT_THAT(mock.Overloaded(5), 9);
EXPECT_THAT(mock.Overloaded(7), 7);
const MockConstOverload& const_mock = mock;
EXPECT_THAT(const_mock.Overloaded(1), 0);
EXPECT_THAT(const_mock.Overloaded(5), 11);
EXPECT_THAT(const_mock.Overloaded(7), 13);
}
} // namespace
// Allows the user to define his own main and then invoke gmock_main
// Allows the user to define their own main and then invoke gmock_main
// from it. This might be necessary on some platforms which require
// specific setup and teardown.
#if GMOCK_RENAME_MAIN
@@ -2634,11 +2765,10 @@ int gmock_main(int argc, char **argv) {
int main(int argc, char **argv) {
#endif // GMOCK_RENAME_MAIN
testing::InitGoogleMock(&argc, argv);
// Ensures that the tests pass no matter what value of
// --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
testing::GMOCK_FLAG(catch_leaked_mocks) = true;
testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
GMOCK_FLAG_SET(catch_leaked_mocks, true);
GMOCK_FLAG_SET(verbose, testing::internal::kWarningVerbosity);
return RUN_ALL_TESTS();
}