remove C-Mock source

- use c-mock of tizen
- use downloaded c-mock for linux

diff --git a/debian/rules b/debian/rules
index 2392d3f..1555513 100755 (executable)
--- a/debian/rules
+++ b/debian/rules
@@ -37,6 +37,10 @@ override_dh_auto_clean:
 override_dh_auto_configure:
        mkdir -p ${AITT_BUILD_ROOT_PATH}; \
        cd ${AITT_BUILD_ROOT_PATH}; \
+       wget -N -T 3 https://github.com/hjagodzinski/C-Mock/archive/refs/tags/v0.4.0.tar.gz; \
+       wget -N -T 3 https://github.com/hjagodzinski/C-Mock/archive/refs/tags/v0.3.1.tar.gz; \
+       tar -xvf v0.4.0.tar.gz; \
+       tar -xvf v0.3.1.tar.gz; \
        cmake .. \
                -DPLATFORM=${PLATFORM} \
                -DCMAKE_INSTALL_PREFIX:PATH=/usr \

diff --git a/external/C-Mock/LICENSE.md b/external/C-Mock/LICENSE.md
deleted file mode 100644 (file)
index a5d6631..0000000
--- a/external/C-Mock/LICENSE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-Copyright (c) 2013, Hubert Jagodziński
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

diff --git a/external/C-Mock/README.md b/external/C-Mock/README.md
deleted file mode 100644 (file)
index c074b92..0000000
--- a/external/C-Mock/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-C Mock - Google Mock Extension
-==============================
-
-https://github.com/hjagodzinski/C-Mock
-
-Overview
---------
-
-C Mock is [Google Mock](https://github.com/google/googletest)'s extension allowing a function mocking.
-
-This is neither a patch to nor fork of Google Mock. This is just a set of headers providing a way to use tools for mock methods with mock functions in tests.
-
-C Mock is not intended to promote a bad design. Its goal is to aid the developers test their code.

diff --git a/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h b/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h
deleted file mode 100644 (file)
index b1e6a44..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h
+++ /dev/null
@@ -1,370 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py cmock-function-class-mockers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements CMockMocker class and CMOCK_MOCK_FUNCTIONn() macros of
-// various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-// Allows finding an instance of a class:
-//   class Foo : public CMockMocker<Foo> { ... }
-//   Foo *p = CMockMocker<Foo>::cmock_get_instance();
-template<typename T>
-class CMockMocker
-{
-public:
-       CMockMocker()
-       {
-               instance = (T *)this;
-       }
-
-       ~CMockMocker()
-       {
-               instance = (T *)NULL;
-       }
-
-       static T *cmock_get_instance() { return instance; }
-
-private:
-       static T *instance;
-};
-
-template<typename T>
-T *CMockMocker<T>::instance = NULL;
-
-// Find the real implementation of a mocked function
-static inline void *
-cmock_lookup(const char *fname)
-{
-    return dlsym(RTLD_NEXT, fname);
-}
-
-#define CMOCK_MOCK_FUNCTION0(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)() = \
-       (GMOCK_RESULT_(, F) (*)())cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n() { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(); \
-} \
-
-#define CMOCK_MOCK_FUNCTION1(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1) = \
-       (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1); \
-} \
-
-#define CMOCK_MOCK_FUNCTION2(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2); \
-} \
-
-#define CMOCK_MOCK_FUNCTION3(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, \
-    F) cmock_a3) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3); \
-} \
-
-#define CMOCK_MOCK_FUNCTION4(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-     F) cmock_a4))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-    F) cmock_a4) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-} \
-
-#define CMOCK_MOCK_FUNCTION5(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5); \
-} \
-
-#define CMOCK_MOCK_FUNCTION6(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-    F) cmock_a6) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-     F) cmock_a6))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5, cmock_a6); \
-} \
-
-#define CMOCK_MOCK_FUNCTION7(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-    F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
-     7, F) cmock_a7))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5, cmock_a6, cmock_a7); \
-} \
-
-#define CMOCK_MOCK_FUNCTION8(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-    F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
-    F) cmock_a8) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
-     7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5, cmock_a6, cmock_a7, cmock_a8); \
-} \
-
-#define CMOCK_MOCK_FUNCTION9(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-    F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, \
-    GMOCK_ARG_(, 9, F) cmock_a9) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
-     7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-     F) cmock_a9))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-    F) cmock_a9) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5, cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-} \
-
-#define CMOCK_MOCK_FUNCTION10(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
-    F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-    GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-    F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, \
-    GMOCK_ARG_(, 9, F) cmock_a9, GMOCK_ARG_(, 10, F) cmock_a10) = \
- (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
-     7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-     F) cmock_a9, GMOCK_ARG_(, 10, F) cmock_a10))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-    GMOCK_ARG_(, 10, F) cmock_a10) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
-        cmock_a5, cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-} \
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_

