mirrors/turtle
3
0
Fork 0
mirror of https://github.com/mat007/turtle.git synced 2026-06-22 12:13:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Preview of clang-format changes and CI

Browse source
This commit is contained in:
Alexander Grund 2020-09-05 14:37:48 +02:00
parent bfd1701fcb
commit 805e3b02bf
No known key found for this signature in database
GPG key ID: E92C451FC21EF13F
98 changed files with 6339 additions and 11357 deletions
Download patch file Download diff file Expand all files Collapse all files

139
.clang-format Normal file
View file

@ -0,0 +1,139 @@
---
Language: Cpp
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterCaseLabel: true
AfterClass: true
AfterControlStatement: true
AfterEnum: true
AfterFunction: true
AfterNamespace: false
AfterObjCDeclaration: true
AfterStruct: true
AfterUnion: true
AfterExternBlock: true
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: false
SplitEmptyNamespace: false
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: AfterColon
BreakBeforeTernaryOperators: false
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 120
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: true
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 2
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '<turtle/'
Priority: 10
SortPriority: 0
- Regex: '<boost/'
Priority: 20
SortPriority: 0
- Regex: '^<'
Priority: 30
SortPriority: 0
- Regex: '.*'
Priority: 1
SortPriority: 0
IncludeIsMainRegex: '(Impl|_Win32|_Other)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: true
IndentGotoLabels: true
IndentPPDirectives: AfterHash
IndentWidth: 4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: Inner
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 10000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: Never
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: c++14
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 4
UseCRLF: false
UseTab: Never
...

17
.github/workflows/static-analysis.yml vendored Normal file
View file

@ -0,0 +1,17 @@
name: Static analysis
on:
push:
pull_request:
jobs:
Formatting:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- run: git submodule update --init
- name: Formatting
uses: DoozyX/clang-format-lint-action@v0.9
with:
source: 'include test doc'
clangFormatVersion: 10

46
doc/example/customization.cpp
View file

@ -14,8 +14,7 @@
#include "mock_view.hpp"
//[ mock_stream_user_type
namespace user_namespace
{
namespace user_namespace {
struct user_type
{};
@ -23,11 +22,10 @@ namespace user_namespace
{
return s << "user_type";
}
}
} // namespace user_namespace
//]
namespace custom_constraint_free_function_test
{
namespace custom_constraint_free_function_test {
//[ custom_constraint_free_function
bool custom_constraint(int actual)
{
@ -44,22 +42,15 @@ BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two )
c.add(41, 1);
}
//]
}
} // namespace custom_constraint_free_function_test
namespace custom_constraint_functor_test
{
namespace custom_constraint_functor_test {
//[ custom_constraint_functor
struct custom_constraint
{
friend bool operator==( int actual, const custom_constraint& )
{
return actual == 42;
}
friend bool operator==(int actual, const custom_constraint&) { return actual == 42; }
friend std::ostream& operator<<( std::ostream& s, const custom_constraint& )
{
return s << "_ == 42";
}
friend std::ostream& operator<<(std::ostream& s, const custom_constraint&) { return s << "_ == 42"; }
};
//]
@ -72,28 +63,23 @@ BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two )
c.add(41, 1);
}
//]
}
} // namespace custom_constraint_functor_test
//[ near_constraint
template<typename Expected>
struct near_constraint
{
near_constraint( Expected expected, Expected threshold )
: expected_( expected )
, threshold_( threshold )
{}
near_constraint(Expected expected, Expected threshold) : expected_(expected), threshold_(threshold) {}
template<typename Actual>
bool operator()(Actual actual) const
{
return std::abs( actual - boost::unwrap_ref( expected_ ) )
< boost::unwrap_ref( threshold_ );
return std::abs(actual - boost::unwrap_ref(expected_)) < boost::unwrap_ref(threshold_);
}
friend std::ostream& operator<<(std::ostream& s, const near_constraint& c)
{
return s << "near( " << mock::format( c.expected_ )
<< ", " << mock::format( c.threshold_ ) << " )";
return s << "near( " << mock::format(c.expected_) << ", " << mock::format(c.threshold_) << " )";
}
Expected expected_, threshold_;
@ -106,8 +92,7 @@ mock::constraint< near_constraint< Expected > > near( Expected expected, Expecte
}
//]
namespace near_constraint_test
{
namespace near_constraint_test {
//[ near_constraint_test
BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one)
{
@ -117,10 +102,9 @@ BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_plus_or_minus_one )
c.add(41, 1);
}
//]
}
} // namespace near_constraint_test
namespace near_constraint_cref_test
{
namespace near_constraint_cref_test {
//[ near_constraint_cref_test
BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one)
{
@ -133,7 +117,7 @@ BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_plus_or_minus_one )
c.add(41, 1);
}
//]
}
} // namespace near_constraint_cref_test
#undef MOCK_MAX_ARGS
//[ max_args

37
doc/example/getting_started.cpp
View file

@ -8,14 +8,13 @@
//[ prerequisite
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
//]
#include "calculator.hpp"
#include "mock_view.hpp"
namespace phases
{
namespace phases {
//[ phases
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
@ -25,10 +24,9 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
c.add(0, 0); // exercise object under test
} // verify mock objects
//]
}
} // namespace phases
namespace verify_reset
{
namespace verify_reset {
//[ verify_reset
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
@ -44,10 +42,9 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
mock::reset(); // reset all expectations for all existing mock objects
} // automatically verify all expectations are fulfilled for all mock objects going out of scope
//]
}
} // namespace verify_reset
namespace expectations
{
namespace expectations {
//[ expectations
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
@ -58,10 +55,9 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
c.add(0, 0);
}
//]
}
} // namespace expectations
namespace sequence
{
namespace sequence {
//[ sequence
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
@ -74,10 +70,9 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
c.add(1, 0);
}
//]
}
} // namespace sequence
namespace several_sequences
{
namespace several_sequences {
//[ several_sequences
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
@ -93,10 +88,9 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
c.add(2, 0);
}
//]
}
} // namespace several_sequences
namespace action
{
namespace action {
//[ action_view
class view
{
@ -105,10 +99,7 @@ public:
};
//]
MOCK_BASE_CLASS( mock_view, view )
{
MOCK_METHOD( display, 1 )
};
MOCK_BASE_CLASS(mock_view, view){MOCK_METHOD(display, 1)};
class calculator
{
@ -126,4 +117,4 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
c.add(0, 0);
}
//]
}
} // namespace action

28
doc/example/limitations_comma_in_macro.cpp
View file

@ -7,42 +7,36 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_comma_in_macro_problem
template<typename T1, typename T2>
struct my_base_class
{};
//]
}
} // namespace
namespace limitations_comma_in_macro_solution_1
{
namespace limitations_comma_in_macro_solution_1 {
//[ limitations_comma_in_macro_solution_1
typedef my_base_class<int, int> my_base_type;
MOCK_BASE_CLASS( my_mock, my_base_type )
{};
MOCK_BASE_CLASS(my_mock, my_base_type){};
//]
}
} // namespace limitations_comma_in_macro_solution_1
namespace limitations_comma_in_macro_solution_2
{
namespace limitations_comma_in_macro_solution_2 {
//[ limitations_comma_in_macro_solution_2
template<typename T1, typename T2>
MOCK_BASE_CLASS( my_mock, my_base_class< T1 BOOST_PP_COMMA() T2 > )
{};
MOCK_BASE_CLASS(my_mock, my_base_class<T1 BOOST_PP_COMMA() T2>){};
//]
}
} // namespace limitations_comma_in_macro_solution_2
namespace limitations_comma_in_macro_solution_3
{
namespace limitations_comma_in_macro_solution_3 {
//[ limitations_comma_in_macro_solution_3
template<typename T1, typename T2>
struct my_mock : my_base_class<T1, T2>, mock::object
{};
//]
}
} // namespace limitations_comma_in_macro_solution_3

29
doc/example/limitations_const_parameter_warning.cpp
View file

@ -7,11 +7,10 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_const_parameter_warning_problem
class base
{
@ -19,10 +18,9 @@ namespace
virtual void method(const int) = 0;
};
//]
}
} // namespace
namespace limitations_const_parameter_warning_explanation
{
namespace limitations_const_parameter_warning_explanation {
//[ limitations_const_parameter_warning_explanation
class derived : public base
{
@ -30,21 +28,16 @@ namespace limitations_const_parameter_warning_explanation
virtual void method(const int);
};
void derived::method( int )
{}
void derived::method(int) {}
//]
}
} // namespace limitations_const_parameter_warning_explanation
namespace limitations_const_parameter_warning_solution
{
namespace limitations_const_parameter_warning_solution {
//[ limitations_const_parameter_warning_solution
MOCK_BASE_CLASS( mock_base, base )
{
void method( const int i )
{
method_stub( i );
}
MOCK_BASE_CLASS(mock_base, base){void method(const int i){method_stub(i);
} // namespace limitations_const_parameter_warning_solution
MOCK_METHOD(method_stub, 1, void(int), method)
};
}
;
//]
}

12
doc/example/limitations_literal_zero.cpp
View file

@ -7,11 +7,10 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_literal_zero_problem
class base
{
@ -19,12 +18,9 @@ namespace
virtual void method(int* i) = 0;
};
MOCK_BASE_CLASS( mock_base, base )
{
MOCK_METHOD( method, 1 )
};
MOCK_BASE_CLASS(mock_base, base){MOCK_METHOD(method, 1)};
//]
}
} // namespace
BOOST_AUTO_TEST_CASE(literal_zero)
{

7
doc/example/limitations_non_virtual_method.cpp
View file

@ -7,8 +7,8 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
//[ limitations_non_virtual_method_problem
class base
@ -20,8 +20,5 @@ public:
//]
//[ limitations_non_virtual_method_problem_2
MOCK_BASE_CLASS( mock_base, base )
{
MOCK_METHOD( method, 0 )
};
MOCK_BASE_CLASS(mock_base, base){MOCK_METHOD(method, 0)};
//]

14
doc/example/limitations_protected_private_method.cpp
View file

@ -7,26 +7,22 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_protected_private_method_problem
class base
{
protected:
virtual void method_1() = 0;
private:
virtual void method_2() = 0;
};
//]
//[ limitations_protected_private_method_solution
MOCK_BASE_CLASS( mock_base, base )
{
MOCK_METHOD( method_1, 0, void() )
MOCK_METHOD( method_2, 0, void() )
};
MOCK_BASE_CLASS(mock_base, base){MOCK_METHOD(method_1, 0, void()) MOCK_METHOD(method_2, 0, void())};
//]
}
} // namespace

15
doc/example/limitations_template_base_class_method.cpp
View file

@ -7,18 +7,16 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_template_base_class_method_problem
template<typename T>
class base
{
public:
virtual ~base()
{}
virtual ~base() {}
virtual void method() = 0;
};
@ -26,9 +24,6 @@ namespace
//[ limitations_template_base_class_method_solution
template<typename T>
MOCK_BASE_CLASS( mock_base, base< T > )
{
MOCK_METHOD( method, 1, void() )
};
MOCK_BASE_CLASS(mock_base, base<T>){MOCK_METHOD(method, 1, void())};
//]
}
} // namespace

19
doc/example/limitations_template_method.cpp
View file

@ -7,11 +7,10 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace limitations_template_method_problem
{
namespace limitations_template_method_problem {
//[ limitations_template_method_problem
class concept
{
@ -30,16 +29,12 @@ void function_under_test( T t ) // T is supposed to model the previous concept
//]
//[ limitations_template_method_solution
MOCK_CLASS( mock_concept )
{
MOCK_METHOD( method, 1, void( int ), method_int )
MOCK_METHOD( method, 1, void( const char* ), method_string )
};
MOCK_CLASS(mock_concept){MOCK_METHOD(method, 1, void(int), method_int)
MOCK_METHOD(method, 1, void(const char*), method_string)};
//]
}
} // namespace limitations_template_method_problem
namespace limitations_template_method_problem_2
{
namespace limitations_template_method_problem_2 {
//[ limitations_template_method_problem_2
class concept
{
@ -80,4 +75,4 @@ std::string mock_concept::create< std::string >()
return create_string();
}
//]
}
} // namespace limitations_template_method_problem_2

19
doc/example/limitations_throw_specifier.cpp
View file

@ -7,29 +7,24 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
//[ limitations_throw_specifier_problem
struct base_class
{
virtual ~base_class()
{}
virtual ~base_class() {}
virtual void method() throw();
};
//]
//[ limitations_throw_specifier_solution
MOCK_BASE_CLASS( mock_class, base_class )
{
void method() throw ()
{
method_proxy();
}
MOCK_BASE_CLASS(mock_class, base_class){void method() throw(){method_proxy();
} // namespace
MOCK_METHOD(method_proxy, 0, void(), method)
};
}
;
//]
}

2
doc/example/mock_view.hpp
View file

@ -9,8 +9,8 @@
#ifndef MOCK_VIEW
#define MOCK_VIEW
#include <turtle/mock.hpp>
#include "view.hpp"
#include <turtle/mock.hpp>
//[ mock_view
MOCK_BASE_CLASS(mock_view, view) // declare a 'mock_view' class implementing 'view'

26
doc/example/motivation.cpp
View file

@ -7,13 +7,12 @@
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include "calculator.hpp"
#include "mock_view.hpp"
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace simple
{
namespace simple {
//[ simple_calculator
class calculator
{
@ -29,17 +28,14 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
BOOST_CHECK_EQUAL(0, c.add(0, 0));
}
//]
}
} // namespace simple
namespace without_mock_object
{
namespace without_mock_object {
//[ my_view
class my_view : public view
{
public:
my_view()
: called( false )
{}
my_view() : called(false) {}
virtual void display(int result)
{
called = true;
@ -60,17 +56,17 @@ BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
BOOST_CHECK_EQUAL(0, v.value);
}
//]
}
} // namespace without_mock_object
namespace with_mock_object
{
namespace with_mock_object {
//[ zero_plus_zero_is_zero_with_mock_object
BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero)
{
mock_view v;
calculator c(v);
MOCK_EXPECT( v.display ).once().with( 0 ); // expect the 'display' method to be called once (and only once) with a parameter value equal to 0
MOCK_EXPECT(v.display).once().with(
0); // expect the 'display' method to be called once (and only once) with a parameter value equal to 0
c.add(0, 0);
}
//]
}
} // namespace with_mock_object

21
doc/example/patterns_async_call.cpp
View file

@ -7,8 +7,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//[ async_call_problem
namespace
{
namespace {
class base_class
{
public:
@ -22,18 +21,17 @@ namespace
void flush(); // repetitively calling this method will in turn call base_class::method at some point
};
}
} // namespace
//]
//[ async_call_solution
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/thread.hpp>
#include <turtle/mock.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/thread.hpp>
namespace
{
namespace {
template<typename F>
void check(bool& condition, F flush, int attempts = 100, int sleep = 100)
{
@ -45,15 +43,12 @@ namespace
}
}
MOCK_BASE_CLASS( mock_base_class, base_class )
{
MOCK_METHOD( method, 0 )
};
MOCK_BASE_CLASS(mock_base_class, base_class){MOCK_METHOD(method, 0)};
void set_bool(bool& b)
{
b = true;
}
}
} // namespace
BOOST_AUTO_TEST_CASE(method_is_called)
{

20
doc/example/patterns_invoke_functor.cpp
View file

@ -9,8 +9,7 @@
//[ invoke_functor_problem
#include <boost/function.hpp>
namespace
{
namespace {
class base_class
{
public:
@ -18,27 +17,24 @@ namespace
};
void function(base_class&); // the function will call 'method' with a functor to be applied
}
} // namespace
//]
//[ invoke_functor_solution
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <boost/bind/apply.hpp>
#include <turtle/mock.hpp>
#include <boost/bind/apply.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
MOCK_BASE_CLASS( mock_class, base_class )
{
MOCK_METHOD( method, 1 )
};
namespace {
MOCK_BASE_CLASS(mock_class, base_class){MOCK_METHOD(method, 1)};
}
BOOST_AUTO_TEST_CASE(how_to_invoke_a_functor_passed_as_parameter_of_a_mock_method)
{
mock_class mock;
MOCK_EXPECT( mock.method ).calls( boost::bind( boost::apply< void >(), _1, 42 ) ); // whenever 'method' is called, invoke the functor with 42
MOCK_EXPECT(mock.method)
.calls(boost::bind(boost::apply<void>(), _1, 42)); // whenever 'method' is called, invoke the functor with 42
function(mock);
}
//]

23
doc/example/patterns_quick_constraint.cpp
View file

@ -8,18 +8,15 @@
//[ quick_constraint_problem
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <iostream>
namespace
{
namespace {
class my_class
{
public:
explicit my_class( int data )
: data_( data )
{}
explicit my_class(int data) : data_(data) {}
int data_;
};
@ -28,11 +25,10 @@ namespace
return os << "my_class( " << c.data_ << " )";
}
MOCK_CLASS( my_mock )
{
MOCK_CLASS(my_mock){
MOCK_METHOD(method, 1, void(const my_class&)) // how to simply write a custom constraint ?
};
}
} // namespace
//]
//[ quick_constraint_solution
@ -40,16 +36,19 @@ namespace
namespace // in the same namespace as 'my_class'
{
bool operator==( const my_class& actual, const std::string& expected ) // the first part of the trick is to compare to a string
bool operator==(const my_class& actual,
const std::string& expected) // the first part of the trick is to compare to a string
{
return boost::lexical_cast<std::string>(actual) == expected;
}
} // mock
} // namespace
BOOST_AUTO_TEST_CASE(method_is_called)
{
my_mock mock;
MOCK_EXPECT( mock.method ).once().with( "my_class( 42 )" ); // the second part of the trick is to express the constraint as a string
MOCK_EXPECT(mock.method)
.once()
.with("my_class( 42 )"); // the second part of the trick is to express the constraint as a string
mock.method(my_class(42));
}
//]

25
doc/example/patterns_retrieve_cref.cpp
View file

@ -7,8 +7,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//[ retrieve_cref_problem
namespace
{
namespace {
class base_class
{
public:
@ -20,22 +19,19 @@ namespace
public:
explicit my_class(base_class&);
void process(); // the processing will call 'method' two times with the same value, but we don't know what value beforehand
void process(); // the processing will call 'method' two times with the same value, but we don't know what value
// beforehand
};
}
} // namespace
//]
//[ retrieve_cref_solution
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
MOCK_BASE_CLASS( mock_base_class, base_class )
{
MOCK_METHOD( method, 1 )
};
namespace {
MOCK_BASE_CLASS(mock_base_class, base_class){MOCK_METHOD(method, 1)};
}
BOOST_AUTO_TEST_CASE(method_is_called_two_times_with_the_same_value)
@ -43,8 +39,11 @@ BOOST_AUTO_TEST_CASE( method_is_called_two_times_with_the_same_value )
mock_base_class mock;
my_class c(mock);
int value;
MOCK_EXPECT( mock.method ).once().with( mock::retrieve( value ) ); // on first call retrieve the value, this expectation takes precedence because it can never fail
MOCK_EXPECT( mock.method ).once().with( boost::cref( value ) ); // on second call compare the previously retrieved value with the newly received one
MOCK_EXPECT(mock.method).once().with(mock::retrieve(value)); // on first call retrieve the value, this expectation
// takes precedence because it can never fail
MOCK_EXPECT(mock.method)
.once()
.with(boost::cref(value)); // on second call compare the previously retrieved value with the newly received one
c.process();
}
//]

21
doc/example/patterns_static_objects.cpp
View file

@ -8,17 +8,14 @@
//[ static_objects_problem
#define BOOST_AUTO_TEST_MAIN
#include <boost/test/auto_unit_test.hpp>
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <ostream>
namespace
{
namespace {
struct my_class
{
my_class( int i )
: i_( i )
{}
my_class(int i) : i_(i) {}
int i_;
};
@ -29,12 +26,13 @@ namespace
}
MOCK_FUNCTION(f, 1, void(my_class*)) // being static 'f' outlive the test case
}
} // namespace
BOOST_AUTO_TEST_CASE(static_objects_problem)
{
my_class c(42);
MOCK_EXPECT( f ).once().with( &c ); // the set expectation will also outlive the test case and leak into other test cases using 'f'
MOCK_EXPECT(f).once().with(
&c); // the set expectation will also outlive the test case and leak into other test cases using 'f'
} // the 'c' instance goes out of scope and the '&c' pointer becomes dangling
//]
@ -43,7 +41,8 @@ struct fixture
{
~fixture()
{
mock::reset(); // the use of a fixture ensures the reset will prevent the expectations from leaking into other test cases
mock::reset(); // the use of a fixture ensures the reset will prevent the expectations from leaking into other
// test cases
}
};
@ -57,7 +56,9 @@ BOOST_FIXTURE_TEST_CASE( static_object_partial_solution, fixture )
//]
//[ static_objects_solution
BOOST_FIXTURE_TEST_CASE( static_objects_solution, mock::cleanup ) // actually the library includes a ready to use fixture just like the one described
BOOST_FIXTURE_TEST_CASE(
static_objects_solution,
mock::cleanup) // actually the library includes a ready to use fixture just like the one described
{
my_class c(42);
MOCK_EXPECT(f).once().with(&c);

2
doc/example/rationale.cpp
View file

@ -6,9 +6,9 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <turtle/mock.hpp>
#include "calculator.hpp"
#include "mock_view.hpp"
#include <turtle/mock.hpp>
//[ overflow_throws
BOOST_AUTO_TEST_CASE(overflow_throws)

592
doc/example/reference.cpp
View file

File diff suppressed because it is too large Load diff

9
include/turtle/catch.hpp
View file

@ -21,8 +21,8 @@ struct catch_mock_error_policy
}
template<typename Context>
static void fail( const char* message, const Context& context,
const char* file = "file://unknown-location", int line = 0 )
static void fail(const char* message, const Context& context, const char* file = "file://unknown-location",
int line = 0)
{
CAPTURE(context);
FAIL_CHECK(message << " in: " << file << ":" << line);
@ -35,10 +35,7 @@ struct catch_mock_error_policy
INFO(file << ":" << line);
}
static void pass( const char* file, int line )
{
INFO( file << ":" << line );
}
static void pass(const char* file, int line) { INFO(file << ":" << line); }
};
#define MOCK_ERROR_POLICY catch_mock_error_policy

13
include/turtle/cleanup.hpp
View file

@ -10,20 +10,16 @@
#define MOCK_CLEANUP_HPP_INCLUDED
#include "config.hpp"
#include "verify.hpp"
#include "reset.hpp"
#include "verify.hpp"
#ifdef MOCK_USE_BOOST_TEST
# include <boost/test/unit_test_suite.hpp>
#endif
namespace mock
{
namespace mock {
struct cleanup
{
~cleanup()
{
mock::reset();
}
~cleanup() { mock::reset(); }
};
#ifdef MOCK_USE_BOOST_TEST
@ -33,7 +29,6 @@ namespace mock
# endif
#endif
} // mock
} // namespace mock
#endif // MOCK_CLEANUP_HPP_INCLUDED

3
include/turtle/config.hpp
View file

@ -94,8 +94,7 @@
# endif
#endif
#if defined(__cpp_lib_uncaught_exceptions) || \
defined(_MSC_VER) && (_MSC_VER >= 1900)
#if defined(__cpp_lib_uncaught_exceptions) || defined(_MSC_VER) && (_MSC_VER >= 1900)
# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS
# define MOCK_UNCAUGHT_EXCEPTIONS
# endif

160
include/turtle/constraint.hpp
View file

