diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..f62b875 --- /dev/null +++ b/.clang-format @@ -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: ' +template 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 + template + 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 ) + 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_; }; -template< typename Expected > -mock::constraint< near_constraint< Expected > > near( Expected expected, Expected threshold ) +template +mock::constraint> near(Expected expected, Expected threshold) { - return near_constraint< Expected >( expected, threshold ); + return near_constraint(expected, threshold); } //] -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 ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one) { - mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).with( near( 42, 1 ) ); - c.add( 41, 1 ); + mock_view v; + calculator c(v); + MOCK_EXPECT(v.display).with(near(42, 1)); + 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 ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one) { - mock_view v; - calculator c( v ); - int expected, threshold; - MOCK_EXPECT( v.display ).with( near( boost::cref( expected ), boost::cref( threshold ) ) ); - expected = 42; - threshold = 1; - c.add( 41, 1 ); + mock_view v; + calculator c(v); + int expected, threshold; + MOCK_EXPECT(v.display).with(near(boost::cref(expected), boost::cref(threshold))); + expected = 42; + threshold = 1; + c.add(41, 1); } //] -} +} // namespace near_constraint_cref_test #undef MOCK_MAX_ARGS //[ max_args @@ -142,7 +126,7 @@ BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_plus_or_minus_one ) //] //[ custom_policy -template< typename Result > +template struct custom_policy { static Result abort() @@ -150,17 +134,17 @@ struct custom_policy // Notify the test framework that an error occurs which makes it impossible to continue the test. // This should most likely throw an exception of some kind. } - template< typename Context > - static void fail( const char* message, const Context& context, const char* file = "unknown location", int line = 0 ) + template + static void fail(const char* message, const Context& context, const char* file = "unknown location", int line = 0) { // Notify the test framework that an unexpected call has occurred. } - template< typename Context > - static void call( const Context& context, const char* file, int line ) + template + static void call(const Context& context, const char* file, int line) { // Notify the test framework that an expectation has been fulfilled. } - static void pass( const char* file, int line ) + static void pass(const char* file, int line) { // Notify the test framework that the test execution merely passed the given code location. } diff --git a/doc/example/getting_started.cpp b/doc/example/getting_started.cpp index ff732c4..9fc1acf 100644 --- a/doc/example/getting_started.cpp +++ b/doc/example/getting_started.cpp @@ -8,122 +8,113 @@ //[ prerequisite #define BOOST_AUTO_TEST_MAIN -#include #include +#include //] #include "calculator.hpp" #include "mock_view.hpp" -namespace phases -{ +namespace phases { //[ phases -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { - mock_view v; // create mock objects - calculator c( v ); // create object under test - MOCK_EXPECT( v.display ).once().with( 0 ); // configure mock objects - c.add( 0, 0 ); // exercise object under test -} // verify mock objects + mock_view v; // create mock objects + calculator c(v); // create object under test + MOCK_EXPECT(v.display).once().with(0); // configure mock objects + 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 ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).once().with( 0 ); - c.add( 0, 0 ); - MOCK_VERIFY( v.display ); // verify all expectations are fulfilled for the 'display' method - mock::verify( v ); // verify all expectations are fulfilled for all methods of 'v' - mock::verify(); // verify all expectations are fulfilled for all existing mock objects - MOCK_RESET( v.display ); // reset all expectations for the 'display' method - mock::reset( v ); // reset all expectations for all methods of 'v' - mock::reset(); // reset all expectations for all existing mock objects -} // automatically verify all expectations are fulfilled for all mock objects going out of scope + calculator c(v); + MOCK_EXPECT(v.display).once().with(0); + c.add(0, 0); + MOCK_VERIFY(v.display); // verify all expectations are fulfilled for the 'display' method + mock::verify(v); // verify all expectations are fulfilled for all methods of 'v' + mock::verify(); // verify all expectations are fulfilled for all existing mock objects + MOCK_RESET(v.display); // reset all expectations for the 'display' method + mock::reset(v); // reset all expectations for all methods of 'v' + 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 ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).once().with( 0 ); // this call must occur once (and only once) - MOCK_EXPECT( v.display ).with( 1 ); // this call can occur any number of times (including never) - c.add( 0, 0 ); + calculator c(v); + MOCK_EXPECT(v.display).once().with(0); // this call must occur once (and only once) + MOCK_EXPECT(v.display).with(1); // this call can occur any number of times (including never) + c.add(0, 0); } //] -} +} // namespace expectations -namespace sequence -{ +namespace sequence { //[ sequence -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { mock_view v; - calculator c( v ); + calculator c(v); mock::sequence s; - MOCK_EXPECT( v.display ).once().with( 0 ).in( s ); // add this expectation to the sequence - MOCK_EXPECT( v.display ).with( 1 ).in( s ); // add this expectation to the sequence after the previous call - c.add( 0, 0 ); - c.add( 1, 0 ); + MOCK_EXPECT(v.display).once().with(0).in(s); // add this expectation to the sequence + MOCK_EXPECT(v.display).with(1).in(s); // add this expectation to the sequence after the previous call + c.add(0, 0); + c.add(1, 0); } //] -} +} // namespace sequence -namespace several_sequences -{ +namespace several_sequences { //[ several_sequences -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { mock_view v; - calculator c( v ); + calculator c(v); mock::sequence s1, s2; - MOCK_EXPECT( v.display ).once().with( 0 ).in( s1 ); - MOCK_EXPECT( v.display ).once().with( 1 ).in( s2 ); - MOCK_EXPECT( v.display ).with( 2 ).in( s1, s2 ); // add this expectation to both sequences after the previous calls - c.add( 0, 0 ); - c.add( 1, 0 ); - c.add( 1, 1 ); - c.add( 2, 0 ); + MOCK_EXPECT(v.display).once().with(0).in(s1); + MOCK_EXPECT(v.display).once().with(1).in(s2); + MOCK_EXPECT(v.display).with(2).in(s1, s2); // add this expectation to both sequences after the previous calls + c.add(0, 0); + c.add(1, 0); + c.add(1, 1); + c.add(2, 0); } //] -} +} // namespace several_sequences -namespace action -{ +namespace action { //[ action_view class view { public: - virtual bool display( int result ) = 0; // returns a boolean + virtual bool display(int result) = 0; // returns a boolean }; //] -MOCK_BASE_CLASS( mock_view, view ) -{ - MOCK_METHOD( display, 1 ) -}; +MOCK_BASE_CLASS(mock_view, view){MOCK_METHOD(display, 1)}; class calculator { public: - calculator( view& v ); + calculator(view& v); - void add( int a, int b ); + void add(int a, int b); }; //[ action_test -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { - mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).once().with( 0 ); // missing returns( true ) - c.add( 0, 0 ); + mock_view v; + calculator c(v); + MOCK_EXPECT(v.display).once().with(0); // missing returns( true ) + c.add(0, 0); } //] -} +} // namespace action diff --git a/doc/example/limitations_comma_in_macro.cpp b/doc/example/limitations_comma_in_macro.cpp index c19ebdf..fd7256f 100644 --- a/doc/example/limitations_comma_in_macro.cpp +++ b/doc/example/limitations_comma_in_macro.cpp @@ -7,42 +7,36 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_comma_in_macro_problem - template< typename T1, typename T2 > - struct my_base_class - {}; +template +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 ) - {}; -//] -} +typedef my_base_class my_base_type; -namespace limitations_comma_in_macro_solution_2 -{ +MOCK_BASE_CLASS(my_mock, my_base_type){}; +//] +} // namespace limitations_comma_in_macro_solution_1 + +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 > ) - {}; +template +MOCK_BASE_CLASS(my_mock, my_base_class){}; //] -} +} // 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 - {}; +template +struct my_mock : my_base_class, mock::object +{}; //] -} +} // namespace limitations_comma_in_macro_solution_3 diff --git a/doc/example/limitations_const_parameter_warning.cpp b/doc/example/limitations_const_parameter_warning.cpp index 531bba2..379bbf7 100644 --- a/doc/example/limitations_const_parameter_warning.cpp +++ b/doc/example/limitations_const_parameter_warning.cpp @@ -7,44 +7,37 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_const_parameter_warning_problem - class base - { - public: - virtual void method( const int ) = 0; - }; -//] -} - -namespace limitations_const_parameter_warning_explanation +class base { +public: + virtual void method(const int) = 0; +}; +//] +} // namespace + +namespace limitations_const_parameter_warning_explanation { //[ limitations_const_parameter_warning_explanation - class derived : public base - { - public: - virtual void method( const int ); - }; - - void derived::method( int ) - {} -//] -} - -namespace limitations_const_parameter_warning_solution +class derived : public base { +public: + virtual void method(const int); +}; + +void derived::method(int) {} +//] +} // namespace limitations_const_parameter_warning_explanation + +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_METHOD( method_stub, 1, void( int ), method ) - }; +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) +} +; //] } diff --git a/doc/example/limitations_literal_zero.cpp b/doc/example/limitations_literal_zero.cpp index 463f4ea..19e4a3b 100644 --- a/doc/example/limitations_literal_zero.cpp +++ b/doc/example/limitations_literal_zero.cpp @@ -7,37 +7,33 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_literal_zero_problem - class base - { - public: - virtual void method( int* i ) = 0; - }; +class base +{ +public: + 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 ) +BOOST_AUTO_TEST_CASE(literal_zero) { mock_base m; -//[ limitations_literal_zero_solution_1 - MOCK_EXPECT( m.method ).with( mock::equal< int* >( 0 ) ); // this compiles -//] -//[ limitations_literal_zero_solution_2 - MOCK_EXPECT( m.method ).with( mock::negate ); + //[ limitations_literal_zero_solution_1 + MOCK_EXPECT(m.method).with(mock::equal(0)); // this compiles + //] + //[ limitations_literal_zero_solution_2 + MOCK_EXPECT(m.method).with(mock::negate); //] #ifdef MOCK_NULLPTR -//[ limitations_literal_zero_solution_3 - MOCK_EXPECT( m.method ).with( nullptr ); + //[ limitations_literal_zero_solution_3 + MOCK_EXPECT(m.method).with(nullptr); //] #endif } diff --git a/doc/example/limitations_non_virtual_method.cpp b/doc/example/limitations_non_virtual_method.cpp index b6f0457..19f6756 100644 --- a/doc/example/limitations_non_virtual_method.cpp +++ b/doc/example/limitations_non_virtual_method.cpp @@ -7,8 +7,8 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include //[ 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)}; //] diff --git a/doc/example/limitations_protected_private_method.cpp b/doc/example/limitations_protected_private_method.cpp index a3a23f3..ba9fd24 100644 --- a/doc/example/limitations_protected_private_method.cpp +++ b/doc/example/limitations_protected_private_method.cpp @@ -7,26 +7,22 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_protected_private_method_problem - class base - { - protected: - virtual void method_1() = 0; - private: - virtual void method_2() = 0; - }; +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 diff --git a/doc/example/limitations_template_base_class_method.cpp b/doc/example/limitations_template_base_class_method.cpp index 5b5461b..d0073d3 100644 --- a/doc/example/limitations_template_base_class_method.cpp +++ b/doc/example/limitations_template_base_class_method.cpp @@ -7,28 +7,23 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_template_base_class_method_problem - template< typename T > - class base - { - public: - virtual ~base() - {} +template +class base +{ +public: + virtual ~base() {} - virtual void method() = 0; - }; + virtual void method() = 0; +}; //] - + //[ limitations_template_base_class_method_solution - template< typename T > - MOCK_BASE_CLASS( mock_base, base< T > ) - { - MOCK_METHOD( method, 1, void() ) - }; +template +MOCK_BASE_CLASS(mock_base, base){MOCK_METHOD(method, 1, void())}; //] -} +} // namespace diff --git a/doc/example/limitations_template_method.cpp b/doc/example/limitations_template_method.cpp index c5c0fa7..10c3f19 100644 --- a/doc/example/limitations_template_method.cpp +++ b/doc/example/limitations_template_method.cpp @@ -7,77 +7,72 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace limitations_template_method_problem -{ +namespace limitations_template_method_problem { //[ limitations_template_method_problem class concept { public: - template< typename T > - void method( T t ) + template + void method(T t) {} }; -template< typename T > -void function_under_test( T t ) // T is supposed to model the previous concept +template +void function_under_test(T t) // T is supposed to model the previous concept { - t.method( 42 ); - t.method( "string" ); + t.method(42); + t.method("string"); } //] - -//[ 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 ) -}; -//] -} -namespace limitations_template_method_problem_2 -{ +//[ 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)}; +//] +} // namespace limitations_template_method_problem + +namespace limitations_template_method_problem_2 { //[ limitations_template_method_problem_2 class concept { public: - template< typename T > + template T create() { return T(); } }; -template< typename T > -void function_under_test( T t ) // T is supposed to model the previous concept +template +void function_under_test(T t) // T is supposed to model the previous concept { - t.template create< int >(); - t.template create< std::string >(); + t.template create(); + t.template create(); } //] - + //[ limitations_template_method_solution_2 -MOCK_CLASS( mock_concept ) +MOCK_CLASS(mock_concept) { - template< typename T > + template T create(); - MOCK_METHOD( create_int, 0, int(), create_int ) - MOCK_METHOD( create_string, 0, std::string(), create_string ) + MOCK_METHOD(create_int, 0, int(), create_int) + MOCK_METHOD(create_string, 0, std::string(), create_string) }; template<> -int mock_concept::create< int >() +int mock_concept::create() { return create_int(); } template<> -std::string mock_concept::create< std::string >() +std::string mock_concept::create() { return create_string(); } //] -} +} // namespace limitations_template_method_problem_2 diff --git a/doc/example/limitations_throw_specifier.cpp b/doc/example/limitations_throw_specifier.cpp index 01e70fe..c5a887d 100644 --- a/doc/example/limitations_throw_specifier.cpp +++ b/doc/example/limitations_throw_specifier.cpp @@ -7,29 +7,24 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace -{ +namespace { //[ limitations_throw_specifier_problem - struct base_class - { - virtual ~base_class() - {} +struct base_class +{ + virtual ~base_class() {} - virtual void method() throw (); - }; + virtual void method() throw(); +}; //] //[ limitations_throw_specifier_solution - MOCK_BASE_CLASS( mock_class, base_class ) - { - void method() throw () - { - method_proxy(); - } - MOCK_METHOD( method_proxy, 0, void(), method ) - }; +MOCK_BASE_CLASS(mock_class, base_class){void method() throw(){method_proxy(); +} // namespace +MOCK_METHOD(method_proxy, 0, void(), method) +} +; //] } diff --git a/doc/example/mock_view.hpp b/doc/example/mock_view.hpp index 0633ae5..86996bd 100644 --- a/doc/example/mock_view.hpp +++ b/doc/example/mock_view.hpp @@ -9,13 +9,13 @@ #ifndef MOCK_VIEW #define MOCK_VIEW -#include #include "view.hpp" +#include //[ mock_view -MOCK_BASE_CLASS( mock_view, view ) // declare a 'mock_view' class implementing 'view' +MOCK_BASE_CLASS(mock_view, view) // declare a 'mock_view' class implementing 'view' { - MOCK_METHOD( display, 1 ) // implement the 'display' method from 'view' (taking 1 argument) + MOCK_METHOD(display, 1) // implement the 'display' method from 'view' (taking 1 argument) }; //] diff --git a/doc/example/motivation.cpp b/doc/example/motivation.cpp index 9aef368..983f88c 100644 --- a/doc/example/motivation.cpp +++ b/doc/example/motivation.cpp @@ -7,40 +7,36 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include -#include #include "calculator.hpp" #include "mock_view.hpp" +#include +#include -namespace simple -{ +namespace simple { //[ simple_calculator class calculator { public: - int add( int a, int b ); + int add(int a, int b); }; //] //[ simple_zero_plus_zero_is_zero -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { calculator c; - BOOST_CHECK_EQUAL( 0, c.add( 0, 0 ) ); + 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 ) - {} - virtual void display( int result ) + my_view() : called(false) {} + virtual void display(int result) { called = true; value = result; @@ -51,26 +47,26 @@ public: //] //[ zero_plus_zero_is_zero_without_mock_object -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero) { my_view v; - calculator c( v ); - c.add( 0, 0 ); - BOOST_REQUIRE( v.called ); - BOOST_CHECK_EQUAL( 0, v.value ); + calculator c(v); + c.add(0, 0); + BOOST_REQUIRE(v.called); + 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 ) +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 - c.add( 0, 0 ); + 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 + c.add(0, 0); } //] -} +} // namespace with_mock_object diff --git a/doc/example/patterns_async_call.cpp b/doc/example/patterns_async_call.cpp index e1b2a60..98ceb3b 100644 --- a/doc/example/patterns_async_call.cpp +++ b/doc/example/patterns_async_call.cpp @@ -7,67 +7,62 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ async_call_problem -namespace +namespace { +class base_class { - class base_class - { - public: - virtual void method() = 0; - }; +public: + virtual void method() = 0; +}; - class my_class - { - public: - explicit my_class( base_class& ); +class my_class +{ +public: + explicit my_class(base_class&); - void flush(); // repetitively calling this method will in turn call base_class::method at some point - }; -} + 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 -#include -#include #include +#include +#include +#include -namespace +namespace { +template +void check(bool& condition, F flush, int attempts = 100, int sleep = 100) { - template< typename F > - void check( bool& condition, F flush, int attempts = 100, int sleep = 100 ) + while(!condition && attempts > 0) { - while( !condition && attempts > 0 ) - { - --attempts; - boost::this_thread::sleep( boost::posix_time::milliseconds( sleep ) ); - flush(); - } - } - - MOCK_BASE_CLASS( mock_base_class, base_class ) - { - MOCK_METHOD( method, 0 ) - }; - void set_bool(bool& b) - { - b = true; + --attempts; + boost::this_thread::sleep(boost::posix_time::milliseconds(sleep)); + flush(); } } -BOOST_AUTO_TEST_CASE( method_is_called ) +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) { mock_base_class m; - my_class c( m ); + my_class c(m); bool done = false; // when method is called it will set done to true // Note: Boost 1.57 introduced a bug preventing usage of the lambda with clang in C++98 // See: https://svn.boost.org/trac10/ticket/10785 #if defined(BOOST_CLANG) && (BOOST_VERSION >= 105700) - MOCK_EXPECT( m.method ).once().calls( boost::bind(&set_bool, done) ); + MOCK_EXPECT(m.method).once().calls(boost::bind(&set_bool, done)); #else - MOCK_EXPECT( m.method ).once().calls( boost::lambda::var( done ) = true ); + MOCK_EXPECT(m.method).once().calls(boost::lambda::var(done) = true); #endif - check( done, boost::bind( &my_class::flush, &c ) ); // just wait on done, flushing from time to time + check(done, boost::bind(&my_class::flush, &c)); // just wait on done, flushing from time to time } //] diff --git a/doc/example/patterns_invoke_functor.cpp b/doc/example/patterns_invoke_functor.cpp index f4d281d..89cd2ef 100644 --- a/doc/example/patterns_invoke_functor.cpp +++ b/doc/example/patterns_invoke_functor.cpp @@ -9,36 +9,32 @@ //[ invoke_functor_problem #include -namespace +namespace { +class base_class { - class base_class - { - public: - virtual void method( const boost::function< void( int ) >& functor ) = 0; - }; +public: + virtual void method(const boost::function& functor) = 0; +}; - void function( base_class& ); // the function will call 'method' with a functor to be applied -} +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 -#include #include +#include +#include -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 ) +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 - function( mock ); + MOCK_EXPECT(mock.method) + .calls(boost::bind(boost::apply(), _1, 42)); // whenever 'method' is called, invoke the functor with 42 + function(mock); } //] diff --git a/doc/example/patterns_quick_constraint.cpp b/doc/example/patterns_quick_constraint.cpp index a331bdc..a6ed099 100644 --- a/doc/example/patterns_quick_constraint.cpp +++ b/doc/example/patterns_quick_constraint.cpp @@ -8,31 +8,27 @@ //[ quick_constraint_problem #define BOOST_AUTO_TEST_MAIN -#include #include +#include #include -namespace +namespace { +class my_class { - class my_class - { - public: - explicit my_class( int data ) - : data_( data ) - {} - int data_; - }; +public: + explicit my_class(int data) : data_(data) {} + int data_; +}; - std::ostream& operator<<( std::ostream& os, const my_class& c ) // my_class is serializable to an std::ostream - { - return os << "my_class( " << c.data_ << " )"; - } - - MOCK_CLASS( my_mock ) - { - MOCK_METHOD( method, 1, void( const my_class& ) ) // how to simply write a custom constraint ? - }; +std::ostream& operator<<(std::ostream& os, const my_class& c) // my_class is serializable to an std::ostream +{ + return os << "my_class( " << c.data_ << " )"; } + +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 - { - return boost::lexical_cast< std::string >( actual ) == expected; - } -} // mock +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(actual) == expected; +} +} // namespace -BOOST_AUTO_TEST_CASE( method_is_called ) +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.method( my_class( 42 ) ); + 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)); } //] diff --git a/doc/example/patterns_retrieve_cref.cpp b/doc/example/patterns_retrieve_cref.cpp index 8be3e9a..40528aa 100644 --- a/doc/example/patterns_retrieve_cref.cpp +++ b/doc/example/patterns_retrieve_cref.cpp @@ -7,44 +7,43 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ retrieve_cref_problem -namespace +namespace { +class base_class { - class base_class - { - public: - virtual void method( int value ) = 0; - }; +public: + virtual void method(int value) = 0; +}; - class my_class - { - public: - explicit my_class( base_class& ); +class my_class +{ +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 #include +#include -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 ) +BOOST_AUTO_TEST_CASE(method_is_called_two_times_with_the_same_value) { mock_base_class mock; - my_class c( 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(); } //] diff --git a/doc/example/patterns_static_objects.cpp b/doc/example/patterns_static_objects.cpp index c385fbc..8109619 100644 --- a/doc/example/patterns_static_objects.cpp +++ b/doc/example/patterns_static_objects.cpp @@ -8,33 +8,31 @@ //[ static_objects_problem #define BOOST_AUTO_TEST_MAIN -#include #include +#include #include -namespace +namespace { +struct my_class { - struct my_class - { - my_class( int i ) - : i_( i ) - {} + my_class(int i) : i_(i) {} - int i_; - }; + int i_; +}; - std::ostream& operator<<( std::ostream& os, const my_class* c ) - { - return os << "my_class " << c->i_; // the 'c' pointer must be valid when logging - } - - MOCK_FUNCTION( f, 1, void( my_class* ) ) // being static 'f' outlive the test case +std::ostream& operator<<(std::ostream& os, const my_class* c) +{ + return os << "my_class " << c->i_; // the 'c' pointer must be valid when logging } -BOOST_AUTO_TEST_CASE( static_objects_problem ) +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' + 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' } // the 'c' instance goes out of scope and the '&c' pointer becomes dangling //] @@ -43,25 +41,28 @@ 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 } }; -BOOST_FIXTURE_TEST_CASE( static_object_partial_solution, fixture ) +BOOST_FIXTURE_TEST_CASE(static_object_partial_solution, fixture) { - my_class c( 42 ); - MOCK_EXPECT( f ).once().with( &c ); - f( &c ); + my_class c(42); + MOCK_EXPECT(f).once().with(&c); + f(&c); mock::verify(); // verify the expectations before local objects are destroyed and before the fixture resets them } //] //[ 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 ); - f( &c ); + my_class c(42); + MOCK_EXPECT(f).once().with(&c); + f(&c); mock::verify(); } //] diff --git a/doc/example/rationale.cpp b/doc/example/rationale.cpp index 170e7e7..454b4b8 100644 --- a/doc/example/rationale.cpp +++ b/doc/example/rationale.cpp @@ -6,15 +6,15 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include "calculator.hpp" #include "mock_view.hpp" +#include //[ overflow_throws -BOOST_AUTO_TEST_CASE( overflow_throws ) +BOOST_AUTO_TEST_CASE(overflow_throws) { mock_view v; - calculator c( v ); - BOOST_CHECK_THROW( c.add( (std::numeric_limits< int >::max)(), 1 ), std::exception ); + calculator c(v); + BOOST_CHECK_THROW(c.add((std::numeric_limits::max)(), 1), std::exception); } //] diff --git a/doc/example/reference.cpp b/doc/example/reference.cpp index bb2c4d6..0eed911 100644 --- a/doc/example/reference.cpp +++ b/doc/example/reference.cpp @@ -7,965 +7,815 @@ // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_AUTO_TEST_MAIN -#include #include +#include -namespace class_example_1 -{ +namespace class_example_1 { //[ class_example_1 -MOCK_CLASS( mock_class ) -{}; +MOCK_CLASS(mock_class){}; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_class ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_class) { mock_class c; } //] -} +} // namespace class_example_1 -namespace class_example_2 -{ +namespace class_example_2 { //[ class_example_2 -template< typename T > -MOCK_CLASS( mock_class ) -{}; +template +MOCK_CLASS(mock_class){}; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_mock_class ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_template_mock_class) { - mock_class< int > c; + mock_class c; } //] -} +} // namespace class_example_2 -namespace class_example_3 -{ +namespace class_example_3 { //[ class_example_3 struct base_class {}; -MOCK_BASE_CLASS( mock_class, base_class ) -{}; +MOCK_BASE_CLASS(mock_class, base_class){}; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_derived_mock_class ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_derived_mock_class) { mock_class c; } //] -} +} // namespace class_example_3 -namespace class_example_4 -{ +namespace class_example_4 { //[ class_example_4 -template< typename T > +template struct base_class {}; -template< typename T > -MOCK_BASE_CLASS( mock_class, base_class< T > ) -{}; +template +MOCK_BASE_CLASS(mock_class, base_class){}; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_derived_mock_class ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_template_derived_mock_class) { - mock_class< int > c; + mock_class c; } //] -} +} // namespace class_example_4 -namespace class_example_5 -{ +namespace class_example_5 { //[ class_example_5 struct name : mock::object // equivalent to using MOCK_CLASS {}; //] -} +} // namespace class_example_5 -namespace class_example_6 -{ +namespace class_example_6 { //[ class_example_6 -template< typename T > +template struct name : mock::object // equivalent to using MOCK_CLASS {}; //] -} +} // namespace class_example_6 -namespace class_example_7 -{ +namespace class_example_7 { //[ class_example_7 class base {}; struct name : base, mock::object // equivalent to using MOCK_BASE_CLASS { - typedef base base_type; // this is required for the shortest form of MOCK_METHOD to work when not using MOCK_BASE_CLASS + typedef base + base_type; // this is required for the shortest form of MOCK_METHOD to work when not using MOCK_BASE_CLASS }; //] -} +} // namespace class_example_7 -namespace class_example_8 -{ +namespace class_example_8 { //[ class_example_8 -template< typename T > +template struct base {}; -template< typename T > -struct name : base< T >, mock::object +template +struct name : base, mock::object { - typedef base< T > base_type; + typedef base base_type; }; //] -} +} // namespace class_example_8 -namespace member_function_example_1 -{ +namespace member_function_example_1 { //[ member_function_example_1 struct base_class { - virtual ~base_class() - {} - virtual void method( int ) = 0; + virtual ~base_class() {} + virtual void method(int) = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) -{ - MOCK_METHOD( method, 1 ) // only possible when referring unambiguously to a base class method +MOCK_BASE_CLASS(mock_class, base_class){ + MOCK_METHOD(method, 1) // only possible when referring unambiguously to a base class method }; //] -} +} // namespace member_function_example_1 -namespace member_function_example_2 -{ +namespace member_function_example_2 { //[ member_function_example_2 struct base_class { - virtual ~base_class() - {} - virtual void method( int, const std::string& ) = 0; - virtual void method( float ) = 0; + virtual ~base_class() {} + virtual void method(int, const std::string&) = 0; + virtual void method(float) = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) -{ - MOCK_METHOD( method, 2, void( int, const std::string& ), identifier_1 ) // both the signature and identifier must be specified because of ambiguity due to overloading - MOCK_METHOD( method, 1, void( float ), identifier_2 ) // the identifier must differ from the previous one in order to fully disambiguate methods +MOCK_BASE_CLASS(mock_class, base_class){ + MOCK_METHOD( + method, 2, void(int, const std::string&), + identifier_1) // both the signature and identifier must be specified because of ambiguity due to overloading + MOCK_METHOD(method, 1, void(float), + identifier_2) // the identifier must differ from the previous one in order to fully disambiguate methods }; //] -} +} // namespace member_function_example_2 -namespace member_function_example_3 -{ +namespace member_function_example_3 { //[ member_function_example_3 struct base_class { - virtual ~base_class() - {} - virtual void method( float ) = 0; - virtual void method( float ) const = 0; + virtual ~base_class() {} + virtual void method(float) = 0; + virtual void method(float) const = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) -{ - MOCK_METHOD( method, 1, void( float ) ) // this generates both const and non-const versions +MOCK_BASE_CLASS(mock_class, base_class){ + MOCK_METHOD(method, 1, void(float)) // this generates both const and non-const versions }; //] -} +} // namespace member_function_example_3 -namespace member_function_example_4 -{ +namespace member_function_example_4 { //[ member_function_example_4 struct base_class { - virtual ~base_class() - {} - virtual void method( float ) = 0; - virtual void method( float ) const = 0; + virtual ~base_class() {} + virtual void method(float) = 0; + virtual void method(float) const = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) -{ - MOCK_CONST_METHOD( method, 1, void( float ), identifier_1 ) // this generates only the const version - MOCK_NON_CONST_METHOD( method, 1, void( float ), identifier_2 ) // this generates only the non-const version, with a different identifier +MOCK_BASE_CLASS(mock_class, base_class){ + MOCK_CONST_METHOD(method, 1, void(float), identifier_1) // this generates only the const version + MOCK_NON_CONST_METHOD(method, 1, void(float), + identifier_2) // this generates only the non-const version, with a different identifier }; //] -} +} // namespace member_function_example_4 -namespace member_function_example_5 -{ +namespace member_function_example_5 { //[ member_function_example_5 struct base_class { - virtual ~base_class() - {} - virtual void method( float ) = 0; + virtual ~base_class() {} + virtual void method(float) = 0; }; struct mock_class : base_class { typedef base_class base_type; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS - MOCK_METHOD( method, 1 ) + MOCK_METHOD(method, 1) }; //] -} +} // namespace member_function_example_5 -namespace member_function_example_6 -{ +namespace member_function_example_6 { //[ member_function_example_6 -MOCK_CLASS( mock_class ) -{ - MOCK_NON_CONST_METHOD( operator=, 1, mock_class&( const mock_class& ), assignment ) // operators require a custom identifier +MOCK_CLASS(mock_class){ + MOCK_NON_CONST_METHOD(operator=, 1, mock_class &(const mock_class&), + assignment) // operators require a custom identifier }; //] -} +} // namespace member_function_example_6 -namespace member_function_example_7 -{ +namespace member_function_example_7 { //[ member_function_example_7 -template< typename T > -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD_TPL( method, 1, void( const T& ) ) // the _TPL variants must be used if the signature includes a template parameter of the class +template +MOCK_CLASS(mock_class){ + MOCK_METHOD_TPL( + method, 1, + void(const T&)) // the _TPL variants must be used if the signature includes a template parameter of the class }; //] -} +} // namespace member_function_example_7 -namespace member_function_example_8 -{ +namespace member_function_example_8 { //[ member_function_example_8 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ) // the signature must be wrapped in BOOST_IDENTITY_TYPE if the return type contains a comma +MOCK_CLASS(mock_class){ + MOCK_METHOD(method, 0, + BOOST_IDENTITY_TYPE((std::map()))) // the signature must be wrapped in BOOST_IDENTITY_TYPE if + // the return type contains a comma }; //] -} +} // namespace member_function_example_8 #ifdef BOOST_MSVC -namespace member_function_example_9 -{ +namespace member_function_example_9 { //[ member_function_example_9 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention +MOCK_CLASS(mock_class){ + MOCK_METHOD(__stdcall method, 0, void(), + method) // all parameters must be provided when specifying a different calling convention }; //] -} +} // namespace member_function_example_9 #endif -namespace static_member_function_example_1 -{ +namespace static_member_function_example_1 { //[ static_member_function_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD( method, 1, float( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_STATIC_METHOD(method, 1, float(int))}; //] -} +} // namespace static_member_function_example_1 -namespace static_member_function_example_2 -{ +namespace static_member_function_example_2 { //[ static_member_function_example_2 -template< typename T > -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD_TPL( method, 1, void( T ) ) -}; +template +MOCK_CLASS(mock_class){MOCK_STATIC_METHOD_TPL(method, 1, void(T))}; //] -} +} // namespace static_member_function_example_2 #ifdef BOOST_MSVC -namespace static_member_function_example_3 -{ +namespace static_member_function_example_3 { //[ static_member_function_example_3 -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention +MOCK_CLASS(mock_class){ + MOCK_STATIC_METHOD(__stdcall method, 0, void(), + method) // all parameters must be provided when specifying a different calling convention }; //] -} +} // namespace static_member_function_example_3 #endif -namespace constructor_example_1 -{ +namespace constructor_example_1 { //[ constructor_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) -}; +MOCK_CLASS(mock_class){MOCK_CONSTRUCTOR(mock_class, 2, (int, const std::string&), identifier)}; //] -} +} // namespace constructor_example_1 -namespace constructor_example_2 -{ +namespace constructor_example_2 { //[ constructor_example_2 -template< typename T > -MOCK_CLASS( mock_class ) -{ - MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) - MOCK_CONSTRUCTOR_TPL( mock_class, 2, ( T, const std::string& ), identifier_2 ) -}; +template +MOCK_CLASS(mock_class){MOCK_CONSTRUCTOR(mock_class, 2, (int, const std::string&), identifier) + MOCK_CONSTRUCTOR_TPL(mock_class, 2, (T, const std::string&), identifier_2)}; //] -} +} // namespace constructor_example_2 #ifdef BOOST_MSVC -namespace constructor_example_3 -{ +namespace constructor_example_3 { //[ constructor_example_3 -MOCK_CLASS( mock_class ) -{ - MOCK_CONSTRUCTOR( __stdcall mock_class, 0, (), constructor ) -}; +MOCK_CLASS(mock_class){MOCK_CONSTRUCTOR(__stdcall mock_class, 0, (), constructor)}; //] -} +} // namespace constructor_example_3 #endif -namespace destructor_example_1 -{ +namespace destructor_example_1 { //[ destructor_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_DESTRUCTOR( ~mock_class, destructor ) -}; +MOCK_CLASS(mock_class){MOCK_DESTRUCTOR(~mock_class, destructor)}; //] -} +} // namespace destructor_example_1 #ifdef BOOST_MSVC -namespace destructor_example_2 -{ +namespace destructor_example_2 { //[ destructor_example_2 -MOCK_CLASS( mock_class ) -{ - MOCK_DESTRUCTOR( __stdcall ~mock_class, destructor ) -}; +MOCK_CLASS(mock_class){MOCK_DESTRUCTOR(__stdcall ~mock_class, destructor)}; //] -} +} // namespace destructor_example_2 #endif -namespace conversion_operator_example_1 -{ +namespace conversion_operator_example_1 { //[ conversion_operator_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_CONVERSION_OPERATOR( operator, int, conversion_to_int ) - MOCK_CONST_CONVERSION_OPERATOR( operator, const std::string&, conversion_to_string ) -}; +MOCK_CLASS(mock_class){MOCK_CONVERSION_OPERATOR(operator, int, conversion_to_int) + MOCK_CONST_CONVERSION_OPERATOR(operator, const std::string&, conversion_to_string)}; //] -} +} // namespace conversion_operator_example_1 -namespace conversion_operator_example_2 -{ +namespace conversion_operator_example_2 { //[ conversion_operator_example_2 -template< typename T > -MOCK_CLASS( mock_class ) -{ - MOCK_CONVERSION_OPERATOR_TPL( operator, T, conversion_to_T ) // the _TPL variants must be used if the signature includes a template parameter of the class - MOCK_CONST_CONVERSION_OPERATOR( operator, const std::string&, const_conversion_to_string ) - MOCK_NON_CONST_CONVERSION_OPERATOR( operator, const std::string&, non_const_conversion_to_string ) -}; +template +MOCK_CLASS(mock_class){ + MOCK_CONVERSION_OPERATOR_TPL(operator, T, conversion_to_T) // the _TPL variants must be used if the signature includes + // a template parameter of the class + MOCK_CONST_CONVERSION_OPERATOR(operator, const std::string&, const_conversion_to_string) + MOCK_NON_CONST_CONVERSION_OPERATOR(operator, const std::string&, non_const_conversion_to_string)}; //] -} +} // namespace conversion_operator_example_2 #ifdef BOOST_MSVC -namespace conversion_operator_example_3 -{ +namespace conversion_operator_example_3 { //[ conversion_operator_example_3 -MOCK_CLASS( mock_class ) -{ - MOCK_CONVERSION_OPERATOR( __stdcall operator, int, conversion_to_int ) -}; +MOCK_CLASS(mock_class){MOCK_CONVERSION_OPERATOR(__stdcall operator, int, conversion_to_int)}; //] -} +} // namespace conversion_operator_example_3 #endif -namespace function_example_1 -{ +namespace function_example_1 { //[ function_example_1 -MOCK_FUNCTION( f, 1, float( int ) ) +MOCK_FUNCTION(f, 1, float(int)) -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_function ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_function) { - f( 3 ); + f(3); } //] -} +} // namespace function_example_1 #ifdef BOOST_MSVC -namespace function_example_2 -{ +namespace function_example_2 { //[ function_example_2 -MOCK_FUNCTION( __stdcall f, 0, void(), f ) // all parameters must be provided when specifying a different calling convention +MOCK_FUNCTION(__stdcall f, 0, void(), + f) // all parameters must be provided when specifying a different calling convention //] -} +} // namespace function_example_2 #endif -namespace functor_example_1 -{ +namespace functor_example_1 { //[ functor_example_1 -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_functor) { - MOCK_FUNCTOR( f, void( int ) ); - f( 3 ); + MOCK_FUNCTOR(f, void(int)); + f(3); } //] -} +} // namespace functor_example_1 -namespace functor_example_2 -{ +namespace functor_example_2 { //[ functor_example_2 -template< typename T > +template struct mock_class { - MOCK_FUNCTOR_TPL( f, void( T ) ); + MOCK_FUNCTOR_TPL(f, void(T)); }; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_functor) { - mock_class< int > c; - c.f( 3 ); + mock_class c; + c.f(3); } //] -} +} // namespace functor_example_2 -namespace expectation_example_1 -{ +namespace expectation_example_1 { //[ expectation_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, int( int ), method ) - MOCK_METHOD( method, 2, void( const std::string&, float ), method2 ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, int(int), method) + MOCK_METHOD(method, 2, void(const std::string&, float), method2)}; -BOOST_AUTO_TEST_CASE( demonstrates_configuring_mock_objects ) +BOOST_AUTO_TEST_CASE(demonstrates_configuring_mock_objects) { mock_class c; mock::sequence s; - MOCK_EXPECT( c.method ).once().with( 0 ).in( s ).returns( 42 ); - MOCK_EXPECT( c.method2 ).never().with( "ok", mock::any ); - MOCK_EXPECT( c.method2 ).at_least( 2 ).in( s ).throws( std::runtime_error( "error !" ) ); + MOCK_EXPECT(c.method).once().with(0).in(s).returns(42); + MOCK_EXPECT(c.method2).never().with("ok", mock::any); + MOCK_EXPECT(c.method2).at_least(2).in(s).throws(std::runtime_error("error !")); } //] -} +} // namespace expectation_example_1 -namespace invocation_example_1 -{ +namespace invocation_example_1 { //[ invocation_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 2, void( int, const std::string& ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 2, void(int, const std::string&))}; -BOOST_AUTO_TEST_CASE( demonstrates_setting_up_invocations_on_a_mock_method ) +BOOST_AUTO_TEST_CASE(demonstrates_setting_up_invocations_on_a_mock_method) { mock_class c; - MOCK_EXPECT( c.method ).once(); // can only be called once - MOCK_EXPECT( c.method ); // can be called an unlimited number of times + MOCK_EXPECT(c.method).once(); // can only be called once + MOCK_EXPECT(c.method); // can be called an unlimited number of times } //] -} +} // namespace invocation_example_1 -namespace invocation_example_2 -{ +namespace invocation_example_2 { //[ invocation_example_2 -BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_functor) { - MOCK_FUNCTOR( f, void( int, const std::string& ) ); - MOCK_EXPECT( f ).once(); + MOCK_FUNCTOR(f, void(int, const std::string&)); + MOCK_EXPECT(f).once(); } //] -} +} // namespace invocation_example_2 -namespace invocation_example_3 -{ +namespace invocation_example_3 { //[ invocation_example_3 -MOCK_FUNCTION( f, 1, void( int ) ) +MOCK_FUNCTION(f, 1, void(int)) -BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_function ) +BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_function) { - MOCK_EXPECT( f ).once(); + MOCK_EXPECT(f).once(); } //] -} +} // namespace invocation_example_3 -namespace invocation_example_4 -{ +namespace invocation_example_4 { //[ invocation_example_4 -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_STATIC_METHOD(method, 1, void(int))}; -BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_static_method ) +BOOST_AUTO_TEST_CASE(demonstrates_setting_up_an_invocation_on_a_mock_static_method) { mock_class c; - MOCK_EXPECT( c.method ).once(); - MOCK_EXPECT( mock_class::method ).once(); // does the same + MOCK_EXPECT(c.method).once(); + MOCK_EXPECT(mock_class::method).once(); // does the same } //] -} +} // namespace invocation_example_4 -namespace constraints_example_1 -{ +namespace constraints_example_1 { //[ constraints_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 2, void( int, const std::string& ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 2, void(int, const std::string&))}; -BOOST_AUTO_TEST_CASE( demonstrates_adding_builtin_constraints ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_builtin_constraints) { - mock_class c; - MOCK_EXPECT( c.method ).with( mock::equal( 3 ), mock::equal( "some string" ) ); - MOCK_EXPECT( c.method ).with( 3, "some string" ); // equivalent to the previous one using short-cuts + mock_class c; + MOCK_EXPECT(c.method).with(mock::equal(3), mock::equal("some string")); + MOCK_EXPECT(c.method).with(3, "some string"); // equivalent to the previous one using short-cuts } //] -} +} // namespace constraints_example_1 -namespace constraints_example_2 -{ +namespace constraints_example_2 { //[ constraints_example_2 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -bool custom_constraint( int actual ) +bool custom_constraint(int actual) { - return actual == 42; + return actual == 42; } -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_free_function ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_a_free_function) { - mock_class c; - MOCK_EXPECT( c.method ).with( &custom_constraint ); + mock_class c; + MOCK_EXPECT(c.method).with(&custom_constraint); } //] -} +} // namespace constraints_example_2 -namespace constraints_example_3 -{ +namespace constraints_example_3 { //[ constraints_example_3 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -bool custom_constraint( int expected, int actual ) +bool custom_constraint(int expected, int actual) { - return expected == actual; + return expected == actual; } -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_standard_library_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_a_standard_library_functor) { - mock_class c; - MOCK_EXPECT( c.method ).with( std::bind1st( std::ptr_fun( &custom_constraint ), 42 ) ); // std::ptr_fun creates an std::unary_function + mock_class c; + MOCK_EXPECT(c.method).with( + std::bind1st(std::ptr_fun(&custom_constraint), 42)); // std::ptr_fun creates an std::unary_function } //] -} +} // namespace constraints_example_3 -namespace constraints_example_4 -{ +namespace constraints_example_4 { //[ constraints_example_4 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -bool custom_constraint( int expected, int actual ) +bool custom_constraint(int expected, int actual) { - return expected == actual; + return expected == actual; } -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_bind ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_boost_bind) { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::bind( &custom_constraint, 42, _1 ) ); + mock_class c; + MOCK_EXPECT(c.method).with(boost::bind(&custom_constraint, 42, _1)); } //] -} +} // namespace constraints_example_4 #ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC -#include +# include -namespace constraints_example_5 -{ +namespace constraints_example_5 { //[ constraints_example_5 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_lambda ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_boost_lambda) { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::lambda::_1 == 42 ); + mock_class c; + MOCK_EXPECT(c.method).with(boost::lambda::_1 == 42); } //] -} +} // namespace constraints_example_5 #endif // BOOST_MSVC #include -namespace constraints_example_6 -{ +namespace constraints_example_6 { //[ constraints_example_6 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_phoenix ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_boost_phoenix) { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::arg1 == 42 ); - MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::_1 == 42 ); + mock_class c; + MOCK_EXPECT(c.method).with(boost::phoenix::arg_names::arg1 == 42); + MOCK_EXPECT(c.method).with(boost::phoenix::arg_names::_1 == 42); } //] -} +} // namespace constraints_example_6 #ifdef MOCK_LAMBDAS -namespace constraints_example_7 -{ +namespace constraints_example_7 { //[ constraints_example_7 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, void( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, void(int))}; -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_constraint_with_cxx11_lambda ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_constraint_with_cxx11_lambda) { mock_class c; - MOCK_EXPECT( c.method ).with( []( int actual ) { return 42 == actual; } ); + MOCK_EXPECT(c.method).with([](int actual) { return 42 == actual; }); } //] -} +} // namespace constraints_example_7 #endif -namespace constraints_example_8 -{ +namespace constraints_example_8 { //[ constraints_example_8 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 2, void( int, const std::string& ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 2, void(int, const std::string&))}; -BOOST_AUTO_TEST_CASE( demonstrates_combining_constraints ) +BOOST_AUTO_TEST_CASE(demonstrates_combining_constraints) { - mock_class c; - MOCK_EXPECT( c.method ).with( mock::less( 4 ) && mock::greater( 2 ), ! mock::equal( "" ) ); + mock_class c; + MOCK_EXPECT(c.method).with(mock::less(4) && mock::greater(2), !mock::equal("")); } //] -} +} // namespace constraints_example_8 -namespace constraints_example_9 -{ +namespace constraints_example_9 { //[ constraints_example_9 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 2, void( const std::string&, std::size_t ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 2, void(const std::string&, std::size_t))}; -bool custom_constraint( const std::string& actual_1, std::size_t actual_2 ) +bool custom_constraint(const std::string& actual_1, std::size_t actual_2) { return actual_1.size() <= actual_2; } -BOOST_AUTO_TEST_CASE( demonstrates_one_constraint_for_all_arguments ) +BOOST_AUTO_TEST_CASE(demonstrates_one_constraint_for_all_arguments) { - mock_class c; - MOCK_EXPECT( c.method ).with( &custom_constraint ); + mock_class c; + MOCK_EXPECT(c.method).with(&custom_constraint); } //] -} +} // namespace constraints_example_9 -namespace sequence_example_1 -{ +namespace sequence_example_1 { //[ sequence_example_1 -MOCK_CLASS( mock_class_1 ) -{ - MOCK_METHOD( method_1, 0, void() ) -}; +MOCK_CLASS(mock_class_1){MOCK_METHOD(method_1, 0, void())}; -MOCK_CLASS( mock_class_2 ) -{ - MOCK_METHOD( method_2, 0, void() ) -}; +MOCK_CLASS(mock_class_2){MOCK_METHOD(method_2, 0, void())}; -MOCK_CLASS( mock_class_3 ) -{ - MOCK_METHOD( method_3, 0, void() ) -}; +MOCK_CLASS(mock_class_3){MOCK_METHOD(method_3, 0, void())}; -BOOST_AUTO_TEST_CASE( demonstrates_enforcing_several_expectation_orders ) +BOOST_AUTO_TEST_CASE(demonstrates_enforcing_several_expectation_orders) { - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock::sequence s_1, s_2; - MOCK_EXPECT( c_1.method_1 ).in( s_1 ); - MOCK_EXPECT( c_2.method_2 ).in( s_2 ); // c_1.method_1 and c_2.method_2 are in different sequences and can be called in any order - MOCK_EXPECT( c_3.method_3 ).in( s_1, s_2 ); // c_3.method_3 must be called after both c_1.method_1 and c_2.method_2 + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock::sequence s_1, s_2; + MOCK_EXPECT(c_1.method_1).in(s_1); + MOCK_EXPECT(c_2.method_2) + .in(s_2); // c_1.method_1 and c_2.method_2 are in different sequences and can be called in any order + MOCK_EXPECT(c_3.method_3).in(s_1, s_2); // c_3.method_3 must be called after both c_1.method_1 and c_2.method_2 } //] -} +} // namespace sequence_example_1 #ifdef MOCK_LAMBDAS -namespace action_example_1 -{ +namespace action_example_1 { //[ action_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 1, int( int ) ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 1, int(int))}; -int function( int i ) +int function(int i) { return i; } -BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions ) +BOOST_AUTO_TEST_CASE(demonstrates_configuring_actions) { - mock_class c; - MOCK_EXPECT( c.method ).returns( 42 ); - MOCK_EXPECT( c.method ).moves( 42 ); // returns by moving the value - MOCK_EXPECT( c.method ).throws( std::runtime_error( "error !" ) ); - MOCK_EXPECT( c.method ).calls( &function ); // forwards 'method' parameter to 'function' - MOCK_EXPECT( c.method ).calls( boost::bind( &function, 42 ) ); // drops 'method' parameter and binds 42 as parameter to 'function' - MOCK_EXPECT( c.method ).calls( []( int i ) { return i; } ); // uses a C++11 lambda + mock_class c; + MOCK_EXPECT(c.method).returns(42); + MOCK_EXPECT(c.method).moves(42); // returns by moving the value + MOCK_EXPECT(c.method).throws(std::runtime_error("error !")); + MOCK_EXPECT(c.method).calls(&function); // forwards 'method' parameter to 'function' + MOCK_EXPECT(c.method).calls( + boost::bind(&function, 42)); // drops 'method' parameter and binds 42 as parameter to 'function' + MOCK_EXPECT(c.method).calls([](int i) { return i; }); // uses a C++11 lambda } //] -} +} // namespace action_example_1 #endif -namespace action_example_2 -{ +namespace action_example_2 { //[ action_example_2 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 0, int&() ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 0, int&())}; -BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions_with_references ) +BOOST_AUTO_TEST_CASE(demonstrates_configuring_actions_with_references) { - mock_class c; - int i = 0; - MOCK_EXPECT( c.method ).returns( boost::ref( i ) ); // wrap i to store a reference - c.method() = 42; // really change i and not just the stored copy - BOOST_CHECK_EQUAL( 42, i ); // indeed + mock_class c; + int i = 0; + MOCK_EXPECT(c.method).returns(boost::ref(i)); // wrap i to store a reference + c.method() = 42; // really change i and not just the stored copy + BOOST_CHECK_EQUAL(42, i); // indeed } //] -} +} // namespace action_example_2 -namespace verification_example_1 -{ +namespace verification_example_1 { //[ verification_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 0, void() ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 0, void())}; -BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_method ) +BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_method) { - mock_class c; - MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met - mock::verify( c ); // verifies all expectations set for all methods of 'c' - mock::verify(); // verifies all existing mock objects, functions and functors + mock_class c; + MOCK_VERIFY(c.method); // logs an error and returns false if not all expectations are met + mock::verify(c); // verifies all expectations set for all methods of 'c' + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} +} // namespace verification_example_1 -namespace verification_example_2 -{ +namespace verification_example_2 { //[ verification_example_2 -BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_functor) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met - mock::verify( f ); // behaves the same as MOCK_VERIFY - mock::verify(); // verifies all existing mock objects, functions and functors + MOCK_FUNCTOR(f, void(int)); + MOCK_VERIFY(f); // logs an error and returns false if not all expectations are met + mock::verify(f); // behaves the same as MOCK_VERIFY + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} +} // namespace verification_example_2 -namespace verification_example_3 -{ +namespace verification_example_3 { //[ verification_example_3 -MOCK_FUNCTION( f, 1, void( int ) ) +MOCK_FUNCTION(f, 1, void(int)) -BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_function ) +BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_mock_function) { - MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met - mock::verify(); // verifies all existing mock objects, functions and functors + MOCK_VERIFY(f); // logs an error and returns false if not all expectations are met + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} +} // namespace verification_example_3 -namespace verification_example_4 -{ +namespace verification_example_4 { //[ verification_example_4 -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD( method, 0, void() ) -}; +MOCK_CLASS(mock_class){MOCK_STATIC_METHOD(method, 0, void())}; -BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_static_mock_method ) +BOOST_AUTO_TEST_CASE(demonstrates_verifying_a_static_mock_method) { - mock_class c; - MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met - MOCK_VERIFY( mock_class::method ); // does the same - mock::verify(); // verifies all existing mock objects, functions and functors + mock_class c; + MOCK_VERIFY(c.method); // logs an error and returns false if not all expectations are met + MOCK_VERIFY(mock_class::method); // does the same + mock::verify(); // verifies all existing mock objects, functions and functors } //] -} +} // namespace verification_example_4 -namespace reset_example_1 -{ +namespace reset_example_1 { //[ reset_example_1 -MOCK_CLASS( mock_class ) -{ - MOCK_METHOD( method, 0, void() ) -}; +MOCK_CLASS(mock_class){MOCK_METHOD(method, 0, void())}; -BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_method ) +BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_method) { - mock_class c; - MOCK_RESET( c.method ); // resets all expectations set for 'c.method' - mock::reset( c ); // resets all expectations set on 'c' - mock::reset(); // resets all existing mock objects, functions and functors + mock_class c; + MOCK_RESET(c.method); // resets all expectations set for 'c.method' + mock::reset(c); // resets all expectations set on 'c' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} +} // namespace reset_example_1 -namespace reset_example_2 -{ +namespace reset_example_2 { //[ reset_example_2 -BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_functor ) +BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_functor) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_RESET( f ); // resets all expectations set for 'f' - mock::reset( f ); // behaves the same as MOCK_RESET - mock::reset(); // resets all existing mock objects, functions and functors + MOCK_FUNCTOR(f, void(int)); + MOCK_RESET(f); // resets all expectations set for 'f' + mock::reset(f); // behaves the same as MOCK_RESET + mock::reset(); // resets all existing mock objects, functions and functors } //] -} +} // namespace reset_example_2 -namespace reset_example_3 -{ +namespace reset_example_3 { //[ reset_example_3 -MOCK_FUNCTION( f, 1, void( int ) ) +MOCK_FUNCTION(f, 1, void(int)) -BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_function ) +BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_mock_function) { - MOCK_RESET( f ); // resets all expectations set for 'f' - mock::reset(); // resets all existing mock objects, functions and functors + MOCK_RESET(f); // resets all expectations set for 'f' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} +} // namespace reset_example_3 -namespace reset_example_4 -{ +namespace reset_example_4 { //[ reset_example_4 -MOCK_CLASS( mock_class ) -{ - MOCK_STATIC_METHOD( method, 0, void() ) -}; +MOCK_CLASS(mock_class){MOCK_STATIC_METHOD(method, 0, void())}; -BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_static_mock_method ) +BOOST_AUTO_TEST_CASE(demonstrates_resetting_a_static_mock_method) { - mock_class c; - MOCK_RESET( c.method ); // resets all expectations set for 'c::method' - MOCK_RESET( mock_class::method ); // resets all expectations set for 'c::method' - mock::reset(); // resets all existing mock objects, functions and functors + mock_class c; + MOCK_RESET(c.method); // resets all expectations set for 'c::method' + MOCK_RESET(mock_class::method); // resets all expectations set for 'c::method' + mock::reset(); // resets all existing mock objects, functions and functors } //] -} +} // namespace reset_example_4 -namespace helpers_example_1 -{ +namespace helpers_example_1 { //[ helpers_example_1 -MOCK_CONSTRAINT( any, true ) // this is how mock::any could be defined -MOCK_CONSTRAINT( forty_two, actual == 42 ) // this defines a 'forty_two' constraint +MOCK_CONSTRAINT(any, true) // this is how mock::any could be defined +MOCK_CONSTRAINT(forty_two, actual == 42) // this defines a 'forty_two' constraint -BOOST_AUTO_TEST_CASE( mock_constraint_0_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_0_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( forty_two ); - MOCK_EXPECT( f ).with( any ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(forty_two); + MOCK_EXPECT(f).with(any); } //] -} +} // namespace helpers_example_1 -namespace helpers_example_2 -{ +namespace helpers_example_2 { //[ helpers_example_2 -MOCK_CONSTRAINT( equal, expected, actual == expected ) // this is how mock::equal could be defined -MOCK_CONSTRAINT( near, expected, std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' +MOCK_CONSTRAINT(equal, expected, actual == expected) // this is how mock::equal could be defined +MOCK_CONSTRAINT(near, expected, + std::abs(actual - expected) + < 0.01) // this defines a 'near' constraint which can be used as 'near( 42 )' -BOOST_AUTO_TEST_CASE( mock_constraint_1_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_1_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( near( 42 ) ); - MOCK_EXPECT( f ).with( equal( 42 ) ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(near(42)); + MOCK_EXPECT(f).with(equal(42)); } //] -} +} // namespace helpers_example_2 -namespace helpers_example_3 -{ +namespace helpers_example_3 { //[ helpers_example_3 -MOCK_CONSTRAINT( near, expected, tolerance, std::abs( actual - expected ) < tolerance ) // this is how mock::near could be defined +MOCK_CONSTRAINT(near, expected, tolerance, + std::abs(actual - expected) < tolerance) // this is how mock::near could be defined -BOOST_AUTO_TEST_CASE( mock_constraint_2_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_2_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( near( 42, 0.001 ) ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(near(42, 0.001)); } //] -} +} // namespace helpers_example_3 -namespace helpers_example_4 -{ +namespace helpers_example_4 { //[ helpers_example_4 -MOCK_CONSTRAINT_EXT( any, 0,, true ) // this is (almost) how mock::any is defined -MOCK_CONSTRAINT_EXT( forty_two, 0,, actual == 42 ) // this defines a 'forty_two' constraint +MOCK_CONSTRAINT_EXT(any, 0, , true) // this is (almost) how mock::any is defined +MOCK_CONSTRAINT_EXT(forty_two, 0, , actual == 42) // this defines a 'forty_two' constraint -BOOST_AUTO_TEST_CASE( mock_constraint_0_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_0_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( forty_two ); - MOCK_EXPECT( f ).with( any ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(forty_two); + MOCK_EXPECT(f).with(any); } //] -} +} // namespace helpers_example_4 -namespace helpers_example_5 -{ +namespace helpers_example_5 { //[ helpers_example_5 -MOCK_CONSTRAINT_EXT( equal, 1, ( expected ), actual == expected ) // this is how mock::equal is defined -MOCK_CONSTRAINT_EXT( near, 1, ( expected ), std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' +MOCK_CONSTRAINT_EXT(equal, 1, (expected), actual == expected) // this is how mock::equal is defined +MOCK_CONSTRAINT_EXT(near, 1, (expected), + std::abs(actual - expected) + < 0.01) // this defines a 'near' constraint which can be used as 'near( 42 )' -BOOST_AUTO_TEST_CASE( mock_constraint_1_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_1_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( near( 42 ) ); - MOCK_EXPECT( f ).with( equal( 42 ) ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(near(42)); + MOCK_EXPECT(f).with(equal(42)); } //] -} +} // namespace helpers_example_5 -namespace helpers_example_6 -{ +namespace helpers_example_6 { //[ helpers_example_6 -MOCK_CONSTRAINT_EXT( near, 2, ( expected, tolerance ), std::abs( actual - expected ) < tolerance ) // this is how mock::near is defined +MOCK_CONSTRAINT_EXT(near, 2, (expected, tolerance), + std::abs(actual - expected) < tolerance) // this is how mock::near is defined -BOOST_AUTO_TEST_CASE( mock_constraint_2_arity ) +BOOST_AUTO_TEST_CASE(mock_constraint_2_arity) { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_EXPECT( f ).with( near( 42, 0.001 ) ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).with(near(42, 0.001)); } //] -} +} // namespace helpers_example_6 diff --git a/doc/example/view.hpp b/doc/example/view.hpp index 797523a..82dfbd2 100644 --- a/doc/example/view.hpp +++ b/doc/example/view.hpp @@ -13,7 +13,7 @@ class view { public: - virtual void display( int result ) = 0; + virtual void display(int result) = 0; }; //] diff --git a/include/turtle/catch.hpp b/include/turtle/catch.hpp index dd9c8ad..e74ed77 100644 --- a/include/turtle/catch.hpp +++ b/include/turtle/catch.hpp @@ -11,34 +11,31 @@ #include -template< typename Result > +template struct catch_mock_error_policy { static Result abort() { - FAIL( "Aborted" ); - throw std::runtime_error( "unreachable" ); + FAIL("Aborted"); + throw std::runtime_error("unreachable"); } - - template< typename Context > - static void fail( const char* message, const Context& context, - const char* file = "file://unknown-location", int line = 0 ) + + template + 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 ); + CAPTURE(context); + FAIL_CHECK(message << " in: " << file << ":" << line); } - - template< typename Context > - static void call( const Context& context, const char* file, int line ) + + template + static void call(const Context& context, const char* file, int line) { - CAPTURE( context ); - INFO( file << ":" << line ); - } - - static void pass( const char* file, int line ) - { - INFO( file << ":" << line ); + CAPTURE(context); + INFO(file << ":" << line); } + + static void pass(const char* file, int line) { INFO(file << ":" << line); } }; #define MOCK_ERROR_POLICY catch_mock_error_policy diff --git a/include/turtle/cleanup.hpp b/include/turtle/cleanup.hpp index de49559..e2bde3d 100644 --- a/include/turtle/cleanup.hpp +++ b/include/turtle/cleanup.hpp @@ -10,30 +10,25 @@ #define MOCK_CLEANUP_HPP_INCLUDED #include "config.hpp" -#include "verify.hpp" #include "reset.hpp" +#include "verify.hpp" #ifdef MOCK_USE_BOOST_TEST -#include +# include #endif -namespace mock +namespace mock { +struct cleanup { - struct cleanup - { - ~cleanup() - { - mock::reset(); - } - }; + ~cleanup() { mock::reset(); } +}; #ifdef MOCK_USE_BOOST_TEST - BOOST_GLOBAL_FIXTURE( cleanup ) -#if BOOST_VERSION >= 105900 - ; -#endif +BOOST_GLOBAL_FIXTURE(cleanup) +# if BOOST_VERSION >= 105900 + ; +# endif #endif -} // mock - +} // namespace mock #endif // MOCK_CLEANUP_HPP_INCLUDED diff --git a/include/turtle/config.hpp b/include/turtle/config.hpp index 16b0ed5..465ad9e 100644 --- a/include/turtle/config.hpp +++ b/include/turtle/config.hpp @@ -16,89 +16,88 @@ #include #ifndef MOCK_ERROR_POLICY -# define MOCK_ERROR_POLICY mock::error -# define MOCK_USE_BOOST_TEST +# define MOCK_ERROR_POLICY mock::error +# define MOCK_USE_BOOST_TEST #endif #ifndef MOCK_MAX_ARGS -# define MOCK_MAX_ARGS 9 +# define MOCK_MAX_ARGS 9 #endif #ifndef MOCK_MAX_SEQUENCES -# define MOCK_MAX_SEQUENCES 10 +# define MOCK_MAX_SEQUENCES 10 #endif #ifndef BOOST_FUNCTION_MAX_ARGS -# define BOOST_FUNCTION_MAX_ARGS MOCK_MAX_ARGS +# define BOOST_FUNCTION_MAX_ARGS MOCK_MAX_ARGS #elif BOOST_PP_LESS(BOOST_FUNCTION_MAX_ARGS, MOCK_MAX_ARGS) -# error BOOST_FUNCTION_MAX_ARGS must be set to MOCK_MAX_ARGS or higher +# error BOOST_FUNCTION_MAX_ARGS must be set to MOCK_MAX_ARGS or higher #endif #ifndef BOOST_FT_MAX_ARITY -# define BOOST_FT_MAX_ARITY BOOST_PP_INC(MOCK_MAX_ARGS) +# define BOOST_FT_MAX_ARITY BOOST_PP_INC(MOCK_MAX_ARGS) #elif BOOST_PP_LESS_EQUAL(BOOST_FT_MAX_ARITY, MOCK_MAX_ARGS) -# error BOOST_FT_MAX_ARITY must be set to MOCK_MAX_ARGS + 1 or higher +# error BOOST_FT_MAX_ARITY must be set to MOCK_MAX_ARGS + 1 or higher #endif #if !defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR) -# ifndef MOCK_NO_NULLPTR -# define MOCK_NULLPTR -# endif +# ifndef MOCK_NO_NULLPTR +# define MOCK_NULLPTR +# endif #endif #if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE) -# ifndef MOCK_NO_DECLTYPE -# define MOCK_DECLTYPE -# endif +# ifndef MOCK_NO_DECLTYPE +# define MOCK_DECLTYPE +# endif #endif #if !defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS) -# ifndef MOCK_NO_VARIADIC_MACROS -# define MOCK_VARIADIC_MACROS -# endif +# ifndef MOCK_NO_VARIADIC_MACROS +# define MOCK_VARIADIC_MACROS +# endif #endif #if !defined(BOOST_NO_CXX11_SMART_PTR) && !defined(BOOST_NO_SMART_PTR) -# ifndef MOCK_NO_SMART_PTR -# define MOCK_SMART_PTR -# endif +# ifndef MOCK_NO_SMART_PTR +# define MOCK_SMART_PTR +# endif #endif #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES) -# ifndef MOCK_NO_RVALUE_REFERENCES -# define MOCK_RVALUE_REFERENCES -# endif +# ifndef MOCK_NO_RVALUE_REFERENCES +# define MOCK_RVALUE_REFERENCES +# endif #endif #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) -# ifndef MOCK_NO_HDR_FUNCTIONAL -# define MOCK_HDR_FUNCTIONAL -# endif +# ifndef MOCK_NO_HDR_FUNCTIONAL +# define MOCK_HDR_FUNCTIONAL +# endif #endif #if !defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX) -# ifndef MOCK_NO_HDR_MUTEX -# define MOCK_HDR_MUTEX -# endif +# ifndef MOCK_NO_HDR_MUTEX +# define MOCK_HDR_MUTEX +# endif #endif #if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) -# ifndef MOCK_NO_LAMBDAS -# define MOCK_LAMBDAS -# endif +# ifndef MOCK_NO_LAMBDAS +# define MOCK_LAMBDAS +# endif #endif #if !defined(BOOST_NO_AUTO_PTR) -# ifndef MOCK_NO_AUTO_PTR -# define MOCK_AUTO_PTR -# endif +# ifndef MOCK_NO_AUTO_PTR +# define MOCK_AUTO_PTR +# endif #endif -#if defined(__cpp_lib_uncaught_exceptions) || \ - defined(_MSC_VER) && (_MSC_VER >= 1900) -# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS -# define MOCK_UNCAUGHT_EXCEPTIONS -# endif +#if defined(__cpp_lib_uncaught_exceptions) || defined(_MSC_VER) && (_MSC_VER >= 1900) +# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS +# define MOCK_UNCAUGHT_EXCEPTIONS +# endif #endif #endif // MOCK_CONFIG_HPP_INCLUDED diff --git a/include/turtle/constraint.hpp b/include/turtle/constraint.hpp index 887a22d..5c83a46 100644 --- a/include/turtle/constraint.hpp +++ b/include/turtle/constraint.hpp @@ -11,248 +11,194 @@ #include "config.hpp" #include "log.hpp" -#include -#include +#include +#include #include -#include +#include #include #include -#include -#include -#include +#include +#include +#include #include -namespace mock +namespace mock { +template +struct constraint { - template< typename Constraint > - struct constraint - { - constraint() - {} - constraint( const Constraint& c ) - : c_( c ) - {} - Constraint c_; - }; + constraint() {} + constraint(const Constraint& c) : c_(c) {} + Constraint c_; +}; -namespace detail -{ - template< typename Lhs, typename Rhs > +namespace detail { + template class and_ { public: - and_( const Lhs& lhs, const Rhs& rhs ) - : lhs_( lhs ) - , rhs_( rhs ) - {} - template< typename Actual > - bool operator()( const Actual& actual ) const + and_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {} + template + bool operator()(const Actual& actual) const { - return lhs_( actual ) && rhs_( actual ); + return lhs_(actual) && rhs_(actual); } - friend std::ostream& operator<<( std::ostream& s, const and_& a ) + 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_; }; - template< typename Lhs, typename Rhs > + template class or_ { public: - or_( const Lhs& lhs, const Rhs& rhs ) - : lhs_( lhs ) - , rhs_( rhs ) - {} - template< typename Actual > - bool operator()( const Actual& actual ) const + or_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {} + template + bool operator()(const Actual& actual) const { - return lhs_( actual ) || rhs_( actual ); + return lhs_(actual) || rhs_(actual); } - friend std::ostream& operator<<( std::ostream& s, const or_& o ) + 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_; }; - template< typename Constraint > + template class not_ { public: - explicit not_( const Constraint& c ) - : c_( c ) - {} - template< typename Actual > - bool operator()( const Actual& actual ) const + explicit not_(const Constraint& c) : c_(c) {} + template + 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_ ); + return !c_(actual); } + friend std::ostream& operator<<(std::ostream& s, const not_& n) { return s << "! " << mock::format(n.c_); } + private: Constraint c_; }; +} // namespace detail + +template +const constraint> operator||(const constraint& lhs, const constraint& rhs) +{ + return detail::or_(lhs.c_, rhs.c_); } - template< typename Lhs, typename 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 +const constraint> operator&&(const constraint& lhs, const constraint& rhs) +{ + return detail::and_(lhs.c_, rhs.c_); +} - template< typename Lhs, typename 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 +const constraint> operator!(const constraint& c) +{ + return detail::not_(c.c_); +} +} // namespace mock - template< typename Constraint > - const constraint< detail::not_< Constraint > > - operator!( const constraint< Constraint >& c ) - { - return detail::not_< Constraint >( c.c_ ); - } -} // mock +#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \ + namespace detail { \ + struct Name \ + { \ + template \ + bool operator()(const Actual& actual) const \ + { \ + return Expr; \ + } \ + friend std::ostream& operator<<(std::ostream& s, const Name&) { return s << BOOST_STRINGIZE(Name); } \ + }; \ + } \ + const mock::constraint Name; -#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \ - namespace detail \ - { \ - struct Name \ - { \ - template< typename Actual > \ - bool operator()( const Actual& actual ) const \ - { \ - return Expr; \ - } \ - 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(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::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::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(BOOST_PP_ARRAY_ELEM(n, Args)) -#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \ - 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, _) \ - {} \ - template< typename Actual > \ - bool operator()( const Actual& actual ) const \ - { \ - 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 \ - { \ - return Expr; \ - } \ - friend std::ostream& operator<<( std::ostream& s, const Name& c ) \ - { \ - 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)) ) \ - { \ - return detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) >( \ - BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args)) ); \ +#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \ + namespace detail { \ + template \ + struct Name \ + { \ + template \ + explicit Name(BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _)) : BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \ + {} \ + template \ + bool operator()(const Actual& actual) const \ + { \ + return test(actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _)); \ + } \ + template \ + 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, _) << " )"; \ + } \ + BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \ + }; \ + } \ + template \ + mock::constraint> Name( \ + BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args))) \ + { \ + return detail::Name( \ + 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,),) -#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,) -#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 +# 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, ), ) +# 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, ) +# 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_CONSTRAINT_AUX_AUX(Name, n, 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_AUX(Name, n, 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 diff --git a/include/turtle/constraints.hpp b/include/turtle/constraints.hpp index c17320f..be52370 100644 --- a/include/turtle/constraints.hpp +++ b/include/turtle/constraints.hpp @@ -14,299 +14,244 @@ #include "detail/addressof.hpp" #include "detail/move_helper.hpp" #include -#include -#include #include -#include #include +#include +#include +#include #if BOOST_VERSION >= 107000 -#include +# include #else -#include +# include #endif -namespace mock -{ - MOCK_UNARY_CONSTRAINT( any, 0,, ((void)actual, true) ) - MOCK_UNARY_CONSTRAINT( affirm, 0,, !! actual ) - MOCK_UNARY_CONSTRAINT( negate, 0,, ! actual ) - MOCK_UNARY_CONSTRAINT( evaluate, 0,, actual() ) +namespace mock { +MOCK_UNARY_CONSTRAINT(any, 0, , ((void)actual, true)) +MOCK_UNARY_CONSTRAINT(affirm, 0, , !!actual) +MOCK_UNARY_CONSTRAINT(negate, 0, , !actual) +MOCK_UNARY_CONSTRAINT(evaluate, 0, , actual()) - MOCK_NARY_CONSTRAINT( less, 1, ( expected ), actual < expected ) - MOCK_NARY_CONSTRAINT( greater, 1, ( expected ), actual > expected ) - MOCK_NARY_CONSTRAINT( less_equal, 1, ( expected ), actual <= expected ) - MOCK_NARY_CONSTRAINT( greater_equal, 1, ( expected ), actual >= expected ) +MOCK_NARY_CONSTRAINT(less, 1, (expected), actual < expected) +MOCK_NARY_CONSTRAINT(greater, 1, (expected), actual > expected) +MOCK_NARY_CONSTRAINT(less_equal, 1, (expected), actual <= expected) +MOCK_NARY_CONSTRAINT(greater_equal, 1, (expected), actual >= expected) #if BOOST_VERSION < 105900 -# 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 ) ) -# define MOCK_FRACTION_TOLERANCE() \ - boost::test_tools::check_is_close( \ - actual, \ - expected, \ - boost::test_tools::fraction_tolerance( 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)) +# define MOCK_FRACTION_TOLERANCE() \ + boost::test_tools::check_is_close(actual, expected, boost::test_tools::fraction_tolerance(tolerance)) #else // BOOST_VERSION < 105900 -namespace detail -{ - template< typename T, typename Tolerance > - bool is_small( const T& t, const Tolerance& tolerance ) +namespace detail { + template + bool is_small(const T& t, const Tolerance& tolerance) { - return boost::math::fpc::small_with_tolerance< T >( tolerance )( t ); + return boost::math::fpc::small_with_tolerance(tolerance)(t); } - template< typename T1, typename T2, typename Tolerance > - bool is_close( const T1& t1, const T2& t2, const Tolerance& tolerance ) + template + 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 ); + typedef typename boost::common_type::type common_type; + return boost::math::fpc::close_at_tolerance(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 #ifdef small -# pragma push_macro( "small" ) -# undef small -# define MOCK_SMALL_DEFINED +# pragma push_macro("small") +# 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" ) +# 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 #ifdef near -# pragma push_macro( "near" ) -# undef near -# define MOCK_NEAR_DEFINED +# pragma push_macro("near") +# 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" ) +# pragma pop_macro("near") #endif -namespace detail -{ - template< typename Expected > +namespace detail { + template struct equal { - explicit equal( Expected expected ) - : expected_( expected ) - {} - template< typename Actual > - bool operator()( const Actual& actual, - typename boost::enable_if< - boost::has_equal_to< - Actual, - typename - boost::unwrap_reference< Expected >::type - > - >::type* = 0 ) const + explicit equal(Expected expected) : expected_(expected) {} + template + bool + operator()(const Actual& actual, + typename boost::enable_if< + boost::has_equal_to::type>>::type* = 0) const { - return actual == boost::unwrap_ref( expected_ ); + return actual == boost::unwrap_ref(expected_); } - template< typename Actual > - bool operator()( const Actual& actual, - typename boost::disable_if< - boost::has_equal_to< - Actual, - typename - boost::unwrap_reference< Expected >::type - > - >::type* = 0 ) const + template + bool + operator()(const Actual& actual, + typename boost::disable_if< + boost::has_equal_to::type>>::type* = 0) const { - return actual && *actual == boost::unwrap_ref( expected_ ); + return actual && *actual == boost::unwrap_ref(expected_); } - friend std::ostream& operator<<( std::ostream& s, const equal& e ) + friend std::ostream& operator<<(std::ostream& s, const equal& e) { - return s << "equal( " << mock::format( e.expected_ ) << " )"; + return s << "equal( " << mock::format(e.expected_) << " )"; } Expected expected_; }; - template< typename Expected > + template struct same { - explicit same( const Expected& expected ) - : expected_( detail::addressof( boost::unwrap_ref( expected ) ) ) - {} - template< typename Actual > - bool operator()( const Actual& actual ) const + explicit same(const Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {} + template + bool operator()(const Actual& actual) const { - return detail::addressof( actual ) == expected_; + return detail::addressof(actual) == expected_; } - friend std::ostream& operator<<( std::ostream& os, const same& s ) + friend std::ostream& operator<<(std::ostream& os, const same& s) { - return os << "same( " << mock::format( *s.expected_ ) << " )"; + return os << "same( " << mock::format(*s.expected_) << " )"; } - const typename - boost::unwrap_reference< Expected >::type* expected_; + const typename boost::unwrap_reference::type* expected_; }; - template< typename Expected > + template struct retrieve { - explicit retrieve( Expected& expected ) - : expected_( detail::addressof( boost::unwrap_ref( expected ) ) ) - {} - template< typename Actual > - bool operator()( const Actual& actual, - typename boost::disable_if< - boost::is_convertible< - const Actual*, - typename - boost::unwrap_reference< Expected >::type - > - >::type* = 0 ) const + explicit retrieve(Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {} + template + bool operator()( + const Actual& actual, + typename boost::disable_if< + boost::is_convertible::type>>::type* = 0) const { *expected_ = actual; return true; } - template< typename 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 + template + bool operator()( + BOOST_RV_REF(Actual) actual, + typename boost::disable_if< + boost::is_convertible::type>>::type* = 0) const { - *expected_ = boost::move( actual ); + *expected_ = boost::move(actual); return true; } - template< typename Actual > - bool operator()( Actual& actual, - typename boost::enable_if< - boost::is_convertible< Actual*, - typename - boost::unwrap_reference< Expected >::type - > - >::type* = 0 ) const + template + bool + operator()(Actual& actual, + typename boost::enable_if< + boost::is_convertible::type>>::type* = 0) const { - *expected_ = detail::addressof( actual ); + *expected_ = detail::addressof(actual); return true; } - friend std::ostream& operator<<( std::ostream& s, const retrieve& r ) + friend std::ostream& operator<<(std::ostream& s, const retrieve& r) { - return s << "retrieve( " << mock::format( *r.expected_ ) << " )"; + return s << "retrieve( " << mock::format(*r.expected_) << " )"; } - typename - boost::unwrap_reference< Expected >::type* expected_; + typename boost::unwrap_reference::type* expected_; }; - template< typename Expected > + template struct assign { - explicit assign( const Expected& expected ) - : expected_( expected ) - {} - template< typename Actual > - bool operator()( Actual& actual ) const + explicit assign(const Expected& expected) : expected_(expected) {} + template + bool operator()(Actual& actual) const { - actual = boost::unwrap_ref( expected_ ); + actual = boost::unwrap_ref(expected_); return true; } - template< typename Actual > - bool operator()( Actual* actual, - typename boost::enable_if< - boost::is_convertible< - typename - boost::unwrap_reference< Expected >::type, - Actual - > - >::type* = 0 ) const + template + bool + operator()(Actual* actual, + typename boost::enable_if< + boost::is_convertible::type, Actual>>::type* = 0) const { - if( ! actual ) + if(!actual) return false; - *actual = boost::unwrap_ref( expected_ ); + *actual = boost::unwrap_ref(expected_); return true; } - friend std::ostream& operator<<( std::ostream& s, const assign& a ) + friend std::ostream& operator<<(std::ostream& s, const assign& a) { - return s << "assign( " << mock::format( a.expected_ ) << " )"; + return s << "assign( " << mock::format(a.expected_) << " )"; } Expected expected_; }; - template< typename Expected > + template struct contain { - explicit contain( const Expected& expected ) - : expected_( expected ) - {} - bool operator()( const std::string& actual ) const + 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 ) + friend std::ostream& operator<<(std::ostream& s, const contain& n) { - return s << "contain( " << mock::format( n.expected_ ) << " )"; + return s << "contain( " << mock::format(n.expected_) << " )"; } Expected expected_; }; +} // namespace detail + +template +constraint::type>> equal(BOOST_FWD_REF(T) t) +{ + return detail::equal::type>(boost::forward(t)); } - template< typename T > - constraint< detail::equal< typename detail::forward_type< T >::type > > equal( BOOST_FWD_REF(T) t ) - { - return detail::equal< typename detail::forward_type< T >::type >( boost::forward< T >( t ) ); - } +template +constraint> same(T& t) +{ + return detail::same(t); +} +template +constraint> retrieve(T& t) +{ + return detail::retrieve(t); +} +template +constraint> assign(T t) +{ + return detail::assign(t); +} +template +constraint> contain(T t) +{ + return detail::contain(t); +} - template< typename T > - constraint< detail::same< T > > same( T& t ) - { - return detail::same< T >( t ); - } - template< typename T > - constraint< detail::retrieve< T > > retrieve( T& t ) - { - return detail::retrieve< T >( t ); - } - template< typename T > - constraint< detail::assign< T > > assign( T t ) - { - return detail::assign< T >( t ); - } - template< typename T > - constraint< detail::contain< T > > contain( T t ) - { - return detail::contain< T >( t ); - } - - template< typename T > - constraint< T > call( T t ) - { - return constraint< T >( t ); - } -} // mock +template +constraint call(T t) +{ + return constraint(t); +} +} // namespace mock #endif // MOCK_CONSTRAINTS_HPP_INCLUDED diff --git a/include/turtle/detail/action.hpp b/include/turtle/detail/action.hpp index a146130..0e9729b 100644 --- a/include/turtle/detail/action.hpp +++ b/include/turtle/detail/action.hpp @@ -10,77 +10,62 @@ #define MOCK_ACTION_HPP_INCLUDED #include "../config.hpp" -#include -#include -#include -#include -#include -#include #include +#include +#include +#include #include +#include +#include +#include -namespace mock -{ -namespace detail -{ - template< typename Result, typename Signature > +namespace mock { namespace detail { + template class action_base { private: #ifdef MOCK_HDR_FUNCTIONAL - typedef std::function< Signature > functor_type; - typedef std::function< Result() > action_type; + typedef std::function functor_type; + typedef std::function action_type; #else - typedef boost::function< Signature > functor_type; - typedef boost::function< Result() > action_type; + typedef boost::function functor_type; + typedef boost::function action_type; #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 ) + void calls(const functor_type& f) { - if( ! f ) - throw std::invalid_argument( "null functor" ); + if(!f) + throw std::invalid_argument("null functor"); f_ = f; } - template< typename Exception > - void throws( Exception e ) + template + void throws(Exception e) { - a_ = boost::bind( &do_throw< Exception >, e ); + a_ = boost::bind(&do_throw, e); } protected: - void set( const action_type& a ) + void set(const action_type& a) { a_ = a; } + template + void set(const boost::reference_wrapper& r) { - a_ = a; - } - template< typename Y > - void set( const boost::reference_wrapper< Y >& r ) - { - a_ = boost::bind( &do_ref< Y >, r.get_pointer() ); + a_ = boost::bind(&do_ref, r.get_pointer()); } private: - template< typename T > - static T& do_ref( T* t ) + template + static T& do_ref(T* t) { return *t; } - template< typename T > - static Result do_throw( T t ) + template + static Result do_throw(T t) { throw t; } @@ -89,138 +74,117 @@ namespace detail action_type a_; }; - template< typename Result, typename Signature > - class action : public action_base< Result, Signature > + template + class action : public action_base { public: - template< typename Value > - void returns( const Value& v ) + template + void returns(const Value& v) { - this->set( boost::ref( store( v ) ) ); + this->set(boost::ref(store(v))); } - template< typename Y > - void returns( const boost::reference_wrapper< Y >& r ) + template + void returns(const boost::reference_wrapper& r) { - this->set( r ); + this->set(r); } - template< typename Value > - void moves( BOOST_RV_REF(Value) v ) + template + 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::type>, boost::ref(store(boost::move(v))))); } private: - template< typename Value > - static BOOST_RV_REF(Value) move( Value& t ) + template + static BOOST_RV_REF(Value) move(Value& t) { - return boost::move( t ); + return boost::move(t); } struct value : boost::noncopyable { - virtual ~value() - {} + virtual ~value() {} }; - template< typename T > + template struct value_imp : value { - typedef - typename boost::remove_const< - typename boost::remove_reference< - T - >::type - >::type value_type; + typedef typename boost::remove_const::type>::type value_type; - 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(BOOST_RV_REF(value_type) t) : t_(boost::move(t)) {} + value_imp(const value_type& t) : t_(t) {} + template + value_imp(Y* y) : t_(y) {} value_type t_; }; - template< typename T > - T& store( BOOST_RV_REF(T) t ) + template + T& store(BOOST_RV_REF(T) t) { - v_.reset( new value_imp< T >( boost::move( t ) ) ); - return static_cast< value_imp< T >& >( *v_ ).t_; + v_.reset(new value_imp(boost::move(t))); + return static_cast&>(*v_).t_; } - template< typename T > - T& store( const T& t ) + template + T& store(const T& t) { - v_.reset( new value_imp< T >( t ) ); - return static_cast< value_imp< T >& >( *v_ ).t_; + v_.reset(new value_imp(t)); + return static_cast&>(*v_).t_; } - template< typename T > - typename boost::remove_reference< Result >::type& store( T* t ) + template + typename boost::remove_reference::type& store(T* t) { - v_.reset( new value_imp< Result >( t ) ); - return static_cast< value_imp< Result >& >( *v_ ).t_; + v_.reset(new value_imp(t)); + return static_cast&>(*v_).t_; } - boost::shared_ptr< value > v_; + boost::shared_ptr v_; }; - template< typename Signature > - class action< void, Signature > : public action_base< void, Signature > + template + class action : public action_base { 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 > + template + class action, Signature> : public action_base, 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_ ) ); + if(v_.get()) + returns(boost::ref(v_)); } - template< typename Y > - void returns( Y* r ) + template + void returns(Y* r) { - v_.reset( r ); - this->set( boost::ref( v_ ) ); + v_.reset(r); + this->set(boost::ref(v_)); } - template< typename Y > - void returns( std::auto_ptr< Y > r ) + template + void returns(std::auto_ptr r) { v_ = r; - this->set( boost::ref( v_ ) ); + this->set(boost::ref(v_)); } - template< typename Y > - void returns( const boost::reference_wrapper< Y >& r ) + template + void returns(const boost::reference_wrapper& r) { - this->set( r ); + this->set(r); } private: - mutable std::auto_ptr< Result > v_; + mutable std::auto_ptr v_; }; #endif // MOCK_AUTO_PTR -} -} // mock +}} // namespace mock::detail #endif // MOCK_ACTION_HPP_INCLUDED diff --git a/include/turtle/detail/addressof.hpp b/include/turtle/detail/addressof.hpp index 4e48a8d..ff84bbd 100644 --- a/include/turtle/detail/addressof.hpp +++ b/include/turtle/detail/addressof.hpp @@ -12,25 +12,15 @@ #include "../config.hpp" #include -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 diff --git a/include/turtle/detail/child.hpp b/include/turtle/detail/child.hpp index 992d397..8d297d8 100644 --- a/include/turtle/detail/child.hpp +++ b/include/turtle/detail/child.hpp @@ -10,43 +10,36 @@ #define MOCK_CHILD_HPP_INCLUDED #include "../config.hpp" -#include "type_name.hpp" #include "parent.hpp" -#include +#include "type_name.hpp" #include +#include #include -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, - boost::unit_test::const_string name ) + child() : parent_(0) {} + void update(parent& p, boost::unit_test::const_string instance, boost::optional type, + boost::unit_test::const_string name) { - if( instance != "?." || name_.empty() ) - p = parent( instance, type ); + if(instance != "?." || name_.empty()) + p = parent(instance, type); parent_ = &p; name_ = name; } - friend std::ostream& operator<<( std::ostream& s, const child& c ) + friend std::ostream& operator<<(std::ostream& s, const child& c) { - if( c.parent_ ) + if(c.parent_) 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 diff --git a/include/turtle/detail/context.hpp b/include/turtle/detail/context.hpp index 9b275a3..b7e3501 100644 --- a/include/turtle/detail/context.hpp +++ b/include/turtle/detail/context.hpp @@ -16,10 +16,7 @@ #include #include -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( verifiable& v ) = 0; - virtual void remove( verifiable& v ) = 0; + virtual void add(const void* p, verifiable& v, boost::unit_test::const_string instance, + boost::optional 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 diff --git a/include/turtle/detail/expectation_template.hpp b/include/turtle/detail/expectation_template.hpp index 20bf6f4..0546b55 100644 --- a/include/turtle/detail/expectation_template.hpp +++ b/include/turtle/detail/expectation_template.hpp @@ -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 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 ) ) + BOOST_PP_IF(n, &&, ) c##n##_(mock::detail::move_if_not_lvalue_reference(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(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::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::type -namespace mock -{ -namespace detail -{ - template< typename Signature > class default_matcher; +namespace mock { namespace detail { + template + 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 + class default_matcher : + public matcher_base { private: - virtual bool operator()( - BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _) ) + virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _)) { return true; } + virtual void serialize(std::ostream& s) const { - 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 + 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 + class single_matcher : + public matcher_base { 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 + 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 + 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 + class multi_matcher : + public matcher_base { 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_ ); + return f_(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _)); } + virtual void serialize(std::ostream& s) const { s << mock::format(f_); } private: F f_; @@ -124,146 +93,99 @@ namespace detail #endif - template< typename Signature > class expectation; + template + 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 + class expectation : + public action { 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()), + matcher_(boost::make_shared>()), + 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 ) + expectation(const char* file, int line) + : invocation_(boost::make_shared()), + matcher_(boost::make_shared>()), + file_(file), line_(line) {} ~expectation() { - for( sequences_cit it = sequences_.begin(); - it != sequences_.end(); ++it ) - (*it)->remove( this ); + 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& 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 + 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(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c))); return *this; } -#if MOCK_NUM_ARGS > 1 - template< typename Constraint > - expectation& with( const Constraint& c ) +# if MOCK_NUM_ARGS > 1 + template + 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(c)); return *this; } -#endif +# endif #endif - void add( sequence& s ) + void add(sequence& s) { - s.impl_->add( this ); - sequences_.push_back( s.impl_ ); + s.impl_->add(this); + 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 ) - if( ! (*it)->is_valid( this ) ) + 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 ) - (*it)->invalidate( this ); + 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_ << " )" + << ".with( " << *e.matcher_ << " )" #endif - ; + ; } private: - typedef std::vector< - boost::shared_ptr< sequence_impl > - > sequences_type; + typedef std::vector> 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 invocation_; + boost::shared_ptr> matcher_; sequences_type sequences_; const char* file_; int line_; }; -} -} // mock +}} // namespace mock::detail #undef MOCK_EXPECTATION_INITIALIZE #undef MOCK_EXPECTATION_MEMBER diff --git a/include/turtle/detail/formatter.hpp b/include/turtle/detail/formatter.hpp index 18ccd73..10595be 100644 --- a/include/turtle/detail/formatter.hpp +++ b/include/turtle/detail/formatter.hpp @@ -13,38 +13,29 @@ #include "../stream.hpp" #include "addressof.hpp" -namespace mock -{ -namespace detail -{ - template< typename T > +namespace mock { namespace detail { + template 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_; }; - template< typename T > - stream& operator<<( stream& s, const formatter< T >& f ) + template + stream& operator<<(stream& s, const formatter& f) { - f.serialize( s ); + f.serialize(s); return s; } - template< typename T > - std::ostream& operator<<( std::ostream& s, const formatter< T >& f ) + template + std::ostream& operator<<(std::ostream& s, const formatter& f) { - stream ss( s ); - f.serialize( ss ); + stream ss(s); + f.serialize(ss); return s; } -} -} // mock +}} // namespace mock::detail #endif // MOCK_FORMATTER_HPP_INCLUDED diff --git a/include/turtle/detail/function.hpp b/include/turtle/detail/function.hpp index a17dfec..3edf806 100644 --- a/include/turtle/detail/function.hpp +++ b/include/turtle/detail/function.hpp @@ -10,79 +10,67 @@ #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 -#include -#include -#include +#include "mutex.hpp" +#include "type_name.hpp" +#include "verifiable.hpp" +#include +#include +#include +#include +#include +#include #include #include +#include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include #include #include -#include -namespace mock -{ -namespace detail -{ - template< typename R, typename E > +namespace mock { namespace detail { + template struct wrapper_base { - wrapper_base( E& e ) - : e_( &e ) - {} + wrapper_base(E& e) : e_(&e) {} - template< typename T > - void returns( T t ) + template + void returns(T t) { - e_->returns( t ); + e_->returns(t); } E* e_; }; - template< typename E > - struct wrapper_base< void, E > + template + struct wrapper_base { - wrapper_base( E& e ) - : e_( &e ) - {} + wrapper_base(E& e) : e_(&e) {} E* e_; }; - template< typename R, typename E > - struct wrapper_base< R*, E > + template + struct wrapper_base { - wrapper_base( E& e ) - : e_( &e ) - {} + wrapper_base(E& e) : e_(&e) {} - void returns( R* r ) + void returns(R* r) { e_->returns(r); } + template + void returns(const boost::reference_wrapper& r) { - e_->returns( r ); - } - template< typename Y > - void returns( const boost::reference_wrapper< Y >& r ) - { - e_->returns( r ); + e_->returns(r); } E* e_; @@ -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 diff --git a/include/turtle/detail/function_impl_template.hpp b/include/turtle/detail/function_impl_template.hpp index 3a68971..c7205b3 100644 --- a/include/turtle/detail/function_impl_template.hpp +++ b/include/turtle/detail/function_impl_template.hpp @@ -9,200 +9,163 @@ #include "expectation_template.hpp" #ifndef MOCK_ERROR_POLICY -# error no error policy has been set +# 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 ) +#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) -#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) -namespace mock -{ -namespace detail -{ - template< typename Signature > class function_impl; +namespace mock { namespace detail { + template + 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 + class function_impl : + public verifiable, + public boost::enable_shared_from_this> { public: - typedef safe_error< R, MOCK_ERROR_POLICY< R > > error_type; + typedef safe_error> 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()) {} virtual ~function_impl() { - if( valid_ && exceptions_ >= exceptions() ) - 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 ), - it->file(), it->line() ); - if( context_ ) - context_->remove( *this ); + if(valid_ && exceptions_ >= exceptions()) + 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), + it->file(), it->line()); + if(context_) + context_->remove(*this); } virtual bool verify() const { - lock _( mutex_ ); - for( expectations_cit it = expectations_.begin(); - it != expectations_.end(); ++it ) - if( ! it->verify() ) + lock _(mutex_); + 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 ), - it->file(), it->line() ); + error_type::fail("verification failed", + boost::unit_test::lazy_ostream::instance() + << lazy_context(this) << lazy_expectations(this), + it->file(), it->line()); } return valid_; } virtual void reset() { - lock _( mutex_ ); + lock _(mutex_); valid_ = true; - boost::shared_ptr< function_impl > guard = - this->shared_from_this(); + boost::shared_ptr guard = this->shared_from_this(); expectations_.clear(); } private: - typedef expectation< - R( BOOST_PP_ENUM_PARAMS( MOCK_NUM_ARGS, T ) ) - > expectation_type; + typedef expectation expectation_type; - class wrapper : public wrapper_base< R, expectation_type > + class wrapper : public wrapper_base { private: - typedef wrapper_base< R, expectation_type > base_type; + typedef wrapper_base base_type; 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& operator=( BOOST_RV_REF( wrapper ) x ) + wrapper(const boost::shared_ptr& 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; - lock_ = boost::move( x.lock_ ); + static_cast(*this) = x; + lock_ = boost::move(x.lock_); return *this; } wrapper& once() { - this->e_->invoke( boost::make_shared< detail::once >() ); + this->e_->invoke(boost::make_shared()); return *this; } wrapper& never() { - this->e_->invoke( boost::make_shared< detail::never >() ); + this->e_->invoke(boost::make_shared()); return *this; } - wrapper& exactly( std::size_t count ) + wrapper& exactly(std::size_t count) { - this->e_->invoke( - boost::make_shared< detail::exactly >( count ) ); + this->e_->invoke(boost::make_shared(count)); return *this; } - wrapper& at_least( std::size_t min ) + wrapper& at_least(std::size_t min) { - this->e_->invoke( - boost::make_shared< detail::at_least >( min ) ); + this->e_->invoke(boost::make_shared(min)); return *this; } - wrapper& at_most( std::size_t max ) + wrapper& at_most(std::size_t max) { - this->e_->invoke( - boost::make_shared< detail::at_most >( max ) ); + this->e_->invoke(boost::make_shared(max)); return *this; } - wrapper& between( std::size_t min, std::size_t max ) + 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(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 + 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; } -#if MOCK_NUM_ARGS > 1 - template< typename Constraint > - wrapper& with( const Constraint& c ) +# if MOCK_NUM_ARGS > 1 + template + wrapper& with(const Constraint& c) { - this->e_->with( c ); + this->e_->with(c); return *this; } -#endif +# 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) ) \ - { \ - BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \ - return *this; \ +#define MOCK_FUNCTION_IN(z, n, d) \ + wrapper& in(BOOST_PP_ENUM_PARAMS(n, sequence& s)) \ + { \ + BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \ + 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 - template< typename TT > - void calls( TT t ) + template + void calls(TT t) { - this->e_->calls( t ); + this->e_->calls(t); } - template< typename TT > - void throws( TT t ) + template + void throws(TT t) { - this->e_->throws( t ); + this->e_->throws(t); } - template< typename TT > - void moves( BOOST_RV_REF(TT) t ) + template + void moves(BOOST_RV_REF(TT) t) { - this->e_->moves( boost::move( t ) ); + this->e_->moves(boost::move(t)); } lock lock_; @@ -211,84 +174,71 @@ namespace detail public: typedef wrapper wrapper_type; - wrapper expect( const char* file, int line ) + wrapper expect(const char* file, int line) { - lock _( mutex_ ); - expectations_.push_back( expectation_type( file, line ) ); + lock _(mutex_); + expectations_.push_back(expectation_type(file, line)); valid_ = true; - return wrapper( mutex_, expectations_.back() ); + return wrapper(mutex_, expectations_.back()); } wrapper expect() { - lock _( mutex_ ); - expectations_.push_back( expectation_type() ); + lock _(mutex_); + expectations_.push_back(expectation_type()); valid_ = true; - return wrapper( mutex_, expectations_.back() ); + 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_ ); + 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() ) + 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() ) + 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() ); - if( it->functor() ) - return it->functor()( - BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ); + 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->trigger(); } - error_type::fail( "unexpected call", MOCK_FUNCTION_CONTEXT ); + 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, - boost::unit_test::const_string name ) + void add(context& c, const void* p, boost::unit_test::const_string instance, boost::optional type, + boost::unit_test::const_string name) { - lock _( mutex_ ); - if( ! context_ ) - c.add( *this ); - c.add( p, *this, instance, type, name ); + lock _(mutex_); + if(!context_) + c.add(*this); + c.add(p, *this, instance, type, name); 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 ); + lock _(impl.mutex_); + return s << lazy_context(&impl) << lazy_expectations(&impl); } 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_ ); + if(c.impl_->context_) + c.impl_->context_->serialize(s, *c.impl_); else s << '?'; return s; @@ -298,31 +248,26 @@ 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; } const function_impl* impl_; }; - typedef std::list< expectation_type > expectations_type; + typedef std::list expectations_type; typedef typename expectations_type::const_iterator expectations_cit; expectations_type expectations_; context* context_; mutable bool valid_; const int exceptions_; - const boost::shared_ptr< mutex > mutex_; + const boost::shared_ptr mutex_; }; -} -} // mock +}} // namespace mock::detail #undef MOCK_FUNCTION_FORMAT #undef MOCK_FUNCTION_CONTEXT diff --git a/include/turtle/detail/function_template.hpp b/include/turtle/detail/function_template.hpp index 0ebfe14..b481345 100644 --- a/include/turtle/detail/function_template.hpp +++ b/include/turtle/detail/function_template.hpp @@ -8,99 +8,74 @@ #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) -namespace mock -{ -namespace detail -{ - template< typename Signature > class function; +namespace mock { namespace detail { + template + class function; - template< typename R - BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) > - class function< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) > + template + class function { public: typedef R result_type; - template< typename Args > + template struct sig { typedef R type; }; private: - typedef function_impl< - R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) - > impl_type; + typedef function_impl 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()) {} - bool verify() const + bool verify() const { return impl_->verify(); } + bool verify(const char* file, int line) const { + error_type::pass(file, line); return impl_->verify(); } - bool verify( const char* file, int line ) const + void reset() { impl_->reset(); } + void reset(const char* file, int line) { - error_type::pass( file, line ); - return impl_->verify(); - } - void reset() - { - impl_->reset(); - } - void reset( const char* file, int line ) - { - error_type::pass( file, line ); + error_type::pass(file, line); impl_->reset(); } - expectation_type expect( const char* file, int line ) + expectation_type expect(const char* file, int line) { - error_type::pass( file, line ); - return impl_->expect( file, line ); + error_type::pass(file, line); + return impl_->expect(file, line); } - expectation_type expect() + expectation_type expect() { return impl_->expect(); } + + R operator()(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t)) const { - return impl_->expect(); + return (*impl_)(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _)); } - 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 ) + function& operator()(context& c, boost::unit_test::const_string instance) { - return s << *f.impl_; - } - - function& operator()( context& c, - boost::unit_test::const_string instance ) - { - impl_->add( c, impl_.get(), instance, boost::none, "" ); + 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, boost::unit_test::const_string name) const { - impl_->add( c, p, instance, type, name ); + impl_->add(c, p, instance, type, name); } private: - boost::shared_ptr< impl_type > impl_; + boost::shared_ptr impl_; }; -} -} // mock +}} // namespace mock::detail #undef MOCK_MOVE diff --git a/include/turtle/detail/functor.hpp b/include/turtle/detail/functor.hpp index 53e776f..e4ce1e8 100644 --- a/include/turtle/detail/functor.hpp +++ b/include/turtle/detail/functor.hpp @@ -14,39 +14,32 @@ #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, public mutex { - MOCK_SINGLETON_CONS( functor_mutex_t ); + MOCK_SINGLETON_CONS(functor_mutex_t); }; - MOCK_SINGLETON_INST( functor_mutex ) + MOCK_SINGLETON_INST(functor_mutex) - template< typename Signature > - struct functor : function< Signature > + template + struct functor : function { functor() { - scoped_lock _( functor_mutex ); + scoped_lock _(functor_mutex); static functor* f = 0; - if( f ) + if(f) { *this = *f; f = 0; functor_mutex.unlock(); - } - else + } else { functor_mutex.lock(); f = this; } } }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_FUNCTOR_HPP_INCLUDED diff --git a/include/turtle/detail/group.hpp b/include/turtle/detail/group.hpp index d0668cc..b4973ff 100644 --- a/include/turtle/detail/group.hpp +++ b/include/turtle/detail/group.hpp @@ -11,54 +11,42 @@ #include "../config.hpp" #include "verifiable.hpp" -#include #include +#include #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class group { public: - void add( verifiable& v ) + void add(verifiable& v) { verifiables_.push_back(&v); } + void remove(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 ) - if( ! (*it)->verify() ) + for(verifiables_cit it = verifiables_.begin(); it != verifiables_.end(); ++it) + if(!(*it)->verify()) valid = false; return valid; } 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(); } private: - typedef std::vector< verifiable* > verifiables_t; + typedef std::vector verifiables_t; typedef verifiables_t::const_iterator verifiables_cit; verifiables_t verifiables_; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_GROUP_HPP_INCLUDED diff --git a/include/turtle/detail/invocation.hpp b/include/turtle/detail/invocation.hpp index fd1c0f6..7b6efc8 100644 --- a/include/turtle/detail/invocation.hpp +++ b/include/turtle/detail/invocation.hpp @@ -11,14 +11,11 @@ #include "../config.hpp" #include -#include -#include #include +#include +#include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class invocation : private boost::noncopyable { public: @@ -30,66 +27,51 @@ 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; + virtual std::ostream& serialize(std::ostream& s) const = 0; }; 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'" ); + if(min > max) + throw std::invalid_argument("'min' > 'max'"); } virtual bool invoke() { - if( count_ == max_ ) + if(count_ == max_) return false; ++count_; 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_; std::size_t count_; private: - virtual std::ostream& serialize( std::ostream& s ) const + 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 + virtual std::ostream& serialize(std::ostream& s) const { return s << "exactly( " << count_ << '/' << max_ << " )"; } @@ -98,40 +80,28 @@ 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::max)()) {} private: - virtual std::ostream& serialize( std::ostream& s ) const + virtual std::ostream& serialize(std::ostream& s) const { return s << "at_least( " << count_ << '/' << min_ << " )"; } @@ -140,12 +110,10 @@ 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 + virtual std::ostream& serialize(std::ostream& s) const { return s << "at_most( " << count_ << '/' << max_ << " )"; } @@ -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 diff --git a/include/turtle/detail/is_functor.hpp b/include/turtle/detail/is_functor.hpp index 5d4de95..78f9e94 100644 --- a/include/turtle/detail/is_functor.hpp +++ b/include/turtle/detail/is_functor.hpp @@ -11,52 +11,42 @@ #include "../config.hpp" #include -#include -#include #include #include +#include +#include -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 ) +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) #ifdef MOCK_DECLTYPE - template< typename F, typename P > + template struct is_callable { typedef boost::type_traits::yes_type yes_type; typedef boost::type_traits::no_type no_type; - template< typename T > - static yes_type check( - decltype( boost::declval< T >()( boost::declval< P >() ) )* ); - template< typename T > - static no_type check( ... ); + template + static yes_type check(decltype(boost::declval()(boost::declval

()))*); + template + static no_type check(...); - typedef boost::mpl::bool_< - sizeof( check< F >( 0 ) ) == sizeof( yes_type ) > type; + typedef boost::mpl::bool_(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 >, + template + struct is_functor : + boost::mpl::or_, #ifdef MOCK_DECLTYPE - is_callable< T, P >, + is_callable, #endif - has_result_type< T >, - has_result< T >, - has_sig< T > - > + has_result_type, has_result, has_sig> {}; -} -} // mock +}} // namespace mock::detail #endif // MOCK_IS_FUNCTOR_HPP_INCLUDED diff --git a/include/turtle/detail/matcher_base_template.hpp b/include/turtle/detail/matcher_base_template.hpp index 07fa326..946b3af 100644 --- a/include/turtle/detail/matcher_base_template.hpp +++ b/include/turtle/detail/matcher_base_template.hpp @@ -6,37 +6,29 @@ // (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::type -namespace mock -{ -namespace detail -{ - template< typename Signature > class matcher_base; +namespace mock { namespace detail { + template + 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 + class matcher_base : 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 ); + m.serialize(s); return s; } private: - virtual void serialize( std::ostream& ) const = 0; + virtual void serialize(std::ostream&) const = 0; }; -} -} // mock +}} // namespace mock::detail #undef MOCK_REF_ARG diff --git a/include/turtle/detail/move_helper.hpp b/include/turtle/detail/move_helper.hpp index 87f1f2d..a9903c7 100644 --- a/include/turtle/detail/move_helper.hpp +++ b/include/turtle/detail/move_helper.hpp @@ -10,69 +10,62 @@ #define MOCK_MOVE_HELPER_HPP_INCLUDED #include "../config.hpp" -#include -#include -#include #include #include +#include #include +#include +#include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { #ifdef MOCK_RVALUE_REFERENCES - template< typename T > + template struct forward_type { typedef T type; }; - template< typename T > + template struct ref_arg { - typedef typename boost::conditional< - boost::is_reference< T >::value, - T, - typename boost::add_rvalue_reference< T >::type >::type type; + typedef typename boost::conditional::value, T, + typename boost::add_rvalue_reference::type>::type type; }; - template< typename T > - inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t) + template + inline T&& move_if_not_lvalue_reference(typename boost::remove_reference::type& t) { - return static_cast< T&& >(t); + return static_cast(t); } - template< typename T > - inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type&& t) + template + inline T&& move_if_not_lvalue_reference(typename boost::remove_reference::type&& t) { - return static_cast< T&& >(t); + return static_cast(t); } #else - template< typename T > + template struct forward_type { - typedef typename boost::decay< const T >::type type; + typedef typename boost::decay::type type; }; - template< class T> - struct forward_type< boost::rv< T > > + template + struct forward_type> { typedef T type; }; - template< typename T > + template struct ref_arg { - typedef typename boost::conditional< - boost::is_reference< T >::value, - T, - const typename boost::add_reference< T >::type >::type type; + typedef typename boost::conditional::value, T, + const typename boost::add_reference::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) + template + inline typename boost::remove_reference::type& + move_if_not_lvalue_reference(typename boost::remove_reference::type& t) { return t; } #endif -} -} +}} // namespace mock::detail -#endif // MOCK_MOVE_HELPER_HPP_INCLUDED +#endif // MOCK_MOVE_HELPER_HPP_INCLUDED diff --git a/include/turtle/detail/mutex.hpp b/include/turtle/detail/mutex.hpp index b5dcb35..d4a999d 100644 --- a/include/turtle/detail/mutex.hpp +++ b/include/turtle/detail/mutex.hpp @@ -17,24 +17,21 @@ #ifdef MOCK_THREAD_SAFE -#ifdef MOCK_HDR_MUTEX -#include -#else -#include -#include -#endif +# ifdef MOCK_HDR_MUTEX +# include +# else +# include +# include +# endif -namespace mock -{ -namespace detail -{ -#ifdef MOCK_HDR_MUTEX +namespace mock { namespace detail { +# ifdef MOCK_HDR_MUTEX typedef std::recursive_mutex mutex; - typedef std::lock_guard< mutex > scoped_lock; -#else + typedef std::lock_guard scoped_lock; +# else typedef boost::recursive_mutex mutex; - typedef boost::lock_guard< mutex > scoped_lock; -#endif + typedef boost::lock_guard scoped_lock; +# endif struct lock { @@ -42,23 +39,18 @@ 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& m) : m_(m) { m_->lock(); } ~lock() { - if( m_ ) + 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(); } - lock& operator=( BOOST_RV_REF( lock ) x ) + lock& operator=(BOOST_RV_REF(lock) x) { m_ = x.m_; x.m_.reset(); @@ -66,32 +58,24 @@ namespace detail } private: - boost::shared_ptr< mutex > m_; + boost::shared_ptr 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,68 +83,56 @@ 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&) {} + ~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, public mutex { - MOCK_SINGLETON_CONS( error_mutex_t ); + MOCK_SINGLETON_CONS(error_mutex_t); }; - MOCK_SINGLETON_INST( error_mutex ) + MOCK_SINGLETON_INST(error_mutex) #ifdef BOOST_MSVC -# pragma warning( push ) -# pragma warning( disable: 4702 ) +# pragma warning(push) +# pragma warning(disable : 4702) #endif - template< typename Result, typename Error > + template struct safe_error { static Result abort() { - scoped_lock _( error_mutex ); + scoped_lock _(error_mutex); return Error::abort(); } - template< typename Context > - static void fail( const char* message, const Context& context, - const char* file = "unknown location", int line = 0 ) + template + 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 ); + scoped_lock _(error_mutex); + Error::fail(message, context, file, line); } - template< typename Context > - static void call( const Context& context, const char* file, int line ) + template + static void call(const Context& context, const char* file, int line) { - scoped_lock _( error_mutex ); - Error::call( context, file, line ); + scoped_lock _(error_mutex); + Error::call(context, file, line); } - static void pass( const char* file, int line ) + static void pass(const char* file, int line) { - scoped_lock _( error_mutex ); - Error::pass( file, line ); + scoped_lock _(error_mutex); + Error::pass(file, line); } }; #ifdef BOOST_MSVC -# pragma warning( pop ) +# pragma warning(pop) #endif -} -} // mock +}} // namespace mock::detail #endif // MOCK_MUTEX_HPP_INCLUDED diff --git a/include/turtle/detail/object_impl.hpp b/include/turtle/detail/object_impl.hpp index 6aa215f..3556296 100644 --- a/include/turtle/detail/object_impl.hpp +++ b/include/turtle/detail/object_impl.hpp @@ -10,58 +10,50 @@ #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 +#include "parent.hpp" +#include "root.hpp" +#include "type_name.hpp" #include #include #include +#include -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 { public: - object_impl() - : mutex_( boost::make_shared< mutex >() ) - {} + object_impl() : mutex_(boost::make_shared()) {} - 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, boost::unit_test::const_string name) { - lock _( mutex_ ); - if( children_.empty() ) - detail::root.add( *this ); - children_[ &v ].update( parent_, instance, type, name ); + lock _(mutex_); + if(children_.empty()) + detail::root.add(*this); + children_[&v].update(parent_, instance, type, name); } - virtual void add( verifiable& v ) + virtual void add(verifiable& v) { - lock _( mutex_ ); - group_.add( v ); + lock _(mutex_); + group_.add(v); } - virtual void remove( verifiable& v ) + virtual void remove(verifiable& v) { - lock _( mutex_ ); - group_.remove( v ); - children_.erase( &v ); - if( children_.empty() ) - detail::root.remove( *this ); + lock _(mutex_); + group_.remove(v); + children_.erase(&v); + if(children_.empty()) + detail::root.remove(*this); } - virtual void serialize( std::ostream& s, const verifiable& v ) const + virtual void serialize(std::ostream& s, const verifiable& v) const { - lock _( mutex_ ); - children_cit it = children_.find( &v ); - if( it != children_.end() ) + lock _(mutex_); + children_cit it = children_.find(&v); + if(it != children_.end()) s << it->second; else s << "?"; @@ -69,26 +61,25 @@ namespace detail virtual bool verify() const { - lock _( mutex_ ); + lock _(mutex_); return group_.verify(); } virtual void reset() { - lock _( mutex_ ); - boost::shared_ptr< object_impl > guard = shared_from_this(); + lock _(mutex_); + boost::shared_ptr guard = shared_from_this(); group_.reset(); } private: - typedef std::map< const verifiable*, child > children_t; + typedef std::map children_t; typedef children_t::const_iterator children_cit; group group_; parent parent_; children_t children_; - const boost::shared_ptr< mutex > mutex_; + const boost::shared_ptr mutex_; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_OBJECT_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/parameter.hpp b/include/turtle/detail/parameter.hpp index 38925a2..9ce4e89 100644 --- a/include/turtle/detail/parameter.hpp +++ b/include/turtle/detail/parameter.hpp @@ -10,25 +10,16 @@ #define MOCK_PARAMETER_HPP_INCLUDED #include "../config.hpp" -#include #include +#include #include -namespace mock -{ -namespace detail -{ - template< typename Signature, int n > +namespace mock { namespace detail { + template struct parameter { - typedef typename - boost::mpl::at_c< - typename - boost::function_types::parameter_types< Signature >, - n - >::type type; + typedef typename boost::mpl::at_c, n>::type type; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_PARAMETER_HPP_INCLUDED diff --git a/include/turtle/detail/parent.hpp b/include/turtle/detail/parent.hpp index 0d14e77..2ba2248 100644 --- a/include/turtle/detail/parent.hpp +++ b/include/turtle/detail/parent.hpp @@ -11,36 +11,30 @@ #include "../config.hpp" #include "type_name.hpp" -#include #include +#include #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class parent { public: - parent() + parent() {} + parent(boost::unit_test::const_string instance, boost::optional type) + : instance_(instance), type_(type) {} - 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 ) + friend std::ostream& operator<<(std::ostream& s, const parent& p) { s << p.instance_; - if( p.type_ ) + if(p.type_) s << *p.type_ << "::"; return s; } + private: boost::unit_test::const_string instance_; - boost::optional< type_name > type_; + boost::optional type_; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_PARENT_HPP_INCLUDED diff --git a/include/turtle/detail/root.hpp b/include/turtle/detail/root.hpp index dae3790..7948080 100644 --- a/include/turtle/detail/root.hpp +++ b/include/turtle/detail/root.hpp @@ -10,117 +10,99 @@ #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 -#include #include +#include -namespace mock -{ -namespace detail -{ - class root_t : public singleton< root_t >, public context +namespace mock { namespace detail { + class root_t : public singleton, 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, 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 ) ) ); - it->second.update( instance, type, 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))); + it->second.update(instance, type, name); } - virtual void add( verifiable& v ) + virtual void add(verifiable& v) { - scoped_lock _( mutex_ ); - group_.add( v ); + scoped_lock _(mutex_); + group_.add(v); } - virtual void remove( verifiable& v ) + virtual void remove(verifiable& v) { - scoped_lock _( mutex_ ); - group_.remove( v ); - children_.erase( &v ); + scoped_lock _(mutex_); + group_.remove(v); + children_.erase(&v); } bool verify() const { - scoped_lock _( mutex_ ); + scoped_lock _(mutex_); return group_.verify(); } void reset() { - scoped_lock _( mutex_ ); + scoped_lock _(mutex_); group_.reset(); } - virtual void serialize( std::ostream& s, const verifiable& v ) const + virtual void serialize(std::ostream& s, const verifiable& v) const { - scoped_lock _( mutex_ ); - children_cit it = children_.find( &v ); - if( it != children_.end() ) + scoped_lock _(mutex_); + children_cit it = children_.find(&v); + if(it != children_.end()) s << it->second; else s << "?"; } private: - typedef std::map< const void*, - std::pair< parent, std::size_t > > parents_t; + typedef std::map> 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 ) + counter_child(parents_t& parents, const void* p) + : 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; } ~counter_child() { - if( --it_->second.second == 0 ) - parents_->erase( it_ ); + if(--it_->second.second == 0) + parents_->erase(it_); } - void update( boost::unit_test::const_string instance, - boost::optional< type_name > type, - boost::unit_test::const_string name ) + void update(boost::unit_test::const_string instance, boost::optional 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_; + child_.update(it_->second.first, instance, type, name); } + friend std::ostream& operator<<(std::ostream& s, const counter_child& c) { return s << c.child_; } private: - counter_child& operator=( const counter_child& ); + counter_child& operator=(const counter_child&); parents_t* parents_; parents_t::iterator it_; child child_; }; - typedef std::map< const verifiable*, counter_child > children_t; + typedef std::map children_t; typedef children_t::const_iterator children_cit; parents_t parents_; @@ -128,10 +110,9 @@ namespace detail group group_; mutable mutex mutex_; - MOCK_SINGLETON_CONS( root_t ); + MOCK_SINGLETON_CONS(root_t); }; - MOCK_SINGLETON_INST( root ) -} -} // mock + MOCK_SINGLETON_INST(root) +}} // namespace mock::detail #endif // MOCK_ROOT_HPP_INCLUDED diff --git a/include/turtle/detail/sequence_impl.hpp b/include/turtle/detail/sequence_impl.hpp index c7d3ce6..b7bab1f 100644 --- a/include/turtle/detail/sequence_impl.hpp +++ b/include/turtle/detail/sequence_impl.hpp @@ -11,57 +11,48 @@ #include "../config.hpp" #include "mutex.hpp" -#include #include +#include #include #include -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()) {} - void add( void* e ) + void add(void* e) { - lock _( mutex_ ); - elements_.push_back( e ); + lock _(mutex_); + elements_.push_back(e); } - void remove( void* e ) + void remove(void* e) { - lock _( mutex_ ); - elements_.erase( std::remove( elements_.begin(), - elements_.end(), e ), elements_.end() ); + lock _(mutex_); + elements_.erase(std::remove(elements_.begin(), elements_.end(), e), elements_.end()); } - bool is_valid( const void* e ) const + bool is_valid(const void* e) const { - lock _( mutex_ ); - return std::find( elements_.begin(), elements_.end(), e ) - != elements_.end(); + lock _(mutex_); + return std::find(elements_.begin(), elements_.end(), e) != elements_.end(); } - void invalidate( const void* e ) + void invalidate(const void* e) { - lock _( mutex_ ); - elements_type::iterator it = - std::find( elements_.begin(), elements_.end(), e ); - if( it != elements_.end() ) - elements_.erase( elements_.begin(), it ); + lock _(mutex_); + elements_type::iterator it = std::find(elements_.begin(), elements_.end(), e); + if(it != elements_.end()) + elements_.erase(elements_.begin(), it); } private: - typedef std::vector< void* > elements_type; + typedef std::vector elements_type; elements_type elements_; - const boost::shared_ptr< mutex > mutex_; + const boost::shared_ptr mutex_; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_SEQUENCE_IMPL_HPP_INCLUDED diff --git a/include/turtle/detail/signature.hpp b/include/turtle/detail/signature.hpp index 03c016c..aec9cd7 100644 --- a/include/turtle/detail/signature.hpp +++ b/include/turtle/detail/signature.hpp @@ -10,36 +10,24 @@ #define MOCK_SIGNATURE_HPP_INCLUDED #include "../config.hpp" -#include #include +#include #include -#include #include #include +#include #define BOOST_TYPEOF_SILENT #include -namespace mock -{ -namespace detail -{ - template< typename M > +namespace mock { namespace detail { + template 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::type>, + typename boost::mpl::pop_front>::type>> {}; - template< typename T > + template struct base { typedef T base_type; @@ -48,16 +36,12 @@ namespace detail // if an error is generated by the line below it means // the method is ambiguous : specify its signature to // disambiguate - template< typename T > - T& ambiguous_method_requires_to_specify_signature( const T& ); -} -} // mock + template + T& ambiguous_method_requires_to_specify_signature(const T&); +}} // namespace mock::detail -#define MOCK_SIGNATURE(M) \ - mock::detail::signature< \ - BOOST_TYPEOF( \ - mock::detail::ambiguous_method_requires_to_specify_signature( \ - &base_type::M ) ) \ - >::type +#define MOCK_SIGNATURE(M) \ + mock::detail::signature::type #endif // MOCK_SIGNATURE_HPP_INCLUDED diff --git a/include/turtle/detail/singleton.hpp b/include/turtle/detail/singleton.hpp index 2080750..e58ca5c 100644 --- a/include/turtle/detail/singleton.hpp +++ b/include/turtle/detail/singleton.hpp @@ -11,36 +11,34 @@ #include -namespace mock { -namespace detail { +namespace mock { namespace detail { -template< typename Derived > -class singleton { -public: - static Derived& instance() + template + class singleton { - static Derived the_inst; - return the_inst; - } + public: + static Derived& instance() + { + static Derived the_inst; + return the_inst; + } - BOOST_DELETED_FUNCTION(singleton(singleton const&)) - BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&)) + BOOST_DELETED_FUNCTION(singleton(singleton const&)) + BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&)) -protected: - BOOST_DEFAULTED_FUNCTION(singleton(), {}) - BOOST_DEFAULTED_FUNCTION(~singleton(), {}) -}; + protected: + BOOST_DEFAULTED_FUNCTION(singleton(), {}) + BOOST_DEFAULTED_FUNCTION(~singleton(), {}) + }; -} // detail -} // mock +}} // namespace mock::detail // Add a private ctor to the type to prevent misuse -#define MOCK_SINGLETON_CONS( type ) \ -private: \ -friend class mock::detail::singleton< type >; \ -type() {} +#define MOCK_SINGLETON_CONS(type) \ +private: \ + friend class mock::detail::singleton; \ + 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 diff --git a/include/turtle/detail/type_name.hpp b/include/turtle/detail/type_name.hpp index 8264601..39451f8 100644 --- a/include/turtle/detail/type_name.hpp +++ b/include/turtle/detail/type_name.hpp @@ -10,108 +10,101 @@ #define MOCK_TYPE_NAME_HPP_INCLUDED #include "../config.hpp" -#include -#include #include +#include #include +#include #include #if BOOST_VERSION >= 107000 -# include -# define MOCK_TYPEID( t ) BOOST_CORE_TYPEID(t) -# define MOCK_TYPEINFO boost::core::typeinfo +# include +# define MOCK_TYPEID(t) BOOST_CORE_TYPEID(t) +# define MOCK_TYPEINFO boost::core::typeinfo #else -# include -# define MOCK_TYPEID( t ) BOOST_SP_TYPEID(t) -# define MOCK_TYPEINFO boost::detail::sp_typeinfo +# include +# define MOCK_TYPEID(t) BOOST_SP_TYPEID(t) +# define MOCK_TYPEINFO boost::detail::sp_typeinfo #endif #include +#include #include #include -#include #ifdef __GNUC__ -#include -#include +# include +# include #endif -#define MOCK_TYPE_NAME( t ) mock::detail::type_name( MOCK_TYPEID(t) ) +#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 ) - {} - friend std::ostream& operator<<( std::ostream& s, const type_name& t ) + 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_ ); + 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 ); - if( ! status && demangled ) - serialize( s, demangled.get() ); + boost::shared_ptr demangled(abi::__cxa_demangle(name, 0, 0, &status), &std::free); + if(!status && demangled) + serialize(s, demangled.get()); else #endif - serialize( s, name ); + serialize(s, name); } typedef std::string::size_type size_type; - void serialize( std::ostream& s, std::string name ) const + void serialize(std::ostream& s, std::string name) const { - const size_type nm = rfind( name, ':' ) + 1; - const size_type tpl = name.find( '<', nm ); - s << clean( name.substr( nm, tpl - nm ) ); - if( tpl == std::string::npos ) + const size_type nm = rfind(name, ':') + 1; + const size_type tpl = name.find('<', nm); + s << clean(name.substr(nm, tpl - nm)); + if(tpl == std::string::npos) return; s << '<'; - list( s, name.substr( tpl + 1, name.rfind( '>' ) - tpl - 1 ) ); + list(s, name.substr(tpl + 1, name.rfind('>') - tpl - 1)); s << '>'; } - void list( std::ostream& s, const std::string& name ) const + void list(std::ostream& s, const std::string& name) const { - const size_type comma = rfind( name, ',' ); - if( comma != std::string::npos ) + const size_type comma = rfind(name, ','); + if(comma != std::string::npos) { - list( s, name.substr( 0, comma ) ); + list(s, name.substr(0, comma)); s << ", "; } - serialize( s, name.substr( comma + 1 ) ); + serialize(s, name.substr(comma + 1)); } - std::string clean( std::string name ) const + std::string clean(std::string name) const { - boost::algorithm::trim( name ); - boost::algorithm::erase_all( name, "class " ); - boost::algorithm::erase_all( name, "struct " ); - boost::algorithm::erase_all( name, "__ptr64" ); - boost::algorithm::replace_all( name, " &", "&" ); - boost::algorithm::replace_all( name, "& ", "&" ); - boost::algorithm::replace_all( name, " *", "*" ); - boost::algorithm::replace_all( name, "* ", "*" ); + boost::algorithm::trim(name); + boost::algorithm::erase_all(name, "class "); + boost::algorithm::erase_all(name, "struct "); + boost::algorithm::erase_all(name, "__ptr64"); + boost::algorithm::replace_all(name, " &", "&"); + boost::algorithm::replace_all(name, "& ", "&"); + boost::algorithm::replace_all(name, " *", "*"); + boost::algorithm::replace_all(name, "* ", "*"); return name; } - size_type rfind( const std::string& name, char c ) const + size_type rfind(const std::string& name, char c) const { size_type count = 0; - for( size_type i = name.size() - 1; i > 0; --i ) + for(size_type i = name.size() - 1; i > 0; --i) { - if( name[ i ] == '>' ) + if(name[i] == '>') ++count; - else if( name[ i ] == '<' ) + else if(name[i] == '<') --count; - if( name[ i ] == c && count == 0 ) + if(name[i] == c && count == 0) return i; } return std::string::npos; @@ -119,7 +112,6 @@ namespace detail const MOCK_TYPEINFO* info_; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_TYPE_NAME_HPP_INCLUDED diff --git a/include/turtle/detail/verifiable.hpp b/include/turtle/detail/verifiable.hpp index 5d85c93..8f8eb11 100644 --- a/include/turtle/detail/verifiable.hpp +++ b/include/turtle/detail/verifiable.hpp @@ -12,10 +12,7 @@ #include "../config.hpp" #include -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 diff --git a/include/turtle/error.hpp b/include/turtle/error.hpp index 95be42c..fd48a3e 100644 --- a/include/turtle/error.hpp +++ b/include/turtle/error.hpp @@ -11,69 +11,59 @@ #include "config.hpp" #ifdef MOCK_USE_BOOST_TEST -#include "exception.hpp" -#include -#include -#include -#include -#include +# include "exception.hpp" +# include +# include +# include +# include +# include -namespace mock +namespace mock { +template +struct error { - template< typename Result > - struct error + static Result abort() { - static Result abort() - { - boost::unit_test::framework::test_unit_aborted( - boost::unit_test::framework::current_test_case() ); - throw boost::enable_current_exception( exception() ); - } + 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 ) ); - } + static void pass(const char* file, int line) + { + boost::unit_test::unit_test_log.set_checkpoint(file, static_cast(line)); + } - template< typename Context > - 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 - false -#else - 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::log::end(); - } + template + 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 + false +# else + boost::unit_test::AR_FAILED +# endif + ); + boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast(line)) + << boost::unit_test::log_all_errors << message << ": " << context + << boost::unit_test::log::end(); + } - template< typename Context > - static void call( const Context& context, const char* file, int line ) - { - boost::unit_test::framework::assertion_result( -#if BOOST_VERSION < 105900 - true -#else - 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::log_successful_tests - << "mock expectation fulfilled: " << context - << boost::unit_test::log::end(); - } - }; -} // mock + template + static void call(const Context& context, const char* file, int line) + { + boost::unit_test::framework::assertion_result( +# if BOOST_VERSION < 105900 + true +# else + boost::unit_test::AR_PASSED +# endif + ); + boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast(line)) + << boost::unit_test::log_successful_tests + << "mock expectation fulfilled: " << context << boost::unit_test::log::end(); + } +}; +} // namespace mock #endif // MOCK_USE_BOOST_TEST diff --git a/include/turtle/exception.hpp b/include/turtle/exception.hpp index 4e7796c..ced9893 100644 --- a/include/turtle/exception.hpp +++ b/include/turtle/exception.hpp @@ -11,13 +11,12 @@ #include "config.hpp" #ifdef MOCK_USE_BOOST_TEST -#include +# include -namespace mock -{ - struct exception : virtual boost::execution_aborted - {}; -} // mock +namespace mock { +struct exception : virtual boost::execution_aborted +{}; +} // namespace mock #endif // MOCK_USE_BOOST_TEST diff --git a/include/turtle/format.hpp b/include/turtle/format.hpp index 6b4095c..56aa1e1 100644 --- a/include/turtle/format.hpp +++ b/include/turtle/format.hpp @@ -12,14 +12,13 @@ #include "config.hpp" #include "detail/formatter.hpp" -namespace mock +namespace mock { +template +detail::formatter format(const T& t) { - template< typename T > - detail::formatter< T > format( const T& t ) - { - return detail::formatter< T >( t ); - } + return detail::formatter(t); +} -} // mock +} // namespace mock #endif // MOCK_FORMAT_HPP_INCLUDED diff --git a/include/turtle/log.hpp b/include/turtle/log.hpp index 104c9fe..988ddbe 100644 --- a/include/turtle/log.hpp +++ b/include/turtle/log.hpp @@ -10,195 +10,186 @@ #define MOCK_LOG_HPP_INCLUDED #include "config.hpp" -#include "stream.hpp" #include "format.hpp" -#include +#include "stream.hpp" #include #include #include +#include #include -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 +class shared_ptr; +template +class weak_ptr; +template +class reference_wrapper; +template +class optional; -namespace phoenix -{ - template< typename T > struct actor; +namespace phoenix { + template + struct actor; } -namespace lambda -{ - template< typename T > class lambda_functor; -} -namespace assign_detail -{ - template< typename T > class generic_list; +namespace lambda { + template + class lambda_functor; } +namespace assign_detail { + template + class generic_list; } +} // namespace boost -namespace mock -{ -namespace detail -{ - template< typename T > - void serialize( stream& s, const T& begin, const T& end ) +namespace mock { +namespace detail { + template + void serialize(stream& s, const T& begin, const T& end) { s << '('; - for( T it = begin; it != end; ++it ) - s << (it == begin ? "" : ",") << mock::format( *it ); + for(T it = begin; it != end; ++it) + s << (it == begin ? "" : ",") << mock::format(*it); s << ')'; } -} +} // namespace detail #ifdef MOCK_AUTO_PTR - template< typename T > - stream& operator<<( stream& s, const std::auto_ptr< T >& t ) - { - return s << mock::format( t.get() ); - } +template +stream& operator<<(stream& s, const std::auto_ptr& t) +{ + return s << mock::format(t.get()); +} #endif // MOCK_AUTO_PTR - 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 ) << ')'; - } +template +stream& operator<<(stream& s, const std::pair& p) +{ + return s << '(' << mock::format(p.first) << ',' << mock::format(p.second) << ')'; +} - template< typename T, typename A > - stream& operator<<( stream& s, const std::deque< T, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T, typename A > - stream& operator<<( stream& s, const std::list< T, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T, typename A > - stream& operator<<( stream& s, const std::vector< T, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename K, typename T, typename C, typename A > - stream& operator<<( stream& s, const std::map< K, T, C, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename K, typename T, typename C, typename A > - stream& operator<<( stream& s, const std::multimap< K, T, C, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T, typename C, typename A > - stream& operator<<( stream& s, const std::set< T, C, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T, typename C, typename A > - stream& operator<<( stream& s, const std::multiset< T, C, A >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T > - stream& operator<<( stream& s, - const boost::assign_detail::generic_list< T >& t ) - { - detail::serialize( s, t.begin(), t.end() ); - return s; - } - template< typename T > - stream& operator<<( stream& s, const boost::reference_wrapper< T >& t ) - { - return s << mock::format( t.get() ); - } - template< typename T > - stream& operator<<( stream& s, const boost::shared_ptr< T >& t ) - { - return s << mock::format( t.get() ); - } - template< typename T > - stream& operator<<( stream& s, const boost::weak_ptr< T >& t ) - { - return s << mock::format( t.lock() ); - } - inline stream& operator<<( stream& s, const boost::none_t& ) - { - return s << "none"; - } - template< typename T > - stream& operator<<( stream& s, const boost::optional< T >& t ) - { - if( t ) - return s << mock::format( t.get() ); - return s << boost::none; - } +template +stream& operator<<(stream& s, const std::deque& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::list& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::vector& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::map& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::multimap& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::set& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const std::multiset& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const boost::assign_detail::generic_list& t) +{ + detail::serialize(s, t.begin(), t.end()); + return s; +} +template +stream& operator<<(stream& s, const boost::reference_wrapper& t) +{ + return s << mock::format(t.get()); +} +template +stream& operator<<(stream& s, const boost::shared_ptr& t) +{ + return s << mock::format(t.get()); +} +template +stream& operator<<(stream& s, const boost::weak_ptr& t) +{ + return s << mock::format(t.lock()); +} +inline stream& operator<<(stream& s, const boost::none_t&) +{ + return s << "none"; +} +template +stream& operator<<(stream& s, const boost::optional& t) +{ + if(t) + return s << mock::format(t.get()); + return s << boost::none; +} #ifdef MOCK_SMART_PTR - template< typename T > - stream& operator<<( stream& s, const std::shared_ptr< T >& t ) - { - return s << mock::format( t.get() ); - } - template< typename T > - stream& operator<<( stream& s, const std::weak_ptr< T >& t ) - { - return s << mock::format( t.lock() ); - } - template< typename T, typename D > - stream& operator<<( stream& s, const std::unique_ptr< T, D >& p ) - { - return s << mock::format( p.get() ); - } +template +stream& operator<<(stream& s, const std::shared_ptr& t) +{ + return s << mock::format(t.get()); +} +template +stream& operator<<(stream& s, const std::weak_ptr& t) +{ + return s << mock::format(t.lock()); +} +template +stream& operator<<(stream& s, const std::unique_ptr& p) +{ + return s << mock::format(p.get()); +} #endif - template< typename T > - stream& operator<<( stream& s, const boost::lambda::lambda_functor< T >& ) - { - return s << '?'; - } - template< typename T > - stream& operator<<( stream& s, const boost::phoenix::actor< T >& ) - { - return s << '?'; - } +template +stream& operator<<(stream& s, const boost::lambda::lambda_functor&) +{ + return s << '?'; +} +template +stream& operator<<(stream& s, const boost::phoenix::actor&) +{ + return s << '?'; +} #ifdef MOCK_NULLPTR - inline stream& operator<<( stream& s, std::nullptr_t ) - { - return s << "nullptr"; - } +inline stream& operator<<(stream& s, std::nullptr_t) +{ + return s << "nullptr"; +} #endif - template< typename 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 ) - { - *s.s_ << t; - return s; - } -} // mock +template +typename boost::enable_if, stream&>::type operator<<(stream& s, T*) +{ + return s << '?'; +} +template +typename boost::disable_if, stream&>::type operator<<(stream& s, T* t) +{ + *s.s_ << t; + return s; +} +} // namespace mock #endif // MOCK_LOG_HPP_INCLUDED diff --git a/include/turtle/matcher.hpp b/include/turtle/matcher.hpp index c6082a7..6db5ccd 100644 --- a/include/turtle/matcher.hpp +++ b/include/turtle/matcher.hpp @@ -10,101 +10,72 @@ #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 -#include +#include "log.hpp" #include +#include +#include #include -namespace mock +namespace mock { +template +class matcher { - template< typename Actual, typename Expected, typename Enable = void > - class matcher +public: + explicit matcher(Expected expected) : expected_(expected) {} + bool operator()(typename boost::add_reference::type actual) { - public: - 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_ ); - } - private: - Expected 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_); } - template<> - 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_ ); - } - private: - const char* expected_; - }; +private: + Expected expected_; +}; - template< typename Actual, typename Constraint > - class matcher< Actual, mock::constraint< Constraint > > - { - public: - 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_ ); - } - private: - Constraint c_; - }; +template<> +class matcher +{ +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_); } - template< typename Actual, typename Functor > - class matcher< Actual, Functor, - typename boost::enable_if< - detail::is_functor< Functor, Actual > - >::type - > +private: + const char* expected_; +}; + +template +class matcher> +{ +public: + explicit matcher(const constraint& c) : c_(c.c_) {} + bool operator()(typename detail::ref_arg::type actual) { - public: - 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_ ); - } - private: - Functor c_; - }; -} // mock + return c_(mock::detail::move_if_not_lvalue_reference::type>(actual)); + } + friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); } + +private: + Constraint c_; +}; + +template +class matcher>::type> +{ +public: + explicit matcher(const Functor& f) : c_(f) {} + bool operator()(typename detail::ref_arg::type actual) + { + return c_(mock::detail::move_if_not_lvalue_reference::type>(actual)); + } + friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); } + +private: + Functor c_; +}; +} // namespace mock #endif // MOCK_MATCHER_HPP_INCLUDED diff --git a/include/turtle/mock.hpp b/include/turtle/mock.hpp index f873cee..be32b04 100644 --- a/include/turtle/mock.hpp +++ b/include/turtle/mock.hpp @@ -9,245 +9,198 @@ #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 #include #include #include -#include -#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::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 f, f##_mock +# define MOCK_FUNCTOR_TPL(f, ...) mock::detail::functor 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 -#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 f, f##_mock +# define MOCK_FUNCTOR_TPL(f, S) mock::detail::functor 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 \ - { \ - 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_METHOD_HELPER(S, t, tpn) \ + mutable mock::detail::function t##_mock_; \ + mock::detail::function& t##_mock( \ + 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)); \ + 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::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)) -#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_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::value); \ + return MOCK_ANONYMOUS_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \ } -#define MOCK_METHOD_EXT(M, n, S, t) \ - MOCK_METHOD_AUX(M, n, S, t,,) \ - MOCK_METHOD_AUX(M, n, S, t, const,) \ - MOCK_METHOD_HELPER(S, t,) +#define MOCK_METHOD_EXT(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t, , ) \ + MOCK_METHOD_AUX(M, n, S, t, const, ) \ + MOCK_METHOD_HELPER(S, t, ) #define MOCK_CONST_METHOD_EXT(M, n, S, t) \ - MOCK_METHOD_AUX(M, n, S, t, const,) \ - MOCK_METHOD_HELPER(S, t,) + MOCK_METHOD_AUX(M, n, S, t, const, ) \ + MOCK_METHOD_HELPER(S, t, ) #define MOCK_NON_CONST_METHOD_EXT(M, n, S, t) \ - MOCK_METHOD_AUX(M, n, S, t,,) \ - MOCK_METHOD_HELPER(S, t,) + MOCK_METHOD_AUX(M, n, S, t, , ) \ + MOCK_METHOD_HELPER(S, t, ) -#define MOCK_METHOD_EXT_TPL(M, n, S, t) \ - MOCK_METHOD_AUX(M, n, S, t,, typename) \ +#define MOCK_METHOD_EXT_TPL(M, n, S, t) \ + MOCK_METHOD_AUX(M, n, S, t, , typename) \ MOCK_METHOD_AUX(M, n, S, t, const, typename) \ MOCK_METHOD_HELPER(S, t, typename) -#define MOCK_CONST_METHOD_EXT_TPL(M, n, S, t) \ +#define MOCK_CONST_METHOD_EXT_TPL(M, n, S, t) \ MOCK_METHOD_AUX(M, n, S, t, const, typename) \ MOCK_METHOD_HELPER(S, t, typename) #define MOCK_NON_CONST_METHOD_EXT_TPL(M, n, S, t) \ - MOCK_METHOD_AUX(M, n, S, t,, typename) \ + MOCK_METHOD_AUX(M, n, S, t, , typename) \ MOCK_METHOD_HELPER(S, t, typename) -#define MOCK_CONVERSION_OPERATOR(M, T, t) \ +#define MOCK_CONVERSION_OPERATOR(M, T, t) \ M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ - M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ - MOCK_METHOD_HELPER(T(), t,) -#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t, ) +#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \ M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ - MOCK_METHOD_HELPER(T(), t,) + MOCK_METHOD_HELPER(T(), t, ) #define MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, t) \ - M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ - MOCK_METHOD_HELPER(T(), t,) + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + MOCK_METHOD_HELPER(T(), t, ) -#define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) \ +#define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) \ M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ - M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ MOCK_METHOD_HELPER(T(), t, typename) -#define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \ +#define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \ M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ MOCK_METHOD_HELPER(T(), t, typename) #define MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \ - M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ 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, \ - boost::unit_test::const_string instance ) \ - { \ - static mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) > f; \ - return f( context, instance ); \ +#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \ + s mock::detail::function& t##_mock(mock::detail::context& context, \ + boost::unit_test::const_string instance) \ + { \ + static mock::detail::function f; \ + return f(context, instance); \ } -#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) ); \ - } \ +#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)); } \ 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( ... ) {} } \ - MOCK_METHOD_HELPER(void(), t,) +#define MOCK_DESTRUCTOR(T, t) \ + 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 ); \ - return MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, S, tpn) ); \ +#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::value); \ + return MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \ } #ifdef MOCK_VARIADIC_MACROS -#define MOCK_VARIADIC_ELEM_0(e0, ...) e0 -#define MOCK_VARIADIC_ELEM_1(e0, e1, ...) e1 -#define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2 +# define MOCK_VARIADIC_ELEM_0(e0, ...) e0 +# define MOCK_VARIADIC_ELEM_1(e0, e1, ...) e1 +# define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2 -#define MOCK_METHOD(M, ...) \ - 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_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_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \ - MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, )) +# define MOCK_METHOD(M, ...) \ + 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_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_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, )) -#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, )) -#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, )) +# 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, )) +# 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, )) +# 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, )) -#define MOCK_FUNCTION(F, n, ...) \ - MOCK_FUNCTION_AUX(F, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ - inline,) +# define MOCK_FUNCTION(F, n, ...) \ + 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,) +# 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, ) -#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) +# 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) #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 -#define MOCK_EXPECT(t) MOCK_HELPER(t).expect( __FILE__, __LINE__ ) -#define MOCK_RESET(t) MOCK_HELPER(t).reset( __FILE__, __LINE__ ) -#define MOCK_VERIFY(t) MOCK_HELPER(t).verify( __FILE__, __LINE__ ) +#define MOCK_EXPECT(t) MOCK_HELPER(t).expect(__FILE__, __LINE__) +#define MOCK_RESET(t) MOCK_HELPER(t).reset(__FILE__, __LINE__) +#define MOCK_VERIFY(t) MOCK_HELPER(t).verify(__FILE__, __LINE__) #endif // MOCK_MOCK_HPP_INCLUDED diff --git a/include/turtle/object.hpp b/include/turtle/object.hpp index d201757..630e696 100644 --- a/include/turtle/object.hpp +++ b/include/turtle/object.hpp @@ -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 +#include #include #include #include -#include -#include -namespace mock -{ - class object; +namespace mock { +class object; -namespace detail -{ - template< typename E > - E& configure( const object& o, E& e, - boost::unit_test::const_string instance, - boost::optional< type_name > type, - boost::unit_test::const_string name ); +namespace detail { + template + E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional 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, - boost::unit_test::const_string name, - typename boost::disable_if< - typename boost::is_base_of< object, T > - >::type* = 0 ) + template + E& configure(const T& t, E& e, boost::unit_test::const_string instance, boost::optional type, + boost::unit_test::const_string name, + typename boost::disable_if>::type* = 0) { - e.configure( detail::root, &t, instance, type, name ); + e.configure(detail::root, &t, instance, type, name); return e; } -} - class object - { - public: - object() - : impl_( boost::make_shared< detail::object_impl >() ) - {} - protected: - ~object() - {} - public: - boost::shared_ptr< detail::object_impl > impl_; - }; - -namespace detail +} // namespace detail +class object { - template< typename E > - E& configure( const object& o, E& e, - boost::unit_test::const_string instance, - boost::optional< type_name > type, - boost::unit_test::const_string name ) +public: + object() : impl_(boost::make_shared()) {} + +protected: + ~object() {} + +public: + boost::shared_ptr impl_; +}; + +namespace detail { + template + E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional type, + boost::unit_test::const_string name) { - e.configure( *o.impl_, o.impl_.get(), instance, type, name ); + e.configure(*o.impl_, o.impl_.get(), instance, type, name); return e; } -} -} // mock +} // namespace detail +} // namespace mock #endif // MOCK_OBJECT_HPP_INCLUDED diff --git a/include/turtle/reset.hpp b/include/turtle/reset.hpp index 20237b9..4315d4c 100644 --- a/include/turtle/reset.hpp +++ b/include/turtle/reset.hpp @@ -10,25 +10,24 @@ #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() { - inline void reset() - { - detail::root.reset(); - } - inline void reset( const object& o ) - { - o.impl_->reset(); - } - template< typename Signature > - void reset( detail::functor< Signature >& f ) - { - f.reset(); - } -} // mock + detail::root.reset(); +} +inline void reset(const object& o) +{ + o.impl_->reset(); +} +template +void reset(detail::functor& f) +{ + f.reset(); +} +} // namespace mock #endif // MOCK_RESET_HPP_INCLUDED diff --git a/include/turtle/sequence.hpp b/include/turtle/sequence.hpp index 28a2ee9..4e465e1 100644 --- a/include/turtle/sequence.hpp +++ b/include/turtle/sequence.hpp @@ -12,17 +12,14 @@ #include "config.hpp" #include "detail/sequence_impl.hpp" -namespace mock +namespace mock { +class sequence { - class sequence - { - public: - sequence() - : impl_( boost::make_shared< detail::sequence_impl >() ) - {} +public: + sequence() : impl_(boost::make_shared()) {} - boost::shared_ptr< detail::sequence_impl > impl_; - }; -} // mock + boost::shared_ptr impl_; +}; +} // namespace mock #endif // MOCK_SEQUENCE_HPP_INCLUDED diff --git a/include/turtle/stream.hpp b/include/turtle/stream.hpp index d8f3707..4b06909 100644 --- a/include/turtle/stream.hpp +++ b/include/turtle/stream.hpp @@ -13,48 +13,36 @@ #include #include -namespace mock +namespace mock { +struct stream { - struct stream - { - explicit stream( std::ostream& s ) - : s_( &s ) - {} - std::ostream* 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 > - sink( const T& ) + template + sink(const T&) {} }; - 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 void serialize( std::ostream& s ) const = 0; + virtual ~holder() {} + virtual void serialize(std::ostream& s) const = 0; }; - template< typename T > + template struct holder_imp : holder { - explicit holder_imp( const T& t ) - : t_( t ) - {} - virtual void serialize( std::ostream& s ) const + 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 // line below the solution is to add a serialization operator to a @@ -66,77 +54,58 @@ namespace conversion struct any : boost::noncopyable { - template< typename T > - any( const T& t ) - : h_( new holder_imp< T >( t ) ) + template + any(const T& t) : h_(new holder_imp(t)) {} - ~any() - { - delete h_; - } + ~any() { delete h_; } holder* h_; }; -} -} +}} // namespace detail::conversion - inline stream& operator<<( stream& s, const detail::conversion::any& d ) - { - d.h_->serialize( *s.s_ ); - return s; - } +inline stream& operator<<(stream& s, const detail::conversion::any& d) +{ + d.h_->serialize(*s.s_); + return s; +} #else // MOCK_USE_CONVERSIONS -namespace detail -{ -namespace conversion -{ - template< typename S, typename T > - S& operator<<( S &s, const T& ) +namespace detail { namespace conversion { + template + S& operator<<(S& s, const T&) { return s << '?'; } -} -} +}} // namespace detail::conversion - template< typename T > - stream& operator<<( stream& s, const T& t ) - { - using namespace detail::conversion; - *s.s_ << t; - return s; - } +template +stream& operator<<(stream& s, const T& t) +{ + using namespace detail::conversion; + *s.s_ << t; + return s; +} #endif // MOCK_USE_CONVERSIONS -namespace detail -{ - template< typename T > - void serialize( stream& s, const T& t ) +namespace detail { + template + void serialize(stream& s, const T& t) { // if an error about an ambiguous conversion is generated by the // line below the solution is to add a serialization operator to a // mock::stream for T s << t; } - 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 ) + inline void serialize(stream& s, bool b) { s << (b ? "true" : "false"); } + template + void serialize(stream& s, const std::basic_string& 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(c); } +} // namespace detail +} // namespace mock #endif // MOCK_STREAM_HPP_INCLUDED diff --git a/include/turtle/verify.hpp b/include/turtle/verify.hpp index 61df6df..1995374 100644 --- a/include/turtle/verify.hpp +++ b/include/turtle/verify.hpp @@ -10,25 +10,24 @@ #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() { - inline bool verify() - { - return detail::root.verify(); - } - inline bool verify( const object& o ) - { - return o.impl_->verify(); - } - template< typename Signature > - bool verify( const detail::functor< Signature >& f ) - { - return f.verify(); - } -} // mock + return detail::root.verify(); +} +inline bool verify(const object& o) +{ + return o.impl_->verify(); +} +template +bool verify(const detail::functor& f) +{ + return f.verify(); +} +} // namespace mock #endif // MOCK_VERIFY_HPP_INCLUDED diff --git a/test/bench_30_classes_30_methods_30_args_30_max_args.cpp b/test/bench_30_classes_30_methods_30_args_30_max_args.cpp index 7872dc2..6cd6a41 100644 --- a/test/bench_30_classes_30_methods_30_args_30_max_args.cpp +++ b/test/bench_30_classes_30_methods_30_args_30_max_args.cpp @@ -9,1126 +9,315 @@ #define MOCK_MAX_ARGS 30 #include #ifdef _MSC_VER -#pragma warning( disable: 4505 ) +# pragma warning(disable : 4505) #endif -namespace +namespace { +class base_class { - class base_class - { - public: - virtual ~base_class() {} - virtual void f1( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f2( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f3( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f4( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f5( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f6( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f7( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f8( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f9( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f10( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f11( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f12( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f13( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f14( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f15( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f16( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f17( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f18( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f19( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f20( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f21( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f22( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f23( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f24( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f25( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f26( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f27( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f28( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f29( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - virtual void f30( int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int, - int, int, int, int, int, int, int, int, int, int ) = 0; - }; +public: + virtual ~base_class() {} + virtual void f1(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f2(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f3(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f4(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f5(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f6(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f7(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f8(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f9(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f10(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f11(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f12(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f13(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f14(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f15(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f16(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f17(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f18(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f19(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f20(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f21(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f22(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f23(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f24(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f25(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f26(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f27(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f28(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f29(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; + virtual void f30(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, + int, int, int, int, int, int, int, int, int, int) = 0; +}; - MOCK_BASE_CLASS( mock_class_1, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_2, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_3, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_4, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_5, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_6, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_7, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_8, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_9, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_10, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_11, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_12, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_13, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_14, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_15, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_16, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_17, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_18, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_19, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_20, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_21, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_22, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_23, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_24, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_25, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_26, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_27, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_28, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_29, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; - MOCK_BASE_CLASS( mock_class_30, base_class ) - { - MOCK_METHOD( f1, 30 ) - MOCK_METHOD( f2, 30 ) - MOCK_METHOD( f3, 30 ) - MOCK_METHOD( f4, 30 ) - MOCK_METHOD( f5, 30 ) - MOCK_METHOD( f6, 30 ) - MOCK_METHOD( f7, 30 ) - MOCK_METHOD( f8, 30 ) - MOCK_METHOD( f9, 30 ) - MOCK_METHOD( f10, 30 ) - MOCK_METHOD( f11, 30 ) - MOCK_METHOD( f12, 30 ) - MOCK_METHOD( f13, 30 ) - MOCK_METHOD( f14, 30 ) - MOCK_METHOD( f15, 30 ) - MOCK_METHOD( f16, 30 ) - MOCK_METHOD( f17, 30 ) - MOCK_METHOD( f18, 30 ) - MOCK_METHOD( f19, 30 ) - MOCK_METHOD( f20, 30 ) - MOCK_METHOD( f21, 30 ) - MOCK_METHOD( f22, 30 ) - MOCK_METHOD( f23, 30 ) - MOCK_METHOD( f24, 30 ) - MOCK_METHOD( f25, 30 ) - MOCK_METHOD( f26, 30 ) - MOCK_METHOD( f27, 30 ) - MOCK_METHOD( f28, 30 ) - MOCK_METHOD( f29, 30 ) - MOCK_METHOD( f30, 30 ) - }; +MOCK_BASE_CLASS(mock_class_1, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_2, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_3, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_4, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_5, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_6, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_7, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_8, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_9, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_10, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_11, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_12, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_13, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_14, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_15, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_16, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_17, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_18, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_19, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_20, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_21, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_22, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_23, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_24, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_25, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_26, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_27, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_28, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_29, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; +MOCK_BASE_CLASS(mock_class_30, base_class){ + MOCK_METHOD(f1, 30) MOCK_METHOD(f2, 30) MOCK_METHOD(f3, 30) MOCK_METHOD(f4, 30) MOCK_METHOD(f5, 30) + MOCK_METHOD(f6, 30) MOCK_METHOD(f7, 30) MOCK_METHOD(f8, 30) MOCK_METHOD(f9, 30) MOCK_METHOD(f10, 30) + MOCK_METHOD(f11, 30) MOCK_METHOD(f12, 30) MOCK_METHOD(f13, 30) MOCK_METHOD(f14, 30) MOCK_METHOD(f15, 30) + MOCK_METHOD(f16, 30) MOCK_METHOD(f17, 30) MOCK_METHOD(f18, 30) MOCK_METHOD(f19, 30) MOCK_METHOD(f20, 30) + MOCK_METHOD(f21, 30) MOCK_METHOD(f22, 30) MOCK_METHOD(f23, 30) MOCK_METHOD(f24, 30) MOCK_METHOD(f25, 30) + MOCK_METHOD(f26, 30) MOCK_METHOD(f27, 30) MOCK_METHOD(f28, 30) MOCK_METHOD(f29, 30) MOCK_METHOD(f30, 30)}; - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock_class_4 c_4; - mock_class_5 c_5; - mock_class_6 c_6; - mock_class_7 c_7; - mock_class_8 c_8; - mock_class_9 c_9; - mock_class_10 c_10; - mock_class_11 c_11; - mock_class_12 c_12; - mock_class_13 c_13; - mock_class_14 c_14; - mock_class_15 c_15; - mock_class_16 c_16; - mock_class_17 c_17; - mock_class_18 c_18; - mock_class_19 c_19; - mock_class_20 c_20; - mock_class_21 c_21; - mock_class_22 c_22; - mock_class_23 c_23; - mock_class_24 c_24; - mock_class_25 c_25; - mock_class_26 c_26; - mock_class_27 c_27; - mock_class_28 c_28; - mock_class_29 c_29; - mock_class_30 c_30; -} +mock_class_1 c_1; +mock_class_2 c_2; +mock_class_3 c_3; +mock_class_4 c_4; +mock_class_5 c_5; +mock_class_6 c_6; +mock_class_7 c_7; +mock_class_8 c_8; +mock_class_9 c_9; +mock_class_10 c_10; +mock_class_11 c_11; +mock_class_12 c_12; +mock_class_13 c_13; +mock_class_14 c_14; +mock_class_15 c_15; +mock_class_16 c_16; +mock_class_17 c_17; +mock_class_18 c_18; +mock_class_19 c_19; +mock_class_20 c_20; +mock_class_21 c_21; +mock_class_22 c_22; +mock_class_23 c_23; +mock_class_24 c_24; +mock_class_25 c_25; +mock_class_26 c_26; +mock_class_27 c_27; +mock_class_28 c_28; +mock_class_29 c_29; +mock_class_30 c_30; +} // namespace diff --git a/test/bench_30_classes_30_methods_9_args.cpp b/test/bench_30_classes_30_methods_9_args.cpp index 67d1b65..7af2fce 100644 --- a/test/bench_30_classes_30_methods_9_args.cpp +++ b/test/bench_30_classes_30_methods_9_args.cpp @@ -8,1066 +8,285 @@ #include #ifdef _MSC_VER -#pragma warning( disable: 4505 ) +# pragma warning(disable : 4505) #endif -namespace +namespace { +class base_class { - class base_class - { - public: - virtual ~base_class() {} - virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; - }; +public: + virtual ~base_class() {} + virtual void f1(int, int, int, int, int, int, int, int, int) = 0; + virtual void f2(int, int, int, int, int, int, int, int, int) = 0; + virtual void f3(int, int, int, int, int, int, int, int, int) = 0; + virtual void f4(int, int, int, int, int, int, int, int, int) = 0; + virtual void f5(int, int, int, int, int, int, int, int, int) = 0; + virtual void f6(int, int, int, int, int, int, int, int, int) = 0; + virtual void f7(int, int, int, int, int, int, int, int, int) = 0; + virtual void f8(int, int, int, int, int, int, int, int, int) = 0; + virtual void f9(int, int, int, int, int, int, int, int, int) = 0; + virtual void f10(int, int, int, int, int, int, int, int, int) = 0; + virtual void f11(int, int, int, int, int, int, int, int, int) = 0; + virtual void f12(int, int, int, int, int, int, int, int, int) = 0; + virtual void f13(int, int, int, int, int, int, int, int, int) = 0; + virtual void f14(int, int, int, int, int, int, int, int, int) = 0; + virtual void f15(int, int, int, int, int, int, int, int, int) = 0; + virtual void f16(int, int, int, int, int, int, int, int, int) = 0; + virtual void f17(int, int, int, int, int, int, int, int, int) = 0; + virtual void f18(int, int, int, int, int, int, int, int, int) = 0; + virtual void f19(int, int, int, int, int, int, int, int, int) = 0; + virtual void f20(int, int, int, int, int, int, int, int, int) = 0; + virtual void f21(int, int, int, int, int, int, int, int, int) = 0; + virtual void f22(int, int, int, int, int, int, int, int, int) = 0; + virtual void f23(int, int, int, int, int, int, int, int, int) = 0; + virtual void f24(int, int, int, int, int, int, int, int, int) = 0; + virtual void f25(int, int, int, int, int, int, int, int, int) = 0; + virtual void f26(int, int, int, int, int, int, int, int, int) = 0; + virtual void f27(int, int, int, int, int, int, int, int, int) = 0; + virtual void f28(int, int, int, int, int, int, int, int, int) = 0; + virtual void f29(int, int, int, int, int, int, int, int, int) = 0; + virtual void f30(int, int, int, int, int, int, int, int, int) = 0; +}; - MOCK_BASE_CLASS( mock_class_1, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_2, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_3, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_4, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_5, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_6, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_7, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_8, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_9, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_10, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_11, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_12, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_13, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_14, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_15, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_16, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_17, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_18, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_19, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_20, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_21, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_22, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_23, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_24, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_25, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_26, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_27, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_28, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_29, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_30, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; +MOCK_BASE_CLASS(mock_class_1, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_2, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_3, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_4, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_5, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_6, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_7, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_8, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_9, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_10, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_11, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_12, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_13, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_14, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_15, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_16, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_17, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_18, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_19, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_20, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_21, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_22, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_23, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_24, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_25, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_26, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_27, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_28, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_29, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_30, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock_class_4 c_4; - mock_class_5 c_5; - mock_class_6 c_6; - mock_class_7 c_7; - mock_class_8 c_8; - mock_class_9 c_9; - mock_class_10 c_10; - mock_class_11 c_11; - mock_class_12 c_12; - mock_class_13 c_13; - mock_class_14 c_14; - mock_class_15 c_15; - mock_class_16 c_16; - mock_class_17 c_17; - mock_class_18 c_18; - mock_class_19 c_19; - mock_class_20 c_20; - mock_class_21 c_21; - mock_class_22 c_22; - mock_class_23 c_23; - mock_class_24 c_24; - mock_class_25 c_25; - mock_class_26 c_26; - mock_class_27 c_27; - mock_class_28 c_28; - mock_class_29 c_29; - mock_class_30 c_30; -} +mock_class_1 c_1; +mock_class_2 c_2; +mock_class_3 c_3; +mock_class_4 c_4; +mock_class_5 c_5; +mock_class_6 c_6; +mock_class_7 c_7; +mock_class_8 c_8; +mock_class_9 c_9; +mock_class_10 c_10; +mock_class_11 c_11; +mock_class_12 c_12; +mock_class_13 c_13; +mock_class_14 c_14; +mock_class_15 c_15; +mock_class_16 c_16; +mock_class_17 c_17; +mock_class_18 c_18; +mock_class_19 c_19; +mock_class_20 c_20; +mock_class_21 c_21; +mock_class_22 c_22; +mock_class_23 c_23; +mock_class_24 c_24; +mock_class_25 c_25; +mock_class_26 c_26; +mock_class_27 c_27; +mock_class_28 c_28; +mock_class_29 c_29; +mock_class_30 c_30; +} // namespace diff --git a/test/bench_30_classes_30_methods_9_args_10_max_args.cpp b/test/bench_30_classes_30_methods_9_args_10_max_args.cpp index 61a553c..4b67a65 100644 --- a/test/bench_30_classes_30_methods_9_args_10_max_args.cpp +++ b/test/bench_30_classes_30_methods_9_args_10_max_args.cpp @@ -9,1066 +9,285 @@ #define MOCK_MAX_ARGS 10 #include #ifdef _MSC_VER -#pragma warning( disable: 4505 ) +# pragma warning(disable : 4505) #endif -namespace +namespace { +class base_class { - class base_class - { - public: - virtual ~base_class() {} - virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; - }; +public: + virtual ~base_class() {} + virtual void f1(int, int, int, int, int, int, int, int, int) = 0; + virtual void f2(int, int, int, int, int, int, int, int, int) = 0; + virtual void f3(int, int, int, int, int, int, int, int, int) = 0; + virtual void f4(int, int, int, int, int, int, int, int, int) = 0; + virtual void f5(int, int, int, int, int, int, int, int, int) = 0; + virtual void f6(int, int, int, int, int, int, int, int, int) = 0; + virtual void f7(int, int, int, int, int, int, int, int, int) = 0; + virtual void f8(int, int, int, int, int, int, int, int, int) = 0; + virtual void f9(int, int, int, int, int, int, int, int, int) = 0; + virtual void f10(int, int, int, int, int, int, int, int, int) = 0; + virtual void f11(int, int, int, int, int, int, int, int, int) = 0; + virtual void f12(int, int, int, int, int, int, int, int, int) = 0; + virtual void f13(int, int, int, int, int, int, int, int, int) = 0; + virtual void f14(int, int, int, int, int, int, int, int, int) = 0; + virtual void f15(int, int, int, int, int, int, int, int, int) = 0; + virtual void f16(int, int, int, int, int, int, int, int, int) = 0; + virtual void f17(int, int, int, int, int, int, int, int, int) = 0; + virtual void f18(int, int, int, int, int, int, int, int, int) = 0; + virtual void f19(int, int, int, int, int, int, int, int, int) = 0; + virtual void f20(int, int, int, int, int, int, int, int, int) = 0; + virtual void f21(int, int, int, int, int, int, int, int, int) = 0; + virtual void f22(int, int, int, int, int, int, int, int, int) = 0; + virtual void f23(int, int, int, int, int, int, int, int, int) = 0; + virtual void f24(int, int, int, int, int, int, int, int, int) = 0; + virtual void f25(int, int, int, int, int, int, int, int, int) = 0; + virtual void f26(int, int, int, int, int, int, int, int, int) = 0; + virtual void f27(int, int, int, int, int, int, int, int, int) = 0; + virtual void f28(int, int, int, int, int, int, int, int, int) = 0; + virtual void f29(int, int, int, int, int, int, int, int, int) = 0; + virtual void f30(int, int, int, int, int, int, int, int, int) = 0; +}; - MOCK_BASE_CLASS( mock_class_1, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_2, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_3, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_4, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_5, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_6, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_7, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_8, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_9, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_10, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_11, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_12, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_13, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_14, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_15, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_16, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_17, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_18, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_19, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_20, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_21, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_22, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_23, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_24, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_25, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_26, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_27, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_28, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_29, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_30, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; +MOCK_BASE_CLASS(mock_class_1, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_2, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_3, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_4, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_5, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_6, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_7, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_8, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_9, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_10, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_11, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_12, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_13, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_14, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_15, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_16, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_17, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_18, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_19, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_20, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_21, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_22, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_23, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_24, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_25, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_26, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_27, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_28, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_29, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_30, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock_class_4 c_4; - mock_class_5 c_5; - mock_class_6 c_6; - mock_class_7 c_7; - mock_class_8 c_8; - mock_class_9 c_9; - mock_class_10 c_10; - mock_class_11 c_11; - mock_class_12 c_12; - mock_class_13 c_13; - mock_class_14 c_14; - mock_class_15 c_15; - mock_class_16 c_16; - mock_class_17 c_17; - mock_class_18 c_18; - mock_class_19 c_19; - mock_class_20 c_20; - mock_class_21 c_21; - mock_class_22 c_22; - mock_class_23 c_23; - mock_class_24 c_24; - mock_class_25 c_25; - mock_class_26 c_26; - mock_class_27 c_27; - mock_class_28 c_28; - mock_class_29 c_29; - mock_class_30 c_30; -} +mock_class_1 c_1; +mock_class_2 c_2; +mock_class_3 c_3; +mock_class_4 c_4; +mock_class_5 c_5; +mock_class_6 c_6; +mock_class_7 c_7; +mock_class_8 c_8; +mock_class_9 c_9; +mock_class_10 c_10; +mock_class_11 c_11; +mock_class_12 c_12; +mock_class_13 c_13; +mock_class_14 c_14; +mock_class_15 c_15; +mock_class_16 c_16; +mock_class_17 c_17; +mock_class_18 c_18; +mock_class_19 c_19; +mock_class_20 c_20; +mock_class_21 c_21; +mock_class_22 c_22; +mock_class_23 c_23; +mock_class_24 c_24; +mock_class_25 c_25; +mock_class_26 c_26; +mock_class_27 c_27; +mock_class_28 c_28; +mock_class_29 c_29; +mock_class_30 c_30; +} // namespace diff --git a/test/bench_30_classes_30_methods_9_args_20_max_args.cpp b/test/bench_30_classes_30_methods_9_args_20_max_args.cpp index fe442fa..67ed7ba 100644 --- a/test/bench_30_classes_30_methods_9_args_20_max_args.cpp +++ b/test/bench_30_classes_30_methods_9_args_20_max_args.cpp @@ -9,1066 +9,285 @@ #define MOCK_MAX_ARGS 20 #include #ifdef _MSC_VER -#pragma warning( disable: 4505 ) +# pragma warning(disable : 4505) #endif -namespace +namespace { +class base_class { - class base_class - { - public: - virtual ~base_class() {} - virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; - }; +public: + virtual ~base_class() {} + virtual void f1(int, int, int, int, int, int, int, int, int) = 0; + virtual void f2(int, int, int, int, int, int, int, int, int) = 0; + virtual void f3(int, int, int, int, int, int, int, int, int) = 0; + virtual void f4(int, int, int, int, int, int, int, int, int) = 0; + virtual void f5(int, int, int, int, int, int, int, int, int) = 0; + virtual void f6(int, int, int, int, int, int, int, int, int) = 0; + virtual void f7(int, int, int, int, int, int, int, int, int) = 0; + virtual void f8(int, int, int, int, int, int, int, int, int) = 0; + virtual void f9(int, int, int, int, int, int, int, int, int) = 0; + virtual void f10(int, int, int, int, int, int, int, int, int) = 0; + virtual void f11(int, int, int, int, int, int, int, int, int) = 0; + virtual void f12(int, int, int, int, int, int, int, int, int) = 0; + virtual void f13(int, int, int, int, int, int, int, int, int) = 0; + virtual void f14(int, int, int, int, int, int, int, int, int) = 0; + virtual void f15(int, int, int, int, int, int, int, int, int) = 0; + virtual void f16(int, int, int, int, int, int, int, int, int) = 0; + virtual void f17(int, int, int, int, int, int, int, int, int) = 0; + virtual void f18(int, int, int, int, int, int, int, int, int) = 0; + virtual void f19(int, int, int, int, int, int, int, int, int) = 0; + virtual void f20(int, int, int, int, int, int, int, int, int) = 0; + virtual void f21(int, int, int, int, int, int, int, int, int) = 0; + virtual void f22(int, int, int, int, int, int, int, int, int) = 0; + virtual void f23(int, int, int, int, int, int, int, int, int) = 0; + virtual void f24(int, int, int, int, int, int, int, int, int) = 0; + virtual void f25(int, int, int, int, int, int, int, int, int) = 0; + virtual void f26(int, int, int, int, int, int, int, int, int) = 0; + virtual void f27(int, int, int, int, int, int, int, int, int) = 0; + virtual void f28(int, int, int, int, int, int, int, int, int) = 0; + virtual void f29(int, int, int, int, int, int, int, int, int) = 0; + virtual void f30(int, int, int, int, int, int, int, int, int) = 0; +}; - MOCK_BASE_CLASS( mock_class_1, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_2, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_3, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_4, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_5, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_6, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_7, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_8, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_9, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_10, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_11, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_12, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_13, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_14, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_15, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_16, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_17, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_18, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_19, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_20, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_21, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_22, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_23, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_24, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_25, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_26, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_27, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_28, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_29, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_30, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; +MOCK_BASE_CLASS(mock_class_1, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_2, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_3, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_4, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_5, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_6, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_7, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_8, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_9, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_10, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_11, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_12, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_13, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_14, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_15, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_16, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_17, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_18, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_19, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_20, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_21, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_22, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_23, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_24, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_25, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_26, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_27, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_28, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_29, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_30, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock_class_4 c_4; - mock_class_5 c_5; - mock_class_6 c_6; - mock_class_7 c_7; - mock_class_8 c_8; - mock_class_9 c_9; - mock_class_10 c_10; - mock_class_11 c_11; - mock_class_12 c_12; - mock_class_13 c_13; - mock_class_14 c_14; - mock_class_15 c_15; - mock_class_16 c_16; - mock_class_17 c_17; - mock_class_18 c_18; - mock_class_19 c_19; - mock_class_20 c_20; - mock_class_21 c_21; - mock_class_22 c_22; - mock_class_23 c_23; - mock_class_24 c_24; - mock_class_25 c_25; - mock_class_26 c_26; - mock_class_27 c_27; - mock_class_28 c_28; - mock_class_29 c_29; - mock_class_30 c_30; -} +mock_class_1 c_1; +mock_class_2 c_2; +mock_class_3 c_3; +mock_class_4 c_4; +mock_class_5 c_5; +mock_class_6 c_6; +mock_class_7 c_7; +mock_class_8 c_8; +mock_class_9 c_9; +mock_class_10 c_10; +mock_class_11 c_11; +mock_class_12 c_12; +mock_class_13 c_13; +mock_class_14 c_14; +mock_class_15 c_15; +mock_class_16 c_16; +mock_class_17 c_17; +mock_class_18 c_18; +mock_class_19 c_19; +mock_class_20 c_20; +mock_class_21 c_21; +mock_class_22 c_22; +mock_class_23 c_23; +mock_class_24 c_24; +mock_class_25 c_25; +mock_class_26 c_26; +mock_class_27 c_27; +mock_class_28 c_28; +mock_class_29 c_29; +mock_class_30 c_30; +} // namespace diff --git a/test/bench_30_classes_30_methods_9_args_30_max_args.cpp b/test/bench_30_classes_30_methods_9_args_30_max_args.cpp index 3f6e0af..1b497df 100644 --- a/test/bench_30_classes_30_methods_9_args_30_max_args.cpp +++ b/test/bench_30_classes_30_methods_9_args_30_max_args.cpp @@ -9,1066 +9,285 @@ #define MOCK_MAX_ARGS 30 #include #ifdef _MSC_VER -#pragma warning( disable: 4505 ) +# pragma warning(disable : 4505) #endif -namespace +namespace { +class base_class { - class base_class - { - public: - virtual ~base_class() {} - virtual void f1( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f2( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f3( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f4( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f5( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f6( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f7( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f8( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f9( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f10( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f11( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f12( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f13( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f14( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f15( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f16( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f17( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f18( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f19( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f20( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f21( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f22( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f23( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f24( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f25( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f26( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f27( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f28( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f29( int, int, int, int, int, int, int, int, int ) = 0; - virtual void f30( int, int, int, int, int, int, int, int, int ) = 0; - }; +public: + virtual ~base_class() {} + virtual void f1(int, int, int, int, int, int, int, int, int) = 0; + virtual void f2(int, int, int, int, int, int, int, int, int) = 0; + virtual void f3(int, int, int, int, int, int, int, int, int) = 0; + virtual void f4(int, int, int, int, int, int, int, int, int) = 0; + virtual void f5(int, int, int, int, int, int, int, int, int) = 0; + virtual void f6(int, int, int, int, int, int, int, int, int) = 0; + virtual void f7(int, int, int, int, int, int, int, int, int) = 0; + virtual void f8(int, int, int, int, int, int, int, int, int) = 0; + virtual void f9(int, int, int, int, int, int, int, int, int) = 0; + virtual void f10(int, int, int, int, int, int, int, int, int) = 0; + virtual void f11(int, int, int, int, int, int, int, int, int) = 0; + virtual void f12(int, int, int, int, int, int, int, int, int) = 0; + virtual void f13(int, int, int, int, int, int, int, int, int) = 0; + virtual void f14(int, int, int, int, int, int, int, int, int) = 0; + virtual void f15(int, int, int, int, int, int, int, int, int) = 0; + virtual void f16(int, int, int, int, int, int, int, int, int) = 0; + virtual void f17(int, int, int, int, int, int, int, int, int) = 0; + virtual void f18(int, int, int, int, int, int, int, int, int) = 0; + virtual void f19(int, int, int, int, int, int, int, int, int) = 0; + virtual void f20(int, int, int, int, int, int, int, int, int) = 0; + virtual void f21(int, int, int, int, int, int, int, int, int) = 0; + virtual void f22(int, int, int, int, int, int, int, int, int) = 0; + virtual void f23(int, int, int, int, int, int, int, int, int) = 0; + virtual void f24(int, int, int, int, int, int, int, int, int) = 0; + virtual void f25(int, int, int, int, int, int, int, int, int) = 0; + virtual void f26(int, int, int, int, int, int, int, int, int) = 0; + virtual void f27(int, int, int, int, int, int, int, int, int) = 0; + virtual void f28(int, int, int, int, int, int, int, int, int) = 0; + virtual void f29(int, int, int, int, int, int, int, int, int) = 0; + virtual void f30(int, int, int, int, int, int, int, int, int) = 0; +}; - MOCK_BASE_CLASS( mock_class_1, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_2, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_3, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_4, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_5, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_6, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_7, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_8, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_9, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_10, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_11, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_12, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_13, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_14, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_15, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_16, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_17, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_18, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_19, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_20, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_21, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_22, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_23, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_24, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_25, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_26, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_27, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_28, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_29, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; - MOCK_BASE_CLASS( mock_class_30, base_class ) - { - MOCK_METHOD( f1, 9 ) - MOCK_METHOD( f2, 9 ) - MOCK_METHOD( f3, 9 ) - MOCK_METHOD( f4, 9 ) - MOCK_METHOD( f5, 9 ) - MOCK_METHOD( f6, 9 ) - MOCK_METHOD( f7, 9 ) - MOCK_METHOD( f8, 9 ) - MOCK_METHOD( f9, 9 ) - MOCK_METHOD( f10, 9 ) - MOCK_METHOD( f11, 9 ) - MOCK_METHOD( f12, 9 ) - MOCK_METHOD( f13, 9 ) - MOCK_METHOD( f14, 9 ) - MOCK_METHOD( f15, 9 ) - MOCK_METHOD( f16, 9 ) - MOCK_METHOD( f17, 9 ) - MOCK_METHOD( f18, 9 ) - MOCK_METHOD( f19, 9 ) - MOCK_METHOD( f20, 9 ) - MOCK_METHOD( f21, 9 ) - MOCK_METHOD( f22, 9 ) - MOCK_METHOD( f23, 9 ) - MOCK_METHOD( f24, 9 ) - MOCK_METHOD( f25, 9 ) - MOCK_METHOD( f26, 9 ) - MOCK_METHOD( f27, 9 ) - MOCK_METHOD( f28, 9 ) - MOCK_METHOD( f29, 9 ) - MOCK_METHOD( f30, 9 ) - }; +MOCK_BASE_CLASS(mock_class_1, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_2, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_3, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_4, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_5, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_6, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_7, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_8, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_9, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_10, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_11, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_12, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_13, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_14, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_15, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_16, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_17, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_18, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_19, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_20, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_21, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_22, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_23, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_24, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_25, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_26, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_27, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_28, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_29, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; +MOCK_BASE_CLASS(mock_class_30, base_class){ + MOCK_METHOD(f1, 9) MOCK_METHOD(f2, 9) MOCK_METHOD(f3, 9) MOCK_METHOD(f4, 9) MOCK_METHOD(f5, 9) MOCK_METHOD(f6, 9) + MOCK_METHOD(f7, 9) MOCK_METHOD(f8, 9) MOCK_METHOD(f9, 9) MOCK_METHOD(f10, 9) MOCK_METHOD(f11, 9) MOCK_METHOD(f12, 9) + MOCK_METHOD(f13, 9) MOCK_METHOD(f14, 9) MOCK_METHOD(f15, 9) MOCK_METHOD(f16, 9) MOCK_METHOD(f17, 9) + MOCK_METHOD(f18, 9) MOCK_METHOD(f19, 9) MOCK_METHOD(f20, 9) MOCK_METHOD(f21, 9) MOCK_METHOD(f22, 9) + MOCK_METHOD(f23, 9) MOCK_METHOD(f24, 9) MOCK_METHOD(f25, 9) MOCK_METHOD(f26, 9) MOCK_METHOD(f27, 9) + MOCK_METHOD(f28, 9) MOCK_METHOD(f29, 9) MOCK_METHOD(f30, 9)}; - mock_class_1 c_1; - mock_class_2 c_2; - mock_class_3 c_3; - mock_class_4 c_4; - mock_class_5 c_5; - mock_class_6 c_6; - mock_class_7 c_7; - mock_class_8 c_8; - mock_class_9 c_9; - mock_class_10 c_10; - mock_class_11 c_11; - mock_class_12 c_12; - mock_class_13 c_13; - mock_class_14 c_14; - mock_class_15 c_15; - mock_class_16 c_16; - mock_class_17 c_17; - mock_class_18 c_18; - mock_class_19 c_19; - mock_class_20 c_20; - mock_class_21 c_21; - mock_class_22 c_22; - mock_class_23 c_23; - mock_class_24 c_24; - mock_class_25 c_25; - mock_class_26 c_26; - mock_class_27 c_27; - mock_class_28 c_28; - mock_class_29 c_29; - mock_class_30 c_30; -} +mock_class_1 c_1; +mock_class_2 c_2; +mock_class_3 c_3; +mock_class_4 c_4; +mock_class_5 c_5; +mock_class_6 c_6; +mock_class_7 c_7; +mock_class_8 c_8; +mock_class_9 c_9; +mock_class_10 c_10; +mock_class_11 c_11; +mock_class_12 c_12; +mock_class_13 c_13; +mock_class_14 c_14; +mock_class_15 c_15; +mock_class_16 c_16; +mock_class_17 c_17; +mock_class_18 c_18; +mock_class_19 c_19; +mock_class_20 c_20; +mock_class_21 c_21; +mock_class_22 c_22; +mock_class_23 c_23; +mock_class_24 c_24; +mock_class_25 c_25; +mock_class_26 c_26; +mock_class_27 c_27; +mock_class_28 c_28; +mock_class_29 c_29; +mock_class_30 c_30; +} // namespace diff --git a/test/defined.hpp b/test/defined.hpp index e0587f6..8ea5946 100644 --- a/test/defined.hpp +++ b/test/defined.hpp @@ -10,11 +10,11 @@ #define MOCK_TEST_DEFINED_HPP_INCLUDED #ifdef BOOST_AUTO_TEST_MAIN -#undef BOOST_AUTO_TEST_MAIN +# undef BOOST_AUTO_TEST_MAIN #endif #include -MOCK_FUNCTION( f, 0, void(), f ) +MOCK_FUNCTION(f, 0, void(), f) #endif // MOCK_TEST_DEFINED_HPP_INCLUDED diff --git a/test/detail/test_function.cpp b/test/detail/test_function.cpp index 682840a..22658cc 100644 --- a/test/detail/test_function.cpp +++ b/test/detail/test_function.cpp @@ -8,345 +8,347 @@ #include "../mock_error.hpp" #include "../undefined.hpp" -#include #include -#include -#include +#include +#include +#include #include #include -#include -#include +#include +#include // static -namespace -{ - boost::function< void() > static_f; +namespace { +boost::function 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()>::type>)); +BOOST_MPL_ASSERT((boost::is_same()>::type>)); +BOOST_MPL_ASSERT((boost::is_same(float)>::type>)); +BOOST_MPL_ASSERT((boost::is_same(float)>::type>)); +} // namespace // functor -BOOST_FIXTURE_TEST_CASE( a_function_can_be_passed_as_functor, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(a_function_can_be_passed_as_functor, mock_error_fixture) { - mock::detail::function< void() > f; - boost::function< void() > functor = f; + mock::detail::function f; + boost::function functor = f; } -BOOST_FIXTURE_TEST_CASE( a_function_can_be_passed_as_functor_using_boost_bind_and_boost_ref, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(a_function_can_be_passed_as_functor_using_boost_bind_and_boost_ref, mock_error_fixture) { - mock::detail::function< void() > f; - boost::function< void() > functor = boost::bind( boost::ref( f ) ); + mock::detail::function f; + boost::function functor = boost::bind(boost::ref(f)); } // invocations -BOOST_FIXTURE_TEST_CASE( triggering_an_unconfigured_function_calls_unexpected_call_error, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_unconfigured_function_calls_unexpected_call_error, mock_error_fixture) { { - mock::detail::function< void() > f; - CHECK_ERROR( f(), "unexpected call", 0, "?()" ); + mock::detail::function f; + CHECK_ERROR(f(), "unexpected call", 0, "?()"); } { - mock::detail::function< int( int, const std::string& ) > f; - CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )" ); + mock::detail::function f; + CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )"); } } -BOOST_FIXTURE_TEST_CASE( triggering_a_never_expectation_calls_unexpected_call_error, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_a_never_expectation_calls_unexpected_call_error, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().never(); - CHECK_ERROR( f(), "unexpected call", 0, "?()\nv never()" ); + CHECK_ERROR(f(), "unexpected call", 0, "?()\nv never()"); } { - mock::detail::function< int( int, const std::string& ) > f; + mock::detail::function f; f.expect().never(); - CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )\nv never().with( any, any )" ); + CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )\nv never().with( any, any )"); } } -BOOST_FIXTURE_TEST_CASE( triggering_an_unlimited_expectation_is_valid, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_unlimited_expectation_is_valid, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect(); f(); f(); - CHECK_CALLS( 2 ); + CHECK_CALLS(2); } { - mock::detail::function< void( int, std::string ) > f; + mock::detail::function f; f.expect(); - f( 1, "s1" ); - f( 2, "s2" ); - CHECK_CALLS( 2 ); + f(1, "s1"); + f(2, "s2"); + CHECK_CALLS(2); } { - mock::detail::function< void( int, const std::string& ) > f; + mock::detail::function f; f.expect(); - f( 1, "s1" ); - f( 2, "s2" ); - CHECK_CALLS( 2 ); + f(1, "s1"); + f(2, "s2"); + CHECK_CALLS(2); } } -BOOST_FIXTURE_TEST_CASE( triggering_several_once_expectations_is_valid, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_several_once_expectations_is_valid, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); f.expect().once(); f(); f(); - CHECK_CALLS( 2 ); + CHECK_CALLS(2); } { - mock::detail::function< void( int, std::string ) > f; - f.expect().once().with( 1, "s1" ); - f.expect().once().with( 2, "s2" ); - f( 1, "s1" ); - f( 2, "s2" ); - CHECK_CALLS( 2 ); + mock::detail::function f; + f.expect().once().with(1, "s1"); + f.expect().once().with(2, "s2"); + f(1, "s1"); + f(2, "s2"); + CHECK_CALLS(2); } { - mock::detail::function< void( int, const std::string& ) > f; - f.expect().once().with( 1, "s1" ); - f.expect().once().with( 2, "s2" ); - f( 1, "s1" ); - f( 2, "s2" ); - CHECK_CALLS( 2 ); + mock::detail::function f; + f.expect().once().with(1, "s1"); + f.expect().once().with(2, "s2"); + f(1, "s1"); + f(2, "s2"); + CHECK_CALLS(2); } } -BOOST_FIXTURE_TEST_CASE( triggering_a_once_expectation_calls_unexpected_call_error_after_one_call, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_a_once_expectation_calls_unexpected_call_error_after_one_call, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); f(); - CHECK_ERROR( f(), "unexpected call", 1, "?()\nv once()" ); + CHECK_ERROR(f(), "unexpected call", 1, "?()\nv once()"); } { - mock::detail::function< void( int, const std::string& ) > f; + mock::detail::function f; f.expect().once(); - f( 1, "s" ); - CHECK_ERROR( f( 1, "s" ), "unexpected call", 1, "?( 1, \"s\" )\nv once().with( any, any )" ); + f(1, "s"); + CHECK_ERROR(f(1, "s"), "unexpected call", 1, "?( 1, \"s\" )\nv once().with( any, any )"); } } -BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_function_call_as_pointers, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(literal_zero_can_be_used_in_function_call_as_pointers, mock_error_fixture) { - mock::detail::function< void( int* ) > f; + mock::detail::function f; f.expect().once(); - f( 0 ); - CHECK_CALLS( 1 ); + f(0); + CHECK_CALLS(1); } // verify -BOOST_FIXTURE_TEST_CASE( verifying_an_unconfigured_function_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_an_unconfigured_function_succeeds, mock_error_fixture) { { - mock::detail::function< void() > f; - BOOST_CHECK( f.verify() ); + mock::detail::function f; + BOOST_CHECK(f.verify()); } { - mock::detail::function< int( int, const std::string& ) > f; - BOOST_CHECK( f.verify() ); + mock::detail::function f; + BOOST_CHECK(f.verify()); } } -BOOST_FIXTURE_TEST_CASE( verifying_an_unlimited_expectation_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_an_unlimited_expectation_succeeds, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect(); - BOOST_CHECK( f.verify() ); - CHECK_CALLS( 0 ); + BOOST_CHECK(f.verify()); + CHECK_CALLS(0); } { - mock::detail::function< int( int, const std::string& ) > f; + mock::detail::function f; f.expect(); - BOOST_CHECK( f.verify() ); - CHECK_CALLS( 0 ); + BOOST_CHECK(f.verify()); + CHECK_CALLS(0); } } -BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_after_one_call_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_after_one_call_succeeds, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); f(); - BOOST_CHECK( f.verify() ); - CHECK_CALLS( 1 ); + BOOST_CHECK(f.verify()); + CHECK_CALLS(1); } { - mock::detail::function< void( int, const std::string& ) > f; + mock::detail::function f; f.expect().once(); - f( 1, "s" ); - BOOST_CHECK( f.verify() ); - CHECK_CALLS( 1 ); + f(1, "s"); + BOOST_CHECK(f.verify()); + CHECK_CALLS(1); } } -BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_before_the_call_fails, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_before_the_call_fails, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); - CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once()" ); + CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once()"); } { - mock::detail::function< int( int, const std::string& ) > f; + mock::detail::function f; f.expect().once(); - CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once().with( any, any )" ); + CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once().with( any, any )"); } } -BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_after_a_verify_and_one_call_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_a_once_expectation_after_a_verify_and_one_call_succeeds, mock_error_fixture) { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); - CHECK_ERROR( BOOST_CHECK( ! f.verify() ), "verification failed", 0, "?\n. once()" ); + CHECK_ERROR(BOOST_CHECK(!f.verify()), "verification failed", 0, "?\n. once()"); f(); - BOOST_CHECK( f.verify() ); - CHECK_CALLS( 1 ); + BOOST_CHECK(f.verify()); + CHECK_CALLS(1); } // reset -BOOST_FIXTURE_TEST_CASE( triggering_a_reset_function_calls_unexpected_call_error, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_a_reset_function_calls_unexpected_call_error, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect(); f.reset(); - CHECK_ERROR( f(), "unexpected call", 0, "?()" ); + CHECK_ERROR(f(), "unexpected call", 0, "?()"); } { - mock::detail::function< int( int, const std::string& ) > f; + mock::detail::function f; f.expect(); f.reset(); - CHECK_ERROR( f( 1, "s" ), "unexpected call", 0, "?( 1, \"s\" )" ); + CHECK_ERROR(f(1, "s"), "unexpected call", 0, "?( 1, \"s\" )"); } } -BOOST_FIXTURE_TEST_CASE( verifying_a_reset_function_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_a_reset_function_succeeds, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect(); f.reset(); - BOOST_CHECK( f.verify() ); + BOOST_CHECK(f.verify()); } { - mock::detail::function< int( int, const std::string& ) > f; + mock::detail::function f; f.expect(); f.reset(); - BOOST_CHECK( f.verify() ); + BOOST_CHECK(f.verify()); } } // 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; - f.expect().with( 42 ); - CHECK_ERROR( f( 43 ), "unexpected call", 0, "?( 43 )\n. unlimited().with( 42 )" ); + mock::detail::function f; + f.expect().with(42); + CHECK_ERROR(f(43), "unexpected call", 0, "?( 43 )\n. unlimited().with( 42 )"); } { - 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\" )" ); + mock::detail::function f; + f.expect().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 ) ); - f( 41 ); - f( 42 ); - CHECK_ERROR( f( 43 ), "unexpected call", 2, "?( 43 )\n. unlimited().with( ( equal( 42 ) || less( 42 ) ) )" ); + mock::detail::function f; + f.expect().with(mock::equal(42) || mock::less(42)); + f(41); + f(42); + 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 ) ); - f( 42 ); - CHECK_ERROR( f( 43 ), "unexpected call", 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )" ); + mock::detail::function f; + f.expect().with(mock::equal(42) && !mock::less(41)); + f(42); + CHECK_ERROR(f(43), "unexpected call", 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )"); } -namespace +namespace { +class my_interface : boost::noncopyable { - class my_interface : boost::noncopyable - { - public: - virtual ~my_interface() {} - private: - virtual void my_method() = 0; - }; - class my_implementation : public my_interface - { - virtual void my_method() {} - }; -} +public: + virtual ~my_interface() {} -BOOST_FIXTURE_TEST_CASE( passing_call_values_by_reference_is_transparent, mock_error_fixture ) +private: + virtual void my_method() = 0; +}; +class my_implementation : public my_interface +{ + virtual void my_method() {} +}; +} // namespace + +BOOST_FIXTURE_TEST_CASE(passing_call_values_by_reference_is_transparent, mock_error_fixture) { { - mock::detail::function< void( my_interface& ) > f; + mock::detail::function f; my_implementation imp; - f.expect().with( mock::same( imp ) ); - f( imp ); - CHECK_CALLS( 1 ); + f.expect().with(mock::same(imp)); + f(imp); + CHECK_CALLS(1); } { - mock::detail::function< void( const my_interface& ) > f; + mock::detail::function f; my_implementation imp; - f.expect().with( mock::same( imp ) ); - f( imp ); - CHECK_CALLS( 1 ); + f.expect().with(mock::same(imp)); + f(imp); + CHECK_CALLS(1); } } -namespace +namespace { +bool custom_constraint(int) { - bool custom_constraint( int ) - { - return false; - } + 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; - f.expect().with( &custom_constraint ); - CHECK_ERROR( f( 42 ), "unexpected call", 0, "?( 42 )\n. unlimited().with( ? )" ); + mock::detail::function f; + f.expect().with(&custom_constraint); + CHECK_ERROR(f(42), "unexpected call", 0, "?( 42 )\n. unlimited().with( ? )"); } { - mock::detail::function< int( int, const std::string& ) > f; - f.expect().with( &custom_constraint, "actual" ); - CHECK_ERROR( f( 42, "actual" ), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( ?, \"actual\" )" ); + mock::detail::function f; + f.expect().with(&custom_constraint, "actual"); + CHECK_ERROR(f(42, "actual"), "unexpected call", 0, "?( 42, \"actual\" )\n. unlimited().with( ?, \"actual\" )"); } } -//BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) +// BOOST_FIXTURE_TEST_CASE( literal_zero_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) //{ // mock::detail::function< void( int* ) > f; // f.expect().with( 0 ); @@ -356,220 +358,217 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_failing_custom_constrain #ifdef MOCK_NULLPTR -BOOST_FIXTURE_TEST_CASE( nullptr_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(nullptr_can_be_used_in_place_of_null_pointers_in_constraints, mock_error_fixture) { - mock::detail::function< void( int* ) > f; - f.expect().with( nullptr ); - f( 0 ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().with(nullptr); + f(0); + CHECK_CALLS(1); } #endif #ifdef MOCK_SMART_PTR -BOOST_FIXTURE_TEST_CASE( unique_ptr_is_supported_as_parameter, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(unique_ptr_is_supported_as_parameter, mock_error_fixture) { - mock::detail::function< void( std::unique_ptr< int > ) > f; + mock::detail::function)> f; f.expect(); - std::unique_ptr< int > p( new int ); - f( std::move( p ) ); - CHECK_CALLS( 1 ); + std::unique_ptr p(new int); + f(std::move(p)); + CHECK_CALLS(1); } #endif // MOCK_SMART_PTR // result handling -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_no_return_set_calls_missing_action, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_with_no_return_set_calls_missing_action, mock_error_fixture) { { - mock::detail::function< int() > f; + mock::detail::function f; f.expect(); - CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); + CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); } { - mock::detail::function< int&() > f; + mock::detail::function f; f.expect(); - CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); + CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); } { - mock::detail::function< const std::string&() > f; + mock::detail::function f; f.expect(); - CHECK_ERROR( f(), "missing action", 0, "?()\n. unlimited()" ); + CHECK_ERROR(f(), "missing action", 0, "?()\n. unlimited()"); } } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_value, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_the_set_value, mock_error_fixture) { { - mock::detail::function< int() > f; - f.expect().returns( 42 ); - BOOST_CHECK_EQUAL( 42, f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(42); + BOOST_CHECK_EQUAL(42, f()); + CHECK_CALLS(1); } { - mock::detail::function< int() > f; + mock::detail::function f; const int i = 42; - f.expect().returns( i ); - BOOST_CHECK_EQUAL( i, f() ); - CHECK_CALLS( 1 ); + f.expect().returns(i); + BOOST_CHECK_EQUAL(i, f()); + CHECK_CALLS(1); } { - mock::detail::function< int() > f; + mock::detail::function f; int i = 42; - f.expect().returns( boost::ref( i ) ); + f.expect().returns(boost::ref(i)); i = 43; - BOOST_CHECK_EQUAL( 43, f() ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(43, f()); + CHECK_CALLS(1); } { - mock::detail::function< int&() > f; - f.expect().returns( 42 ); - BOOST_CHECK_EQUAL( 42, f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(42); + BOOST_CHECK_EQUAL(42, f()); + CHECK_CALLS(1); } { - mock::detail::function< int&() > f; + mock::detail::function f; const int result = 42; - f.expect().returns( result ); - BOOST_CHECK_EQUAL( result, f() ); - CHECK_CALLS( 1 ); + f.expect().returns(result); + BOOST_CHECK_EQUAL(result, f()); + CHECK_CALLS(1); } { - mock::detail::function< int&() > f; + mock::detail::function f; int i = 42; - f.expect().returns( i ); + f.expect().returns(i); i = 43; - BOOST_CHECK_EQUAL( 42, f() ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(42, f()); + CHECK_CALLS(1); } { - mock::detail::function< int&() > f; + mock::detail::function f; int i = 42; - f.expect().returns( boost::ref( i ) ); + f.expect().returns(boost::ref(i)); i = 43; - BOOST_CHECK_EQUAL( 43, f() ); - BOOST_CHECK_EQUAL( 12, f() = 12 ); - BOOST_CHECK_EQUAL( 12, i ); - CHECK_CALLS( 2 ); + BOOST_CHECK_EQUAL(43, f()); + BOOST_CHECK_EQUAL(12, f() = 12); + BOOST_CHECK_EQUAL(12, i); + CHECK_CALLS(2); } { - mock::detail::function< std::string() > f; - f.expect().returns( "result" ); - BOOST_CHECK_EQUAL( "result", f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns("result"); + BOOST_CHECK_EQUAL("result", f()); + CHECK_CALLS(1); } { - mock::detail::function< const std::string&() > f; - f.expect().returns( "result" ); - BOOST_CHECK_EQUAL( "result", f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns("result"); + BOOST_CHECK_EQUAL("result", f()); + CHECK_CALLS(1); } { - mock::detail::function< int*() > f; - f.expect().returns( 0 ); - BOOST_CHECK( ! f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(0); + BOOST_CHECK(!f()); + CHECK_CALLS(1); } #ifdef BOOST_MSVC // this produces a warning with gcc { - mock::detail::function< int* const() > f; + mock::detail::function f; int i = 0; - f.expect().returns( &i ); - BOOST_CHECK_EQUAL( &i, f() ); - CHECK_CALLS( 1 ); + f.expect().returns(&i); + BOOST_CHECK_EQUAL(&i, f()); + CHECK_CALLS(1); } #endif { - mock::detail::function< int() > f; - f.expect().returns( 0 ); - BOOST_CHECK_EQUAL( 0, f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(0); + BOOST_CHECK_EQUAL(0, f()); + CHECK_CALLS(1); } { - mock::detail::function< int&() > f; - f.expect().returns( 0 ); - BOOST_CHECK_EQUAL( 0, f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(0); + BOOST_CHECK_EQUAL(0, f()); + CHECK_CALLS(1); } { - mock::detail::function< unsigned int() > f; - f.expect().returns( 0 ); - BOOST_CHECK_EQUAL( 0u, f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().returns(0); + BOOST_CHECK_EQUAL(0u, f()); + CHECK_CALLS(1); } } -namespace +namespace { +struct base { - struct base - { - virtual ~base() - {} - virtual void f() = 0; - }; - struct derived : base - { - virtual void f() - {} - }; -} + virtual ~base() {} + virtual void f() = 0; +}; +struct derived : base +{ + virtual void f() {} +}; +} // namespace #ifdef MOCK_AUTO_PTR -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_auto_ptr_value, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_the_set_auto_ptr_value, mock_error_fixture) { { - mock::detail::function< std::auto_ptr< int >() > f; - std::auto_ptr< int > ptr( new int( 3 ) ); - f.expect().returns( boost::ref( ptr ) ); - BOOST_CHECK_EQUAL( 3, *ptr ); - BOOST_CHECK_EQUAL( 3, *f() ); - BOOST_CHECK( ! ptr.get() ); - BOOST_CHECK( ! f().get() ); - CHECK_CALLS( 2 ); + mock::detail::function()> f; + std::auto_ptr ptr(new int(3)); + f.expect().returns(boost::ref(ptr)); + BOOST_CHECK_EQUAL(3, *ptr); + BOOST_CHECK_EQUAL(3, *f()); + BOOST_CHECK(!ptr.get()); + BOOST_CHECK(!f().get()); + CHECK_CALLS(2); } { - mock::detail::function< std::auto_ptr< int >() > f; - std::auto_ptr< int > ptr( new int( 3 ) ); - f.expect().returns( ptr ); - BOOST_CHECK( ! ptr.get() ); - BOOST_CHECK_EQUAL( 3, *f() ); - BOOST_CHECK( ! f().get() ); - CHECK_CALLS( 2 ); + mock::detail::function()> f; + std::auto_ptr ptr(new int(3)); + f.expect().returns(ptr); + BOOST_CHECK(!ptr.get()); + BOOST_CHECK_EQUAL(3, *f()); + BOOST_CHECK(!f().get()); + CHECK_CALLS(2); } { - mock::detail::function< std::auto_ptr< int >() > f; - f.expect().returns( new int( 3 ) ); - BOOST_CHECK_EQUAL( 3, *f() ); - BOOST_CHECK( ! f().get() ); - CHECK_CALLS( 2 ); + mock::detail::function()> f; + f.expect().returns(new int(3)); + BOOST_CHECK_EQUAL(3, *f()); + BOOST_CHECK(!f().get()); + CHECK_CALLS(2); } { - mock::detail::function< std::auto_ptr< int >() > f; - f.expect().returns( std::auto_ptr< int >( new int( 3 ) ) ); - BOOST_CHECK_EQUAL( 3, *f() ); - BOOST_CHECK( ! f().get() ); - CHECK_CALLS( 2 ); + mock::detail::function()> f; + f.expect().returns(std::auto_ptr(new int(3))); + BOOST_CHECK_EQUAL(3, *f()); + BOOST_CHECK(!f().get()); + CHECK_CALLS(2); } { - mock::detail::function< std::auto_ptr< base >() > f; - f.expect().returns( new derived ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + f.expect().returns(new derived); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< std::auto_ptr< base >() > f; - f.expect().returns( std::auto_ptr< base >( new derived ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + f.expect().returns(std::auto_ptr(new derived)); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< std::auto_ptr< base >() > f; - f.expect().returns( std::auto_ptr< derived >( new derived ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + f.expect().returns(std::auto_ptr(new derived)); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } } @@ -577,366 +576,365 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_auto_ptr_valu #ifdef MOCK_RVALUE_REFERENCES -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_lvalue, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_lvalue, mock_error_fixture) { - mock::detail::function< int() > f; + mock::detail::function f; int i = 3; - f.expect().moves( i ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + f.expect().moves(i); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_const_lvalue, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_const_lvalue, mock_error_fixture) { - mock::detail::function< int() > f; + mock::detail::function f; const int i = 3; - f.expect().moves( i ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + f.expect().moves(i); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_rvalue, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_rvalue, mock_error_fixture) { - mock::detail::function< int() > f; - f.expect().moves( 3 ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function f; + f.expect().moves(3); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } #endif #ifdef MOCK_SMART_PTR -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_unique_ptr_lvalue, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_unique_ptr_lvalue, mock_error_fixture) { - mock::detail::function< std::unique_ptr< int >() > f; - std::unique_ptr< int > p( new int ); - f.expect().moves( std::move( p ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + std::unique_ptr p(new int); + f.expect().moves(std::move(p)); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_unique_ptr_rvalue, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_moves_the_set_unique_ptr_rvalue, mock_error_fixture) { { - mock::detail::function< std::unique_ptr< int >() > f; - f.expect().moves( std::unique_ptr< int >( new int ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + f.expect().moves(std::unique_ptr(new int)); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } } #endif // MOCK_SMART_PTR -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_shared_ptr_value, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_the_set_shared_ptr_value, mock_error_fixture) { { - mock::detail::function< boost::shared_ptr< base >() > f; - f.expect().returns( new derived ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function()> f; + f.expect().returns(new derived); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< const boost::shared_ptr< base >&() > f; - f.expect().returns( new derived ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function&()> f; + f.expect().returns(new derived); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< boost::shared_ptr< base >&() > f; - f.expect().returns( new derived ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + mock::detail::function&()> f; + f.expect().returns(new derived); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_by_reference, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_returns_by_reference, mock_error_fixture) { { - mock::detail::function< base&() > f; + mock::detail::function f; derived b; - f.expect().returns( boost::ref( b ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + f.expect().returns(boost::ref(b)); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< base&() > f; + mock::detail::function f; derived b; - f.expect().returns( b ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + f.expect().returns(b); + BOOST_CHECK_NO_THROW(f()); + CHECK_CALLS(1); } { - mock::detail::function< undefined&() > f; - f.expect().returns( boost::ref( get_undefined() ) ); + mock::detail::function f; + f.expect().returns(boost::ref(get_undefined())); f.reset(); } } -namespace +namespace { +int custom_result() { - int custom_result() - { - return 42; - } + return 42; +} +} // namespace + +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor, mock_error_fixture) +{ + mock::detail::function f; + f.expect().calls(&custom_result); + BOOST_CHECK_EQUAL(42, f()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor, mock_error_fixture ) +namespace { +int custom_result_with_parameter(int i) { - mock::detail::function< int() > f; - f.expect().calls( &custom_result ); - BOOST_CHECK_EQUAL( 42, f() ); - CHECK_CALLS( 1 ); + return i; +} +} // namespace + +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_with_parameters, mock_error_fixture) +{ + mock::detail::function f; + f.expect().calls(&custom_result_with_parameter); + BOOST_CHECK_EQUAL(42, f(42)); + CHECK_CALLS(1); } -namespace +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_calls_the_custom_functor_without_parameters_thanks_to_boost_bind, + mock_error_fixture) { - int custom_result_with_parameter( int i ) - { - return i; - } + mock::detail::function f; + f.expect().calls(boost::bind(&custom_result)); + BOOST_CHECK_EQUAL(42, f(17)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_calls_the_custom_functor_with_parameters, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(triggering_an_expectation_throws_the_set_exception, mock_error_fixture) { - mock::detail::function< int( int ) > f; - f.expect().calls( &custom_result_with_parameter ); - BOOST_CHECK_EQUAL( 42, f( 42 ) ); - CHECK_CALLS( 1 ); -} - -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 ) ); - BOOST_CHECK_EQUAL( 42, f( 17 ) ); - CHECK_CALLS( 1 ); -} - -BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_throws_the_set_exception, mock_error_fixture ) -{ - mock::detail::function< int() > f; - f.expect().throws( std::runtime_error( "some exception" ) ); + mock::detail::function f; + f.expect().throws(std::runtime_error("some exception")); try { f(); - } - catch( std::runtime_error& f ) + } catch(std::runtime_error& f) { - BOOST_CHECK_EQUAL( "some exception", f.what() ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL("some exception", f.what()); + CHECK_CALLS(1); return; } - BOOST_FAIL( "should have thrown" ); + BOOST_FAIL("should have thrown"); } // multiple expectations -BOOST_FIXTURE_TEST_CASE( expecting_twice_a_single_expectation_makes_it_callable_twice, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(expecting_twice_a_single_expectation_makes_it_callable_twice, mock_error_fixture) { { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); f.expect().once(); f(); f(); - CHECK_ERROR( f(), "unexpected call", 2, "?()\nv once()\nv once()" ); + CHECK_ERROR(f(), "unexpected call", 2, "?()\nv once()\nv once()"); } { - mock::detail::function< void( const std::string& ) > f; - f.expect().once().with( "first" ); - 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\" )" ); + mock::detail::function f; + f.expect().once().with("first"); + 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\" )"); } } -BOOST_FIXTURE_TEST_CASE( best_expectation_is_selected_first, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(best_expectation_is_selected_first, mock_error_fixture) { { - mock::detail::function< void( int ) > f; - f.expect().once().with( 1 ); - f.expect().once().with( 2 ); - f( 2 ); - f( 1 ); - CHECK_ERROR( f( 3 ), "unexpected call", 2, "?( 3 )\nv once().with( 1 )\nv once().with( 2 )" ); + mock::detail::function f; + f.expect().once().with(1); + f.expect().once().with(2); + f(2); + f(1); + CHECK_ERROR(f(3), "unexpected call", 2, "?( 3 )\nv once().with( 1 )\nv once().with( 2 )"); } { - mock::detail::function< void( const std::string& ) > f; - f.expect().once().with( "first" ); - 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\" )" ); + mock::detail::function f; + f.expect().once().with("first"); + 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\" )"); } } // error report -namespace +namespace { +template +std::string to_string(const T& t) { - template< typename T > - std::string to_string( const T& t ) - { - std::stringstream s; - s << t; - return s.str(); - } + std::stringstream s; + s << t; + return s.str(); } +} // namespace -BOOST_FIXTURE_TEST_CASE( expectation_can_be_serialized_to_be_human_readable, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(expectation_can_be_serialized_to_be_human_readable, mock_error_fixture) { { - mock::detail::function< void( int ) > f; - f.expect().once().with( 1 ); - f.expect().once().with( 2 ); - BOOST_CHECK_NO_THROW( f( 2 ) ); + mock::detail::function f; + f.expect().once().with(1); + f.expect().once().with(2); + BOOST_CHECK_NO_THROW(f(2)); const std::string expected = "?\n" ". once().with( 1 )\n" "v once().with( 2 )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(expected, to_string(f)); + CHECK_CALLS(1); f.reset(); } { - mock::detail::function< void( int ) > f; - f.expect().never().with( 1 ); + mock::detail::function f; + f.expect().never().with(1); const std::string expected = "?\n" "v never().with( 1 )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); f.reset(); } { - mock::detail::function< void( const std::string& ) > f; - f.expect().never().with( mock::less( "first" ) ); - f.expect().exactly( 2 ).with( "second" ); - BOOST_CHECK_NO_THROW( f( "second" ) ); + mock::detail::function f; + f.expect().never().with(mock::less("first")); + f.expect().exactly(2).with("second"); + BOOST_CHECK_NO_THROW(f("second")); { const std::string expected = "?\n" "v never().with( less( \"first\" ) )\n" ". exactly( 1/2 ).with( \"second\" )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); } - BOOST_CHECK_NO_THROW( f( "second" ) ); + BOOST_CHECK_NO_THROW(f("second")); { const std::string expected = "?\n" "v never().with( less( \"first\" ) )\n" "v exactly( 2/2 ).with( \"second\" )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); - CHECK_CALLS( 2 ); + BOOST_CHECK_EQUAL(expected, to_string(f)); + CHECK_CALLS(2); } f.reset(); } { - mock::detail::function< void( int ) > f; + mock::detail::function f; f.expect().once(); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); f.reset(); } { - mock::detail::function< void( int ) > f; - f.expect().once().with( mock::any ); + mock::detail::function f; + f.expect().once().with(mock::any); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); f.reset(); } { - mock::detail::function< void( int ) > f; + mock::detail::function f; f.expect().once(); const std::string expected = "?\n" ". once().with( any )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); f.reset(); } { - mock::detail::function< void( int ) > f; - f.expect().once().with( &custom_constraint ); + mock::detail::function f; + f.expect().once().with(&custom_constraint); const std::string expected = "?\n" ". once().with( ? )"; - BOOST_CHECK_EQUAL( expected, to_string( f ) ); + BOOST_CHECK_EQUAL(expected, to_string(f)); f.reset(); } } -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() > ); + boost::scoped_ptr> f(new mock::detail::function); f->expect().once(); - CHECK_ERROR( f.reset(), "untriggered expectation", 0, "?\n. 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; + mock::detail::function f; f.expect().once(); - CHECK_ERROR( f.verify(), "verification failed", 0, "?\n. 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, "?()" ); + mock::detail::function f; + CHECK_ERROR(f(), "unexpected call", 0, "?()"); } -BOOST_FIXTURE_TEST_CASE( adding_an_expectation_reactivates_the_verification_upon_destruction, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(adding_an_expectation_reactivates_the_verification_upon_destruction, mock_error_fixture) { - boost::scoped_ptr< mock::detail::function< void() > > f( new mock::detail::function< void() > ); - CHECK_ERROR( (*f)(), "unexpected call", 0, "?()" ); + boost::scoped_ptr> f(new mock::detail::function); + CHECK_ERROR((*f)(), "unexpected call", 0, "?()"); f->expect().once(); - CHECK_ERROR( f.reset(), "untriggered expectation", 0, "?\n. once()" ); + CHECK_ERROR(f.reset(), "untriggered expectation", 0, "?\n. once()"); } -BOOST_FIXTURE_TEST_CASE( throwing_an_exception_disables_the_automatic_verification_upon_destruction, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(throwing_an_exception_disables_the_automatic_verification_upon_destruction, mock_error_fixture) { try { - mock::detail::function< void() > f; + mock::detail::function f; f.expect().once(); throw std::exception(); - } - catch( std::exception& ) + } catch(std::exception&) {} } -BOOST_FIXTURE_TEST_CASE( adding_file_and_line_number_information, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(adding_file_and_line_number_information, mock_error_fixture) { - mock::detail::function< void() > f; - f.expect( "file name", 42 ).once(); - CHECK_ERROR( f.verify(), "verification failed", 0, "?\n. once()" ); - BOOST_CHECK_EQUAL( "file name", mock_error_data.last_file ); - BOOST_CHECK_EQUAL( 42, mock_error_data.last_line ); + mock::detail::function f; + f.expect("file name", 42).once(); + CHECK_ERROR(f.verify(), "verification failed", 0, "?\n. once()"); + BOOST_CHECK_EQUAL("file name", mock_error_data.last_file); + BOOST_CHECK_EQUAL(42, mock_error_data.last_line); } #ifdef MOCK_THREAD_SAFE -#include +# include -namespace +namespace { +void iterate(mock::detail::function& f) { - void iterate( mock::detail::function< int() >& f ) + f.expect().once().returns(0); + try { - f.expect().once().returns( 0 ); - try - { - f(); - } - catch( ... ) - {} - } + f(); + } catch(...) + {} } +} // namespace -BOOST_FIXTURE_TEST_CASE( function_is_thread_safe, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(function_is_thread_safe, mock_error_fixture) { - mock::detail::function< int() > f; + mock::detail::function f; boost::thread_group group; - for( int i = 0; i < 100; ++i ) - group.create_thread( boost::bind( &iterate, boost::ref( f ) ) ); + for(int i = 0; i < 100; ++i) + group.create_thread(boost::bind(&iterate, boost::ref(f))); group.join_all(); - CHECK_CALLS( 100 ); + CHECK_CALLS(100); } #endif // MOCK_THREAD_SAFE diff --git a/test/detail/test_invocation.cpp b/test/detail/test_invocation.cpp index 7bec6f8..fb31ca4 100644 --- a/test/detail/test_invocation.cpp +++ b/test/detail/test_invocation.cpp @@ -9,68 +9,68 @@ #include #include -BOOST_AUTO_TEST_CASE( unlimited ) +BOOST_AUTO_TEST_CASE(unlimited) { mock::detail::unlimited invocation; - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); } -BOOST_AUTO_TEST_CASE( once ) +BOOST_AUTO_TEST_CASE(once) { mock::detail::once invocation; - BOOST_CHECK( ! invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( invocation.exhausted() ); - BOOST_CHECK( ! invocation.invoke() ); + BOOST_CHECK(!invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(invocation.exhausted()); + BOOST_CHECK(!invocation.invoke()); } -BOOST_AUTO_TEST_CASE( never ) +BOOST_AUTO_TEST_CASE(never) { mock::detail::never invocation; - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( invocation.exhausted() ); - BOOST_CHECK( ! invocation.invoke() ); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(invocation.exhausted()); + BOOST_CHECK(!invocation.invoke()); } -BOOST_AUTO_TEST_CASE( at_most ) +BOOST_AUTO_TEST_CASE(at_most) { - mock::detail::at_most invocation( 1 ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( invocation.exhausted() ); - BOOST_CHECK( ! invocation.invoke() ); + mock::detail::at_most invocation(1); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(invocation.exhausted()); + BOOST_CHECK(!invocation.invoke()); } -BOOST_AUTO_TEST_CASE( at_least ) +BOOST_AUTO_TEST_CASE(at_least) { - mock::detail::at_least invocation( 1 ); - BOOST_CHECK( ! invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); + mock::detail::at_least invocation(1); + BOOST_CHECK(!invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); } -BOOST_AUTO_TEST_CASE( between ) +BOOST_AUTO_TEST_CASE(between) { - mock::detail::between invocation( 1, 2 ); - BOOST_CHECK( ! invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( ! invocation.exhausted() ); - BOOST_CHECK( invocation.invoke() ); - BOOST_CHECK( invocation.verify() ); - BOOST_CHECK( invocation.exhausted() ); - BOOST_CHECK( ! invocation.invoke() ); + mock::detail::between invocation(1, 2); + BOOST_CHECK(!invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(!invocation.exhausted()); + BOOST_CHECK(invocation.invoke()); + BOOST_CHECK(invocation.verify()); + BOOST_CHECK(invocation.exhausted()); + BOOST_CHECK(!invocation.invoke()); } diff --git a/test/detail/test_is_functor.cpp b/test/detail/test_is_functor.cpp index a6a0f38..9e92ad8 100644 --- a/test/detail/test_is_functor.cpp +++ b/test/detail/test_is_functor.cpp @@ -9,147 +9,148 @@ #include #include #ifdef BOOST_MSVC -#pragma warning( push, 0 ) +# pragma warning(push, 0) #endif #include #include #ifdef BOOST_MSVC -#pragma warning( pop ) +# pragma warning(pop) #endif -#include #include +#include -namespace +namespace { +struct declared_but_not_defined; +BOOST_MPL_ASSERT_NOT((mock::detail::is_functor)); + +template +void is_functor(T) { - struct declared_but_not_defined; - BOOST_MPL_ASSERT_NOT(( - mock::detail::is_functor< declared_but_not_defined, int > )); + BOOST_MPL_ASSERT((mock::detail::is_functor)); +} +template +void is_not_functor(T) +{ + BOOST_MPL_ASSERT_NOT((mock::detail::is_functor)); +} - template< typename T > - void is_functor( T ) +void f0() {} +bool f1(int) +{ + return false; +} +bool f2(std::string, int) +{ + return false; +} +} // namespace + +BOOST_AUTO_TEST_CASE(data_is_not_functor) +{ + is_not_functor(42); +} + +BOOST_AUTO_TEST_CASE(function_is_functor) +{ + is_functor(f0); + is_functor(f1); + is_functor(f2); +} + +BOOST_AUTO_TEST_CASE(function_pointer_is_functor) +{ + is_functor(&f0); + is_functor(&f1); + is_functor(&f2); +} + +BOOST_AUTO_TEST_CASE(std_ptr_fun_is_functor) +{ + is_functor(std::ptr_fun(&f1)); + is_functor(std::ptr_fun(&f2)); +} + +BOOST_AUTO_TEST_CASE(std_bind_first_is_functor) +{ + is_functor(std::bind1st(std::ptr_fun(&f2), "")); +} + +namespace { +struct unary_functor0 : public std::unary_function +{}; +struct unary_functor1 : public std::unary_function +{}; +} // namespace + +BOOST_AUTO_TEST_CASE(std_unary_functor_is_functor) +{ + is_functor(unary_functor0()); + is_functor(unary_functor1()); +} + +BOOST_AUTO_TEST_CASE(boost_bind_is_functor) +{ + is_functor(boost::bind(&f0)); + is_functor(boost::bind(&f1, _1)); + is_functor(boost::bind(&f2, "", _1)); +} + +BOOST_AUTO_TEST_CASE(boost_lambda_is_functor) +{ + is_functor(boost::lambda::_1 < 42); +} + +BOOST_AUTO_TEST_CASE(boost_phoenix_is_functor) +{ + is_functor(boost::phoenix::arg_names::arg1 < 42); + is_functor(boost::phoenix::arg_names::_1 < 42); +} + +BOOST_AUTO_TEST_CASE(boost_function_is_functor) +{ + is_functor(boost::function()); +} + +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 { +struct sig_functor +{ + template + struct sig { - BOOST_MPL_ASSERT(( mock::detail::is_functor< T, int > )); - } - template< typename T > - void is_not_functor( T ) - { - BOOST_MPL_ASSERT_NOT(( mock::detail::is_functor< T, int > )); - } - - void f0() {} - bool f1( int ) { return false; } - bool f2( std::string, int ) { return false; } -} - -BOOST_AUTO_TEST_CASE( data_is_not_functor ) -{ - is_not_functor( 42 ); -} - -BOOST_AUTO_TEST_CASE( function_is_functor ) -{ - is_functor( f0 ); - is_functor( f1 ); - is_functor( f2 ); -} - -BOOST_AUTO_TEST_CASE( function_pointer_is_functor ) -{ - is_functor( &f0 ); - is_functor( &f1 ); - is_functor( &f2 ); -} - -BOOST_AUTO_TEST_CASE( std_ptr_fun_is_functor ) -{ - is_functor( std::ptr_fun( &f1 ) ); - is_functor( std::ptr_fun( &f2 ) ); -} - -BOOST_AUTO_TEST_CASE( std_bind_first_is_functor ) -{ - is_functor( std::bind1st( std::ptr_fun( &f2 ), "" ) ); -} - -namespace -{ - struct unary_functor0 : public std::unary_function< void, void > - {}; - struct unary_functor1 : public std::unary_function< int, void > - {}; -} - -BOOST_AUTO_TEST_CASE( std_unary_functor_is_functor ) -{ - is_functor( unary_functor0() ); - is_functor( unary_functor1() ); -} - -BOOST_AUTO_TEST_CASE( boost_bind_is_functor ) -{ - is_functor( boost::bind( &f0 ) ); - is_functor( boost::bind( &f1, _1 ) ); - is_functor( boost::bind( &f2, "", _1 ) ); -} - -BOOST_AUTO_TEST_CASE( boost_lambda_is_functor ) -{ - is_functor( boost::lambda::_1 < 42 ); -} - -BOOST_AUTO_TEST_CASE( boost_phoenix_is_functor ) -{ - is_functor( boost::phoenix::arg_names::arg1 < 42 ); - is_functor( boost::phoenix::arg_names::_1 < 42 ); -} - -BOOST_AUTO_TEST_CASE( boost_function_is_functor ) -{ - is_functor( boost::function< void() >() ); -} - -namespace -{ - struct result_type_functor - { - typedef void result_type; + typedef void type; }; -} +}; +} // namespace -BOOST_AUTO_TEST_CASE( class_with_result_type_is_functor ) +BOOST_AUTO_TEST_CASE(class_with_sig_is_functor) { - is_functor( result_type_functor() ); -} - -namespace -{ - struct sig_functor - { - template< typename Args > - struct sig - { - typedef void type; - }; - }; -} - -BOOST_AUTO_TEST_CASE( class_with_sig_is_functor ) -{ - is_functor( sig_functor() ); + is_functor(sig_functor()); } #ifdef MOCK_LAMBDAS -BOOST_AUTO_TEST_CASE( cxx11_lambda_is_functor ) +BOOST_AUTO_TEST_CASE(cxx11_lambda_is_functor) { - is_not_functor( []() {} ); -#ifdef MOCK_DECLTYPE - is_functor( []( int ) {} ); -#else - is_not_functor( []( int ) {} ); -#endif - is_not_functor( []( const std::string&, int ) {} ); - is_not_functor( []( int, const std::string& ) {} ); + is_not_functor([]() {}); +# ifdef MOCK_DECLTYPE + is_functor([](int) {}); +# else + is_not_functor([](int) {}); +# endif + is_not_functor([](const std::string&, int) {}); + is_not_functor([](int, const std::string&) {}); } #endif diff --git a/test/detail/test_signature.cpp b/test/detail/test_signature.cpp index 27f4e91..7f5c106 100644 --- a/test/detail/test_signature.cpp +++ b/test/detail/test_signature.cpp @@ -7,23 +7,20 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include #include +#include -namespace +namespace { +struct base { - struct base - { - void method_1(); - float method_2( int ) const; - }; - typedef base base_type; -} + void method_1(); + float method_2(int) const; +}; +typedef base base_type; +} // namespace -BOOST_AUTO_TEST_CASE( mock_signature_generates_signature ) +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)); + BOOST_MPL_ASSERT((boost::is_same)); } diff --git a/test/detail/test_type_name.cpp b/test/detail/test_type_name.cpp index 292414a..1f29bd7 100644 --- a/test/detail/test_type_name.cpp +++ b/test/detail/test_type_name.cpp @@ -7,219 +7,217 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include #include +#include -namespace +namespace { +template +std::string to_string(const T&) { - template< typename T > - std::string to_string( const T& ) - { - return boost::lexical_cast< std::string >( MOCK_TYPE_NAME(T) ); - } + return boost::lexical_cast(MOCK_TYPE_NAME(T)); } +} // namespace -BOOST_AUTO_TEST_CASE( name_of_base_type_is_extracted ) +BOOST_AUTO_TEST_CASE(name_of_base_type_is_extracted) { - BOOST_CHECK_EQUAL( "char", to_string( 'a' ) ); - BOOST_CHECK_EQUAL( "bool", to_string( true ) ); - BOOST_CHECK_EQUAL( "int", to_string< int >( 0 ) ); - BOOST_CHECK_EQUAL( "short", to_string< short >( 0 ) ); - BOOST_CHECK_EQUAL( "long", to_string< long >( 0 ) ); - BOOST_CHECK_EQUAL( "unsigned int", to_string< unsigned int >( 0 ) ); - BOOST_CHECK_EQUAL( "unsigned short", to_string< unsigned short >( 0 ) ); - BOOST_CHECK_EQUAL( "unsigned long", to_string< unsigned long >( 0 ) ); + BOOST_CHECK_EQUAL("char", to_string('a')); + BOOST_CHECK_EQUAL("bool", to_string(true)); + BOOST_CHECK_EQUAL("int", to_string(0)); + BOOST_CHECK_EQUAL("short", to_string(0)); + BOOST_CHECK_EQUAL("long", to_string(0)); + BOOST_CHECK_EQUAL("unsigned int", to_string(0)); + BOOST_CHECK_EQUAL("unsigned short", to_string(0)); + BOOST_CHECK_EQUAL("unsigned long", to_string(0)); } struct my_type_in_default_namespace { - struct inner {}; + struct inner + {}; }; -BOOST_AUTO_TEST_CASE( name_of_type_in_default_namespace_is_extracted ) +BOOST_AUTO_TEST_CASE(name_of_type_in_default_namespace_is_extracted) { - BOOST_CHECK_EQUAL( "my_type_in_default_namespace", to_string( my_type_in_default_namespace() ) ); + BOOST_CHECK_EQUAL("my_type_in_default_namespace", to_string(my_type_in_default_namespace())); } -BOOST_AUTO_TEST_CASE( name_of_inner_type_from_type_in_default_namespace_is_extracted ) +BOOST_AUTO_TEST_CASE(name_of_inner_type_from_type_in_default_namespace_is_extracted) { - BOOST_CHECK_EQUAL( "inner", to_string( my_type_in_default_namespace::inner() ) ); + BOOST_CHECK_EQUAL("inner", to_string(my_type_in_default_namespace::inner())); } -template< typename T > +template 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_AUTO_TEST_CASE(name_of_template_type_in_default_namespace_is_extracted) { - BOOST_CHECK_EQUAL( "my_template_type_in_default_namespace", to_string( my_template_type_in_default_namespace() ) ); + BOOST_CHECK_EQUAL("my_template_type_in_default_namespace", + to_string(my_template_type_in_default_namespace())); } -BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_default_namespace_is_extracted ) +BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_default_namespace_is_extracted) { - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type_in_default_namespace::inner() ) ); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type_in_default_namespace::inner())); } -namespace +namespace { +struct my_type_in_anonymous_namespace +{}; +} // namespace + +BOOST_AUTO_TEST_CASE(name_of_type_in_anonymous_namespace_is_extracted) { - struct my_type_in_anonymous_namespace {}; + BOOST_CHECK_EQUAL("my_type_in_anonymous_namespace", to_string(my_type_in_anonymous_namespace())); } -BOOST_AUTO_TEST_CASE( name_of_type_in_anonymous_namespace_is_extracted ) +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_in_anonymous_namespace", to_string( my_type_in_anonymous_namespace() ) ); + BOOST_CHECK_EQUAL("my_type_from_named_namespace", to_string(nm::my_type_from_named_namespace())); } -namespace nm -{ - struct my_type_from_named_namespace {}; -} - -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 {}; -} -} - -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 {}; -} -} - -BOOST_AUTO_TEST_CASE( name_of_type_in_unnamed_inner_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "my_type_in_unnamed_inner_namespace", to_string( inner::my_type_in_unnamed_inner_namespace() ) ); -} - -BOOST_AUTO_TEST_CASE( name_of_local_type_is_extracted ) -{ - struct my_local_type {}; - BOOST_CHECK_EQUAL( "my_local_type", boost::lexical_cast< std::string >( MOCK_TYPE_NAME(my_local_type) ) ); -} - -namespace -{ - template< typename T > - struct my_template_type - { - struct inner {}; - }; -} - -BOOST_AUTO_TEST_CASE( name_of_template_type_in_anonymous_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const* >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const* >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< int const*& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( my_template_type< std::exception const*& >() ) ); -} - -BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_anonymous_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const* >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const* >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< int const*& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( my_template_type< std::exception const*& >::inner() ) ); -} - -namespace nm -{ - template< typename T > - struct my_template_type - { - struct inner {}; - }; -} - -BOOST_AUTO_TEST_CASE( name_of_template_type_in_named_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const* >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const* >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< int const*& >() ) ); - BOOST_CHECK_EQUAL( "my_template_type", to_string( nm::my_template_type< std::exception const*& >() ) ); -} - -BOOST_AUTO_TEST_CASE( name_of_inner_type_from_template_type_in_named_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const* >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const* >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< int const*& >::inner() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm::my_template_type< std::exception const*& >::inner() ) ); -} - -namespace nm2 -{ - template< typename T > - struct my_template_type - { - template< typename U > - struct inner {}; - }; -} - -BOOST_AUTO_TEST_CASE( name_of_template_inner_type_from_template_type_in_named_namespace_is_extracted ) -{ - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int >() ) ); - - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const& >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const& >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const* >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const* >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int const*& >::inner< int >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception const*& >::inner< int >() ) ); - - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const& >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const& >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const* >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const* >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< int >::inner< int const*& >() ) ); - BOOST_CHECK_EQUAL( "inner", to_string( nm2::my_template_type< std::exception >::inner< int const*& >() ) ); -} - -namespace -{ - template< typename T1, typename T2, typename T3 > - struct my_tpl +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())); } -BOOST_AUTO_TEST_CASE( name_of_nested_template_with_multiple_arguments_is_extracted ) +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) { - BOOST_CHECK_EQUAL( "vector>", to_string( std::vector< int >() ) ); - BOOST_CHECK_EQUAL( "vector>, allocator>>>", to_string( std::vector< std::vector< int > >() ) ); - BOOST_CHECK_EQUAL( "my_tpl, my_tpl, my_tpl>", to_string( my_tpl< my_tpl< int, int, int >, my_tpl< int, int, int >, my_tpl< int, int, int > >() ) ); + BOOST_CHECK_EQUAL("my_type_in_unnamed_inner_namespace", to_string(inner::my_type_in_unnamed_inner_namespace())); +} + +BOOST_AUTO_TEST_CASE(name_of_local_type_is_extracted) +{ + struct my_local_type + {}; + BOOST_CHECK_EQUAL("my_local_type", boost::lexical_cast(MOCK_TYPE_NAME(my_local_type))); +} + +namespace { +template +struct my_template_type +{ + struct inner + {}; +}; +} // namespace + +BOOST_AUTO_TEST_CASE(name_of_template_type_in_anonymous_namespace_is_extracted) +{ + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(my_template_type())); +} + +BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_anonymous_namespace_is_extracted) +{ + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(my_template_type::inner())); +} + +namespace nm { +template +struct my_template_type +{ + struct inner + {}; +}; +} // namespace nm + +BOOST_AUTO_TEST_CASE(name_of_template_type_in_named_namespace_is_extracted) +{ + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); + BOOST_CHECK_EQUAL("my_template_type", to_string(nm::my_template_type())); +} + +BOOST_AUTO_TEST_CASE(name_of_inner_type_from_template_type_in_named_namespace_is_extracted) +{ + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm::my_template_type::inner())); +} + +namespace nm2 { +template +struct my_template_type +{ + template + struct inner + {}; +}; +} // namespace nm2 + +BOOST_AUTO_TEST_CASE(name_of_template_inner_type_from_template_type_in_named_namespace_is_extracted) +{ + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); + BOOST_CHECK_EQUAL("inner", to_string(nm2::my_template_type::inner())); +} + +namespace { +template +struct my_tpl +{}; +} // namespace + +BOOST_AUTO_TEST_CASE(name_of_nested_template_with_multiple_arguments_is_extracted) +{ + BOOST_CHECK_EQUAL("vector>", to_string(std::vector())); + BOOST_CHECK_EQUAL("vector>, allocator>>>", + to_string(std::vector>())); + BOOST_CHECK_EQUAL("my_tpl, my_tpl, my_tpl>", + to_string(my_tpl, my_tpl, my_tpl>())); } diff --git a/test/fail_ambiguous_mock_method.cpp b/test/fail_ambiguous_mock_method.cpp index 08148ce..5e685e7 100644 --- a/test/fail_ambiguous_mock_method.cpp +++ b/test/fail_ambiguous_mock_method.cpp @@ -8,17 +8,13 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() {} - virtual void my_method() = 0; - virtual void my_method( int ) = 0; - }; + virtual ~my_base() {} + virtual void my_method() = 0; + 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 diff --git a/test/fail_constraint_functor_not_compatible.cpp b/test/fail_constraint_functor_not_compatible.cpp index 51558eb..70cfd34 100644 --- a/test/fail_constraint_functor_not_compatible.cpp +++ b/test/fail_constraint_functor_not_compatible.cpp @@ -8,17 +8,13 @@ #include -namespace -{ - MOCK_CLASS( my_class ) - { - MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) - }; - bool constraint( int, int ); +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)}; +bool constraint(int, int); - void test_case() - { - my_class c; - MOCK_EXPECT( c.my_method ).with( &constraint ); - } +void test_case() +{ + my_class c; + MOCK_EXPECT(c.my_method).with(&constraint); } +} // namespace diff --git a/test/fail_constraint_value_not_comparable.cpp b/test/fail_constraint_value_not_comparable.cpp index 0d0ef8c..2788b9a 100644 --- a/test/fail_constraint_value_not_comparable.cpp +++ b/test/fail_constraint_value_not_comparable.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)}; +void test_case() { - 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" ); - } + my_class c; + MOCK_EXPECT(c.my_method).with("42"); } +} // namespace diff --git a/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp b/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp index f54013c..dc2e1fc 100644 --- a/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp +++ b/test/fail_constraint_value_of_wrong_type_in_builtin_constraint.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)}; +void test_case() { - 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" ) ); - } + my_class c; + MOCK_EXPECT(c.my_method).with(mock::equal("42")); } +} // namespace diff --git a/test/fail_mismatch_type_in_returns_int_action.cpp b/test/fail_mismatch_type_in_returns_int_action.cpp index 1147857..1cb2aac 100644 --- a/test/fail_mismatch_type_in_returns_int_action.cpp +++ b/test/fail_mismatch_type_in_returns_int_action.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, int(), my_method)}; +void test_case() { - 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() ); - } + my_class c; + MOCK_EXPECT(c.my_method).returns(std::string()); } +} // namespace diff --git a/test/fail_mismatch_type_in_returns_string_action.cpp b/test/fail_mismatch_type_in_returns_string_action.cpp index 103613f..5ecf4a5 100644 --- a/test/fail_mismatch_type_in_returns_string_action.cpp +++ b/test/fail_mismatch_type_in_returns_string_action.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, std::string(), my_method)}; +void test_case() { - 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 ); - } + my_class c; + MOCK_EXPECT(c.my_method).returns(42); } +} // namespace diff --git a/test/fail_mismatch_type_in_returns_void_action.cpp b/test/fail_mismatch_type_in_returns_void_action.cpp index 68b774c..6382518 100644 --- a/test/fail_mismatch_type_in_returns_void_action.cpp +++ b/test/fail_mismatch_type_in_returns_void_action.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 0, void(), my_method)}; +void test_case() { - 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" ); - } + my_class c; + MOCK_EXPECT(c.my_method).returns("42"); } +} // namespace diff --git a/test/fail_non_existing_base_class_method_in_mock_method.cpp b/test/fail_non_existing_base_class_method_in_mock_method.cpp index 0e50e73..0d64280 100644 --- a/test/fail_non_existing_base_class_method_in_mock_method.cpp +++ b/test/fail_non_existing_base_class_method_in_mock_method.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~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 diff --git a/test/fail_number_of_arguments_greater_than_max_constant.cpp b/test/fail_number_of_arguments_greater_than_max_constant.cpp index 7a71272..520f2c7 100644 --- a/test/fail_number_of_arguments_greater_than_max_constant.cpp +++ b/test/fail_number_of_arguments_greater_than_max_constant.cpp @@ -8,18 +8,14 @@ #include -BOOST_STATIC_ASSERT( MOCK_MAX_ARGS == 9 ); +BOOST_STATIC_ASSERT(MOCK_MAX_ARGS == 9); -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() {} - virtual void my_method( int, int, int, int, int, int, int, int, int, int ) = 0; - }; + 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 diff --git a/test/fail_template_argument_without_tpl_macro.cpp b/test/fail_template_argument_without_tpl_macro.cpp index a0e700e..289ef79 100644 --- a/test/fail_template_argument_without_tpl_macro.cpp +++ b/test/fail_template_argument_without_tpl_macro.cpp @@ -8,11 +8,7 @@ #include -namespace -{ - template< typename T > - MOCK_CLASS( my_class ) - { - MOCK_METHOD_EXT( my_method, 1, void( T ), my_method ) - }; +namespace { +template +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(T), my_method)}; } diff --git a/test/fail_too_many_arguments_in_mock_method.cpp b/test/fail_too_many_arguments_in_mock_method.cpp index fa4ca01..88e4425 100644 --- a/test/fail_too_many_arguments_in_mock_method.cpp +++ b/test/fail_too_many_arguments_in_mock_method.cpp @@ -8,16 +8,12 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() {} - virtual void my_method( int ) = 0; - }; + 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 diff --git a/test/fail_wrong_number_of_arguments_in_with.cpp b/test/fail_wrong_number_of_arguments_in_with.cpp index dc3420f..edc5505 100644 --- a/test/fail_wrong_number_of_arguments_in_with.cpp +++ b/test/fail_wrong_number_of_arguments_in_with.cpp @@ -8,15 +8,11 @@ #include -namespace +namespace { +MOCK_CLASS(my_class){MOCK_METHOD_EXT(my_method, 1, void(int), my_method)}; +void test_case() { - 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 ); - } + my_class c; + MOCK_EXPECT(c.my_method).with(42, 42); } +} // namespace diff --git a/test/mock_error.hpp b/test/mock_error.hpp index bd3fbe9..eb5b20a 100644 --- a/test/mock_error.hpp +++ b/test/mock_error.hpp @@ -15,7 +15,7 @@ #include #include -struct mock_error_data_t : mock::detail::singleton< mock_error_data_t > +struct mock_error_data_t : mock::detail::singleton { void reset() { @@ -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; @@ -52,60 +47,54 @@ struct mock_error_data_t : mock::detail::singleton< mock_error_data_t > std::string last_context; std::string last_file; int last_line; - MOCK_SINGLETON_CONS( mock_error_data_t ); + MOCK_SINGLETON_CONS(mock_error_data_t); }; -MOCK_SINGLETON_INST( mock_error_data ) +MOCK_SINGLETON_INST(mock_error_data) -template< typename Result > +template 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*/ ) + template + 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 ) + template + 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(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() ); - BOOST_CHECK_EQUAL( 0, mock_error_data.call_count ); + BOOST_CHECK(mock_error_data.verify()); + BOOST_CHECK_EQUAL(0, mock_error_data.call_count); } }; -#define CHECK_CALLS( calls ) \ - BOOST_CHECK_EQUAL( calls, mock_error_data.call_count ); \ +#define CHECK_CALLS(calls) \ + BOOST_CHECK_EQUAL(calls, mock_error_data.call_count); \ mock_error_data.call_count = 0; -#define CHECK_ERROR( expr, error, calls, context ) \ - BOOST_CHECK( mock_error_data.verify() ); \ - 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 ); \ - CHECK_CALLS( calls ); \ +#define CHECK_ERROR(expr, error, calls, context) \ + BOOST_CHECK(mock_error_data.verify()); \ + 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); \ + CHECK_CALLS(calls); \ mock_error_data.reset(); #endif // MOCK_TEST_MOCK_ERROR_HPP_INCLUDED diff --git a/test/test_constraint.cpp b/test/test_constraint.cpp index c690d07..06b6306 100644 --- a/test/test_constraint.cpp +++ b/test/test_constraint.cpp @@ -11,32 +11,30 @@ #ifdef MOCK_VARIADIC_MACROS -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 { +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 ) +BOOST_AUTO_TEST_CASE(mock_constraint_is_supported_by_compilers_with_variadic_macros) { - BOOST_CHECK( constraint_0.c_( 0 ) ); - BOOST_CHECK( constraint_1( 0 ).c_( 0 ) ); - BOOST_CHECK( constraint_2( 0, 0 ).c_( 0 ) ); + BOOST_CHECK(constraint_0.c_(0)); + BOOST_CHECK(constraint_1(0).c_(0)); + BOOST_CHECK(constraint_2(0, 0).c_(0)); } #endif // MOCK_VARIADIC_MACROS -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 { +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 ) +BOOST_AUTO_TEST_CASE(mock_constraint_ext_is_supported_by_all_compilers) { - BOOST_CHECK( constraint_0_ext.c_( 0 ) ); - BOOST_CHECK( constraint_1_ext( 0 ).c_( 0 ) ); - BOOST_CHECK( constraint_2_ext( 0, 0 ).c_( 0 ) ); + BOOST_CHECK(constraint_0_ext.c_(0)); + BOOST_CHECK(constraint_1_ext(0).c_(0)); + BOOST_CHECK(constraint_2_ext(0, 0).c_(0)); } diff --git a/test/test_constraints.cpp b/test/test_constraints.cpp index 9e918da..34eceb1 100644 --- a/test/test_constraints.cpp +++ b/test/test_constraints.cpp @@ -10,414 +10,379 @@ #include #include -BOOST_AUTO_TEST_CASE( all_comparison_constraints_can_be_instanciated ) +BOOST_AUTO_TEST_CASE(all_comparison_constraints_can_be_instanciated) { - mock::equal( 0 ); - mock::less( 0 ); - mock::greater( 0 ); - mock::less_equal( 0 ); - mock::greater_equal( 0 ); + mock::equal(0); + mock::less(0); + mock::greater(0); + mock::less_equal(0); + mock::greater_equal(0); } -BOOST_AUTO_TEST_CASE( constraints_can_be_negated_using_the_not_operator ) +BOOST_AUTO_TEST_CASE(constraints_can_be_negated_using_the_not_operator) { - ! mock::any; - ! mock::affirm; - ! mock::negate; - ! mock::evaluate; - ! mock::equal( 0 ); - ! mock::less( 0 ); - ! mock::greater( 0 ); - ! mock::less_equal( 0 ); - ! mock::greater_equal( 0 ); + !mock::any; + !mock::affirm; + !mock::negate; + !mock::evaluate; + !mock::equal(0); + !mock::less(0); + !mock::greater(0); + !mock::less_equal(0); + !mock::greater_equal(0); } -BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_or_operator ) +BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_or_operator) { - mock::less( 0 ) || mock::greater( 0 ); + mock::less(0) || mock::greater(0); } -BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_and_operator ) +BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_and_operator) { - mock::less( 0 ) && mock::greater( 0 ); + mock::less(0) && mock::greater(0); } -BOOST_AUTO_TEST_CASE( equal_constraint ) +BOOST_AUTO_TEST_CASE(equal_constraint) { - BOOST_CHECK( mock::equal( std::string( "string" ) ).c_( "string" ) ); - BOOST_CHECK( ! mock::equal( std::string( "string" ) ).c_( "not string" ) ); + BOOST_CHECK(mock::equal(std::string("string")).c_("string")); + BOOST_CHECK(!mock::equal(std::string("string")).c_("not string")); { std::string s; - BOOST_AUTO( c, mock::equal( boost::cref( s ) ) ); + BOOST_AUTO(c, mock::equal(boost::cref(s))); s = "string"; - BOOST_CHECK( c.c_( "string" ) ); + BOOST_CHECK(c.c_("string")); } #ifdef MOCK_SMART_PTR { - std::unique_ptr< int > i; - std::unique_ptr< int > j( new int( 3 ) ); - BOOST_CHECK( ! mock::equal( i ).c_( j ) ); - BOOST_CHECK( ! mock::equal( j ).c_( i ) ); - BOOST_CHECK( mock::equal( i ).c_( i ) ); - BOOST_CHECK( mock::equal( j ).c_( j ) ); + std::unique_ptr i; + std::unique_ptr j(new int(3)); + BOOST_CHECK(!mock::equal(i).c_(j)); + BOOST_CHECK(!mock::equal(j).c_(i)); + BOOST_CHECK(mock::equal(i).c_(i)); + BOOST_CHECK(mock::equal(j).c_(j)); } #endif } -BOOST_AUTO_TEST_CASE( equal_constraint_deref ) +BOOST_AUTO_TEST_CASE(equal_constraint_deref){{int i = 3; +BOOST_CHECK(mock::equal(3).c_(&i)); +BOOST_CHECK(!mock::equal(7).c_(&i)); +} { - { - int i = 3; - BOOST_CHECK( mock::equal( 3 ).c_( &i ) ); - BOOST_CHECK( ! mock::equal( 7 ).c_( &i ) ); - } - { - int* i = 0; - BOOST_CHECK( ! mock::equal( 3 ).c_( i ) ); - } + int* i = 0; + BOOST_CHECK(!mock::equal(3).c_(i)); +} #ifdef MOCK_SMART_PTR - { - std::unique_ptr< int > j( new int( 3 ) ); - BOOST_CHECK( mock::equal( 3 ).c_( j ) ); - std::unique_ptr< int > i; - BOOST_CHECK( ! mock::equal( 3 ).c_( i ) ); - } +{ + std::unique_ptr j(new int(3)); + BOOST_CHECK(mock::equal(3).c_(j)); + std::unique_ptr i; + BOOST_CHECK(!mock::equal(3).c_(i)); +} #endif // MOCK_SMART_PTR } -BOOST_AUTO_TEST_CASE( same_constraint ) +BOOST_AUTO_TEST_CASE(same_constraint){{int i = 0; +int j = 0; +BOOST_CHECK_EQUAL(i, j); +BOOST_CHECK(!mock::same(i).c_(j)); +BOOST_CHECK(mock::same(i).c_(i)); +} { - { - int i = 0; - int j = 0; - BOOST_CHECK_EQUAL( i, j ); - BOOST_CHECK( ! mock::same( i ).c_( j ) ); - BOOST_CHECK( mock::same( i ).c_( i ) ); - } - { - 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 ) ); - BOOST_CHECK( ! c.c_( j ) ); - BOOST_CHECK( c.c_( i ) ); - } + int i = 0; + int j = 0; + BOOST_CHECK_EQUAL(i, j); + mock::constraint>> c = mock::same(boost::cref(i)); + BOOST_CHECK(!c.c_(j)); + BOOST_CHECK(c.c_(i)); +} #ifdef MOCK_NULLPTR - { - std::nullptr_t p; - BOOST_CHECK( mock::same( p ).c_( p ) ); - } +{ + std::nullptr_t p; + BOOST_CHECK(mock::same(p).c_(p)); +} #endif } -BOOST_AUTO_TEST_CASE( assign_constraint ) +BOOST_AUTO_TEST_CASE(assign_constraint) { { int i = 0; - BOOST_CHECK( mock::assign( 3 ).c_( i ) ); - BOOST_CHECK_EQUAL( 3, i ); + BOOST_CHECK(mock::assign(3).c_(i)); + BOOST_CHECK_EQUAL(3, i); } { int i = 0; - BOOST_CHECK( mock::assign( 3 ).c_( &i ) ); - BOOST_CHECK_EQUAL( 3, i ); + BOOST_CHECK(mock::assign(3).c_(&i)); + BOOST_CHECK_EQUAL(3, i); } { const int* i = 0; const int j = 1; - BOOST_CHECK( mock::assign( &j ).c_( i ) ); - BOOST_CHECK_EQUAL( &j, i ); + BOOST_CHECK(mock::assign(&j).c_(i)); + BOOST_CHECK_EQUAL(&j, i); } { int* i = 0; const int j = 1; - BOOST_CHECK( ! mock::assign( j ).c_( i ) ); - BOOST_CHECK( ! i ); + BOOST_CHECK(!mock::assign(j).c_(i)); + BOOST_CHECK(!i); } { int i = 0; int j = 1; - 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 ); + mock::constraint>> c = mock::assign(boost::cref(j)); + BOOST_CHECK(c.c_(i)); + BOOST_CHECK_EQUAL(1, i); j = 3; - BOOST_CHECK( c.c_( i ) ); - BOOST_CHECK_EQUAL( 3, i ); + BOOST_CHECK(c.c_(i)); + BOOST_CHECK_EQUAL(3, i); } { int i = 0; int j = 1; - 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 ); + mock::constraint>> c = mock::assign(boost::cref(j)); + BOOST_CHECK(c.c_(&i)); + BOOST_CHECK_EQUAL(1, i); j = 3; - BOOST_CHECK( c.c_( &i ) ); - BOOST_CHECK_EQUAL( 3, i ); + BOOST_CHECK(c.c_(&i)); + BOOST_CHECK_EQUAL(3, i); } { 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 ) ); - BOOST_CHECK( c.c_( i ) ); - BOOST_CHECK_EQUAL( j, i ); + mock::constraint>> c = mock::assign(boost::cref(j)); + BOOST_CHECK(c.c_(i)); + BOOST_CHECK_EQUAL(j, i); j = 0; - BOOST_CHECK( c.c_( i ) ); - BOOST_CHECK_EQUAL( j, i ); + BOOST_CHECK(c.c_(i)); + BOOST_CHECK_EQUAL(j, i); } } -BOOST_AUTO_TEST_CASE( retrieve_constraint ) +BOOST_AUTO_TEST_CASE(retrieve_constraint) { { int i = 0; const int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, j); } { int* i = 0; int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( &j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(&j)); + BOOST_CHECK_EQUAL(i, &j); } { const int* i = 0; const int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { const int* i = 0; int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { int* i = 0; int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { const int* i = 0; const int j = 1; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { int** i = 0; int* j = 0; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { const int** i = 0; const int* j = 0; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } { int i = 0; const int j = 1; - BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) ); - BOOST_CHECK_EQUAL( i, j ); + BOOST_CHECK(mock::retrieve(boost::ref(i)).c_(j)); + BOOST_CHECK_EQUAL(i, j); } { const int* i = 0; const int j = 1; - BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(boost::ref(i)).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } #ifdef MOCK_NULLPTR { std::nullptr_t* i = 0; std::nullptr_t j; - BOOST_CHECK( mock::retrieve( i ).c_( j ) ); - BOOST_CHECK_EQUAL( i, &j ); + BOOST_CHECK(mock::retrieve(i).c_(j)); + BOOST_CHECK_EQUAL(i, &j); } #endif #ifdef MOCK_SMART_PTR { - std::unique_ptr< int > i; - std::unique_ptr< int > j( new int( 3 ) ); - BOOST_CHECK( mock::retrieve( i ).c_( boost::move( j ) ) ); - BOOST_REQUIRE( i ); - BOOST_CHECK_EQUAL( 3, *i ); - BOOST_CHECK( !j ); + std::unique_ptr i; + std::unique_ptr j(new int(3)); + BOOST_CHECK(mock::retrieve(i).c_(boost::move(j))); + BOOST_REQUIRE(i); + BOOST_CHECK_EQUAL(3, *i); + BOOST_CHECK(!j); } #endif } -namespace +namespace { +struct A +{}; +struct B { - 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 ) +BOOST_AUTO_TEST_CASE(retrieve_constraint_uses_assignment_operator) { B b; const A a = A(); - mock::retrieve( b ).c_( a ); + mock::retrieve(b).c_(a); } -BOOST_AUTO_TEST_CASE( affirm_constraint ) +BOOST_AUTO_TEST_CASE(affirm_constraint) { { int* i = 0; int j; - BOOST_CHECK( ! mock::affirm.c_( i ) ); - BOOST_CHECK( mock::affirm.c_( &j ) ); + BOOST_CHECK(!mock::affirm.c_(i)); + BOOST_CHECK(mock::affirm.c_(&j)); } { #ifdef MOCK_SMART_PTR - std::unique_ptr< int > i; - std::unique_ptr< int > j( new int( 3 ) ); - BOOST_CHECK( ! mock::affirm.c_( i ) ); - BOOST_CHECK( mock::affirm.c_( j ) ); + std::unique_ptr i; + std::unique_ptr j(new int(3)); + BOOST_CHECK(!mock::affirm.c_(i)); + BOOST_CHECK(mock::affirm.c_(j)); #endif } } -BOOST_AUTO_TEST_CASE( negate_constraint ) +BOOST_AUTO_TEST_CASE(negate_constraint) { int* i = 0; int j; - BOOST_CHECK( mock::negate.c_( i ) ); - BOOST_CHECK( ! mock::negate.c_( &j ) ); + BOOST_CHECK(mock::negate.c_(i)); + BOOST_CHECK(!mock::negate.c_(&j)); } -namespace +namespace { +bool return_true() { - bool return_true() - { - return true; - } - bool return_false() - { - return false; - } + return true; +} +bool return_false() +{ + return false; +} +} // namespace + +BOOST_AUTO_TEST_CASE(call_constraint) +{ + BOOST_CHECK(mock::call(&return_true).c_()); + BOOST_CHECK(!mock::call(&return_false).c_()); } -BOOST_AUTO_TEST_CASE( call_constraint ) +BOOST_AUTO_TEST_CASE(evaluate_constraint) { - BOOST_CHECK( mock::call( &return_true ).c_() ); - BOOST_CHECK( ! mock::call( &return_false ).c_() ); + BOOST_CHECK(mock::evaluate.c_(&return_true)); + BOOST_CHECK(!mock::evaluate.c_(&return_false)); } -BOOST_AUTO_TEST_CASE( evaluate_constraint ) +BOOST_AUTO_TEST_CASE(contain_constraint_with_const_char_ptr) { - BOOST_CHECK( mock::evaluate.c_( &return_true ) ); - BOOST_CHECK( ! mock::evaluate.c_( &return_false ) ); -} - -BOOST_AUTO_TEST_CASE( contain_constraint_with_const_char_ptr ) -{ - BOOST_CHECK( mock::contain( "string" ).c_( "this is a string" ) ); - BOOST_CHECK( mock::contain( "string" ).c_( std::string( "this is a string" ) ) ); - BOOST_CHECK( ! mock::contain( "not found" ).c_( "this is a string" ) ); - BOOST_CHECK( ! mock::contain( "not found" ).c_( std::string( "this is a string" ) ) ); + BOOST_CHECK(mock::contain("string").c_("this is a string")); + BOOST_CHECK(mock::contain("string").c_(std::string("this is a string"))); + BOOST_CHECK(!mock::contain("not found").c_("this is a string")); + 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>> 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" ) ) ); + BOOST_CHECK(c.c_("this is a string")); + BOOST_CHECK(c.c_(std::string("this is a string"))); s = "not found"; - BOOST_CHECK( ! c.c_( "this is a string" ) ); - BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) ); + BOOST_CHECK(!c.c_("this is a string")); + BOOST_CHECK(!c.c_(std::string("this is a string"))); } } -BOOST_AUTO_TEST_CASE( contain_constraint_with_strings ) +BOOST_AUTO_TEST_CASE(contain_constraint_with_strings) { - BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( "this is a string" ) ); - BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( std::string( "this is a string" ) ) ); - BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( "this is a string" ) ); - BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( std::string( "this is a string" ) ) ); + BOOST_CHECK(mock::contain(std::string("string")).c_("this is a string")); + BOOST_CHECK(mock::contain(std::string("string")).c_(std::string("this is a string"))); + BOOST_CHECK(!mock::contain(std::string("not found")).c_("this is a string")); + 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>> 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" ) ) ); + BOOST_CHECK(c.c_("this is a string")); + BOOST_CHECK(c.c_(std::string("this is a string"))); s = "not found"; - BOOST_CHECK( ! c.c_( "this is a string" ) ); - BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) ); + BOOST_CHECK(!c.c_("this is a string")); + BOOST_CHECK(!c.c_(std::string("this is a string"))); } } -namespace +namespace { +struct type_with_overloaded_address_operator { - struct type_with_overloaded_address_operator - { - void operator&() {} - void operator&() const {} - }; -} + void operator&() {} + void operator&() const {} +}; +} // namespace -BOOST_AUTO_TEST_CASE( type_with_overloaded_address_operator_can_be_used_in_constraints ) +BOOST_AUTO_TEST_CASE(type_with_overloaded_address_operator_can_be_used_in_constraints) { type_with_overloaded_address_operator t; - mock::same( t ).c_( t ); - mock::retrieve( t ).c_( t ); + mock::same(t).c_(t); + mock::retrieve(t).c_(t); type_with_overloaded_address_operator* pt; - mock::retrieve( pt ).c_( t ); + mock::retrieve(pt).c_(t); } -BOOST_AUTO_TEST_CASE( close_constraint ) +BOOST_AUTO_TEST_CASE(close_constraint) { - BOOST_CHECK( mock::close( 12.0, 0.0001 ).c_( 12 ) ); - BOOST_CHECK( ! mock::close( 12.0, 0.0001 ).c_( 13 ) ); + BOOST_CHECK(mock::close(12.0, 0.0001).c_(12)); + BOOST_CHECK(!mock::close(12.0, 0.0001).c_(13)); } -BOOST_AUTO_TEST_CASE( close_fraction_constraint ) +BOOST_AUTO_TEST_CASE(close_fraction_constraint) { - BOOST_CHECK( mock::close_fraction( 12.0, 0.0001 ).c_( 12 ) ); - BOOST_CHECK( ! mock::close_fraction( 12.0, 0.0001 ).c_( 13 ) ); + BOOST_CHECK(mock::close_fraction(12.0, 0.0001).c_(12)); + BOOST_CHECK(!mock::close_fraction(12.0, 0.0001).c_(13)); } -BOOST_AUTO_TEST_CASE( small_constraint ) +BOOST_AUTO_TEST_CASE(small_constraint) { - BOOST_CHECK( mock::small( 0.0001 ).c_( 0. ) ); - BOOST_CHECK( ! mock::small( 0.0001 ).c_( 12. ) ); + BOOST_CHECK(mock::small(0.0001).c_(0.)); + BOOST_CHECK(!mock::small(0.0001).c_(12.)); } -BOOST_AUTO_TEST_CASE( near_constraint ) +BOOST_AUTO_TEST_CASE(near_constraint) { - BOOST_CHECK( mock::near( 12.0, 0.0001 ).c_( 12 ) ); - BOOST_CHECK( ! mock::near( 12.0, 0.0001 ).c_( 13 ) ); + BOOST_CHECK(mock::near(12.0, 0.0001).c_(12)); + BOOST_CHECK(!mock::near(12.0, 0.0001).c_(13)); } diff --git a/test/test_exception.cpp b/test/test_exception.cpp index 818ddeb..198b08e 100644 --- a/test/test_exception.cpp +++ b/test/test_exception.cpp @@ -10,16 +10,14 @@ #include #include -BOOST_AUTO_TEST_CASE( a_mock_exception_is_not_an_std_exception_to_not_mess_with_user_exceptions ) +BOOST_AUTO_TEST_CASE(a_mock_exception_is_not_an_std_exception_to_not_mess_with_user_exceptions) { try { throw mock::exception(); - } - catch( std::exception& ) + } catch(std::exception&) { - BOOST_FAIL( "mock::exception must not be an std::exception" ); - } - catch( mock::exception& ) + BOOST_FAIL("mock::exception must not be an std::exception"); + } catch(mock::exception&) {} } diff --git a/test/test_integration.cpp b/test/test_integration.cpp index 8cc3557..fbaeefd 100644 --- a/test/test_integration.cpp +++ b/test/test_integration.cpp @@ -9,771 +9,688 @@ #include "mock_error.hpp" #include "undefined.hpp" #include -#include #include #include #include +#include #include -namespace +namespace { +struct my_custom_mock { - struct my_custom_mock - { - MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) - }; -} + 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 ) +BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_and_without_inheriting_from_object, mock_error_fixture) { my_custom_mock m; - MOCK_EXPECT( m.my_tag ).once(); + MOCK_EXPECT(m.my_tag).once(); m.my_method(); - CHECK_CALLS( 1 ); + CHECK_CALLS(1); } -namespace +namespace { +struct my_custom_mock_object { - struct my_custom_mock_object - { - MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) - }; -} + MOCK_METHOD_EXT(my_method, 0, void(), my_tag) +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros, mock_error_fixture) { my_custom_mock_object m; - MOCK_EXPECT( m.my_tag ).once(); + MOCK_EXPECT(m.my_tag).once(); m.my_method(); - CHECK_CALLS( 1 ); + 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 ) +BOOST_FIXTURE_TEST_CASE(basic_mock_object_usage, mock_error_fixture) { my_mock m; { - MOCK_EXPECT( m.my_tag ).once().returns( 0 ); - BOOST_CHECK_EQUAL( 0, m.my_method( 13 ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.my_tag).once().returns(0); + BOOST_CHECK_EQUAL(0, m.my_method(13)); + CHECK_CALLS(1); } mock::verify(); mock::reset(); { - MOCK_EXPECT( m.my_tag ).once().with( 42 ).returns( 7 ); - BOOST_CHECK_EQUAL( 7, m.my_method( 42 ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.my_tag).once().with(42).returns(7); + BOOST_CHECK_EQUAL(7, m.my_method(42)); + CHECK_CALLS(1); } mock::verify(); mock::reset(); { - MOCK_EXPECT( m.my_tag ).once().returns( 51 ); - BOOST_CHECK_EQUAL( 51, m.my_method( 27 ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.my_tag).once().returns(51); + BOOST_CHECK_EQUAL(51, m.my_method(27)); + CHECK_CALLS(1); } } -namespace +namespace { +class my_ambiguited_interface : boost::noncopyable { - class my_ambiguited_interface : boost::noncopyable - { - public: - virtual ~my_ambiguited_interface() - {} - virtual void my_method() = 0; - virtual void my_method( int ) = 0; - }; +public: + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_object_method_disambiguation, mock_error_fixture) { my_ambiguited_mock m; - MOCK_EXPECT( m.my_tag1 ); + MOCK_EXPECT(m.my_tag1); m.my_method(); - CHECK_ERROR( m.my_method( 12 ), "unexpected call", 1, "?.my_ambiguited_mock::my_tag_2( 12 )" ); + 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 { - class my_const_ambiguited_interface : boost::noncopyable - { - public: - virtual ~my_const_ambiguited_interface() - {} - virtual void my_method() = 0; - virtual void my_method() const = 0; - }; +public: + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_object_method_const_disambiguation, mock_error_fixture) { my_const_ambiguited_mock mock; - MOCK_EXPECT( mock.tag1 ); - BOOST_CHECK_NO_THROW( mock.my_method() ); + MOCK_EXPECT(mock.tag1); + BOOST_CHECK_NO_THROW(mock.my_method()); const my_const_ambiguited_mock const_mock; - CHECK_ERROR( const_mock.my_method(), "unexpected call", 1, "?.my_const_ambiguited_mock::tag_2()" ); + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_object_method_with_declared_but_not_defined_parameter_is_valid, mock_error_fixture) { my_undefined_mock mock; - MOCK_EXPECT( mock.t ); + MOCK_EXPECT(mock.t); } -namespace -{ - MOCK_FUNCTOR( gf, int( float, const std::string& ) ); +namespace { +MOCK_FUNCTOR(gf, int(float, const std::string&)); } -BOOST_FIXTURE_TEST_CASE( mock_functor_in_namespace_is_supported, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_in_namespace_is_supported, mock_error_fixture) { - boost::function< int( float, const std::string& ) > func; - MOCK_EXPECT( gf ).once().with( 3, "op" ).returns( 42 ); + boost::function func; + MOCK_EXPECT(gf).once().with(3, "op").returns(42); func = gf; - BOOST_CHECK_EQUAL( 42, func( 3, "op" ) ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(42, func(3, "op")); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mock_functor_in_function_is_supported, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_in_function_is_supported, mock_error_fixture) { - boost::function< int( float, const std::string& ) > func; + boost::function func; { - MOCK_FUNCTOR( f, int( float, const std::string& ) ); - MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 ); + MOCK_FUNCTOR(f, int(float, const std::string&)); + MOCK_EXPECT(f).once().with(3, "op").returns(42); func = f; } - BOOST_CHECK_EQUAL( 42, func( 3, "op" ) ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(42, func(3, "op")); + CHECK_CALLS(1); } -namespace +namespace { +struct functor_fixture : mock_error_fixture { - struct functor_fixture : mock_error_fixture - { - MOCK_FUNCTOR( f, int( float, const std::string& ) ); - }; + MOCK_FUNCTOR(f, int(float, const std::string&)); +}; +} // namespace + +BOOST_FIXTURE_TEST_CASE(mock_functor_in_fixture_is_supported, functor_fixture) +{ + MOCK_EXPECT(f).once().with(3, "op").returns(42); + BOOST_CHECK_EQUAL(42, f(3.f, "op")); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mock_functor_in_fixture_is_supported, functor_fixture ) +namespace { +template +struct my_template_mock { - MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 ); - BOOST_CHECK_EQUAL( 42, f( 3.f, "op" ) ); - CHECK_CALLS( 1 ); + MOCK_METHOD_EXT(my_method, 0, void(), my_tag) + 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) +{ + my_template_mock m; + MOCK_EXPECT(m.my_tpl_tag).with(3, ""); + m.my_method(3, ""); + BOOST_CHECK(MOCK_VERIFY(m.my_tpl_tag)); + CHECK_CALLS(1); } -namespace +namespace { +template +struct my_template_base_class { - template< typename T > - struct my_template_mock - { - MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) - 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 ) - }; + virtual ~my_template_base_class() {} + virtual void my_method(T) = 0; + virtual void my_other_method() = 0; +}; +template +MOCK_BASE_CLASS(my_template_base_class_mock, + my_template_base_class){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) +{ + my_template_base_class_mock m; + MOCK_EXPECT(m.my_method).once().with(3); + m.my_method(3); + BOOST_CHECK(MOCK_VERIFY(m.my_method)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_method_is_supported, mock_error_fixture ) +namespace { +class my_observer : boost::noncopyable { - my_template_mock< int > m; - MOCK_EXPECT( m.my_tpl_tag ).with( 3, "" ); - m.my_method( 3, "" ); - BOOST_CHECK( MOCK_VERIFY( m.my_tpl_tag ) ); - CHECK_CALLS( 1 ); -} +public: + virtual ~my_observer() {} + virtual void notify(int value) = 0; +}; -namespace +class my_manager : boost::noncopyable { - template< typename T > - struct 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 ) - }; -} +public: + virtual ~my_manager() {} + virtual my_observer& get_observer() const = 0; +}; -BOOST_FIXTURE_TEST_CASE( mocking_a_template_base_class_method_is_supported, mock_error_fixture ) +class my_subject : boost::noncopyable { - my_template_base_class_mock< int > m; - MOCK_EXPECT( m.my_method ).once().with( 3 ); - m.my_method( 3 ); - BOOST_CHECK( MOCK_VERIFY( m.my_method ) ); - CHECK_CALLS( 1 ); -} +public: + explicit my_subject(my_manager& f) : o_(f.get_observer()), value_(0) {} + void increment() { o_.notify(++value_); } -namespace +private: + my_observer& o_; + int value_; +}; + +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)}; + +struct fixture : mock_error_fixture { - class my_observer : boost::noncopyable - { - public: - virtual ~my_observer() - {} - virtual void notify( int value ) = 0; - }; + my_mock_manager manager; + my_mock_observer observer; +}; +} // namespace - class my_manager : boost::noncopyable - { - public: - 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_ ); - } - private: - my_observer& o_; - int value_; - }; - - 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 ) - }; - - struct fixture : mock_error_fixture - { - my_mock_manager manager; - my_mock_observer observer; - }; -} - -BOOST_FIXTURE_TEST_CASE( basic_mock_object_collaboration_usage, fixture ) +BOOST_FIXTURE_TEST_CASE(basic_mock_object_collaboration_usage, fixture) { - MOCK_EXPECT( manager.get_observer ).returns( boost::ref( observer ) ); - my_subject subject( manager ); - MOCK_EXPECT( observer.notify ).once().with( 1 ); + MOCK_EXPECT(manager.get_observer).returns(boost::ref(observer)); + my_subject subject(manager); + MOCK_EXPECT(observer.notify).once().with(1); subject.increment(); - MOCK_EXPECT( observer.notify ).once().with( 2 ); + MOCK_EXPECT(observer.notify).once().with(2); subject.increment(); - MOCK_EXPECT( observer.notify ).once().with( 3 ); + MOCK_EXPECT(observer.notify).once().with(3); subject.increment(); - CHECK_CALLS( 4 ); + CHECK_CALLS(4); } -namespace +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) { - MOCK_CLASS( my_constructed_class ) - { - MOCK_CONSTRUCTOR( my_constructed_class, 2, ( int, const std::string& ), constructor ) - }; + MOCK_EXPECT(my_constructed_class::constructor).with(42, "some text").once(); + my_constructed_class(42, "some text"); + BOOST_CHECK(MOCK_VERIFY(my_constructed_class::constructor)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mocking_a_constructor, mock_error_fixture ) +namespace { +template +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) { - MOCK_EXPECT( my_constructed_class::constructor ).with( 42, "some text" ).once(); - my_constructed_class( 42, "some text" ); - BOOST_CHECK( MOCK_VERIFY( my_constructed_class::constructor ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(my_constructed_template_class::constructor).with(42, "some text").once(); + my_constructed_template_class(42, "some text"); + BOOST_CHECK(MOCK_VERIFY(my_constructed_template_class::constructor)); + CHECK_CALLS(1); } -namespace -{ - template< typename T > - MOCK_CLASS( my_constructed_template_class ) - { - MOCK_CONSTRUCTOR_TPL( my_constructed_template_class, 2, ( T, const std::string& ), constructor ) - }; +namespace { +MOCK_CLASS(my_destroyed_class){MOCK_DESTRUCTOR(~my_destroyed_class, destructor)}; } -BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_constructor, mock_error_fixture ) -{ - MOCK_EXPECT( my_constructed_template_class< int >::constructor ).with( 42, "some text" ).once(); - my_constructed_template_class< int >( 42, "some text" ); - BOOST_CHECK( MOCK_VERIFY( my_constructed_template_class< int >::constructor ) ); - CHECK_CALLS( 1 ); -} - -namespace -{ - MOCK_CLASS( my_destroyed_class ) - { - MOCK_DESTRUCTOR( ~my_destroyed_class, destructor ) - }; -} - -BOOST_FIXTURE_TEST_CASE( mocking_a_destructor, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mocking_a_destructor, mock_error_fixture) { { my_destroyed_class c; - MOCK_EXPECT( c.destructor ).once(); + MOCK_EXPECT(c.destructor).once(); } - CHECK_CALLS( 1 ); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture) { CHECK_ERROR( - try - { - my_destroyed_class c; - throw std::runtime_error( "should not crash" ); - } - catch( std::runtime_error& ) - { - }, - "unexpected call", 0, "?.my_destroyed_class::destructor()" ); + try { + my_destroyed_class c; + throw std::runtime_error("should not crash"); + } catch(std::runtime_error&){}, + "unexpected call", 0, "?.my_destroyed_class::destructor()"); } -BOOST_FIXTURE_TEST_CASE( failed_sequence_in_mocked_destructor_does_not_throw, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(failed_sequence_in_mocked_destructor_does_not_throw, mock_error_fixture) { mock::sequence s; my_custom_mock m; CHECK_ERROR( - { - my_destroyed_class c; - MOCK_EXPECT( c.destructor ).once().in( s ); - MOCK_EXPECT( m.my_tag ).once().in( s ); - m.my_method(); - }, - "sequence failed", 1, "c.my_destroyed_class::destructor()\n. once()" ); + { + my_destroyed_class c; + MOCK_EXPECT(c.destructor).once().in(s); + MOCK_EXPECT(m.my_tag).once().in(s); + m.my_method(); + }, + "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(), tag)}; } -BOOST_FIXTURE_TEST_CASE( boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture) { boost_optional b; my_mock_observer o; - MOCK_EXPECT( b.tag ).once().returns( boost::ref( o ) ); + MOCK_EXPECT(b.tag).once().returns(boost::ref(o)); b.method(); - CHECK_CALLS( 1 ); + CHECK_CALLS(1); } -namespace -{ - bool serialized = false; +namespace { +bool serialized = false; - struct custom_argument +struct custom_argument +{ + friend std::ostream& operator<<(std::ostream& s, custom_argument) { - friend std::ostream& operator<<( std::ostream& s, custom_argument ) - { - serialized = true; - return s; - } - }; - struct custom_constraint + serialized = true; + return s; + } +}; +struct custom_constraint +{ + template + friend bool operator==(Actual, custom_constraint) { - template< typename Actual > - friend bool operator==( Actual, custom_constraint ) - { - return true; - } - friend std::ostream& operator<<( std::ostream& s, custom_constraint ) - { - serialized = true; - return s; - } - }; -} - -BOOST_FIXTURE_TEST_CASE( constraints_and_arguments_are_serialized_lazily, mock_error_fixture ) -{ - MOCK_FUNCTOR( f, void( const custom_argument& ) ); - MOCK_EXPECT( f ).with( custom_constraint() ); - f( custom_argument() ); - BOOST_CHECK( ! serialized ); - CHECK_CALLS( 1 ); -} - -namespace -{ - struct custom_constraint_with_non_const_operator + return true; + } + friend std::ostream& operator<<(std::ostream& s, custom_constraint) { - template< typename Actual > - bool operator()( Actual actual ) - { - return actual == 42; - } - }; + serialized = true; + return s; + } +}; +} // namespace + +BOOST_FIXTURE_TEST_CASE(constraints_and_arguments_are_serialized_lazily, mock_error_fixture) +{ + MOCK_FUNCTOR(f, void(const custom_argument&)); + MOCK_EXPECT(f).with(custom_constraint()); + f(custom_argument()); + BOOST_CHECK(!serialized); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( custom_constraint_function_operator_does_not_need_to_be_const, mock_error_fixture ) +namespace { +struct custom_constraint_with_non_const_operator { - MOCK_FUNCTOR( f, void( float ) ); - MOCK_EXPECT( f ).with( mock::constraint< custom_constraint_with_non_const_operator >( custom_constraint_with_non_const_operator() ) ); - f( 42 ); - CHECK_CALLS( 1 ); + template + bool operator()(Actual actual) + { + 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())); + f(42); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( boost_reference_wrapper_is_supported_in_value_constraint, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(boost_reference_wrapper_is_supported_in_value_constraint, mock_error_fixture) { - MOCK_FUNCTOR( f, void( const std::string& ) ); + MOCK_FUNCTOR(f, void(const std::string&)); std::string s; - MOCK_EXPECT( f ).once().with( boost::cref( s ) ); + MOCK_EXPECT(f).once().with(boost::cref(s)); s = "string"; - f( "string" ); - CHECK_CALLS( 1 ); + f("string"); + CHECK_CALLS(1); } -namespace -{ - template< typename T > - void nothing( T ) - {} +namespace { +template +void nothing(T) +{} - struct member_pointer_mock_class - { - MOCK_CONST_METHOD_EXT( my_method, 0, void(), my_method ) - }; +struct member_pointer_mock_class +{ + 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); } -BOOST_FIXTURE_TEST_CASE( member_pointer_on_mock_method_is_valid, mock_error_fixture ) -{ - nothing( &member_pointer_mock_class::my_method ); +namespace { +MOCK_FUNCTION(free_function, 1, void(int), free_function) } -namespace +BOOST_FIXTURE_TEST_CASE(a_free_function_can_be_mocked, mock_error_fixture) { - MOCK_FUNCTION( free_function, 1, void( int ), free_function ) + MOCK_EXPECT(free_function).once(); + 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); } -BOOST_FIXTURE_TEST_CASE( a_free_function_can_be_mocked, mock_error_fixture ) +namespace { +struct some_class : mock::object { - MOCK_EXPECT( free_function ).once(); - 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 ); + 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 )"); + some_class::some_static_method(42); + CHECK_CALLS(1); + BOOST_CHECK(MOCK_VERIFY(some_class::some_static_method)); + MOCK_RESET(some_class::some_static_method); } -namespace +BOOST_FIXTURE_TEST_CASE(a_static_method_is_not_reset_when_resetting_an_instance_of_the_class, mock_error_fixture) { - struct some_class : mock::object - { - MOCK_STATIC_METHOD( some_static_method, 1, void( int ), some_static_method ) - }; -} - -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 )" ); - some_class::some_static_method( 42 ); - CHECK_CALLS( 1 ); - BOOST_CHECK( MOCK_VERIFY( some_class::some_static_method ) ); - MOCK_RESET( some_class::some_static_method ); -} - -BOOST_FIXTURE_TEST_CASE( a_static_method_is_not_reset_when_resetting_an_instance_of_the_class, mock_error_fixture ) -{ - MOCK_EXPECT( some_class::some_static_method ).once(); + 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 )" ); - MOCK_RESET( some_class::some_static_method ); + 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 )"); + MOCK_RESET(some_class::some_static_method); } -namespace +namespace { +template +struct some_template_class { - template< typename T > - struct some_template_class - { - MOCK_STATIC_METHOD_TPL( some_static_method, 1, void( T ), some_static_method ) - }; + 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::some_static_method).once(); + CHECK_ERROR(BOOST_CHECK(!MOCK_VERIFY(some_template_class::some_static_method)), "verification failed", 0, + "some_template_class< int >::some_static_method\n. once().with( any )"); + some_template_class::some_static_method(42); + BOOST_CHECK(mock::verify()); + BOOST_CHECK(MOCK_VERIFY(some_template_class::some_static_method)); + MOCK_RESET(some_template_class::some_static_method); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( a_static_method_in_a_template_class_can_be_mocked, mock_error_fixture ) +namespace { +MOCK_CLASS(mock_class) { - 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 )" ); - some_template_class< int >::some_static_method( 42 ); - BOOST_CHECK( mock::verify() ); - BOOST_CHECK( MOCK_VERIFY( some_template_class< int >::some_static_method ) ); - MOCK_RESET( some_template_class< int >::some_static_method ); - CHECK_CALLS( 1 ); -} + MOCK_METHOD_EXT(m, 0, void(), t); +}; +} // namespace -namespace +BOOST_FIXTURE_TEST_CASE(resetting_referenced_mock_class_does_not_crash, mock_error_fixture) { - MOCK_CLASS( mock_class ) - { - MOCK_METHOD_EXT( m, 0, void(), t ); - }; -} - -BOOST_FIXTURE_TEST_CASE( resetting_referenced_mock_class_does_not_crash, mock_error_fixture ) -{ - MOCK_FUNCTOR( f, mock_class() ); + MOCK_FUNCTOR(f, mock_class()); { mock_class c; - MOCK_EXPECT( f ).returns( c ); - MOCK_EXPECT( c.t ); + MOCK_EXPECT(f).returns(c); + MOCK_EXPECT(c.t); } mock::reset(); } -namespace +namespace { +MOCK_CLASS(mock_class2) { - MOCK_CLASS( mock_class2 ) - { - MOCK_METHOD_EXT( m, 0, mock_class2(), t ); - }; -} + MOCK_METHOD_EXT(m, 0, mock_class2(), t); +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture) { { mock_class2 c; - MOCK_EXPECT( c.t ).returns( c ); + MOCK_EXPECT(c.t).returns(c); } mock::reset(); } -namespace -{ - template< typename T1, typename T2 > - struct my_base - {}; - MOCK_BASE_CLASS( my_comma_mock, my_base< int BOOST_PP_COMMA() int > ) - {}; -} +namespace { +template +struct my_base +{}; +MOCK_BASE_CLASS(my_comma_mock, my_base){}; +} // namespace #ifdef MOCK_THREAD_SAFE -#include +# include -namespace +namespace { +void create_class() { - void create_class() + my_mock m; + MOCK_EXPECT(m.my_tag).once().with(3).returns(42); + try { - my_mock m; - MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 ); - try - { - m.my_method( 3 ); - } - catch( ... ) - {} - } + m.my_method(3); + } catch(...) + {} } +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_class_creation_is_thread_safe, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_class_creation_is_thread_safe, mock_error_fixture) { boost::thread_group group; - for( int i = 0; i < 100; ++i ) - group.create_thread( &create_class ); + for(int i = 0; i < 100; ++i) + group.create_thread(&create_class); group.join_all(); - CHECK_CALLS( 100 ); + CHECK_CALLS(100); } -namespace +namespace { +void create_functor(int i) { - void create_functor( int i ) + mock::detail::functor f; + boost::this_thread::sleep(boost::posix_time::milliseconds(100)); + mock::detail::functor f_mock; + MOCK_EXPECT(f).once().with(i); + try { - mock::detail::functor< void( int ) > f; - boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) ); - mock::detail::functor< void( int ) > f_mock; - MOCK_EXPECT( f ).once().with( i ); - try - { - f( i ); - } - catch( ... ) - {} - } + f(i); + } catch(...) + {} } +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_functor_creation_is_thread_safe, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_creation_is_thread_safe, mock_error_fixture) { boost::thread_group group; - for( int i = 0; i < 100; ++i ) - group.create_thread( boost::bind( &create_functor, i ) ); + for(int i = 0; i < 100; ++i) + group.create_thread(boost::bind(&create_functor, i)); group.join_all(); - CHECK_CALLS( 100 ); + CHECK_CALLS(100); } -namespace +namespace { +void iterate(my_mock& m) { - void iterate( my_mock& m ) - { - MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 ); - BOOST_CHECK_EQUAL( 42, m.my_method( 3 ) ); - } + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_class_is_thread_safe, mock_error_fixture) { my_mock m; boost::thread_group group; - for( int i = 0; i < 100; ++i ) - group.create_thread( boost::bind( &iterate, boost::ref( m ) ) ); + for(int i = 0; i < 100; ++i) + group.create_thread(boost::bind(&iterate, boost::ref(m))); group.join_all(); - CHECK_CALLS( 100 ); + CHECK_CALLS(100); } #endif // MOCK_THREAD_SAFE -namespace +namespace { +MOCK_CLASS(my_multi_mock) { - MOCK_CLASS( my_multi_mock ) - { - MOCK_METHOD_EXT( m1, 1, void( int ), m1 ); - MOCK_METHOD_EXT( m2, 2, void( int, int ), m2 ); - }; -} + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_method_accepts_multi_constraint, mock_error_fixture) { my_multi_mock m; - MOCK_FUNCTOR( f, bool( int, int ) ); - MOCK_EXPECT( m.m2 ).once().with( f ); - MOCK_EXPECT( f ).once().with( 1, 2 ).returns( true ); - m.m2( 1, 2 ); - CHECK_CALLS( 2 ); + MOCK_FUNCTOR(f, bool(int, int)); + MOCK_EXPECT(m.m2).once().with(f); + MOCK_EXPECT(f).once().with(1, 2).returns(true); + m.m2(1, 2); + CHECK_CALLS(2); } -namespace +namespace { +struct my_polymorphic_constraint { - struct my_polymorphic_constraint + template + bool operator()(T1, T2) const { - template< typename T1, typename T2 > - bool operator()( T1, T2 ) const - { - return true; - } - }; -} + return true; + } +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture) { my_multi_mock m; - MOCK_EXPECT( m.m2 ).once().with( my_polymorphic_constraint() ); - m.m2( 1, 2 ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.m2).once().with(my_polymorphic_constraint()); + m.m2(1, 2); + CHECK_CALLS(1); } #ifdef MOCK_SMART_PTR -BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_action, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_action, mock_error_fixture) { - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - std::unique_ptr< int > p; - MOCK_EXPECT( f ).once().calls( - []( std::unique_ptr< int > ) - { - } ); - f( std::unique_ptr< int >( new int( 7 ) ) ); - CHECK_CALLS( 1 ); + MOCK_FUNCTOR(f, void(std::unique_ptr)); + std::unique_ptr p; + MOCK_EXPECT(f).once().calls([](std::unique_ptr) {}); + f(std::unique_ptr(new int(7))); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_equal_constraint, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_equal_constraint, mock_error_fixture) { { - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - MOCK_EXPECT( f ).once().with( mock::equal( 7 ) ); - f( std::unique_ptr< int >( new int( 7 ) ) ); - CHECK_CALLS( 1 ); + MOCK_FUNCTOR(f, void(std::unique_ptr)); + MOCK_EXPECT(f).once().with(mock::equal(7)); + f(std::unique_ptr(new int(7))); + CHECK_CALLS(1); } { - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - MOCK_EXPECT( f ).once().with( 7 ); - f( std::unique_ptr< int >( new int( 7 ) ) ); - CHECK_CALLS( 1 ); + MOCK_FUNCTOR(f, void(std::unique_ptr)); + MOCK_EXPECT(f).once().with(7); + f(std::unique_ptr(new int(7))); + CHECK_CALLS(1); } } -BOOST_FIXTURE_TEST_CASE( std_unique_ptr_argument_is_supported_in_retrieve_constraint, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(std_unique_ptr_argument_is_supported_in_retrieve_constraint, mock_error_fixture) { { - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - MOCK_EXPECT( f ).once().with( nullptr ); - f( 0 ); - CHECK_CALLS( 1 ); + MOCK_FUNCTOR(f, void(std::unique_ptr)); + MOCK_EXPECT(f).once().with(nullptr); + f(0); + CHECK_CALLS(1); } { - std::unique_ptr< int > i; - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - MOCK_EXPECT( f ).once().with( mock::retrieve( i ) ); - std::unique_ptr< int > j( new int( 7 ) ); - f( std::move( j ) ); - BOOST_CHECK( !j ); - BOOST_REQUIRE( i ); - BOOST_CHECK_EQUAL( 7, *i ); - CHECK_CALLS( 1 ); + std::unique_ptr i; + MOCK_FUNCTOR(f, void(std::unique_ptr)); + MOCK_EXPECT(f).once().with(mock::retrieve(i)); + std::unique_ptr j(new int(7)); + f(std::move(j)); + BOOST_CHECK(!j); + BOOST_REQUIRE(i); + BOOST_CHECK_EQUAL(7, *i); + CHECK_CALLS(1); } { - std::unique_ptr< int > i; - MOCK_FUNCTOR( f, void( std::unique_ptr< int > ) ); - MOCK_EXPECT( f ).once().with( nullptr ); - MOCK_EXPECT( f ).once().with( mock::retrieve( i ) ); - f( 0 ); - std::unique_ptr< int > j( new int( 7 ) ); - f( std::move( j ) ); - BOOST_CHECK( !j ); - BOOST_REQUIRE( i ); - BOOST_CHECK_EQUAL( 7, *i ); - CHECK_CALLS( 2 ); + std::unique_ptr i; + MOCK_FUNCTOR(f, void(std::unique_ptr)); + MOCK_EXPECT(f).once().with(nullptr); + MOCK_EXPECT(f).once().with(mock::retrieve(i)); + f(0); + std::unique_ptr j(new int(7)); + f(std::move(j)); + BOOST_CHECK(!j); + BOOST_REQUIRE(i); + BOOST_CHECK_EQUAL(7, *i); + CHECK_CALLS(2); } } struct my_unique_ptr_class { - MOCK_CONSTRUCTOR( my_unique_ptr_class, 1, ( std::unique_ptr< int > ), constructor ) - MOCK_METHOD_EXT( m, 1, void( std::unique_ptr< int > ), m ) - MOCK_STATIC_METHOD( ms, 1, void( std::unique_ptr< int > ), ms ) + MOCK_CONSTRUCTOR(my_unique_ptr_class, 1, (std::unique_ptr), constructor) + MOCK_METHOD_EXT(m, 1, void(std::unique_ptr), m) + MOCK_STATIC_METHOD(ms, 1, void(std::unique_ptr), ms) }; #endif diff --git a/test/test_log.cpp b/test/test_log.cpp index 728eb20..cb441d4 100644 --- a/test/test_log.cpp +++ b/test/test_log.cpp @@ -7,678 +7,649 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include #include -#include -#include #include #include +#include +#include +#include #ifdef BOOST_MSVC -#pragma warning( push, 0 ) +# pragma warning(push, 0) #endif -#include #include +#include #ifdef BOOST_MSVC -#pragma warning( pop ) +# pragma warning(pop) #endif #ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC -#include -#include +# include +# include #endif #include -#include #include #include #include #include +#include -namespace +namespace { +template +std::string to_string(const T& t) { - template< typename T > - std::string to_string( const T& t ) - { - std::stringstream s; - s << mock::format( t ); - return s.str(); - } - template< typename T > - std::string to_string( T* t ) - { - std::stringstream s; - s << mock::format( t ); - return s.str(); - } + std::stringstream s; + s << mock::format(t); + return s.str(); } +template +std::string to_string(T* t) +{ + std::stringstream s; + s << mock::format(t); + return s.str(); +} +} // namespace -BOOST_AUTO_TEST_CASE( pointer_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(pointer_yields_its_value_when_serialized) { { int i = 0; - BOOST_CHECK_NE( "?", to_string( &i ) ); - BOOST_CHECK_EQUAL( boost::lexical_cast< std::string >( &i ), to_string( &i ) ); + BOOST_CHECK_NE("?", to_string(&i)); + BOOST_CHECK_EQUAL(boost::lexical_cast(&i), to_string(&i)); } { const int i = 0; - BOOST_CHECK_NE( "?", to_string( &i ) ); - BOOST_CHECK_EQUAL( boost::lexical_cast< std::string >( &i ), to_string( &i ) ); + BOOST_CHECK_NE("?", to_string(&i)); + BOOST_CHECK_EQUAL(boost::lexical_cast(&i), to_string(&i)); } } -BOOST_AUTO_TEST_CASE( base_type_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(base_type_yields_its_value_when_serialized) { - BOOST_CHECK_EQUAL( "42", to_string( 42 ) ); + BOOST_CHECK_EQUAL("42", to_string(42)); } -BOOST_AUTO_TEST_CASE( booleans_are_serialized_as_bool_alpha ) +BOOST_AUTO_TEST_CASE(booleans_are_serialized_as_bool_alpha) { - BOOST_CHECK_EQUAL( "true", to_string( true ) ); - BOOST_CHECK_EQUAL( "false", to_string( false ) ); + BOOST_CHECK_EQUAL("true", to_string(true)); + BOOST_CHECK_EQUAL("false", to_string(false)); } -BOOST_AUTO_TEST_CASE( strings_are_serialized_with_double_quotes ) +BOOST_AUTO_TEST_CASE(strings_are_serialized_with_double_quotes) { - BOOST_CHECK_EQUAL( "\"string\"", to_string( "string" ) ); - BOOST_CHECK_EQUAL( "\"string\"", to_string( std::string( "string" ) ) ); + BOOST_CHECK_EQUAL("\"string\"", to_string("string")); + 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) { - struct non_serializable - {}; + BOOST_CHECK_EQUAL("?", to_string(non_serializable())); } -BOOST_AUTO_TEST_CASE( non_serializable_type_yields_a_question_mark_when_serialized ) +namespace { +struct serializable +{}; +std::ostream& operator<<(std::ostream& s, const serializable&) { - BOOST_CHECK_EQUAL( "?", to_string( non_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&) { - struct serializable - {}; - std::ostream& operator<<( std::ostream& s, const serializable& ) - { - return s << "serializable"; - } + BOOST_FAIL("should not have been called"); + return s; +} +mock::stream& operator<<(mock::stream& s, const streamable&) +{ + return s << "streamable"; +} +} // namespace + +BOOST_AUTO_TEST_CASE(streamable_type_yields_its_value_when_serialized) +{ + BOOST_CHECK_EQUAL("streamable", to_string(streamable())); } -BOOST_AUTO_TEST_CASE( serializable_type_yields_its_value_when_serialized ) +namespace { +struct mock_streamable +{}; +BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const mock_streamable&) { - BOOST_CHECK_EQUAL( "serializable", to_string( serializable() ) ); + BOOST_FAIL("should not have been called"); + return s; +} +} // namespace +namespace mock { +stream& operator<<(stream& s, const mock_streamable&) +{ + return s << "mock_streamable"; +} +} // namespace mock + +BOOST_AUTO_TEST_CASE(mock_streamable_type_yields_its_value_when_serialized) +{ + BOOST_CHECK_EQUAL("mock_streamable", to_string(mock_streamable())); } -namespace -{ - struct streamable - {}; - BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<( std::ostream& s, const streamable& ) - { - BOOST_FAIL( "should not have been called" ); - return s; - } - mock::stream& operator<<( mock::stream& s, const streamable& ) - { - return s << "streamable"; - } -} +namespace { +struct derived_from_serializable : serializable +{}; +} // namespace -BOOST_AUTO_TEST_CASE( streamable_type_yields_its_value_when_serialized ) -{ - BOOST_CHECK_EQUAL( "streamable", to_string( streamable() ) ); -} - -namespace -{ - struct mock_streamable - {}; - BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<( std::ostream& s, const mock_streamable& ) - { - BOOST_FAIL( "should not have been called" ); - return s; - } -} -namespace mock -{ - stream& operator<<( stream& s, const mock_streamable& ) - { - return s << "mock_streamable"; - } -} // mock - -BOOST_AUTO_TEST_CASE( mock_streamable_type_yields_its_value_when_serialized ) -{ - BOOST_CHECK_EQUAL( "mock_streamable", to_string( mock_streamable() ) ); -} - -namespace -{ - struct derived_from_serializable : serializable - {}; -} - -BOOST_AUTO_TEST_CASE( type_derived_from_serializable_yields_a_question_mark_when_serialized ) +BOOST_AUTO_TEST_CASE(type_derived_from_serializable_yields_a_question_mark_when_serialized) { #ifdef MOCK_USE_CONVERSIONS - BOOST_CHECK_EQUAL( "serializable", to_string( derived_from_serializable() ) ); + BOOST_CHECK_EQUAL("serializable", to_string(derived_from_serializable())); #else - BOOST_CHECK_EQUAL( "?", to_string( derived_from_serializable() ) ); + BOOST_CHECK_EQUAL("?", to_string(derived_from_serializable())); #endif } -namespace -{ - struct derived_from_streamable : streamable - {}; -} +namespace { +struct derived_from_streamable : streamable +{}; +} // namespace -BOOST_AUTO_TEST_CASE( type_derived_from_streamable_yields_a_question_mark_when_serialized ) +BOOST_AUTO_TEST_CASE(type_derived_from_streamable_yields_a_question_mark_when_serialized) { #ifdef MOCK_USE_CONVERSIONS - BOOST_CHECK_EQUAL( "streamable", to_string( derived_from_streamable() ) ); + BOOST_CHECK_EQUAL("streamable", to_string(derived_from_streamable())); #else - BOOST_CHECK_EQUAL( "?", to_string( derived_from_streamable() ) ); + BOOST_CHECK_EQUAL("?", to_string(derived_from_streamable())); #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 { - struct convertible_to_base - { - operator int() const; - }; + 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())); } -BOOST_AUTO_TEST_CASE( type_convertible_to_base_yields_a_question_mark_when_serialized ) +namespace { +struct convertible_to_serializable { - BOOST_CHECK_EQUAL( "?", to_string( convertible_to_base() ) ); + 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 { - struct convertible_to_serializable - { - operator serializable() const; - }; + 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())); } -BOOST_AUTO_TEST_CASE( type_convertible_to_serializable_yields_a_question_mark_when_serialized ) +namespace { +struct ambiguous_convertible { - BOOST_CHECK_EQUAL( "?", to_string( convertible_to_serializable() ) ); + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template + 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 { - struct convertible_to_streamable - { - operator streamable() const; - }; + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template + 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_to_streamable_yields_a_question_mark_when_serialized ) +BOOST_AUTO_TEST_CASE(type_convertible_serializable_yields_its_value_when_serialized) { - BOOST_CHECK_EQUAL( "?", to_string( convertible_to_streamable() ) ); -} - -namespace -{ - struct ambiguous_convertible - { - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() const; - template< typename T > operator T() const; - }; -} - -BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_yields_a_question_mark_when_serialized ) -{ - BOOST_CHECK_EQUAL( "?", to_string( ambiguous_convertible() ) ); -} - -namespace -{ - struct ambiguous_convertible_serializable - { - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() const; - template< typename T > operator T() const; - }; - std::ostream& operator<<( std::ostream& s, const ambiguous_convertible_serializable& ) - { - return s << "ambiguous_convertible_serializable"; - } -} - -BOOST_AUTO_TEST_CASE( type_convertible_serializable_yields_its_value_when_serialized ) -{ - BOOST_CHECK_EQUAL( "ambiguous_convertible_serializable", to_string( ambiguous_convertible_serializable() ) ); + BOOST_CHECK_EQUAL("ambiguous_convertible_serializable", to_string(ambiguous_convertible_serializable())); } #endif // MOCK_USE_CONVERSIONS -namespace +namespace { +struct ambiguous_convertible_streamable { - struct ambiguous_convertible_streamable - { - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() const; - template< typename T > operator T() const; - }; - BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<( std::ostream& s, const ambiguous_convertible_streamable& ) - { - BOOST_FAIL( "should not have been called" ); - return s; - } - mock::stream& operator<<( mock::stream& s, const ambiguous_convertible_streamable& ) - { - return s << "ambiguous_convertible_streamable"; - } + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template + operator T() const; +}; +BOOST_ATTRIBUTE_UNUSED std::ostream& operator<<(std::ostream& s, const ambiguous_convertible_streamable&) +{ + BOOST_FAIL("should not have been called"); + return s; +} +mock::stream& operator<<(mock::stream& s, const ambiguous_convertible_streamable&) +{ + 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())); } -BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_streamable_yields_its_value_when_serialized ) +namespace { +struct ambiguous_convertible_mock_streamable { - BOOST_CHECK_EQUAL( "ambiguous_convertible_streamable", to_string( ambiguous_convertible_streamable() ) ); + operator float() const; + operator int() const; + operator serializable() const; + operator streamable() const; + template + 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 +namespace mock { +stream& operator<<(stream& s, const ambiguous_convertible_mock_streamable&) +{ + return s << "ambiguous_convertible_mock_streamable"; +} +} // 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 +struct template_serializable +{}; +template +std::ostream& operator<<(std::ostream& s, const template_serializable&) { - struct ambiguous_convertible_mock_streamable - { - operator float() const; - operator int() const; - operator serializable() const; - operator streamable() 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; - } + return s << "template_serializable"; } -namespace mock -{ - stream& operator<<( stream& s, const ambiguous_convertible_mock_streamable& ) - { - return s << "ambiguous_convertible_mock_streamable"; - } -} // mock +} // namespace -BOOST_AUTO_TEST_CASE( type_ambiguous_convertible_mock_streamable_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(template_type_serializable_yields_its_value_when_serialized) { - BOOST_CHECK_EQUAL( "ambiguous_convertible_mock_streamable", to_string( ambiguous_convertible_mock_streamable() ) ); + BOOST_CHECK_EQUAL("template_serializable", to_string(template_serializable())); } -namespace +namespace { +template +struct template_streamable +{}; +template +std::ostream& operator<<(std::ostream& s, const template_streamable&) { - template< typename T > - struct template_serializable - {}; - template< typename T > - std::ostream& operator<<( std::ostream& s, const template_serializable< T >& ) - { - return s << "template_serializable"; - } + BOOST_FAIL("should not have been called"); + return s; +} +template +mock::stream& operator<<(mock::stream& s, const template_streamable&) +{ + 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())); } -BOOST_AUTO_TEST_CASE( template_type_serializable_yields_its_value_when_serialized ) +namespace { +template +struct template_mock_streamable +{}; +template +std::ostream& operator<<(std::ostream& s, const template_mock_streamable&) { - BOOST_CHECK_EQUAL( "template_serializable", to_string( template_serializable< int >() ) ); + BOOST_FAIL("should not have been called"); + return s; +} +} // namespace +namespace mock { +template +stream& operator<<(stream& s, const template_mock_streamable&) +{ + return s << "template_mock_streamable"; +} +} // namespace mock + +BOOST_AUTO_TEST_CASE(template_mock_streamable_yields_its_value_when_serialized) +{ + BOOST_CHECK_EQUAL("template_mock_streamable", to_string(template_mock_streamable())); } -namespace +BOOST_AUTO_TEST_CASE(std_pairs_are_serialized) { - template< typename T > - struct template_streamable - {}; - template< typename T > - std::ostream& operator<<( std::ostream& s, const template_streamable< T >& ) - { - BOOST_FAIL( "should not have been called" ); - return s; - } - template< typename T > - mock::stream& operator<<( mock::stream& s, const template_streamable< T >& ) - { - return s << "template_streamable"; - } -} - -BOOST_AUTO_TEST_CASE( template_template_streamable_yields_its_value_when_serialized ) -{ - BOOST_CHECK_EQUAL( "template_streamable", to_string( template_streamable< int >() ) ); -} - -namespace -{ - template< typename T > - struct template_mock_streamable - {}; - template< typename T > - std::ostream& operator<<( std::ostream& s, const template_mock_streamable< T >& ) - { - BOOST_FAIL( "should not have been called" ); - return s; - } -} -namespace mock -{ - template< typename T > - stream& operator<<( stream& s, const template_mock_streamable< T >& ) - { - return s << "template_mock_streamable"; - } -} // mock - -BOOST_AUTO_TEST_CASE( template_mock_streamable_yields_its_value_when_serialized ) -{ - BOOST_CHECK_EQUAL( "template_mock_streamable", to_string( template_mock_streamable< int >() ) ); -} - -BOOST_AUTO_TEST_CASE( std_pairs_are_serialized ) -{ - BOOST_CHECK_EQUAL( "(3,42)", to_string( std::make_pair( 3, 42.f ) ) ); + BOOST_CHECK_EQUAL("(3,42)", to_string(std::make_pair(3, 42.f))); } #ifdef MOCK_AUTO_PTR -BOOST_AUTO_TEST_CASE( std_auto_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_auto_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::auto_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( std::auto_ptr< int >( new int( 42 ) ) ) ); + BOOST_CHECK_NE("?", to_string(std::auto_ptr())); + BOOST_CHECK_NE("?", to_string(std::auto_ptr(new int(42)))); } #endif // MOCK_AUTO_PTR -BOOST_AUTO_TEST_CASE( boost_shared_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_shared_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( boost::shared_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( boost::shared_ptr< int >( new int( 42 ) ) ) ); + BOOST_CHECK_NE("?", to_string(boost::shared_ptr())); + BOOST_CHECK_NE("?", to_string(boost::shared_ptr(new int(42)))); } -BOOST_AUTO_TEST_CASE( boost_weak_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_weak_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( boost::weak_ptr< int >( boost::shared_ptr< int >() ) ) ); - BOOST_CHECK_NE( "?", to_string( boost::weak_ptr< int >( boost::shared_ptr< int >( new int( 42 ) ) ) ) ); + BOOST_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr()))); + BOOST_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr(new int(42))))); } #ifdef MOCK_SMART_PTR -BOOST_AUTO_TEST_CASE( std_shared_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_shared_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >( new int( 42 ) ) ) ); + BOOST_CHECK_NE("?", to_string(std::shared_ptr())); + BOOST_CHECK_NE("?", to_string(std::shared_ptr(new int(42)))); } -BOOST_AUTO_TEST_CASE( std_weak_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_weak_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::weak_ptr< int >( std::shared_ptr< int >() ) ) ); - BOOST_CHECK_NE( "?", to_string( std::weak_ptr< int >( std::shared_ptr< int >( new int( 42 ) ) ) ) ); + BOOST_CHECK_NE("?", to_string(std::weak_ptr(std::shared_ptr()))); + BOOST_CHECK_NE("?", to_string(std::weak_ptr(std::shared_ptr(new int(42))))); } -BOOST_AUTO_TEST_CASE( std_unique_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_unique_ptr_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >( new int( 42 ) ) ) ); + BOOST_CHECK_NE("?", to_string(std::unique_ptr())); + BOOST_CHECK_NE("?", to_string(std::unique_ptr(new int(42)))); } #endif -BOOST_AUTO_TEST_CASE( std_deques_are_serialized ) +BOOST_AUTO_TEST_CASE(std_deques_are_serialized) { - std::deque< int > d; - d.push_back( 12 ); - d.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( d ) ); + std::deque d; + d.push_back(12); + d.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(d)); } -BOOST_AUTO_TEST_CASE( std_lists_are_serialized ) +BOOST_AUTO_TEST_CASE(std_lists_are_serialized) { - std::list< int > l; - l.push_back( 12 ); - l.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( l ) ); + std::list l; + l.push_back(12); + l.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(l)); } -BOOST_AUTO_TEST_CASE( std_vectors_are_serialized ) +BOOST_AUTO_TEST_CASE(std_vectors_are_serialized) { - std::vector< int > v; - v.push_back( 12 ); - v.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( v ) ); + std::vector v; + v.push_back(12); + v.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(v)); } -BOOST_AUTO_TEST_CASE( std_maps_are_serialized ) +BOOST_AUTO_TEST_CASE(std_maps_are_serialized) { - std::map< int, std::string > m; - m[ 12 ] = "12"; - m[ 42 ] = "42"; - BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( m ) ); + std::map m; + m[12] = "12"; + m[42] = "42"; + BOOST_CHECK_EQUAL("((12,\"12\"),(42,\"42\"))", to_string(m)); } -BOOST_AUTO_TEST_CASE( std_multimaps_are_serialized ) +BOOST_AUTO_TEST_CASE(std_multimaps_are_serialized) { - std::multimap< int, std::string > m; - m.insert( std::make_pair( 12, "12" )); - m.insert( std::make_pair( 42, "42" )); - BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( m ) ); + std::multimap m; + m.insert(std::make_pair(12, "12")); + m.insert(std::make_pair(42, "42")); + BOOST_CHECK_EQUAL("((12,\"12\"),(42,\"42\"))", to_string(m)); } -BOOST_AUTO_TEST_CASE( std_sets_are_serialized ) +BOOST_AUTO_TEST_CASE(std_sets_are_serialized) { - std::set< int > s; - s.insert( 12 ); - s.insert( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); + std::set s; + s.insert(12); + s.insert(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(s)); } -BOOST_AUTO_TEST_CASE( std_multisets_are_serialized ) +BOOST_AUTO_TEST_CASE(std_multisets_are_serialized) { - std::multiset< int > s; - s.insert( 12 ); - s.insert( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); + std::multiset s; + s.insert(12); + s.insert(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(s)); } -BOOST_AUTO_TEST_CASE( std_deques_of_vectors_are_serialized ) +BOOST_AUTO_TEST_CASE(std_deques_of_vectors_are_serialized) { - std::deque< std::vector< int > > v; - std::vector< int > v1, v2; - v1.push_back( 12 ); - v2.push_back( 42 ); - v2.push_back( 77 ); - v.push_back( v1 ); - v.push_back( v2 ); - BOOST_CHECK_EQUAL( "((12),(42,77))", to_string( v ) ); + std::deque> v; + std::vector v1, v2; + v1.push_back(12); + v2.push_back(42); + v2.push_back(77); + v.push_back(v1); + v.push_back(v2); + BOOST_CHECK_EQUAL("((12),(42,77))", to_string(v)); } -BOOST_AUTO_TEST_CASE( std_vectors_of_deques_are_serialized ) +BOOST_AUTO_TEST_CASE(std_vectors_of_deques_are_serialized) { - std::vector< std::deque< int > > v; - std::deque< int > v1, v2; - v1.push_back( 12 ); - v2.push_back( 42 ); - v2.push_back( 77 ); - v.push_back( v1 ); - v.push_back( v2 ); - BOOST_CHECK_EQUAL( "((12),(42,77))", to_string( v ) ); + std::vector> v; + std::deque v1, v2; + v1.push_back(12); + v2.push_back(42); + v2.push_back(77); + v.push_back(v1); + v.push_back(v2); + BOOST_CHECK_EQUAL("((12),(42,77))", to_string(v)); } -BOOST_AUTO_TEST_CASE( boost_assign_list_of_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_assign_list_of_are_serialized) { - BOOST_CHECK_EQUAL( "(12,42)", to_string( boost::assign::list_of( 12 )( 42 ) ) ); + BOOST_CHECK_EQUAL("(12,42)", to_string(boost::assign::list_of(12)(42))); } -BOOST_AUTO_TEST_CASE( boost_assign_map_list_of_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_assign_map_list_of_are_serialized) { - BOOST_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( boost::assign::map_list_of( 12, "12" )( 42, "42" ) ) ); + BOOST_CHECK_EQUAL("((12,\"12\"),(42,\"42\"))", to_string(boost::assign::map_list_of(12, "12")(42, "42"))); } -BOOST_AUTO_TEST_CASE( boost_reference_wrappers_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_reference_wrappers_are_serialized) { const int i = 3; - BOOST_CHECK_EQUAL( "3", to_string( boost::cref( i ) ) ); - BOOST_CHECK_EQUAL( "\"string\"", to_string( boost::cref( "string" ) ) ); + BOOST_CHECK_EQUAL("3", to_string(boost::cref(i))); + BOOST_CHECK_EQUAL("\"string\"", to_string(boost::cref("string"))); } -namespace +namespace { +void callable_builtin() {} +} // namespace + +BOOST_AUTO_TEST_CASE(callable_builtin_yields_a_question_mark_when_serialized) { - void callable_builtin() - {} + BOOST_CHECK_EQUAL("?", to_string(callable_builtin)); + BOOST_CHECK_EQUAL("?", to_string(&callable_builtin)); } -BOOST_AUTO_TEST_CASE( callable_builtin_yields_a_question_mark_when_serialized ) +namespace { +struct serialized_using_format +{}; +std::ostream& operator<<(std::ostream& s, const serialized_using_format&) { - BOOST_CHECK_EQUAL( "?", to_string( callable_builtin ) ); - BOOST_CHECK_EQUAL( "?", to_string( &callable_builtin ) ); + 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&) { - struct serialized_using_format - {}; - std::ostream& operator<<( std::ostream& s, const serialized_using_format& ) - { - return s << mock::format( "string" ); - } + 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())); } -BOOST_AUTO_TEST_CASE( type_can_use_format_when_serialized ) +namespace { +struct std_string_streamed +{}; +mock::stream& operator<<(mock::stream& s, const std_string_streamed&) { - BOOST_CHECK_EQUAL( "\"string\"", to_string( serialized_using_format() ) ); + 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 -{ - struct streamed_using_format - {}; - mock::stream& operator<<( mock::stream& s, const streamed_using_format& ) - { - return s << mock::format( "string" ); - } -} - -BOOST_AUTO_TEST_CASE( type_can_use_format_when_streamed ) -{ - BOOST_CHECK_EQUAL( "\"string\"", to_string( streamed_using_format() ) ); -} - -namespace -{ - struct std_string_streamed - {}; - mock::stream& operator<<( mock::stream& s, const std_string_streamed& ) - { - return s << std::string( "string" ); - } -} - -BOOST_AUTO_TEST_CASE( std_string_streamed_is_not_a_container ) -{ - BOOST_CHECK_EQUAL( "string", to_string( std_string_streamed() ) ); -} - -namespace mock -{ -namespace detail -{ - template< typename T > +namespace mock { namespace detail { + template struct template_serializable {}; - template< typename T > - std::ostream& operator<<( std::ostream& s, const template_serializable< T >& ) + template + std::ostream& operator<<(std::ostream& s, const template_serializable&) { 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_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 >() ) ); + BOOST_CHECK_EQUAL("mock::detail::template_serializable", to_string(mock::detail::template_serializable())); } -namespace mock -{ -namespace detail -{ - template< typename T > +namespace mock { namespace detail { + template struct template_streamable {}; - template< typename T > - std::ostream& operator<<( std::ostream& s, const template_streamable< T >& ) + template + std::ostream& operator<<(std::ostream& s, const template_streamable&) { - BOOST_FAIL( "should not have been called" ); + BOOST_FAIL("should not have been called"); return s; } - template< typename T > - mock::stream& operator<<( mock::stream& s, const template_streamable< T >& ) + template + mock::stream& operator<<(mock::stream& s, const template_streamable&) { return s << "mock::detail::template_streamable"; } -} -} // mock +}} // namespace mock::detail -BOOST_AUTO_TEST_CASE( mock_detail_template_template_streamable_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(mock_detail_template_template_streamable_yields_its_value_when_serialized) { - BOOST_CHECK_EQUAL( "mock::detail::template_streamable", to_string( mock::detail::template_streamable< int >() ) ); + BOOST_CHECK_EQUAL("mock::detail::template_streamable", to_string(mock::detail::template_streamable())); } -BOOST_AUTO_TEST_CASE( unsigned_char_is_serialized_as_int ) +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' ) ); + BOOST_CHECK_EQUAL(boost::lexical_cast(static_cast('a')), to_string('a')); } -namespace +namespace { +bool some_function() { - bool some_function() - { - return false; - } + return false; +} +} // namespace + +BOOST_AUTO_TEST_CASE(boost_phoenix_functor_yields_question_mark_when_serialized) +{ + BOOST_CHECK_EQUAL("?", to_string(boost::phoenix::bind(&some_function))); + BOOST_CHECK_EQUAL("?", to_string(boost::phoenix::arg_names::_1 < 42)); } -BOOST_AUTO_TEST_CASE( boost_phoenix_functor_yields_question_mark_when_serialized ) +BOOST_AUTO_TEST_CASE(boost_bind_functor_yields_question_mark_when_serialized) { - BOOST_CHECK_EQUAL( "?", to_string( boost::phoenix::bind( &some_function ) ) ); - BOOST_CHECK_EQUAL( "?", to_string( boost::phoenix::arg_names::_1 < 42 ) ); -} - -BOOST_AUTO_TEST_CASE( boost_bind_functor_yields_question_mark_when_serialized ) -{ - BOOST_CHECK_EQUAL( "?", to_string( boost::bind( &some_function ) ) ); + BOOST_CHECK_EQUAL("?", to_string(boost::bind(&some_function))); } #ifndef BOOST_MSVC // this produces an ICE with all versions of MSVC -BOOST_AUTO_TEST_CASE( boost_lambda_functor_yields_question_mark_when_serialized ) +BOOST_AUTO_TEST_CASE(boost_lambda_functor_yields_question_mark_when_serialized) { - BOOST_CHECK_EQUAL( "?", to_string( boost::lambda::bind( &some_function ) ) ); - BOOST_CHECK_EQUAL( "?", to_string( boost::lambda::_1 < 42 ) ); + BOOST_CHECK_EQUAL("?", to_string(boost::lambda::bind(&some_function))); + BOOST_CHECK_EQUAL("?", to_string(boost::lambda::_1 < 42)); } #endif #ifdef MOCK_NULLPTR -BOOST_AUTO_TEST_CASE( nullptr_is_serialized ) +BOOST_AUTO_TEST_CASE(nullptr_is_serialized) { - BOOST_CHECK_EQUAL( "nullptr", to_string( nullptr ) ); + BOOST_CHECK_EQUAL("nullptr", to_string(nullptr)); } #endif -BOOST_AUTO_TEST_CASE( mock_boost_optional_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(mock_boost_optional_yields_its_value_when_serialized) { - BOOST_CHECK_EQUAL( "7", to_string( boost::optional< int >( 7 ) ) ); - BOOST_CHECK_EQUAL( "?", to_string( boost::optional< non_serializable >( non_serializable() ) ) ); - BOOST_CHECK_EQUAL( "none", to_string( boost::optional< int >() ) ); - BOOST_CHECK_EQUAL( "none", to_string( boost::optional< non_serializable >() ) ); - BOOST_CHECK_EQUAL( "none", to_string( boost::none ) ); + BOOST_CHECK_EQUAL("7", to_string(boost::optional(7))); + BOOST_CHECK_EQUAL("?", to_string(boost::optional(non_serializable()))); + BOOST_CHECK_EQUAL("none", to_string(boost::optional())); + BOOST_CHECK_EQUAL("none", to_string(boost::optional())); + BOOST_CHECK_EQUAL("none", to_string(boost::none)); } diff --git a/test/test_matcher.cpp b/test/test_matcher.cpp index c28648e..af451ae 100644 --- a/test/test_matcher.cpp +++ b/test/test_matcher.cpp @@ -9,70 +9,66 @@ #include #include -namespace +namespace { +template +bool match(Expected expected, Actual actual) { - template< typename Expected, typename Actual > - bool match( Expected expected, Actual actual ) - { - return mock::matcher< Actual, Expected >( expected )( actual ); - } + return mock::matcher(expected)(actual); +} +} // namespace + +BOOST_AUTO_TEST_CASE(int_and_int_can_be_compared) +{ + BOOST_CHECK(match(3, 3)); + BOOST_CHECK(!match(3, 4)); + BOOST_CHECK(!match(4, 3)); } -BOOST_AUTO_TEST_CASE( int_and_int_can_be_compared ) -{ - BOOST_CHECK( match( 3, 3 ) ); - BOOST_CHECK( ! match( 3, 4 ) ); - BOOST_CHECK( ! match( 4, 3 ) ); -} - -BOOST_AUTO_TEST_CASE( ref_to_int_and_int_can_be_compared ) +BOOST_AUTO_TEST_CASE(ref_to_int_and_int_can_be_compared) { const int i = 3; - BOOST_CHECK( match( 3, boost::cref( i ) ) ); - BOOST_CHECK( ! match( 4, boost::cref( i ) ) ); + BOOST_CHECK(match(3, boost::cref(i))); + BOOST_CHECK(!match(4, boost::cref(i))); } -namespace +namespace { +struct fixture { - 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 ); - BOOST_REQUIRE( actual == std::string( static_string ) ); - } - std::string text; - const char* actual; - }; -} + const char* static_string = "same text"; + BOOST_REQUIRE(actual != static_string); + BOOST_REQUIRE(actual == std::string(static_string)); + } + std::string text; + const char* actual; +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_pointer_can_be_compared, fixture ) +BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_const_char_pointer_can_be_compared, fixture) { const char* expected = "same text"; - BOOST_CHECK( match( expected, actual ) ); + BOOST_CHECK(match(expected, actual)); const char* unexpected = "different text"; - BOOST_CHECK( ! match( actual, unexpected ) ); + BOOST_CHECK(!match(actual, unexpected)); } -BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_string_literal_can_be_compared, fixture ) +BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_string_literal_can_be_compared, fixture) { - BOOST_CHECK( match( "same text", actual ) ); - BOOST_CHECK( ! match( "different text", actual ) ); + BOOST_CHECK(match("same text", actual)); + BOOST_CHECK(!match("different text", actual)); } -BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_array_can_be_compared, fixture ) +BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_const_char_array_can_be_compared, fixture) { const char expected[10] = "same text"; - BOOST_CHECK( match( expected, actual ) ); + BOOST_CHECK(match(expected, actual)); const char unexpected[15] = "different text"; - BOOST_CHECK( ! match( unexpected, actual ) ); + BOOST_CHECK(!match(unexpected, actual)); } -BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_std_string_can_be_compared, fixture ) +BOOST_FIXTURE_TEST_CASE(const_char_pointer_and_std_string_can_be_compared, fixture) { - BOOST_CHECK( match( std::string( "same text" ), actual ) ); - BOOST_CHECK( ! match( std::string( "different text" ), actual ) ); + BOOST_CHECK(match(std::string("same text"), actual)); + BOOST_CHECK(!match(std::string("different text"), actual)); } diff --git a/test/test_max_args.cpp b/test/test_max_args.cpp index 970a25f..627a040 100644 --- a/test/test_max_args.cpp +++ b/test/test_max_args.cpp @@ -8,32 +8,31 @@ #include "mock_error.hpp" #include -#include #include +#include #define IDENTITY(z, n, d) d -namespace +namespace { +struct my_custom_mock { - 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 ) - }; -} + 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 ) +BOOST_FIXTURE_TEST_CASE(call_mock_method_with_max_number_of_args, mock_error_fixture) { my_custom_mock m; - MOCK_EXPECT( m.tag ).once().with( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ); - m.method( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.tag).once().with(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0)); + m.method(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( call_mock_method_with_max_number_of_args_and_a_return_value, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(call_mock_method_with_max_number_of_args_and_a_return_value, mock_error_fixture) { my_custom_mock m; - MOCK_EXPECT( m.tag_2 ).once().with( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ).returns( 42 ); - BOOST_CHECK_EQUAL( 42, m.method2( BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0) ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.tag_2).once().with(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0)).returns(42); + BOOST_CHECK_EQUAL(42, m.method2(BOOST_PP_ENUM(MOCK_MAX_ARGS, IDENTITY, 0))); + CHECK_CALLS(1); } diff --git a/test/test_mock.cpp b/test/test_mock.cpp index 2e4f41c..4a3e0c3 100644 --- a/test/test_mock.cpp +++ b/test/test_mock.cpp @@ -8,461 +8,385 @@ #include "mock_error.hpp" #include -#include -#include #include +#include +#include -namespace +namespace { +template +void my_function(T& t) { - 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 ) - }; + t.my_method("some parameter"); } +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 ) +BOOST_FIXTURE_TEST_CASE(mock_object_for_static_polymorphism, mock_error_fixture) { const mock_class m; - MOCK_EXPECT( m.my_tag ).once().with( "some parameter" ); - my_function( m ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.my_tag).once().with("some parameter"); + my_function(m); + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_addition_operator, mock_error_fixture) { mock_class_with_operator m; - MOCK_EXPECT( m.addition ).once().returns( boost::ref( m ) ); + MOCK_EXPECT(m.addition).once().returns(boost::ref(m)); m += 1; - CHECK_CALLS( 1 ); + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_conversion_operator, mock_error_fixture) { mock_class_with_conversion_operator m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); - BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.conversion).once().returns(42); + BOOST_CHECK_EQUAL(42, static_cast(m)); + CHECK_CALLS(1); } -namespace +namespace { +template +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) { - template< typename T > - MOCK_CLASS( mock_template_class_with_conversion_operator ) - { - MOCK_CONVERSION_OPERATOR_TPL( operator, T, conversion ) - }; + mock_template_class_with_conversion_operator m; + MOCK_EXPECT(m.conversion).once().returns(42); + BOOST_CHECK_EQUAL(42, static_cast(m)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mock_template_conversion_operator, mock_error_fixture ) -{ - mock_template_class_with_conversion_operator< int > m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); - BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); - 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 ) +BOOST_FIXTURE_TEST_CASE(mock_const_conversion_operator, mock_error_fixture) { mock_class_with_const_conversion_operator m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); + MOCK_EXPECT(m.conversion).once().returns(42); int i = m; - BOOST_CHECK_EQUAL( 42, i ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(42, i); + 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 ) +BOOST_FIXTURE_TEST_CASE(mock_non_const_conversion_operator, mock_error_fixture) { mock_class_with_non_const_conversion_operator m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); + MOCK_EXPECT(m.conversion).once().returns(42); int i = m; - BOOST_CHECK_EQUAL( 42, i ); - CHECK_CALLS( 1 ); + BOOST_CHECK_EQUAL(42, i); + CHECK_CALLS(1); } -namespace +namespace { +template +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) { - template< typename T > - MOCK_CLASS( mock_template_class_with_const_conversion_operator ) - { - MOCK_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) - }; + mock_template_class_with_const_conversion_operator m; + MOCK_EXPECT(m.conversion).once().returns(42); + BOOST_CHECK_EQUAL(42, static_cast(m)); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( mock_template_const_conversion_operator, mock_error_fixture ) +namespace { +template +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) { - mock_template_class_with_const_conversion_operator< int > m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); - BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); - CHECK_CALLS( 1 ); + mock_template_class_with_non_const_conversion_operator m; + MOCK_EXPECT(m.conversion).once().returns(42); + BOOST_CHECK_EQUAL(42, static_cast(m)); + CHECK_CALLS(1); } -namespace -{ - template< typename T > - MOCK_CLASS( mock_template_class_with_non_const_conversion_operator ) - { - MOCK_NON_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) - }; +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_template_non_const_conversion_operator, mock_error_fixture ) -{ - mock_template_class_with_non_const_conversion_operator< int > m; - MOCK_EXPECT( m.conversion ).once().returns( 42 ); - BOOST_CHECK_EQUAL( 42, static_cast< int >( m ) ); - 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 ) - }; -} - -BOOST_FIXTURE_TEST_CASE( MOCK_CONST_METHOD_EXT_macro_defines_a_bindable_method, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(MOCK_CONST_METHOD_EXT_macro_defines_a_bindable_method, mock_error_fixture) { my_mock m; - boost::bind( &my_mock::my_method, &m, 42 ); + boost::bind(&my_mock::my_method, &m, 42); } -BOOST_FIXTURE_TEST_CASE( MOCK_VERIFY_macro, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(MOCK_VERIFY_macro, mock_error_fixture) { my_mock m; - MOCK_VERIFY( m.my_method ); + MOCK_VERIFY(m.my_method); } -BOOST_FIXTURE_TEST_CASE( MOCK_RESET_macro, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(MOCK_RESET_macro, mock_error_fixture) { my_mock m; - MOCK_RESET( m.my_method ); + MOCK_RESET(m.my_method); } -BOOST_FIXTURE_TEST_CASE( MOCK_EXPECT_macro, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(MOCK_EXPECT_macro, mock_error_fixture) { my_mock m; - MOCK_EXPECT( m.my_method ).once().with( 42 ); - m.my_method( 42 ); - CHECK_CALLS( 1 ); + MOCK_EXPECT(m.my_method).once().with(42); + m.my_method(42); + CHECK_CALLS(1); } -namespace +namespace { +template +std::string to_string(const T& t) { - template< typename T > - std::string to_string( const T& t ) - { - std::stringstream s; - s << t; - return s.str(); - } + std::stringstream s; + s << t; + return s.str(); } +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_object_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_object_is_named, mock_error_fixture) { my_mock m; - BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m.my_method ) ) ); - BOOST_CHECK_EQUAL( "?.my_mock::my_method_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_method_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_HELPER( m.my_method ) ) ); - BOOST_CHECK_EQUAL( "m.my_mock::my_method_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_method_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m.my_method ) ) ); - BOOST_CHECK_EQUAL( "m.my_mock::my_method", to_string( MOCK_HELPER( m.my_method ) ) ); + BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m.my_method))); + BOOST_CHECK_EQUAL("?.my_mock::my_method_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_method_2))); + BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_HELPER(m.my_method))); + BOOST_CHECK_EQUAL("m.my_mock::my_method_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_method_2))); + BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m.my_method))); + BOOST_CHECK_EQUAL("m.my_mock::my_method", to_string(MOCK_HELPER(m.my_method))); } #ifdef MOCK_AUTO_PTR -BOOST_FIXTURE_TEST_CASE( mock_object_auto_pointer_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_object_auto_pointer_is_named, mock_error_fixture) { - std::auto_ptr< my_mock > m( new my_mock ); - BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + std::auto_ptr m(new my_mock); + BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); } -BOOST_FIXTURE_TEST_CASE( mock_object_const_auto_pointer_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_object_const_auto_pointer_is_named, mock_error_fixture) { - const std::auto_ptr< my_mock > m( new my_mock ); - BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + const std::auto_ptr m(new my_mock); + BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); } #endif // MOCK_AUTO_PTR -BOOST_FIXTURE_TEST_CASE( mock_object_shared_pointer_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_object_shared_pointer_is_named, mock_error_fixture) { - boost::shared_ptr< my_mock > m( new my_mock ); - BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + boost::shared_ptr m(new my_mock); + BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); } -BOOST_FIXTURE_TEST_CASE( mock_object_const_shared_pointer_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_object_const_shared_pointer_is_named, mock_error_fixture) { - const boost::shared_ptr< my_mock > m( new my_mock ); - BOOST_CHECK_EQUAL( "?.my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_ANONYMOUS_HELPER( m->my_method ) ) ); - BOOST_CHECK_EQUAL( "m->my_mock::my_method", to_string( MOCK_HELPER( m->my_method ) ) ); + const boost::shared_ptr m(new my_mock); + BOOST_CHECK_EQUAL("?.my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_ANONYMOUS_HELPER(m->my_method))); + BOOST_CHECK_EQUAL("m->my_mock::my_method", to_string(MOCK_HELPER(m->my_method))); } -namespace +namespace { +struct my_custom_mock { - struct my_custom_mock - { - MOCK_METHOD_EXT( my_method, 0, void(), my_tag ) - MOCK_METHOD_EXT( my_method_2, 0, void(), my_tag_2 ) - }; -} + 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 ) ) ); - BOOST_CHECK_EQUAL( "?.my_custom_mock::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL("?.my_custom_mock::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL("?.my_custom_mock::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); + BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); + BOOST_CHECK_EQUAL("m.my_custom_mock::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); + 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 { - 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 ) - }; -} + 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 ) +BOOST_FIXTURE_TEST_CASE(custom_mock_object_without_macros_is_named, mock_error_fixture) { my_custom_mock_object m; - BOOST_CHECK_EQUAL( "?.my_custom_mock_object::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); - BOOST_CHECK_EQUAL( "?.my_custom_mock_object::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag_2", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag_2 ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_ANONYMOUS_HELPER( m.my_tag ) ) ); - BOOST_CHECK_EQUAL( "m.my_custom_mock_object::my_tag", to_string( MOCK_HELPER( m.my_tag ) ) ); + BOOST_CHECK_EQUAL("?.my_custom_mock_object::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL("?.my_custom_mock_object::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); + BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag_2", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag_2))); + BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_ANONYMOUS_HELPER(m.my_tag))); + BOOST_CHECK_EQUAL("m.my_custom_mock_object::my_tag", to_string(MOCK_HELPER(m.my_tag))); } -BOOST_FIXTURE_TEST_CASE( mock_functor, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor, mock_error_fixture) { - MOCK_FUNCTOR( f1, void() ); - MOCK_FUNCTOR( f2, int( const std::string& ) ); + MOCK_FUNCTOR(f1, void()); + MOCK_FUNCTOR(f2, int(const std::string&)); } -namespace +namespace { +template +struct tpl_functor_class { - template< typename T > - struct tpl_functor_class - { - MOCK_FUNCTOR_TPL( f, void( T ) ); - }; + MOCK_FUNCTOR_TPL(f, void(T)); +}; +} // namespace + +BOOST_FIXTURE_TEST_CASE(mock_functor_reset, mock_error_fixture) +{ + MOCK_FUNCTOR(f, void()); + MOCK_RESET(f); + mock::reset(f); } -BOOST_FIXTURE_TEST_CASE( mock_functor_reset, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_verify, mock_error_fixture) { - MOCK_FUNCTOR( f, void() ); - MOCK_RESET( f ); - mock::reset( f ); + MOCK_FUNCTOR(f, void()); + MOCK_VERIFY(f); + mock::verify(f); } -BOOST_FIXTURE_TEST_CASE( mock_functor_verify, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_is_named, mock_error_fixture) { - MOCK_FUNCTOR( f, void() ); - MOCK_VERIFY( f ); - mock::verify( f ); + MOCK_FUNCTOR(f, void()); + BOOST_CHECK_EQUAL("f", to_string(MOCK_HELPER(f))); } -BOOST_FIXTURE_TEST_CASE( mock_functor_is_named, mock_error_fixture ) -{ - MOCK_FUNCTOR( f, void() ); - BOOST_CHECK_EQUAL( "f", to_string( MOCK_HELPER( f ) ) ); +namespace { +MOCK_FUNCTION(mock_function, 1, float(int), mock_function) } -namespace +BOOST_FIXTURE_TEST_CASE(mock_function_is_named, mock_error_fixture) { - MOCK_FUNCTION( mock_function, 1, float( int ), mock_function ) + BOOST_CHECK_EQUAL("mock_function", to_string(MOCK_HELPER(mock_function))); } -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 +BOOST_FIXTURE_TEST_CASE(mock_static_function_is_named, mock_error_fixture) { - MOCK_CLASS( static_function_class ) - { - MOCK_STATIC_METHOD( f, 1, float( int ), f ) - }; + BOOST_CHECK_EQUAL("static_function_class::f", to_string(MOCK_HELPER(static_function_class::f))); } -BOOST_FIXTURE_TEST_CASE( mock_static_function_is_named, mock_error_fixture ) +namespace { +MOCK_CLASS(round_parenthesized_signature) { - BOOST_CHECK_EQUAL( "static_function_class::f", to_string( MOCK_HELPER( static_function_class::f ) ) ); -} - -namespace -{ - MOCK_CLASS( round_parenthesized_signature ) - { - MOCK_METHOD_EXT( m0, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), m0 ) - MOCK_STATIC_METHOD( m1, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), m1 ) - MOCK_FUNCTOR( f0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ); - }; - MOCK_FUNCTION( fun0, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())), fun0 ) -} + MOCK_METHOD_EXT(m0, 0, BOOST_IDENTITY_TYPE((std::map())), m0) + MOCK_STATIC_METHOD(m1, 0, BOOST_IDENTITY_TYPE((std::map())), m1) + MOCK_FUNCTOR(f0, BOOST_IDENTITY_TYPE((std::map()))); +}; +MOCK_FUNCTION(fun0, 0, BOOST_IDENTITY_TYPE((std::map())), fun0) +} // namespace #ifdef MOCK_VARIADIC_MACROS -namespace +namespace { +struct base { - struct base - { - virtual ~base() - {} + virtual ~base() {} - virtual void m1() = 0; - virtual void m10() const = 0; - virtual void m11() = 0; - }; + 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 ) - }; +template +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){}; - MOCK_FUNCTION( fun1, 0, void() ) - MOCK_FUNCTION( fun2, 0, void(), fun2 ) - MOCK_FUNCTION( fun3, 0, BOOST_IDENTITY_TYPE((std::map< int, int >())) ) +MOCK_FUNCTION(fun1, 0, void()) +MOCK_FUNCTION(fun2, 0, void(), fun2) +MOCK_FUNCTION(fun3, 0, BOOST_IDENTITY_TYPE((std::map()))) - MOCK_FUNCTOR( f_variadic, std::map< int, int >() ); -} +MOCK_FUNCTOR(f_variadic, std::map()); +} // namespace #else // MOCK_VARIADIC_MACROS -namespace +namespace { +struct base { - struct base - { - virtual ~base() - {} + virtual ~base() {} - virtual void m1() = 0; - }; + 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 ) - }; -} +template +MOCK_BASE_CLASS(derived_tpl, base){MOCK_METHOD_EXT(m1, 0, void(), m1)}; +} // namespace #endif // MOCK_VARIADIC_MACROS #ifdef BOOST_MSVC -# define MOCK_STDCALL __stdcall +# define MOCK_STDCALL __stdcall #else -# define MOCK_STDCALL +# define MOCK_STDCALL #endif -namespace stdcall +namespace stdcall { +struct base { - struct base - { - virtual ~base() - {} + virtual ~base() {} - virtual void MOCK_STDCALL m1() = 0; - }; + 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_METHOD_EXT( MOCK_STDCALL m2, 0, void(), m2 ) +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 ) + 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 ) -} +MOCK_FUNCTION(MOCK_STDCALL f, 0, void(), f) +} // namespace stdcall diff --git a/test/test_object.cpp b/test/test_object.cpp index 84e1094..ba2201f 100644 --- a/test/test_object.cpp +++ b/test/test_object.cpp @@ -7,102 +7,81 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "mock_error.hpp" +#include #include #include -#include -#include #include +#include -namespace -{ - struct object : mock::object - {}; +namespace { +struct object : mock::object +{}; - object static_o; -} +object static_o; +} // namespace -BOOST_FIXTURE_TEST_CASE( verifying_an_empty_object_succeeds, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(verifying_an_empty_object_succeeds, mock_error_fixture) { object o; - BOOST_CHECK( mock::verify( o ) ); + BOOST_CHECK(mock::verify(o)); } -namespace +namespace { +struct fixture : mock_error_fixture { - struct fixture : mock_error_fixture - { - fixture() - { - mock::detail::configure( o, e, "instance", MOCK_TYPE_NAME(o), "name" ); - } - object o; - mock::detail::function< void() > e; - }; -} + fixture() { mock::detail::configure(o, e, "instance", MOCK_TYPE_NAME(o), "name"); } + object o; + mock::detail::function e; +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( verifying_an_object_containing_a_failing_expectation_fails, fixture ) +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()" ); - mock::reset( o ); - BOOST_CHECK( mock::verify( o ) ); + CHECK_ERROR(BOOST_CHECK(!mock::verify(o)), "verification failed", 0, "instanceobject::name\n. once()"); + mock::reset(o); + BOOST_CHECK(mock::verify(o)); } -BOOST_FIXTURE_TEST_CASE( verifying_all_objects_with_one_of_them_containing_a_failing_expectation_fails, fixture ) +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() ); + BOOST_CHECK(mock::verify()); } -BOOST_FIXTURE_TEST_CASE( resetting_an_object_containing_a_failing_expectation_and_verifying_it_succeeds, fixture ) +BOOST_FIXTURE_TEST_CASE(resetting_an_object_containing_a_failing_expectation_and_verifying_it_succeeds, fixture) { e.expect().once(); - mock::reset( o ); - BOOST_CHECK( mock::verify( o ) ); + mock::reset(o); + BOOST_CHECK(mock::verify(o)); } -BOOST_FIXTURE_TEST_CASE( an_object_is_assignable_by_sharing_its_state, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(an_object_is_assignable_by_sharing_its_state, mock_error_fixture) { object o1; - mock::detail::function< void() > e; + mock::detail::function e; { object o2; - mock::detail::configure( o2, e, "instance", MOCK_TYPE_NAME(o2), "name" ); + 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 ) +BOOST_FIXTURE_TEST_CASE(an_object_is_copiable_by_sharing_its_state, mock_error_fixture) { - boost::scoped_ptr< object > o2( new object ); - const object o1( *o2 ); - mock::detail::function< void() > e; - mock::detail::configure( *o2, e, "instance", MOCK_TYPE_NAME(*o2), "name" ); + boost::scoped_ptr o2(new object); + const object o1(*o2); + mock::detail::function 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()"); } diff --git a/test/test_sequence.cpp b/test/test_sequence.cpp index d14de02..85e5fd9 100644 --- a/test/test_sequence.cpp +++ b/test/test_sequence.cpp @@ -7,108 +7,110 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "mock_error.hpp" -#include #include +#include #include -BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_out_of_order_throws, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_out_of_order_throws, mock_error_fixture) { mock::sequence s; - mock::detail::function< void( int ) > e; - e.expect().once().with( 1 ).in( s ); - e.expect().once().with( 2 ).in( s ); - BOOST_CHECK_NO_THROW( e( 2 ) ); - CHECK_ERROR( e( 1 ), "sequence failed", 1, "?( 1 )\n. once().with( 1 )\nv once().with( 2 )" ); + mock::detail::function e; + e.expect().once().with(1).in(s); + e.expect().once().with(2).in(s); + BOOST_CHECK_NO_THROW(e(2)); + 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; - e.expect().with( 1 ).in( s ); - e.expect().once().with( 2 ).in( s ); - BOOST_CHECK_NO_THROW( e( 1 ) ); - BOOST_CHECK_NO_THROW( e( 2 ) ); - CHECK_ERROR( e( 1 ), "sequence failed", 2, "?( 1 )\n. unlimited().with( 1 )\nv once().with( 2 )" ); + mock::detail::function e; + e.expect().with(1).in(s); + e.expect().once().with(2).in(s); + BOOST_CHECK_NO_THROW(e(1)); + BOOST_CHECK_NO_THROW(e(2)); + CHECK_ERROR(e(1), "sequence failed", 2, "?( 1 )\n. unlimited().with( 1 )\nv once().with( 2 )"); } -BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_calling_in_order_is_valid, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_calling_in_order_is_valid, mock_error_fixture) { mock::sequence s; - mock::detail::function< void( int ) > e; - e.expect().once().with( 1 ).in( s ); - e.expect().once().with( 2 ).in( s ); - BOOST_CHECK_NO_THROW( e( 1 ) ); - BOOST_CHECK_NO_THROW( e( 2 ) ); - BOOST_CHECK( e.verify() ); - CHECK_CALLS( 2 ); + mock::detail::function e; + e.expect().once().with(1).in(s); + e.expect().once().with(2).in(s); + BOOST_CHECK_NO_THROW(e(1)); + BOOST_CHECK_NO_THROW(e(2)); + BOOST_CHECK(e.verify()); + CHECK_CALLS(2); } -BOOST_FIXTURE_TEST_CASE( registering_to_a_sequence_and_multiply_calling_in_order_is_valid, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(registering_to_a_sequence_and_multiply_calling_in_order_is_valid, mock_error_fixture) { mock::sequence s; - mock::detail::function< void( int ) > e; - e.expect().exactly( 2 ).with( 1 ).in( s ); - e.expect().exactly( 2 ).with( 2 ).in( s ); - BOOST_CHECK_NO_THROW( e( 1 ) ); - BOOST_CHECK_NO_THROW( e( 1 ) ); - BOOST_CHECK_NO_THROW( e( 2 ) ); - BOOST_CHECK_NO_THROW( e( 2 ) ); - BOOST_CHECK( e.verify() ); - CHECK_CALLS( 4 ); + mock::detail::function e; + e.expect().exactly(2).with(1).in(s); + e.expect().exactly(2).with(2).in(s); + BOOST_CHECK_NO_THROW(e(1)); + BOOST_CHECK_NO_THROW(e(1)); + BOOST_CHECK_NO_THROW(e(2)); + BOOST_CHECK_NO_THROW(e(2)); + BOOST_CHECK(e.verify()); + 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; - e1.expect().once().in( s ); - e2.expect().once().in( s ); - BOOST_CHECK_NO_THROW( e2() ); - CHECK_ERROR( e1(), "sequence failed", 1, "?()\n. once()" ); + mock::detail::function e1, e2; + e1.expect().once().in(s); + e2.expect().once().in(s); + BOOST_CHECK_NO_THROW(e2()); + CHECK_ERROR(e1(), "sequence failed", 1, "?()\n. once()"); } -BOOST_FIXTURE_TEST_CASE( destroying_a_sequence_does_not_remove_order_call_enforcement, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(destroying_a_sequence_does_not_remove_order_call_enforcement, mock_error_fixture) { - mock::detail::function< void() > e1, e2; + mock::detail::function e1, e2; { mock::sequence s; - e1.expect().once().in( s ); - e2.expect().once().in( s ); + e1.expect().once().in(s); + e2.expect().once().in(s); } - BOOST_CHECK_NO_THROW( e2() ); - CHECK_ERROR( e1(), "sequence failed", 1, "?()\n. once()" ); + BOOST_CHECK_NO_THROW(e2()); + CHECK_ERROR(e1(), "sequence failed", 1, "?()\n. once()"); } -BOOST_FIXTURE_TEST_CASE( resetting_an_expectation_removes_it_from_order_call_enforcement, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(resetting_an_expectation_removes_it_from_order_call_enforcement, mock_error_fixture) { mock::sequence s; - mock::detail::function< void() > e1, e2; - e1.expect().once().in( s ); - e2.expect().once().in( s ); + mock::detail::function e1, e2; + e1.expect().once().in(s); + e2.expect().once().in(s); e1.reset(); - BOOST_CHECK_NO_THROW( e2() ); - BOOST_CHECK( e1.verify() ); - BOOST_CHECK( e2.verify() ); - CHECK_CALLS( 1 ); + BOOST_CHECK_NO_THROW(e2()); + BOOST_CHECK(e1.verify()); + BOOST_CHECK(e2.verify()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( an_expectation_can_be_used_in_several_sequences, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(an_expectation_can_be_used_in_several_sequences, mock_error_fixture) { mock::sequence s1, s2; - mock::detail::function< void() > e; - e.expect().once().in( s1, s2 ); - BOOST_CHECK_NO_THROW( e() ); - BOOST_CHECK( e.verify() ); - CHECK_CALLS( 1 ); + mock::detail::function e; + e.expect().once().in(s1, s2); + BOOST_CHECK_NO_THROW(e()); + BOOST_CHECK(e.verify()); + CHECK_CALLS(1); } -BOOST_FIXTURE_TEST_CASE( a_result_specification_is_set_after_a_sequence, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(a_result_specification_is_set_after_a_sequence, mock_error_fixture) { mock::sequence s; - mock::detail::function< int() > e; - e.expect().once().in( s ).returns( 3 ); - BOOST_CHECK_EQUAL( 3, e() ); - BOOST_CHECK( e.verify() ); - CHECK_CALLS( 1 ); + mock::detail::function e; + e.expect().once().in(s).returns(3); + BOOST_CHECK_EQUAL(3, e()); + BOOST_CHECK(e.verify()); + CHECK_CALLS(1); }