TestCaller.h

Go to the documentation of this file.

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
 
#ifndef META_OCEAN_TEST_TESTBASE_TEST_CALLER_H
#define META_OCEAN_TEST_TESTBASE_TEST_CALLER_H
 
#include "ocean/test/testbase/TestBase.h"
 
#include "ocean/base/Caller.h"
 
namespace Ocean
{
 
namespace Test
{
 
namespace TestBase
{
 
/**
 * This class implements a caller test.
 * @ingroup testbase
 */
class OCEAN_TEST_BASE_EXPORT TestCaller
{
    protected:
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param0
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param1
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param2
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param3
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param4
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param5
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param6
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param7
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param8
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param9
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param10
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param11
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param12
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param13
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param14
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param15
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param16
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param17
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param18
        {
            // nothing to do here
        };
 
        /**
         * This class implements an arbitrary parameter.
         */
        class Param19
        {
            // nothing to do here
        };
 
        /**
         * This class implements a helper class holding member functions.
         */
        class Object
        {
            public:
 
                /**
                 * Default constructor doing nothing.
                 */
                Object();
 
                /**
                 * Member function with no parameter.
                 */
                void function();
 
                /**
                 * Member function with one parameter.
                 * @param p0 First parameter
                 */
                void function(Param0* p0);
 
                /**
                 * Member function with two parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 */
                void function(Param0* p0, Param1* p1);
 
                /**
                 * Member function with three parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2);
 
                /**
                 * Member function with four parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3);
 
                /**
                 * Member function with five parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4);
 
                /**
                 * Member function with six parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5);
 
                /**
                 * Member function with seven parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6);
 
                /**
                 * Member function with eight parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7);
 
                /**
                 * Member function with nine parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 * @param p8 Ninth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8);
 
                /**
                 * Member function with ten parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 * @param p8 Ninth parameter
                 * @param p9 Tenth parameter
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9);
 
                /**
                 * Member function with 11 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10);
 
                /**
                 * Member function with 12 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11);
 
                /**
                 * Member function with 13 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12);
 
                /**
                 * Member function with 14 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13);
 
                /**
                 * Member function with 15 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14);
 
                /**
                 * Member function with 16 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15);
 
                /**
                 * Member function with 17 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16);
 
                /**
                 * Member function with 18 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17);
 
                /**
                 * Member function with 19 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18);
 
                /**
                 * Member function with 20 parameter.
                 */
                void function(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18, Param19* p19);
 
                /**
                 * Member function with no parameter.
                 * @return True, if succeeded
                 */
                int functionInt() const;
 
                /**
                 * Member function with one parameter.
                 * @param p0 First parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0) const;
 
                /**
                 * Member function with two parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1) const;
 
                /**
                 * Member function with three parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2) const;
 
                /**
                 * Member function with four parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3) const;
 
                /**
                 * Member function with five parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4) const;
 
                /**
                 * Member function with six parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5) const;
 
                /**
                 * Member function with seven parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6) const;
 
                /**
                 * Member function with eight parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7) const;
 
                /**
                 * Member function with nine parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 * @param p8 Ninth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8) const;
 
                /**
                 * Member function with ten parameter.
                 * @param p0 First parameter
                 * @param p1 Second parameter
                 * @param p2 Third parameter
                 * @param p3 Fourth parameter
                 * @param p4 Fifth parameter
                 * @param p5 Sixth parameter
                 * @param p6 Seventh parameter
                 * @param p7 Eighth parameter
                 * @param p8 Ninth parameter
                 * @param p9 Tenth parameter
                 * @return True, if succeeded
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9) const;
 
                /**
                 * Member function with 11 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10) const;
 
                /**
                 * Member function with 12 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11) const;
 
                /**
                 * Member function with 13 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12) const;
 
                /**
                 * Member function with 14 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13) const;
 
                /**
                 * Member function with 15 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14) const;
 
                /**
                 * Member function with 16 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15) const;
 
                /**
                 * Member function with 17 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16) const;
 
                /**
                 * Member function with 18 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17) const;
 
                /**
                 * Member function with 19 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18) const;
 
                /**
                 * Member function with 20 parameter.
                 */
                int functionInt(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18, Param19* p19) const;
 