@ -11,40 +11,32 @@
#include "config.hpp"
#include "log.hpp"
#include <boost/ref.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/move/move.hpp>
#include <boost/preprocessor/array.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/variadic/to_array.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/array.hpp>
#include <boost/move/move.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/variadic/to_array.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/decay.hpp>
namespace mock
{
namespace mock {
template<typename Constraint>
struct constraint
{
constraint()
{}
constraint( const Constraint& c )
: c_( c )
{}
constraint() {}
constraint(const Constraint& c) : c_(c) {}
Constraint c_;
};
namespace detail
{
namespace detail {
template<typename Lhs, typename Rhs>
class and_
{
public:
and_( const Lhs& lhs, const Rhs& rhs )
: lhs_( lhs )
, rhs_( rhs )
{}
and_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
@ -52,9 +44,9 @@ namespace detail
}
friend std::ostream& operator<<(std::ostream& s, const and_& a)
{
return s << "( " << mock::format( a.lhs_ )
<< " && " << mock::format( a.rhs_ ) << " )";
return s << "( " << mock::format(a.lhs_) << " && " << mock::format(a.rhs_) << " )";
}
private:
Lhs lhs_;
Rhs rhs_;
@ -64,10 +56,7 @@ namespace detail
class or_
{
public:
or_( const Lhs& lhs, const Rhs& rhs )
: lhs_( lhs )
, rhs_( rhs )
{}
or_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
@ -75,9 +64,9 @@ namespace detail
}
friend std::ostream& operator<<(std::ostream& s, const or_& o)
{
return s << "( " << mock::format( o.lhs_ )
<< " || " << mock::format( o.rhs_ )<< " )";
return s << "( " << mock::format(o.lhs_) << " || " << mock::format(o.rhs_) << " )";
}
private:
Lhs lhs_;
Rhs rhs_;
@ -87,50 +76,40 @@ namespace detail
class not_
{
public:
explicit not_( const Constraint& c )
: c_( c )
{}
explicit not_(const Constraint& c) : c_(c) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
return !c_(actual);
}
friend std::ostream& operator<<( std::ostream& s, const not_& n )
{
return s << "! " << mock::format( n.c_ );
}
friend std::ostream& operator<<(std::ostream& s, const not_& n) { return s << "! " << mock::format(n.c_); }
private:
Constraint c_;
};
}
} // namespace detail
template<typename Lhs, typename Rhs>
const constraint< detail::or_< Lhs, Rhs > >
operator||( const constraint< Lhs >& lhs,
const constraint< Rhs >& rhs )
const constraint<detail::or_<Lhs, Rhs>> operator||(const constraint<Lhs>& lhs, const constraint<Rhs>& rhs)
{
return detail::or_<Lhs, Rhs>(lhs.c_, rhs.c_);
}
template<typename Lhs, typename Rhs>
const constraint< detail::and_< Lhs, Rhs > >
operator&&( const constraint< Lhs >& lhs,
const constraint< Rhs >& rhs )
const constraint<detail::and_<Lhs, Rhs>> operator&&(const constraint<Lhs>& lhs, const constraint<Rhs>& rhs)
{
return detail::and_<Lhs, Rhs>(lhs.c_, rhs.c_);
}
template<typename Constraint>
const constraint< detail::not_< Constraint > >
operator!( const constraint< Constraint >& c )
const constraint<detail::not_<Constraint>> operator!(const constraint<Constraint>& c)
{
return detail::not_<Constraint>(c.c_);
}
} // mock
} // namespace mock
#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail \
{ \
namespace detail { \
struct Name \
{ \
template<typename Actual> \
@ -138,121 +117,88 @@ namespace detail
{ \
return Expr; \
} \
friend std::ostream& operator<<( std::ostream& s, const Name& ) \
{ \
return s << BOOST_STRINGIZE(Name); \
} \
friend std::ostream& operator<<(std::ostream& s, const Name&) { return s << BOOST_STRINGIZE(Name); } \
}; \
} \
const mock::constraint<detail::Name> Name;
#define MOCK_CONSTRAINT_ASSIGN(z, n, d) \
expected##n( boost::forward< T##n >(e##n) )
#define MOCK_CONSTRAINT_ASSIGN(z, n, d) expected##n(boost::forward<T##n>(e##n))
#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) \
boost::unwrap_ref( expected##n )
#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) boost::unwrap_ref(expected##n)
#define MOCK_CONSTRAINT_FORMAT(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) mock::format( c.expected##n )
#define MOCK_CONSTRAINT_FORMAT(z, n, d) BOOST_PP_IF(n, << ", " <<, ) mock::format(c.expected##n)
#define MOCK_CONSTRAINT_MEMBER(z, n, d) \
Expected_##n expected##n;
#define MOCK_CONSTRAINT_MEMBER(z, n, d) Expected_##n expected##n;
#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) \
typename boost::decay< const T##n >::type
#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) typename boost::decay<const T##n>::type
#define MOCK_CONSTRAINT_CREF_PARAM(z, n, Args) \
const typename boost::unwrap_reference< Expected_##n >::type& \
BOOST_PP_ARRAY_ELEM(n, Args)
const typename boost::unwrap_reference<Expected_##n>::type& BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARG(z, n, Args) \
BOOST_FWD_REF(T##n) BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARG(z, n, Args) BOOST_FWD_REF(T##n) BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARGS(z, n, Args) \
BOOST_FWD_REF(T##n) e##n
#define MOCK_CONSTRAINT_ARGS(z, n, Args) BOOST_FWD_REF(T##n) e##n
#define MOCK_CONSTRAINT_PARAM(z, n, Args) \
boost::forward< T##n >( BOOST_PP_ARRAY_ELEM(n, Args) )
#define MOCK_CONSTRAINT_PARAM(z, n, Args) boost::forward<T##n>(BOOST_PP_ARRAY_ELEM(n, Args))
#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail \
{ \
namespace detail { \
template<BOOST_PP_ENUM_PARAMS(n, typename Expected_)> \
struct Name \
{ \
template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
explicit Name( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _) ) \
: BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \
explicit Name(BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _)) : BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \
{} \
template<typename Actual> \
bool operator()(const Actual& actual) const \
{ \
return test( actual, \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _) ); \
return test(actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _)); \
} \
template<typename Actual> \
bool test( const Actual& actual, \
BOOST_PP_ENUM(n, \
MOCK_CONSTRAINT_CREF_PARAM, (n, Args)) ) const \
bool test(const Actual& actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_CREF_PARAM, (n, Args))) const \
{ \
return Expr; \
} \
friend std::ostream& operator<<(std::ostream& s, const Name& c) \
{ \
return s << BOOST_STRINGIZE(Name) << "( " \
<< BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) \
<< " )"; \
return s << BOOST_STRINGIZE(Name) << "( " << BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) << " )"; \
} \
BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \
}; \
} \
template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
mock::constraint< \
detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) > \
> Name( BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args)) ) \
mock::constraint<detail::Name<BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _)>> Name( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args))) \
{ \
return detail::Name<BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _)>( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args))); \
}
#define MOCK_CONSTRAINT_EXT(Name, n, Args, Expr) \
BOOST_PP_IF(n, \
MOCK_NARY_CONSTRAINT, \
MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr)
BOOST_PP_IF(n, MOCK_NARY_CONSTRAINT, MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr)
#ifdef MOCK_VARIADIC_MACROS
# ifdef BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
BOOST_PP_CAT(MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),)
BOOST_PP_CAT(MOCK_VARIADIC_SIZE_I(__VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ), )
# else // BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
MOCK_VARIADIC_SIZE_I(__VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, \
14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, )
# endif // BOOST_MSVC
#define MOCK_VARIADIC_SIZE_I( \
e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, \
e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, \
e25, e26, e27, e28, e29, e30, e31, size, ...) size
# define MOCK_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, \
e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, size, ...) \
size
# define MOCK_CONSTRAINT_AUX_AUX(Name, n, Array) \
MOCK_CONSTRAINT_EXT( \
Name, n, \
BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \
MOCK_CONSTRAINT_EXT(Name, n, BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \
BOOST_PP_ARRAY_ELEM(n, Array))
#define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) \
MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size,Tuple))
# define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size, Tuple))
#define MOCK_CONSTRAINT(Name, ...) \
MOCK_CONSTRAINT_AUX( \
Name, MOCK_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))
# define MOCK_CONSTRAINT(Name, ...) MOCK_CONSTRAINT_AUX(Name, MOCK_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))
#endif // MOCK_VARIADIC_MACROS

147
include/turtle/constraints.hpp
View file

@ -14,19 +14,18 @@
#include "detail/addressof.hpp"
#include "detail/move_helper.hpp"
#include <boost/ref.hpp>
#include <boost/version.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/common_type.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/has_equal_to.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/version.hpp>
#if BOOST_VERSION >= 107000
# include <boost/test/tools/floating_point_comparison.hpp>
#else
# include <boost/test/floating_point_comparison.hpp>
#endif
namespace mock
{
namespace mock {
MOCK_UNARY_CONSTRAINT(any, 0, , ((void)actual, true))
MOCK_UNARY_CONSTRAINT(affirm, 0, , !!actual)
MOCK_UNARY_CONSTRAINT(negate, 0, , !actual)
@ -39,23 +38,15 @@ namespace mock
#if BOOST_VERSION < 105900
# define MOCK_SMALL() \
boost::test_tools::check_is_small( actual, tolerance )
# define MOCK_SMALL() boost::test_tools::check_is_small(actual, tolerance)
# define MOCK_PERCENT_TOLERANCE() \
boost::test_tools::check_is_close( \
actual, \
expected, \
boost::test_tools::percent_tolerance( tolerance ) )
boost::test_tools::check_is_close(actual, expected, boost::test_tools::percent_tolerance(tolerance))
# define MOCK_FRACTION_TOLERANCE() \
boost::test_tools::check_is_close( \
actual, \
expected, \
boost::test_tools::fraction_tolerance( tolerance ) )
boost::test_tools::check_is_close(actual, expected, boost::test_tools::fraction_tolerance(tolerance))
#else // BOOST_VERSION < 105900
namespace detail
{
namespace detail {
template<typename T, typename Tolerance>
bool is_small(const T& t, const Tolerance& tolerance)
{
@ -66,18 +57,13 @@ namespace detail
bool is_close(const T1& t1, const T2& t2, const Tolerance& tolerance)
{
typedef typename boost::common_type<T1, T2>::type common_type;
return boost::math::fpc::close_at_tolerance< common_type >(
tolerance, boost::math::fpc::FPC_STRONG )( t1, t2 );
}
return boost::math::fpc::close_at_tolerance<common_type>(tolerance, boost::math::fpc::FPC_STRONG)(t1, t2);
}
} // namespace detail
# define MOCK_SMALL() \
detail::is_small( actual, tolerance )
# define MOCK_PERCENT_TOLERANCE() \
detail::is_close( actual, expected, \
boost::math::fpc::percent_tolerance( tolerance ) )
# define MOCK_FRACTION_TOLERANCE() \
detail::is_close( actual, expected, tolerance )
# define MOCK_SMALL() detail::is_small(actual, tolerance)
# define MOCK_PERCENT_TOLERANCE() detail::is_close(actual, expected, boost::math::fpc::percent_tolerance(tolerance))
# define MOCK_FRACTION_TOLERANCE() detail::is_close(actual, expected, tolerance)
#endif // BOOST_VERSION < 105900
@ -86,17 +72,14 @@ namespace detail
# undef small
# define MOCK_SMALL_DEFINED
#endif
MOCK_NARY_CONSTRAINT( small, 1, ( tolerance ),
( MOCK_SMALL() ) )
MOCK_NARY_CONSTRAINT(small, 1, (tolerance), (MOCK_SMALL()))
#ifdef MOCK_SMALL_DEFINED
# pragma pop_macro("small")
#endif
MOCK_NARY_CONSTRAINT( close, 2, ( expected, tolerance ),
( MOCK_PERCENT_TOLERANCE() ) )
MOCK_NARY_CONSTRAINT(close, 2, (expected, tolerance), (MOCK_PERCENT_TOLERANCE()))
MOCK_NARY_CONSTRAINT( close_fraction, 2, ( expected, tolerance ),
( MOCK_FRACTION_TOLERANCE() ) )
MOCK_NARY_CONSTRAINT(close_fraction, 2, (expected, tolerance), (MOCK_FRACTION_TOLERANCE()))
#undef MOCK_PERCENT_TOLERANCE
#undef MOCK_FRACTION_TOLERANCE
@ -106,41 +89,29 @@ namespace detail
# undef near
# define MOCK_NEAR_DEFINED
#endif
MOCK_NARY_CONSTRAINT( near, 2, ( expected, tolerance ),
std::abs( actual - expected ) < tolerance )
MOCK_NARY_CONSTRAINT(near, 2, (expected, tolerance), std::abs(actual - expected) < tolerance)
#ifdef MOCK_NEAR_DEFINED
# pragma pop_macro("near")
#endif
namespace detail
{
namespace detail {
template<typename Expected>
struct equal
{
explicit equal( Expected expected )
: expected_( expected )
{}
explicit equal(Expected expected) : expected_(expected) {}
template<typename Actual>
bool operator()( const Actual& actual,
bool
operator()(const Actual& actual,
typename boost::enable_if<
boost::has_equal_to<
Actual,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
boost::has_equal_to<Actual, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
return actual == boost::unwrap_ref(expected_);
}
template<typename Actual>
bool operator()( const Actual& actual,
bool
operator()(const Actual& actual,
typename boost::disable_if<
boost::has_equal_to<
Actual,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
boost::has_equal_to<Actual, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
return actual && *actual == boost::unwrap_ref(expected_);
}
@ -154,9 +125,7 @@ namespace detail
template<typename Expected>
struct same
{
explicit same( const Expected& expected )
: expected_( detail::addressof( boost::unwrap_ref( expected ) ) )
{}
explicit same(const Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
@ -166,50 +135,36 @@ namespace detail
{
return os << "same( " << mock::format(*s.expected_) << " )";
}
const typename
boost::unwrap_reference< Expected >::type* expected_;
const typename boost::unwrap_reference<Expected>::type* expected_;
};
template<typename Expected>
struct retrieve
{
explicit retrieve( Expected& expected )
: expected_( detail::addressof( boost::unwrap_ref( expected ) ) )
{}
explicit retrieve(Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {}
template<typename Actual>
bool operator()( const Actual& actual,
bool operator()(
const Actual& actual,
typename boost::disable_if<
boost::is_convertible<
const Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
boost::is_convertible<const Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = actual;
return true;
}
template<typename Actual>
bool operator()( BOOST_RV_REF(Actual) actual,
bool operator()(
BOOST_RV_REF(Actual) actual,
typename boost::disable_if<
boost::is_convertible<
const Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
boost::is_convertible<const Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = boost::move(actual);
return true;
}
template<typename Actual>
bool operator()( Actual& actual,
bool
operator()(Actual& actual,
typename boost::enable_if<
boost::is_convertible< Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
boost::is_convertible<Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = detail::addressof(actual);
return true;
@ -218,16 +173,13 @@ namespace detail
{
return s << "retrieve( " << mock::format(*r.expected_) << " )";
}
typename
boost::unwrap_reference< Expected >::type* expected_;
typename boost::unwrap_reference<Expected>::type* expected_;
};
template<typename Expected>
struct assign
{
explicit assign( const Expected& expected )
: expected_( expected )
{}
explicit assign(const Expected& expected) : expected_(expected) {}
template<typename Actual>
bool operator()(Actual& actual) const
{
@ -235,14 +187,10 @@ namespace detail
return true;
}
template<typename Actual>
bool operator()( Actual* actual,
bool
operator()(Actual* actual,
typename boost::enable_if<
boost::is_convertible<
typename
boost::unwrap_reference< Expected >::type,
Actual
>
>::type* = 0 ) const
boost::is_convertible<typename boost::unwrap_reference<Expected>::type, Actual>>::type* = 0) const
{
if(!actual)
return false;
@ -259,13 +207,10 @@ namespace detail
template<typename Expected>
struct contain
{
explicit contain( const Expected& expected )
: expected_( expected )
{}
explicit contain(const Expected& expected) : expected_(expected) {}
bool operator()(const std::string& actual) const
{
return actual.find( boost::unwrap_ref( expected_ ) )
!= std::string::npos;
return actual.find(boost::unwrap_ref(expected_)) != std::string::npos;
}
friend std::ostream& operator<<(std::ostream& s, const contain& n)
{
@ -273,7 +218,7 @@ namespace detail
}
Expected expected_;
};
}
} // namespace detail
template<typename T>
constraint<detail::equal<typename detail::forward_type<T>::type>> equal(BOOST_FWD_REF(T) t)
@ -307,6 +252,6 @@ namespace detail
{
return constraint<T>(t);
}
} // mock
} // namespace mock
#endif // MOCK_CONSTRAINTS_HPP_INCLUDED

82
include/turtle/detail/action.hpp
View file

@ -10,19 +10,16 @@
#define MOCK_ACTION_HPP_INCLUDED
#include "../config.hpp"
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/move/move.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/move/move.hpp>
#include <boost/noncopyable.hpp>
#include <boost/ref.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename Result, typename Signature>
class action_base
{
@ -36,18 +33,9 @@ namespace detail
#endif
public:
const functor_type& functor() const
{
return f_;
}
bool valid() const
{
return f_ || a_;
}
Result trigger() const
{
return a_();
}
const functor_type& functor() const { return f_; }
bool valid() const { return f_ || a_; }
Result trigger() const { return a_(); }
void calls(const functor_type& f)
{
@ -63,10 +51,7 @@ namespace detail
}
protected:
void set( const action_type& a )
{
a_ = a;
}
void set(const action_type& a) { a_ = a; }
template<typename Y>
void set(const boost::reference_wrapper<Y>& r)
{
@ -108,9 +93,7 @@ namespace detail
void moves(BOOST_RV_REF(Value) v)
{
this->set(
boost::bind(
&move< typename boost::remove_reference< Value >::type >,
boost::ref( store( boost::move( v ) ) ) ) );
boost::bind(&move<typename boost::remove_reference<Value>::type>, boost::ref(store(boost::move(v)))));
}
private:
@ -121,28 +104,17 @@ namespace detail
}
struct value : boost::noncopyable
{
virtual ~value()
{}
virtual ~value() {}
};
template<typename T>
struct value_imp : value
{
typedef
typename boost::remove_const<
typename boost::remove_reference<
T
>::type
>::type value_type;
typedef typename boost::remove_const<typename boost::remove_reference<T>::type>::type value_type;
value_imp( BOOST_RV_REF(value_type) t )
: t_( boost::move( t ) )
{}
value_imp( const value_type& t )
: t_( t )
{}
value_imp(BOOST_RV_REF(value_type) t) : t_(boost::move(t)) {}
value_imp(const value_type& t) : t_(t) {}
template<typename Y>
value_imp( Y* y )
: t_( y )
value_imp(Y* y) : t_(y)
{}
value_type t_;
};
@ -173,26 +145,19 @@ namespace detail
class action<void, Signature> : public action_base<void, Signature>
{
public:
action()
{
this->set( boost::bind( &do_nothing ) );
}
action() { this->set(boost::bind(&do_nothing)); }
private:
static void do_nothing()
{}
static void do_nothing() {}
};
#ifdef MOCK_AUTO_PTR
template<typename Result, typename Signature>
class action< std::auto_ptr< Result >, Signature >
: public action_base< std::auto_ptr< Result >, Signature >
class action<std::auto_ptr<Result>, Signature> : public action_base<std::auto_ptr<Result>, Signature>
{
public:
action()
{}
action( const action& rhs )
: v_( rhs.v_.release() )
action() {}
action(const action& rhs) : v_(rhs.v_.release())
{
if(v_.get())
returns(boost::ref(v_));
@ -220,7 +185,6 @@ namespace detail
mutable std::auto_ptr<Result> v_;
};
#endif // MOCK_AUTO_PTR
}
} // mock
}} // namespace mock::detail
#endif // MOCK_ACTION_HPP_INCLUDED

18
include/turtle/detail/addressof.hpp
View file

@ -12,25 +12,15 @@
#include "../config.hpp"
#include <boost/utility/addressof.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
using boost::addressof;
#ifdef MOCK_NULLPTR
inline const std::nullptr_t* addressof( const std::nullptr_t& p )
{
return &p;
}
inline std::nullptr_t* addressof( std::nullptr_t& p )
{
return &p;
}
inline const std::nullptr_t* addressof(const std::nullptr_t& p) { return &p; }
inline std::nullptr_t* addressof(std::nullptr_t& p) { return &p; }
#endif
}
} // mock
}} // namespace mock::detail
#endif // MOCK_ADDRESSOF_HPP_INCLUDED

21
include/turtle/detail/child.hpp
View file

@ -10,25 +10,18 @@
#define MOCK_CHILD_HPP_INCLUDED
#include "../config.hpp"
#include "type_name.hpp"
#include "parent.hpp"
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include "type_name.hpp"
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class child
{
public:
child()
: parent_( 0 )
{}
void update( parent& p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
child() : parent_(0) {}
void update(parent& p, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
if(instance != "?." || name_.empty())
@ -42,11 +35,11 @@ namespace detail
s << *c.parent_;
return s << c.name_;
}
private:
const parent* parent_;
boost::unit_test::const_string name_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_CHILD_HPP_INCLUDED

17
include/turtle/detail/context.hpp
View file

@ -16,10 +16,7 @@
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class verifiable;
class context : boost::noncopyable
@ -28,17 +25,13 @@ namespace detail
context() {}
virtual ~context() {}
virtual void add( const void* p, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name ) = 0;
virtual void add(const void* p, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name) = 0;
virtual void add(verifiable& v) = 0;
virtual void remove(verifiable& v) = 0;
virtual void serialize( std::ostream& s,
const verifiable& v ) const = 0;
virtual void serialize(std::ostream& s, const verifiable& v) const = 0;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_CONTEXT_HPP_INCLUDED

208
include/turtle/detail/expectation_template.hpp
View file

@ -8,115 +8,84 @@
#include "matcher_base_template.hpp"
#define MOCK_EXPECTATION_INITIALIZE(z, n, d) \
BOOST_PP_COMMA_IF(n) c##n##_( c##n )
#define MOCK_EXPECTATION_INITIALIZE(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_(c##n)
#define MOCK_EXPECTATION_MEMBER(z, n, d) \
matcher< T##n, Constraint_##n > c##n##_;
#define MOCK_EXPECTATION_MEMBER(z, n, d) matcher<T##n, Constraint_##n> c##n##_;
#define MOCK_EXPECTATION_IS_VALID(z, n, d) \
BOOST_PP_IF(n, &&, ) c##n##_(mock::detail::move_if_not_lvalue_reference<T##n>(a##n))
#define MOCK_EXPECTATION_SERIALIZE(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) c##n##_
#define MOCK_EXPECTATION_SERIALIZE(z, n, d) BOOST_PP_IF(n, << ", " <<, ) c##n##_
#define MOCK_EXPECTATION_SERIALIZE_ANY(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) "any"
#define MOCK_EXPECTATION_SERIALIZE_ANY(z, n, d) BOOST_PP_IF(n, << ", " <<, ) "any"
#define MOCK_EXPECTATION_PARAM(z, n, Args) \
mock::detail::move_if_not_lvalue_reference< T##n >( a##n )
#define MOCK_EXPECTATION_PARAM(z, n, Args) mock::detail::move_if_not_lvalue_reference<T##n>(a##n)
#define MOCK_REF_ARG(z, n, d) \
typename ref_arg< T##n >::type a##n
#define MOCK_REF_ARG(z, n, d) typename ref_arg<T##n>::type a##n
#define MOCK_REF_ARG_T(z, n, d) \
typename ref_arg< T##n >::type
#define MOCK_REF_ARG_T(z, n, d) typename ref_arg<T##n>::type
namespace mock
{
namespace detail
{
template< typename Signature > class default_matcher;
namespace mock { namespace detail {
template<typename Signature>
class default_matcher;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class default_matcher< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _) )
{
return true;
}
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _)) { return true; }
virtual void serialize(std::ostream& s) const
{
s << "" BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_SERIALIZE_ANY, _);
s << "" BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_SERIALIZE_ANY, _);
}
};
#ifndef MOCK_NUM_ARGS_0
template< typename Constraint, typename Signature > class single_matcher;
template<typename Constraint, typename Signature>
class single_matcher;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_),
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)
>
class single_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ),
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_), BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class single_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_)),
void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
single_matcher(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
: BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_INITIALIZE, _)
single_matcher(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
: BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_INITIALIZE, _)
{}
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) )
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _))
{
return BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_IS_VALID, _);
return BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_IS_VALID, _);
}
virtual void serialize(std::ostream& s) const
{
s << BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_SERIALIZE, _);
s << BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_SERIALIZE, _);
}
private:
BOOST_PP_REPEAT(
MOCK_NUM_ARGS, MOCK_EXPECTATION_MEMBER, _)
BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_MEMBER, _)
};
template< typename F, typename Signature > class multi_matcher;
template<typename F, typename Signature>
class multi_matcher;
template< typename F,
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class multi_matcher< F, void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<typename F, BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class multi_matcher<F, void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
multi_matcher( const F& f )
: f_( f )
{}
multi_matcher(const F& f) : f_(f) {}
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) )
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _))
{
return f_(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _));
}
virtual void serialize( std::ostream& s ) const
{
s << mock::format( f_ );
}
virtual void serialize(std::ostream& s) const { s << mock::format(f_); }
private:
F f_;
@ -124,72 +93,47 @@ namespace detail
#endif
template< typename Signature > class expectation;
template<typename Signature>
class expectation;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
class expectation< R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) >
: public action< R, R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class expectation<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public action<R, R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
expectation()
: invocation_( boost::make_shared< unlimited >() )
, matcher_(
boost::make_shared<
default_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> () )
, file_( "unknown location" )
, line_( 0 )
: invocation_(boost::make_shared<unlimited>()),
matcher_(boost::make_shared<default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>()),
file_("unknown location"), line_(0)
{}
expectation(const char* file, int line)
: invocation_( boost::make_shared< unlimited >() )
, matcher_(
boost::make_shared<
default_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> () )
, file_( file )
, line_( line )
: invocation_(boost::make_shared<unlimited>()),
matcher_(boost::make_shared<default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>()),
file_(file), line_(line)
{}
~expectation()
{
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
(*it)->remove(this);
}
void invoke( const boost::shared_ptr< invocation >& i )
{
invocation_ = i;
}
void invoke(const boost::shared_ptr<invocation>& i) { invocation_ = i; }
#ifndef MOCK_NUM_ARGS_0
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)
>
expectation& with(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)>
expectation& with(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
{
matcher_.reset(
new single_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ),
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) ) );
new single_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_)),
void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c)));
return *this;
}
# if MOCK_NUM_ARGS > 1
template<typename Constraint>
expectation& with(const Constraint& c)
{
matcher_.reset(
new multi_matcher<
Constraint,
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>( c ) );
matcher_.reset(new multi_matcher<Constraint, void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>(c));
return *this;
}
# endif
@ -201,45 +145,30 @@ namespace detail
sequences_.push_back(s.impl_);
}
bool verify() const
{
return invocation_->verify();
}
bool verify() const { return invocation_->verify(); }
bool is_valid(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) const
bool is_valid(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _)) const
{
return !invocation_->exhausted()
&& (*matcher_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _) );
return !invocation_->exhausted() && (*matcher_)(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _));
}
bool invoke() const
{
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
if(!(*it)->is_valid(this))
return false;
bool result = invocation_->invoke();
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
(*it)->invalidate(this);
return result;
}
const char* file() const
{
return file_;
}
int line() const
{
return line_;
}
const char* file() const { return file_; }
int line() const { return line_; }
friend std::ostream& operator<<(
std::ostream& s, const expectation& e )
friend std::ostream& operator<<(std::ostream& s, const expectation& e)
{
return s << ( e.invocation_->exhausted() ? 'v' : '.' )
<< ' ' << *e.invocation_
return s << (e.invocation_->exhausted() ? 'v' : '.') << ' ' << *e.invocation_
#ifndef MOCK_NUM_ARGS_0
<< ".with( " << *e.matcher_ << " )"
#endif
@ -247,23 +176,16 @@ namespace detail
}
private:
typedef std::vector<
boost::shared_ptr< sequence_impl >
> sequences_type;
typedef std::vector<boost::shared_ptr<sequence_impl>> sequences_type;
typedef sequences_type::const_iterator sequences_cit;
boost::shared_ptr<invocation> invocation_;
boost::shared_ptr<
matcher_base<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> matcher_;
boost::shared_ptr<matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>> matcher_;
sequences_type sequences_;
const char* file_;
int line_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_EXPECTATION_INITIALIZE
#undef MOCK_EXPECTATION_MEMBER

