Development/covering missed tags & removing mock shell dependency

.github/workflows/ProxyStubFunctionalTests.yml

@@ -52,7 +52,7 @@ jobs:
         run: |
           set -euo pipefail
           export DEBIAN_FRONTEND=noninteractive
-          PKGS="python3-venv python3-pip build-essential cmake ninja-build"
+          PKGS="python3-venv python3-pip build-essential cmake ninja-build libgtest-dev"
           if [ "${{ matrix.architecture }}" = "32" ]; then
             PKGS="$PKGS zlib1g-dev:i386 libssl-dev:i386 gcc-13-multilib g++-13-multilib"
           else
@@ -86,6 +86,7 @@ jobs:
             -DCMAKE_VERBOSE_MAKEFILE=ON \
             -DENABLE_TESTING=ON \
             -DFUNCTIONAL_TESTS=ON \
+            -DENABLE_TEST_RUNTIME=ON \
             -DPROXYSTUB_GENERATOR=$(pwd)/ProxyStubGenerator/StubGenerator.py \
             -DJSON_GENERATOR=$(pwd)/JsonGenerator/JsonGenerator.py
           cmake \

tests/FunctionalTests/CMakeLists.txt

@@ -25,6 +25,14 @@ option(TEST_OPTIONALS    "Enable optional parameters tests"     ON)
 option(TEST_PRIMITIVES   "Enable primitive types tests"         ON)
 option(TEST_RESTRICTIONS "Enable restrict annotation tests"     ON) 
 option(TEST_STRUCTS      "Enable POD struct tests"              ON)
+option(TEST_ENCODING_MAC         "Enable @encode:mac annotation tests"           ON)
+option(TEST_LENGTH_MODES         "Enable @length:void/@length:return tests"      ON)
+option(TEST_JSON_SHAPE           "Enable @wrapped/@extract shape tests"          ON)
+option(TEST_JSON_TEXT_KEEP       "Enable @text:keep naming tests"                ON)
+option(TEST_JSON_TEXT_CASE       "Enable @text:legacy case convention tests"     ON)
+option(TEST_JSON_COMPLIANT       "Enable @compliant format tests"                ON)
+option(TEST_JSON_UNCOMPLIANT_EXT "Enable @uncompliant:extended format tests"     ON)
+option(TEST_JSON_UNCOMPLIANT_COL "Enable @uncompliant:collapsed format tests"    ON)
 
 set(CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}" CACHE BOOL "" FORCE)
 

tests/FunctionalTests/README.md

@@ -60,7 +60,7 @@ This generates JSON-RPC dispatch code but integration with the main test executa
 
 ### JSON-RPC functional tests
 
-A separate test executable validates JsonGenerator output using a simplified header-only architecture:
+A separate test executable validates JsonGenerator output using a lightweight two-file server infrastructure:
 
 ```bash
 cmake -S . -B build -DBUILD_JSON_RPC_TESTS=ON
@@ -71,7 +71,7 @@ cmake --build build --target JsonRpcFunctionalTests
 This creates `JsonRpcFunctionalTests` executable that:
 - Reuses the same interface definitions and implementation classes as COM-RPC tests
 - Tests **full round-trip JSON marshalling/unmarshalling** using Thunder's `PluginHost::JSONRPC::Invoke()` directly
-- Uses **header-only infrastructure** (`JsonRpcServer.h` contains both registration system and dispatcher)
+- Uses a lightweight two-file infrastructure: `JsonRpcServer.h` contains the registration system and dispatcher, `JsonRpcServer.cpp` contains the runtime bootstrap (`ThunderTestRuntime` init and `IShell` attach)
 - **One-line registration** per interface using lambda-based static registrars (no template specialization boilerplate)
 - Uses `JsonRpcTestHarness<IF>` fixtures instead of `TestHarness<IF>`
 - Validates that generated `J<Interface>::Register()` dispatch code compiles and works correctly
@@ -140,7 +140,7 @@ ProxyStubs are generated by `ProxyStubGenerator` at build time into `build/comrp
 
 ## JSON-RPC test architecture
 
-The JSON-RPC test binary uses Thunder's `PluginHost::JSONRPC` for direct method dispatch without network transport. The infrastructure is **header-only** - all registration and dispatch logic lives in `JsonRpcServer.h`:
+The JSON-RPC test binary performs direct in-process dispatcher invocation (no network transport). `JsonRpcServer` is built on `Test::JsonRPCRegister` (from `JsonRpcRegistrations.h`), which derives from `PluginHost::JSONRPCSupportsEventStatus`. The infrastructure splits across two files: `JsonRpcServer.h` contains the registration system and dispatcher, while `JsonRpcServer.cpp` contains the runtime bootstrap (`ThunderTestRuntime` initialisation and `IShell` attachment):
 
 ```
 ┌────────────────────────────────────────────────────┐
@@ -158,8 +158,8 @@ The JSON-RPC test binary uses Thunder's `PluginHost::JSONRPC` for direct method
 │  │ │based registry)  │ │      │   ↓             │  │
 │  │ └─────────────────┘ │      │ JSON-RPC 2.0    │  │
 │  │                     │      │ params/response │  │
-│  │  MockShell          │      │                 │  │
-│  │  (IShell stub)      │      │                 │  │
+│  │  ThunderTestRuntime │      │                 │  │
+│  │  + real IShell      │      │                 │  │
 │  │                     │      │                 │  │
 │  │  Impl (reused)      │      │                 │  │
 │  └─────────────────────┘      └─────────────────┘  │
@@ -168,9 +168,9 @@ The JSON-RPC test binary uses Thunder's `PluginHost::JSONRPC` for direct method
 └────────────────────────────────────────────────────┘
 ```
 