                /**
                 * Constant member with individual parameter types, but without references.
                 * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
                 * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
                 * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
                 * @param parameter3 A string parameter, which will be cleared (while it is not a reference)
                 * @return Returns -1 always
                 */
                int constantFunctionIndividualParameters0(int parameter0, bool* parameter1, float* parameter2, std::string parameter3) const;
 
                /**
                 * Constant member with individual parameter types, with references.
                 * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
                 * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
                 * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
                 * @param parameter3 A double parameter, which will be increated by 20 (while it is a reference)
                 * @param parameter4 A string parameter, which will be cleared (while it is not a reference)
                 * @param parameter5 A string parameter, which will be mirrored (while it is a reference)
                 * @param parameter6 A constant object parameter as reference
                 * @return Returns -1 always
                 */
                int constantFunctionIndividualParameters1(int parameter0, bool* parameter1, float* parameter2, double& parameter3, std::string parameter4, std::string& parameter5, const Object& parameter6) const;
 
                /**
                 * Constant member with individual parameter types, but without references.
                 * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
                 * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
                 * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
                 * @param parameter3 A string parameter, which will be cleared (while it is not a reference)
                 * @return Returns -1 always
                 */
                int nonConstantFunctionIndividualParameters0(int parameter0, bool* parameter1, float* parameter2, std::string parameter3);
 
                /**
                 * Constant member with individual parameter types, with references.
                 * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
                 * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
                 * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
                 * @param parameter3 A double parameter, which will be increated by 20 (while it is a reference)
                 * @param parameter4 A string parameter, which will be cleared (while it is not a reference)
                 * @param parameter5 A string parameter, which will be mirrored (while it is a reference)
                 * @param parameter6 A constant object parameter as reference
                 * @return Returns -1 always
                 */
                int nonConstantFunctionIndividualParameters1(int parameter0, bool* parameter1, float* parameter2, double& parameter3, std::string parameter4, std::string& parameter5, const Object& parameter6);
        };
 
    public:
 
        /**
         * Tests the entire caller functionality.
         * @return True, if succeeded
         */
        static bool test();
 
        /**
         * Tests the caller object with member functions.
         * @return True, if succeeded
         */
        static bool testCallerMembers();
 
        /**
         * Tests the caller object with static functions.
         * @return True, if succeeded
         */
        static bool testCallerStatics();
 
        /**
         * Tests the caller object with a mixture of parameter types.
         * @return True, if succeeded
         */
        static bool testCallerParameters();
    
    private:
 
        /**
         * Static function with no parameter.
         */
        static void function0();
 
        /**
         * Static function with one parameter.
         * @param p0 First parameter
         */
        static void function1(Param0* p0);
 
        /**
         * Static function with two parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         */
        static void function2(Param0* p0, Param1* p1);
 
        /**
         * Static function with three parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         */
        static void function3(Param0* p0, Param1* p1, Param2* p2);
 
        /**
         * Static function with four parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         */
        static void function4(Param0* p0, Param1* p1, Param2* p2, Param3* p3);
 
        /**
         * Static function with five parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         */
        static void function5(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4);
 
        /**
         * Static function with six parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         */
        static void function6(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5);
 
        /**
         * Static function with seven parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         */
        static void function7(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6);
 
        /**
         * Static function with eight parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         */
        static void function8(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7);
 
        /**
         * Static function with nine parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         * @param p8 Ninth parameter
         */
        static void function9(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8);
 
        /**
         * Static function with ten parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         * @param p8 Ninth parameter
         * @param p9 Tenth parameter
         */
        static void function10(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9);
 
        /**
         * Static function with 11 parameter.
         */
        static void function11(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10);
 
        /**
         * Static function with 12 parameter.
         */
        static void function12(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11);
 
        /**
         * Static function with 13 parameter.
         */
        static void function13(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12);
 
        /**
         * Static function with 14 parameter.
         */
        static void function14(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13);
 
        /**
         * Static function with 15 parameter.
         */
        static void function15(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14);
 
        /**
         * Static function with 16 parameter.
         */
        static void function16(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15);
 
        /**
         * Static function with 17 parameter.
         */
        static void function17(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16);
 
        /**
         * Static function with 18 parameter.
         */
        static void function18(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17);
 
        /**
         * Static function with 19 parameter.
         */
        static void function19(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18);
 
        /**
         * Static function with 20 parameter.
         */
        static void function20(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18, Param19* p19);
 