17
include/turtle/detail/formatter.hpp
View file

@ -13,20 +13,12 @@
#include "../stream.hpp"
#include "addressof.hpp"
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename T>
struct formatter
{
explicit formatter( const T& t )
: t_( detail::addressof( t ) )
{}
void serialize( stream& s ) const
{
detail::serialize( s, *t_ );
}
explicit formatter(const T& t) : t_(detail::addressof(t)) {}
void serialize(stream& s) const { detail::serialize(s, *t_); }
const T* t_;
};
@ -44,7 +36,6 @@ namespace detail
f.serialize(ss);
return s;
}
}
} // mock
}} // namespace mock::detail
#endif // MOCK_FORMATTER_HPP_INCLUDED

59
include/turtle/detail/function.hpp
View file

@ -10,46 +10,41 @@
#define MOCK_FUNCTION_HPP_INCLUDED
#include "../config.hpp"
#include "../constraints.hpp"
#include "../error.hpp"
#include "../log.hpp"
#include "../constraints.hpp"
#include "../sequence.hpp"
#include "../matcher.hpp"
#include "../sequence.hpp"
#include "action.hpp"
#include "verifiable.hpp"
#include "invocation.hpp"
#include "type_name.hpp"
#include "context.hpp"
#include "mutex.hpp"
#include "invocation.hpp"
#include "move_helper.hpp"
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include "mutex.hpp"
#include "type_name.hpp"
#include "verifiable.hpp"
#include <boost/call_traits.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/make_shared.hpp>
#include <boost/move/move.hpp>
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/comparison/greater.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/test/utils/lazy_ostream.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/call_traits.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <boost/move/move.hpp>
#include <boost/optional.hpp>
#include <list>
#include <ostream>
#include <vector>
#include <list>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename R, typename E>
struct wrapper_base
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
template<typename T>
void returns(T t)
@ -62,23 +57,16 @@ namespace detail
template<typename E>
struct wrapper_base<void, E>
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
E* e_;
};
template<typename R, typename E>
struct wrapper_base<R*, E>
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
void returns( R* r )
{
e_->returns( r );
}
void returns(R* r) { e_->returns(r); }
template<typename Y>
void returns(const boost::reference_wrapper<Y>& r)
{
@ -97,8 +85,7 @@ namespace detail
return std::uncaught_exception() ? 1 : 0;
#endif
}
}
} // mock
}} // namespace mock::detail
#define MOCK_NUM_ARGS 0
#define MOCK_NUM_ARGS_0

143
include/turtle/detail/function_impl_template.hpp
View file