-**Server side** — `JsonRpcServer` inherits from `PluginHost::JSONRPC` and `PluginHost::IPlugin`. A `MockShell` provides the minimal `IShell` interface needed for initialization. Implementation classes are the same protocol-agnostic implementations used for COM-RPC tests.
+**Server side** — `JsonRpcServer` derives from `Test::JsonRPCRegister` (which derives from `PluginHost::JSONRPCSupportsEventStatus`) and does not implement `PluginHost::IPlugin`. It initializes `Thunder::TestCore::ThunderTestRuntime` and attaches to a real `IShell` from the embedded Thunder `PluginHost::Server` (Controller callsign). Implementation classes are the same protocol-agnostic implementations used for COM-RPC tests.
 
-**Registration system** (header-only in `JsonRpcServer.h`):
+**Registration system** (in `JsonRpcServer.h`):
 - `JsonRpcRegistrationProvider`: Singleton collecting registration lambdas
 - `JsonRpcRegistrar<INTERFACE, IMPL>`: Template class capturing register function in lambda
 - Static initialization: Each implementation file has one-line registrar:

tests/FunctionalTests/common/CMakeLists.txt

@@ -51,6 +51,13 @@ target_link_libraries(FunctionalTestCommon
         ${NAMESPACE}COM::${NAMESPACE}COM
 )
 
+if(ENABLE_JSON_RPC_TESTS)
+    target_link_libraries(FunctionalTestCommon
+        PUBLIC
+            ${NAMESPACE}Plugins::${NAMESPACE}Plugins
+    )
+endif()
+
 add_library(FunctionalTestProxySources OBJECT)
 add_library(FunctionalTestJsonSources OBJECT)
 
@@ -65,6 +72,7 @@ target_link_libraries(FunctionalTestJsonSources
     PRIVATE
         FunctionalTestCommon
         ${NAMESPACE}Core::${NAMESPACE}Core
+        ${NAMESPACE}Plugins::${NAMESPACE}Plugins
 )
 
 macro(AddTestInterface TestName)
@@ -155,6 +163,38 @@ if (TEST_ASYNC)
     AddTestInterface("Async" COM_RPC JSON_RPC)
 endif()
 
+if (TEST_ENCODING_MAC)
+    AddTestInterface("EncodingMac" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_LENGTH_MODES)
+    AddTestInterface("LengthModes" COM_RPC)  # COM-RPC only — @length:return requires non-uint32_t return type, unsupported by JsonGenerator
+endif()
+
+if (TEST_JSON_SHAPE)
+    AddTestInterface("JsonShape" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_JSON_TEXT_KEEP)
+    AddTestInterface("JsonTextKeep" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_JSON_TEXT_CASE)
+    AddTestInterface("JsonTextCase" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_JSON_COMPLIANT)
+    AddTestInterface("JsonCompliant" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_JSON_UNCOMPLIANT_EXT)
+    AddTestInterface("JsonUncompliantExtended" COM_RPC JSON_RPC)
+endif()
+
+if (TEST_JSON_UNCOMPLIANT_COL)
+    AddTestInterface("JsonUncompliantCollapsed" COM_RPC JSON_RPC)
+endif()
+
 list(LENGTH COM_RPC_INTERFACE_HEADERS NUM_COM_TESTS)
 list(LENGTH JSON_INTERFACE_HEADERS NUM_JSON_TESTS)
 

tests/FunctionalTests/common/implementations/TestEncodingMacImpl.cpp

@@ -0,0 +1,64 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ImplementationFactory.h>
+#include <ITestEncodingMac.h>
+#include <cstring>
+
+namespace Thunder {
+namespace TestImplementation {
+
+    class TestEncodingMacImpl : public FunctionalTest::ITestEncodingMac {
+    public:
+        TestEncodingMacImpl() { memset(_mac, 0, sizeof(_mac)); }
+        ~TestEncodingMacImpl() override = default;
+
+        TestEncodingMacImpl(const TestEncodingMacImpl&) = delete;
+        TestEncodingMacImpl& operator=(const TestEncodingMacImpl&) = delete;
+
+        Core::hresult SetMacAddress(const uint8_t mac[]) override
+        {
+            memcpy(_mac, mac, 6);
+            return Core::ERROR_NONE;
+        }
+
+        Core::hresult GetMacAddress(uint8_t mac[]) const override
+        {
+            memcpy(mac, _mac, 6);
+            return Core::ERROR_NONE;
+        }
+
+        Core::hresult EchoMacAddress(const uint8_t input[], uint8_t output[]) const override
+        {
+            memcpy(output, input, 6);
+            return Core::ERROR_NONE;
+        }
+
+        BEGIN_INTERFACE_MAP(TestEncodingMacImpl)
+        INTERFACE_ENTRY(FunctionalTest::ITestEncodingMac)
+        END_INTERFACE_MAP
+
+    private:
+        uint8_t _mac[6];
+    };
+
+    static Factory::Registrar<FunctionalTest::ITestEncodingMac, TestEncodingMacImpl> g_encodingMacRegistrar;
+
+} // namespace TestImplementation
+} // namespace Thunder