diff --git a/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h.pump b/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h.pump
deleted file mode 100644 (file)
index 7ac55db..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock-function-class-mockers.h.pump
+++ /dev/null
@@ -1,109 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ cmock-function-mockers.h.  Pump (pump.py) can be found in
-$$ googletest/scripts.
-$$
-$var n = 10  $$ The maximum arity we support.
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements CMockMocker class and CMOCK_MOCK_FUNCTIONn() macros of various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-// Allows finding an instance of a class:
-//   class Foo : public CMockMocker<Foo> { ... }
-//   Foo *p = CMockMocker<Foo>::cmock_get_instance();
-template<typename T>
-class CMockMocker
-{
-public:
-       CMockMocker()
-       {
-               instance = (T *)this;
-       }
-
-       ~CMockMocker()
-       {
-               instance = (T *)NULL;
-       }
-
-       static T *cmock_get_instance() { return instance; }
-       
-private:
-       static T *instance;
-};
-
-template<typename T>
-T *CMockMocker<T>::instance = NULL;
-
-// Find the real implementation of a mocked function
-static inline void *
-cmock_lookup(const char *fname)
-{
-    return dlsym(RTLD_NEXT, fname);
-}
-
-$range i 0..n
-
-$for i [[
-$range j 1..i
-$var call_args = [[$for j, [[cmock_a$j]]]]
-$var declare_args = [[$for j, [[GMOCK_ARG_(, $j, F) cmock_a$j]]]]
-$var matcher_args = [[$for j, [[GMOCK_MATCHER_(, $j, F) cmock_a$j]]]]
-
-#define CMOCK_MOCK_FUNCTION$i(c, n, F) \
-static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)($declare_args) = \
-       (GMOCK_RESULT_(, F) (*)($declare_args))cmock_lookup(#n); \
-\
-GMOCK_RESULT_(, F) n($declare_args) { \
-    c *mock = c::cmock_get_instance(); \
-    if (mock != NULL) { \
-        return mock->n($call_args); \
-    } \
-       \
-    if (__cmock_real_##c##_##n == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return __cmock_real_##c##_##n($call_args); \
-} \
-
-]]
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_

diff --git a/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h b/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h
deleted file mode 100644 (file)
index 8fd2a8a..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h
+++ /dev/null
@@ -1,1082 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py cmock-function-mockers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements DECLARE_FUNCTION_MOCKn() and IMPLEMENT_FUNCTION_MOCKn()
-// macros of various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-#define DECLARE_FUNCTION_MOCK0(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(); \
-        ::testing::MockSpec<F> cmock_func(); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK0(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()() { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
-     this_method_does_not_take_0_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func() { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call() { \
-    if (instance != NULL) { \
-        return (*instance)(); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n() { \
-    return c::call(); \
-}
-
-#define DECLARE_FUNCTION_MOCK1(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK1(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
-     this_method_does_not_take_1_argument); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1) { \
-    return c::call(cmock_a1); \
-}
-
-#define DECLARE_FUNCTION_MOCK2(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK2(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
-     this_method_does_not_take_2_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2) { \
-    return c::call(cmock_a1, cmock_a2); \
-}
-
-#define DECLARE_FUNCTION_MOCK3(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, \
-            F) cmock_a3); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK3(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
-     this_method_does_not_take_3_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3); \
-}
-
-#define DECLARE_FUNCTION_MOCK4(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK4(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-    F) cmock_a4) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
-     this_method_does_not_take_4_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-    F) cmock_a4) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-    F) cmock_a4) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
-}
-
-#define DECLARE_FUNCTION_MOCK5(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, \
-            F) cmock_a5); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK5(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
-     this_method_does_not_take_5_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
-}
-
-#define DECLARE_FUNCTION_MOCK6(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-        GMOCK_ARG_(, 6, F) cmock_a6); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-            GMOCK_MATCHER_(, 6, F) cmock_a6); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-            F) cmock_a6); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK6(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
-     this_method_does_not_take_6_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-         cmock_a6); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-    GMOCK_MATCHER_(, 6, F) cmock_a6) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6); \
-}
-
-#define DECLARE_FUNCTION_MOCK7(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-        GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-            GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, \
-            F) cmock_a7); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-            F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK7(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
-     this_method_does_not_take_7_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-         cmock_a6, cmock_a7); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-    GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
-        cmock_a7); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7); \
-}
-
-#define DECLARE_FUNCTION_MOCK8(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-        GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-        GMOCK_ARG_(, 8, F) cmock_a8); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-            GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-            GMOCK_MATCHER_(, 8, F) cmock_a8); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-            F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
-            F) cmock_a8); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK8(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
-     this_method_does_not_take_8_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-         cmock_a6, cmock_a7, cmock_a8); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-    GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-    GMOCK_MATCHER_(, 8, F) cmock_a8) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
-        cmock_a7, cmock_a8); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8); \
-}
-
-#define DECLARE_FUNCTION_MOCK9(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-        GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-        GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-            GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-            GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, \
-            F) cmock_a9); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-            F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
-            F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK9(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-    F) cmock_a9) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
-     this_method_does_not_take_9_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-         cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-    GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-    GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-    F) cmock_a9) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
-        cmock_a7, cmock_a8, cmock_a9); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
-    F) cmock_a9) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
-}
-
-#define DECLARE_FUNCTION_MOCK10(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
-        GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-        GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-        GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-        GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-        GMOCK_ARG_(, 10, F) cmock_a10); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-            GMOCK_ARG_(, 10, F) cmock_a10); \
-        ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-            GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-            GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-            GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-            GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9, \
-            GMOCK_MATCHER_(, 10, F) cmock_a10); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
-            GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
-            GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
-            GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
-            GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-            GMOCK_ARG_(, 10, F) cmock_a10); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
-            2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
-            F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
-            F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
-            F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, GMOCK_ARG_(, 10, \
-            F) cmock_a10); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK10(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-    GMOCK_ARG_(, 10, F) cmock_a10) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
-     this_method_does_not_take_10_arguments); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-         cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
-    GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
-    GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
-    GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
-    GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9, \
-    GMOCK_MATCHER_(, 10, F) cmock_a10) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-    GMOCK_ARG_(, 10, F) cmock_a10) { \
-    if (instance != NULL) { \
-        return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-            cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
-        cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
-    F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
-    GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
-    F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
-    GMOCK_ARG_(, 10, F) cmock_a10) { \
-    return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
-        cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
-}
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_

diff --git a/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h.pump b/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h.pump
deleted file mode 100644 (file)
index 652e4c2..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h.pump
+++ /dev/null
@@ -1,129 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ cmock-function-mockers.h.  Pump (pump.py) can be found in
-$$ googletest/scripts.
-$$
-$var n = 10  $$ The maximum arity we support.
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements DECLARE_FUNCTION_MOCKn() and IMPLEMENT_FUNCTION_MOCKn() macros of various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-$range i 0..n
-
-$for i [[
-$range j 1..i
-$var call_args = [[$for j, [[cmock_a$j]]]]
-$var declare_args = [[$for j, [[GMOCK_ARG_(, $j, F) cmock_a$j]]]]
-$var matcher_args = [[$for j, [[GMOCK_MATCHER_(, $j, F) cmock_a$j]]]]
-
-#define DECLARE_FUNCTION_MOCK$i(c, n, F) \
-class c \
-{ \
-    typedef GMOCK_RESULT_(, F) (*func_type)($declare_args); \
-\
-    public: \
-        static func_type real; \
-\
-        c(); \
-        ~c(); \
-\
-        GMOCK_RESULT_(, F) operator()($declare_args); \
-        ::testing::MockSpec<F> cmock_func($matcher_args); \
-\
-    private: \
-        static func_type lookup(); \
-        static GMOCK_RESULT_(, F) call($declare_args); \
-\
-        static c *instance; \
-\
-        ::testing::FunctionMocker<F> mocker; \
-\
-        friend GMOCK_RESULT_(, F) n($declare_args); \
-};
-
-#define IMPLEMENT_FUNCTION_MOCK$i(c, n, F) \
-c::c() { \
-    instance = this; \
-} \
-\
-c::~c() { \
-    instance = NULL; \
-} \
-\
-GMOCK_RESULT_(, F) c::operator()($declare_args) { \
-    GTEST_COMPILE_ASSERT_(::std::tuple_size< \
-    ::testing::internal::Function<F>::ArgumentTuple>::value == $i, \
-     this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
-     mocker.SetOwnerAndName(this, #n); \
-     return mocker.Invoke($call_args); \
-} \
-\
-::testing::MockSpec<F> c::cmock_func($matcher_args) { \
-    mocker.RegisterOwner(this); \
-    return mocker.With($call_args); \
-} \
-\
-c::func_type c::lookup() { \
-    return (c::func_type)dlsym(RTLD_NEXT, #n); \
-} \
-\
-GMOCK_RESULT_(, F) c::call($declare_args) { \
-    if (instance != NULL) { \
-        return (*instance)($call_args); \
-    } \
-\
-    if (real == NULL) { \
-        std::ostringstream msg; \
-        msg << "Error: Function " << #n; \
-        msg << " not found. Neither mock nor real function is present."; \
-        throw std::logic_error(msg.str()); \
-    } \
-    return real($call_args); \
-} \
-\
-c *c::instance = NULL; \
-c::func_type c::real = lookup(); \
-\
-GMOCK_RESULT_(, F) n($declare_args) { \
-    return c::call($call_args); \
-}
-
-]]
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_

diff --git a/external/C-Mock/v0.3.1/cmock/cmock-spec-builders.h b/external/C-Mock/v0.3.1/cmock/cmock-spec-builders.h
deleted file mode 100644 (file)
index 52438dc..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock-spec-builders.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements ON_FUNCTION_CALL() and EXPECT_FUNCTION_CALL() macros.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_
-
-#define CMOCK_ON_FUNCTION_CALL_IMPL_(obj, call) \
-    ((obj).cmock_func call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
-                                                    #obj, #call)
-#define ON_FUNCTION_CALL(obj, call) CMOCK_ON_FUNCTION_CALL_IMPL_(obj, call)
-
-#define CMOCK_EXPECT_FUNCTION_CALL_IMPL_(obj, call) \
-    ((obj).cmock_func call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
-#define EXPECT_FUNCTION_CALL(obj, call) CMOCK_EXPECT_FUNCTION_CALL_IMPL_(obj, call)
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_

diff --git a/external/C-Mock/v0.3.1/cmock/cmock.h b/external/C-Mock/v0.3.1/cmock/cmock.h
deleted file mode 100644 (file)
index c059a82..0000000
--- a/external/C-Mock/v0.3.1/cmock/cmock.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This is the main header file an user should include.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_H_
-
-#include <gmock/gmock.h>
-
-#include "cmock-function-mockers.h"
-#include "cmock-function-class-mockers.h"
-#include "cmock-spec-builders.h"
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_H_

diff --git a/external/C-Mock/v0.4.0/cmock/cmock-function-class-mockers.h b/external/C-Mock/v0.4.0/cmock/cmock-function-class-mockers.h
deleted file mode 100644 (file)
index ca39ea2..0000000
--- a/external/C-Mock/v0.4.0/cmock/cmock-function-class-mockers.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements CMockMocker class, the generic macros CMOCK_MOCK_METHOD & CMOCK_MOCK_FUNCTION
-// and old-style CMOCK_MOCK_FUNCTIONn() macros of various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-#include "cmock/cmock-internal.h"
-
-// Allows finding an instance of a class:
-//   class Foo : public CMockMocker<Foo> { ... }
-//   Foo *p = CMockMocker<Foo>::cmock_get_instance();
-template<typename T>
-class CMockMocker
-{
-public:
-       CMockMocker()
-       {
-               instance = (T *)this;
-       }
-
-       ~CMockMocker()
-       {
-               instance = (T *)NULL;
-       }
-
-       static T *cmock_get_instance() { return instance; }
-
-private:
-       static T *instance;
-};
-
-template<typename T>
-T *CMockMocker<T>::instance = NULL;
-
-// Find the real implementation of a mocked function
-static inline void *
-cmock_lookup(const char *fname)
-{
-    return dlsym(RTLD_NEXT, fname);
-}
-
-#define CMOCK_MOCK_METHOD(_Ret, _FunctionName, _Args) \
-    MOCK_METHOD(_Ret, _FunctionName, _Args); \
-\
-    typedef _Ret (*_FunctionName##_type)(GMOCK_PP_REPEAT(CMOCK_INTERNAL_NO_PARAMETER_NAME, (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)), GMOCK_PP_NARG0 _Args)); \
-    static _FunctionName##_type cmock_real_##_FunctionName;
-
-#define CMOCK_INTERNAL_IMPLEMENT_FUNCTION(_ClassName, _FunctionName, _RealFunctionPtr, _N, _Signature) \
-    CMOCK_INTERNAL_RETURN_TYPE(_Signature) _FunctionName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) { \
-        _ClassName *mock = _ClassName::cmock_get_instance(); \
-        if (mock != nullptr) { \
-            return mock->_FunctionName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-        } \
-\
-        if (_RealFunctionPtr == nullptr) { \
-            std::ostringstream msg; \
-            msg << "Error: Function " << #_FunctionName; \
-            msg << " not found. Neither mock nor real function is present."; \
-            throw std::logic_error(msg.str()); \
-        } \
-        return _RealFunctionPtr(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-    }
-
-#define CMOCK_REAL_FUNCTION(_ClassName, _FunctionName) \
-    _ClassName::cmock_real_##_FunctionName
-
-#define CMOCK_MOCK_FUNCTION(_ClassName,  _Ret, _FunctionName, _Args) \
-    _ClassName::_FunctionName##_type CMOCK_REAL_FUNCTION(_ClassName, _FunctionName) = (_ClassName::_FunctionName##_type)cmock_lookup(#_FunctionName); \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION(_ClassName, _FunctionName, CMOCK_REAL_FUNCTION(_ClassName, _FunctionName), GMOCK_PP_NARG0 _Args, (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
-
-#define CMOCK_INTERNAL_MOCK_FUNCTIONN(_ClassName, _FunctionName, _N, _Signature) \
-    typedef CMOCK_INTERNAL_RETURN_TYPE(_Signature) (*_ClassName##_##_FunctionName##_type)(GMOCK_PP_REPEAT(CMOCK_INTERNAL_NO_PARAMETER_NAME, _Signature, _N)); \
-    static _ClassName##_##_FunctionName##_type cmock_real_##_FunctionName = (_ClassName##_##_FunctionName##_type)cmock_lookup(#_FunctionName); \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION(_ClassName, _FunctionName, cmock_real_##_FunctionName, _N, _Signature)
-
-#define CMOCK_MOCK_FUNCTION0(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 0, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION1(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 1, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION2(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 2, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION3(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 3, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION4(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 4, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION5(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 5, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION6(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 6, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION7(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 7, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION8(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 8, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION9(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 9, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define CMOCK_MOCK_FUNCTION10(c, n, ...) \
-    CMOCK_INTERNAL_MOCK_FUNCTIONN(c, n, 10, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_

diff --git a/external/C-Mock/v0.4.0/cmock/cmock-function-mockers.h b/external/C-Mock/v0.4.0/cmock/cmock-function-mockers.h
deleted file mode 100644 (file)
index e924077..0000000
--- a/external/C-Mock/v0.4.0/cmock/cmock-function-mockers.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements DECLARE_FUNCTION_MOCKn() and IMPLEMENT_FUNCTION_MOCKn()
-// macros of various arities.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
-
-#include <dlfcn.h>
-
-#include <sstream>
-#include <stdexcept>
-
-#include "cmock/cmock-internal.h"
-
-#define CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(_ClassName, _FunctionName, _N, _Signature) \
-    class _ClassName \
-    { \
-        typedef CMOCK_INTERNAL_RETURN_TYPE(_Signature) (*func_type)(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)); \
-\
-        public: \
-            static func_type real; \
-\
-            _ClassName(); \
-            ~_ClassName(); \
-\
-            CMOCK_INTERNAL_RETURN_TYPE(_Signature) operator()(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)); \
-            ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> cmock_func(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)); \
-\
-        private: \
-            static func_type lookup(); \
-            static CMOCK_INTERNAL_RETURN_TYPE(_Signature) call(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)); \
-\
-            static _ClassName *instance; \
-\
-            ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> mocker; \
-\
-            friend CMOCK_INTERNAL_RETURN_TYPE(_Signature) _FunctionName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)); \
-    };
-
-#define CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(_ClassName, _FunctionName, _N, _Signature) \
-    _ClassName::_ClassName() { \
-        instance = this; \
-    } \
-\
-    _ClassName::~_ClassName() { \
-        instance = NULL; \
-    } \
-\
-    CMOCK_INTERNAL_RETURN_TYPE(_Signature) _ClassName::operator()(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) { \
-        mocker.SetOwnerAndName(this, #_FunctionName); \
-        return mocker.Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-    } \
-\
-    ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> _ClassName::cmock_func(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) { \
-        mocker.RegisterOwner(this); \
-        return mocker.With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \
-    } \
-\
-    _ClassName::func_type _ClassName::lookup() { \
-        return (_ClassName::func_type)dlsym(RTLD_NEXT, #_FunctionName); \
-    } \
-\
-    CMOCK_INTERNAL_RETURN_TYPE(_Signature) _ClassName::call(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) { \
-        if (instance != NULL) { \
-            return (*instance)(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-        } \
-\
-        if (real == NULL) { \
-            std::ostringstream msg; \
-            msg << "Error: Function " << #_FunctionName; \
-            msg << " not found. Neither mock nor real function is present."; \
-            throw std::logic_error(msg.str()); \
-        } \
-        return real(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-    } \
-\
-    _ClassName *_ClassName::instance = NULL; \
-    _ClassName::func_type _ClassName::real = lookup(); \
-\
-    CMOCK_INTERNAL_RETURN_TYPE(_Signature) _FunctionName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) { \
-        return _ClassName::call(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
-    }
-
-#define DECLARE_FUNCTION_MOCK0(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 0, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK0(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 0, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK1(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 1, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK1(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 1, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK2(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 2, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK2(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 2, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK3(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 3, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK3(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 3, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK4(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 4, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK4(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 4, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK5(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 5, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK5(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 5, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK6(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 6, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK6(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 6, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK7(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 7, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK7(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 7, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK8(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 8, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK8(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 8, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK9(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 9, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK9(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 9, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define DECLARE_FUNCTION_MOCK10(c, n, ...) \
-    CMOCK_INTERNAL_DECLARE_FUNCTION_MOCKN(c, n, 10, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define IMPLEMENT_FUNCTION_MOCK10(c, n, ...) \
-    CMOCK_INTERNAL_IMPLEMENT_FUNCTION_MOCKN(c, n, 10, (::testing::internal::identity_t<__VA_ARGS__>))
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_

diff --git a/external/C-Mock/v0.4.0/cmock/cmock-internal.h b/external/C-Mock/v0.4.0/cmock/cmock-internal.h
deleted file mode 100644 (file)
index eab684b..0000000
--- a/external/C-Mock/v0.4.0/cmock/cmock-internal.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements helper macros for internal use only.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_INTERNAL_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_INTERNAL_H_
-
-#define CMOCK_INTERNAL_NO_PARAMETER_NAME(_i, _Signature, _) \
-    GMOCK_PP_COMMA_IF(_i) \
-    GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))
-
-#define CMOCK_INTERNAL_RETURN_TYPE(_Signature) \
-    typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(_Signature)>::Result
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_INTERNAL_H_
\ No newline at end of file

diff --git a/external/C-Mock/v0.4.0/cmock/cmock-spec-builders.h b/external/C-Mock/v0.4.0/cmock/cmock-spec-builders.h
deleted file mode 100644 (file)
index 52438dc..0000000
--- a/external/C-Mock/v0.4.0/cmock/cmock-spec-builders.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This file implements ON_FUNCTION_CALL() and EXPECT_FUNCTION_CALL() macros.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_
-
-#define CMOCK_ON_FUNCTION_CALL_IMPL_(obj, call) \
-    ((obj).cmock_func call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
-                                                    #obj, #call)
-#define ON_FUNCTION_CALL(obj, call) CMOCK_ON_FUNCTION_CALL_IMPL_(obj, call)
-
-#define CMOCK_EXPECT_FUNCTION_CALL_IMPL_(obj, call) \
-    ((obj).cmock_func call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
-#define EXPECT_FUNCTION_CALL(obj, call) CMOCK_EXPECT_FUNCTION_CALL_IMPL_(obj, call)
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_SPEC_BUILDERS_H_

diff --git a/external/C-Mock/v0.4.0/cmock/cmock.h b/external/C-Mock/v0.4.0/cmock/cmock.h
deleted file mode 100644 (file)
index c059a82..0000000
--- a/external/C-Mock/v0.4.0/cmock/cmock.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2021, Hubert Jagodziński
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
-
-// C Mock - Google Mock's extension allowing a function mocking.
-//
-// This is the main header file an user should include.
-
-#ifndef CMOCK_INCLUDE_CMOCK_CMOCK_H_
-#define CMOCK_INCLUDE_CMOCK_CMOCK_H_
-
-#include <gmock/gmock.h>
-
-#include "cmock-function-mockers.h"
-#include "cmock-function-class-mockers.h"
-#include "cmock-spec-builders.h"
-
-#endif // CMOCK_INCLUDE_CMOCK_CMOCK_H_

diff --git a/packaging/aitt.spec b/packaging/aitt.spec
index 5a64b76..5b89bab 100644 (file)
--- a/packaging/aitt.spec
+++ b/packaging/aitt.spec
@@ -4,12 +4,12 @@ Release: 0
 Summary: AI Telemetry Transport based on MQTT
 
 Group: Machine Learning / ML Framework
-License: Apache-2.0 and BSD-2-Clause
+License: Apache-2.0
 Source0: %{name}-%{version}.tar.gz
 Source1001: %{name}.manifest
 
 %{?!stdoutlog: %global stdoutlog 0}
-%{?!test: %global test 1}
+%{?!test: %global test 0}
 %{?!gcov: %global gcov 0}
 %{?!use_glib: %global use_glib 1}
 
@@ -17,7 +17,6 @@ BuildRequires: cmake
 BuildRequires: pkgconfig(bundle)
 BuildRequires: pkgconfig(dlog)
 BuildRequires: pkgconfig(flatbuffers)
-BuildRequires: pkgconfig(gmock_main)
 BuildRequires: pkgconfig(libmosquitto)
 BuildRequires: pkgconfig(openssl1.1)
 %if %{use_glib}
@@ -29,7 +28,10 @@ BuildRequires: pkgconfig(capi-media-webrtc)
 BuildRequires: pkgconfig(gstreamer-video-1.0)
 BuildRequires: pkgconfig(glib-2.0)
 BuildRequires: pkgconfig(json-glib-1.0)
-
+%endif
+%if %{test}
+BuildRequires: pkgconfig(gmock_main)
+BuildRequires: pkgconfig(c-mock)
 %endif
 %if %{gcov}
 BuildRequires: lcov
@@ -113,7 +115,7 @@ genhtml %{name}_gcov.info -o out --legend --show-details
 
 %if 0%{test}
 %files unittests
-%license LICENSE.APLv2 external/C-Mock/LICENSE.md
+%license LICENSE.APLv2
 %manifest %{name}.manifest
 %{_bindir}/*_ut*
 %{_bindir}/*_test

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 6bae4af..8581063 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,15 +2,15 @@ set(AITT_UT ${PROJECT_NAME}_ut)
 
 add_definitions(-DLOG_STDOUT)
 
-pkg_check_modules(UT_NEEDS REQUIRED gmock_main)
-include_directories(${UT_NEEDS_INCLUDE_DIRS} ../src)
-link_directories(${UT_NEEDS_LIBRARY_DIRS})
+pkg_check_modules(GTEST REQUIRED gmock_main)
+include_directories(${GTEST_INCLUDE_DIRS} ../src)
+link_directories(${GTEST_LIBRARY_DIRS})
 
 ###########################################################################
 set(AITT_UT_SRC AITT_test.cc RequestResponse_test.cc MainLoopHandler_test.cc aitt_c_test.cc
     AITT_TCP_test.cc)
 add_executable(${AITT_UT} ${AITT_UT_SRC})
-target_link_libraries(${AITT_UT} Threads::Threads ${UT_NEEDS_LIBRARIES} ${PROJECT_NAME})
+target_link_libraries(${AITT_UT} Threads::Threads ${GTEST_LIBRARIES} ${PROJECT_NAME})
 
 install(TARGETS ${AITT_UT} DESTINATION ${AITT_TEST_BINDIR})
 
@@ -28,7 +28,7 @@ add_test(
 set(AITT_STREAM_UT ${PROJECT_NAME}_stream_ut)
 set(AITT_STREAM_UT_SRC AittStream_test.cc)
 add_executable(${AITT_STREAM_UT} ${AITT_STREAM_UT_SRC})
-target_link_libraries(${AITT_STREAM_UT} Threads::Threads ${UT_NEEDS_LIBRARIES} ${PROJECT_NAME})
+target_link_libraries(${AITT_STREAM_UT} Threads::Threads ${GTEST_LIBRARIES} ${PROJECT_NAME})
 
 install(TARGETS ${AITT_STREAM_UT} DESTINATION ${AITT_TEST_BINDIR})
 
@@ -43,21 +43,26 @@ add_test(
 ###########################################################################
 file(GLOB AITT_MANUAL_SRC *_manualtest.cc)
 add_executable(${AITT_UT}_manual ${AITT_MANUAL_SRC})
-target_link_libraries(${AITT_UT}_manual Threads::Threads ${UT_NEEDS_LIBRARIES} ${PROJECT_NAME})
+target_link_libraries(${AITT_UT}_manual Threads::Threads ${GTEST_LIBRARIES} ${PROJECT_NAME})
 
 install(TARGETS ${AITT_UT}_manual DESTINATION ${AITT_TEST_BINDIR})
 
 ###########################################################################
-if(${UT_NEEDS_VERSION} GREATER 1.7)
+if(${GTEST_VERSION} VERSION_GREATER 1.7)
     set(AITT_UT_MQ ${PROJECT_NAME}_ut_mq)
     add_executable(${AITT_UT_MQ} MosquittoMQ_mocktest.cc MosquittoMock.cc $<TARGET_OBJECTS:INTERNAL_OBJ>)
-    target_link_libraries(${AITT_UT_MQ} ${UT_NEEDS_LIBRARIES} Threads::Threads ${CMAKE_DL_LIBS} ${AITT_COMMON})
-    if(${UT_NEEDS_VERSION} GREATER 1.10)
-        target_include_directories(${AITT_UT_MQ} PRIVATE ../external/C-Mock/v0.4.0)
-    else()
-        target_include_directories(${AITT_UT_MQ} PRIVATE ../external/C-Mock/v0.3.1)
-    endif()
-    target_link_libraries(${AITT_UT_MQ} ${UT_NEEDS_LIBRARIES})
+    target_link_libraries(${AITT_UT_MQ} ${GTEST_LIBRARIES} Threads::Threads ${CMAKE_DL_LIBS} ${AITT_COMMON})
+    if(PLATFORM STREQUAL "tizen")
+        pkg_check_modules(CMOCK REQUIRED c-mock)
+        target_include_directories(${AITT_UT_MQ} PRIVATE ${CMOCK_INCLUDE_DIRS})
+        target_link_directories(${AITT_UT_MQ} PRIVATE ${CMOCK_LIBRARY_DIRS})
+    else(PLATFORM STREQUAL "tizen")
+        if(${GTEST_VERSION} VERSION_GREATER 1.10)
+            target_include_directories(${AITT_UT_MQ} PRIVATE ${CMAKE_BINARY_DIR}/C-Mock-0.4.0/include)
+        else()
+            target_include_directories(${AITT_UT_MQ} PRIVATE ${CMAKE_BINARY_DIR}/C-Mock-0.3.1/include)
+        endif()
+    endif(PLATFORM STREQUAL "tizen")
     install(TARGETS ${AITT_UT_MQ} DESTINATION ${AITT_TEST_BINDIR})
 
     add_test(
@@ -68,10 +73,10 @@ if(${UT_NEEDS_VERSION} GREATER 1.7)
             LD_LIBRARY_PATH=../common/:$ENV{LD_LIBRARY_PATH}
             ${CMAKE_CURRENT_BINARY_DIR}/${AITT_UT_MQ} --gtest_filter=*_Anytime
     )
-endif(${UT_NEEDS_VERSION} GREATER 1.7)
+endif(${GTEST_VERSION} VERSION_GREATER 1.7)
 ###########################################################################
 add_executable(${AITT_UT}_local ModuleLoader_test.cc MosquittoMQ_test.cc $<TARGET_OBJECTS:INTERNAL_OBJ>)
-target_link_libraries(${AITT_UT}_local ${UT_NEEDS_LIBRARIES} ${AITT_NEEDS_LIBRARIES} ${CMAKE_DL_LIBS} ${AITT_COMMON})
+target_link_libraries(${AITT_UT}_local ${GTEST_LIBRARIES} ${AITT_NEEDS_LIBRARIES} ${CMAKE_DL_LIBS} ${AITT_COMMON})
 
 install(TARGETS ${AITT_UT}_local DESTINATION ${AITT_TEST_BINDIR})