@ -12,53 +12,37 @@
# error no error policy has been set
#endif
#define MOCK_FUNCTION_FORMAT(z, n, N) \
<< ' ' << mock::format( t##n ) \
<< BOOST_PP_IF(BOOST_PP_EQUAL(N,n), ' ', ',')
#define MOCK_FUNCTION_FORMAT(z, n, N) << ' ' << mock::format(t##n) << BOOST_PP_IF(BOOST_PP_EQUAL(N, n), ' ', ',')
#define MOCK_FUNCTION_CONTEXT \
boost::unit_test::lazy_ostream::instance() \
<< lazy_context( this ) \
<< '(' BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_FUNCTION_FORMAT, \
BOOST_PP_DEC(MOCK_NUM_ARGS)) \
<< ')' \
<< lazy_expectations( this )
<< lazy_context(this) << '(' BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_FUNCTION_FORMAT, BOOST_PP_DEC(MOCK_NUM_ARGS)) \
<< ')' << lazy_expectations(this)
#define MOCK_MOVE(z, n, d) \
mock::detail::move_if_not_lvalue_reference< T##n >( t##n )
#define MOCK_MOVE(z, n, d) mock::detail::move_if_not_lvalue_reference<T##n>(t##n)
namespace mock
{
namespace detail
{
template< typename Signature > class function_impl;
namespace mock { namespace detail {
template<typename Signature>
class function_impl;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
class function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public verifiable, public boost::enable_shared_from_this<
function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )> >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public verifiable,
public boost::enable_shared_from_this<function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>
{
public:
typedef safe_error<R, MOCK_ERROR_POLICY<R>> error_type;
public:
function_impl()
: context_( 0 )
, valid_( true )
, exceptions_( exceptions() )
, mutex_( boost::make_shared< mutex >() )
{}
function_impl() : context_(0), valid_(true), exceptions_(exceptions()), mutex_(boost::make_shared<mutex>()) {}
virtual ~function_impl()
{
if(valid_ && exceptions_ >= exceptions())
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(!it->verify())
error_type::fail("untriggered expectation",
boost::unit_test::lazy_ostream::instance()
<< lazy_context( this )
<< lazy_expectations( this ),
<< lazy_context(this) << lazy_expectations(this),
it->file(), it->line());
if(context_)
context_->remove(*this);
@ -67,15 +51,13 @@ namespace detail
virtual bool verify() const
{
lock _(mutex_);
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(!it->verify())
{
valid_ = false;
error_type::fail("verification failed",
boost::unit_test::lazy_ostream::instance()
<< lazy_context( this )
<< lazy_expectations( this ),
<< lazy_context(this) << lazy_expectations(this),
it->file(), it->line());
}
return valid_;
@ -85,15 +67,12 @@ namespace detail
{
lock _(mutex_);
valid_ = true;
boost::shared_ptr< function_impl > guard =
this->shared_from_this();
boost::shared_ptr<function_impl> guard = this->shared_from_this();
expectations_.clear();
}
private:
typedef expectation<
R( BOOST_PP_ENUM_PARAMS( MOCK_NUM_ARGS, T ) )
> expectation_type;
typedef expectation<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> expectation_type;
class wrapper : public wrapper_base<R, expectation_type>
{
@ -102,14 +81,8 @@ namespace detail
BOOST_MOVABLE_BUT_NOT_COPYABLE(wrapper)
public:
wrapper( const boost::shared_ptr< mutex >& m, expectation_type& e )
: base_type( e )
, lock_( m )
{}
wrapper( BOOST_RV_REF( wrapper ) x )
: base_type( x )
, lock_( boost::move( x.lock_) )
{}
wrapper(const boost::shared_ptr<mutex>& m, expectation_type& e) : base_type(e), lock_(m) {}
wrapper(BOOST_RV_REF(wrapper) x) : base_type(x), lock_(boost::move(x.lock_)) {}
wrapper& operator=(BOOST_RV_REF(wrapper) x)
{
static_cast<base_type&>(*this) = x;
@ -128,38 +101,30 @@ namespace detail
}
wrapper& exactly(std::size_t count)
{
this->e_->invoke(
boost::make_shared< detail::exactly >( count ) );
this->e_->invoke(boost::make_shared<detail::exactly>(count));
return *this;
}
wrapper& at_least(std::size_t min)
{
this->e_->invoke(
boost::make_shared< detail::at_least >( min ) );
this->e_->invoke(boost::make_shared<detail::at_least>(min));
return *this;
}
wrapper& at_most(std::size_t max)
{
this->e_->invoke(
boost::make_shared< detail::at_most >( max ) );
this->e_->invoke(boost::make_shared<detail::at_most>(max));
return *this;
}
wrapper& between(std::size_t min, std::size_t max)
{
this->e_->invoke(
boost::make_shared< detail::between >( min, max ) );
this->e_->invoke(boost::make_shared<detail::between>(min, max));
return *this;
}
#ifndef MOCK_NUM_ARGS_0
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)
>
wrapper& with(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)>
wrapper& with(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
{
this->e_->with(
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) );
this->e_->with(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c));
return *this;
}
@ -173,8 +138,7 @@ namespace detail
# endif
#endif
#define MOCK_FUNCTION_IN_ADD(z, n, d) \
this->e_->add( s##n );
#define MOCK_FUNCTION_IN_ADD(z, n, d) this->e_->add(s##n);
#define MOCK_FUNCTION_IN(z, n, d) \
wrapper& in(BOOST_PP_ENUM_PARAMS(n, sequence& s)) \
@ -183,8 +147,7 @@ namespace detail
return *this; \
}
BOOST_PP_REPEAT(MOCK_MAX_SEQUENCES,
MOCK_FUNCTION_IN, _)
BOOST_PP_REPEAT(MOCK_MAX_SEQUENCES, MOCK_FUNCTION_IN, _)
#undef MOCK_FUNCTION_IN
#undef MOCK_FUNCTION_IN_ADD
@ -226,43 +189,34 @@ namespace detail
return wrapper(mutex_, expectations_.back());
}
R operator()(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const
R operator()(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t)) const
{
lock _(mutex_);
valid_ = false;
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
if( it->is_valid(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ) )
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(it->is_valid(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _)))
{
if(!it->invoke())
{
error_type::fail( "sequence failed",
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
error_type::fail("sequence failed", MOCK_FUNCTION_CONTEXT, it->file(), it->line());
return error_type::abort();
}
if(!it->valid())
{
error_type::fail( "missing action",
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
error_type::fail("missing action", MOCK_FUNCTION_CONTEXT, it->file(), it->line());
return error_type::abort();
}
valid_ = true;
error_type::call(
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
error_type::call(MOCK_FUNCTION_CONTEXT, it->file(), it->line());
if(it->functor())
return it->functor()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) );
return it->functor()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _));
return it->trigger();
}
error_type::fail("unexpected call", MOCK_FUNCTION_CONTEXT);
return error_type::abort();
}
void add( context& c, const void* p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
void add(context& c, const void* p, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
lock _(mutex_);
@ -272,8 +226,7 @@ namespace detail
context_ = &c;
}
friend std::ostream& operator<<(
std::ostream& s, const function_impl& impl )
friend std::ostream& operator<<(std::ostream& s, const function_impl& impl)
{
lock _(impl.mutex_);
return s << lazy_context(&impl) << lazy_expectations(&impl);
@ -281,11 +234,8 @@ namespace detail
struct lazy_context
{
lazy_context( const function_impl* impl )
: impl_( impl )
{}
friend std::ostream& operator<<(
std::ostream& s, const lazy_context& c )
lazy_context(const function_impl* impl) : impl_(impl) {}
friend std::ostream& operator<<(std::ostream& s, const lazy_context& c)
{
if(c.impl_->context_)
c.impl_->context_->serialize(s, *c.impl_);
@ -298,14 +248,10 @@ namespace detail
struct lazy_expectations
{
lazy_expectations( const function_impl* impl )
: impl_( impl )
{}
friend std::ostream& operator<<(
std::ostream& s, const lazy_expectations& e )
lazy_expectations(const function_impl* impl) : impl_(impl) {}
friend std::ostream& operator<<(std::ostream& s, const lazy_expectations& e)
{
for( expectations_cit it = e.impl_->expectations_.begin();
it != e.impl_->expectations_.end(); ++it )
for(expectations_cit it = e.impl_->expectations_.begin(); it != e.impl_->expectations_.end(); ++it)
s << std::endl << *it;
return s;
}
@ -321,8 +267,7 @@ namespace detail
const int exceptions_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_FUNCTION_FORMAT
#undef MOCK_FUNCTION_CONTEXT

57
include/turtle/detail/function_template.hpp
View file

@ -8,17 +8,13 @@
#include "function_impl_template.hpp"
#define MOCK_MOVE(z, n, d) \
mock::detail::move_if_not_lvalue_reference< T##n >( t##n )
#define MOCK_MOVE(z, n, d) mock::detail::move_if_not_lvalue_reference<T##n>(t##n)
namespace mock
{
namespace detail
{
template< typename Signature > class function;
namespace mock { namespace detail {
template<typename Signature>
class function;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class function<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
@ -31,30 +27,20 @@ namespace detail
};
private:
typedef function_impl<
R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
> impl_type;
typedef function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> impl_type;
typedef typename impl_type::wrapper_type expectation_type;
typedef typename impl_type::error_type error_type;
public:
function()
: impl_( boost::make_shared< impl_type >() )
{}
function() : impl_(boost::make_shared<impl_type>()) {}
bool verify() const
{
return impl_->verify();
}
bool verify() const { return impl_->verify(); }
bool verify(const char* file, int line) const
{
error_type::pass(file, line);
return impl_->verify();
}
void reset()
{
impl_->reset();
}
void reset() { impl_->reset(); }
void reset(const char* file, int line)
{
error_type::pass(file, line);
@ -66,33 +52,23 @@ namespace detail
error_type::pass(file, line);
return impl_->expect(file, line);
}
expectation_type expect()
{
return impl_->expect();
}
expectation_type expect() { return impl_->expect(); }
R operator()(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const
R operator()(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t)) const
{
return (*impl_)(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _));
}
friend std::ostream& operator<<( std::ostream& s, const function& f )
{
return s << *f.impl_;
}
friend std::ostream& operator<<(std::ostream& s, const function& f) { return s << *f.impl_; }
function& operator()( context& c,
boost::unit_test::const_string instance )
function& operator()(context& c, boost::unit_test::const_string instance)
{
impl_->add(c, impl_.get(), instance, boost::none, "");
return *this;
}
void configure( context& c, const void* p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name ) const
void configure(context& c, const void* p, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name) const
{
impl_->add(c, p, instance, type, name);
}
@ -100,7 +76,6 @@ namespace detail
private:
boost::shared_ptr<impl_type> impl_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_MOVE

15
include/turtle/detail/functor.hpp
View file

@ -14,13 +14,8 @@
#include "mutex.hpp"
#include "singleton.hpp"
namespace mock
{
namespace detail
{
class functor_mutex_t :
public singleton< functor_mutex_t >,
public mutex
namespace mock { namespace detail {
class functor_mutex_t : public singleton<functor_mutex_t>, public mutex
{
MOCK_SINGLETON_CONS(functor_mutex_t);
};
@ -38,15 +33,13 @@ namespace detail
*this = *f;
f = 0;
functor_mutex.unlock();
}
else
} else
{
functor_mutex.lock();
f = this;
}
}
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_FUNCTOR_HPP_INCLUDED

28
include/turtle/detail/group.hpp
View file

@ -11,33 +11,24 @@
#include "../config.hpp"
#include "verifiable.hpp"
#include <functional>
#include <algorithm>
#include <functional>
#include <vector>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class group
{
public:
void add( verifiable& v )
{
verifiables_.push_back( &v );
}
void add(verifiable& v) { verifiables_.push_back(&v); }
void remove(verifiable& v)
{
verifiables_.erase(
std::remove( verifiables_.begin(), verifiables_.end(), &v ),
verifiables_.end() );
verifiables_.erase(std::remove(verifiables_.begin(), verifiables_.end(), &v), verifiables_.end());
}
bool verify() const
{
bool valid = true;
for( verifiables_cit it = verifiables_.begin();
it != verifiables_.end(); ++it )
for(verifiables_cit it = verifiables_.begin(); it != verifiables_.end(); ++it)
if(!(*it)->verify())
valid = false;
return valid;
@ -45,10 +36,8 @@ namespace detail
void reset()
{
const verifiables_t verifiables = verifiables_;
for( verifiables_cit it = verifiables.begin();
it != verifiables.end(); ++it )
if( std::find( verifiables_.begin(), verifiables_.end(), *it )
!= verifiables_.end() )
for(verifiables_cit it = verifiables.begin(); it != verifiables.end(); ++it)
if(std::find(verifiables_.begin(), verifiables_.end(), *it) != verifiables_.end())
(*it)->reset();
}
@ -58,7 +47,6 @@ namespace detail
verifiables_t verifiables_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_GROUP_HPP_INCLUDED

74
include/turtle/detail/invocation.hpp
View file

@ -11,14 +11,11 @@
#include "../config.hpp"
#include <boost/noncopyable.hpp>
#include <stdexcept>
#include <ostream>
#include <limits>
#include <ostream>
#include <stdexcept>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class invocation : private boost::noncopyable
{
public:
@ -30,10 +27,7 @@ namespace detail
virtual bool exhausted() const = 0;
friend std::ostream& operator<<( std::ostream& s, const invocation& i )
{
return i.serialize( s );
}
friend std::ostream& operator<<(std::ostream& s, const invocation& i) { return i.serialize(s); }
private:
virtual std::ostream& serialize(std::ostream& s) const = 0;
@ -42,10 +36,7 @@ namespace detail
class between : public invocation
{
public:
between( std::size_t min, std::size_t max )
: min_( min )
, max_( max )
, count_( 0 )
between(std::size_t min, std::size_t max) : min_(min), max_(max), count_(0)
{
if(min > max)
throw std::invalid_argument("'min' > 'max'");
@ -59,15 +50,9 @@ namespace detail
return true;
}
virtual bool exhausted() const
{
return count_ >= max_;
}
virtual bool exhausted() const { return count_ >= max_; }
virtual bool verify() const
{
return min_ <= count_ && count_ <= max_;
}
virtual bool verify() const { return min_ <= count_ && count_ <= max_; }
protected:
const std::size_t min_, max_;
@ -76,17 +61,14 @@ namespace detail
private:
virtual std::ostream& serialize(std::ostream& s) const
{
return s << "between( " << count_
<< "/[" << min_ << ',' << max_ << "] )";
return s << "between( " << count_ << "/[" << min_ << ',' << max_ << "] )";
}
};
class exactly : public between
{
public:
explicit exactly( std::size_t count )
: between( count, count )
{}
explicit exactly(std::size_t count) : between(count, count) {}
private:
virtual std::ostream& serialize(std::ostream& s) const
@ -98,37 +80,25 @@ namespace detail
class never : public exactly
{
public:
never()
: exactly( 0 )
{}
never() : exactly(0) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "never()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "never()"; }
};
class once : public exactly
{
public:
once()
: exactly( 1 )
{}
once() : exactly(1) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "once()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "once()"; }
};
class at_least : public between
{
public:
explicit at_least( std::size_t min )
: between( min, (std::numeric_limits< std::size_t >::max)() )
{}
explicit at_least(std::size_t min) : between(min, (std::numeric_limits<std::size_t>::max)()) {}
private:
virtual std::ostream& serialize(std::ostream& s) const
@ -140,9 +110,7 @@ namespace detail
class at_most : public between
{
public:
explicit at_most( std::size_t max )
: between( 0, max )
{}
explicit at_most(std::size_t max) : between(0, max) {}
private:
virtual std::ostream& serialize(std::ostream& s) const
@ -154,17 +122,11 @@ namespace detail
class unlimited : public at_least
{
public:
unlimited()
: at_least( 0 )
{}
unlimited() : at_least(0) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "unlimited()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "unlimited()"; }
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_INVOCATION_HPP_INCLUDED

28
include/turtle/detail/is_functor.hpp
View file

@ -11,15 +11,12 @@
#include "../config.hpp"
#include <boost/function_types/is_callable_builtin.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/utility/declval.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/utility/declval.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
@ -33,30 +30,23 @@ namespace detail
typedef boost::type_traits::no_type no_type;
template<typename T>
static yes_type check(
decltype( boost::declval< T >()( boost::declval< P >() ) )* );
static yes_type check(decltype(boost::declval<T>()(boost::declval<P>()))*);
template<typename T>
static no_type check(...);
typedef boost::mpl::bool_<
sizeof( check< F >( 0 ) ) == sizeof( yes_type ) > type;
typedef boost::mpl::bool_<sizeof(check<F>(0)) == sizeof(yes_type)> type;
};
#endif // MOCK_DECLTYPE
template<typename T, typename P>
struct is_functor
: boost::mpl::or_<
boost::function_types::is_callable_builtin< T >,
struct is_functor :
boost::mpl::or_<boost::function_types::is_callable_builtin<T>,
#ifdef MOCK_DECLTYPE
is_callable<T, P>,
#endif
has_result_type< T >,
has_result< T >,
has_sig< T >
>
has_result_type<T>, has_result<T>, has_sig<T>>
{};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_IS_FUNCTOR_HPP_INCLUDED

26
include/turtle/detail/matcher_base_template.hpp
View file

@ -6,28 +6,21 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#define MOCK_REF_ARG(z, n, d) \
typename ref_arg< T##n >::type
#define MOCK_REF_ARG(z, n, d) typename ref_arg<T##n>::type
namespace mock
{
namespace detail
{
template< typename Signature > class matcher_base;
namespace mock { namespace detail {
template<typename Signature>
class matcher_base;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: boost::noncopyable
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> : boost::noncopyable
{
public:
virtual ~matcher_base() {}
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) = 0;
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _)) = 0;
friend std::ostream& operator<<(
std::ostream& s, const matcher_base& m )
friend std::ostream& operator<<(std::ostream& s, const matcher_base& m)
{
m.serialize(s);
return s;
@ -36,7 +29,6 @@ namespace detail
private:
virtual void serialize(std::ostream&) const = 0;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_REF_ARG

25
include/turtle/detail/move_helper.hpp
View file

@ -10,17 +10,14 @@
#define MOCK_MOVE_HELPER_HPP_INCLUDED
#include "../config.hpp"
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_rvalue_reference.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
#ifdef MOCK_RVALUE_REFERENCES
template<typename T>
struct forward_type
@ -30,9 +27,7 @@ namespace detail
template<typename T>
struct ref_arg
{
typedef typename boost::conditional<
boost::is_reference< T >::value,
T,
typedef typename boost::conditional<boost::is_reference<T>::value, T,
typename boost::add_rvalue_reference<T>::type>::type type;
};
@ -61,18 +56,16 @@ namespace detail
template<typename T>
struct ref_arg
{
typedef typename boost::conditional<
boost::is_reference< T >::value,
T,
typedef typename boost::conditional<boost::is_reference<T>::value, T,
const typename boost::add_reference<T>::type>::type type;
};
template<typename T>
inline typename boost::remove_reference< T >::type& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t)
inline typename boost::remove_reference<T>::type&
move_if_not_lvalue_reference(typename boost::remove_reference<T>::type& t)
{
return t;
}
#endif
}
}
}} // namespace mock::detail
#endif // MOCK_MOVE_HELPER_HPP_INCLUDED

68
include/turtle/detail/mutex.hpp
View file

@ -20,14 +20,11 @@
# ifdef MOCK_HDR_MUTEX
# include <mutex>
# else
#include <boost/thread/recursive_mutex.hpp>
# include <boost/thread/lock_guard.hpp>
# include <boost/thread/recursive_mutex.hpp>
# endif
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
# ifdef MOCK_HDR_MUTEX
typedef std::recursive_mutex mutex;
typedef std::lock_guard<mutex> scoped_lock;
@ -42,18 +39,13 @@ namespace detail
BOOST_MOVABLE_BUT_NOT_COPYABLE(lock)
public:
lock( const boost::shared_ptr< mutex >& m )
: m_( m )
{
m_->lock();
}
lock(const boost::shared_ptr<mutex>& m) : m_(m) { m_->lock(); }
~lock()
{
if(m_)
m_->unlock();
}
lock( BOOST_RV_REF( lock ) x )
: m_( x.m_ )
lock(BOOST_RV_REF(lock) x) : m_(x.m_)
{
// Explicit reset to avoid unlock in destructor
x.m_.reset();
@ -68,30 +60,22 @@ namespace detail
private:
boost::shared_ptr<mutex> m_;
};
}
} // mock
}} // namespace mock::detail
#else // MOCK_THREAD_SAFE
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
struct mutex : boost::noncopyable
{
void lock()
{}
void unlock()
{}
void lock() {}
void unlock() {}
};
// Dummy lock classes.
// Constructor + Destructor make it RAII classes for compilers and avoid unused variable warnings
struct scoped_lock : boost::noncopyable
{
scoped_lock( mutex& )
{}
~scoped_lock()
{}
scoped_lock(mutex&) {}
~scoped_lock() {}
};
class lock : boost::noncopyable
{
@ -99,28 +83,17 @@ namespace detail
BOOST_MOVABLE_BUT_NOT_COPYABLE(lock)
public:
lock( const boost::shared_ptr< mutex >& )
{}
~lock()
{}
lock( BOOST_RV_REF( lock ) )
{}
lock& operator=( BOOST_RV_REF( lock ) )
{
return *this;
}
lock(const boost::shared_ptr<mutex>&) {}
~lock() {}
lock(BOOST_RV_REF(lock)) {}
lock& operator=(BOOST_RV_REF(lock)) { return *this; }
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_THREAD_SAFE
namespace mock
{
namespace detail
{
class error_mutex_t : public singleton< error_mutex_t >,
public mutex
namespace mock { namespace detail {
class error_mutex_t : public singleton<error_mutex_t>, public mutex
{
MOCK_SINGLETON_CONS(error_mutex_t);
};
@ -139,8 +112,8 @@ namespace detail
return Error::abort();
}
template<typename Context>
static void fail( const char* message, const Context& context,
const char* file = "unknown location", int line = 0 )
static void fail(const char* message, const Context& context, const char* file = "unknown location",
int line = 0)
{
scoped_lock _(error_mutex);
Error::fail(message, context, file, line);
@ -160,7 +133,6 @@ namespace detail
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
}
} // mock
}} // namespace mock::detail
#endif // MOCK_MUTEX_HPP_INCLUDED

31
include/turtle/detail/object_impl.hpp
View file

@ -10,33 +10,25 @@
#define MOCK_OBJECT_IMPL_HPP_INCLUDED
#include "../config.hpp"
#include "root.hpp"
#include "parent.hpp"
#include "type_name.hpp"
#include "context.hpp"
#include "child.hpp"
#include "context.hpp"
#include "mutex.hpp"
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include "parent.hpp"
#include "root.hpp"
#include "type_name.hpp"
#include <boost/enable_shared_from_this.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
namespace mock
{
namespace detail
{
class object_impl : public context, public verifiable,
public boost::enable_shared_from_this< object_impl >
namespace mock { namespace detail {
class object_impl : public context, public verifiable, public boost::enable_shared_from_this<object_impl>
{
public:
object_impl()
: mutex_( boost::make_shared< mutex >() )
{}
object_impl() : mutex_(boost::make_shared<mutex>()) {}
virtual void add( const void* /*p*/, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
virtual void add(const void* /*p*/, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name)
{
lock _(mutex_);
if(children_.empty())
@ -88,7 +80,6 @@ namespace detail
children_t children_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_OBJECT_IMPL_HPP_INCLUDED

17
include/turtle/detail/parameter.hpp
View file

@ -10,25 +10,16 @@
#define MOCK_PARAMETER_HPP_INCLUDED
#include "../config.hpp"
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/function_arity.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/mpl/at.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename Signature, int n>
struct parameter
{
typedef typename
boost::mpl::at_c<
typename
boost::function_types::parameter_types< Signature >,
n
>::type type;
typedef typename boost::mpl::at_c<typename boost::function_types::parameter_types<Signature>, n>::type type;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_PARAMETER_HPP_INCLUDED

20
include/turtle/detail/parent.hpp
View file

@ -11,23 +11,17 @@
#include "../config.hpp"
#include "type_name.hpp"
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class parent
{
public:
parent()
{}
parent( boost::unit_test::const_string instance,
boost::optional< type_name > type )
: instance_( instance )
, type_( type )
parent() {}
parent(boost::unit_test::const_string instance, boost::optional<type_name> type)
: instance_(instance), type_(type)
{}
friend std::ostream& operator<<(std::ostream& s, const parent& p)
{
@ -36,11 +30,11 @@ namespace detail
s << *p.type_ << "::";
return s;
}
private:
boost::unit_test::const_string instance_;
boost::optional<type_name> type_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_PARENT_HPP_INCLUDED

49
include/turtle/detail/root.hpp
View file

@ -10,34 +10,27 @@
#define MOCK_ROOT_HPP_INCLUDED
#include "../config.hpp"
#include "parent.hpp"
#include "group.hpp"
#include "context.hpp"
#include "child.hpp"
#include "context.hpp"
#include "group.hpp"
#include "mutex.hpp"
#include "parent.hpp"
#include "singleton.hpp"
#include <boost/optional.hpp>
#include <ostream>
#include <map>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class root_t : public singleton<root_t>, public context
{
public:
virtual void add( const void* p, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
virtual void add(const void* p, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name)
{
scoped_lock _(mutex_);
children_t::iterator it = children_.lower_bound(&v);
if( it == children_.end() ||
children_.key_comp()( &v, it->first ) )
it = children_.insert( it,
std::make_pair( &v, counter_child( parents_, p ) ) );
if(it == children_.end() || children_.key_comp()(&v, it->first))
it = children_.insert(it, std::make_pair(&v, counter_child(parents_, p)));
it->second.update(instance, type, name);
}
virtual void add(verifiable& v)
@ -75,23 +68,17 @@ namespace detail
}
private:
typedef std::map< const void*,
std::pair< parent, std::size_t > > parents_t;
typedef std::map<const void*, std::pair<parent, std::size_t>> parents_t;
class counter_child
{
public:
counter_child(parents_t& parents, const void* p)
: parents_( &parents )
, it_( parents.insert(
std::make_pair( p, parents_t::mapped_type() ) ).first )
: parents_(&parents), it_(parents.insert(std::make_pair(p, parents_t::mapped_type())).first)
{
++it_->second.second;
}
counter_child( const counter_child& rhs )
: parents_( rhs.parents_ )
, it_( rhs.it_ )
, child_( rhs.child_ )
counter_child(const counter_child& rhs) : parents_(rhs.parents_), it_(rhs.it_), child_(rhs.child_)
{
++it_->second.second;
}
@ -100,17 +87,12 @@ namespace detail
if(--it_->second.second == 0)
parents_->erase(it_);
}
void update( boost::unit_test::const_string instance,
boost::optional< type_name > type,
void update(boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
child_.update(it_->second.first, instance, type, name);
}
friend std::ostream& operator<<( std::ostream& s,
const counter_child& c )
{
return s << c.child_;
}
friend std::ostream& operator<<(std::ostream& s, const counter_child& c) { return s << c.child_; }
private:
counter_child& operator=(const counter_child&);
@ -131,7 +113,6 @@ namespace detail
MOCK_SINGLETON_CONS(root_t);
};
MOCK_SINGLETON_INST(root)
}
} // mock
}} // namespace mock::detail
#endif // MOCK_ROOT_HPP_INCLUDED

23
include/turtle/detail/sequence_impl.hpp
View file

@ -11,21 +11,16 @@
#include "../config.hpp"
#include "mutex.hpp"
#include <boost/noncopyable.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <algorithm>
#include <vector>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class sequence_impl : private boost::noncopyable
{
public:
sequence_impl()
: mutex_( boost::make_shared< mutex >() )
{}
sequence_impl() : mutex_(boost::make_shared<mutex>()) {}
void add(void* e)
{
@ -35,22 +30,19 @@ namespace detail
void remove(void* e)
{
lock _(mutex_);
elements_.erase( std::remove( elements_.begin(),
elements_.end(), e ), elements_.end() );
elements_.erase(std::remove(elements_.begin(), elements_.end(), e), elements_.end());
}
bool is_valid(const void* e) const
{
lock _(mutex_);
return std::find( elements_.begin(), elements_.end(), e )
!= elements_.end();
return std::find(elements_.begin(), elements_.end(), e) != elements_.end();
}
void invalidate(const void* e)
{
lock _(mutex_);
elements_type::iterator it =
std::find( elements_.begin(), elements_.end(), e );
elements_type::iterator it = std::find(elements_.begin(), elements_.end(), e);
if(it != elements_.end())
elements_.erase(elements_.begin(), it);
}
@ -61,7 +53,6 @@ namespace detail
elements_type elements_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_SEQUENCE_IMPL_HPP_INCLUDED

34
include/turtle/detail/signature.hpp
View file

@ -10,33 +10,21 @@
#define MOCK_SIGNATURE_HPP_INCLUDED
#include "../config.hpp"
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/mpl/single_view.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/single_view.hpp>
#define BOOST_TYPEOF_SILENT
#include <boost/typeof/typeof.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename M>
struct signature :
boost::function_types::function_type<
boost::mpl::joint_view<
boost::mpl::single_view<
typename
boost::function_types::result_type< M >::type
>,
typename boost::mpl::pop_front<
typename
boost::function_types::parameter_types< M >
>::type
>
>
boost::function_types::function_type<boost::mpl::joint_view<
boost::mpl::single_view<typename boost::function_types::result_type<M>::type>,
typename boost::mpl::pop_front<typename boost::function_types::parameter_types<M>>::type>>
{};
template<typename T>
@ -50,14 +38,10 @@ namespace detail
// disambiguate
template<typename T>
T& ambiguous_method_requires_to_specify_signature(const T&);
}
} // mock
}} // namespace mock::detail
#define MOCK_SIGNATURE(M) \
mock::detail::signature< \
BOOST_TYPEOF( \
mock::detail::ambiguous_method_requires_to_specify_signature( \
&base_type::M ) ) \
>::type
mock::detail::signature<BOOST_TYPEOF( \
mock::detail::ambiguous_method_requires_to_specify_signature(&base_type::M))>::type
#endif // MOCK_SIGNATURE_HPP_INCLUDED

12
include/turtle/detail/singleton.hpp
View file

@ -11,11 +11,11 @@
#include <boost/config.hpp>
namespace mock {
namespace detail {
namespace mock { namespace detail {
template<typename Derived>
class singleton {
class singleton
{
public:
static Derived& instance()
{
@ -31,8 +31,7 @@ protected:
BOOST_DEFAULTED_FUNCTION(~singleton(), {})
};
} // detail
} // mock
}} // namespace mock::detail
// Add a private ctor to the type to prevent misuse
#define MOCK_SINGLETON_CONS(type) \
@ -40,7 +39,6 @@ private: \
friend class mock::detail::singleton<type>; \
type() {}
#define MOCK_SINGLETON_INST( inst ) \
static BOOST_JOIN( inst, _t )& inst = BOOST_JOIN( inst, _t )::instance();
#define MOCK_SINGLETON_INST(inst) static BOOST_JOIN(inst, _t)& inst = BOOST_JOIN(inst, _t)::instance();
#endif // MOCK_SINGLETON_HPP

28
include/turtle/detail/type_name.hpp
View file

@ -10,10 +10,10 @@
#define MOCK_TYPE_NAME_HPP_INCLUDED
#include "../config.hpp"
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/erase.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/version.hpp>
#if BOOST_VERSION >= 107000
# include <boost/core/typeinfo.hpp>
@ -25,41 +25,34 @@
# define MOCK_TYPEINFO boost::detail::sp_typeinfo
#endif
#include <boost/shared_ptr.hpp>
#include <ostream>
#include <stdexcept>
#include <typeinfo>
#include <ostream>
#ifdef __GNUC__
#include <cxxabi.h>
# include <cstdlib>
# include <cxxabi.h>
#endif
#define MOCK_TYPE_NAME(t) mock::detail::type_name(MOCK_TYPEID(t))
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class type_name
{
public:
explicit type_name( const MOCK_TYPEINFO& info )
: info_( &info )
{}
explicit type_name(const MOCK_TYPEINFO& info) : info_(&info) {}
friend std::ostream& operator<<(std::ostream& s, const type_name& t)
{
t.serialize(s, *t.info_);
return s;
}
private:
void serialize( std::ostream& s,
const MOCK_TYPEINFO& info ) const
void serialize(std::ostream& s, const MOCK_TYPEINFO& info) const
{
const char* name = info.name();
#ifdef __GNUC__
int status = 0;
boost::shared_ptr< char > demangled(
abi::__cxa_demangle( name, 0, 0, &status ),
&std::free );
boost::shared_ptr<char> demangled(abi::__cxa_demangle(name, 0, 0, &status), &std::free);
if(!status && demangled)
serialize(s, demangled.get());
else
@ -119,7 +112,6 @@ namespace detail
const MOCK_TYPEINFO* info_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_TYPE_NAME_HPP_INCLUDED

8
include/turtle/detail/verifiable.hpp
View file

@ -12,10 +12,7 @@
#include "../config.hpp"
#include <boost/noncopyable.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class verifiable : private boost::noncopyable
{
public:
@ -26,7 +23,6 @@ namespace detail
virtual void reset() = 0;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_VERIFIABLE_HPP_INCLUDED

32
include/turtle/error.hpp
View file

@ -12,33 +12,29 @@
#include "config.hpp"
#ifdef MOCK_USE_BOOST_TEST
# include "exception.hpp"
#include <boost/version.hpp>
# include <boost/exception/enable_current_exception.hpp>
# include <boost/test/framework.hpp>
# include <boost/test/test_tools.hpp>
# include <boost/test/unit_test_suite.hpp>
#include <boost/exception/enable_current_exception.hpp>
# include <boost/version.hpp>
namespace mock
{
namespace mock {
template<typename Result>
struct error
{
static Result abort()
{
boost::unit_test::framework::test_unit_aborted(
boost::unit_test::framework::current_test_case() );
boost::unit_test::framework::test_unit_aborted(boost::unit_test::framework::current_test_case());
throw boost::enable_current_exception(exception());
}
static void pass(const char* file, int line)
{
boost::unit_test::unit_test_log.set_checkpoint( file,
static_cast< std::size_t >( line ) );
boost::unit_test::unit_test_log.set_checkpoint(file, static_cast<std::size_t>(line));
}
template<typename Context>
static void fail( const char* message, const Context& context,
const char* file = "unknown location", int line = 0 )
static void fail(const char* message, const Context& context, const char* file = "unknown location", int line = 0)
{
boost::unit_test::framework::assertion_result(
# if BOOST_VERSION < 105900
@ -47,11 +43,8 @@ namespace mock
boost::unit_test::AR_FAILED
# endif
);
boost::unit_test::unit_test_log
<< boost::unit_test::log::begin( file,
static_cast< std::size_t >( line ) )
<< boost::unit_test::log_all_errors
<< message << ": " << context
boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast<std::size_t>(line))
<< boost::unit_test::log_all_errors << message << ": " << context
<< boost::unit_test::log::end();
}
@ -65,15 +58,12 @@ namespace mock
boost::unit_test::AR_PASSED
# endif
);
boost::unit_test::unit_test_log
<< boost::unit_test::log::begin( file,
static_cast< std::size_t >( line ) )
boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast<std::size_t>(line))
<< boost::unit_test::log_successful_tests
<< "mock expectation fulfilled: " << context
<< boost::unit_test::log::end();
<< "mock expectation fulfilled: " << context << boost::unit_test::log::end();
}
};
} // mock
} // namespace mock
#endif // MOCK_USE_BOOST_TEST

5
include/turtle/exception.hpp
View file

@ -13,11 +13,10 @@
#ifdef MOCK_USE_BOOST_TEST
# include <boost/test/execution_monitor.hpp>
namespace mock
{
namespace mock {
struct exception : virtual boost::execution_aborted
{};
} // mock
} // namespace mock
#endif // MOCK_USE_BOOST_TEST

5
include/turtle/format.hpp
View file

@ -12,14 +12,13 @@
#include "config.hpp"
#include "detail/formatter.hpp"
namespace mock
{
namespace mock {
template<typename T>
detail::formatter<T> format(const T& t)
{
return detail::formatter<T>(t);
}
} // mock
} // namespace mock
#endif // MOCK_FORMAT_HPP_INCLUDED

67
include/turtle/log.hpp
View file

@ -10,39 +10,40 @@
#define MOCK_LOG_HPP_INCLUDED
#include "config.hpp"
#include "stream.hpp"
#include "format.hpp"
#include <boost/utility/enable_if.hpp>
#include "stream.hpp"
#include <boost/detail/container_fwd.hpp>
#include <boost/function_types/is_callable_builtin.hpp>
#include <boost/none.hpp>
#include <boost/utility/enable_if.hpp>
#include <memory>
namespace boost
{
template< typename T > class shared_ptr;
template< typename T > class weak_ptr;
template< typename T > class reference_wrapper;
template< typename T > class optional;
namespace boost {
template<typename T>
class shared_ptr;
template<typename T>
class weak_ptr;
template<typename T>
class reference_wrapper;
template<typename T>
class optional;
namespace phoenix
{
template< typename T > struct actor;
namespace phoenix {
template<typename T>
struct actor;
}
namespace lambda
{
template< typename T > class lambda_functor;
}
namespace assign_detail
{
template< typename T > class generic_list;
namespace lambda {
template<typename T>
class lambda_functor;
}
namespace assign_detail {
template<typename T>
class generic_list;
}
} // namespace boost
namespace mock
{
namespace detail
{
namespace mock {
namespace detail {
template<typename T>
void serialize(stream& s, const T& begin, const T& end)
{
@ -51,7 +52,7 @@ namespace detail
s << (it == begin ? "" : ",") << mock::format(*it);
s << ')';
}
}
} // namespace detail
#ifdef MOCK_AUTO_PTR
template<typename T>
@ -64,8 +65,7 @@ namespace detail
template<typename T1, typename T2>
stream& operator<<(stream& s, const std::pair<T1, T2>& p)
{
return s << '(' << mock::format( p.first )
<< ',' << mock::format( p.second ) << ')';
return s << '(' << mock::format(p.first) << ',' << mock::format(p.second) << ')';
}
template<typename T, typename A>
@ -111,8 +111,7 @@ namespace detail
return s;
}
template<typename T>
stream& operator<<( stream& s,
const boost::assign_detail::generic_list< T >& t )
stream& operator<<(stream& s, const boost::assign_detail::generic_list<T>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
@ -181,24 +180,16 @@ namespace detail
#endif
template<typename T>
typename boost::enable_if<
boost::function_types::is_callable_builtin< T >,
stream&
>::type
operator<<( stream& s, T* )
typename boost::enable_if<boost::function_types::is_callable_builtin<T>, stream&>::type operator<<(stream& s, T*)
{
return s << '?';
}
template<typename T>
typename boost::disable_if<
boost::function_types::is_callable_builtin< T >,
stream&
>::type
operator<<( stream& s, T* t )
typename boost::disable_if<boost::function_types::is_callable_builtin<T>, stream&>::type operator<<(stream& s, T* t)
{
*s.s_ << t;
return s;
}
} // mock
} // namespace mock
#endif // MOCK_LOG_HPP_INCLUDED

69
include/turtle/matcher.hpp
View file

@ -10,34 +10,27 @@
#define MOCK_MATCHER_HPP_INCLUDED
#include "config.hpp"
#include "log.hpp"
#include "constraints.hpp"
#include "detail/is_functor.hpp"
#include "detail/move_helper.hpp"
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/add_reference.hpp>
#include "log.hpp"
#include <boost/ref.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/utility/enable_if.hpp>
#include <cstring>
namespace mock
{
namespace mock {
template<typename Actual, typename Expected, typename Enable = void>
class matcher
{
public:
explicit matcher( Expected expected )
: expected_( expected )
{}
explicit matcher(Expected expected) : expected_(expected) {}
bool operator()(typename boost::add_reference<const Actual>::type actual)
{
return mock::equal(
boost::unwrap_ref( expected_ ) ).c_( actual );
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.expected_ );
return mock::equal(boost::unwrap_ref(expected_)).c_(actual);
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); }
private:
Expected expected_;
};
@ -46,18 +39,10 @@ namespace mock
class matcher<const char*, const char*>
{
public:
explicit matcher( const char* expected )
: expected_( expected )
{}
bool operator()( const char* actual )
{
return std::strcmp( actual, expected_ ) == 0;
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.expected_ );
}
explicit matcher(const char* expected) : expected_(expected) {}
bool operator()(const char* actual) { return std::strcmp(actual, expected_) == 0; }
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); }
private:
const char* expected_;
};
@ -66,45 +51,31 @@ namespace mock
class matcher<Actual, mock::constraint<Constraint>>
{
public:
explicit matcher( const constraint< Constraint >& c )
: c_( c.c_ )
{}
explicit matcher(const constraint<Constraint>& c) : c_(c.c_) {}
bool operator()(typename detail::ref_arg<Actual>::type actual)
{
return c_(mock::detail::move_if_not_lvalue_reference<typename detail::ref_arg<Actual>::type>(actual));
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.c_ );
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); }
private:
Constraint c_;
};
template<typename Actual, typename Functor>
class matcher< Actual, Functor,
typename boost::enable_if<
detail::is_functor< Functor, Actual >
>::type
>
class matcher<Actual, Functor, typename boost::enable_if<detail::is_functor<Functor, Actual>>::type>
{
public:
explicit matcher( const Functor& f )
: c_( f )
{}
explicit matcher(const Functor& f) : c_(f) {}
bool operator()(typename detail::ref_arg<Actual>::type actual)
{
return c_(mock::detail::move_if_not_lvalue_reference<typename detail::ref_arg<Actual>::type>(actual));
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.c_ );
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); }
private:
Functor c_;
};
} // mock
} // namespace mock
#endif // MOCK_MATCHER_HPP_INCLUDED

157
include/turtle/mock.hpp
View file

@ -9,93 +9,68 @@
#ifndef MOCK_MOCK_HPP_INCLUDED
#define MOCK_MOCK_HPP_INCLUDED
#include "cleanup.hpp"
#include "config.hpp"
#include "detail/function.hpp"
#include "detail/functor.hpp"
#include "detail/parameter.hpp"
#include "detail/signature.hpp"
#include "detail/type_name.hpp"
#include "object.hpp"
#include "reset.hpp"
#include "verify.hpp"
#include "cleanup.hpp"
#include "detail/functor.hpp"
#include "detail/function.hpp"
#include "detail/type_name.hpp"
#include "detail/signature.hpp"
#include "detail/parameter.hpp"
#include <boost/mpl/assert.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/utility/identity_type.hpp>
#include <boost/mpl/assert.hpp>
#define MOCK_CLASS(T) \
struct T : mock::object
#define MOCK_CLASS(T) struct T : mock::object
#define MOCK_FUNCTION_TYPE(S, tpn) \
tpn boost::remove_pointer< tpn BOOST_IDENTITY_TYPE(S) >::type
#define MOCK_FUNCTION_TYPE(S, tpn) tpn boost::remove_pointer<tpn BOOST_IDENTITY_TYPE(S)>::type
#ifdef MOCK_VARIADIC_MACROS
#define MOCK_BASE_CLASS(T, ...) \
struct T : __VA_ARGS__, mock::object, mock::detail::base< __VA_ARGS__ >
# define MOCK_BASE_CLASS(T, ...) struct T : __VA_ARGS__, mock::object, mock::detail::base<__VA_ARGS__>
#define MOCK_FUNCTOR(f, ...) \
mock::detail::functor< MOCK_FUNCTION_TYPE((__VA_ARGS__),) > f, f##_mock
#define MOCK_FUNCTOR_TPL(f, ...) \
mock::detail::functor< \
MOCK_FUNCTION_TYPE((__VA_ARGS__), typename) > f, f##_mock
# define MOCK_FUNCTOR(f, ...) mock::detail::functor<MOCK_FUNCTION_TYPE((__VA_ARGS__), )> f, f##_mock
# define MOCK_FUNCTOR_TPL(f, ...) mock::detail::functor<MOCK_FUNCTION_TYPE((__VA_ARGS__), typename)> f, f##_mock
#else // MOCK_VARIADIC_MACROS
#define MOCK_BASE_CLASS(T, I) \
struct T : I, mock::object, mock::detail::base< I >
# define MOCK_BASE_CLASS(T, I) struct T : I, mock::object, mock::detail::base<I>
#define MOCK_FUNCTOR(f, S) \
mock::detail::functor< MOCK_FUNCTION_TYPE((S),) > f, f##_mock
#define MOCK_FUNCTOR_TPL(f, S) \
mock::detail::functor< \
MOCK_FUNCTION_TYPE((S), typename) > f, f##_mock
# define MOCK_FUNCTOR(f, S) mock::detail::functor<MOCK_FUNCTION_TYPE((S), )> f, f##_mock
# define MOCK_FUNCTOR_TPL(f, S) mock::detail::functor<MOCK_FUNCTION_TYPE((S), typename)> f, f##_mock
#endif // MOCK_VARIADIC_MACROS
#define MOCK_HELPER(t) \
t##_mock( mock::detail::root, BOOST_PP_STRINGIZE(t) )
#define MOCK_ANONYMOUS_HELPER(t) \
t##_mock( mock::detail::root, "?." )
#define MOCK_HELPER(t) t##_mock(mock::detail::root, BOOST_PP_STRINGIZE(t))
#define MOCK_ANONYMOUS_HELPER(t) t##_mock(mock::detail::root, "?.")
#define MOCK_METHOD_HELPER(S, t, tpn) \
mutable mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)> t##_mock_; \
mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)>& t##_mock( \
const mock::detail::context&, \
const boost::unit_test::const_string& instance ) const \
const mock::detail::context&, const boost::unit_test::const_string& instance) const \
{ \
mock::detail::configure( *this, t##_mock_, \
instance.substr( 0, instance.rfind( BOOST_PP_STRINGIZE(t) ) ), \
MOCK_TYPE_NAME(*this), \
BOOST_PP_STRINGIZE(t) ); \
mock::detail::configure(*this, t##_mock_, instance.substr(0, instance.rfind(BOOST_PP_STRINGIZE(t))), \
MOCK_TYPE_NAME(*this), BOOST_PP_STRINGIZE(t)); \
return t##_mock_; \
}
#define MOCK_PARAM(S, tpn) \
tpn mock::detail::parameter< MOCK_FUNCTION_TYPE((S), tpn)
#define MOCK_DECL_PARAM(z, n, d) \
BOOST_PP_COMMA_IF(n) d, n >::type p##n
#define MOCK_DECL_PARAMS(n, S, tpn) \
BOOST_PP_REPEAT(n, MOCK_DECL_PARAM, MOCK_PARAM(S, tpn))
#define MOCK_PARAM(S, tpn) tpn mock::detail::parameter < MOCK_FUNCTION_TYPE((S), tpn)
#define MOCK_DECL_PARAM(z, n, d) BOOST_PP_COMMA_IF(n) d, n > ::type p##n
#define MOCK_DECL_PARAMS(n, S, tpn) BOOST_PP_REPEAT(n, MOCK_DECL_PARAM, MOCK_PARAM(S, tpn))
#define MOCK_DECL(M, n, S, c, tpn) \
tpn boost::function_types::result_type< \
MOCK_FUNCTION_TYPE((S), tpn) >::type M( \
MOCK_DECL_PARAMS(n, S, tpn) ) c
tpn boost::function_types::result_type<MOCK_FUNCTION_TYPE((S), tpn)>::type M(MOCK_DECL_PARAMS(n, S, tpn)) c
#define MOCK_FORWARD_PARAM(z, n, d) \
BOOST_PP_COMMA_IF(n) d, n >::type >( p##n )
#define MOCK_FORWARD_PARAM(z, n, d) BOOST_PP_COMMA_IF(n) d, n > ::type > (p##n)
#define MOCK_FORWARD_PARAMS(n, S, tpn) \
BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, \
mock::detail::move_if_not_lvalue_reference< MOCK_PARAM(S, tpn))
BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, mock::detail::move_if_not_lvalue_reference < MOCK_PARAM(S, tpn))
#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \
MOCK_DECL(M, n, S, c, tpn) \
{ \
BOOST_MPL_ASSERT_RELATION( n, ==, \
boost::function_types::function_arity< \
MOCK_FUNCTION_TYPE((S), tpn) >::value ); \
return MOCK_ANONYMOUS_HELPER(t)( \
MOCK_FORWARD_PARAMS(n, S, tpn) ); \
BOOST_MPL_ASSERT_RELATION(n, ==, boost::function_types::function_arity<MOCK_FUNCTION_TYPE((S), tpn)>::value); \
return MOCK_ANONYMOUS_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \
}
#define MOCK_METHOD_EXT(M, n, S, t) \
@ -143,8 +118,7 @@
MOCK_METHOD_HELPER(T(), t, typename)
#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) >& t##_mock( \
mock::detail::context& context, \
s mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)>& t##_mock(mock::detail::context& context, \
boost::unit_test::const_string instance) \
{ \
static mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)> f; \
@ -152,28 +126,28 @@
}
#define MOCK_CONSTRUCTOR_AUX(T, n, A, t, tpn) \
T( MOCK_DECL_PARAMS(n, void A, tpn) ) \
{ \
MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, void A, tpn) ); \
} \
T(MOCK_DECL_PARAMS(n, void A, tpn)) { MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, void A, tpn)); } \
MOCK_FUNCTION_HELPER(void A, t, static, tpn)
#define MOCK_CONSTRUCTOR(T, n, A, t) \
MOCK_CONSTRUCTOR_AUX(T, n, A, t,)
#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) \
MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename)
#define MOCK_CONSTRUCTOR(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, )
#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename)
#define MOCK_DESTRUCTOR(T, t) \
T() { try { MOCK_ANONYMOUS_HELPER(t)(); } catch( ... ) {} } \
T() \
{ \
try \
{ \
MOCK_ANONYMOUS_HELPER(t)(); \
} catch(...) \
{} \
} \
MOCK_METHOD_HELPER(void(), t, )
#define MOCK_FUNCTION_AUX(F, n, S, t, s, tpn) \
MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s MOCK_DECL(F, n, S, , tpn) \
{ \
BOOST_MPL_ASSERT_RELATION( n, ==, \
boost::function_types::function_arity< \
MOCK_FUNCTION_TYPE((S), tpn) >::value ); \
BOOST_MPL_ASSERT_RELATION(n, ==, boost::function_types::function_arity<MOCK_FUNCTION_TYPE((S), tpn)>::value); \
return MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \
}
@ -184,65 +158,44 @@
# define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2
# define MOCK_METHOD(M, ...) \
MOCK_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_CONST_METHOD(M, ...) \
MOCK_CONST_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_CONST_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_NON_CONST_METHOD(M, ...) \
MOCK_NON_CONST_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_NON_CONST_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_METHOD_TPL(M, n, ...) \
MOCK_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
MOCK_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_CONST_METHOD_TPL(M, n, ...) \
MOCK_CONST_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
MOCK_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_NON_CONST_METHOD_TPL(M, n, ...) \
MOCK_NON_CONST_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
MOCK_NON_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_FUNCTION(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
inline,)
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), inline, )
# define MOCK_STATIC_METHOD(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
static,)
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, )
# define MOCK_STATIC_METHOD_TPL(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
static, typename)
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, \
typename)
#else // MOCK_VARIADIC_MACROS
#define MOCK_METHOD(M, n) \
MOCK_METHOD_EXT(M, n, MOCK_SIGNATURE(M), M)
# define MOCK_METHOD(M, n) MOCK_METHOD_EXT(M, n, MOCK_SIGNATURE(M), M)
#define MOCK_FUNCTION(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, inline,)
# define MOCK_FUNCTION(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, inline, )
#define MOCK_STATIC_METHOD(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, static,)
# define MOCK_STATIC_METHOD(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, static, )
#define MOCK_STATIC_METHOD_TPL(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, static, typename)
# define MOCK_STATIC_METHOD_TPL(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, static, typename)
#endif // MOCK_VARIADIC_MACROS