tests/FunctionalTests/common/implementations/TestJsonCompliantImpl.cpp

@@ -0,0 +1,48 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ImplementationFactory.h>
+#include <ITestJsonCompliant.h>
+
+namespace Thunder {
+namespace TestImplementation {
+
+    class TestJsonCompliantImpl : public FunctionalTest::ITestJsonCompliant {
+    public:
+        TestJsonCompliantImpl() = default;
+        ~TestJsonCompliantImpl() override = default;
+
+        TestJsonCompliantImpl(const TestJsonCompliantImpl&) = delete;
+        TestJsonCompliantImpl& operator=(const TestJsonCompliantImpl&) = delete;
+
+        Core::hresult Ping(const string& payload, string& reply) const override
+        {
+            reply = payload;
+            return Core::ERROR_NONE;
+        }
+
+        BEGIN_INTERFACE_MAP(TestJsonCompliantImpl)
+        INTERFACE_ENTRY(FunctionalTest::ITestJsonCompliant)
+        END_INTERFACE_MAP
+    };
+
+    static Factory::Registrar<FunctionalTest::ITestJsonCompliant, TestJsonCompliantImpl> g_registrar;
+
+} // namespace TestImplementation
+} // namespace Thunder

tests/FunctionalTests/common/implementations/TestJsonShapeImpl.cpp

@@ -0,0 +1,67 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ImplementationFactory.h>
+#include <ITestJsonShape.h>
+
+namespace Thunder {
+namespace TestImplementation {
+
+    class TestJsonShapeImpl : public FunctionalTest::ITestJsonShape {
+    public:
+        TestJsonShapeImpl() : _counter(42) {}
+        ~TestJsonShapeImpl() override = default;
+
+        TestJsonShapeImpl(const TestJsonShapeImpl&) = delete;
+        TestJsonShapeImpl& operator=(const TestJsonShapeImpl&) = delete;
+
+        Core::hresult GetWrappedCounter(uint32_t& counter) const override
+        {
+            counter = _counter;
+            return Core::ERROR_NONE;
+        }
+
+        Core::hresult EchoExtractedList(
+            const std::vector<uint32_t>& input,
+            std::vector<uint32_t>& output) const override
+        {
+            output = input;
+            return Core::ERROR_NONE;
+        }
+
+        Core::hresult EchoStruct(
+            const Dimensions& in,
+            Dimensions& out) const override
+        {
+            out = in;
+            return Core::ERROR_NONE;
+        }
+
+        BEGIN_INTERFACE_MAP(TestJsonShapeImpl)
+        INTERFACE_ENTRY(FunctionalTest::ITestJsonShape)
+        END_INTERFACE_MAP
+
+    private:
+        uint32_t _counter;
+    };
+
+    static Factory::Registrar<FunctionalTest::ITestJsonShape, TestJsonShapeImpl> g_jsonShapeRegistrar;
+
+} // namespace TestImplementation
+} // namespace Thunder

tests/FunctionalTests/common/implementations/TestJsonTextCaseImpl.cpp

@@ -0,0 +1,48 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Metrological
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ImplementationFactory.h>
+#include <ITestJsonTextCase.h>
+
+namespace Thunder {
+namespace TestImplementation {
+
+    class TestJsonTextCaseImpl : public FunctionalTest::ITestJsonTextCase {
+    public:
+        TestJsonTextCaseImpl() = default;
+        ~TestJsonTextCaseImpl() override = default;
+
+        TestJsonTextCaseImpl(const TestJsonTextCaseImpl&) = delete;
+        TestJsonTextCaseImpl& operator=(const TestJsonTextCaseImpl&) = delete;
+
+        Core::hresult EchoCaseConvention(const uint16_t sourceValue, uint16_t& resultValue) const override
+        {
+            resultValue = sourceValue;
+            return Core::ERROR_NONE;
+        }
+
+        BEGIN_INTERFACE_MAP(TestJsonTextCaseImpl)
+        INTERFACE_ENTRY(FunctionalTest::ITestJsonTextCase)
+        END_INTERFACE_MAP
+    };
+
+    static Factory::Registrar<FunctionalTest::ITestJsonTextCase, TestJsonTextCaseImpl> g_registrar;
+
+} // namespace TestImplementation
+} // namespace Thunder