Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F73209708
gmock_output_test_.cc
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Fri, Jul 19, 15:21
Size
8 KB
Mime Type
text/x-c
Expires
Sun, Jul 21, 15:21 (2 d)
Engine
blob
Format
Raw Data
Handle
19161705
Attached To
R9484 sp4e-homework-lars-bertil
gmock_output_test_.cc
View Options
// 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.
// Tests Google Mock's output in various scenarios. This ensures that
// Google Mock's messages are readable and useful.
#include "gmock/gmock.h"
#include <stdio.h>
#include <string>
#include "gtest/gtest.h"
// Silence C4100 (unreferenced formal parameter)
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif
using
testing
::
_
;
using
testing
::
AnyNumber
;
using
testing
::
Ge
;
using
testing
::
InSequence
;
using
testing
::
NaggyMock
;
using
testing
::
Ref
;
using
testing
::
Return
;
using
testing
::
Sequence
;
using
testing
::
Value
;
class
MockFoo
{
public
:
MockFoo
()
{}
MOCK_METHOD3
(
Bar
,
char
(
const
std
::
string
&
s
,
int
i
,
double
x
));
MOCK_METHOD2
(
Bar2
,
bool
(
int
x
,
int
y
));
MOCK_METHOD2
(
Bar3
,
void
(
int
x
,
int
y
));
private
:
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
MockFoo
);
};
class
GMockOutputTest
:
public
testing
::
Test
{
protected
:
NaggyMock
<
MockFoo
>
foo_
;
};
TEST_F
(
GMockOutputTest
,
ExpectedCall
)
{
testing
::
GMOCK_FLAG
(
verbose
)
=
"info"
;
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
_
));
foo_
.
Bar2
(
0
,
0
);
// Expected call
testing
::
GMOCK_FLAG
(
verbose
)
=
"warning"
;
}
TEST_F
(
GMockOutputTest
,
ExpectedCallToVoidFunction
)
{
testing
::
GMOCK_FLAG
(
verbose
)
=
"info"
;
EXPECT_CALL
(
foo_
,
Bar3
(
0
,
_
));
foo_
.
Bar3
(
0
,
0
);
// Expected call
testing
::
GMOCK_FLAG
(
verbose
)
=
"warning"
;
}
TEST_F
(
GMockOutputTest
,
ExplicitActionsRunOut
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
Times
(
2
)
.
WillOnce
(
Return
(
false
));
foo_
.
Bar2
(
2
,
2
);
foo_
.
Bar2
(
1
,
1
);
// Explicit actions in EXPECT_CALL run out.
}
TEST_F
(
GMockOutputTest
,
UnexpectedCall
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
_
));
foo_
.
Bar2
(
1
,
0
);
// Unexpected call
foo_
.
Bar2
(
0
,
0
);
// Expected call
}
TEST_F
(
GMockOutputTest
,
UnexpectedCallToVoidFunction
)
{
EXPECT_CALL
(
foo_
,
Bar3
(
0
,
_
));
foo_
.
Bar3
(
1
,
0
);
// Unexpected call
foo_
.
Bar3
(
0
,
0
);
// Expected call
}
TEST_F
(
GMockOutputTest
,
ExcessiveCall
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
_
));
foo_
.
Bar2
(
0
,
0
);
// Expected call
foo_
.
Bar2
(
0
,
1
);
// Excessive call
}
TEST_F
(
GMockOutputTest
,
ExcessiveCallToVoidFunction
)
{
EXPECT_CALL
(
foo_
,
Bar3
(
0
,
_
));
foo_
.
Bar3
(
0
,
0
);
// Expected call
foo_
.
Bar3
(
0
,
1
);
// Excessive call
}
TEST_F
(
GMockOutputTest
,
UninterestingCall
)
{
foo_
.
Bar2
(
0
,
1
);
// Uninteresting call
}
TEST_F
(
GMockOutputTest
,
UninterestingCallToVoidFunction
)
{
foo_
.
Bar3
(
0
,
1
);
// Uninteresting call
}
TEST_F
(
GMockOutputTest
,
RetiredExpectation
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
RetiresOnSaturation
();
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
0
));
foo_
.
Bar2
(
1
,
1
);
foo_
.
Bar2
(
1
,
1
);
// Matches a retired expectation
foo_
.
Bar2
(
0
,
0
);
}
TEST_F
(
GMockOutputTest
,
UnsatisfiedPrerequisite
)
{
{
InSequence
s
;
EXPECT_CALL
(
foo_
,
Bar
(
_
,
0
,
_
));
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
0
));
EXPECT_CALL
(
foo_
,
Bar2
(
1
,
_
));
}
foo_
.
Bar2
(
1
,
0
);
// Has one immediate unsatisfied pre-requisite
foo_
.
Bar
(
"Hi"
,
0
,
0
);
foo_
.
Bar2
(
0
,
0
);
foo_
.
Bar2
(
1
,
0
);
}
TEST_F
(
GMockOutputTest
,
UnsatisfiedPrerequisites
)
{
Sequence
s1
,
s2
;
EXPECT_CALL
(
foo_
,
Bar
(
_
,
0
,
_
))
.
InSequence
(
s1
);
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
0
))
.
InSequence
(
s2
);
EXPECT_CALL
(
foo_
,
Bar2
(
1
,
_
))
.
InSequence
(
s1
,
s2
);
foo_
.
Bar2
(
1
,
0
);
// Has two immediate unsatisfied pre-requisites
foo_
.
Bar
(
"Hi"
,
0
,
0
);
foo_
.
Bar2
(
0
,
0
);
foo_
.
Bar2
(
1
,
0
);
}
TEST_F
(
GMockOutputTest
,
UnsatisfiedWith
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
_
,
_
)).
With
(
Ge
());
}
TEST_F
(
GMockOutputTest
,
UnsatisfiedExpectation
)
{
EXPECT_CALL
(
foo_
,
Bar
(
_
,
_
,
_
));
EXPECT_CALL
(
foo_
,
Bar2
(
0
,
_
))
.
Times
(
2
);
foo_
.
Bar2
(
0
,
1
);
}
TEST_F
(
GMockOutputTest
,
MismatchArguments
)
{
const
std
::
string
s
=
"Hi"
;
EXPECT_CALL
(
foo_
,
Bar
(
Ref
(
s
),
_
,
Ge
(
0
)));
foo_
.
Bar
(
"Ho"
,
0
,
-
0.1
);
// Mismatch arguments
foo_
.
Bar
(
s
,
0
,
0
);
}
TEST_F
(
GMockOutputTest
,
MismatchWith
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
Ge
(
2
),
Ge
(
1
)))
.
With
(
Ge
());
foo_
.
Bar2
(
2
,
3
);
// Mismatch With()
foo_
.
Bar2
(
2
,
1
);
}
TEST_F
(
GMockOutputTest
,
MismatchArgumentsAndWith
)
{
EXPECT_CALL
(
foo_
,
Bar2
(
Ge
(
2
),
Ge
(
1
)))
.
With
(
Ge
());
foo_
.
Bar2
(
1
,
3
);
// Mismatch arguments and mismatch With()
foo_
.
Bar2
(
2
,
1
);
}
TEST_F
(
GMockOutputTest
,
UnexpectedCallWithDefaultAction
)
{
ON_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
WillByDefault
(
Return
(
true
));
// Default action #1
ON_CALL
(
foo_
,
Bar2
(
1
,
_
))
.
WillByDefault
(
Return
(
false
));
// Default action #2
EXPECT_CALL
(
foo_
,
Bar2
(
2
,
2
));
foo_
.
Bar2
(
1
,
0
);
// Unexpected call, takes default action #2.
foo_
.
Bar2
(
0
,
0
);
// Unexpected call, takes default action #1.
foo_
.
Bar2
(
2
,
2
);
// Expected call.
}
TEST_F
(
GMockOutputTest
,
ExcessiveCallWithDefaultAction
)
{
ON_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
WillByDefault
(
Return
(
true
));
// Default action #1
ON_CALL
(
foo_
,
Bar2
(
1
,
_
))
.
WillByDefault
(
Return
(
false
));
// Default action #2
EXPECT_CALL
(
foo_
,
Bar2
(
2
,
2
));
EXPECT_CALL
(
foo_
,
Bar2
(
1
,
1
));
foo_
.
Bar2
(
2
,
2
);
// Expected call.
foo_
.
Bar2
(
2
,
2
);
// Excessive call, takes default action #1.
foo_
.
Bar2
(
1
,
1
);
// Expected call.
foo_
.
Bar2
(
1
,
1
);
// Excessive call, takes default action #2.
}
TEST_F
(
GMockOutputTest
,
UninterestingCallWithDefaultAction
)
{
ON_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
WillByDefault
(
Return
(
true
));
// Default action #1
ON_CALL
(
foo_
,
Bar2
(
1
,
_
))
.
WillByDefault
(
Return
(
false
));
// Default action #2
foo_
.
Bar2
(
2
,
2
);
// Uninteresting call, takes default action #1.
foo_
.
Bar2
(
1
,
1
);
// Uninteresting call, takes default action #2.
}
TEST_F
(
GMockOutputTest
,
ExplicitActionsRunOutWithDefaultAction
)
{
ON_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
WillByDefault
(
Return
(
true
));
// Default action #1
EXPECT_CALL
(
foo_
,
Bar2
(
_
,
_
))
.
Times
(
2
)
.
WillOnce
(
Return
(
false
));
foo_
.
Bar2
(
2
,
2
);
foo_
.
Bar2
(
1
,
1
);
// Explicit actions in EXPECT_CALL run out.
}
TEST_F
(
GMockOutputTest
,
CatchesLeakedMocks
)
{
MockFoo
*
foo1
=
new
MockFoo
;
MockFoo
*
foo2
=
new
MockFoo
;
// Invokes ON_CALL on foo1.
ON_CALL
(
*
foo1
,
Bar
(
_
,
_
,
_
)).
WillByDefault
(
Return
(
'a'
));
// Invokes EXPECT_CALL on foo2.
EXPECT_CALL
(
*
foo2
,
Bar2
(
_
,
_
));
EXPECT_CALL
(
*
foo2
,
Bar2
(
1
,
_
));
EXPECT_CALL
(
*
foo2
,
Bar3
(
_
,
_
)).
Times
(
AnyNumber
());
foo2
->
Bar2
(
2
,
1
);
foo2
->
Bar2
(
1
,
1
);
// Both foo1 and foo2 are deliberately leaked.
}
MATCHER_P2
(
IsPair
,
first
,
second
,
""
)
{
return
Value
(
arg
.
first
,
first
)
&&
Value
(
arg
.
second
,
second
);
}
TEST_F
(
GMockOutputTest
,
PrintsMatcher
)
{
const
testing
::
Matcher
<
int
>
m1
=
Ge
(
48
);
EXPECT_THAT
((
std
::
pair
<
int
,
bool
>
(
42
,
true
)),
IsPair
(
m1
,
true
));
}
void
TestCatchesLeakedMocksInAdHocTests
()
{
MockFoo
*
foo
=
new
MockFoo
;
// Invokes EXPECT_CALL on foo.
EXPECT_CALL
(
*
foo
,
Bar2
(
_
,
_
));
foo
->
Bar2
(
2
,
1
);
// foo is deliberately leaked.
}
int
main
(
int
argc
,
char
**
argv
)
{
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
)
=
"warning"
;
TestCatchesLeakedMocksInAdHocTests
();
return
RUN_ALL_TESTS
();
}
#ifdef _MSC_VER
# pragma warning(pop)
#endif
Event Timeline
Log In to Comment