46
include/turtle/object.hpp
View file

@ -10,65 +10,53 @@
#define MOCK_OBJECT_HPP_INCLUDED
#include "config.hpp"
#include "detail/object_impl.hpp"
#include "detail/root.hpp"
#include "detail/type_name.hpp"
#include "detail/object_impl.hpp"
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
namespace mock
{
namespace mock {
class object;
namespace detail
{
namespace detail {
template<typename E>
E& configure( const object& o, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name);
template<typename T, typename E>
E& configure( const T& t, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
E& configure(const T& t, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name,
typename boost::disable_if<
typename boost::is_base_of< object, T >
>::type* = 0 )
typename boost::disable_if<typename boost::is_base_of<object, T>>::type* = 0)
{
e.configure(detail::root, &t, instance, type, name);
return e;
}
}
} // namespace detail
class object
{
public:
object()
: impl_( boost::make_shared< detail::object_impl >() )
{}
object() : impl_(boost::make_shared<detail::object_impl>()) {}
protected:
~object()
{}
~object() {}
public:
boost::shared_ptr<detail::object_impl> impl_;
};
namespace detail
{
namespace detail {
template<typename E>
E& configure( const object& o, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
e.configure(*o.impl_, o.impl_.get(), instance, type, name);
return e;
}
}
} // mock
} // namespace detail
} // namespace mock
#endif // MOCK_OBJECT_HPP_INCLUDED

9
include/turtle/reset.hpp
View file

