diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..3e0460e --- /dev/null +++ b/.clang-format @@ -0,0 +1,162 @@ +--- +Language: Cpp +# BasedOnStyle: Mozilla +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveMacros: false +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Left +AlignOperands: true +AlignTrailingComments: true +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: Yes +BinPackArguments: false +BinPackParameters: false +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: None +BreakBeforeBraces: Custom +BreakBeforeInheritanceComma: false +BreakInheritanceList: AfterColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 120 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: true +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 2 +Cpp11BracedListStyle: false +DeriveLineEnding: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: ' //[ mock_stream_user_type -namespace user_namespace -{ - struct user_type - {}; +namespace user_namespace { +struct user_type +{}; - inline mock::stream& operator<<( mock::stream& s, const user_type& ) - { - return s << "user_type"; - } +inline mock::stream& operator<<(mock::stream& s, const user_type&) +{ + return s << "user_type"; } +} // namespace user_namespace //] -namespace custom_constraint_free_function_test -{ +namespace custom_constraint_free_function_test { //[ custom_constraint_free_function -bool custom_constraint( int actual ) +bool custom_constraint(int actual) { return actual == 42; } //] //[ custom_constraint_free_function_test -BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_free_function ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_free_function) { mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).with( &custom_constraint ); - c.add( 41, 1 ); - } -//] + calculator c(v); + MOCK_EXPECT(v.display).with(&custom_constraint); + c.add(41, 1); } +//] +} // namespace custom_constraint_free_function_test -namespace custom_constraint_functor_test -{ +namespace custom_constraint_functor_test { //[ custom_constraint_functor struct custom_constraint { - friend bool operator==( int actual, const custom_constraint& ) - { - return actual == 42; - } + friend bool operator==(int actual, const custom_constraint&) { return actual == 42; } - friend std::ostream& operator<<( std::ostream& s, const custom_constraint& ) - { - return s << "_ == 42"; - } + friend std::ostream& operator<<(std::ostream& s, const custom_constraint&) { return s << "_ == 42"; } }; //] //[ custom_constraint_functor_test -BOOST_AUTO_TEST_CASE( forty_one_plus_one_is_forty_two_custom_constraint ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_custom_constraint) { mock_view v; - calculator c( v ); - MOCK_EXPECT( v.display ).with( custom_constraint() ); - c.add( 41, 1 ); + calculator c(v); + MOCK_EXPECT(v.display).with(custom_constraint()); + c.add(41, 1); } //] -} +} // namespace custom_constraint_functor_test //[ near_constraint -template< typename Expected > +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 - mock::unwrap_ref(expected_) ) <= mock::unwrap_ref(threshold_) ; + return std::abs(actual - mock::unwrap_ref(expected_)) <= mock::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_near ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one_near) { - 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_near_cref ) +BOOST_AUTO_TEST_CASE(forty_one_plus_one_is_forty_two_plus_or_minus_one_near_cref) { - mock_view v; - calculator c( v ); - int expected = 0, threshold = 0; - MOCK_EXPECT( v.display ).with( near( std::cref( expected ), std::cref( threshold ) ) ); - expected = 42; - threshold = 1; - c.add( 41, 1 ); + mock_view v; + calculator c(v); + int expected = 0, threshold = 0; + MOCK_EXPECT(v.display).with(near(std::cref(expected), std::cref(threshold))); + expected = 42; + threshold = 1; + c.add(41, 1); } //] // Example of a "strong type" float -struct float_wrapper{ +struct float_wrapper +{ float value; - float_wrapper(float value): value(value){} + float_wrapper(float value) : value(value) {} operator float() const { return value; } - friend std::ostream& operator<<( std::ostream& s, const float_wrapper& f) - { - return s << f.value; - } + friend std::ostream& operator<<(std::ostream& s, const float_wrapper& f) { return s << f.value; } }; -BOOST_AUTO_TEST_CASE( near_constraint_works_with_with_float_wrapper_and_cref ) +BOOST_AUTO_TEST_CASE(near_constraint_works_with_with_float_wrapper_and_cref) { - mock_view v; - calculator c( v ); - float_wrapper expected = 0, threshold = 0; - // This works even without the unwrap_ref - MOCK_EXPECT( v.display ).once().with( near( expected, threshold ) ); - // This requires 2 implicit conversion: from reference_wrapper to float_wrapper, then to float - // so unwrap_ref in near is required as C++ allows only 1 implicit conversion - MOCK_EXPECT( v.display ).once().with( near( std::cref( expected ), std::cref( threshold ) ) ); - expected = 42; - threshold = 1; - c.add(0, 0); - c.add(41, 1); -} + mock_view v; + calculator c(v); + float_wrapper expected = 0, threshold = 0; + // This works even without the unwrap_ref + MOCK_EXPECT(v.display).once().with(near(expected, threshold)); + // This requires 2 implicit conversion: from reference_wrapper to float_wrapper, then to float + // so unwrap_ref in near is required as C++ allows only 1 implicit conversion + MOCK_EXPECT(v.display).once().with(near(std::cref(expected), std::cref(threshold))); + expected = 42; + threshold = 1; + c.add(0, 0); + c.add(41, 1); } +} // namespace near_constraint_cref_test #undef MOCK_MAX_ARGS //[ max_args @@ -169,12 +152,12 @@ BOOST_AUTO_TEST_CASE( near_constraint_works_with_with_float_wrapper_and_cref ) //] #if defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-parameter" #endif //[ custom_policy -template< typename Result > +template struct custom_policy { static Result abort() @@ -182,17 +165,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. } @@ -200,7 +183,7 @@ struct custom_policy //] #if defined(__GNUC__) -#pragma GCC diagnostic pop +# pragma GCC diagnostic pop #endif #undef MOCK_ERROR_POLICY diff --git a/doc/example/getting_started.cpp b/doc/example/getting_started.cpp index 4cf11fe..fa89366 100644 --- a/doc/example/getting_started.cpp +++ b/doc/example/getting_started.cpp @@ -7,15 +7,15 @@ // http://www.boost.org/LICENSE_1_0.txt) #include -#include #include +#include std::function error_handler_abort; std::function error_handler_pass; std::function error_handler_call; std::function error_handler_fail; -template< typename Result > +template struct configurable_mock_error { static Result abort() @@ -24,25 +24,22 @@ struct configurable_mock_error return Result(); } - static void pass( const char* file, int line ) - { - error_handler_pass(file, line); - } + static void pass(const char* file, int line) { error_handler_pass(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) { std::stringstream s; s << context; - error_handler_call( s.str(), file, line ); + error_handler_call(s.str(), file, line); } - template< typename Context > - static void fail( const char* message, const Context& context, const char* file = "", int line = 0 ) + template + static void fail(const char* message, const Context& context, const char* file = "", int line = 0) { std::stringstream s; s << context; - error_handler_fail( message, s.str(), file, line ); + error_handler_fail(message, s.str(), file, line); } }; @@ -50,8 +47,8 @@ struct configurable_mock_error #define MOCK_USE_BOOST_TEST //[ prerequisite -#include #include +#include //] #include "calculator.hpp" #include "mock_view.hpp" @@ -69,124 +66,114 @@ struct Fixture BOOST_FIXTURE_TEST_SUITE(GettingStarted, Fixture) -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_reset ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_reset) { 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_expect ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_expect) { 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_then_1_plus_0_is_1 ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_then_1_plus_0_is_1) { 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( add_several_numbers_in_sequences ) +BOOST_AUTO_TEST_CASE(add_several_numbers_in_sequences) { 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 BOOST_AUTO_TEST_SUITE_END() -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_BASE_CLASS(mock_view, view) { - MOCK_METHOD( display, 1 ) + MOCK_METHOD(display, 1) }; class calculator { view& v; -public: - calculator( view& v ): v(v) {} - void add( int a, int b ){ v.display(a + b); } +public: + calculator(view& v) : v(v) {} + + void add(int a, int b) { v.display(a + b); } }; -struct CatchFailureFixture: Fixture +struct CatchFailureFixture : Fixture { static bool aborted; static std::string fail_msg; - static void abort() - { - aborted = true; - } - static void fail( const std::string& message, const std::string&, const char* = "", int = 0 ){ - fail_msg = message; - } + static void abort() { aborted = true; } + static void fail(const std::string& message, const std::string&, const char* = "", int = 0) { fail_msg = message; } CatchFailureFixture() { error_handler_abort = abort; @@ -201,22 +188,21 @@ struct CatchFailureFixture: Fixture bool CatchFailureFixture::aborted = false; std::string CatchFailureFixture::fail_msg; -struct AssertMissingAction: CatchFailureFixture{ - void teardown(){ - assert_failure("missing action"); - } +struct AssertMissingAction : CatchFailureFixture +{ + void teardown() { assert_failure("missing action"); } }; -BOOST_FIXTURE_TEST_SUITE( MissingReturnActionSuite, AssertMissingAction) +BOOST_FIXTURE_TEST_SUITE(MissingReturnActionSuite, AssertMissingAction) //[ action_test -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero_with_action ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_with_action) { - 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 BOOST_AUTO_TEST_SUITE_END() diff --git a/doc/example/limitations_const_parameter_warning.cpp b/doc/example/limitations_const_parameter_warning.cpp index 88a163c..8f0de3b 100644 --- a/doc/example/limitations_const_parameter_warning.cpp +++ b/doc/example/limitations_const_parameter_warning.cpp @@ -6,53 +6,46 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#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 +class derived : public base { -//[ 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 ) - }; +public: + virtual void method(const int); +}; + +void derived::method(int) {} //] -} +} // namespace limitations_const_parameter_warning_explanation + +namespace { +//[ 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) +}; +//] +} // namespace BOOST_AUTO_TEST_CASE(check_method_stub_is_called) { mock_base b; MOCK_EXPECT(b.method).once().with(1); // Example user code taking a base* (or smart pointer variant) - auto callMethod = [](base* bPtr){ bPtr->method(1); }; + auto callMethod = [](base* bPtr) { bPtr->method(1); }; callMethod(&b); } diff --git a/doc/example/limitations_literal_zero.cpp b/doc/example/limitations_literal_zero.cpp index badd1c2..c838d23 100644 --- a/doc/example/limitations_literal_zero.cpp +++ b/doc/example/limitations_literal_zero.cpp @@ -6,35 +6,34 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#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_3 - MOCK_EXPECT( m.method ).with( nullptr ); -//] + //[ 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); + //] + //[ limitations_literal_zero_solution_3 + MOCK_EXPECT(m.method).with(nullptr); + //] } diff --git a/doc/example/limitations_non_virtual_method.cpp b/doc/example/limitations_non_virtual_method.cpp index 27e1899..01c92d3 100644 --- a/doc/example/limitations_non_virtual_method.cpp +++ b/doc/example/limitations_non_virtual_method.cpp @@ -6,8 +6,8 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include +#include //[ limitations_non_virtual_method_problem class base @@ -19,9 +19,9 @@ public: //] //[ limitations_non_virtual_method_problem_2 -MOCK_BASE_CLASS( mock_base, base ) +MOCK_BASE_CLASS(mock_base, base) { - MOCK_METHOD( method, 0 ) + MOCK_METHOD(method, 0) }; //] diff --git a/doc/example/limitations_protected_private_method.cpp b/doc/example/limitations_protected_private_method.cpp index 887b10f..ed969d1 100644 --- a/doc/example/limitations_protected_private_method.cpp +++ b/doc/example/limitations_protected_private_method.cpp @@ -6,31 +6,36 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include +#include -namespace -{ +namespace { //[ limitations_protected_private_method_problem - class base +class base +{ +public: + void call() { - public: - void call(){ method_1(); method_2(); } - protected: - virtual void method_1() = 0; - private: - virtual void method_2() = 0; - }; + method_1(); + method_2(); + } + +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 BOOST_AUTO_TEST_CASE(mocked_methods_are_called) { diff --git a/doc/example/limitations_template_base_class_method.cpp b/doc/example/limitations_template_base_class_method.cpp index b8e6839..e026a25 100644 --- a/doc/example/limitations_template_base_class_method.cpp +++ b/doc/example/limitations_template_base_class_method.cpp @@ -6,30 +6,29 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include +#include -namespace -{ +namespace { //[ limitations_template_base_class_method_problem - template< typename T > - class base - { - public: - virtual ~base() = default; +template +class base +{ +public: + virtual ~base() = default; - 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, 0, void() ) - }; +template +MOCK_BASE_CLASS(mock_base, base) +{ + MOCK_METHOD(method, 0, void()) +}; //] -} +} // namespace BOOST_AUTO_TEST_CASE(call_method_from_templated_class) { diff --git a/doc/example/limitations_template_method.cpp b/doc/example/limitations_template_method.cpp index 598934e..3ca0629 100644 --- a/doc/example/limitations_template_method.cpp +++ b/doc/example/limitations_template_method.cpp @@ -6,32 +6,31 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include +#include -namespace limitations_template_method_problem -{ +namespace limitations_template_method_problem { //[ limitations_template_method_problem class concept_class { 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_CLASS(mock_concept) { - MOCK_METHOD( method, 1, void( int ), method_int ) - MOCK_METHOD( method, 1, void( const char* ), method_string ) + MOCK_METHOD(method, 1, void(int), method_int) + MOCK_METHOD(method, 1, void(const char*), method_string) }; //] @@ -42,46 +41,45 @@ BOOST_AUTO_TEST_CASE(mocked_templated_methods_are_called) MOCK_EXPECT(b.method_string).once().with(mock::equal(std::string("string"))); function_under_test(b); } -} +} // namespace limitations_template_method_problem -namespace limitations_template_method_problem_2 -{ +namespace limitations_template_method_problem_2 { //[ limitations_template_method_problem_2 class concept_class { 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(); } @@ -94,4 +92,4 @@ BOOST_AUTO_TEST_CASE(dispatch_methods_are_called) MOCK_EXPECT(b.create_string).once().returns(""); function_under_test(b); } -} +} // namespace limitations_template_method_problem_2 diff --git a/doc/example/limitations_throw_specifier.cpp b/doc/example/limitations_throw_specifier.cpp index 1c72731..5c1e872 100644 --- a/doc/example/limitations_throw_specifier.cpp +++ b/doc/example/limitations_throw_specifier.cpp @@ -6,31 +6,27 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#include #include +#include -namespace -{ +namespace { //[ limitations_throw_specifier_problem - struct base_class - { - virtual ~base_class() = default; +struct base_class +{ + virtual ~base_class() = default; - virtual void method() throw() = 0; - }; + virtual void method() throw() = 0; +}; //] //[ limitations_throw_specifier_solution - MOCK_BASE_CLASS( mock_class, base_class ) - { - void method() throw() override - { - method_proxy(); - } - MOCK_METHOD( method_proxy, 0, void(), method ) - }; +MOCK_BASE_CLASS(mock_class, base_class) +{ + void method() throw() override { method_proxy(); } + MOCK_METHOD(method_proxy, 0, void(), method) +}; //] -} +} // namespace BOOST_AUTO_TEST_CASE(call_method_proxy) { diff --git a/doc/example/mock_view.hpp b/doc/example/mock_view.hpp index 0633ae5..b2ba52a 100644 --- a/doc/example/mock_view.hpp +++ b/doc/example/mock_view.hpp @@ -9,14 +9,14 @@ #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) }; -//] + //] #endif // MOCK_VIEW diff --git a/doc/example/motivation.cpp b/doc/example/motivation.cpp index aadc975..100e3cb 100644 --- a/doc/example/motivation.cpp +++ b/doc/example/motivation.cpp @@ -6,42 +6,41 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#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); }; //] -int calculator::add( int a, int b ){ return a + b; } +int calculator::add(int a, int b) +{ + return a + 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; @@ -52,26 +51,26 @@ public: //] //[ zero_plus_zero_is_zero_without_mock_object -BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero_without_mock_object ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_without_mock_object) { 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_with_mock_object ) +BOOST_AUTO_TEST_CASE(zero_plus_zero_is_zero_with_mock_object) { 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 0e8b779..5d18946 100644 --- a/doc/example/patterns_async_call.cpp +++ b/doc/example/patterns_async_call.cpp @@ -7,68 +7,66 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ async_call_problem -namespace mock_test +namespace mock_test { +class base_class { - class base_class - { - public: - virtual void method() = 0; - }; +public: + virtual void method() = 0; +}; - class my_class - { - base_class& b; - public: - explicit my_class( base_class& ); +class my_class +{ + base_class& b; - void flush(); // repetitively calling this method will in turn call base_class::method at some point - }; -} +public: + explicit my_class(base_class&); + + void flush(); // repetitively calling this method will in turn call base_class::method at some point +}; +} // namespace mock_test //] -namespace mock_test +namespace mock_test { +my_class::my_class(base_class& b) : b(b) {} +void my_class::flush() { - my_class::my_class( base_class& b): b(b){} - void my_class::flush() - { - static int counter = 7; - if(--counter == 0) - b.method(); - } + static int counter = 7; + if(--counter == 0) + b.method(); } +} // namespace mock_test //[ async_call_solution +#include #include #include -#include -namespace mock_test +namespace mock_test { +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(); - } + --attempts; + boost::this_thread::sleep(boost::posix_time::milliseconds(sleep)); + flush(); } +} - MOCK_BASE_CLASS( mock_base_class, base_class ) - { - MOCK_METHOD( method, 0 ) - }; +MOCK_BASE_CLASS(mock_base_class, base_class) +{ + MOCK_METHOD(method, 0) +}; -BOOST_AUTO_TEST_CASE( method_is_called ) +BOOST_AUTO_TEST_CASE(method_is_called) { mock_base_class m; - my_class c( m ); + my_class c(m); bool done = false; - MOCK_EXPECT( m.method ).once().calls( [&done](){ done = true; } ); - check( done, [&c](){ c.flush(); } ); // just wait on done, flushing from time to time + MOCK_EXPECT(m.method).once().calls([&done]() { done = true; }); + check(done, [&c]() { c.flush(); }); // just wait on done, flushing from time to time } -} +} // namespace mock_test //] diff --git a/doc/example/patterns_invoke_functor.cpp b/doc/example/patterns_invoke_functor.cpp index a66e471..f22b32a 100644 --- a/doc/example/patterns_invoke_functor.cpp +++ b/doc/example/patterns_invoke_functor.cpp @@ -13,14 +13,17 @@ static void someFunctor(int newValue); //[ invoke_functor_problem #include - class base_class - { - public: - virtual void method( const std::function< void( int ) >& functor ) = 0; - }; +class base_class +{ +public: + virtual void method(const std::function& functor) = 0; +}; - // the function will call 'method' with a functor to be applied - void function(base_class& c) { c.method(someFunctor); } +// the function will call 'method' with a functor to be applied +void function(base_class& c) +{ + c.method(someFunctor); +} //] // Some test-only code to verify what is described @@ -42,21 +45,22 @@ struct CheckReceivedValue #define BOOST_AUTO_TEST_CASE(name) BOOST_FIXTURE_TEST_CASE(name, CheckReceivedValue) //[ invoke_functor_solution -#include #include +#include -namespace +namespace { +MOCK_BASE_CLASS(mock_class, base_class) { - MOCK_BASE_CLASS( mock_class, base_class ) - { - MOCK_METHOD( method, 1 ) - }; -} + MOCK_METHOD(method, 1) +}; +} // namespace -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( [](const auto &functor){ functor(42); } ); // whenever 'method' is called, invoke the functor with 42 - function( mock ); + MOCK_EXPECT(mock.method).calls([](const auto& functor) { + functor(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 13bec6b..959dc78 100644 --- a/doc/example/patterns_quick_constraint.cpp +++ b/doc/example/patterns_quick_constraint.cpp @@ -7,31 +7,28 @@ // http://www.boost.org/LICENSE_1_0.txt) //[ quick_constraint_problem -#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 @@ -39,18 +36,21 @@ 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 - { - std::ostringstream s; - s << actual; - return s.str() == expected; - } -} // mock +bool operator==(const my_class& actual, + const std::string& expected) // the first part of the trick is to compare to a string +{ + std::ostringstream s; + s << actual; + return s.str() == 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 be28298..86d5345 100644 --- a/doc/example/patterns_retrieve_cref.cpp +++ b/doc/example/patterns_retrieve_cref.cpp @@ -7,55 +7,59 @@ // 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 //] -namespace +namespace { +static base_class* global_b = nullptr; +my_class::my_class(base_class& b) { - static base_class* global_b = nullptr; - my_class::my_class( base_class& b){ global_b = &b; } - void my_class::process() - { - int secret_value = 42; - global_b->method(secret_value); - global_b->method(secret_value); - } + global_b = &b; } +void my_class::process() +{ + int secret_value = 42; + global_b->method(secret_value); + global_b->method(secret_value); +} +} // namespace //[ retrieve_cref_solution -#include #include +#include -namespace +namespace { +MOCK_BASE_CLASS(mock_base_class, base_class) { - MOCK_BASE_CLASS( mock_base_class, base_class ) - { - MOCK_METHOD( method, 1 ) - }; -} + MOCK_METHOD(method, 1) +}; +} // namespace -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( std::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(std::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 7918531..0d6d82c 100644 --- a/doc/example/patterns_static_objects.cpp +++ b/doc/example/patterns_static_objects.cpp @@ -12,37 +12,36 @@ #define MOCK_MAKE_TEST_PASS 1 #if MOCK_MAKE_TEST_PASS -#undef BOOST_AUTO_TEST_CASE -#define BOOST_AUTO_TEST_CASE(name) BOOST_FIXTURE_TEST_CASE(name, mock::cleanup) +# undef BOOST_AUTO_TEST_CASE +# define BOOST_AUTO_TEST_CASE(name) BOOST_FIXTURE_TEST_CASE(name, mock::cleanup) #endif //[ static_objects_problem -#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' outlives 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' outlives 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 //] @@ -51,25 +50,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 9ece937..6d4f937 100644 --- a/doc/example/rationale.cpp +++ b/doc/example/rationale.cpp @@ -6,9 +6,9 @@ // (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 #include #include #include @@ -16,18 +16,20 @@ // Dummy to detect if the assertion unexpectedly succeeded to test what is explained #undef BOOST_CHECK_THROW -#define BOOST_CHECK_THROW(expr, exc) \ - try { \ - expr; \ - } catch(const exc&) { \ - std::cerr << "Exception thrown but should not"; \ - } +#define BOOST_CHECK_THROW(expr, exc) \ + try \ + { \ + expr; \ + } catch(const exc&) \ + { \ + std::cerr << "Exception thrown but should not"; \ + } //[ 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 ae6ca2e..adec0b3 100644 --- a/doc/example/reference.cpp +++ b/doc/example/reference.cpp @@ -6,948 +6,924 @@ // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#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() = default; - virtual void method( int ) = 0; + virtual void method(int) = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) +MOCK_BASE_CLASS(mock_class, base_class) { - MOCK_METHOD( method, 1 ) // only possible when referring unambiguously to a base class method + 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() = default; - virtual void method( int, const std::string& ) = 0; - virtual void method( float ) = 0; + virtual void method(int, const std::string&) = 0; + virtual void method(float) = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) +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_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() = default; - virtual void method( float ) = 0; - virtual void method( float ) const = 0; + virtual void method(float) = 0; + virtual void method(float) const = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) +MOCK_BASE_CLASS(mock_class, base_class) { - MOCK_METHOD( method, 1, void( float ) ) // this generates both const and non-const versions + 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() = default; - virtual void method( float ) = 0; - virtual void method( float ) const = 0; + virtual void method(float) = 0; + virtual void method(float) const = 0; }; -MOCK_BASE_CLASS( mock_class, base_class ) +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_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() = default; - virtual void method( float ) = 0; + 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_CLASS(mock_class) { - MOCK_NON_CONST_METHOD( operator=, 1, mock_class&( const mock_class& ), assignment ) // operators require a custom identifier + 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 ) +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 + 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_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_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_CLASS(mock_class) { - MOCK_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention + 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_CLASS(mock_class) { - MOCK_STATIC_METHOD( method, 1, float( int ) ) + 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 ) +template +MOCK_CLASS(mock_class) { - MOCK_STATIC_METHOD_TPL( method, 1, void( T ) ) + 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_CLASS(mock_class) { - MOCK_STATIC_METHOD( __stdcall method, 0, void(), method ) // all parameters must be provided when specifying a different calling convention + 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_CLASS(mock_class) { - MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) + 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 ) +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 ) + 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_CLASS(mock_class) { - MOCK_CONSTRUCTOR( __stdcall mock_class, 0, (), constructor ) + 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_CLASS(mock_class) { - MOCK_DESTRUCTOR( ~mock_class, destructor ) + 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_CLASS(mock_class) { - MOCK_DESTRUCTOR( __stdcall ~mock_class, destructor ) + 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_CLASS(mock_class) { - MOCK_CONVERSION_OPERATOR( operator, int, conversion_to_int ) - MOCK_CONST_CONVERSION_OPERATOR( operator, const std::string&, conversion_to_string ) + 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 ) +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 ) + 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_CLASS(mock_class) { - MOCK_CONVERSION_OPERATOR( __stdcall operator, int, conversion_to_int ) + 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, void( int ) ) +MOCK_FUNCTION(f, 1, void(int)) -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_function ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_function) { MOCK_EXPECT(f).once().with(3); - 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 ) ); - MOCK_EXPECT(f).once().with(3); - f( 3 ); + MOCK_FUNCTOR(f, void(int)); + MOCK_EXPECT(f).once().with(3); + 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( f, void( T ) ); + MOCK_FUNCTOR(f, void(T)); }; -BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor_inside_a_class ) +BOOST_AUTO_TEST_CASE(demonstrates_instantiating_a_mock_functor_inside_a_class) { - mock_class< int > c; + mock_class c; MOCK_EXPECT(c.f).once().with(3); - c.f( 3 ); + c.f(3); } //] -} +} // namespace functor_example_2 -namespace expectation_example_1 -{ +namespace expectation_example_1 { //[ expectation_example_1 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 1, int( int ), method ) - MOCK_METHOD( method, 2, void( const std::string&, float ), method2 ) + 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 !")); BOOST_TEST(c.method(0) == 42); BOOST_CHECK_THROW(c.method("not ok", 1.f), std::runtime_error); BOOST_CHECK_THROW(c.method("not ok", 2.f), std::runtime_error); } //] -} +} // namespace expectation_example_1 -namespace invocation_example_1 -{ +namespace invocation_example_1 { //[ invocation_example_1 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 2, void( int, const std::string& ) ) - MOCK_METHOD( method2, 1, void( int ) ) + MOCK_METHOD(method, 2, void(int, const std::string&)) + MOCK_METHOD(method2, 1, void(int)) }; -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.method2 ); // can be called an unlimited number of times + MOCK_EXPECT(c.method).once(); // can only be called once + MOCK_EXPECT(c.method2); // can be called an unlimited number of times c.method(42, "Hello world!"); c.method2(42); c.method2(42); c.method2(42); } //] -} +} // 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(); f(42, "Hello world!"); } //] -} +} // 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(); f(42); } //] -} +} // namespace invocation_example_3 -namespace invocation_example_4 -{ +namespace invocation_example_4 { //[ invocation_example_4 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_STATIC_METHOD( method1, 1, void( int ) ) - MOCK_STATIC_METHOD( method2, 1, void( int ) ) + MOCK_STATIC_METHOD(method1, 1, void(int)) + MOCK_STATIC_METHOD(method2, 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.method1 ).once(); - MOCK_EXPECT( mock_class::method2 ).once(); // does the same (but for the other method) + MOCK_EXPECT(c.method1).once(); + MOCK_EXPECT(mock_class::method2).once(); // does the same (but for the other method) c.method1(42); c.method2(42); } //] -} +} // namespace invocation_example_4 -namespace constraints_example_1 -{ +namespace constraints_example_1 { //[ constraints_example_1 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method1, 2, void( int, const std::string& ) ) - MOCK_METHOD( method2, 2, void( int, const std::string& ) ) + MOCK_METHOD(method1, 2, void(int, const std::string&)) + MOCK_METHOD(method2, 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.method1 ).with( mock::equal( 3 ), mock::equal( "some string" ) ); - MOCK_EXPECT( c.method2 ).with( 3, "some string" ); // similar to the previous one using short-cuts - c.method1(3, "some string"); - c.method2(3, "some string"); + mock_class c; + MOCK_EXPECT(c.method1).with(mock::equal(3), mock::equal("some string")); + MOCK_EXPECT(c.method2).with(3, "some string"); // similar to the previous one using short-cuts + c.method1(3, "some string"); + c.method2(3, "some string"); } //] -} +} // namespace constraints_example_1 -namespace constraints_example_2 -{ +namespace constraints_example_2 { //[ constraints_example_2 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 1, void( int ) ) + 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 ); - c.method(42); + mock_class c; + MOCK_EXPECT(c.method).with(&custom_constraint); + c.method(42); } //] -} +} // namespace constraints_example_2 -namespace constraints_example_3 -{ +namespace constraints_example_3 { //[ constraints_example_3 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 1, void( int ) ) + 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 - c.method(42); + mock_class c; + MOCK_EXPECT(c.method).with( + std::bind1st(std::ptr_fun(&custom_constraint), 42)); // std::ptr_fun creates an std::unary_function + c.method(42); } //] -} +} // namespace constraints_example_3 -namespace constraints_example_4 -{ +namespace constraints_example_4 { //[ constraints_example_4 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 1, void( int ) ) + 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_std_bind ) +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_custom_constraint_with_std_bind) { - mock_class c; - using namespace std::placeholders; - MOCK_EXPECT( c.method ).with( std::bind( &custom_constraint, 42, _1 ) ); - c.method(42); + mock_class c; + using namespace std::placeholders; + MOCK_EXPECT(c.method).with(std::bind(&custom_constraint, 42, _1)); + c.method(42); } //] -} +} // 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_CLASS(mock_class) { - MOCK_METHOD( method, 1, void( int ) ) + 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 ); - c.method(42); + mock_class c; + MOCK_EXPECT(c.method).with(boost::lambda::_1 == 42); + c.method(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_CLASS(mock_class) { - MOCK_METHOD( method1, 1, void( int ) ) - MOCK_METHOD( method2, 1, void( int ) ) + MOCK_METHOD(method1, 1, void(int)) + MOCK_METHOD(method2, 1, void(int)) }; -BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_phoenix ) -{ - mock_class c; - MOCK_EXPECT( c.method1 ).with( boost::phoenix::arg_names::arg1 == 42 ); - MOCK_EXPECT( c.method2 ).with( boost::phoenix::arg_names::_1 == 42 ); - c.method1(42); - c.method2(42); -} -//] -} - -namespace constraints_example_7 -{ -//[ constraints_example_7 -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_custom_constraint_with_boost_phoenix) { mock_class c; - MOCK_EXPECT( c.method ).with( []( int actual ) { return 42 == actual; } ); + MOCK_EXPECT(c.method1).with(boost::phoenix::arg_names::arg1 == 42); + MOCK_EXPECT(c.method2).with(boost::phoenix::arg_names::_1 == 42); + c.method1(42); + c.method2(42); +} +//] +} // namespace constraints_example_6 + +namespace constraints_example_7 { +//[ constraints_example_7 +MOCK_CLASS(mock_class) +{ + MOCK_METHOD(method, 1, void(int)) +}; + +BOOST_AUTO_TEST_CASE(demonstrates_adding_a_constraint_with_cxx11_lambda) +{ + mock_class c; + MOCK_EXPECT(c.method).with([](int actual) { return 42 == actual; }); c.method(42); } //] -} +} // namespace constraints_example_7 -namespace constraints_example_8 -{ +namespace constraints_example_8 { //[ constraints_example_8 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 2, void( int, const std::string& ) ) + 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( "" ) ); - c.method(3, "Hello World!"); + mock_class c; + MOCK_EXPECT(c.method).with(mock::less(4) && mock::greater(2), !mock::equal("")); + c.method(3, "Hello World!"); } //] -} +} // namespace constraints_example_8 -namespace constraints_example_9 -{ +namespace constraints_example_9 { //[ constraints_example_9 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 2, void( const std::string&, std::size_t ) ) + 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 ); - c.method("1234", 4); + mock_class c; + MOCK_EXPECT(c.method).with(&custom_constraint); + c.method("1234", 4); } //] -} +} // namespace constraints_example_9 -namespace sequence_example_1 -{ +namespace sequence_example_1 { //[ sequence_example_1 -MOCK_CLASS( mock_class_1 ) +MOCK_CLASS(mock_class_1) { - MOCK_METHOD( method_1, 0, void() ) + MOCK_METHOD(method_1, 0, void()) }; -MOCK_CLASS( mock_class_2 ) +MOCK_CLASS(mock_class_2) { - MOCK_METHOD( method_2, 0, void() ) + MOCK_METHOD(method_2, 0, void()) }; -MOCK_CLASS( mock_class_3 ) +MOCK_CLASS(mock_class_3) { - MOCK_METHOD( method_3, 0, void() ) + 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 - c_2.method_2(); - c_1.method_1(); - c_3.method_3(); + 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 + c_2.method_2(); + c_1.method_1(); + c_3.method_3(); } //] -} +} // namespace sequence_example_1 -namespace action_example_1 -{ +namespace action_example_1 { //[ action_example_1 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 1, int( int ) ) + 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 ).once().returns( 42 ); - MOCK_EXPECT( c.method ).once().moves( 42 ); // returns by moving the value - MOCK_EXPECT( c.method ).once().throws( std::runtime_error( "error !" ) ); - MOCK_EXPECT( c.method ).once().calls( &function ); // forwards 'method' parameter to 'function' - MOCK_EXPECT( c.method ).once().calls( std::bind( &function, 42 ) ); // drops 'method' parameter and binds 42 as parameter to 'function' - MOCK_EXPECT( c.method ).once().calls( []( int i ) { return i; } ); // uses a C++11 lambda - BOOST_TEST(c.method(0) == 42); - BOOST_TEST(c.method(1) == 42); - BOOST_CHECK_THROW(c.method(0), std::runtime_error); - BOOST_TEST(c.method(2) == 2); - BOOST_TEST(c.method(3) == 42); - BOOST_TEST(c.method(4) == 4); + mock_class c; + MOCK_EXPECT(c.method).once().returns(42); + MOCK_EXPECT(c.method).once().moves(42); // returns by moving the value + MOCK_EXPECT(c.method).once().throws(std::runtime_error("error !")); + MOCK_EXPECT(c.method).once().calls(&function); // forwards 'method' parameter to 'function' + MOCK_EXPECT(c.method).once().calls( + std::bind(&function, 42)); // drops 'method' parameter and binds 42 as parameter to 'function' + MOCK_EXPECT(c.method).once().calls([](int i) { return i; }); // uses a C++11 lambda + BOOST_TEST(c.method(0) == 42); + BOOST_TEST(c.method(1) == 42); + BOOST_CHECK_THROW(c.method(0), std::runtime_error); + BOOST_TEST(c.method(2) == 2); + BOOST_TEST(c.method(3) == 42); + BOOST_TEST(c.method(4) == 4); } //] -} +} // namespace action_example_1 -namespace action_example_2 -{ +namespace action_example_2 { //[ action_example_2 -MOCK_CLASS( mock_class ) +MOCK_CLASS(mock_class) { - MOCK_METHOD( method, 0, int&() ) + 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( std::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(std::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_CLASS(mock_class) { - MOCK_METHOD( method, 0, void() ) + 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_CLASS(mock_class) { - MOCK_STATIC_METHOD( method, 0, void() ) + 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_CLASS(mock_class) { - MOCK_METHOD( method, 0, void() ) + 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_CLASS(mock_class) { - MOCK_STATIC_METHOD( method, 0, void() ) + 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 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..77c753b 100644 --- a/include/turtle/catch.hpp +++ b/include/turtle/catch.hpp @@ -11,34 +11,33 @@ #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 f23084d..b2a0f68 100644 --- a/include/turtle/config.hpp +++ b/include/turtle/config.hpp @@ -14,29 +14,28 @@ #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 #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(__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 4708cf8..126ce5d 100644 --- a/include/turtle/constraint.hpp +++ b/include/turtle/constraint.hpp @@ -12,243 +12,284 @@ #include "config.hpp" #include "log.hpp" #include "unwrap_reference.hpp" -#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 \ + { \ + (void)actual; \ + 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 \ - { \ - (void) actual; 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(std::forward(e##n)) -#define MOCK_CONSTRAINT_ASSIGN(z, n, d) \ - expected##n( std::forward< T##n >(e##n) ) +#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) mock::unwrap_ref(expected##n) -#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) \ - mock::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) \ - std::decay_t< const T##n > +#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) std::decay_t #define MOCK_CONSTRAINT_CREF_PARAM(z, n, Args) \ - const mock::unwrap_reference_t< Expected_##n >& \ - BOOST_PP_ARRAY_ELEM(n, Args) + const mock::unwrap_reference_t& BOOST_PP_ARRAY_ELEM(n, Args) -#define MOCK_CONSTRAINT_ARG(z, n, Args) \ - T##n&& BOOST_PP_ARRAY_ELEM(n, Args) +#define MOCK_CONSTRAINT_ARG(z, n, Args) T##n&& BOOST_PP_ARRAY_ELEM(n, Args) -#define MOCK_CONSTRAINT_ARGS(z, n, Args) \ - T##n&& e##n +#define MOCK_CONSTRAINT_ARGS(z, n, Args) T##n&& e##n -#define MOCK_CONSTRAINT_PARAM(z, n, Args) \ - std::forward< T##n >( BOOST_PP_ARRAY_ELEM(n, Args) ) +#define MOCK_CONSTRAINT_PARAM(z, n, Args) std::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 BOOST_MSVC -# define MOCK_VARIADIC_SIZE(...) \ +# 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,),) + 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(...) \ +# 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,) + 32, \ + 31, \ + 30, \ + 29, \ + 28, \ + 27, \ + 26, \ + 25, \ + 24, \ + 23, \ + 22, \ + 21, \ + 20, \ + 19, \ + 18, \ + 17, \ + 16, \ + 15, \ + 14, \ + 13, \ + 12, \ + 11, \ + 10, \ + 9, \ + 8, \ + 7, \ + 6, \ + 5, \ + 4, \ + 3, \ + 2, \ + 1, ) #endif // BOOST_MSVC -#define MOCK_VARIADIC_SIZE_I( \ - e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, \ - e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, \ - e25, e26, e27, e28, e29, e30, e31, size, ...) size +#define MOCK_VARIADIC_SIZE_I(e0, \ + e1, \ + e2, \ + e3, \ + e4, \ + e5, \ + e6, \ + e7, \ + e8, \ + e9, \ + e10, \ + e11, \ + e12, \ + e13, \ + e14, \ + e15, \ + e16, \ + e17, \ + e18, \ + e19, \ + e20, \ + e21, \ + e22, \ + e23, \ + e24, \ + e25, \ + e26, \ + e27, \ + e28, \ + e29, \ + e30, \ + e31, \ + size, \ + ...) \ + size #define MOCK_CONSTRAINT_AUX_AUX(Name, n, Array) \ - MOCK_CONSTRAINT_EXT( \ - Name, n, \ - BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \ - BOOST_PP_ARRAY_ELEM(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_CONSTRAINT_HPP_INCLUDED diff --git a/include/turtle/constraints.hpp b/include/turtle/constraints.hpp index f29495a..14e5458 100644 --- a/include/turtle/constraints.hpp +++ b/include/turtle/constraints.hpp @@ -12,300 +12,243 @@ #include "config.hpp" #include "constraint.hpp" #include "detail/move_helper.hpp" -#include "unwrap_reference.hpp" #include "detail/void_t.hpp" +#include "unwrap_reference.hpp" #include #if BOOST_VERSION >= 107000 -#include +# include #else -#include +# include #endif #include #include #include -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 std::common_type_t< T1, T2 > common_type; - return boost::math::fpc::close_at_tolerance< common_type >( - tolerance, boost::math::fpc::FPC_STRONG )( t1, t2 ); + typedef std::common_type_t 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 -{ +namespace detail { template - struct has_equal_to: std::false_type + struct has_equal_to : std::false_type {}; template - struct has_equal_to() == std::declval())>>: std::true_type + struct has_equal_to() == std::declval())>> : std::true_type {}; - template< typename Expected > + template struct equal { - explicit equal( Expected expected ) - : expected_( expected ) - {} - template< typename Actual > - bool operator()( const Actual& actual, - std::enable_if_t< - has_equal_to< - Actual, - unwrap_reference_t< Expected > - >::value - >* = 0 ) const + explicit equal(Expected expected) : expected_(expected) {} + template + bool operator()(const Actual& actual, + std::enable_if_t>::value>* = 0) const { - return actual == unwrap_ref( expected_ ); + return actual == unwrap_ref(expected_); } - template< typename Actual > - bool operator()( const Actual& actual, - std::enable_if_t< - !has_equal_to< - Actual, - unwrap_reference_t< Expected > - >::value - >* = 0 ) const + template + bool operator()(const Actual& actual, + std::enable_if_t>::value>* = 0) const { - return actual && *actual == unwrap_ref( expected_ ); + return actual && *actual == 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_( std::addressof( unwrap_ref( expected ) ) ) - {} - template< typename Actual > - bool operator()( const Actual& actual ) const + explicit same(const Expected& expected) : expected_(std::addressof(unwrap_ref(expected))) {} + template + bool operator()(const Actual& actual) const { - return std::addressof( actual ) == expected_; + return std::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 unwrap_reference_t< Expected >* expected_; + const unwrap_reference_t* expected_; }; - template< typename Expected > + template struct retrieve { - explicit retrieve( Expected& expected ) - : expected_( std::addressof( unwrap_ref( expected ) ) ) - {} - template< typename Actual > - bool operator()( const Actual& actual, - std::enable_if_t< - !std::is_convertible< - const Actual*, - unwrap_reference_t< Expected > - >::value - >* = 0 ) const + explicit retrieve(Expected& expected) : expected_(std::addressof(unwrap_ref(expected))) {} + template + bool operator()( + const Actual& actual, + std::enable_if_t>::value>* = 0) const { *expected_ = actual; return true; } - template< typename Actual > - bool operator()( Actual&& actual, - std::enable_if_t< - !std::is_convertible< - const Actual*, - unwrap_reference_t< Expected > - >::value - >* = 0 ) const + template + bool operator()( + Actual&& actual, + std::enable_if_t>::value>* = 0) const { - *expected_ = std::move( actual ); + *expected_ = std::move(actual); return true; } - template< typename Actual > - bool operator()( Actual& actual, - std::enable_if_t< - std::is_convertible< Actual*, - unwrap_reference_t< Expected > - >::value - >* = 0 ) const + template + bool operator()(Actual& actual, + std::enable_if_t>::value>* = 0) const { - *expected_ = std::addressof( actual ); + *expected_ = std::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_) << " )"; } - unwrap_reference_t< Expected >* expected_; + unwrap_reference_t* 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 = unwrap_ref( expected_ ); + actual = unwrap_ref(expected_); return true; } - template< typename Actual > - bool operator()( Actual* actual, - std::enable_if_t< - std::is_convertible< - unwrap_reference_t< Expected >, - Actual - >::value - >* = 0 ) const + template + bool operator()(Actual* actual, + std::enable_if_t, Actual>::value>* = 0) const { - if( ! actual ) + if(!actual) return false; - *actual = unwrap_ref( expected_ ); + *actual = 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( unwrap_ref( expected_ ) ) - != std::string::npos; + return actual.find(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> equal(T&& t) +{ + return detail::equal(std::forward(t)); } - template< typename T > - constraint< detail::equal< T > > equal( T&& t ) - { - return detail::equal< T >( std::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 714d61a..7bc5fa0 100644 --- a/include/turtle/detail/action.hpp +++ b/include/turtle/detail/action.hpp @@ -14,16 +14,13 @@ #include #include -namespace mock -{ -namespace detail -{ - template< typename Result, typename Signature > +namespace mock { namespace detail { + template class action_base { private: - typedef std::function< Signature > functor_type; - typedef std::function< Result() > action_type; + typedef std::function functor_type; + typedef std::function action_type; protected: // Meant to be subclassed and not be directly used @@ -33,41 +30,29 @@ namespace detail action_base(action_base&&) = delete; action_base& operator=(const action_base&) = delete; action_base& operator=(action_base&&) = delete; + public: + const functor_type& functor() const { return f_; } + bool valid() const { return f_ || a_; } + Result trigger() const { return a_(); } - const functor_type& functor() const + void calls(const functor_type& f) { - return f_; - } - bool valid() const - { - return f_ || a_; - } - Result trigger() const - { - return a_(); - } - - 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_ = [e]() -> Result { throw e; }; } protected: - void set( const action_type& a ) - { - a_ = a; - } - template< typename Y > - void set( const std::reference_wrapper< Y >& r ) + void set(const action_type& a) { a_ = a; } + template + void set(const std::reference_wrapper& r) { a_ = [r]() -> Result { return r.get(); }; } @@ -77,26 +62,26 @@ 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( std::ref( store( v ) ) ); + this->set(std::ref(store(v))); } - template< typename Y > - void returns( const std::reference_wrapper< Y >& r ) + template + void returns(const std::reference_wrapper& r) { - this->set( r ); + this->set(r); } - template< typename Value > - void moves( Value&& v ) + template + void moves(Value&& v) { - auto vRef = std::ref( store( std::move( v ) ) ); - this->set([vRef](){ return std::move(vRef.get()); }); + auto vRef = std::ref(store(std::move(v))); + this->set([vRef]() { return std::move(vRef.get()); }); } private: @@ -107,44 +92,43 @@ namespace detail value& operator=(const value&) = delete; virtual ~value() = default; }; - template< typename T > + template struct value_imp : value { typedef std::remove_const_t> type; - template< typename U > - value_imp( U&& t ) : t_( std::forward( t ) ) + template + value_imp(U&& t) : t_(std::forward(t)) {} type t_; }; - template< typename T > - typename value_imp::type& store( T&& t ) + template + typename value_imp::type& store(T&& t) { - v_ = std::make_unique< value_imp >( std::forward( t ) ); - return static_cast< value_imp< T >& >( *v_ ).t_; + v_ = std::make_unique>(std::forward(t)); + return static_cast&>(*v_).t_; } - template< typename T > - std::remove_reference_t< Result >& store( T* t ) + template + std::remove_reference_t& store(T* t) { - v_ = std::make_unique< value_imp >( t ); - return static_cast< value_imp< Result >& >( *v_ ).t_; + v_ = std::make_unique>(t); + return static_cast&>(*v_).t_; } - std::unique_ptr< value > v_; + std::unique_ptr v_; }; - template< typename Signature > - class action< void, Signature > : public action_base< void, Signature > + template + class action : public action_base { public: action() { - this->set( [](){} ); + this->set([]() {}); } }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_ACTION_HPP_INCLUDED diff --git a/include/turtle/detail/child.hpp b/include/turtle/detail/child.hpp index 992d397..a5621fb 100644 --- a/include/turtle/detail/child.hpp +++ b/include/turtle/detail/child.hpp @@ -10,43 +10,38 @@ #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 3e46813..28fc98c 100644 --- a/include/turtle/detail/context.hpp +++ b/include/turtle/detail/context.hpp @@ -15,10 +15,7 @@ #include #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class verifiable; class context @@ -30,17 +27,16 @@ namespace detail virtual ~context() = default; - 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 d3e74bd..3f42263 100644 --- a/include/turtle/detail/expectation_template.hpp +++ b/include/turtle/detail/expectation_template.hpp @@ -8,115 +8,83 @@ #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##_( std::forward< T##n >( a##n ) ) +#define MOCK_EXPECTATION_IS_VALID(z, n, d) BOOST_PP_IF(n, &&, ) c##n##_(std::forward(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) \ - std::forward< T##n >( a##n ) +#define MOCK_EXPECTATION_PARAM(z, n, Args) std::forward(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,144 +92,103 @@ 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_( std::make_unique< unlimited >() ) - , matcher_( - std::make_unique< - default_matcher< - void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) - > - > () ) - , file_( "unknown location" ) - , line_( 0 ) + : invocation_(std::make_unique()), + matcher_(std::make_unique>()), + file_("unknown location"), line_(0) {} - expectation( const char* file, int line ) - : invocation_( std::make_unique< unlimited >() ) - , matcher_( - std::make_unique< - default_matcher< - void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) - > - > () ) - , file_( file ) - , line_( line ) + expectation(const char* file, int line) + : invocation_(std::make_unique()), + matcher_(std::make_unique>()), file_(file), + line_(line) {} - expectation(expectation &&) = default; + expectation(expectation&&) = default; expectation(expectation const&) = default; - expectation& operator=(expectation &&) = default; + expectation& operator=(expectation&&) = default; expectation& operator=(expectation const&) = default; ~expectation() { - for( auto& sequence: sequences_) - sequence->remove( this ); + for(auto& sequence : sequences_) + sequence->remove(this); } - void invoke( std::unique_ptr< invocation > i ) - { - invocation_ = std::move(i); - } + void invoke(std::unique_ptr i) { invocation_ = std::move(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_ = std::make_unique< - 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) ); + matcher_ = std::make_unique>( + 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_ = std::make_unique< - multi_matcher< - Constraint, - void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) - >>( c ); + matcher_ = std::make_unique>(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( auto& sequence: sequences_) + for(auto& sequence : sequences_) { - if( ! sequence->is_valid( this ) ) + if(!sequence->is_valid(this)) return false; } bool result = invocation_->invoke(); - for( auto& sequence: sequences_) - sequence->invalidate( this ); + for(auto& sequence : sequences_) + sequence->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: - std::unique_ptr< invocation > invocation_; - std::unique_ptr< - matcher_base< - void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) - > - > matcher_; - std::vector< std::shared_ptr > sequences_; + std::unique_ptr invocation_; + std::unique_ptr> matcher_; + std::vector> 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 b1377b9..a27923a 100644 --- a/include/turtle/detail/formatter.hpp +++ b/include/turtle/detail/formatter.hpp @@ -13,38 +13,29 @@ #include "../stream.hpp" #include -namespace mock -{ -namespace detail -{ - template< typename T > +namespace mock { namespace detail { + template struct formatter { - explicit formatter( const T& t ) - : t_( std::addressof( t ) ) - {} - void serialize( stream& s ) const - { - detail::serialize( s, *t_ ); - } + explicit formatter(const T& t) : t_(std::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 e231a95..f5ae558 100644 --- a/include/turtle/detail/function.hpp +++ b/include/turtle/detail/function.hpp @@ -10,74 +10,62 @@ #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 -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 std::reference_wrapper& r) { - e_->returns( r ); - } - template< typename Y > - void returns( const std::reference_wrapper< Y >& r ) - { - e_->returns( r ); + e_->returns(r); } E* e_; @@ -92,8 +80,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 ecf6667..c9db991 100644 --- a/include/turtle/detail/function_impl_template.hpp +++ b/include/turtle/detail/function_impl_template.hpp @@ -9,79 +9,65 @@ #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_FORWARD(z, n, d) \ - std::forward< T##n >( t##n ) +#define MOCK_FORWARD(z, n, d) std::forward(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 std::enable_shared_from_this< - function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )> > + template + class function_impl : + public verifiable, + public std::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_( std::make_shared< mutex >() ) - {} + function_impl() : context_(0), valid_(true), exceptions_(exceptions()), mutex_(std::make_shared()) {} virtual ~function_impl() { - if( valid_ && exceptions_ >= exceptions() ) + if(valid_ && exceptions_ >= exceptions()) { - for( const auto& expectation: expectations_ ) + for(const auto& expectation : expectations_) { - if( ! expectation.verify() ) + if(!expectation.verify()) { - error_type::fail( "untriggered expectation", - boost::unit_test::lazy_ostream::instance() - << lazy_context( this ) - << lazy_expectations( this ), - expectation.file(), expectation.line() ); + error_type::fail("untriggered expectation", + boost::unit_test::lazy_ostream::instance() + << lazy_context(this) << lazy_expectations(this), + expectation.file(), + expectation.line()); } } } - if( context_ ) - context_->remove( *this ); + if(context_) + context_->remove(*this); } virtual bool verify() const { - lock _( mutex_ ); - for( const auto& expectation: expectations_ ) + lock _(mutex_); + for(const auto& expectation : expectations_) { - if( ! expectation.verify() ) + if(!expectation.verify()) { valid_ = false; - error_type::fail( "verification failed", - boost::unit_test::lazy_ostream::instance() - << lazy_context( this ) - << lazy_expectations( this ), - expectation.file(), expectation.line() ); + error_type::fail("verification failed", + boost::unit_test::lazy_ostream::instance() + << lazy_context(this) << lazy_expectations(this), + expectation.file(), + expectation.line()); } } return valid_; @@ -89,115 +75,103 @@ namespace detail virtual void reset() { - lock _( mutex_ ); + lock _(mutex_); valid_ = true; - std::shared_ptr< function_impl > guard = - this->shared_from_this(); + std::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; public: - wrapper( const std::shared_ptr< mutex >& m, expectation_type& e ) - : base_type( e ) - , lock_( m ) - {} + wrapper(const std::shared_ptr& m, expectation_type& e) : base_type(e), lock_(m) {} wrapper(const wrapper&) = delete; - wrapper( wrapper&& x ) = default; + wrapper(wrapper&& x) = default; wrapper& operator=(const wrapper&) = delete; - wrapper& operator=( wrapper&& x ) = default; + wrapper& operator=(wrapper&& x) = default; wrapper& once() { - this->e_->invoke( std::make_unique< detail::once >() ); + this->e_->invoke(std::make_unique()); return *this; } wrapper& never() { - this->e_->invoke( std::make_unique< detail::never >() ); + this->e_->invoke(std::make_unique()); return *this; } - wrapper& exactly( std::size_t count ) + wrapper& exactly(std::size_t count) { - this->e_->invoke( std::make_unique< detail::exactly >( count ) ); + this->e_->invoke(std::make_unique(count)); return *this; } - wrapper& at_least( std::size_t min ) + wrapper& at_least(std::size_t min) { - this->e_->invoke( std::make_unique< detail::at_least >( min ) ); + this->e_->invoke(std::make_unique(min)); return *this; } - wrapper& at_most( std::size_t max ) + wrapper& at_most(std::size_t max) { - this->e_->invoke( std::make_unique< detail::at_most >( max ) ); + this->e_->invoke(std::make_unique(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( std::make_unique< detail::between >( min, max ) ); + this->e_->invoke(std::make_unique(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( TT&& t ) + template + void moves(TT&& t) { - this->e_->moves( std::move( t ) ); + this->e_->moves(std::move(t)); } lock lock_; @@ -206,82 +180,78 @@ namespace detail public: typedef wrapper wrapper_type; - wrapper expect( const char* file, int line ) + wrapper expect(const char* file, int line) { - lock _( mutex_ ); - expectations_.emplace_back( file, line ); + lock _(mutex_); + expectations_.emplace_back(file, line); valid_ = true; - return wrapper( mutex_, expectations_.back() ); + return wrapper(mutex_, expectations_.back()); } wrapper expect() { - lock _( mutex_ ); - expectations_.emplace_back( ); + lock _(mutex_); + expectations_.emplace_back(); 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( const auto& expectation: expectations_ ) + for(const auto& expectation : expectations_) { - if( expectation.is_valid( - BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_FORWARD, _) ) ) + if(expectation.is_valid(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_FORWARD, _))) { - if( ! expectation.invoke() ) + if(!expectation.invoke()) { - error_type::fail( "sequence failed", - MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line() ); + error_type::fail( + "sequence failed", MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); return error_type::abort(); } - if( ! expectation.valid() ) + if(!expectation.valid()) { - error_type::fail( "missing action", - MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line() ); + error_type::fail( + "missing action", MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); return error_type::abort(); } valid_ = true; - error_type::call( MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line() ); - if( expectation.functor() ) - return expectation.functor()( - BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_FORWARD, _) ); + error_type::call(MOCK_FUNCTION_CONTEXT, expectation.file(), expectation.line()); + if(expectation.functor()) + return expectation.functor()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_FORWARD, _)); return expectation.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; @@ -291,26 +261,23 @@ 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( const auto& expectation: e.impl_->expectations_ ) + for(const auto& expectation : e.impl_->expectations_) s << std::endl << expectation; return s; } const function_impl* impl_; }; - std::list< expectation_type > expectations_; + std::list expectations_; context* context_; mutable bool valid_; const int exceptions_; - const std::shared_ptr< mutex > mutex_; + const std::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 e4de743..69a0e18 100644 --- a/include/turtle/detail/function_template.hpp +++ b/include/turtle/detail/function_template.hpp @@ -8,90 +8,68 @@ #include "function_impl_template.hpp" -#define MOCK_FORWARD(z, n, d) \ - std::forward< T##n >( t##n ) +#define MOCK_FORWARD(z, n, d) std::forward(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 { 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_( std::make_shared< impl_type >() ) - {} + function() : impl_(std::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_FORWARD, _)); } - R operator()( - BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const - { - return (*impl_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_FORWARD, _) ); - } + 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: - std::shared_ptr< impl_type > impl_; + std::shared_ptr impl_; }; -} -} // mock +}} // namespace mock::detail #undef MOCK_FORWARD 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 16ce5a3..d8a8e41 100644 --- a/include/turtle/detail/group.hpp +++ b/include/turtle/detail/group.hpp @@ -11,48 +11,39 @@ #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( const auto* verifiable: verifiables_ ) - if( ! verifiable->verify() ) + for(const auto* verifiable : verifiables_) + if(!verifiable->verify()) valid = false; return valid; } void reset() { const auto verifiables = verifiables_; - for( auto* verifiable: verifiables ) - if( std::find( verifiables_.begin(), verifiables_.end(), verifiable ) != verifiables_.end() ) + for(auto* verifiable : verifiables) + if(std::find(verifiables_.begin(), verifiables_.end(), verifiable) != verifiables_.end()) verifiable->reset(); } private: - std::vector< verifiable* > verifiables_; + std::vector 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 cf37dff..5b711e2 100644 --- a/include/turtle/detail/invocation.hpp +++ b/include/turtle/detail/invocation.hpp @@ -10,14 +10,11 @@ #define MOCK_INVOCATION_HPP_INCLUDED #include "../config.hpp" -#include -#include #include +#include +#include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class invocation { public: @@ -32,66 +29,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_ << " )"; } @@ -100,40 +82,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_ << " )"; } @@ -142,12 +112,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_ << " )"; } @@ -156,17 +124,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 066cb92..bcc0699 100644 --- a/include/turtle/detail/is_functor.hpp +++ b/include/turtle/detail/is_functor.hpp @@ -13,18 +13,14 @@ #include "void_t.hpp" #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { /// Trait to return true if F is a functor that can be called with a single argument Arg - template< typename F, typename Arg, class = void > + template struct is_functor : std::false_type {}; - template< typename F, typename Arg > - struct is_functor< F, Arg, void_t()( std::declval() ) )> >: std::true_type + template + struct is_functor()(std::declval()))>> : std::true_type {}; -} -} // 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 931b8e9..8a6199d 100644 --- a/include/turtle/detail/matcher_base_template.hpp +++ b/include/turtle/detail/matcher_base_template.hpp @@ -6,18 +6,14 @@ // (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) ) > + template + class matcher_base { public: matcher_base() = default; @@ -25,19 +21,17 @@ namespace detail matcher_base& operator=(const matcher_base&) = delete; virtual ~matcher_base() = default; - 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 9d910ff..18e303a 100644 --- a/include/turtle/detail/move_helper.hpp +++ b/include/turtle/detail/move_helper.hpp @@ -11,17 +11,9 @@ #include -namespace mock -{ -namespace detail -{ - template< typename T > - using ref_arg = std::conditional< - std::is_reference< T >::value, - T, - std::add_rvalue_reference_t< T > - >; -} -} +namespace mock { namespace detail { + template + using ref_arg = std::conditional::value, T, std::add_rvalue_reference_t>; +}} // 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 793a666..d74d20d 100644 --- a/include/turtle/detail/mutex.hpp +++ b/include/turtle/detail/mutex.hpp @@ -15,65 +15,52 @@ #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 { public: - lock( const std::shared_ptr< mutex >& m ) - : m_( m ) - { - m_->lock(); - } + lock(const std::shared_ptr& m) : m_(m) { m_->lock(); } ~lock() { - if( m_ ) + if(m_) m_->unlock(); } - lock( const lock& ) = delete; - lock( lock&& x ) = default; - lock& operator=( const lock& ) = delete; - lock& operator=( lock&& x ) = default; + lock(const lock&) = delete; + lock(lock&& x) = default; + lock& operator=(const lock&) = delete; + lock& operator=(lock&& x) = default; private: - std::shared_ptr< mutex > m_; + std::shared_ptr m_; }; -} -} // mock +}} // namespace mock::detail #else // MOCK_THREAD_SAFE -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { struct mutex { mutex() = default; mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete; - void lock() - {} - void unlock() - {} + void lock() {} + void unlock() {} }; // Dummy lock classes. // Constructor + Destructor make it RAII classes for compilers and avoid unused variable warnings @@ -82,70 +69,66 @@ namespace detail scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; - scoped_lock( mutex& ) {} + scoped_lock(mutex&) {} ~scoped_lock() {} }; class lock { public: - lock( const std::shared_ptr< mutex >& ) {} + lock(const std::shared_ptr&) {} ~lock() {} lock(const lock&) = delete; - lock( lock&& ) = default; - lock& operator=( const lock& ) = delete; - lock& operator=( lock&& ) = default; + lock(lock&&) = default; + lock& operator=(const lock&) = delete; + lock& operator=(lock&&) = default; }; -} -} // 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 6f5d4eb..081aeb2 100644 --- a/include/turtle/detail/object_impl.hpp +++ b/include/turtle/detail/object_impl.hpp @@ -10,56 +10,51 @@ #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 -namespace mock -{ -namespace detail -{ - class object_impl : public context, public verifiable, - public std::enable_shared_from_this< object_impl > +namespace mock { namespace detail { + class object_impl : public context, public verifiable, public std::enable_shared_from_this { public: - object_impl() - : mutex_( std::make_shared< mutex >() ) - {} + object_impl() : mutex_(std::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_ ); - const auto it = children_.find( &v ); - if( it != children_.end() ) + lock _(mutex_); + const auto it = children_.find(&v); + if(it != children_.end()) s << it->second; else s << "?"; @@ -67,23 +62,22 @@ namespace detail virtual bool verify() const { - lock _( mutex_ ); + lock _(mutex_); return group_.verify(); } virtual void reset() { - lock _( mutex_ ); - std::shared_ptr< object_impl > guard = shared_from_this(); + lock _(mutex_); + std::shared_ptr guard = shared_from_this(); group_.reset(); } private: group group_; parent parent_; - std::map< const verifiable*, child > children_; - const std::shared_ptr< mutex > mutex_; + std::map children_; + const std::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 b37ce58..34679b4 100644 --- a/include/turtle/detail/parameter.hpp +++ b/include/turtle/detail/parameter.hpp @@ -11,58 +11,55 @@ #include "../config.hpp" -namespace mock -{ -namespace detail -{ - template< class... > +namespace mock { namespace detail { + template struct tuple; - template< std::size_t I, class T > + template struct tuple_element; - - template< std::size_t I, class H, class... T > - struct tuple_element> : tuple_element> + + template + struct tuple_element> : tuple_element> {}; - - template< class H, class... T > + + template struct tuple_element<0, tuple> { - using type = H; + using type = H; }; - template< typename Signature > + template struct result_type; - template< typename R, typename... Args > - struct result_type< R(Args...) > + template + struct result_type { using type = R; }; - template< typename Signature > + template struct function_arity; - template< typename R, typename... Args > - struct function_arity< R(Args...) > + template + struct function_arity { static constexpr size_t value = sizeof...(Args); }; - template< typename Signature > + template struct parameter_types; - template< typename R, typename... Args > - struct parameter_types< R(Args...) > + template + struct parameter_types { using type = tuple; }; - template< typename Signature, int n > + template struct parameter { static_assert(n < function_arity::value, "Function signature has not that many parameters"); - using type = typename tuple_element< n, typename parameter_types::type >::type; + using type = typename tuple_element::type>::type; }; template @@ -74,7 +71,6 @@ namespace detail }; template using parameter_type_t = typename parameter_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 aedb373..8c3352e 100644 --- a/include/turtle/detail/parent.hpp +++ b/include/turtle/detail/parent.hpp @@ -11,35 +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() = default; - parent( boost::unit_test::const_string instance, - boost::optional< type_name > type ) - : instance_( instance ) - , type_( type ) + parent(boost::unit_test::const_string instance, boost::optional 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 09c1f95..664ce0a 100644 --- a/include/turtle/detail/root.hpp +++ b/include/turtle/detail/root.hpp @@ -10,110 +10,96 @@ #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_ ); - auto 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_); + auto 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_ ); - const auto it = children_.find( &v ); - if( it != children_.end() ) + scoped_lock _(mutex_); + const auto 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_; @@ -121,14 +107,13 @@ namespace detail }; parents_t parents_; - std::map< const verifiable*, counter_child > children_; + std::map children_; 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 f53fff9..79d6fa0 100644 --- a/include/turtle/detail/sequence_impl.hpp +++ b/include/turtle/detail/sequence_impl.hpp @@ -15,49 +15,41 @@ #include #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class sequence_impl { public: - sequence_impl() - : mutex_( std::make_shared< mutex >() ) - {} + sequence_impl() : mutex_(std::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_ ); - const auto it = std::find( elements_.begin(), elements_.end(), e ); - if( it != elements_.end() ) - elements_.erase( elements_.begin(), it ); + lock _(mutex_); + const auto it = std::find(elements_.begin(), elements_.end(), e); + if(it != elements_.end()) + elements_.erase(elements_.begin(), it); } private: - std::vector< void* > elements_; - const std::shared_ptr< mutex > mutex_; + std::vector elements_; + const std::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 9df1ee2..f76c7b0 100644 --- a/include/turtle/detail/signature.hpp +++ b/include/turtle/detail/signature.hpp @@ -12,22 +12,23 @@ #include "../config.hpp" #include -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { #define MOCK_NOARG -#define MOCK_STRIP_FUNCTION_QUALIFIERS(cv, ref) \ - template< typename R, typename... Args > \ - struct strip_function_qualifiers \ - { using type = R(Args...); }; \ - template< typename R, typename... Args > \ - struct strip_function_qualifiers \ - { using type = R(Args..., ...); }; +#define MOCK_STRIP_FUNCTION_QUALIFIERS(cv, ref) \ + template \ + struct strip_function_qualifiers \ + { \ + using type = R(Args...); \ + }; \ + template \ + struct strip_function_qualifiers \ + { \ + using type = R(Args..., ...); \ + }; #define MOCK_STRIP_FUNCTION_QUALIFIERS_REF(cv) \ - MOCK_STRIP_FUNCTION_QUALIFIERS(cv,) \ - MOCK_STRIP_FUNCTION_QUALIFIERS(cv, &) \ + MOCK_STRIP_FUNCTION_QUALIFIERS(cv, ) \ + MOCK_STRIP_FUNCTION_QUALIFIERS(cv, &) \ MOCK_STRIP_FUNCTION_QUALIFIERS(cv, &&) template @@ -40,20 +41,20 @@ namespace detail #undef MOCK_STRIP_FUNCTION_QUALIFIERS #undef MOCK_STRIP_FUNCTION_QUALIFIERS_REF - template< typename M > + template struct signature; - template< typename R, typename... Args> - struct signature< R(Args...) > + template + struct signature { using type = R(Args...); }; - template< typename Sig, typename C> - struct signature< Sig(C::*) >: signature< typename strip_function_qualifiers::type > + template + struct signature : signature::type> {}; - template< typename T > + template struct base { typedef T base_type; @@ -62,16 +63,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< \ - std::remove_cv_t< std::remove_reference_t < decltype( \ - 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 c8f42d6..e1f4ae6 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&)) + singleton(singleton const&) = delete; + singleton& operator=(singleton const&) = delete; -protected: - BOOST_DEFAULTED_FUNCTION(singleton(), {}) - BOOST_DEFAULTED_FUNCTION(~singleton(), {}) -}; + protected: + singleton() = default; + ~singleton() = default; + }; -} // 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() = default +#define MOCK_SINGLETON_CONS(type) \ +private: \ + friend class mock::detail::singleton; \ + type() = default -#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 7f84193..bc97522 100644 --- a/include/turtle/detail/type_name.hpp +++ b/include/turtle/detail/type_name.hpp @@ -10,37 +10,33 @@ #define MOCK_TYPE_NAME_HPP_INCLUDED #include "../config.hpp" -#include -#include #include +#include #include +#include #include -#include #include -#include #include +#include +#include #ifdef __GNUC__ -#include -#include +# include +# include #endif -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class type_name { public: - explicit type_name( const std::type_info& info ) - : info_( &info ) - {} - friend std::ostream& operator<<( std::ostream& s, const type_name& t ) + explicit type_name(const std::type_info& 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: - static void serialize( std::ostream& s, const std::type_info& info ) + static void serialize(std::ostream& s, const std::type_info& info) { const char* name = info.name(); #ifdef __GNUC__ @@ -49,60 +45,59 @@ namespace detail { void operator()(const void* p) { std::free(const_cast(p)); } }; - std::unique_ptr< const char, Deleter > demangled( - abi::__cxa_demangle( name, 0, 0, &status )); - if( ! status && demangled ) - serialize( s, demangled.get() ); + std::unique_ptr demangled(abi::__cxa_demangle(name, 0, 0, &status)); + if(!status && demangled) + serialize(s, demangled.get()); else #endif - serialize( s, name ); + serialize(s, name); } typedef std::string::size_type size_type; - static void serialize( std::ostream& s, std::string name ) + static void serialize(std::ostream& s, std::string name) { - 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 << '>'; } - static void list( std::ostream& s, const std::string& name ) + static void list(std::ostream& s, const std::string& name) { - 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)); } - static std::string clean( std::string name ) + static std::string clean(std::string 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, "* ", "*" ); + 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; } - static size_type rfind( const std::string& name, char c ) + static size_type rfind(const std::string& name, char c) { 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; @@ -110,17 +105,16 @@ namespace detail const std::type_info* info_; }; - template< typename T > + template type_name make_type_name() { - return type_name( typeid(T) ); + return type_name(typeid(T)); } - template< typename T > - type_name make_type_name( const T& ) + template + type_name make_type_name(const T&) { - return type_name( typeid(T) ); + return type_name(typeid(T)); } -} -} // 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 3390ec9..f6f2150 100644 --- a/include/turtle/detail/verifiable.hpp +++ b/include/turtle/detail/verifiable.hpp @@ -11,10 +11,7 @@ #include "../config.hpp" -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { class verifiable { public: @@ -27,7 +24,6 @@ namespace detail virtual void reset() = 0; }; -} -} // mock +}} // namespace mock::detail #endif // MOCK_VERIFIABLE_HPP_INCLUDED diff --git a/include/turtle/detail/void_t.hpp b/include/turtle/detail/void_t.hpp index 4c45e04..acc2b6b 100644 --- a/include/turtle/detail/void_t.hpp +++ b/include/turtle/detail/void_t.hpp @@ -9,10 +9,7 @@ #ifndef MOCK_VOID_T_HPP_INCLUDED #define MOCK_VOID_T_HPP_INCLUDED -namespace mock -{ -namespace detail -{ +namespace mock { namespace detail { template struct make_void { @@ -21,7 +18,6 @@ namespace detail /// Standard helper to implement the detection idiom. Returns always void template using void_t = typename make_void::type; -} -} // mock +}} // namespace mock::detail #endif // MOCK_VOID_T_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 25a4392..c87b259 100644 --- a/include/turtle/log.hpp +++ b/include/turtle/log.hpp @@ -10,190 +10,187 @@ #define MOCK_LOG_HPP_INCLUDED #include "config.hpp" -#include "stream.hpp" #include "format.hpp" +#include "stream.hpp" #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 << ')'; } template - struct is_callable_impl: std::false_type + struct is_callable_impl : std::false_type {}; template - struct is_callable_impl: std::true_type + struct is_callable_impl : std::true_type {}; template - struct is_callable: is_callable_impl< std::remove_cv_t > + struct is_callable : is_callable_impl> {}; +} // namespace detail + +template +stream& operator<<(stream& s, const std::pair& p) +{ + return s << '(' << mock::format(p.first) << ',' << mock::format(p.second) << ')'; } - 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::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 std::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; +} - 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 std::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::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()); +} - 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 boost::lambda::lambda_functor&) +{ + return s << '?'; +} +template +stream& operator<<(stream& s, const boost::phoenix::actor&) +{ + return s << '?'; +} - 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 << '?'; - } +inline stream& operator<<(stream& s, std::nullptr_t) +{ + return s << "nullptr"; +} - inline stream& operator<<( stream& s, std::nullptr_t ) - { - return s << "nullptr"; - } - - template< typename T > - std::enable_if_t< detail::is_callable< T >::value, stream& > - operator<<( stream& s, T* ) - { - return s << '?'; - } - template< typename T > - std::enable_if_t< !detail::is_callable< T >::value, stream& > - operator<<( stream& s, T* t ) - { - *s.s_ << t; - return s; - } -} // mock +template +std::enable_if_t::value, stream&> operator<<(stream& s, T*) +{ + return s << '?'; +} +template +std::enable_if_t::value, stream&> 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 f6dbd7d..249500f 100644 --- a/include/turtle/matcher.hpp +++ b/include/turtle/matcher.hpp @@ -10,95 +10,71 @@ #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 "log.hpp" #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()(std::add_lvalue_reference_t actual) { - public: - explicit matcher( Expected expected ) - : expected_( expected ) - {} - bool operator()( std::add_lvalue_reference_t< const Actual > actual ) - { - return mock::equal( mock::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(mock::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_( std::forward< 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, - std::enable_if_t< - detail::is_functor< Functor, Actual >::value - > - > +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_( std::forward< 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_(std::forward::type>(actual)); + } + friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); } + +private: + Constraint c_; +}; + +template +class matcher::value>> +{ +public: + explicit matcher(const Functor& f) : c_(f) {} + bool operator()(typename detail::ref_arg::type actual) + { + return c_(std::forward::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 17b5092..4d25f8d 100644 --- a/include/turtle/mock.hpp +++ b/include/turtle/mock.hpp @@ -9,168 +9,153 @@ #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 /// MOCK_CLASS( name ) /// Define a class -#define MOCK_CLASS(T) \ - struct T : mock::object +#define MOCK_CLASS(T) struct T : mock::object /// MOCK_PROTECT_FUNCTION_SIG( signature ) /// Use this with MOCK_FUNCTION/MOCK_*_METHOD if the return type contains commas -#define MOCK_PROTECT_FUNCTION_SIG(...) \ - mock::detail::parameter_type_t +#define MOCK_PROTECT_FUNCTION_SIG(...) mock::detail::parameter_type_t /// Internal compatibility macro if function signature is passed via BOOST_IDENTITY_TYPE /// TODO: Remove support for doing that and move remove_pointer_t to MOCK_PROTECT_FUNCTION_SIG -#define MOCK_FUNCTION_TYPE(...) \ - std::remove_pointer_t< __VA_ARGS__ > +#define MOCK_FUNCTION_TYPE(...) std::remove_pointer_t<__VA_ARGS__> /// MOCK_BASE_CLASS( name, base ) /// Define a class deriving from a base class -#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__> /// MOCK_FUNCTOR( name, signature ) /// Define a callable variable/member -#define MOCK_FUNCTOR(f, ...) \ - mock::detail::functor< MOCK_FUNCTION_TYPE(__VA_ARGS__) > f, f##_mock +#define MOCK_FUNCTOR(f, ...) mock::detail::functor f, f##_mock /// MOCK_FUNCTOR_TPL( name, signature ) #define MOCK_FUNCTOR_TPL(f, ...) static_assert(false, "MOCK_FUNCTOR_TPL has been replaced by MOCK_FUNCTOR") -#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) \ - mutable mock::detail::function< MOCK_FUNCTION_TYPE(S) > t##_mock_; \ - mock::detail::function< MOCK_FUNCTION_TYPE(S) >& 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::detail::make_type_name(*this), \ - BOOST_PP_STRINGIZE(t) ); \ - return t##_mock_; \ +#define MOCK_METHOD_HELPER(S, t) \ + 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::detail::make_type_name(*this), \ + BOOST_PP_STRINGIZE(t)); \ + return t##_mock_; \ } -#define MOCK_PARAM(S, tpn) \ - tpn mock::detail::parameter< MOCK_FUNCTION_TYPE(S) -#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) +#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 mock::detail::result_type< \ - MOCK_FUNCTION_TYPE(S) >::type M( \ - MOCK_DECL_PARAMS(n, S, tpn) ) c + tpn mock::detail::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_PARAMS(n, S, tpn) \ - BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, \ - std::forward< MOCK_PARAM(S, tpn)) -#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \ - MOCK_DECL(M, n, S, c, tpn) \ - { \ - static_assert( n == mock::detail::function_arity< MOCK_FUNCTION_TYPE(S) >::value, "Arity mismatch" ); \ - return MOCK_ANONYMOUS_HELPER(t)( \ - MOCK_FORWARD_PARAMS(n, S, tpn) ); \ +#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, std::forward < MOCK_PARAM(S, tpn)) +#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \ + MOCK_DECL(M, n, S, c, tpn) \ + { \ + static_assert(n == mock::detail::function_arity::value, "Arity mismatch"); \ + 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,) \ +#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_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_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) -#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) #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) /// MOCK_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) /// generates both const and non-const operators -#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)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ MOCK_METHOD_HELPER(T(), t) /// MOCK_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) /// generates only a const operator -#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \ +#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \ M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \ MOCK_METHOD_HELPER(T(), t) /// MOCK_NON_CONST_CONVERSION_OPERATOR( [calling convention] name, type, identifier ) /// generates only a non-const operator #define MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, t) \ - M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ + M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \ MOCK_METHOD_HELPER(T(), t) #define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) MOCK_CONVERSION_OPERATOR(M, T, t) #define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) MOCK_CONST_CONVERSION_OPERATOR(M, T, t) #define MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(M, T, t) MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, t) -#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \ - s mock::detail::function< MOCK_FUNCTION_TYPE(S) >& t##_mock( \ - mock::detail::context& context, \ - boost::unit_test::const_string instance ) \ - { \ - static mock::detail::function< MOCK_FUNCTION_TYPE(S) > 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) /// MOCK_CONSTRUCTOR( [calling convention] name, arity, parameters, identifier ) /// As constructors do not have a return type, the usual signature gets restricted here to just the parameters. -#define MOCK_CONSTRUCTOR(T, n, A, t) \ - MOCK_CONSTRUCTOR_AUX(T, n, A, t,) +#define MOCK_CONSTRUCTOR(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, ) /// MOCK_CONSTRUCTOR( [calling convention] name, arity, parameters, identifier ) /// must be used if the signature uses a template parameter of the class /// As constructors do not have a return type, the usual signature gets restricted here to just the parameters. -#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) \ - MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename) +#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename) /// MOCK_DESTRUCTOR( [calling convention] ~name, identifier ) -#define MOCK_DESTRUCTOR(T, t) \ - T() { try { MOCK_ANONYMOUS_HELPER(t)(); } catch( ... ) {} } \ +#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) \ - { \ - static_assert( n == mock::detail::function_arity< MOCK_FUNCTION_TYPE(S) >::value, "Arity mismatch" ); \ - 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) \ + { \ + static_assert(n == mock::detail::function_arity::value, "Arity mismatch"); \ + return MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \ } #define MOCK_VARIADIC_ELEM_0(e0, ...) e0 @@ -179,79 +164,64 @@ /// MOCK_METHOD( [calling convention] name, arity[, signature[, identifier]] ) /// generates both const and non-const methods -#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_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, )) /// MOCK_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) /// generates only the const version of the method -#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_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, )) /// MOCK_NON_CONST_METHOD( [calling convention] name, arity[, signature[, identifier]] ) /// generates only the non-const version of the method -#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_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, )) /// MOCK_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) /// must be used if the signature uses a template parameter of the class /// generates both const and non-const methods #define MOCK_METHOD_TPL(M, n, ...) \ - MOCK_METHOD_EXT_TPL(M, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) + MOCK_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) /// MOCK_CONST_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) /// must be used if the signature uses a template parameter of the class /// generates only the const version of the method #define MOCK_CONST_METHOD_TPL(M, n, ...) \ - MOCK_CONST_METHOD_EXT_TPL(M, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) + MOCK_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) /// MOCK_NON_CONST_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) /// must be used if the signature uses a template parameter of the class /// generates only the non-const version of the method #define MOCK_NON_CONST_METHOD_TPL(M, n, ...) \ - MOCK_NON_CONST_METHOD_EXT_TPL(M, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) + MOCK_NON_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, )) /// MOCK_FUNCTION( [calling convention] name, arity, signature[, identifier] ) /// if 'identifier' is omitted it will default to 'name' #define MOCK_FUNCTION(F, n, ...) \ - MOCK_FUNCTION_AUX(F, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ - inline,) + MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), inline, ) /// MOCK_STATIC_METHOD( [calling convention] name, arity, signature[, identifier] ) /// if 'identifier' is omitted it will default to 'name' #define MOCK_STATIC_METHOD(F, n, ...) \ - MOCK_FUNCTION_AUX(F, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ - static,) + MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, ) /// MOCK_STATIC_METHOD_TPL( [calling convention] name, arity, signature[, identifier] ) /// must be used if the signature uses a template parameter of the class /// if 'identifier' is omitted it will default to 'name' #define MOCK_STATIC_METHOD_TPL(F, n, ...) \ - MOCK_FUNCTION_AUX(F, n, \ - MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \ - MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \ - static, typename) + MOCK_FUNCTION_AUX( \ + F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, typename) /// MOCK_EXPECT( identifier ) -#define MOCK_EXPECT(t) MOCK_HELPER(t).expect( __FILE__, __LINE__ ) +#define MOCK_EXPECT(t) MOCK_HELPER(t).expect(__FILE__, __LINE__) /// MOCK_RESET( identifier ) -#define MOCK_RESET(t) MOCK_HELPER(t).reset( __FILE__, __LINE__ ) +#define MOCK_RESET(t) MOCK_HELPER(t).reset(__FILE__, __LINE__) /// MOCK_VERIFY( identifier ) -#define MOCK_VERIFY(t) MOCK_HELPER(t).verify( __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 70f98fa..74da12f 100644 --- a/include/turtle/object.hpp +++ b/include/turtle/object.hpp @@ -10,61 +10,61 @@ #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 -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 ); - - 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, - std::enable_if_t< !std::is_base_of< object, T >::value >* = 0 ) - { - e.configure( detail::root, &t, instance, type, name ); - return e; - } -} - class object - { - public: - object() - : impl_( std::make_shared< detail::object_impl >() ) - {} - protected: - ~object() = default; - public: - std::shared_ptr< detail::object_impl > impl_; - }; - -namespace detail -{ - template< typename E > - E& configure( const object& o, E& e, +namespace detail { + template + E& configure(const object& o, + E& e, boost::unit_test::const_string instance, - boost::optional< type_name > type, - boost::unit_test::const_string name ) + boost::optional type, + boost::unit_test::const_string name); + + template + E& configure(const T& t, + E& e, + boost::unit_test::const_string instance, + boost::optional type, + boost::unit_test::const_string name, + std::enable_if_t::value>* = 0) { - e.configure( *o.impl_, o.impl_.get(), instance, type, name ); + e.configure(detail::root, &t, instance, type, name); return e; } -} -} // mock +} // namespace detail +class object +{ +public: + object() : impl_(std::make_shared()) {} + +protected: + ~object() = default; + +public: + std::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); + return e; + } +} // 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 377e920..a4a6281 100644 --- a/include/turtle/sequence.hpp +++ b/include/turtle/sequence.hpp @@ -13,17 +13,14 @@ #include "detail/sequence_impl.hpp" #include -namespace mock +namespace mock { +class sequence { - class sequence - { - public: - sequence() - : impl_( std::make_shared< detail::sequence_impl >() ) - {} +public: + sequence() : impl_(std::make_shared()) {} - std::shared_ptr< detail::sequence_impl > impl_; - }; -} // mock + std::shared_ptr impl_; +}; +} // namespace mock #endif // MOCK_SEQUENCE_HPP_INCLUDED diff --git a/include/turtle/stream.hpp b/include/turtle/stream.hpp index 9f5b0a1..52991ed 100644 --- a/include/turtle/stream.hpp +++ b/include/turtle/stream.hpp @@ -13,33 +13,24 @@ #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 { @@ -48,16 +39,14 @@ namespace conversion holder& operator=(const holder&) = delete; virtual ~holder() = default; - virtual void serialize( std::ostream& s ) const = 0; + 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 @@ -69,72 +58,57 @@ namespace conversion struct any { - template< typename T > - any( const T& t ): h_( std::make_unique< holder_imp >( t ) ) + template + any(const T& t) : h_(std::make_unique>(t)) {} std::unique_ptr 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/unwrap_reference.hpp b/include/turtle/unwrap_reference.hpp index b450cff..93f6f5e 100644 --- a/include/turtle/unwrap_reference.hpp +++ b/include/turtle/unwrap_reference.hpp @@ -12,31 +12,30 @@ #include #include -namespace mock +namespace mock { +template +struct unwrap_reference { - template - struct unwrap_reference - { - using type = T; - }; - template - struct unwrap_reference> - { - using type = T; - }; - template - struct unwrap_reference> - { - using type = T; - }; - template - using unwrap_reference_t = typename unwrap_reference::type; + using type = T; +}; +template +struct unwrap_reference> +{ + using type = T; +}; +template +struct unwrap_reference> +{ + using type = T; +}; +template +using unwrap_reference_t = typename unwrap_reference::type; - template - BOOST_FORCEINLINE unwrap_reference_t& unwrap_ref( T& t ) noexcept - { - return t; - } +template +BOOST_FORCEINLINE unwrap_reference_t& unwrap_ref(T& t) noexcept +{ + return t; } +} // namespace mock -#endif // MOCK_UNWRAP_REFERENCE_HPP_INCLUDED +#endif // MOCK_UNWRAP_REFERENCE_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 021d95b..53bebcd 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,1129 +9,1938 @@ #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() = default; - 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() = default; + 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 int main() { diff --git a/test/bench_30_classes_30_methods_9_args.cpp b/test/bench_30_classes_30_methods_9_args.cpp index 17c5a52..72def03 100644 --- a/test/bench_30_classes_30_methods_9_args.cpp +++ b/test/bench_30_classes_30_methods_9_args.cpp @@ -8,1069 +8,1068 @@ #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() = default; - 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() = default; + 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 int main() { 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 6a8023c..a69d3d9 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,1069 +9,1068 @@ #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() = default; - 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() = default; + 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 int main() { 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 c36c91b..c245b25 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,1069 +9,1068 @@ #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() = default; - 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() = default; + 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 int main() { 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 c9c4be2..b137336 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,1069 +9,1068 @@ #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() = default; - 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() = default; + 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 int main() { 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 a946fc9..f26176f 100644 --- a/test/detail/test_function.cpp +++ b/test/detail/test_function.cpp @@ -8,8 +8,8 @@ #include "../mock_error.hpp" #include "../undefined.hpp" -#include #include +#include #include #include #include @@ -17,334 +17,339 @@ // static -namespace -{ - std::function< void() > static_f; +namespace { +std::function static_f; - static_assert( std::is_same< void, decltype( mock::detail::function< void() >{}() ) >::value, "!"); - static_assert( std::is_same< int, decltype( mock::detail::function< int() >{}() ) >::value, "!"); - static_assert( std::is_same< void, decltype( mock::detail::function< void( float ) >{}( std::declval() ) ) >::value, "!"); - static_assert( std::is_same< int, decltype( mock::detail::function< int( float ) >{}( std::declval() ) ) >::value, "!"); -} +static_assert(std::is_same{}())>::value, "!"); +static_assert(std::is_same{}())>::value, "!"); +static_assert(std::is_same{}(std::declval()))>::value, "!"); +static_assert(std::is_same{}(std::declval()))>::value, "!"); +} // 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; - std::function< void() > functor = f; + mock::detail::function f; + std::function functor = f; } -BOOST_FIXTURE_TEST_CASE( a_function_can_be_passed_as_functor_using_std_bind_and_std_ref, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(a_function_can_be_passed_as_functor_using_std_bind_and_std_ref, mock_error_fixture) { - mock::detail::function< void() > f; - std::function< void() > functor = std::bind( std::ref( f ) ); + mock::detail::function f; + std::function functor = std::bind(std::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 { - class my_interface - { - public: - my_interface() = default; - my_interface(const my_interface&) = delete; - my_interface& operator=(const my_interface&) = delete; - virtual ~my_interface() = default; +public: + my_interface() = default; + my_interface(const my_interface&) = delete; + my_interface& operator=(const my_interface&) = delete; + virtual ~my_interface() = default; - private: - virtual void my_method() = 0; - }; - class my_implementation : public my_interface - { - virtual void my_method() {} - }; -} +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 ) +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 ); @@ -352,513 +357,511 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_failing_custom_constrain // CHECK_CALLS( 1 ); //} -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); } -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); } // 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( std::ref( i ) ); + f.expect().returns(std::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( std::ref( i ) ); + f.expect().returns(std::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() = default; - virtual void f() = 0; - }; - struct derived : base - { - virtual void f() - {} - }; -} + virtual ~base() = default; + virtual void f() = 0; +}; +struct derived : base +{ + virtual void f() {} +}; +} // namespace -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); } -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); } } -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< std::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 std::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< std::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( std::ref( b ) ); - BOOST_CHECK_NO_THROW( f() ); - CHECK_CALLS( 1 ); + f.expect().returns(std::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( std::ref( get_undefined() ) ); + mock::detail::function f; + f.expect().returns(std::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_std_bind, + mock_error_fixture) { - int custom_result_with_parameter( int i ) - { - return i; - } + mock::detail::function f; + f.expect().calls(std::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_std_bind, mock_error_fixture ) -{ - mock::detail::function< int( int ) > f; - f.expect().calls( std::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) { - auto f = std::make_unique>(); + auto f = std::make_unique>(); 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) { - auto f = std::make_unique>(); - CHECK_ERROR( (*f)(), "unexpected call", 0, "?()" ); + auto f = std::make_unique>(); + 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( [&f](){ iterate(f); } ); + for(int i = 0; i < 100; ++i) + group.create_thread([&f]() { iterate(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 93ed575..be9957e 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 0b58b13..1a50e29 100644 --- a/test/detail/test_is_functor.cpp +++ b/test/detail/test_is_functor.cpp @@ -9,110 +9,115 @@ #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 +#include #include #include -namespace +namespace { +struct declared_but_not_defined; +static_assert(!mock::detail::is_functor::value, "Should not be a functor"); + +template +void is_functor(T) { - struct declared_but_not_defined; - static_assert( !mock::detail::is_functor< declared_but_not_defined, int >::value, "Should not be a functor" ); - - template< typename T > - void is_functor( T ) - { - static_assert( mock::detail::is_functor< T, int >::value, "Should be a functor taking an int"); - } - template< typename T > - void is_not_functor( T ) - { - static_assert( !mock::detail::is_functor< T, int >::value, "Should not be a functor taking an int" ); - } - - void f0() {} - bool f1( int ) { return false; } - bool f2( std::string, int ) { return false; } + static_assert(mock::detail::is_functor::value, "Should be a functor taking an int"); +} +template +void is_not_functor(T) +{ + static_assert(!mock::detail::is_functor::value, "Should not be a functor taking an int"); } -BOOST_AUTO_TEST_CASE( data_is_not_functor ) +void f0() {} +bool f1(int) { - is_not_functor( 42 ); + 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 ) +BOOST_AUTO_TEST_CASE(function_is_functor) { - is_not_functor( f0 ); - is_functor( f1 ); - is_not_functor( f2 ); + is_not_functor(f0); + is_functor(f1); + is_not_functor(f2); } -BOOST_AUTO_TEST_CASE( function_pointer_is_functor ) +BOOST_AUTO_TEST_CASE(function_pointer_is_functor) { - is_not_functor( &f0 ); - is_functor( &f1 ); - is_not_functor( &f2 ); + is_not_functor(&f0); + is_functor(&f1); + is_not_functor(&f2); } -BOOST_AUTO_TEST_CASE( std_ptr_fun_is_functor ) +BOOST_AUTO_TEST_CASE(std_ptr_fun_is_functor) { - is_functor( std::ptr_fun( &f1 ) ); - is_not_functor( std::ptr_fun( &f2 ) ); + is_functor(std::ptr_fun(&f1)); + is_not_functor(std::ptr_fun(&f2)); } -BOOST_AUTO_TEST_CASE( std_bind_first_is_functor ) +BOOST_AUTO_TEST_CASE(std_bind_first_is_functor) { - is_functor( std::bind1st( std::ptr_fun( &f2 ), "" ) ); + is_functor(std::bind1st(std::ptr_fun(&f2), "")); } -BOOST_AUTO_TEST_CASE( bind_is_functor ) +BOOST_AUTO_TEST_CASE(bind_is_functor) { { #if BOOST_VERSION >= 106000 using namespace boost::placeholders; #endif - is_functor( boost::bind( &f0 ) ); - is_functor( boost::bind( &f1, _1 ) ); - is_functor( boost::bind( &f2, "", _1 ) ); + is_functor(boost::bind(&f0)); + is_functor(boost::bind(&f1, _1)); + is_functor(boost::bind(&f2, "", _1)); } - is_functor( std::bind( &f0 ) ); - is_functor( std::bind( &f1, std::placeholders::_1 ) ); - is_functor( std::bind( &f2, "", std::placeholders::_1 ) ); + is_functor(std::bind(&f0)); + is_functor(std::bind(&f1, std::placeholders::_1)); + is_functor(std::bind(&f2, "", std::placeholders::_1)); } -BOOST_AUTO_TEST_CASE( boost_lambda_is_functor ) +BOOST_AUTO_TEST_CASE(boost_lambda_is_functor) { - is_functor( boost::lambda::_1 < 42 ); + is_functor(boost::lambda::_1 < 42); } -BOOST_AUTO_TEST_CASE( boost_phoenix_is_functor ) +BOOST_AUTO_TEST_CASE(boost_phoenix_is_functor) { - is_functor( boost::phoenix::arg_names::arg1 < 42 ); - is_functor( boost::phoenix::arg_names::_1 < 42 ); + is_functor(boost::phoenix::arg_names::arg1 < 42); + is_functor(boost::phoenix::arg_names::_1 < 42); } -BOOST_AUTO_TEST_CASE( boost_function_is_functor ) +BOOST_AUTO_TEST_CASE(boost_function_is_functor) { - is_functor( boost::function< void(int) >() ); + is_functor(boost::function()); } -BOOST_AUTO_TEST_CASE( std_function_is_functor ) +BOOST_AUTO_TEST_CASE(std_function_is_functor) { - is_functor( std::function< void(int) >() ); + is_functor(std::function()); } -BOOST_AUTO_TEST_CASE( cxx11_lambda_is_functor ) +BOOST_AUTO_TEST_CASE(cxx11_lambda_is_functor) { - is_not_functor( []() {} ); - is_functor( []( int ) {} ); - is_not_functor( []( const std::string&, int ) {} ); - is_not_functor( []( int, const std::string& ) {} ); + is_not_functor([]() {}); + is_functor([](int) {}); + is_not_functor([](const std::string&, int) {}); + is_not_functor([](int, const std::string&) {}); } diff --git a/test/detail/test_signature.cpp b/test/detail/test_signature.cpp index f20d2a3..ad8228d 100644 --- a/test/detail/test_signature.cpp +++ b/test/detail/test_signature.cpp @@ -10,18 +10,17 @@ #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) { - static_assert( std::is_same< void(), MOCK_SIGNATURE(method_1) >::value, "!"); - static_assert( std::is_same< float( int ), MOCK_SIGNATURE(method_2) >::value, "!"); + static_assert(std::is_same::value, "!"); + static_assert(std::is_same::value, "!"); } diff --git a/test/detail/test_type_name.cpp b/test/detail/test_type_name.cpp index 0f577ef..ff643f3 100644 --- a/test/detail/test_type_name.cpp +++ b/test/detail/test_type_name.cpp @@ -10,218 +10,216 @@ #include #include -namespace +namespace { +template +std::string to_string(const T& t) { - template< typename T > - std::string to_string( const T& t) - { - std::ostringstream s; - s << mock::detail::make_type_name(t); - return s.str(); - } + std::ostringstream s; + s << mock::detail::make_type_name(t); + return s.str(); } +} // 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", to_string( 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", to_string(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 d1c03de..5f493e0 100644 --- a/test/fail_ambiguous_mock_method.cpp +++ b/test/fail_ambiguous_mock_method.cpp @@ -8,17 +8,16 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() = default; - virtual void my_method() = 0; - virtual void my_method( int ) = 0; - }; + virtual ~my_base() = default; + 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 e3d6aed..0fc5d83 100644 --- a/test/fail_constraint_functor_not_compatible.cpp +++ b/test/fail_constraint_functor_not_compatible.cpp @@ -12,7 +12,10 @@ MOCK_CLASS(my_class) { MOCK_METHOD_EXT(my_method, 1, void(int), my_method) }; -bool constraint(int, int) { return true; } +bool constraint(int, int) +{ + return true; +} void test_case() { diff --git a/test/fail_constraint_value_not_comparable.cpp b/test/fail_constraint_value_not_comparable.cpp index dec09ac..ee8b81d 100644 --- a/test/fail_constraint_value_not_comparable.cpp +++ b/test/fail_constraint_value_not_comparable.cpp @@ -8,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + MOCK_METHOD_EXT(my_method, 1, void(int), my_method) }; void test_case() { my_class c; - MOCK_EXPECT( c.my_method ).with( "42" ); + MOCK_EXPECT(c.my_method).with("42"); } 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 8d18b82..4deaea0 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,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + 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" ) ); + MOCK_EXPECT(c.my_method).with(mock::equal("42")); } diff --git a/test/fail_mismatch_type_in_returns_int_action.cpp b/test/fail_mismatch_type_in_returns_int_action.cpp index c4a5aed..8b5df96 100644 --- a/test/fail_mismatch_type_in_returns_int_action.cpp +++ b/test/fail_mismatch_type_in_returns_int_action.cpp @@ -8,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 0, int(), my_method ) + MOCK_METHOD_EXT(my_method, 0, int(), my_method) }; void test_case() { my_class c; - MOCK_EXPECT( c.my_method ).returns( std::string() ); + MOCK_EXPECT(c.my_method).returns(std::string()); } diff --git a/test/fail_mismatch_type_in_returns_string_action.cpp b/test/fail_mismatch_type_in_returns_string_action.cpp index 885a4ac..dadcc33 100644 --- a/test/fail_mismatch_type_in_returns_string_action.cpp +++ b/test/fail_mismatch_type_in_returns_string_action.cpp @@ -8,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 0, std::string(), my_method ) + MOCK_METHOD_EXT(my_method, 0, std::string(), my_method) }; void test_case() { my_class c; - MOCK_EXPECT( c.my_method ).returns( 42 ); + MOCK_EXPECT(c.my_method).returns(42); } diff --git a/test/fail_mismatch_type_in_returns_void_action.cpp b/test/fail_mismatch_type_in_returns_void_action.cpp index d3dd35c..ea7afd3 100644 --- a/test/fail_mismatch_type_in_returns_void_action.cpp +++ b/test/fail_mismatch_type_in_returns_void_action.cpp @@ -8,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 0, void(), my_method ) + MOCK_METHOD_EXT(my_method, 0, void(), my_method) }; void test_case() { my_class c; - MOCK_EXPECT( c.my_method ).returns( "42" ); + MOCK_EXPECT(c.my_method).returns("42"); } 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 b30c9ef..07e483e 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,14 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() = default; - }; + virtual ~my_base() = default; +}; - 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 4c59c70..ef7378a 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,17 @@ #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() = default; - virtual void my_method( int, int, int, int, int, int, int, int, int, int ) = 0; - }; + virtual ~my_base() = default; + 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_too_many_arguments_in_mock_method.cpp b/test/fail_too_many_arguments_in_mock_method.cpp index 7c08f7e..af18e2a 100644 --- a/test/fail_too_many_arguments_in_mock_method.cpp +++ b/test/fail_too_many_arguments_in_mock_method.cpp @@ -8,16 +8,15 @@ #include -namespace +namespace { +struct my_base { - struct my_base - { - virtual ~my_base() = default; - virtual void my_method( int ) = 0; - }; + virtual ~my_base() = default; + 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 033ffd8..d653265 100644 --- a/test/fail_wrong_number_of_arguments_in_with.cpp +++ b/test/fail_wrong_number_of_arguments_in_with.cpp @@ -8,12 +8,12 @@ #include -MOCK_CLASS( my_class ) +MOCK_CLASS(my_class) { - MOCK_METHOD_EXT( my_method, 1, void( int ), my_method ) + MOCK_METHOD_EXT(my_method, 1, void(int), my_method) }; void test_case() { my_class c; - MOCK_EXPECT( c.my_method ).with( 42, 42 ); + MOCK_EXPECT(c.my_method).with(42, 42); } diff --git a/test/mock_error.hpp b/test/mock_error.hpp index 5821f52..5ac02f6 100644 --- a/test/mock_error.hpp +++ b/test/mock_error.hpp @@ -12,10 +12,10 @@ #define MOCK_ERROR_POLICY mock_error #include #include -#include #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,59 +47,56 @@ 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) { std::ostringstream s; s << context; // Context can be streamed - mock_error_data.fail( message, s.str(), file, line ); + mock_error_data.fail(message, s.str(), 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 58793f3..0eb525c 100644 --- a/test/test_constraint.cpp +++ b/test/test_constraint.cpp @@ -9,16 +9,15 @@ #include #include -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)); } diff --git a/test/test_constraints.cpp b/test/test_constraints.cpp index b92f728..11c43fd 100644 --- a/test/test_constraints.cpp +++ b/test/test_constraints.cpp @@ -9,386 +9,372 @@ #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; - auto c = mock::equal( std::cref( s ) ); + auto c = mock::equal(std::cref(s)); s = "string"; - BOOST_CHECK( c.c_( "string" ) ); + BOOST_CHECK(c.c_("string")); } { - 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)); } } -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 ) ); + BOOST_CHECK(mock::equal(3).c_(&i)); + BOOST_CHECK(!mock::equal(7).c_(&i)); } { int* i = 0; - BOOST_CHECK( ! mock::equal( 3 ).c_( i ) ); + BOOST_CHECK(!mock::equal(3).c_(i)); } { - 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)); } } -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 ) ); + 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 ); - auto c = mock::same( i ); - BOOST_CHECK( ! c.c_( j ) ); - BOOST_CHECK( c.c_( i ) ); + BOOST_CHECK_EQUAL(i, j); + auto c = mock::same(i); + BOOST_CHECK(!c.c_(j)); + BOOST_CHECK(c.c_(i)); } { std::nullptr_t p; - BOOST_CHECK( mock::same( p ).c_( p ) ); + BOOST_CHECK(mock::same(p).c_(p)); } } -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< - std::reference_wrapper< const int > - > - > c = mock::assign( std::cref( j ) ); - BOOST_CHECK( c.c_( i ) ); - BOOST_CHECK_EQUAL( 1, i ); + mock::constraint>> c = mock::assign(std::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; - auto c = mock::assign( std::cref( j ) ); - BOOST_CHECK( c.c_( &i ) ); - BOOST_CHECK_EQUAL( 1, i ); + auto c = mock::assign(std::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; - auto c = mock::assign( std::cref( j ) ); - BOOST_CHECK( c.c_( i ) ); - BOOST_CHECK_EQUAL( j, i ); + auto c = mock::assign(std::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( 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); } { 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); } { - std::unique_ptr< int > i; - std::unique_ptr< int > j( new int( 3 ) ); - BOOST_CHECK( mock::retrieve( i ).c_( std::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_(std::move(j))); + BOOST_REQUIRE(i); + BOOST_CHECK_EQUAL(3, *i); + BOOST_CHECK(!j); } } -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)); } { - 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)); } } -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; - auto c = mock::contain( std::cref( s ) ); + auto c = mock::contain(std::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< - std::reference_wrapper< const std::string > - > - > c = mock::contain( std::cref( s ) ); + mock::constraint>> c = + mock::contain(std::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 a2bed75..6525a01 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 8b3cd93..aceccd5 100644 --- a/test/test_integration.cpp +++ b/test/test_integration.cpp @@ -9,775 +9,739 @@ #include "mock_error.hpp" #include "undefined.hpp" #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 +namespace { +MOCK_CLASS(my_mock) { - MOCK_CLASS( my_mock ) - { - MOCK_METHOD_EXT( my_method, 1, int( int ), my_tag ) - }; -} + MOCK_METHOD_EXT(my_method, 1, int(int), my_tag) +}; +} // namespace -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 { - class my_ambiguited_interface - { - public: - my_ambiguited_interface() = default; - my_ambiguited_interface(const my_ambiguited_interface&) = delete; - my_ambiguited_interface& operator=(const my_ambiguited_interface&) = delete; - virtual ~my_ambiguited_interface() = default; - virtual void my_method() = 0; - virtual void my_method( int ) = 0; - }; +public: + my_ambiguited_interface() = default; + my_ambiguited_interface(const my_ambiguited_interface&) = delete; + my_ambiguited_interface& operator=(const my_ambiguited_interface&) = delete; + virtual ~my_ambiguited_interface() = default; + 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 { - class my_const_ambiguited_interface - { - public: - my_const_ambiguited_interface() = default; - my_const_ambiguited_interface(const my_const_ambiguited_interface&) = delete; - my_const_ambiguited_interface& operator=(const my_const_ambiguited_interface&) = delete; - virtual ~my_const_ambiguited_interface() = default; - virtual void my_method() = 0; - virtual void my_method() const = 0; - }; +public: + my_const_ambiguited_interface() = default; + my_const_ambiguited_interface(const my_const_ambiguited_interface&) = delete; + my_const_ambiguited_interface& operator=(const my_const_ambiguited_interface&) = delete; + virtual ~my_const_ambiguited_interface() = default; + 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 +namespace { +MOCK_CLASS(my_undefined_mock) { - MOCK_CLASS( my_undefined_mock ) - { - MOCK_METHOD_EXT( m, 1, void( undefined& ), t ) - }; -} + MOCK_METHOD_EXT(m, 1, void(undefined&), t) +}; +} // namespace -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) { - std::function< int( float, const std::string& ) > func; - MOCK_EXPECT( gf ).once().with( 3, "op" ).returns( 42 ); + std::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) { - std::function< int( float, const std::string& ) > func; + std::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() = default; + 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 { - 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: + my_observer() = default; + my_observer(const my_observer&) = delete; + my_observer& operator=(const my_observer&) = delete; + virtual ~my_observer() = default; + virtual void notify(int value) = 0; +}; -namespace +class my_manager { - template< typename T > - struct my_template_base_class - { - virtual ~my_template_base_class() = default; - 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: + my_manager() = default; + my_manager(const my_manager&) = delete; + my_manager& operator=(const my_manager&) = delete; + virtual ~my_manager() = default; + 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 { - 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) { - class my_observer - { - public: - my_observer() = default; - my_observer(const my_observer&) = delete; - my_observer& operator=(const my_observer&) = delete; - virtual ~my_observer() = default; - virtual void notify( int value ) = 0; - }; + MOCK_METHOD(notify, 1) +}; - class my_manager - { - public: - my_manager() = default; - my_manager(const my_manager&) = delete; - my_manager& operator=(const my_manager&) = delete; - virtual ~my_manager() = default; - virtual my_observer& get_observer() const = 0; - }; - - class my_subject - { - 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 ) +MOCK_BASE_CLASS(my_mock_manager, my_manager) { - MOCK_EXPECT( manager.get_observer ).returns( std::ref( observer ) ); - my_subject subject( manager ); - MOCK_EXPECT( observer.notify ).once().with( 1 ); + MOCK_METHOD(get_observer, 0) +}; + +struct fixture : mock_error_fixture +{ + my_mock_manager manager; + my_mock_observer observer; +}; +} // namespace + +BOOST_FIXTURE_TEST_CASE(basic_mock_object_collaboration_usage, fixture) +{ + MOCK_EXPECT(manager.get_observer).returns(std::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_CLASS( my_constructed_class ) - { - MOCK_CONSTRUCTOR( my_constructed_class, 2, ( int, const std::string& ), constructor ) - }; -} + MOCK_CONSTRUCTOR(my_constructed_class, 2, (int, const std::string&), constructor) +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mocking_a_constructor, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mocking_a_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_class::constructor).with(42, "some text").once(); + my_constructed_class(42, "some text"); + BOOST_CHECK(MOCK_VERIFY(my_constructed_class::constructor)); + CHECK_CALLS(1); } -namespace +namespace { +template +MOCK_CLASS(my_constructed_template_class) { - template< typename T > - MOCK_CLASS( my_constructed_template_class ) - { - MOCK_CONSTRUCTOR_TPL( my_constructed_template_class, 2, ( T, const std::string& ), constructor ) - }; -} + MOCK_CONSTRUCTOR_TPL(my_constructed_template_class, 2, (T, const std::string&), constructor) +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_constructor, mock_error_fixture ) +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 ); + 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 +namespace { +MOCK_CLASS(my_destroyed_class) { - MOCK_CLASS( my_destroyed_class ) - { - MOCK_DESTRUCTOR( ~my_destroyed_class, destructor ) - }; -} + MOCK_DESTRUCTOR(~my_destroyed_class, destructor) +}; +} // namespace -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 +namespace { +MOCK_CLASS(boost_optional) { - MOCK_CLASS( boost_optional ) - { - MOCK_METHOD_EXT( method, 0, boost::optional< my_observer& >(), tag ) - }; -} + MOCK_METHOD_EXT(method, 0, boost::optional(), tag) +}; +} // namespace -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( std::ref( o ) ); + MOCK_EXPECT(b.tag).once().returns(std::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( std::cref( s ) ); + MOCK_EXPECT(f).once().with(std::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 ) -} - -BOOST_FIXTURE_TEST_CASE( a_free_function_can_be_mocked, mock_error_fixture ) -{ - MOCK_EXPECT( free_function ).once(); + 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_CHECK(!MOCK_VERIFY(free_function)), "verification failed", 0, "free_function\n. once().with( any )"); + free_function(42); + CHECK_CALLS(1); + BOOST_CHECK(MOCK_VERIFY(free_function)); + MOCK_RESET(free_function); } -namespace +namespace { +struct some_class : mock::object { - struct some_class : mock::object - { - MOCK_STATIC_METHOD( some_static_method, 1, void( int ), some_static_method ) - }; + 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); } -BOOST_FIXTURE_TEST_CASE( a_static_method_can_be_mocked, mock_error_fixture ) +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(); - 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::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, int > ) - {}; - MOCK_BASE_CLASS( my_boost_pp_comma_mock, my_base< int BOOST_PP_COMMA() int > ) - {}; -} +namespace { +template +struct my_base +{}; +MOCK_BASE_CLASS(my_comma_mock, my_base) +{}; +MOCK_BASE_CLASS(my_boost_pp_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( [i](){ create_functor( i ); } ); + for(int i = 0; i < 100; ++i) + group.create_thread([i]() { 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( [&m](){ iterate(m); } ); + for(int i = 0; i < 100; ++i) + group.create_thread([&m]() { iterate(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); } -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) }; diff --git a/test/test_log.cpp b/test/test_log.cpp index a512ac6..623b6b1 100644 --- a/test/test_log.cpp +++ b/test/test_log.cpp @@ -7,667 +7,638 @@ // http://www.boost.org/LICENSE_1_0.txt) #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 #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; std::ostringstream s; s << &i; const std::string pointerValue = s.str(); - BOOST_CHECK_NE( "?", to_string( &i ) ); - BOOST_CHECK_EQUAL( pointerValue, to_string( &i ) ); + BOOST_CHECK_NE("?", to_string(&i)); + BOOST_CHECK_EQUAL(pointerValue, to_string(&i)); } { const int i = 0; std::ostringstream s; s << &i; const std::string pointerValue = s.str(); - BOOST_CHECK_NE( "?", to_string( &i ) ); - BOOST_CHECK_EQUAL( pointerValue, to_string( &i ) ); + BOOST_CHECK_NE("?", to_string(&i)); + BOOST_CHECK_EQUAL(pointerValue, 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_CHECK_EQUAL("(3,42)", to_string(std::make_pair(3, 42.f))); } -BOOST_AUTO_TEST_CASE( template_template_streamable_yields_its_value_when_serialized ) +BOOST_AUTO_TEST_CASE(boost_shared_ptr_are_serialized) { - BOOST_CHECK_EQUAL( "template_streamable", to_string( template_streamable< int >() ) ); + BOOST_CHECK_NE("?", to_string(boost::shared_ptr())); + BOOST_CHECK_NE("?", to_string(boost::shared_ptr(new int(42)))); } -namespace +BOOST_AUTO_TEST_CASE(boost_weak_ptr_are_serialized) { - 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_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr()))); + BOOST_CHECK_NE("?", to_string(boost::weak_ptr(boost::shared_ptr(new int(42))))); } -BOOST_AUTO_TEST_CASE( std_pairs_are_serialized ) +BOOST_AUTO_TEST_CASE(std_shared_ptr_are_serialized) { - BOOST_CHECK_EQUAL( "(3,42)", to_string( std::make_pair( 3, 42.f ) ) ); + BOOST_CHECK_NE("?", to_string(std::shared_ptr())); + BOOST_CHECK_NE("?", to_string(std::shared_ptr(new int(42)))); } -BOOST_AUTO_TEST_CASE( boost_shared_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_weak_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(std::weak_ptr(std::shared_ptr()))); + BOOST_CHECK_NE("?", to_string(std::weak_ptr(std::shared_ptr(new int(42))))); } -BOOST_AUTO_TEST_CASE( boost_weak_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_unique_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(std::unique_ptr())); + BOOST_CHECK_NE("?", to_string(std::unique_ptr(new int(42)))); } -BOOST_AUTO_TEST_CASE( std_shared_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_deques_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( std::shared_ptr< int >( new int( 42 ) ) ) ); + std::deque d; + d.push_back(12); + d.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(d)); } -BOOST_AUTO_TEST_CASE( std_weak_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_lists_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 ) ) ) ) ); + std::list l; + l.push_back(12); + l.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(l)); } -BOOST_AUTO_TEST_CASE( std_unique_ptr_are_serialized ) +BOOST_AUTO_TEST_CASE(std_vectors_are_serialized) { - BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >() ) ); - BOOST_CHECK_NE( "?", to_string( std::unique_ptr< int >( new int( 42 ) ) ) ); + std::vector v; + v.push_back(12); + v.push_back(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(v)); } -BOOST_AUTO_TEST_CASE( std_deques_are_serialized ) +BOOST_AUTO_TEST_CASE(std_maps_are_serialized) { - std::deque< int > d; - d.push_back( 12 ); - d.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( d ) ); + std::map m; + m[12] = "12"; + m[42] = "42"; + BOOST_CHECK_EQUAL("((12,\"12\"),(42,\"42\"))", to_string(m)); } -BOOST_AUTO_TEST_CASE( std_lists_are_serialized ) +BOOST_AUTO_TEST_CASE(std_multimaps_are_serialized) { - std::list< int > l; - l.push_back( 12 ); - l.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( l ) ); + 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_vectors_are_serialized ) +BOOST_AUTO_TEST_CASE(std_sets_are_serialized) { - std::vector< int > v; - v.push_back( 12 ); - v.push_back( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( v ) ); + std::set s; + s.insert(12); + s.insert(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(s)); } -BOOST_AUTO_TEST_CASE( std_maps_are_serialized ) +BOOST_AUTO_TEST_CASE(std_multisets_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::multiset s; + s.insert(12); + s.insert(42); + BOOST_CHECK_EQUAL("(12,42)", to_string(s)); } -BOOST_AUTO_TEST_CASE( std_multimaps_are_serialized ) +BOOST_AUTO_TEST_CASE(std_deques_of_vectors_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::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_sets_are_serialized ) +BOOST_AUTO_TEST_CASE(std_vectors_of_deques_are_serialized) { - std::set< int > s; - s.insert( 12 ); - s.insert( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); + 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( std_multisets_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_assign_list_of_are_serialized) { - std::multiset< int > s; - s.insert( 12 ); - s.insert( 42 ); - BOOST_CHECK_EQUAL( "(12,42)", to_string( s ) ); + BOOST_CHECK_EQUAL("(12,42)", to_string(boost::assign::list_of(12)(42))); } -BOOST_AUTO_TEST_CASE( std_deques_of_vectors_are_serialized ) +BOOST_AUTO_TEST_CASE(boost_assign_map_list_of_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 ) ); + BOOST_CHECK_EQUAL("((12,\"12\"),(42,\"42\"))", to_string(boost::assign::map_list_of(12, "12")(42, "42"))); } -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 ) ); -} - -BOOST_AUTO_TEST_CASE( boost_assign_list_of_are_serialized ) -{ - 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_CHECK_EQUAL( "((12,\"12\"),(42,\"42\"))", to_string( boost::assign::map_list_of( 12, "12" )( 42, "42" ) ) ); -} - -BOOST_AUTO_TEST_CASE( std_reference_wrappers_are_serialized ) +BOOST_AUTO_TEST_CASE(std_reference_wrappers_are_serialized) { const int i = 3; - BOOST_CHECK_EQUAL( "3", to_string( std::cref( i ) ) ); - BOOST_CHECK_EQUAL( "\"string\"", to_string( std::cref( "string" ) ) ); + BOOST_CHECK_EQUAL("3", to_string(std::cref(i))); + BOOST_CHECK_EQUAL("\"string\"", to_string(std::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( std::to_string( static_cast< int >( 'a' ) ), to_string< unsigned char >( 'a' ) ); + BOOST_CHECK_EQUAL(std::to_string(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(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( bind_functor_yields_question_mark_when_serialized ) -{ - BOOST_CHECK_EQUAL( "?", to_string( boost::bind( &some_function ) ) ); - BOOST_CHECK_EQUAL( "?", to_string( std::bind( &some_function ) ) ); + BOOST_CHECK_EQUAL("?", to_string(boost::bind(&some_function))); + BOOST_CHECK_EQUAL("?", to_string(std::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 -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)); } -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 916f20b..b352a20 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, std::cref( i ) ) ); - BOOST_CHECK( ! match( 4, std::cref( i ) ) ); + BOOST_CHECK(match(3, std::cref(i))); + BOOST_CHECK(!match(4, std::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 7d74943..14ac35e 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 aecaa9a..edcea98 100644 --- a/test/test_mock.cpp +++ b/test/test_mock.cpp @@ -11,404 +11,385 @@ #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 +namespace { +MOCK_CLASS(mock_class_with_operator) { - MOCK_CLASS( mock_class_with_operator ) - { - MOCK_CONST_METHOD_EXT( operator+=, 1, mock_class_with_operator&( int ), addition ) - }; -} + MOCK_CONST_METHOD_EXT(operator+=, 1, mock_class_with_operator &(int), addition) +}; +} // namespace -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( std::ref( m ) ); + MOCK_EXPECT(m.addition).once().returns(std::ref(m)); m += 1; - CHECK_CALLS( 1 ); + CHECK_CALLS(1); } -namespace +namespace { +MOCK_CLASS(mock_class_with_conversion_operator) { - MOCK_CLASS( mock_class_with_conversion_operator ) - { - MOCK_CONVERSION_OPERATOR( operator, int, conversion ) - }; -} + MOCK_CONVERSION_OPERATOR(operator, int, conversion) +}; +} // namespace -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) }; +} // namespace + +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 ) +namespace { +MOCK_CLASS(mock_class_with_const_conversion_operator) { - 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 ); -} + MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion) +}; +} // namespace -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 +namespace { +MOCK_CLASS(mock_class_with_non_const_conversion_operator) { - MOCK_CLASS( mock_class_with_non_const_conversion_operator ) - { - MOCK_CONST_CONVERSION_OPERATOR( operator, int, conversion ) - }; -} + MOCK_CONST_CONVERSION_OPERATOR(operator, int, conversion) +}; +} // namespace -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) { - template< typename T > - MOCK_CLASS( mock_template_class_with_const_conversion_operator ) - { - MOCK_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) - }; -} + MOCK_CONST_CONVERSION_OPERATOR_TPL(operator, T, conversion) +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_template_const_conversion_operator, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_template_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_const_conversion_operator m; + 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_non_const_conversion_operator) { - template< typename T > - MOCK_CLASS( mock_template_class_with_non_const_conversion_operator ) - { - MOCK_NON_CONST_CONVERSION_OPERATOR_TPL( operator, T, conversion ) - }; -} + MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(operator, T, conversion) +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_template_non_const_conversion_operator, mock_error_fixture ) +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 ); + 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 +namespace { +MOCK_CLASS(my_mock) { - 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 ) - }; -} + MOCK_CONST_METHOD_EXT(my_method, 1, void(int), my_method) + MOCK_CONST_METHOD_EXT(my_method_2, 1, void(int), my_method_2) +}; +} // namespace -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; - const auto f = std::bind( &my_mock::my_method, &m, 42 ); - (void) f; + const auto f = std::bind(&my_mock::my_method, &m, 42); + (void)f; } -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))); } -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) { - std::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 ) ) ); + std::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 std::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 std::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( f, void( T ) ); - }; -} + MOCK_FUNCTOR(f, void(T)); +}; +} // namespace -BOOST_FIXTURE_TEST_CASE( mock_functor_reset, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_reset, mock_error_fixture) { - MOCK_FUNCTOR( f, void() ); - MOCK_RESET( f ); - mock::reset( f ); + MOCK_FUNCTOR(f, void()); + MOCK_RESET(f); + mock::reset(f); } -BOOST_FIXTURE_TEST_CASE( mock_functor_verify, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_verify, mock_error_fixture) { - MOCK_FUNCTOR( f, void() ); - MOCK_VERIFY( f ); - mock::verify( f ); + MOCK_FUNCTOR(f, void()); + MOCK_VERIFY(f); + mock::verify(f); } -BOOST_FIXTURE_TEST_CASE( mock_functor_is_named, mock_error_fixture ) +BOOST_FIXTURE_TEST_CASE(mock_functor_is_named, mock_error_fixture) { - MOCK_FUNCTOR( f, void() ); - BOOST_CHECK_EQUAL( "f", to_string( MOCK_HELPER( f ) ) ); + MOCK_FUNCTOR(f, void()); + BOOST_CHECK_EQUAL("f", to_string(MOCK_HELPER(f))); } -namespace +namespace { +MOCK_FUNCTION(mock_function, 1, float(int), mock_function) +} + +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 ) +namespace { +MOCK_CLASS(static_function_class) { - BOOST_CHECK_EQUAL( "mock_function", to_string( MOCK_HELPER( mock_function ) ) ); -} + MOCK_STATIC_METHOD(f, 1, float(int), f) +}; +} // namespace -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 ) ) ); -} + MOCK_METHOD_EXT(m0, 0, MOCK_PROTECT_FUNCTION_SIG(std::map()), m0) + MOCK_STATIC_METHOD(m1, 0, MOCK_PROTECT_FUNCTION_SIG(std::map()), m1) + MOCK_FUNCTOR(f0, MOCK_PROTECT_FUNCTION_SIG(std::map())); +}; +MOCK_FUNCTION(fun0, 0, MOCK_PROTECT_FUNCTION_SIG(std::map()), fun0) +} // namespace -namespace +namespace { +struct base { - MOCK_CLASS( round_parenthesized_signature ) - { - MOCK_METHOD_EXT( m0, 0, MOCK_PROTECT_FUNCTION_SIG(std::map< int, int >()), m0 ) - MOCK_STATIC_METHOD( m1, 0, MOCK_PROTECT_FUNCTION_SIG(std::map< int, int >()), m1 ) - MOCK_FUNCTOR( f0, MOCK_PROTECT_FUNCTION_SIG(std::map< int, int >()) ); - }; - MOCK_FUNCTION( fun0, 0, MOCK_PROTECT_FUNCTION_SIG(std::map< int, int >()), fun0 ) -} + virtual ~base() = default; -namespace + virtual void m1() = 0; + virtual void m10() const = 0; + virtual void m11() = 0; +}; + +MOCK_BASE_CLASS(variadic, base) { - struct base - { - virtual ~base() = default; + 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) +}; - virtual void m1() = 0; - virtual void m10() const = 0; - virtual void m11() = 0; - }; +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( 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(comma_base, std::map) +{}; - template< typename T > - MOCK_BASE_CLASS( variadic_tpl, base ) - { - MOCK_METHOD( m1, 0, void() ) - MOCK_METHOD_TPL( m2, 0, T() ) - MOCK_METHOD_TPL( m3, 0, T(), m3 ) - MOCK_CONST_METHOD_TPL( m4, 0, T() ) - MOCK_CONST_METHOD_TPL( m5, 0, T(), m5 ) - MOCK_NON_CONST_METHOD_TPL( m6, 0, T() ) - MOCK_NON_CONST_METHOD_TPL( m7, 0, T(), m7 ) - MOCK_STATIC_METHOD_TPL( m8, 0, T() ) - MOCK_STATIC_METHOD_TPL( m9, 0, T(), m9 ) - }; +MOCK_FUNCTION(fun1, 0, void()) +MOCK_FUNCTION(fun2, 0, void(), fun2) +MOCK_FUNCTION(fun3, 0, MOCK_PROTECT_FUNCTION_SIG(std::map())) - MOCK_BASE_CLASS( comma_base, std::map< int, int > ) - {}; - - MOCK_FUNCTION( fun1, 0, void() ) - MOCK_FUNCTION( fun2, 0, void(), fun2 ) - MOCK_FUNCTION( fun3, 0, MOCK_PROTECT_FUNCTION_SIG(std::map< int, int >()) ) - - MOCK_FUNCTOR( f_variadic, std::map< int, int >() ); -} +MOCK_FUNCTOR(f_variadic, std::map()); +} // namespace #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() = default; + virtual ~base() = default; - 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_METHOD( MOCK_STDCALL m3, 0, void(), m3 ) - MOCK_STATIC_METHOD( MOCK_STDCALL m4, 0, void(), m4 ) - }; +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_METHOD(MOCK_STDCALL m3, 0, void(), m3) + 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 bd11dc3..2c1e202 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 -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::detail::make_type_name(o), "name" ); - } - object o; - mock::detail::function< void() > e; - }; -} + fixture() { mock::detail::configure(o, e, "instance", mock::detail::make_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::detail::make_type_name(o2), "name" ); + mock::detail::configure(o2, e, "instance", mock::detail::make_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) { auto o2 = std::make_unique(); - const object o1( *o2 ); - mock::detail::function< void() > e; - mock::detail::configure( *o2, e, "instance", mock::detail::make_type_name(*o2), "name" ); + const object o1(*o2); + mock::detail::function e; + mock::detail::configure(*o2, e, "instance", mock::detail::make_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 2a7b584..2415cf4 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); }