Rename test subdirectory to tests for higher consistency with OSS standards

2019-04-25 23:54:51 +02:00
parent 981206fa8c
commit 1b02c604d8
37 changed files with 6 additions and 6 deletions
@@ -0,0 +1,198 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file TestingAdaptor.h
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
+
+#include "adaptor-glue.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+class TestingAdaptor : public sdbus::AdaptorInterfaces<testing_adaptor>
+{
+public:
+    TestingAdaptor(sdbus::IConnection& connection) :
+        AdaptorInterfaces(connection, OBJECT_PATH)
+    {
+        registerAdaptor();
+    }
+
+    ~TestingAdaptor()
+    {
+        unregisterAdaptor();
+    }
+
+    bool wasMultiplyCalled() const { return m_multiplyCalled; }
+    double getMultiplyResult() const { return m_multiplyResult; }
+    bool wasThrowErrorCalled() const { return m_throwErrorCalled; }
+
+protected:
+
+    void noArgNoReturn() const {}
+
+    int32_t getInt() const { return INT32_VALUE; }
+
+    std::tuple<uint32_t, std::string> getTuple() const { return std::make_tuple(UINT32_VALUE, STRING_VALUE); }
+
+    double multiply(const int64_t& a, const double& b) const { return a * b; }
+
+    void multiplyWithNoReply(const int64_t& a, const double& b) const
+    {
+        m_multiplyResult = a * b;
+        m_multiplyCalled = true;
+    }
+
+    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const
+    {
+        std::vector<int16_t> res{x.get<1>()};
+        auto y = std::get<std::vector<int16_t>>(x);
+        res.insert(res.end(), y.begin(), y.end());
+        return res;
+    }
+
+    sdbus::Variant processVariant(sdbus::Variant& v)
+    {
+        sdbus::Variant res = static_cast<int32_t>(v.get<double>());
+        return res;
+    }
+
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const
+    {
+        std::map<int32_t, sdbus::Variant> res;
+        for (auto item : x)
+        {
+            res[item] = (item <= 0) ? std::get<0>(y) : std::get<1>(y);
+        }
+        return res;
+    }
+
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const
+    {
+        return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
+    }
+
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
+    {
+        int32_t res{0};
+        res += std::get<0>(a) + std::get<1>(a);
+        res += std::get<0>(b) + std::get<1>(b);
+        return res;
+    }
+
+    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
+    {
+        uint32_t res{0};
+        for (auto x : a)
+        {
+            res += x;
+        }
+        for (auto x : b)
+        {
+            res += x;
+        }
+        return res;
+    }
+
+    uint32_t doOperation(uint32_t param)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(param));
+        return param;
+    }
+
+    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result)
+    {
+        if (param == 0)
+        {
+            // Don't sleep and return the result from this thread
+            result.returnResults(param);
+        }
+        else
+        {
+            // Process asynchronously in another thread and return the result from there
+            std::thread([param, result = std::move(result)]()
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(param));
+                result.returnResults(param);
+            }).detach();
+        }
+    }
+
+    sdbus::Signature getSignature() const { return SIGNATURE_VALUE; }
+    sdbus::ObjectPath getObjectPath() const { return OBJECT_PATH_VALUE; }
+
+    ComplexType getComplex() const
+    {
+        return { // map
+            {
+                0,  // uint_64_t
+                {   // struct
+                    {   // map
+                        {
+                            'a',  // uint8_t
+                            {   // vector
+                                {   // struct
+                                        "/object/path", // object path
+                                        false,
+                                        3.14,
+                                        {   // map
+                                            {0, "zero"}
+                                        }
+                                }
+                            }
+                        }
+                    },
+                    "a{t(a{ya(obva{is})}gs)}", // signature
+                    ""
+                }
+            }
+        };
+    }
+
+    void throwError() const
+    {
+        m_throwErrorCalled = true;
+        throw sdbus::createError(1, "A test error occurred");
+    }
+
+    std::string state() { return STRING_VALUE; }
+    uint32_t action() { return m_action; }
+    void action(const uint32_t& value) { m_action = value; }
+    bool blocking() { return m_blocking; }
+    void blocking(const bool& value) { m_blocking = value; }
+
+private:
+    uint32_t m_action;
+    bool m_blocking;
+
+    // For dont-expect-reply method call verifications
+    mutable std::atomic<bool> m_multiplyCalled{};
+    mutable double m_multiplyResult{};
+    mutable std::atomic<bool> m_throwErrorCalled{};
+};
+
+
+
+#endif /* INTEGRATIONTESTS_TESTINGADAPTOR_H_ */