@ -10,12 +10,11 @@
#define MOCK_RESET_HPP_INCLUDED
#include "config.hpp"
#include "object.hpp"
#include "detail/root.hpp"
#include "detail/functor.hpp"
#include "detail/root.hpp"
#include "object.hpp"
namespace mock
{
namespace mock {
inline void reset()
{
detail::root.reset();
@ -29,6 +28,6 @@ namespace mock
{
f.reset();
}
} // mock
} // namespace mock
#endif // MOCK_RESET_HPP_INCLUDED

9
include/turtle/sequence.hpp
View file

@ -12,17 +12,14 @@
#include "config.hpp"
#include "detail/sequence_impl.hpp"
namespace mock
{
namespace mock {
class sequence
{
public:
sequence()
: impl_( boost::make_shared< detail::sequence_impl >() )
{}
sequence() : impl_(boost::make_shared<detail::sequence_impl>()) {}
boost::shared_ptr<detail::sequence_impl> impl_;
};
} // mock
} // namespace mock
#endif // MOCK_SEQUENCE_HPP_INCLUDED

65
include/turtle/stream.hpp
View file

@ -13,22 +13,16 @@
#include <boost/noncopyable.hpp>
#include <ostream>
namespace mock
{
namespace mock {
struct stream
{
explicit stream( std::ostream& s )
: s_( &s )
{}
explicit stream(std::ostream& s) : s_(&s) {}
std::ostream* s_;
};
#ifdef MOCK_USE_CONVERSIONS
namespace detail
{
namespace conversion
{
namespace detail { namespace conversion {
struct sink
{
template<typename T>
@ -36,24 +30,18 @@ namespace conversion
{}
};
inline std::ostream& operator<<( std::ostream& s, const sink& )
{
return s << '?';
}
inline std::ostream& operator<<(std::ostream& s, const sink&) { return s << '?'; }
struct holder : boost::noncopyable
{
virtual ~holder()
{}
virtual ~holder() {}
virtual void serialize(std::ostream& s) const = 0;
};
template<typename T>
struct holder_imp : holder
{
explicit holder_imp( const T& t )
: t_( t )
{}
explicit holder_imp(const T& t) : t_(t) {}
virtual void serialize(std::ostream& s) const
{
// if an error about an ambiguous conversion is generated by the
@ -67,17 +55,12 @@ namespace conversion
struct any : boost::noncopyable
{
template<typename T>
any( const T& t )
: h_( new holder_imp< T >( t ) )
any(const T& t) : h_(new holder_imp<T>(t))
{}
~any()
{
delete h_;
}
~any() { delete h_; }
holder* h_;
};
}
}
}} // namespace detail::conversion
inline stream& operator<<(stream& s, const detail::conversion::any& d)
{
@ -87,17 +70,13 @@ namespace conversion
#else // MOCK_USE_CONVERSIONS
namespace detail
{
namespace conversion
{
namespace detail { namespace conversion {
template<typename S, typename T>
S& operator<<(S& s, const T&)
{
return s << '?';
}
}
}
}} // namespace detail::conversion
template<typename T>
stream& operator<<(stream& s, const T& t)
@ -109,8 +88,7 @@ namespace conversion
#endif // MOCK_USE_CONVERSIONS
namespace detail
{
namespace detail {
template<typename T>
void serialize(stream& s, const T& t)
{
@ -119,24 +97,15 @@ namespace detail
// mock::stream for T
s << t;
}
inline void serialize( stream& s, bool b )
{
s << (b ? "true" : "false");
}
inline void serialize(stream& s, bool b) { s << (b ? "true" : "false"); }
template<typename C, typename T, typename A>
void serialize(stream& s, const std::basic_string<C, T, A>& str)
{
s << '"' << str << '"';
}
inline void serialize( stream& s, const char* const str )
{
s << '"' << str << '"';
}
inline void serialize( stream& s, unsigned char c )
{
s << static_cast< int >( c );
}
}
} // mock
inline void serialize(stream& s, const char* const str) { s << '"' << str << '"'; }
inline void serialize(stream& s, unsigned char c) { s << static_cast<int>(c); }
} // namespace detail
} // namespace mock
#endif // MOCK_STREAM_HPP_INCLUDED

9
include/turtle/verify.hpp
View file

@ -10,12 +10,11 @@
#define MOCK_VERIFY_HPP_INCLUDED
#include "config.hpp"
#include "object.hpp"
#include "detail/root.hpp"
#include "detail/functor.hpp"
#include "detail/root.hpp"
#include "object.hpp"
namespace mock
{
namespace mock {
inline bool verify()
{
return detail::root.verify();
@ -29,6 +28,6 @@ namespace mock
{
return f.verify();
}
} // mock
} // namespace mock
#endif // MOCK_VERIFY_HPP_INCLUDED

1295
test/bench_30_classes_30_methods_30_args_30_max_args.cpp
View file

File diff suppressed because it is too large Load diff

1205
test/bench_30_classes_30_methods_9_args.cpp
View file

File diff suppressed because it is too large Load diff

1205
test/bench_30_classes_30_methods_9_args_10_max_args.cpp
View file

File diff suppressed because it is too large Load diff

1205
test/bench_30_classes_30_methods_9_args_20_max_args.cpp
View file

File diff suppressed because it is too large Load diff

1205
test/bench_30_classes_30_methods_9_args_30_max_args.cpp
View file

File diff suppressed because it is too large Load diff

114
test/detail/test_function.cpp
View file

@ -8,30 +8,25 @@
#include "../mock_error.hpp"
#include "../undefined.hpp"
#include <turtle/detail/function.hpp>
#include <turtle/constraints.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/utility/result_of.hpp>
#include <turtle/detail/function.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/utility/result_of.hpp>
// static
namespace
{
namespace {
boost::function<void()> static_f;
BOOST_MPL_ASSERT((
boost::is_same< void, boost::result_of< mock::detail::function< void() >() >::type > ));
BOOST_MPL_ASSERT((
boost::is_same< int, boost::result_of< mock::detail::function< int() >() >::type > ));
BOOST_MPL_ASSERT((
boost::is_same< void, boost::result_of< mock::detail::function< void( float ) >( float ) >::type > ));
BOOST_MPL_ASSERT((
boost::is_same< int, boost::result_of< mock::detail::function< int( float ) >( float ) >::type > ));
}
BOOST_MPL_ASSERT((boost::is_same<void, boost::result_of<mock::detail::function<void()>()>::type>));
BOOST_MPL_ASSERT((boost::is_same<int, boost::result_of<mock::detail::function<int()>()>::type>));
BOOST_MPL_ASSERT((boost::is_same<void, boost::result_of<mock::detail::function<void(float)>(float)>::type>));
BOOST_MPL_ASSERT((boost::is_same<int, boost::result_of<mock::detail::function<int(float)>(float)>::type>));
} // namespace
// functor
@ -260,7 +255,9 @@ BOOST_FIXTURE_TEST_CASE( verifying_a_reset_function_succeeds, mock_error_fixture
// constraints
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_constraint_calls_unexpected_call_error, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(
triggering_an_expectation_with_wrong_parameter_value_in_equal_constraint_calls_unexpected_call_error,
mock_error_fixture)
{
{
mock::detail::function<void(int)> f;
@ -270,11 +267,14 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
{
mock::detail::function<int(int, const std::string&)> f;
f.expect().with(42, "expected");
CHECK_ERROR( f( 42, "actual" ), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( 42, \"expected\" )" );
CHECK_ERROR(f(42, "actual"), "unexpected call", 0,
"?( 42, \"actual\" )\n. unlimited().with( 42, \"expected\" )");
}
}
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_or_less_constraint_calls_unexpected_call_error, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(
triggering_an_expectation_with_wrong_parameter_value_in_equal_or_less_constraint_calls_unexpected_call_error,
mock_error_fixture)
{
mock::detail::function<void(int)> f;
f.expect().with(mock::equal(42) || mock::less(42));
@ -283,7 +283,9 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
CHECK_ERROR(f(43), "unexpected call", 2, "?( 43 )\n. unlimited().with( ( equal( 42 ) || less( 42 ) ) )");
}
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_and_not_less_constraint_calls_unexpected_call_error, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(
triggering_an_expectation_with_wrong_parameter_value_in_equal_and_not_less_constraint_calls_unexpected_call_error,
mock_error_fixture)
{
mock::detail::function<void(int)> f;
f.expect().with(mock::equal(42) && !mock::less(41));
@ -291,12 +293,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
CHECK_ERROR(f(43), "unexpected call", 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )");
}
namespace
{
namespace {
class my_interface : boost::noncopyable
{
public:
virtual ~my_interface() {}
private:
virtual void my_method() = 0;
};
@ -304,7 +306,7 @@ namespace
{
virtual void my_method() {}
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(passing_call_values_by_reference_is_transparent, mock_error_fixture)
{
@ -324,15 +326,15 @@ BOOST_FIXTURE_TEST_CASE( passing_call_values_by_reference_is_transparent, mock_e
}
}
namespace
{
namespace {
bool custom_constraint(int)
{
return false;
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_failing_custom_constraint_calls_unexpected_call_error, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_with_failing_custom_constraint_calls_unexpected_call_error,
mock_error_fixture)
{
{
mock::detail::function<void(int)> f;
@ -501,20 +503,17 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_value, mock_e
}
}
namespace
{
namespace {
struct base
{
virtual ~base()
{}
virtual ~base() {}
virtual void f() = 0;
};
struct derived : base
{
virtual void f()
{}
virtual void f() {}
};
}
} // namespace
#ifdef MOCK_AUTO_PTR
@ -673,13 +672,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_by_reference, mock_er
}
}
namespace
{
namespace {
int custom_result()
{
return 42;
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor, mock_error_fixture)
{
@ -689,13 +687,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor, moc
CHECK_CALLS(1);
}
namespace
{
namespace {
int custom_result_with_parameter(int i)
{
return i;
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_with_parameters, mock_error_fixture)
{
@ -705,7 +702,8 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor_with
CHECK_CALLS(1);
}
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor_without_parameters_thanks_to_boost_bind, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_without_parameters_thanks_to_boost_bind,
mock_error_fixture)
{
mock::detail::function<int(int)> f;
f.expect().calls(boost::bind(&custom_result));
@ -720,8 +718,7 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_throws_the_set_exception, moc
try
{
f();
}
catch( std::runtime_error& f )
} catch(std::runtime_error& f)
{
BOOST_CHECK_EQUAL("some exception", f.what());
CHECK_CALLS(1);
@ -748,7 +745,8 @@ BOOST_FIXTURE_TEST_CASE( expecting_twice_a_single_expectation_makes_it_callable_
f.expect().once().with("second");
f("first");
f("second");
CHECK_ERROR( f( "third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" );
CHECK_ERROR(f("third"), "unexpected call", 2,
"?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )");
}
}
@ -768,14 +766,14 @@ BOOST_FIXTURE_TEST_CASE( best_expectation_is_selected_first, mock_error_fixture
f.expect().once().with("second");
f("second");
f("first");
CHECK_ERROR( f( "third"), "unexpected call", 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" );
CHECK_ERROR(f("third"), "unexpected call", 2,
"?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )");
}
}
// error report
namespace
{
namespace {
template<typename T>
std::string to_string(const T& t)
{
@ -783,7 +781,7 @@ namespace
s << t;
return s.str();
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(expectation_can_be_serialized_to_be_human_readable, mock_error_fixture)
{
@ -862,21 +860,24 @@ BOOST_FIXTURE_TEST_CASE( expectation_can_be_serialized_to_be_human_readable, moc
}
}
BOOST_FIXTURE_TEST_CASE( expectation_with_remaining_untriggered_matches_upon_destruction_calls_untriggered_expectation, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(expectation_with_remaining_untriggered_matches_upon_destruction_calls_untriggered_expectation,
mock_error_fixture)
{
boost::scoped_ptr<mock::detail::function<void()>> f(new mock::detail::function<void()>);
f->expect().once();
CHECK_ERROR(f.reset(), "untriggered expectation", 0, "?\n. once()");
}
BOOST_FIXTURE_TEST_CASE( verifying_expectation_with_remaining_matches_disables_the_automatic_verification_upon_destruction, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(
verifying_expectation_with_remaining_matches_disables_the_automatic_verification_upon_destruction, mock_error_fixture)
{
mock::detail::function<void()> f;
f.expect().once();
CHECK_ERROR(f.verify(), "verification failed", 0, "?\n. once()");
}
BOOST_FIXTURE_TEST_CASE( triggering_unexpected_call_call_disables_the_automatic_verification_upon_destruction, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(triggering_unexpected_call_call_disables_the_automatic_verification_upon_destruction,
mock_error_fixture)
{
mock::detail::function<void()> f;
CHECK_ERROR(f(), "unexpected call", 0, "?()");
@ -897,8 +898,7 @@ BOOST_FIXTURE_TEST_CASE( throwing_an_exception_disables_the_automatic_verificati
mock::detail::function<void()> f;
f.expect().once();
throw std::exception();
}
catch( std::exception& )
} catch(std::exception&)
{}
}
@ -915,19 +915,17 @@ BOOST_FIXTURE_TEST_CASE( adding_file_and_line_number_information, mock_error_fix
# include <boost/thread.hpp>
namespace
{
namespace {
void iterate(mock::detail::function<int()>& f)
{
f.expect().once().returns(0);
try
{
f();
}
catch( ... )
} catch(...)
{}
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(function_is_thread_safe, mock_error_fixture)
{

33
test/detail/test_is_functor.cpp
View file

@ -16,14 +16,12 @@
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
namespace
{
namespace {
struct declared_but_not_defined;
BOOST_MPL_ASSERT_NOT((
mock::detail::is_functor< declared_but_not_defined, int > ));
BOOST_MPL_ASSERT_NOT((mock::detail::is_functor<declared_but_not_defined, int>));
template<typename T>
void is_functor(T)
@ -37,9 +35,15 @@ namespace
}
void f0() {}
bool f1( int ) { return false; }
bool f2( std::string, int ) { return false; }
bool f1(int)
{
return false;
}
bool f2(std::string, int)
{
return false;
}
} // namespace
BOOST_AUTO_TEST_CASE(data_is_not_functor)
{
@ -71,13 +75,12 @@ BOOST_AUTO_TEST_CASE( std_bind_first_is_functor )
is_functor(std::bind1st(std::ptr_fun(&f2), ""));
}
namespace
{
namespace {
struct unary_functor0 : public std::unary_function<void, void>
{};
struct unary_functor1 : public std::unary_function<int, void>
{};
}
} // namespace
BOOST_AUTO_TEST_CASE(std_unary_functor_is_functor)
{
@ -108,21 +111,19 @@ BOOST_AUTO_TEST_CASE( boost_function_is_functor )
is_functor(boost::function<void()>());
}
namespace
{
namespace {
struct result_type_functor
{
typedef void result_type;
};
}
} // namespace
BOOST_AUTO_TEST_CASE(class_with_result_type_is_functor)
{
is_functor(result_type_functor());
}
namespace
{
namespace {
struct sig_functor
{
template<typename Args>
@ -131,7 +132,7 @@ namespace
typedef void type;
};
};
}
} // namespace
BOOST_AUTO_TEST_CASE(class_with_sig_is_functor)
{

13
test/detail/test_signature.cpp
View file

@ -7,23 +7,20 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include <turtle/detail/signature.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
struct base
{
void method_1();
float method_2(int) const;
};
typedef base base_type;
}
} // namespace
BOOST_AUTO_TEST_CASE(mock_signature_generates_signature)
{
BOOST_MPL_ASSERT((
boost::is_same< void(), MOCK_SIGNATURE(method_1) > ));
BOOST_MPL_ASSERT((
boost::is_same< float( int ), MOCK_SIGNATURE(method_2) > ));
BOOST_MPL_ASSERT((boost::is_same<void(), MOCK_SIGNATURE(method_1)>));
BOOST_MPL_ASSERT((boost::is_same<float(int), MOCK_SIGNATURE(method_2)>));
}

92
test/detail/test_type_name.cpp
View file

@ -7,17 +7,16 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include <turtle/detail/type_name.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
template<typename T>
std::string to_string(const T&)
{
return boost::lexical_cast<std::string>(MOCK_TYPE_NAME(T));
}
}
} // namespace
BOOST_AUTO_TEST_CASE(name_of_base_type_is_extracted)
{
@ -33,7 +32,8 @@ BOOST_AUTO_TEST_CASE( name_of_base_type_is_extracted )
struct my_type_in_default_namespace
{
struct inner {};
struct inner
{};
};
BOOST_AUTO_TEST_CASE(name_of_type_in_default_namespace_is_extracted)
@ -49,12 +49,14 @@ BOOST_AUTO_TEST_CASE( name_of_inner_type_from_type_in_default_namespace_is_extra
template<typename T>
struct my_template_type_in_default_namespace
{
struct inner {};
struct inner
{};
};
BOOST_AUTO_TEST_CASE(name_of_template_type_in_default_namespace_is_extracted)
{
BOOST_CHECK_EQUAL( "my_template_type_in_default_namespace<int>", to_string( my_template_type_in_default_namespace<int>() ) );
BOOST_CHECK_EQUAL("my_template_type_in_default_namespace<int>",
to_string(my_template_type_in_default_namespace<int>()));
}
BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_default_namespace_is_extracted)
@ -62,46 +64,40 @@ BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_default_namespace
BOOST_CHECK_EQUAL("inner", to_string(my_template_type_in_default_namespace<int>::inner()));
}
namespace
{
struct my_type_in_anonymous_namespace {};
}
namespace {
struct my_type_in_anonymous_namespace
{};
} // namespace
BOOST_AUTO_TEST_CASE(name_of_type_in_anonymous_namespace_is_extracted)
{
BOOST_CHECK_EQUAL("my_type_in_anonymous_namespace", to_string(my_type_in_anonymous_namespace()));
}
namespace nm
{
struct my_type_from_named_namespace {};
}
namespace nm {
struct my_type_from_named_namespace
{};
} // namespace nm
BOOST_AUTO_TEST_CASE(name_of_type_from_named_namespace_is_extracted)
{
BOOST_CHECK_EQUAL("my_type_from_named_namespace", to_string(nm::my_type_from_named_namespace()));
}
namespace nm
{
namespace inner
{
struct my_type_in_named_inner_namespace {};
}
}
namespace nm { namespace inner {
struct my_type_in_named_inner_namespace
{};
}} // namespace nm::inner
BOOST_AUTO_TEST_CASE(name_of_type_in_named_inner_namespace_is_extracted)
{
BOOST_CHECK_EQUAL("my_type_in_named_inner_namespace", to_string(nm::inner::my_type_in_named_inner_namespace()));
}
namespace
{
namespace inner
{
struct my_type_in_unnamed_inner_namespace {};
}
}
namespace { namespace inner {
struct my_type_in_unnamed_inner_namespace
{};
}} // namespace ::inner
BOOST_AUTO_TEST_CASE(name_of_type_in_unnamed_inner_namespace_is_extracted)
{
@ -110,18 +106,19 @@ BOOST_AUTO_TEST_CASE( name_of_type_in_unnamed_inner_namespace_is_extracted )
BOOST_AUTO_TEST_CASE(name_of_local_type_is_extracted)
{
struct my_local_type {};
struct my_local_type
{};
BOOST_CHECK_EQUAL("my_local_type", boost::lexical_cast<std::string>(MOCK_TYPE_NAME(my_local_type)));
}
namespace
{
namespace {
template<typename T>
struct my_template_type
{
struct inner {};
struct inner
{};
};
}
} // namespace
BOOST_AUTO_TEST_CASE(name_of_template_type_in_anonymous_namespace_is_extracted)
{
@ -147,14 +144,14 @@ BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_anonymous_namespa
BOOST_CHECK_EQUAL("inner", to_string(my_template_type<std::exception const*&>::inner()));
}
namespace nm
{
namespace nm {
template<typename T>
struct my_template_type
{
struct inner {};
struct inner
{};
};
}
} // namespace nm
BOOST_AUTO_TEST_CASE(name_of_template_type_in_named_namespace_is_extracted)
{
@ -180,15 +177,15 @@ BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_named_namespace_i
BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type<std::exception const*&>::inner()));
}
namespace nm2
{
namespace nm2 {
template<typename T>
struct my_template_type
{
template<typename U>
struct inner {};
struct inner
{};
};
}
} // namespace nm2
BOOST_AUTO_TEST_CASE(name_of_template_inner_type_from_template_type_in_named_namespace_is_extracted)
{
@ -210,16 +207,17 @@ BOOST_AUTO_TEST_CASE( name_of_template_inner_type_from_template_type_in_named_na
BOOST_CHECK_EQUAL("inner<int const*&>", to_string(nm2::my_template_type<std::exception>::inner<int const*&>()));
}
namespace
{
namespace {
template<typename T1, typename T2, typename T3>
struct my_tpl
{};
}
} // namespace
BOOST_AUTO_TEST_CASE(name_of_nested_template_with_multiple_arguments_is_extracted)
{
BOOST_CHECK_EQUAL("vector<int, allocator<int>>", to_string(std::vector<int>()));
BOOST_CHECK_EQUAL( "vector<vector<int, allocator<int>>, allocator<vector<int, allocator<int>>>>", to_string( std::vector< std::vector< int > >() ) );
BOOST_CHECK_EQUAL( "my_tpl<my_tpl<int, int, int>, my_tpl<int, int, int>, my_tpl<int, int, int>>", to_string( my_tpl< my_tpl< int, int, int >, my_tpl< int, int, int >, my_tpl< int, int, int > >() ) );
BOOST_CHECK_EQUAL("vector<vector<int, allocator<int>>, allocator<vector<int, allocator<int>>>>",
to_string(std::vector<std::vector<int>>()));
BOOST_CHECK_EQUAL("my_tpl<my_tpl<int, int, int>, my_tpl<int, int, int>, my_tpl<int, int, int>>",
to_string(my_tpl<my_tpl<int, int, int>, my_tpl<int, int, int>, my_tpl<int, int, int>>()));
}

10
test/fail_ambiguous_mock_method.cpp
View file

@ -8,8 +8,7 @@
#include <turtle/mock.hpp>
namespace
{
namespace {
struct my_base
{
virtual ~my_base() {}
@ -17,8 +16,5 @@ namespace
virtual void my_method(int) = 0;
};
MOCK_BASE_CLASS( my_class, my_base )
{
MOCK_METHOD( my_method, 0 )
};
}
MOCK_BASE_CLASS(my_class, my_base){MOCK_METHOD(my_method, 0)};
} // namespace

10
test/fail_constraint_functor_not_compatible.cpp
View file

@ -8,12 +8,8 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 1, void( int ), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)};
bool constraint(int, int);
void test_case()
@ -21,4 +17,4 @@ namespace
my_class c;
MOCK_EXPECT(c.my_method).with(&constraint);
}
}
} // namespace

10
test/fail_constraint_value_not_comparable.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 1, void( int ), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).with("42");
}
}
} // namespace

10
test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 1, void( int ), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).with(mock::equal("42"));
}
}
} // namespace

10
test/fail_mismatch_type_in_returns_int_action.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 0, int(), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, int(), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).returns(std::string());
}
}
} // namespace

10
test/fail_mismatch_type_in_returns_string_action.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 0, std::string(), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, std::string(), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).returns(42);
}
}
} // namespace

10
test/fail_mismatch_type_in_returns_void_action.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 0, void(), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, void(), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).returns("42");
}
}
} // namespace

10
test/fail_non_existing_base_class_method_in_mock_method.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
namespace {
struct my_base
{
virtual ~my_base() {}
};
MOCK_BASE_CLASS( my_class, my_base )
{
MOCK_METHOD( my_method, 0 )
};
}
MOCK_BASE_CLASS(my_class, my_base){MOCK_METHOD(my_method, 0)};
} // namespace

10
test/fail_number_of_arguments_greater_than_max_constant.cpp
View file

@ -10,16 +10,12 @@
BOOST_STATIC_ASSERT(MOCK_MAX_ARGS == 9);
namespace
{
namespace {
struct my_base
{
virtual ~my_base() {}
virtual void my_method(int, int, int, int, int, int, int, int, int, int) = 0;
};
MOCK_BASE_CLASS( my_class, my_base )
{
MOCK_METHOD( my_method, 10 )
};
}
MOCK_BASE_CLASS(my_class, my_base){MOCK_METHOD(my_method, 10)};
} // namespace

8
test/fail_template_argument_without_tpl_macro.cpp
View file

@ -8,11 +8,7 @@
#include <turtle/mock.hpp>
namespace
{
namespace {
template<typename T>
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 1, void( T ), my_method )
};
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(T), my_method)};
}

10
test/fail_too_many_arguments_in_mock_method.cpp
View file

@ -8,16 +8,12 @@
#include <turtle/mock.hpp>
namespace
{
namespace {
struct my_base
{
virtual ~my_base() {}
virtual void my_method(int) = 0;
};
MOCK_BASE_CLASS( my_class, my_base )
{
MOCK_METHOD( my_method, 2 )
};
}
MOCK_BASE_CLASS(my_class, my_base){MOCK_METHOD(my_method, 2)};
} // namespace

10
test/fail_wrong_number_of_arguments_in_with.cpp
View file

@ -8,15 +8,11 @@
#include <turtle/mock.hpp>
namespace
{
MOCK_CLASS( my_class )
{
MOCK_METHOD_EXT( my_method, 1, void( int ), my_method )
};
namespace {
MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)};
void test_case()
{
my_class c;
MOCK_EXPECT(c.my_method).with(42, 42);
}
}
} // namespace

37
test/mock_error.hpp
View file