        /**
         * Static function with no parameter.
         * @return True, if succeeded
         */
        static int functionInt0();
 
        /**
         * Static function with one parameter.
         * @param p0 First parameter
         * @return True, if succeeded
         */
        static int functionInt1(Param0* p0);
 
        /**
         * Static function with two parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @return True, if succeeded
         */
        static int functionInt2(Param0* p0, Param1* p1);
 
        /**
         * Static function with three parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @return True, if succeeded
         */
        static int functionInt3(Param0* p0, Param1* p1, Param2* p2);
 
        /**
         * Static function with four parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @return True, if succeeded
         */
        static int functionInt4(Param0* p0, Param1* p1, Param2* p2, Param3* p3);
 
        /**
         * Static function with five parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @return True, if succeeded
         */
        static int functionInt5(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4);
 
        /**
         * Static function with six parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @return True, if succeeded
         */
        static int functionInt6(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5);
 
        /**
         * Static function with seven parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @return True, if succeeded
         */
        static int functionInt7(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6);
 
        /**
         * Static function with eight parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         * @return True, if succeeded
         */
        static int functionInt8(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7);
 
        /**
         * Static function with nine parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         * @param p8 Ninth parameter
         * @return True, if succeeded
         */
        static int functionInt9(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8);
 
        /**
         * Static function with ten parameter.
         * @param p0 First parameter
         * @param p1 Second parameter
         * @param p2 Third parameter
         * @param p3 Fourth parameter
         * @param p4 Fifth parameter
         * @param p5 Sixth parameter
         * @param p6 Seventh parameter
         * @param p7 Eighth parameter
         * @param p8 Ninth parameter
         * @param p9 Tenth parameter
         * @return True, if succeeded
         */
        static int functionInt10(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9);
 
        /**
         * Static function with 11 parameter.
         */
        static int functionInt11(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10);
 
        /**
         * Static function with 12 parameter.
         */
        static int functionInt12(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11);
 
        /**
         * Static function with 13 parameter.
         */
        static int functionInt13(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12);
 
        /**
         * Static function with 14 parameter.
         */
        static int functionInt14(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13);
 
        /**
         * Static function with 15 parameter.
         */
        static int functionInt15(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14);
 
        /**
         * Static function with 16 parameter.
         */
        static int functionInt16(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15);
 
        /**
         * Static function with 17 parameter.
         */
        static int functionInt17(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16);
 
        /**
         * Static function with 18 parameter.
         */
        static int functionInt18(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17);
 
        /**
         * Static function with 19 parameter.
         */
        static int functionInt19(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18);
 
        /**
         * Static function with 20 parameter.
         */
        static int functionInt20(Param0* p0, Param1* p1, Param2* p2, Param3* p3, Param4* p4, Param5* p5, Param6* p6, Param7* p7, Param8* p8, Param9* p9, Param10* p10, Param11* p11, Param12* p12, Param13* p13, Param14* p14, Param15* p15, Param16* p16, Param17* p17, Param18* p18, Param19* p19);
 
        /**
         * Static function with individual parameter types, but without references.
         * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
         * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
         * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
         * @param parameter3 A string parameter, which will be cleared (while it is not a reference)
         * @return Returns -1 always
         */
        static int functionIndividualParameters0(int parameter0, bool* parameter1, float* parameter2, std::string parameter3);
 
        /**
         * Static function with individual parameter types, with references.
         * @param parameter0 An integer parameter, which will be increased by one (while it is not a reference)
         * @param parameter1 A boolean parameter, which will be inverted (while it is a pointer)
         * @param parameter2 A float parameter, which will be increated by 10 (while it is a pointer)
         * @param parameter3 A double parameter, which will be increated by 20 (while it is a reference)
         * @param parameter4 A string parameter, which will be cleared (while it is not a reference)
         * @param parameter5 A string parameter, which will be mirrored (while it is a reference)
         * @param parameter6 A constant object parameter as reference
         * @return Returns -1 always
         */
        static int functionIndividualParameters1(int parameter0, bool* parameter1, float* parameter2, double& parameter3, std::string parameter4, std::string& parameter5, const Object& parameter6);
};
 
}
 
}
 
}
 
#endif // META_OCEAN_TEST_TESTBASE_TEST_CALLER_H