Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter

- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress

tools/EVerest-main/modules/API/RpcApi/tests/helpers/WebSocketTestClient.hpp

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright chargebyte GmbH and Contributors to EVerest
+#ifndef WEBSOCKETTESTCLIENT_HPP
+#define WEBSOCKETTESTCLIENT_HPP
+
+#include <atomic>
+#include <condition_variable>
+#include <cstring>
+#include <everest/logging.hpp>
+#include <iostream>
+#include <libwebsockets.h>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+class WebSocketTestClient {
+public:
+    WebSocketTestClient(const std::string& address, int port);
+    ~WebSocketTestClient();
+
+    bool connect();
+    bool is_connected();
+    void send(const std::string& message);
+    void send_api_hello_req();
+    const std::string& receive() const;
+    void close();
+    std::string get_received_data() {
+        std::string data;
+        {
+            std::lock_guard<std::mutex> lock(m_cv_mutex);
+            data = m_received_data;
+            m_received_data.clear(); // Clear the received data after getting it
+        }
+        return data;
+    }
+
+    std::string wait_for_data(std::chrono::milliseconds timeout, bool is_result = true) {
+        std::unique_lock<std::mutex> lock(m_cv_mutex);
+
+        bool received = m_cv.wait_for(lock, timeout, [this, is_result]() {
+            if (m_received_data.empty())
+                return false;
+            if (is_result) {
+                // Check string for "result" and "id" keys if is_result is true
+                bool has_result = m_received_data.find("\"result\"") != std::string::npos;
+                bool has_id = m_received_data.find("\"id\"") != std::string::npos;
+                return has_result && has_id;
+            }
+            return true; // For regular responses, we just check if we have data
+        });
+
+        if (!received) {
+            return ""; // Timeout
+        }
+
+        std::string data = m_received_data;
+        m_received_data.clear(); // Clear the received data after getting it
+        return data;
+    }
+
+    bool wait_for_response(std::chrono::milliseconds timeout) {
+        std::unique_lock<std::mutex> lock(m_cv_mutex);
+        return m_cv.wait_for(lock, timeout, [this] { return !m_received_data.empty(); });
+    }
+
+    bool wait_until_connected(std::chrono::milliseconds timeout) {
+        std::unique_lock<std::mutex> lock(m_cv_mutex);
+        return m_cv.wait_for(lock, timeout, [this] { return m_connected.load(); });
+    }
+
+    void start_lws_service_thread();
+    void stop_lws_service_thread();
+
+private:
+    static int callback(struct lws* wsi, enum lws_callback_reasons reason, void* user, void* in, size_t len);
+
+    std::string m_address;
+    int m_port;
+    struct lws_context* m_context;
+    struct lws_client_connect_info m_ccinfo {};
+    struct lws* m_wsi;
+    std::atomic<bool> m_connected{false};
+    std::atomic<bool> m_lws_service_running{false};
+    std::thread m_lws_service_thread;
+    std::string m_received_data;
+
+public:
+    // Condition variable to wait for response
+    std::condition_variable m_cv;
+    std::mutex m_cv_mutex;
+};
+
+#endif // WEBSOCKETTESTCLIENT_HPP