@ -24,10 +24,7 @@ struct mock_error_data_t : mock::detail::singleton< mock_error_data_t >
last_message.clear();
last_context.clear();
}
bool verify()
{
return error_count == 0;
}
bool verify() { return error_count == 0; }
void call()
{
@ -35,9 +32,7 @@ struct mock_error_data_t : mock::detail::singleton< mock_error_data_t >
last_message.clear();
++call_count;
}
void fail( const std::string& message,
const std::string& context,
const char* file, int line )
void fail(const std::string& message, const std::string& context, const char* file, int line)
{
last_context = context;
last_message = message;
@ -59,36 +54,26 @@ MOCK_SINGLETON_INST( mock_error_data )
template<typename Result>
struct mock_error
{
static Result abort()
{
throw std::runtime_error( "aborted" );
}
static Result abort() { throw std::runtime_error("aborted"); }
static void pass( const char* /*file*/, int /*line*/ )
{}
static void pass(const char* /*file*/, int /*line*/) {}
template<typename Context>
static void call( const Context& /*context*/,
const char* /*file*/, int /*line*/ )
static void call(const Context& /*context*/, const char* /*file*/, int /*line*/)
{
mock_error_data.call();
}
template<typename Context>
static void fail( const std::string& message, const Context& context,
const char* file = "", int line = 0 )
static void fail(const std::string& message, const Context& context, const char* file = "", int line = 0)
{
mock_error_data.fail( message,
boost::lexical_cast< std::string >( context ), file, line );
mock_error_data.fail(message, boost::lexical_cast<std::string>(context), file, line);
}
};
struct mock_error_fixture
{
mock_error_fixture()
{
mock_error_data.reset();
}
mock_error_fixture() { mock_error_data.reset(); }
~mock_error_fixture()
{
BOOST_CHECK(mock_error_data.verify());
@ -101,7 +86,11 @@ struct mock_error_fixture
mock_error_data.call_count = 0;
#define CHECK_ERROR(expr, error, calls, context) \
BOOST_CHECK(mock_error_data.verify()); \
try { expr; } catch( ... ) {} \
try \
{ \
expr; \
} catch(...) \
{} \
BOOST_CHECK_EQUAL(1, mock_error_data.error_count); \
BOOST_CHECK_EQUAL(error, mock_error_data.last_message); \
BOOST_CHECK_EQUAL(context, mock_error_data.last_context); \

10
test/test_constraint.cpp
View file

@ -11,12 +11,11 @@
#ifdef MOCK_VARIADIC_MACROS
namespace
{
namespace {
MOCK_CONSTRAINT(constraint_0, actual == 0)
MOCK_CONSTRAINT(constraint_1, expected, actual == expected)
MOCK_CONSTRAINT(constraint_2, expected_0, expected_1, actual == expected_0 || actual == expected_1)
}
} // namespace
BOOST_AUTO_TEST_CASE(mock_constraint_is_supported_by_compilers_with_variadic_macros)
{
@ -27,12 +26,11 @@ BOOST_AUTO_TEST_CASE( mock_constraint_is_supported_by_compilers_with_variadic_ma
#endif // MOCK_VARIADIC_MACROS
namespace
{
namespace {
MOCK_CONSTRAINT_EXT(constraint_0_ext, 0, , actual == 0)
MOCK_CONSTRAINT_EXT(constraint_1_ext, 1, (expected), actual == expected)
MOCK_CONSTRAINT_EXT(constraint_2_ext, 2, (expected_0, expected_1), actual == expected_0 || actual == expected_1)
}
} // namespace
BOOST_AUTO_TEST_CASE(mock_constraint_ext_is_supported_by_all_compilers)
{

71
test/test_constraints.cpp
View file

@ -64,10 +64,7 @@ BOOST_AUTO_TEST_CASE( equal_constraint )
#endif
}
BOOST_AUTO_TEST_CASE( equal_constraint_deref )
{
{
int i = 3;
BOOST_AUTO_TEST_CASE(equal_constraint_deref){{int i = 3;
BOOST_CHECK(mock::equal(3).c_(&i));
BOOST_CHECK(!mock::equal(7).c_(&i));
}
@ -85,10 +82,7 @@ BOOST_AUTO_TEST_CASE( equal_constraint_deref )
#endif // MOCK_SMART_PTR
}
BOOST_AUTO_TEST_CASE( same_constraint )
{
{
int i = 0;
BOOST_AUTO_TEST_CASE(same_constraint){{int i = 0;
int j = 0;
BOOST_CHECK_EQUAL(i, j);
BOOST_CHECK(!mock::same(i).c_(j));
@ -98,11 +92,7 @@ BOOST_AUTO_TEST_CASE( same_constraint )
int i = 0;
int j = 0;
BOOST_CHECK_EQUAL(i, j);
mock::constraint<
mock::detail::same<
const boost::reference_wrapper< const int >
>
> c = mock::same( boost::cref( i ) );
mock::constraint<mock::detail::same<const boost::reference_wrapper<const int>>> c = mock::same(boost::cref(i));
BOOST_CHECK(!c.c_(j));
BOOST_CHECK(c.c_(i));
}
@ -141,11 +131,7 @@ BOOST_AUTO_TEST_CASE( assign_constraint )
{
int i = 0;
int j = 1;
mock::constraint<
mock::detail::assign<
boost::reference_wrapper< const int >
>
> c = mock::assign( boost::cref( j ) );
mock::constraint<mock::detail::assign<boost::reference_wrapper<const int>>> c = mock::assign(boost::cref(j));
BOOST_CHECK(c.c_(i));
BOOST_CHECK_EQUAL(1, i);
j = 3;
@ -155,11 +141,7 @@ BOOST_AUTO_TEST_CASE( assign_constraint )
{
int i = 0;
int j = 1;
mock::constraint<
mock::detail::assign<
boost::reference_wrapper< const int >
>
> c = mock::assign( boost::cref( j ) );
mock::constraint<mock::detail::assign<boost::reference_wrapper<const int>>> c = mock::assign(boost::cref(j));
BOOST_CHECK(c.c_(&i));
BOOST_CHECK_EQUAL(1, i);
j = 3;
@ -170,11 +152,7 @@ BOOST_AUTO_TEST_CASE( assign_constraint )
const int* i = 0;
int k = 1;
int* j = &k;
mock::constraint<
mock::detail::assign<
boost::reference_wrapper< int* const >
>
> c = mock::assign( boost::cref( j ) );
mock::constraint<mock::detail::assign<boost::reference_wrapper<int* const>>> c = mock::assign(boost::cref(j));
BOOST_CHECK(c.c_(i));
BOOST_CHECK_EQUAL(j, i);
j = 0;
@ -265,19 +243,14 @@ BOOST_AUTO_TEST_CASE( retrieve_constraint )
#endif
}
namespace
{
namespace {
struct A
{
};
{};
struct B
{
B& operator=( const A& )
{
return *this;
}
B& operator=(const A&) { return *this; }
};
}
} // namespace
BOOST_AUTO_TEST_CASE(retrieve_constraint_uses_assignment_operator)
{
@ -312,8 +285,7 @@ BOOST_AUTO_TEST_CASE( negate_constraint )
BOOST_CHECK(!mock::negate.c_(&j));
}
namespace
{
namespace {
bool return_true()
{
return true;
@ -322,7 +294,7 @@ namespace
{
return false;
}
}
} // namespace
BOOST_AUTO_TEST_CASE(call_constraint)
{
@ -344,11 +316,8 @@ BOOST_AUTO_TEST_CASE( contain_constraint_with_const_char_ptr )
BOOST_CHECK(!mock::contain("not found").c_(std::string("this is a string")));
{
const char* s = 0;
mock::constraint<
mock::detail::contain<
boost::reference_wrapper< const char* const >
>
> c = mock::contain( boost::cref( s ) );
mock::constraint<mock::detail::contain<boost::reference_wrapper<const char* const>>> c =
mock::contain(boost::cref(s));
s = "string";
BOOST_CHECK(c.c_("this is a string"));
BOOST_CHECK(c.c_(std::string("this is a string")));
@ -366,11 +335,8 @@ BOOST_AUTO_TEST_CASE( contain_constraint_with_strings )
BOOST_CHECK(!mock::contain(std::string("not found")).c_(std::string("this is a string")));
{
std::string s;
mock::constraint<
mock::detail::contain<
boost::reference_wrapper< const std::string >
>
> c = mock::contain( boost::cref( s ) );
mock::constraint<mock::detail::contain<boost::reference_wrapper<const std::string>>> c =
mock::contain(boost::cref(s));
s = "string";
BOOST_CHECK(c.c_("this is a string"));
BOOST_CHECK(c.c_(std::string("this is a string")));
@ -380,14 +346,13 @@ BOOST_AUTO_TEST_CASE( contain_constraint_with_strings )
}
}
namespace
{
namespace {
struct type_with_overloaded_address_operator
{
void operator&() {}
void operator&() const {}
};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_with_overloaded_address_operator_can_be_used_in_constraints)
{

6
test/test_exception.cpp
View file

@ -15,11 +15,9 @@ BOOST_AUTO_TEST_CASE( a_mock_exception_is_not_an_std_exception_to_not_mess_with_
try
{
throw mock::exception();
}
catch( std::exception& )
} catch(std::exception&)
{
BOOST_FAIL("mock::exception must not be an std::exception");
}
catch( mock::exception& )
} catch(mock::exception&)
{}
}

265
test/test_integration.cpp
View file

@ -9,19 +9,18 @@
#include "mock_error.hpp"
#include "undefined.hpp"
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <boost/ref.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <cmath>
namespace
{
namespace {
struct my_custom_mock
{
MOCK_METHOD_EXT(my_method, 0, void(), my_tag)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_and_without_inheriting_from_object, mock_error_fixture)
{
@ -31,13 +30,12 @@ BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheritin
CHECK_CALLS(1);
}
namespace
{
namespace {
struct my_custom_mock_object
{
MOCK_METHOD_EXT(my_method, 0, void(), my_tag)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros, mock_error_fixture)
{
@ -47,12 +45,8 @@ BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( my_mock )
{
MOCK_METHOD_EXT( my_method, 1, int( int ), my_tag )
};
namespace {
MOCK_CLASS(my_mock){MOCK_METHOD_EXT(my_method, 1, int(int), my_tag)};
}
BOOST_FIXTURE_TEST_CASE(basic_mock_object_usage, mock_error_fixture)
@ -79,23 +73,18 @@ BOOST_FIXTURE_TEST_CASE( basic_mock_object_usage, mock_error_fixture )
}
}
namespace
{
namespace {
class my_ambiguited_interface : boost::noncopyable
{
public:
virtual ~my_ambiguited_interface()
{}
virtual ~my_ambiguited_interface() {}
virtual void my_method() = 0;
virtual void my_method(int) = 0;
};
MOCK_BASE_CLASS( my_ambiguited_mock, my_ambiguited_interface )
{
MOCK_METHOD_EXT( my_method, 0, void(), my_tag1 )
MOCK_METHOD_EXT( my_method, 1, void( int ), my_tag_2 )
};
}
MOCK_BASE_CLASS(my_ambiguited_mock, my_ambiguited_interface){MOCK_METHOD_EXT(my_method, 0, void(), my_tag1)
MOCK_METHOD_EXT(my_method, 1, void(int), my_tag_2)};
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_object_method_disambiguation, mock_error_fixture)
{
@ -105,23 +94,18 @@ BOOST_FIXTURE_TEST_CASE( mock_object_method_disambiguation, mock_error_fixture )
CHECK_ERROR(m.my_method(12), "unexpected call", 1, "?.my_ambiguited_mock::my_tag_2( 12 )");
}
namespace
{
namespace {
class my_const_ambiguited_interface : boost::noncopyable
{
public:
virtual ~my_const_ambiguited_interface()
{}
virtual ~my_const_ambiguited_interface() {}
virtual void my_method() = 0;
virtual void my_method() const = 0;
};
MOCK_BASE_CLASS( my_const_ambiguited_mock, my_const_ambiguited_interface )
{
MOCK_NON_CONST_METHOD_EXT( my_method, 0, void(), tag1 )
MOCK_CONST_METHOD_EXT( my_method, 0, void(), tag_2 )
};
}
MOCK_BASE_CLASS(my_const_ambiguited_mock, my_const_ambiguited_interface){
MOCK_NON_CONST_METHOD_EXT(my_method, 0, void(), tag1) MOCK_CONST_METHOD_EXT(my_method, 0, void(), tag_2)};
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_object_method_const_disambiguation, mock_error_fixture)
{
@ -132,12 +116,8 @@ BOOST_FIXTURE_TEST_CASE( mock_object_method_const_disambiguation, mock_error_fix
CHECK_ERROR(const_mock.my_method(), "unexpected call", 1, "?.my_const_ambiguited_mock::tag_2()");
}
namespace
{
MOCK_CLASS( my_undefined_mock )
{
MOCK_METHOD_EXT( m, 1, void( undefined& ), t )
};
namespace {
MOCK_CLASS(my_undefined_mock){MOCK_METHOD_EXT(m, 1, void(undefined&), t)};
}
BOOST_FIXTURE_TEST_CASE(mock_object_method_with_declared_but_not_defined_parameter_is_valid, mock_error_fixture)
@ -146,8 +126,7 @@ BOOST_FIXTURE_TEST_CASE( mock_object_method_with_declared_but_not_defined_parame
MOCK_EXPECT(mock.t);
}
namespace
{
namespace {
MOCK_FUNCTOR(gf, int(float, const std::string&));
}
@ -172,13 +151,12 @@ BOOST_FIXTURE_TEST_CASE( mock_functor_in_function_is_supported, mock_error_fixtu
CHECK_CALLS(1);
}
namespace
{
namespace {
struct functor_fixture : mock_error_fixture
{
MOCK_FUNCTOR(f, int(float, const std::string&));
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_functor_in_fixture_is_supported, functor_fixture)
{
@ -187,8 +165,7 @@ BOOST_FIXTURE_TEST_CASE( mock_functor_in_fixture_is_supported, functor_fixture )
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
struct my_template_mock
{
@ -196,7 +173,7 @@ namespace
MOCK_METHOD_EXT_TPL(my_method, 2, void(T, std::string), my_tpl_tag)
MOCK_METHOD_EXT_TPL(my_other_method, 0, void(), my_other_tag)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mocking_a_template_class_method_is_supported, mock_error_fixture)
{
@ -207,23 +184,19 @@ BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_method_is_supported, mock_erro
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
struct my_template_base_class
{
virtual ~my_template_base_class()
{}
virtual ~my_template_base_class() {}
virtual void my_method(T) = 0;
virtual void my_other_method() = 0;
};
template<typename T>
MOCK_BASE_CLASS( my_template_base_class_mock, my_template_base_class< T > )
{
MOCK_METHOD_EXT_TPL( my_method, 1, void( T ), my_method )
MOCK_METHOD_EXT_TPL( my_other_method, 0, void(), my_other_method )
};
}
MOCK_BASE_CLASS(my_template_base_class_mock,
my_template_base_class<T>){MOCK_METHOD_EXT_TPL(my_method, 1, void(T), my_method)
MOCK_METHOD_EXT_TPL(my_other_method, 0, void(), my_other_method)};
} // namespace
BOOST_FIXTURE_TEST_CASE(mocking_a_template_base_class_method_is_supported, mock_error_fixture)
{
@ -234,56 +207,42 @@ BOOST_FIXTURE_TEST_CASE( mocking_a_template_base_class_method_is_supported, mock
CHECK_CALLS(1);
}
namespace
{
namespace {
class my_observer : boost::noncopyable
{
public:
virtual ~my_observer()
{}
virtual ~my_observer() {}
virtual void notify(int value) = 0;
};
class my_manager : boost::noncopyable
{
public:
virtual ~my_manager()
{}
virtual ~my_manager() {}
virtual my_observer& get_observer() const = 0;
};
class my_subject : boost::noncopyable
{
public:
explicit my_subject( my_manager& f )
: o_( f.get_observer() )
, value_( 0 )
{}
void increment()
{
o_.notify( ++value_ );
}
explicit my_subject(my_manager& f) : o_(f.get_observer()), value_(0) {}
void increment() { o_.notify(++value_); }
private:
my_observer& o_;
int value_;
};
MOCK_BASE_CLASS( my_mock_observer, my_observer )
{
MOCK_METHOD( notify, 1 )
};
MOCK_BASE_CLASS(my_mock_observer, my_observer){MOCK_METHOD(notify, 1)};
MOCK_BASE_CLASS( my_mock_manager, my_manager )
{
MOCK_METHOD( get_observer, 0 )
};
MOCK_BASE_CLASS(my_mock_manager, my_manager){MOCK_METHOD(get_observer, 0)};
struct fixture : mock_error_fixture
{
my_mock_manager manager;
my_mock_observer observer;
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(basic_mock_object_collaboration_usage, fixture)
{
@ -298,12 +257,8 @@ BOOST_FIXTURE_TEST_CASE( basic_mock_object_collaboration_usage, fixture )
CHECK_CALLS(4);
}
namespace
{
MOCK_CLASS( my_constructed_class )
{
MOCK_CONSTRUCTOR( my_constructed_class, 2, ( int, const std::string& ), constructor )
};
namespace {
MOCK_CLASS(my_constructed_class){MOCK_CONSTRUCTOR(my_constructed_class, 2, (int, const std::string&), constructor)};
}
BOOST_FIXTURE_TEST_CASE(mocking_a_constructor, mock_error_fixture)
@ -314,13 +269,10 @@ BOOST_FIXTURE_TEST_CASE( mocking_a_constructor, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
MOCK_CLASS( my_constructed_template_class )
{
MOCK_CONSTRUCTOR_TPL( my_constructed_template_class, 2, ( T, const std::string& ), constructor )
};
MOCK_CLASS(my_constructed_template_class){
MOCK_CONSTRUCTOR_TPL(my_constructed_template_class, 2, (T, const std::string&), constructor)};
}
BOOST_FIXTURE_TEST_CASE(mocking_a_template_class_constructor, mock_error_fixture)
@ -331,12 +283,8 @@ BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_constructor, mock_error_fixtur
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( my_destroyed_class )
{
MOCK_DESTRUCTOR( ~my_destroyed_class, destructor )
};
namespace {
MOCK_CLASS(my_destroyed_class){MOCK_DESTRUCTOR(~my_destroyed_class, destructor)};
}
BOOST_FIXTURE_TEST_CASE(mocking_a_destructor, mock_error_fixture)
@ -351,14 +299,10 @@ BOOST_FIXTURE_TEST_CASE( mocking_a_destructor, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture)
{
CHECK_ERROR(
try
{
try {
my_destroyed_class c;
throw std::runtime_error("should not crash");
}
catch( std::runtime_error& )
{
},
} catch(std::runtime_error&){},
"unexpected call", 0, "?.my_destroyed_class::destructor()");
}
@ -376,12 +320,8 @@ BOOST_FIXTURE_TEST_CASE( failed_sequence_in_mocked_destructor_does_not_throw, mo
"sequence failed", 1, "c.my_destroyed_class::destructor()\n. once()");
}
namespace
{
MOCK_CLASS( boost_optional )
{
MOCK_METHOD_EXT( method, 0, boost::optional< my_observer& >(), tag )
};
namespace {
MOCK_CLASS(boost_optional){MOCK_METHOD_EXT(method, 0, boost::optional<my_observer&>(), tag)};
}
BOOST_FIXTURE_TEST_CASE(boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture)
@ -393,8 +333,7 @@ BOOST_FIXTURE_TEST_CASE( boost_optional_on_base_class_reference_as_return_type_i
CHECK_CALLS(1);
}
namespace
{
namespace {
bool serialized = false;
struct custom_argument
@ -418,7 +357,7 @@ namespace
return s;
}
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(constraints_and_arguments_are_serialized_lazily, mock_error_fixture)
{
@ -429,8 +368,7 @@ BOOST_FIXTURE_TEST_CASE( constraints_and_arguments_are_serialized_lazily, mock_e
CHECK_CALLS(1);
}
namespace
{
namespace {
struct custom_constraint_with_non_const_operator
{
template<typename Actual>
@ -439,12 +377,13 @@ namespace
return actual == 42;
}
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(custom_constraint_function_operator_does_not_need_to_be_const, mock_error_fixture)
{
MOCK_FUNCTOR(f, void(float));
MOCK_EXPECT( f ).with( mock::constraint< custom_constraint_with_non_const_operator >( custom_constraint_with_non_const_operator() ) );
MOCK_EXPECT(f).with(
mock::constraint<custom_constraint_with_non_const_operator>(custom_constraint_with_non_const_operator()));
f(42);
CHECK_CALLS(1);
}
@ -459,8 +398,7 @@ BOOST_FIXTURE_TEST_CASE( boost_reference_wrapper_is_supported_in_value_constrain
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
void nothing(T)
{}
@ -469,44 +407,40 @@ namespace
{
MOCK_CONST_METHOD_EXT(my_method, 0, void(), my_method)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(member_pointer_on_mock_method_is_valid, mock_error_fixture)
{
nothing(&member_pointer_mock_class::my_method);
}
namespace
{
namespace {
MOCK_FUNCTION(free_function, 1, void(int), free_function)
}
BOOST_FIXTURE_TEST_CASE(a_free_function_can_be_mocked, mock_error_fixture)
{
MOCK_EXPECT(free_function).once();
CHECK_ERROR(
BOOST_CHECK( ! MOCK_VERIFY( free_function ) ),
"verification failed", 0, "free_function\n. once().with( any )" );
CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(free_function)), "verification failed", 0,
"free_function\n. once().with( any )");
free_function(42);
CHECK_CALLS(1);
BOOST_CHECK(MOCK_VERIFY(free_function));
MOCK_RESET(free_function);
}
namespace
{
namespace {
struct some_class : mock::object
{
MOCK_STATIC_METHOD(some_static_method, 1, void(int), some_static_method)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(a_static_method_can_be_mocked, mock_error_fixture)
{
MOCK_EXPECT(some_class::some_static_method).once();
CHECK_ERROR(
BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ),
"verification failed", 0, "some_class::some_static_method\n. once().with( any )" );
CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_class::some_static_method)), "verification failed", 0,
"some_class::some_static_method\n. once().with( any )");
some_class::some_static_method(42);
CHECK_CALLS(1);
BOOST_CHECK(MOCK_VERIFY(some_class::some_static_method));
@ -518,27 +452,24 @@ BOOST_FIXTURE_TEST_CASE( a_static_method_is_not_reset_when_resetting_an_instance
MOCK_EXPECT(some_class::some_static_method).once();
some_class c;
mock::reset(c);
CHECK_ERROR(
BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ),
"verification failed", 0, "some_class::some_static_method\n. once().with( any )" );
CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_class::some_static_method)), "verification failed", 0,
"some_class::some_static_method\n. once().with( any )");
MOCK_RESET(some_class::some_static_method);
}
namespace
{
namespace {
template<typename T>
struct some_template_class
{
MOCK_STATIC_METHOD_TPL(some_static_method, 1, void(T), some_static_method)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(a_static_method_in_a_template_class_can_be_mocked, mock_error_fixture)
{
MOCK_EXPECT(some_template_class<int>::some_static_method).once();
CHECK_ERROR(
BOOST_CHECK( ! MOCK_VERIFY( some_template_class< int >::some_static_method ) ),
"verification failed", 0, "some_template_class< int >::some_static_method\n. once().with( any )" );
CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_template_class<int>::some_static_method)), "verification failed", 0,
"some_template_class< int >::some_static_method\n. once().with( any )");
some_template_class<int>::some_static_method(42);
BOOST_CHECK(mock::verify());
BOOST_CHECK(MOCK_VERIFY(some_template_class<int>::some_static_method));
@ -546,13 +477,12 @@ BOOST_FIXTURE_TEST_CASE( a_static_method_in_a_template_class_can_be_mocked, mock
CHECK_CALLS(1);
}
namespace
{
namespace {
MOCK_CLASS(mock_class)
{
MOCK_METHOD_EXT(m, 0, void(), t);
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(resetting_referenced_mock_class_does_not_crash, mock_error_fixture)
{
@ -565,13 +495,12 @@ BOOST_FIXTURE_TEST_CASE( resetting_referenced_mock_class_does_not_crash, mock_er
mock::reset();
}
namespace
{
namespace {
MOCK_CLASS(mock_class2)
{
MOCK_METHOD_EXT(m, 0, mock_class2(), t);
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture)
{
@ -582,21 +511,18 @@ BOOST_FIXTURE_TEST_CASE( resetting_self_referenced_mock_class_does_not_crash, mo
mock::reset();
}
namespace
{
namespace {
template<typename T1, typename T2>
struct my_base
{};
MOCK_BASE_CLASS( my_comma_mock, my_base< int BOOST_PP_COMMA() int > )
{};
}
MOCK_BASE_CLASS(my_comma_mock, my_base<int BOOST_PP_COMMA() int>){};
} // namespace
#ifdef MOCK_THREAD_SAFE
# include <boost/thread.hpp>
namespace
{
namespace {
void create_class()
{
my_mock m;
@ -604,11 +530,10 @@ namespace
try
{
m.my_method(3);
}
catch( ... )
} catch(...)
{}
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_class_creation_is_thread_safe, mock_error_fixture)
{
@ -619,8 +544,7 @@ BOOST_FIXTURE_TEST_CASE( mock_class_creation_is_thread_safe, mock_error_fixture
CHECK_CALLS(100);
}
namespace
{
namespace {
void create_functor(int i)
{
mock::detail::functor<void(int)> f;
@ -630,11 +554,10 @@ namespace
try
{
f(i);
}
catch( ... )
} catch(...)
{}
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_functor_creation_is_thread_safe, mock_error_fixture)
{
@ -645,14 +568,13 @@ BOOST_FIXTURE_TEST_CASE( mock_functor_creation_is_thread_safe, mock_error_fixtur
CHECK_CALLS(100);
}
namespace
{
namespace {
void iterate(my_mock& m)
{
MOCK_EXPECT(m.my_tag).once().with(3).returns(42);
BOOST_CHECK_EQUAL(42, m.my_method(3));
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_class_is_thread_safe, mock_error_fixture)
{
@ -666,14 +588,13 @@ BOOST_FIXTURE_TEST_CASE( mock_class_is_thread_safe, mock_error_fixture )
#endif // MOCK_THREAD_SAFE
namespace
{
namespace {
MOCK_CLASS(my_multi_mock)
{
MOCK_METHOD_EXT(m1, 1, void(int), m1);
MOCK_METHOD_EXT(m2, 2, void(int, int), m2);
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_method_accepts_multi_constraint, mock_error_fixture)
{
@ -685,8 +606,7 @@ BOOST_FIXTURE_TEST_CASE( mock_method_accepts_multi_constraint, mock_error_fixtur
CHECK_CALLS(2);
}
namespace
{
namespace {
struct my_polymorphic_constraint
{
template<typename T1, typename T2>
@ -695,7 +615,7 @@ namespace
return true;
}
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture)
{
@ -711,10 +631,7 @@ BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_action, mock_er
{
MOCK_FUNCTOR(f, void(std::unique_ptr<int>));
std::unique_ptr<int> p;
MOCK_EXPECT( f ).once().calls(
[]( std::unique_ptr< int > )
{
} );
MOCK_EXPECT(f).once().calls([](std::unique_ptr<int>) {});
f(std::unique_ptr<int>(new int(7)));
CHECK_CALLS(1);
}

169
test/test_log.cpp
View file

@ -7,17 +7,17 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include <turtle/log.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/assign.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/weak_ptr.hpp>
#ifdef BOOST_MSVC
# pragma warning(push, 0)
#endif
#include <boost/phoenix/phoenix.hpp>
#include <boost/phoenix/bind.hpp>
#include <boost/phoenix/phoenix.hpp>
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
@ -26,14 +26,13 @@
# include <boost/lambda/lambda.hpp>
#endif
#include <boost/bind.hpp>
#include <vector>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <vector>
namespace
{
namespace {
template<typename T>
std::string to_string(const T& t)
{
@ -48,7 +47,7 @@ namespace
s << mock::format(t);
return s.str();
}
}
} // namespace
BOOST_AUTO_TEST_CASE(pointer_yields_its_value_when_serialized)
{
@ -81,34 +80,31 @@ BOOST_AUTO_TEST_CASE( strings_are_serialized_with_double_quotes )
BOOST_CHECK_EQUAL("\"string\"", to_string(std::string("string")));
}
namespace
{
namespace {
struct non_serializable
{};
}
} // namespace
BOOST_AUTO_TEST_CASE(non_serializable_type_yields_a_question_mark_when_serialized)
{
BOOST_CHECK_EQUAL("?", to_string(non_serializable()));
}
namespace
{
namespace {
struct serializable
{};
std::ostream& operator<<(std::ostream& s, const serializable&)
{
return s << "serializable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(serializable_type_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("serializable", to_string(serializable()));
}
namespace
{
namespace {
struct streamable
{};
BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const streamable&)
@ -120,15 +116,14 @@ namespace
{
return s << "streamable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(streamable_type_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("streamable", to_string(streamable()));
}
namespace
{
namespace {
struct mock_streamable
{};
BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const mock_streamable&)
@ -136,25 +131,23 @@ namespace
BOOST_FAIL("should not have been called");
return s;
}
}
namespace mock
{
} // namespace
namespace mock {
stream& operator<<(stream& s, const mock_streamable&)
{
return s << "mock_streamable";
}
} // mock
} // namespace mock
BOOST_AUTO_TEST_CASE(mock_streamable_type_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("mock_streamable", to_string(mock_streamable()));
}
namespace
{
namespace {
struct derived_from_serializable : serializable
{};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_derived_from_serializable_yields_a_question_mark_when_serialized)
{
@ -165,11 +158,10 @@ BOOST_AUTO_TEST_CASE( type_derived_from_serializable_yields_a_question_mark_when
#endif
}
namespace
{
namespace {
struct derived_from_streamable : streamable
{};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_derived_from_streamable_yields_a_question_mark_when_serialized)
{
@ -180,79 +172,77 @@ BOOST_AUTO_TEST_CASE( type_derived_from_streamable_yields_a_question_mark_when_s
#endif
}
#ifndef MOCK_USE_CONVERSIONS // all this does not compile with conversions activated, which is precisely the purpose of having this compilation flag
#ifndef MOCK_USE_CONVERSIONS // all this does not compile with conversions activated, which is precisely the purpose of
// having this compilation flag
namespace
{
namespace {
struct convertible_to_base
{
operator int() const;
};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_convertible_to_base_yields_a_question_mark_when_serialized)
{
BOOST_CHECK_EQUAL("?", to_string(convertible_to_base()));
}
namespace
{
namespace {
struct convertible_to_serializable
{
operator serializable() const;
};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_convertible_to_serializable_yields_a_question_mark_when_serialized)
{
BOOST_CHECK_EQUAL("?", to_string(convertible_to_serializable()));
}
namespace
{
namespace {
struct convertible_to_streamable
{
operator streamable() const;
};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_convertible_to_streamable_yields_a_question_mark_when_serialized)
{
BOOST_CHECK_EQUAL("?", to_string(convertible_to_streamable()));
}
namespace
{
namespace {
struct ambiguous_convertible
{
operator float() const;
operator int() const;
operator serializable() const;
operator streamable() const;
template< typename T > operator T() const;
template<typename T>
operator T() const;
};
}
} // namespace
BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_yields_a_question_mark_when_serialized)
{
BOOST_CHECK_EQUAL("?", to_string(ambiguous_convertible()));
}
namespace
{
namespace {
struct ambiguous_convertible_serializable
{
operator float() const;
operator int() const;
operator serializable() const;
operator streamable() const;
template< typename T > operator T() const;
template<typename T>
operator T() const;
};
std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_serializable&)
{
return s << "ambiguous_convertible_serializable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(type_convertible_serializable_yields_its_value_when_serialized)
{
@ -261,15 +251,15 @@ BOOST_AUTO_TEST_CASE( type_convertible_serializable_yields_its_value_when_serial
#endif // MOCK_USE_CONVERSIONS
namespace
{
namespace {
struct ambiguous_convertible_streamable
{
operator float() const;
operator int() const;
operator serializable() const;
operator streamable() const;
template< typename T > operator T() const;
template<typename T>
operator T() const;
};
BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_streamable&)
{
@ -280,44 +270,42 @@ namespace
{
return s << "ambiguous_convertible_streamable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_streamable_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("ambiguous_convertible_streamable", to_string(ambiguous_convertible_streamable()));
}
namespace
{
namespace {
struct ambiguous_convertible_mock_streamable
{
operator float() const;
operator int() const;
operator serializable() const;
operator streamable() const;
template< typename T > operator T() const;
template<typename T>
operator T() const;
};
BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_mock_streamable&)
{
BOOST_FAIL("should not have been called");
return s;
}
}
namespace mock
{
} // namespace
namespace mock {
stream& operator<<(stream& s, const ambiguous_convertible_mock_streamable&)
{
return s << "ambiguous_convertible_mock_streamable";
}
} // mock
} // namespace mock
BOOST_AUTO_TEST_CASE(type_ambiguous_convertible_mock_streamable_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("ambiguous_convertible_mock_streamable", to_string(ambiguous_convertible_mock_streamable()));
}
namespace
{
namespace {
template<typename T>
struct template_serializable
{};
@ -326,15 +314,14 @@ namespace
{
return s << "template_serializable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(template_type_serializable_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("template_serializable", to_string(template_serializable<int>()));
}
namespace
{
namespace {
template<typename T>
struct template_streamable
{};
@ -349,15 +336,14 @@ namespace
{
return s << "template_streamable";
}
}
} // namespace
BOOST_AUTO_TEST_CASE(template_template_streamable_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("template_streamable", to_string(template_streamable<int>()));
}
namespace
{
namespace {
template<typename T>
struct template_mock_streamable
{};
@ -367,15 +353,14 @@ namespace
BOOST_FAIL("should not have been called");
return s;
}
}
namespace mock
{
} // namespace
namespace mock {
template<typename T>
stream& operator<<(stream& s, const template_mock_streamable<T>&)
{
return s << "template_mock_streamable";
}
} // mock
} // namespace mock
BOOST_AUTO_TEST_CASE(template_mock_streamable_yields_its_value_when_serialized)
{
@ -528,11 +513,9 @@ BOOST_AUTO_TEST_CASE( boost_reference_wrappers_are_serialized )
BOOST_CHECK_EQUAL("\"string\"", to_string(boost::cref("string")));
}
namespace
{
void callable_builtin()
{}
}
namespace {
void callable_builtin() {}
} // namespace
BOOST_AUTO_TEST_CASE(callable_builtin_yields_a_question_mark_when_serialized)
{
@ -540,55 +523,49 @@ BOOST_AUTO_TEST_CASE( callable_builtin_yields_a_question_mark_when_serialized )
BOOST_CHECK_EQUAL("?", to_string(&callable_builtin));
}
namespace
{
namespace {
struct serialized_using_format
{};
std::ostream& operator<<(std::ostream& s, const serialized_using_format&)
{
return s << mock::format("string");
}
}
} // namespace
BOOST_AUTO_TEST_CASE(type_can_use_format_when_serialized)
{
BOOST_CHECK_EQUAL("\"string\"", to_string(serialized_using_format()));
}
namespace
{
namespace {
struct streamed_using_format
{};
mock::stream& operator<<(mock::stream& s, const streamed_using_format&)
{
return s << mock::format("string");
}
}
} // namespace
BOOST_AUTO_TEST_CASE(type_can_use_format_when_streamed)
{
BOOST_CHECK_EQUAL("\"string\"", to_string(streamed_using_format()));
}
namespace
{
namespace {
struct std_string_streamed
{};
mock::stream& operator<<(mock::stream& s, const std_string_streamed&)
{
return s << std::string("string");
}
}
} // namespace
BOOST_AUTO_TEST_CASE(std_string_streamed_is_not_a_container)
{
BOOST_CHECK_EQUAL("string", to_string(std_string_streamed()));
}
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename T>
struct template_serializable
{};
@ -597,18 +574,14 @@ namespace detail
{
return s << "mock::detail::template_serializable";
}
}
} // mock
}} // namespace mock::detail
BOOST_AUTO_TEST_CASE(mock_detail_template_type_serializable_yields_its_value_when_serialized)
{
BOOST_CHECK_EQUAL("mock::detail::template_serializable", to_string(mock::detail::template_serializable<int>()));
}
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
template<typename T>
struct template_streamable
{};
@ -623,8 +596,7 @@ namespace detail
{
return s << "mock::detail::template_streamable";
}
}
} // mock
}} // namespace mock::detail
BOOST_AUTO_TEST_CASE(mock_detail_template_template_streamable_yields_its_value_when_serialized)
{
@ -636,13 +608,12 @@ BOOST_AUTO_TEST_CASE( unsigned_char_is_serialized_as_int )
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(static_cast<int>('a')), to_string<unsigned char>('a'));
}
namespace
{
namespace {
bool some_function()
{
return false;
}
}
} // namespace
BOOST_AUTO_TEST_CASE(boost_phoenix_functor_yields_question_mark_when_serialized)
{

14
test/test_matcher.cpp
View file

@ -9,14 +9,13 @@
#include <turtle/detail/function.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
template<typename Expected, typename Actual>
bool match(Expected expected, Actual actual)
{
return mock::matcher<Actual, Expected>(expected)(actual);
}
}
} // namespace
BOOST_AUTO_TEST_CASE(int_and_int_can_be_compared)
{
@ -32,13 +31,10 @@ BOOST_AUTO_TEST_CASE( ref_to_int_and_int_can_be_compared )
BOOST_CHECK(!match(4, boost::cref(i)));
}
namespace
{
namespace {
struct fixture
{
fixture()
: text( "same text" )
, actual( text.c_str() )
fixture() : text("same text"), actual(text.c_str())
{
const char* static_string = "same text";
BOOST_REQUIRE(actual != static_string);
@ -47,7 +43,7 @@ namespace
std::string text;
const char* actual;
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_const_char_pointer_can_be_compared, fixture)
{

7
test/test_max_args.cpp
View file

@ -8,19 +8,18 @@
#include "mock_error.hpp"
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/test/auto_unit_test.hpp>
#define IDENTITY(z, n, d) d
namespace
{
namespace {
struct my_custom_mock
{
MOCK_METHOD_EXT(method, MOCK_MAX_ARGS, void(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, int)), tag)
MOCK_METHOD_EXT(method2, MOCK_MAX_ARGS, int(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, int)), tag_2)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(call_mock_method_with_max_number_of_args, mock_error_fixture)
{

206
test/test_mock.cpp
View file

@ -8,22 +8,18 @@
#include "mock_error.hpp"
#include <turtle/mock.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
template<typename T>
void my_function(T& t)
{
t.my_method("some parameter");
}
MOCK_CLASS( mock_class )
{
MOCK_METHOD_EXT( my_method, 1, void( const std::string& ), my_tag )
};
}
MOCK_CLASS(mock_class){MOCK_METHOD_EXT(my_method, 1, void(const std::string&), my_tag)};
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_object_for_static_polymorphism, mock_error_fixture)
{
@ -33,12 +29,8 @@ BOOST_FIXTURE_TEST_CASE( mock_object_for_static_polymorphism, mock_error_fixture
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( mock_class_with_operator )
{
MOCK_CONST_METHOD_EXT( operator+=, 1, mock_class_with_operator&( int ), addition )
};
namespace {
MOCK_CLASS(mock_class_with_operator){MOCK_CONST_METHOD_EXT(operator+=, 1, mock_class_with_operator &(int), addition)};
}
BOOST_FIXTURE_TEST_CASE(mock_addition_operator, mock_error_fixture)
@ -49,12 +41,8 @@ BOOST_FIXTURE_TEST_CASE( mock_addition_operator, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( mock_class_with_conversion_operator )
{
MOCK_CONVERSION_OPERATOR( operator, int, conversion )
};
namespace {
MOCK_CLASS(mock_class_with_conversion_operator){MOCK_CONVERSION_OPERATOR(operator, int, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_conversion_operator, mock_error_fixture)
@ -65,13 +53,9 @@ BOOST_FIXTURE_TEST_CASE( mock_conversion_operator, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
MOCK_CLASS( mock_template_class_with_conversion_operator )
{
MOCK_CONVERSION_OPERATOR_TPL( operator, T, conversion )
};
MOCK_CLASS(mock_template_class_with_conversion_operator){MOCK_CONVERSION_OPERATOR_TPL(operator, T, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_template_conversion_operator, mock_error_fixture)
@ -82,12 +66,8 @@ BOOST_FIXTURE_TEST_CASE( mock_template_conversion_operator, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( mock_class_with_const_conversion_operator )
{
MOCK_CONST_CONVERSION_OPERATOR( operator, int, conversion )
};
namespace {
MOCK_CLASS(mock_class_with_const_conversion_operator){MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_const_conversion_operator, mock_error_fixture)
@ -99,12 +79,8 @@ BOOST_FIXTURE_TEST_CASE( mock_const_conversion_operator, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( mock_class_with_non_const_conversion_operator )
{
MOCK_CONST_CONVERSION_OPERATOR( operator, int, conversion )
};
namespace {
MOCK_CLASS(mock_class_with_non_const_conversion_operator){MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_non_const_conversion_operator, mock_error_fixture)
@ -116,13 +92,10 @@ BOOST_FIXTURE_TEST_CASE( mock_non_const_conversion_operator, mock_error_fixture
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
MOCK_CLASS( mock_template_class_with_const_conversion_operator )
{
MOCK_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion )
};
MOCK_CLASS(mock_template_class_with_const_conversion_operator){
MOCK_CONST_CONVERSION_OPERATOR_TPL(operator, T, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_template_const_conversion_operator, mock_error_fixture)
@ -133,13 +106,10 @@ BOOST_FIXTURE_TEST_CASE( mock_template_const_conversion_operator, mock_error_fix
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
MOCK_CLASS( mock_template_class_with_non_const_conversion_operator )
{
MOCK_NON_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion )
};
MOCK_CLASS(mock_template_class_with_non_const_conversion_operator){
MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(operator, T, conversion)};
}
BOOST_FIXTURE_TEST_CASE(mock_template_non_const_conversion_operator, mock_error_fixture)
@ -150,13 +120,9 @@ BOOST_FIXTURE_TEST_CASE( mock_template_non_const_conversion_operator, mock_error
CHECK_CALLS(1);
}
namespace
{
MOCK_CLASS( my_mock )
{
MOCK_CONST_METHOD_EXT( my_method, 1, void( int ), my_method )
MOCK_CONST_METHOD_EXT( my_method_2, 1, void( int ), my_method_2 )
};
namespace {
MOCK_CLASS(my_mock){MOCK_CONST_METHOD_EXT(my_method, 1, void(int), my_method)
MOCK_CONST_METHOD_EXT(my_method_2, 1, void(int), my_method_2)};
}
BOOST_FIXTURE_TEST_CASE(MOCK_CONST_METHOD_EXT_macro_defines_a_bindable_method, mock_error_fixture)
@ -185,8 +151,7 @@ BOOST_FIXTURE_TEST_CASE( MOCK_EXPECT_macro, mock_error_fixture )
CHECK_CALLS(1);
}
namespace
{
namespace {
template<typename T>
std::string to_string(const T& t)
{
@ -194,7 +159,7 @@ namespace
s << t;
return s.str();
}
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_object_is_named, mock_error_fixture)
{
@ -247,16 +212,16 @@ BOOST_FIXTURE_TEST_CASE( mock_object_const_shared_pointer_is_named, mock_error_f
BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method)));
}
namespace
{
namespace {
struct my_custom_mock
{
MOCK_METHOD_EXT(my_method, 0, void(), my_tag)
MOCK_METHOD_EXT(my_method_2, 0, void(), my_tag_2)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheriting_from_object_is_named, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_and_without_inheriting_from_object_is_named,
mock_error_fixture)
{
my_custom_mock m;
BOOST_CHECK_EQUAL("?.my_custom_mock::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag)));
@ -267,14 +232,13 @@ BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheritin
BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_HELPER(m.my_tag)));
}
namespace
{
namespace {
struct my_custom_mock_object : mock::object
{
MOCK_METHOD_EXT(my_method, 0, void(), my_tag)
MOCK_METHOD_EXT(my_method_2, 0, void(), my_tag_2)
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_is_named, mock_error_fixture)
{
@ -293,14 +257,13 @@ BOOST_FIXTURE_TEST_CASE( mock_functor, mock_error_fixture )
MOCK_FUNCTOR(f2, int(const std::string&));
}
namespace
{
namespace {
template<typename T>
struct tpl_functor_class
{
MOCK_FUNCTOR_TPL(f, void(T));
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(mock_functor_reset, mock_error_fixture)
{
@ -322,8 +285,7 @@ BOOST_FIXTURE_TEST_CASE( mock_functor_is_named, mock_error_fixture )
BOOST_CHECK_EQUAL("f", to_string(MOCK_HELPER(f)));
}
namespace
{
namespace {
MOCK_FUNCTION(mock_function, 1, float(int), mock_function)
}
@ -332,12 +294,8 @@ BOOST_FIXTURE_TEST_CASE( mock_function_is_named, mock_error_fixture )
BOOST_CHECK_EQUAL("mock_function", to_string(MOCK_HELPER(mock_function)));
}
namespace
{
MOCK_CLASS( static_function_class )
{
MOCK_STATIC_METHOD( f, 1, float( int ), f )
};
namespace {
MOCK_CLASS(static_function_class){MOCK_STATIC_METHOD(f, 1, float(int), f)};
}
BOOST_FIXTURE_TEST_CASE(mock_static_function_is_named, mock_error_fixture)
@ -345,8 +303,7 @@ BOOST_FIXTURE_TEST_CASE( mock_static_function_is_named, mock_error_fixture )
BOOST_CHECK_EQUAL("static_function_class::f", to_string(MOCK_HELPER(static_function_class::f)));
}
namespace
{
namespace {
MOCK_CLASS(round_parenthesized_signature)
{
MOCK_METHOD_EXT(m0, 0, BOOST_IDENTITY_TYPE((std::map<int, int>())), m0)
@ -354,84 +311,57 @@ namespace
MOCK_FUNCTOR(f0, BOOST_IDENTITY_TYPE((std::map<int, int>())));
};
MOCK_FUNCTION(fun0, 0, BOOST_IDENTITY_TYPE((std::map<int, int>())), fun0)
}
} // namespace
#ifdef MOCK_VARIADIC_MACROS
namespace
{
namespace {
struct base
{
virtual ~base()
{}
virtual ~base() {}
virtual void m1() = 0;
virtual void m10() const = 0;
virtual void m11() = 0;
};
MOCK_BASE_CLASS( variadic, base )
{
MOCK_METHOD( m1, 0 )
MOCK_METHOD( m2, 0, void() )
MOCK_METHOD( m3, 0, void(), m3 )
MOCK_CONST_METHOD( m10, 0 )
MOCK_CONST_METHOD( m4, 0, void() )
MOCK_CONST_METHOD( m5, 0, void(), m5 )
MOCK_NON_CONST_METHOD( m11, 0 )
MOCK_NON_CONST_METHOD( m6, 0, void() )
MOCK_NON_CONST_METHOD( m7, 0, void(), m7 )
MOCK_STATIC_METHOD( m8, 0, void() )
MOCK_STATIC_METHOD( m9, 0, void(), m9 )
};
MOCK_BASE_CLASS(variadic, base){MOCK_METHOD(m1, 0) MOCK_METHOD(m2, 0, void()) MOCK_METHOD(m3, 0, void(), m3)
MOCK_CONST_METHOD(m10, 0) MOCK_CONST_METHOD(m4, 0, void())
MOCK_CONST_METHOD(m5, 0, void(), m5) MOCK_NON_CONST_METHOD(m11, 0)
MOCK_NON_CONST_METHOD(m6, 0, void()) MOCK_NON_CONST_METHOD(m7, 0, void(), m7)
MOCK_STATIC_METHOD(m8, 0, void()) MOCK_STATIC_METHOD(m9, 0, void(), m9)};
template<typename T>
MOCK_BASE_CLASS( variadic_tpl, base )
{
MOCK_METHOD( m1, 0, void() )
MOCK_METHOD_TPL( m2, 0, T() )
MOCK_METHOD_TPL( m3, 0, T(), m3 )
MOCK_CONST_METHOD_TPL( m4, 0, T() )
MOCK_CONST_METHOD_TPL( m5, 0, T(), m5 )
MOCK_NON_CONST_METHOD_TPL( m6, 0, T() )
MOCK_NON_CONST_METHOD_TPL( m7, 0, T(), m7 )
MOCK_STATIC_METHOD_TPL( m8, 0, T() )
MOCK_STATIC_METHOD_TPL( m9, 0, T(), m9 )
};
MOCK_BASE_CLASS(variadic_tpl, base){MOCK_METHOD(m1, 0, void()) MOCK_METHOD_TPL(m2, 0, T())
MOCK_METHOD_TPL(m3, 0, T(), m3) MOCK_CONST_METHOD_TPL(m4, 0, T())
MOCK_CONST_METHOD_TPL(m5, 0, T(), m5) MOCK_NON_CONST_METHOD_TPL(m6, 0, T())
MOCK_NON_CONST_METHOD_TPL(m7, 0, T(), m7) MOCK_STATIC_METHOD_TPL(m8, 0, T())
MOCK_STATIC_METHOD_TPL(m9, 0, T(), m9)};
MOCK_BASE_CLASS( comma_base, std::map< int, int > )
{};
MOCK_BASE_CLASS(comma_base, std::map<int, int>){};
MOCK_FUNCTION(fun1, 0, void())
MOCK_FUNCTION(fun2, 0, void(), fun2)
MOCK_FUNCTION(fun3, 0, BOOST_IDENTITY_TYPE((std::map<int, int>())))
MOCK_FUNCTOR(f_variadic, std::map<int, int>());
}
} // namespace
#else // MOCK_VARIADIC_MACROS
namespace
{
namespace {
struct base
{
virtual ~base()
{}
virtual ~base() {}
virtual void m1() = 0;
};
MOCK_BASE_CLASS( derived, base )
{
MOCK_METHOD( m1, 0 )
};
MOCK_BASE_CLASS(derived, base){MOCK_METHOD(m1, 0)};
template<typename T>
MOCK_BASE_CLASS( derived_tpl, base )
{
MOCK_METHOD_EXT( m1, 0, void(), m1 )
};
}
MOCK_BASE_CLASS(derived_tpl, base){MOCK_METHOD_EXT(m1, 0, void(), m1)};
} // namespace
#endif // MOCK_VARIADIC_MACROS
@ -441,28 +371,22 @@ namespace
# define MOCK_STDCALL
#endif
namespace stdcall
{
namespace stdcall {
struct base
{
virtual ~base()
{}
virtual ~base() {}
virtual void MOCK_STDCALL m1() = 0;
};
MOCK_BASE_CLASS( derived, base )
{
MOCK_CONSTRUCTOR( MOCK_STDCALL derived, 0, (), derived )
MOCK_DESTRUCTOR( MOCK_STDCALL ~derived, derived )
MOCK_CONVERSION_OPERATOR( MOCK_STDCALL operator, int, to_int )
MOCK_METHOD_EXT( MOCK_STDCALL m1, 0, void(), m1 )
MOCK_BASE_CLASS(derived, base){
MOCK_CONSTRUCTOR(MOCK_STDCALL derived, 0, (), derived) MOCK_DESTRUCTOR(MOCK_STDCALL ~derived, derived)
MOCK_CONVERSION_OPERATOR(MOCK_STDCALL operator, int, to_int) MOCK_METHOD_EXT(MOCK_STDCALL m1, 0, void(), m1)
MOCK_METHOD_EXT(MOCK_STDCALL m2, 0, void(), m2)
#ifdef MOCK_VARIADIC_MACROS
MOCK_METHOD(MOCK_STDCALL m3, 0, void(), m3)
#endif
MOCK_STATIC_METHOD( MOCK_STDCALL m4, 0, void(), m4 )
};
MOCK_STATIC_METHOD(MOCK_STDCALL m4, 0, void(), m4)};
MOCK_FUNCTION(MOCK_STDCALL f, 0, void(), f)
}
} // namespace stdcall

51
test/test_object.cpp
View file

@ -7,19 +7,18 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include "mock_error.hpp"
#include <turtle/detail/function.hpp>
#include <turtle/reset.hpp>
#include <turtle/verify.hpp>
#include <turtle/detail/function.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/test/auto_unit_test.hpp>
namespace
{
namespace {
struct object : mock::object
{};
object static_o;
}
} // namespace
BOOST_FIXTURE_TEST_CASE(verifying_an_empty_object_succeeds, mock_error_fixture)
{
@ -27,25 +26,19 @@ BOOST_FIXTURE_TEST_CASE( verifying_an_empty_object_succeeds, mock_error_fixture
BOOST_CHECK(mock::verify(o));
}
namespace
{
namespace {
struct fixture : mock_error_fixture
{
fixture()
{
mock::detail::configure( o, e, "instance", MOCK_TYPE_NAME(o), "name" );
}
fixture() { mock::detail::configure(o, e, "instance", MOCK_TYPE_NAME(o), "name"); }
object o;
mock::detail::function<void()> e;
};
}
} // namespace
BOOST_FIXTURE_TEST_CASE(verifying_an_object_containing_a_failing_expectation_fails, fixture)
{
e.expect().once();
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify(o)), "verification failed", 0, "instanceobject::name\n. once()");
mock::reset(o);
BOOST_CHECK(mock::verify(o));
}
@ -53,9 +46,7 @@ BOOST_FIXTURE_TEST_CASE( verifying_an_object_containing_a_failing_expectation_fa
BOOST_FIXTURE_TEST_CASE(verifying_all_objects_with_one_of_them_containing_a_failing_expectation_fails, fixture)
{
e.expect().once();
CHECK_ERROR(
BOOST_CHECK( ! mock::verify() ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify()), "verification failed", 0, "instanceobject::name\n. once()");
mock::reset();
BOOST_CHECK(mock::verify());
}
@ -76,16 +67,10 @@ BOOST_FIXTURE_TEST_CASE( an_object_is_assignable_by_sharing_its_state, mock_erro
mock::detail::configure(o2, e, "instance", MOCK_TYPE_NAME(o2), "name");
e.expect().once();
o1 = o2;
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o1 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o2 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()");
CHECK_ERROR(BOOST_CHECK(!mock::verify(o2)), "verification failed", 0, "instanceobject::name\n. once()");
}
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o1 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()");
}
BOOST_FIXTURE_TEST_CASE(an_object_is_copiable_by_sharing_its_state, mock_error_fixture)
@ -95,14 +80,8 @@ BOOST_FIXTURE_TEST_CASE( an_object_is_copiable_by_sharing_its_state, mock_error_
mock::detail::function<void()> e;
mock::detail::configure(*o2, e, "instance", MOCK_TYPE_NAME(*o2), "name");
e.expect().once();
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( *o2 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o1 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify(*o2)), "verification failed", 0, "instanceobject::name\n. once()");
CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()");
o2.reset();
CHECK_ERROR(
BOOST_CHECK( ! mock::verify( o1 ) ),
"verification failed", 0, "instanceobject::name\n. once()" );
CHECK_ERROR(BOOST_CHECK(!mock::verify(o1)), "verification failed", 0, "instanceobject::name\n. once()");
}

8
test/test_sequence.cpp
View file

@ -7,8 +7,8 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include "mock_error.hpp"
#include <turtle/sequence.hpp>
#include <turtle/detail/function.hpp>
#include <turtle/sequence.hpp>
#include <boost/test/auto_unit_test.hpp>
BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_out_of_order_throws, mock_error_fixture)
@ -21,7 +21,8 @@ BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_out_of_order_thro
CHECK_ERROR(e(1), "sequence failed", 1, "?( 1 )\n. once().with( 1 )\nv once().with( 2 )");
}
BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_out_of_order_multiple_invocations_throws, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_out_of_order_multiple_invocations_throws,
mock_error_fixture)
{
mock::sequence s;
mock::detail::function<void(int)> e;
@ -58,7 +59,8 @@ BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_multiply_calling_in_order
CHECK_CALLS(4);
}
BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_enforces_call_order_verification_between_two_different_expectations, mock_error_fixture )
BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_enforces_call_order_verification_between_two_different_expectations,
mock_error_fixture)
{
mock::sequence s;
mock::detail::function<void()> e1, e2;