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/tests/.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+results.xml
+result.xml
+report.html

tools/EVerest-main/tests/BUILD.bazel

@@ -0,0 +1,11 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "module_adapter_stub",
+    hdrs = ["include/ModuleAdapterStub.hpp"],
+    includes = ["include"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//lib/everest/framework",
+    ],
+)

tools/EVerest-main/tests/CMakeLists.txt

@@ -0,0 +1,39 @@
+# enabling coverage related things
+
+evc_include(CodeCoverage)
+
+# add compiler flags to all targets which should be coveraged
+
+foreach(type MODULES LIBRARIES TESTS)
+    ev_get_targets(targets ${type})
+
+    foreach(target ${targets})
+        append_coverage_compiler_flags_to_target(${target})
+
+        if (type STREQUAL "MODULES")
+            target_link_libraries(${target} PRIVATE everest::helpers)
+        endif()
+    endforeach()
+endforeach()
+
+get_target_property(GENERATED_OUTPUT_DIR generate_cpp_files EVEREST_GENERATED_OUTPUT_DIR)
+setup_target_for_coverage_gcovr_html(
+    NAME ${PROJECT_NAME}_create_coverage
+    EXCLUDE "${GENERATED_OUTPUT_DIR}/*" ".*tests/"
+)
+
+# automatically install everest-testing if venv is active
+ev_is_python_venv_active(
+    RESULT_VAR IS_PYTHON_VENV_ACTIVE
+)
+if(IS_PYTHON_VENV_ACTIVE)
+    get_target_property(SOURCE_DIRECTORY ev_pip_package_everest-testing SOURCE_DIRECTORY)
+    message(STATUS "Installing everest-testing from: ${SOURCE_DIRECTORY}")
+    ev_pip_install_local(
+        PACKAGE_NAME "everest-testing"
+        PACKAGE_SOURCE_DIRECTORY "${SOURCE_DIRECTORY}"
+    )
+endif()
+
+add_subdirectory(everest-core_tests)
+add_subdirectory(async_api_tests)

tools/EVerest-main/tests/README.md

@@ -0,0 +1,210 @@
+# EVerest tests
+
+This folder contains the basic test functions for EVerest's e2e testing. You can either extend the '*\*_tests.py*' files in the "EVerest/**tests/core_tests**" folder or write your own!
+
+## Prerequisites
+
+In order to run any of the e2e tests, you need to have EVerest compiled
+and installed on your system. Please also make sure to install the python
+requirements.
+
+```bash
+cd EVerest/
+cmake -S . -B build -DBUILD_TESTING=ON
+cmake --build build --target install --parallel -j$(nproc)
+. build/venv/bin/activate
+cmake --build build --target everestpy_pip_install_dist # install everestpy
+cmake --build build --target everest-testing_pip_install_dist # install everest-testing
+cmake --build build --target iso15118_pip_install_dist # install iso15118 for ev side simulation
+python3 -m pip install "aiofile>=3.7.4"
+python3 -m pip install "netifaces>=0.11.0"
+```
+
+## Execute locally
+
+All test suites are run via the unified `run-tests.sh` script:
+
+```bash
+cd ~/checkout/everest-workspace/EVerest/tests
+
+./run-tests.sh all          # all tests (core, framework, async, OCPP)
+./run-tests.sh core         # core tests only
+./run-tests.sh framework    # framework tests only
+./run-tests.sh asyncapi        # async API tests only
+./run-tests.sh integration  # core + framework + async
+./run-tests.sh ocpp         # all OCPP tests (1.6, 2.0.1, 2.1)
+./run-tests.sh --serial all # run serially (no parallelism)
+./run-tests.sh -j4 all      # limit to 4 parallel workers
+./run-tests.sh --help       # show all options
+```
+
+The script automatically sets up network isolation for parallel ISO 15118 tests
+(requires sudo or CAP_NET_ADMIN) and falls back to sequential execution otherwise.
+
+After execution `result.xml` and `report.html` are written to the `tests/` directory.
+
+### Running individual tests directly
+
+For a single test file or test case, invoke `pytest` directly from the `tests/` directory:
+
+```bash
+cd ~/checkout/everest-workspace/EVerest/tests
+
+# Run a single test file
+python3 -m pytest core_tests/smoke_tests.py
+
+# Run a single test by name
+python3 -m pytest core_tests/smoke_tests.py::test_iso15118_ac_session
+```
+
+Network isolation is not set up automatically in this mode — ISO 15118 tests will
+run sequentially via their `xdist_group` marker.
+
+## Add own test sets
+
+To create own test sets, you need to write a new python file in the "EVerest/**tests/core_tests/**" folder. A basic file template would look like this:
+
+```python
+import logging
+import pytest
+
+from everest.testing.core_utils.fixtures import *
+from validations.base_functions import wait_for_and_validate_event
+from everest.testing.core_utils.test_control_module import TestControlModule
+from everest.testing.core_utils.everest_core import EverestCore
+from validations.user_functions import *
+
+@ pytest.mark.asyncio
+async def test_001_my_first_test(everest_core: EverestCore, 
+                                 test_control_module: TestControlModule):
+    logging.info(">>>>>>>>> test_001_my_first_test <<<<<<<<<")
+    everest_core.start()
+
+    assert await wait_for_and_validate_event(test_control_module, 
+                                             exp_event='my_event', 
+                                             exp_data={"my_data":"test"},
+                                             validation_function=my_validation_function,
+                                             timeout=30) 
+```
+
+\*Note: All test functions' names NEED to start with "test" (see pytest documentation: https://docs.pytest.org/)
+
+In the above example you then would also have to write a (user-)validation function by the name of "my_validation_function()" in the "EVerest/**tests/core_tests/validations/user_functions.py**" file.
+
+For this, you can utilize helper functions from the "EVerest/**tests/core_tests/validations/base_functions.py**" file (e.g. "get_key_if_exists()" to traverse and retrieve event data from an event-object).
+
+**Attention**: When you change something in the test- or validation files, please do not forget to run "*make install*" on EVerest before starting the tests, as otherwise the changes are not reflected in the test run!
+
+### Controlling more functionality with PyTestControlModule
+
+If you would like to receive other everest-internal data, send commands to other EVerest modules or would like to change the received events for everest-testing, you can modify the **PyTestControlModule** in the "EVerest/**modules/PyTestControlModule**" folder.
+
+**Attention:** Please be aware, though, that the use of this module is preliminary and changes in the *everest-framework* may render this module **obsolete** in the future!
+
+## Troubleshooting
+
+**1. Problem:** Multiple concatenated tests that use the *PyTestControlModule* (in standalone configuration) result in an exception and subsequent crash of everest-testing.
+
+**Cause:** There is currently no way to unload a module in *EVerest*. But because pytest runs out of the same context for all tests in a testset, a once loaded *PyTestControlModule* stays active for the rest of the pytest/everest-testing run. When a new test tries to load a second instance of the *PyTestControlModule* it collides with the already running instance and causes everest-testing to crash.
+
+**Solution:** Unfortunately, this requires a change in the everest-framework. This change is currently under development, but not yet merged into main. 
+For the moment, there is a *workaround available:* Use a new test-set (another python file containing a new set of tests) for every test that requires control via the *PyTestControlModule*. As soon as a fix for the underlying issue is merged, this will be updated!
+
+**2. Problem:** On an unmodified run of "basic_charging_tests.py" the test *test_001_charge_defined_ammount* fails and reports an amount of 0.0kWh charged.
+
+**Cause:** Currently there is a bug in the EVSE manager implementation in EVerest, causing a race-condition between resetting the "amount charged" parameter and the event reporting for a "*transaction_finished*" event. Sometimes it reports correctly, other times it reports a value of 0.0kWh charged.
+
+**Solution:** This problem is known and a fix is under way. For the moment, just re-run the test. Usually, this should then produce a passing result.
+
+
+# Code coverage
+
+To activate code coverage, you need to configure the project with
+`BUILD_TESTING` enabled.  Furthermore, `gcovr` needs to be installed.
+
+## Generating coverage reports
+
+Before generating a coverage report you will typically need to run some
+executables or tests, which contain or link to code, that generates coverage
+statistics.
+
+After that, just run:
+```bash
+cmake --build build --target everest-core_create_coverage
+# or ninja -C build everest-core_create_coverage
+```
+
+The generated `index.html` will be available at
+`build/everest-core_create_coverage/index.html`.
+
+**Note**: the code coverage for a specific compilation unit (cpp file) will
+accumulate if you run multiple executables that use this compilation unit.  The
+code coverage is recorded in `gcda` files.  If you want to get separate coverage
+reports for different executables, these `gcda` files need to be deleted for
+each new *run*.
+
+
+## Adding code/targets to code coverage
+
+By default, all *cpp* modules are added automatically to a list of targets that
+will be compiled with coverage flags.  If additional libraries or tests need to
+be added to code coverage, you should use the following functions in your
+*cmake* code:
+```cmake
+ev_register_library_target(LIBRARY_TARGET_NAME)
+ev_register_test_target(TEST_TARGET_NAME)
+```
+
+## Conventions
+
+For the `ev_register_*_target` functions, call these function close to their
+scope of detail - meaning near `add_library` for libraries like:
+
+```cmake
+add_library(evse_security_conversions STATIC)
+add_library(everest::evse_security_conversions ALIAS evse_security_conversions)
+ev_register_library_target(evse_security_conversions)
+```
+
+and near `add_test` for tests like:
+
+```cmake
+add_test(${TLS_GTEST_NAME} ${TLS_GTEST_NAME})
+ev_register_test_target(${TLS_GTEST_NAME})
+```
+
+and not scattered around.
+
+---
+
+By default, all directories ending with `tests` will be excluded from the code
+coverage report (because we're not interested in the code coverage of the unit
+test code itself).  So when adding unit tests for code coverage, place them into
+a `tests` folder.
+
+## Troubleshooting
+
+`no_working_dir_found`: while developing code (e.g. an `example.cpp`), it might
+happen, that the created object file `example.cpp.o` will get out of sync with
+its corresponding `example.cpp.gcno` (`gcov` note file) and/or
+`example.cpp.gcda` (`gcov` data file).  When creating a report, `gcovr` will
+complain, because it can't find the corresponding `example.cpp.o` file for a
+stale `example.cpp.gcno` file.  It might also not be able to find the
+`example.cpp.gcno` file for a stale `example.cpp.gcda` file or an older `gcda`
+file might got out of sync due to a newer `gcno` file and so forth.  Do not
+simply ignore these warnings/errors, as the report might not be accurate
+anymore.
+
+The current sledgehammer approach is to manually delete the files in question or
+just do (**be careful** with `rm` commands and wildcards!):
+```bash
+find ./build -name "*.gcno" -delete
+find ./build -name "*.gcda" -delete
+ninja -C build clean
+ninja -C build
+# run code
+# create coverage
+```
+
+We're currently trying to write some tooling around this to make this more
+usable.

tools/EVerest-main/tests/async_api_tests/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(config)

tools/EVerest-main/tests/async_api_tests/config/CMakeLists.txt

@@ -0,0 +1,6 @@
+# install configs
+install(
+    DIRECTORY "."
+    DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/everest"
+    FILES_MATCHING PATTERN "*.yaml"
+)

tools/EVerest-main/tests/async_api_tests/config/probe-system.yaml

@@ -0,0 +1,11 @@
+active_modules:
+  system_api:
+    module: system_API
+    config_module:
+      cfg_communication_check_to_s: 0
+  probe:
+    module: ProbeModule
+    connections:
+      system:
+        - module_id: system_api
+          implementation_id: main

tools/EVerest-main/tests/async_api_tests/test_system.py

@@ -0,0 +1,175 @@
+import os
+import pytest
+import pytest_asyncio
+import json
+import asyncio
+from typing import Callable, Dict
+import paho.mqtt.client as mqtt
+from everest.testing.core_utils.probe_module import ProbeModule
+from everest.testing.core_utils.everest_core import EverestCore
+from everest.testing.core_utils.fixtures import *
+
+
+class AsyncApiMqttHandler:
+    def __init__(self, broker: str, port: int = 1883, everest_prefix: str = ""):
+        self.broker = broker
+        self.port = port
+        self.everest_prefix = everest_prefix
+        self.handlers: Dict[str, Callable] = {}
+        self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
+        self.client.on_connect = self._on_connect
+        self.client.on_message = self._on_message
+        self.loop = None
+        self._connected = None
+        
+    def register_handler(self, topic: str, handler: Callable):
+        """Register a command handler for a topic"""
+        self.handlers[topic] = handler
+        self.client.subscribe(topic)
+        
+    async def publish(self, topic: str, payload: str):
+        """Publish data to a topic"""
+        if self._connected:
+            await self._connected.wait()
+        self.client.publish(topic, payload)
+        
+    def _on_connect(self, client, userdata, flags, reason_code, properties):
+        """Subscribe to registered topics on connect"""
+        for topic in self.handlers:
+            client.subscribe(topic)
+        if self._connected:
+            self.loop.call_soon_threadsafe(self._connected.set)
+            
+    def _on_message(self, client, userdata, msg):
+        """Dispatch message to handler in asyncio loop"""
+        if msg.topic in self.handlers:
+            asyncio.run_coroutine_threadsafe(
+                self.handlers[msg.topic](msg.payload.decode()),
+                self.loop
+            )
+            
+    async def start(self):
+        """Start the MQTT client"""
+        self.loop = asyncio.get_event_loop()
+        self._connected = asyncio.Event()
+        self.client.connect(self.broker, self.port)
+        self.client.loop_start()
+        
+        try:
+            await asyncio.wait_for(self._connected.wait(), timeout=5.0)
+        except asyncio.TimeoutError:
+            raise TimeoutError("MQTT connection timeout")
+        
+    async def stop(self):
+        """Stop the MQTT client"""
+        self.client.loop_stop()
+        self.client.disconnect()
+
+@pytest_asyncio.fixture
+async def async_api_mqtt_handler(everest_core: EverestCore) -> AsyncApiMqttHandler:
+    broker = os.environ.get("MQTT_SERVER_ADDRESS", "localhost")
+    handler = AsyncApiMqttHandler(broker, 1883, everest_core.mqtt_external_prefix)
+    await handler.start()
+    yield handler
+    await handler.stop()
+
+@pytest.fixture
+def probe_module(everest_core: EverestCore) -> ProbeModule:
+    everest_core.start(standalone_module='probe')
+    probe_module = ProbeModule(everest_core.get_runtime_session())
+    probe_module.start()
+    return probe_module
+
+@pytest.mark.asyncio
+@pytest.mark.everest_core_config('probe-system.yaml')
+async def test_api_cmds(everest_core: EverestCore, async_api_mqtt_handler: AsyncApiMqttHandler, probe_module: ProbeModule):
+
+    mqtt_prefix = everest_core.mqtt_external_prefix
+
+    # register mqtt handler for get_boot_reason
+    async def on_get_boot_reason(payload: str):
+        request = json.loads(payload)
+        response_topic = request['headers']['replyTo']
+        response_payload = "ApplicationReset"
+        await async_api_mqtt_handler.publish(f"{mqtt_prefix}{response_topic}", json.dumps(response_payload))
+
+    # register mqtt handler for set_system_time
+    async def on_set_system_time(payload: str):
+        request = json.loads(payload)
+        response_topic = request['headers']['replyTo']
+        response_payload = True
+        await async_api_mqtt_handler.publish(f"{mqtt_prefix}{response_topic}", json.dumps(response_payload))
+
+    # register mqtt handler for update_firmware
+    async def on_update_firmware(payload: str):
+        request = json.loads(payload)
+        response_topic = request['headers']['replyTo']
+        response_payload = "Accepted"
+        await async_api_mqtt_handler.publish(f"{mqtt_prefix}{response_topic}", json.dumps(response_payload))
+
+    # register mqtt handler for upload_logs
+    async def on_upload_logs(payload: str):
+        request = json.loads(payload)
+        response_topic = request['headers']['replyTo']
+        response_payload = {
+            "file_name": "test_log.txt",
+            "upload_logs_status": "Accepted"
+        }
+        await async_api_mqtt_handler.publish(f"{mqtt_prefix}{response_topic}", json.dumps(response_payload))
+
+    # register mqtt handler for is_reset_allowed
+    async def on_is_reset_allowed(payload: str):
+        request = json.loads(payload)
+        response_topic = request['headers']['replyTo']
+        response_payload = True
+        await async_api_mqtt_handler.publish(f"{mqtt_prefix}{response_topic}", json.dumps(response_payload))
+
+    async_api_mqtt_handler.register_handler(f"{everest_core.mqtt_external_prefix}everest_api/1/system/system_api/e2m/get_boot_reason", on_get_boot_reason)
+    async_api_mqtt_handler.register_handler(f"{everest_core.mqtt_external_prefix}everest_api/1/system/system_api/e2m/set_system_time", on_set_system_time)
+    async_api_mqtt_handler.register_handler(f"{everest_core.mqtt_external_prefix}everest_api/1/system/system_api/e2m/update_firmware", on_update_firmware)
+    async_api_mqtt_handler.register_handler(f"{everest_core.mqtt_external_prefix}everest_api/1/system/system_api/e2m/upload_logs", on_upload_logs)
+    async_api_mqtt_handler.register_handler(f"{everest_core.mqtt_external_prefix}everest_api/1/system/system_api/e2m/is_reset_allowed", on_is_reset_allowed)
+
+    result = await probe_module.call_command(
+        'system',
+        'get_boot_reason',
+        {}
+    )
+    assert result == "ApplicationReset"
+
+    result = await probe_module.call_command(
+        'system',
+        'set_system_time',
+        {'timestamp': "2024-01-01T00:00:00Z"}
+    )
+    assert result == True
+
+    result = await probe_module.call_command(
+        'system',
+        'update_firmware',
+        {
+            'firmware_update_request': {
+                'location': 'http://example.com/firmware.bin',
+                'request_id': 1
+            }
+        }
+    )
+    assert result == "Accepted"
+
+    result = await probe_module.call_command(
+        'system',
+        'upload_logs',
+        {
+            'upload_logs_request': {
+                'location': 'http://example.com/logs'
+            }
+        }
+    )
+    assert result == {"file_name": "test_log.txt", "upload_logs_status": "Accepted"}
+
+    result = await probe_module.call_command(
+        'system',
+        'is_reset_allowed',
+        {'type': 'Soft'}
+    )
+    assert result == True

tools/EVerest-main/tests/conftest.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Pionix GmbH and Contributors to EVerest
+
+from pathlib import Path
+import pytest
+
+from everest.testing.core_utils.network_isolation import NetworkIsolationPlugin
+
+
+def pytest_addoption(parser):
+    parser.addoption("--everest-prefix", action="store", default="../build/dist",
+                     help="everest prefix path; default = '../build/dist'")
+    parser.addoption(
+        "--network-isolation",
+        action="store_true",
+        default=False,
+        help="Enable network isolation for parallel ISO 15118 tests. "
+             "Requires veth pairs created by setup-network-isolation.sh.",
+    )
+
+
+def pytest_configure(config):
+    NetworkIsolationPlugin.register(config)
+
+    everest_prefix = config.getoption('--everest-prefix')
+    everest_config_path = Path(everest_prefix) / 'etc/everest'
+    if not everest_config_path.exists():
+        return
+    everest_configs = [path for path in everest_config_path.iterdir(
+    ) if path.name.startswith('config-') and path.name.endswith('.yaml')]
+    pytest.everest_configs = {}
+    pytest.everest_configs['params'] = []
+    pytest.everest_configs['ids'] = []
+    for config_path in everest_configs:
+        config_id = config_path.stem
+        if config_id == 'config-sil-gen-pm' or config_id.startswith('config-test-') or config_id.startswith('config-bringup-') or config_id.startswith('config-CB'):
+            # skip
+            continue
+        pytest.everest_configs['params'].append(config_path)
+        pytest.everest_configs['ids'].append(config_id)
+
+@pytest.fixture
+def started_test_controller(test_controller):
+    test_controller.start()
+    yield test_controller
+    test_controller.stop()

tools/EVerest-main/tests/core_tests/config_tests.py

@@ -0,0 +1,60 @@
+
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Pionix GmbH and Contributors to EVerest
+
+from copy import deepcopy
+import logging
+import os
+from pathlib import Path
+import pty
+import pytest
+from tempfile import mkdtemp
+from typing import Dict
+
+from everest.testing.core_utils.fixtures import *
+from everest.testing.core_utils.everest_core import EverestCore
+
+from everest.testing.core_utils import EverestConfigAdjustmentStrategy
+
+
+class EverestCoreConfigSilGenPmConfigurationAdjustment(EverestConfigAdjustmentStrategy):
+    def __init__(self):
+        self.temporary_directory = mkdtemp()
+        self.serial_port_0, self.serial_port_1 = pty.openpty()
+        # FIXME: cleanup socket after test
+        self.serial_port_0_name = os.ttyname(self.serial_port_0)
+
+    def adjust_everest_configuration(self, everest_config: Dict):
+        adjusted_config = deepcopy(everest_config)
+
+        adjusted_config["active_modules"]["serial_comm_hub"]["config_implementation"]["main"]["serial_port"] = self.serial_port_0_name
+
+        return adjusted_config
+
+
+@pytest.mark.everest_core_config('config-sil-gen-pm.yaml')
+@pytest.mark.everest_config_adaptions(EverestCoreConfigSilGenPmConfigurationAdjustment())
+@pytest.mark.asyncio
+async def test_start_config_sil_gen_pm(everest_core: EverestCore):
+    logging.info(">>>>>>>>> test_start_config_sil_gen_pm <<<<<<<<<")
+
+    everest_core.start()
+
+
+class TestConfigsInDirectory:
+    @pytest.fixture(params=pytest.everest_configs['params'], ids=pytest.everest_configs['ids'])
+    def core_config(self, request) -> EverestEnvironmentCoreConfiguration:
+        everest_prefix = Path(request.config.getoption("--everest-prefix"))
+
+        everest_config_path = request.param
+
+        return EverestEnvironmentCoreConfiguration(
+            everest_core_path=everest_prefix,
+            template_everest_config_path=everest_config_path,
+        )
+
+    @pytest.mark.asyncio
+    async def test_config(self, everest_core: EverestCore):
+        logging.info(">>>>>>>>> test_config <<<<<<<<<")
+        everest_core.start()

tools/EVerest-main/tests/core_tests/error_history_tests.py

@@ -0,0 +1,266 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Pionix GmbH and Contributors to EVerest
+
+from copy import deepcopy
+from typing import Dict
+import uuid
+import pytest
+import asyncio
+
+from everest.testing.core_utils.fixtures import *
+from everest.testing.core_utils.everest_core import EverestCore
+from everest.testing.core_utils.probe_module import ProbeModule
+
+def assert_error(expected_error, error):
+    assert expected_error['type'] == error['type']
+    assert expected_error['sub_type'] == error['sub_type']
+    assert expected_error['message'] == error['message']
+    assert expected_error['severity'] == error['severity']
+    assert expected_error['state'] == error['state']
+    assert expected_error['description'] == error['description']
+    assert expected_error['origin']['module_id'] == error['origin']['module_id']
+    assert expected_error['origin']['implementation_id'] == error['origin']['implementation_id']
+
+def assert_errors(expected_errors, errors):
+    assert len(expected_errors) == len(errors)
+    for exp_err in expected_errors:
+        index = None
+        for (i, err) in zip(range(len(errors)), errors):
+            if exp_err['type'] == err['type'] and exp_err['sub_type'] == err['sub_type']:
+                if index is not None:
+                    assert False, f'Found multiple errors with uuid {exp_err["uuid"]}'
+                index = i
+
+        assert index is not None
+        assert_error(exp_err, errors[index])
+
+class ErrorHistoryModuleConfigurationStrategy(EverestConfigAdjustmentStrategy):
+    def __init__(self, db_name):
+        self.db_name = db_name
+    def adjust_everest_configuration(self, everest_config: Dict) -> Dict:
+        db_path = f'{self.db_name}.db'
+        adjusted_config = deepcopy(everest_config)
+        module_config = adjusted_config['active_modules']['error_history']
+        module_config['config_implementation'] = {
+            'error_history': {
+                'database_path': db_path
+            }
+        }
+        return adjusted_config
+
+class UniqueDBNameStrategy(ErrorHistoryModuleConfigurationStrategy):
+    def __init__(self):
+        db_name = 'database_' + str(uuid.uuid4())
+        super().__init__(db_name=db_name)
+    def adjust_everest_configuration(self, everest_config: Dict) -> Dict:
+        return super().adjust_everest_configuration(everest_config)
+
+class TestErrorHistory:
+    """
+    Tests for the ErrorHistory module.
+    """
+
+    @pytest.mark.asyncio
+    @pytest.mark.everest_core_config('config-test-error-history-module.yaml')
+    @pytest.mark.everest_config_adaptions(UniqueDBNameStrategy())
+    async def test_error_history(self, everest_core: EverestCore):
+        """
+        Test the ErrorHistory module.
+        """
+        everest_core.start(standalone_module='probe')
+
+        probe_module = ProbeModule(everest_core.get_runtime_session())
+        probe_module.start()
+
+        call_args = {
+            'filters': {}
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert len(result) == 0
+
+        err_args = {
+            'type': 'test_errors/TestErrorA',
+            'sub_type': '',
+            'message': 'Test Error A',
+            'severity': 'Low'
+        }
+        await probe_module.call_command(
+            'test_error_handling',
+            'raise_error',
+            err_args
+        )
+        expected_error = {
+            'type': err_args['type'],
+            'sub_type': '',
+            'message': err_args['message'],
+            'severity': err_args['severity'],
+            'state': 'Active',
+            'description': 'Test error A',
+            'origin': {
+                'module_id': 'test_error_handling',
+                'implementation_id': 'main'
+            }
+        }
+        await asyncio.sleep(0.5)
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert len(result) == 1
+        assert_error(expected_error, result[0])
+
+        await probe_module.call_command(
+            'test_error_handling',
+            'clear_error',
+            {
+                'type': err_args['type'],
+                'sub_type': err_args['sub_type'],
+            }
+        )
+        expected_error['state'] = 'ClearedByModule'
+        await asyncio.sleep(0.5)
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_error(expected_error, result[0])
+
+    @pytest.mark.asyncio
+    @pytest.mark.everest_core_config('config-test-error-history-module.yaml')
+    @pytest.mark.everest_config_adaptions(UniqueDBNameStrategy())
+    async def test_error_history_filter(self, everest_core: EverestCore):
+        """
+        Test the ErrorHistory module with filters.
+        """
+        everest_core.start(standalone_module='probe')
+
+        probe_module = ProbeModule(everest_core.get_runtime_session())
+        probe_module.start()
+        # insert 12 errors
+        test_errors = [
+            # index 0
+            {
+                'type': 'test_errors/TestErrorA',
+                'sub_type': '',
+                'message': 'Test Error A',
+                'severity': 'Low',
+                'description': 'Test error A',
+                'state': 'Active',
+                'origin': {
+                    'module_id': 'test_error_handling',
+                    'implementation_id': 'main'
+                }
+            },
+            # index 1
+            {
+                'type': 'test_errors/TestErrorB',
+                'sub_type': '',
+                'message': 'Test Error B',
+                'severity': 'Low',
+                'description': 'Test error B',
+                'state': 'Active',
+                'origin': {
+                    'module_id': 'test_error_handling',
+                    'implementation_id': 'main'
+                }
+            },
+        ]
+        for err in test_errors:
+            err_args = {
+                'type': err['type'],
+                'sub_type': err['sub_type'],
+                'message': err['message'],
+                'severity': err['severity']
+            }
+            await probe_module.call_command(
+                'test_error_handling',
+                'raise_error',
+                err_args
+            )
+        await asyncio.sleep(0.5)
+
+        # get all errors
+        call_args = {
+            'filters': {}
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors(test_errors, result)
+
+        # get all errors with type TestErrorA
+        call_args['filters'] = {
+            'type_filter': 'test_errors/TestErrorA'
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors([test_errors[0]], result)
+
+        # get all errors from module test_error_handling
+        call_args['filters'] = {
+            'origin_filter': {
+                'module_id': 'test_error_handling',
+                'implementation_id': 'main'
+            }
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors(test_errors, result)
+
+        # get all errors with severity Low
+        call_args['filters'] = {
+            'severity_filter': 'HIGH_GE'
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors([], result)
+
+        # get all 'Active' errors
+        call_args['filters'] = {
+            'state_filter': 'Active'
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors(test_errors, result)
+
+        for err in test_errors:
+            await probe_module.call_command(
+                'test_error_handling',
+                'clear_error',
+                {
+                    'type': err['type'],
+                    'sub_type': err['sub_type']
+                }
+            )
+            err['state'] = 'ClearedByModule'
+        await asyncio.sleep(0.5)
+
+        call_args['filters'] = {
+            'state_filter': 'ClearedByModule'
+        }
+        result = await probe_module.call_command(
+            'error_history',
+            'get_errors',
+            call_args
+        )
+        assert_errors(test_errors, result)

tools/EVerest-main/tests/everest-core_tests/CMakeLists.txt

@@ -0,0 +1,6 @@
+project(everest-core_tests
+    DESCRIPTION "Extending EVerest with testing modules/interfaces/types/errors.. etc"
+    LANGUAGES CXX C)
+ev_add_project(SKIP_DOC_GENERATION)
+
+add_subdirectory(config)

tools/EVerest-main/tests/everest-core_tests/config/CMakeLists.txt

@@ -0,0 +1,6 @@
+# install configs
+install(
+    DIRECTORY "."
+    DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/everest"
+    FILES_MATCHING PATTERN "*.yaml"
+)

tools/EVerest-main/tests/everest-core_tests/config/config-test-cpp-error-handling.yaml

@@ -0,0 +1,13 @@
+active_modules:
+  test_error_handling:
+    module: TestErrorHandling
+    connections:
+      error_raiser:
+        - module_id: probe
+          implementation_id: main
+  test_error_handling_not_req:
+    module: TestErrorHandling
+    connections:
+      error_raiser:
+        - module_id: probe
+          implementation_id: main

tools/EVerest-main/tests/everest-core_tests/config/config-test-error-history-module.yaml

@@ -0,0 +1,18 @@
+active_modules:
+  error_history:
+    module: ErrorHistory
+  test_error_handling:
+    module: TestErrorHandling
+    connections:
+      error_raiser:
+        - module_id: probe
+          implementation_id: main
+  probe:
+    module: ProbeModule
+    connections:
+      test_error_handling:
+        - module_id: test_error_handling
+          implementation_id: main
+      error_history:
+        - module_id: error_history
+          implementation_id: error_history

tools/EVerest-main/tests/everest-core_tests/errors/test_errors.yaml

@@ -0,0 +1,11 @@
+description: >-
+  Set of test error definitions
+errors:
+  - name: TestErrorA
+    description: Test error A
+  - name: TestErrorB
+    description: Test error B
+  - name: TestErrorC
+    description: Test error C
+  - name: TestErrorD
+    description: Test error D

tools/EVerest-main/tests/everest-core_tests/interfaces/test_error_handling.yaml

@@ -0,0 +1,84 @@
+description: >-
+  This interface defines an testing interface that allows to control the
+  usage of error handling features
+cmds:
+  clear_error:
+    description: This command clears all errors of a specific type
+    arguments:
+      type:
+        description: This argument allows to specify the type
+          cleared
+        type: string
+        enum:
+          - test_errors/TestErrorA
+          - test_errors/TestErrorB
+          - test_errors/TestErrorC
+          - test_errors/TestErrorD
+      sub_type:
+        description: This argument allows to specify the sub type
+        type: string
+  clear_all_errors:
+    description: This command clears all errors that are raised by this implementation
+  raise_error:
+    description: This command raises an error
+    arguments:
+      type:
+        description: This argument allows to specify the type
+          raised
+        type: string
+        enum:
+          - test_errors/TestErrorA
+          - test_errors/TestErrorB
+          - test_errors/TestErrorC
+          - test_errors/TestErrorD
+      sub_type:
+        description: This argument allows to specify the sub type
+        type: string
+      message:
+        description: This argument allows to specify the message
+        type: string
+      severity:
+        description: This argument allows to specify the severity
+        type: string
+        enum:
+          - Low
+          - Medium
+          - High
+vars:
+  errors_subscribe_TestErrorA:
+    description: >-
+      This variable publishes the errors raised by error_raiser
+    type: object
+  errors_cleared_subscribe_TestErrorA:
+    description: >-
+      This variable publishes the errors that are cleared by error_raiser
+    type: object
+  errors_subscribe_TestErrorB:
+    description: >-
+      This variable publishes the errors raised by error_raiser
+    type: object
+  errors_cleared_subscribe_TestErrorB:
+    description: >-
+      This variable publishes the errors that are cleared by error_raiser
+    type: object
+  errors_subscribe_all:
+    description: >-
+      This variable publishes the errors raised by error_raiser
+    type: object
+  errors_cleared_subscribe_all:
+    description: >-
+      This variable publishes the errors that are cleared by error_raiser
+    type: object
+  errors_subscribe_global_all:
+    description: >-
+      This variable publishes the errors raised by any module/implementation
+    type: object
+  errors_cleared_subscribe_global_all:
+    description: >-
+      This variable publishes the errors that are cleared by any module/implementation
+    type: object
+errors:
+  - reference: /errors/test_errors#/TestErrorA
+  - reference: /errors/test_errors#/TestErrorB
+  - reference: /errors/test_errors#/TestErrorC
+  - reference: /errors/test_errors#/TestErrorD

tools/EVerest-main/tests/everest-core_tests/interfaces/test_error_raiser.yaml

@@ -0,0 +1,4 @@
+description: >-
+  This interface defines a test interface that allows to raise errors
+errors:
+  - reference: /errors/test_errors

tools/EVerest-main/tests/everest-core_tests/modules/CMakeLists.txt

@@ -0,0 +1 @@
+ev_add_module(TestErrorHandling SKIP_DOC_GENERATION)

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/CMakeLists.txt

@@ -0,0 +1,21 @@
+#
+# AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+# template version 3
+#
+
+# module setup:
+#   - ${MODULE_NAME}: module name
+ev_setup_cpp_module()
+
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+# insert your custom targets and additional config variables here
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+
+target_sources(${MODULE_NAME}
+    PRIVATE
+        "main/test_error_handlingImpl.cpp"
+)
+
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
+# insert other things like install cmds etc here
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/TestErrorHandling.cpp

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#include "TestErrorHandling.hpp"
+
+namespace module {
+
+void TestErrorHandling::init() {
+    invoke_init(*p_main);
+}
+
+void TestErrorHandling::ready() {
+    invoke_ready(*p_main);
+}
+
+} // namespace module

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/TestErrorHandling.hpp

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef TEST_ERROR_HANDLING_HPP
+#define TEST_ERROR_HANDLING_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 2
+//
+
+#include "ld-ev.hpp"
+
+// headers for provided interface implementations
+#include <generated/interfaces/test_error_handling/Implementation.hpp>
+
+// headers for required interface implementations
+#include <generated/interfaces/test_error_raiser/Interface.hpp>
+
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+// insert your custom include headers here
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+
+namespace module {
+
+struct Conf {};
+
+class TestErrorHandling : public Everest::ModuleBase {
+public:
+    TestErrorHandling() = delete;
+    TestErrorHandling(const ModuleInfo& info, std::unique_ptr<test_error_handlingImplBase> p_main,
+                      std::unique_ptr<test_error_raiserIntf> r_error_raiser, Conf& config) :
+        ModuleBase(info), p_main(std::move(p_main)), r_error_raiser(std::move(r_error_raiser)), config(config){};
+
+    const std::unique_ptr<test_error_handlingImplBase> p_main;
+    const std::unique_ptr<test_error_raiserIntf> r_error_raiser;
+    const Conf& config;
+
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+    // insert your public definitions here
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+
+protected:
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+    // insert your protected definitions here
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+
+private:
+    friend class LdEverest;
+    void init();
+    void ready();
+
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+    // insert your private definitions here
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+};
+
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+// insert other definitions here
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+
+} // namespace module
+
+#endif // TEST_ERROR_HANDLING_HPP

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/main/test_error_handlingImpl.cpp

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include "test_error_handlingImpl.hpp"
+
+#include <fmt/format.h>
+#include <utils/error.hpp>
+#include <utils/error/error_json.hpp>
+
+namespace module {
+namespace main {
+
+void test_error_handlingImpl::init() {
+    this->mod->r_error_raiser->subscribe_error(
+        "test_errors/TestErrorA",
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_subscribe_TestErrorA(json(error));
+        },
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_cleared_subscribe_TestErrorA(json(error));
+        });
+    this->mod->r_error_raiser->subscribe_error(
+        "test_errors/TestErrorB",
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_subscribe_TestErrorB(json(error));
+        },
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_cleared_subscribe_TestErrorB(json(error));
+        });
+    this->mod->r_error_raiser->subscribe_all_errors(
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_subscribe_all(json(error));
+        },
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_cleared_subscribe_all(json(error));
+        });
+    subscribe_global_all_errors(
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_subscribe_global_all(json(error));
+        },
+        [this](const Everest::error::Error& error) {
+            EVLOG_debug << fmt::format("received error: {}", json(error).dump(2));
+            this->publish_errors_cleared_subscribe_global_all(json(error));
+        });
+}
+
+void test_error_handlingImpl::ready() {
+}
+
+void test_error_handlingImpl::handle_clear_error(std::string& type, std::string& sub_type) {
+    this->clear_error(type, sub_type);
+}
+
+void test_error_handlingImpl::handle_clear_all_errors() {
+    this->clear_all_errors_of_impl();
+}
+
+void test_error_handlingImpl::handle_raise_error(std::string& type, std::string& sub_type, std::string& message,
+                                                 std::string& severity) {
+    Everest::error::Error error =
+        this->error_factory->create_error(type, sub_type, message, Everest::error::string_to_severity(severity));
+    this->raise_error(error);
+}
+
+} // namespace main
+} // namespace module

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/main/test_error_handlingImpl.hpp

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef MAIN_TEST_ERROR_HANDLING_IMPL_HPP
+#define MAIN_TEST_ERROR_HANDLING_IMPL_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 3
+//
+
+#include <generated/interfaces/test_error_handling/Implementation.hpp>
+
+#include "../TestErrorHandling.hpp"
+
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+// insert your custom include headers here
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+
+namespace module {
+namespace main {
+
+struct Conf {};
+
+class test_error_handlingImpl : public test_error_handlingImplBase {
+public:
+    test_error_handlingImpl() = delete;
+    test_error_handlingImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<TestErrorHandling>& mod,
+                            Conf& config) :
+        test_error_handlingImplBase(ev, "main"), mod(mod), config(config){};
+
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+    // insert your public definitions here
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+
+protected:
+    // command handler functions (virtual)
+    virtual void handle_clear_error(std::string& type, std::string& sub_type) override;
+    virtual void handle_clear_all_errors() override;
+    virtual void handle_raise_error(std::string& type, std::string& sub_type, std::string& message,
+                                    std::string& severity) override;
+
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+    // insert your protected definitions here
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+
+private:
+    const Everest::PtrContainer<TestErrorHandling>& mod;
+    const Conf& config;
+
+    virtual void init() override;
+    virtual void ready() override;
+
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+    // insert your private definitions here
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+};
+
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+// insert other definitions here
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+
+} // namespace main
+} // namespace module
+
+#endif // MAIN_TEST_ERROR_HANDLING_IMPL_HPP

tools/EVerest-main/tests/everest-core_tests/modules/TestErrorHandling/manifest.yaml

@@ -0,0 +1,13 @@
+description: Defines a module that uses error handling features on command
+provides:
+  main:
+    description: This implements an interface that provides control over error handling features
+    interface: test_error_handling
+requires:
+  error_raiser:
+    interface: test_error_raiser  
+enable_global_errors: true  
+metadata:
+  license: https://opensource.org/licenses/Apache-2.0
+  authors:
+    - Andreas Heinrich

tools/EVerest-main/tests/framework_tests/cpp_tests.py

@@ -0,0 +1,739 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Pionix GmbH and Contributors to EVerest
+
+import logging
+import pytest
+import asyncio
+
+from everest.framework import error
+from everest.testing.core_utils.common import Requirement
+from everest.testing.core_utils.fixtures import *
+from everest.testing.core_utils.everest_core import EverestCore
+from everest.testing.core_utils.probe_module import ProbeModule
+
+from dataclasses import dataclass
+@dataclass
+class ErrorHandlingTesterState:
+    """
+    Represents state of ErrorHandlingTester
+    """
+    len_probe_module_errors_TestErrorA: int = 0
+    len_probe_module_errors_cleared_TestErrorA: int = 0
+    len_probe_module_errors_TestErrorB: int = 0
+    len_probe_module_errors_cleared_TestErrorB: int = 0
+    len_probe_module_errors_TestErrorC: int = 0
+    len_probe_module_errors_cleared_TestErrorC: int = 0
+    len_probe_module_errors_TestErrorD: int = 0
+    len_probe_module_errors_cleared_TestErrorD: int = 0
+
+    len_test_error_handling_errors_TestErrorA: int = 0
+    len_test_error_handling_errors_cleared_TestErrorA: int = 0
+    len_test_error_handling_errors_TestErrorB: int = 0
+    len_test_error_handling_errors_cleared_TestErrorB: int = 0
+    len_test_error_handling_errors_all: int = 0
+    len_test_error_handling_errors_cleared_all: int = 0
+    len_test_error_handling_errors_global_all: int = 0
+    len_test_error_handling_errors_cleared_global_all: int = 0
+
+class ErrorHandlingTester:
+    """
+    Helper class to allow reusing testing mechanisms.
+    """
+    def __init__(self, probe_module: ProbeModule):
+        self.__probe_module = probe_module
+
+        self.test_error_handling = {
+            'errors_TestErrorA': [],
+            'errors_cleared_TestErrorA': [],
+            'errors_TestErrorB': [],
+            'errors_cleared_TestErrorB': [],
+            'errors_all': [],
+            'errors_cleared_all': [],
+            'errors_global_all': [],
+            'errors_cleared_global_all': [],
+        }
+
+        self.probe_module = {
+            'errors_TestErrorA': [],
+            'errors_cleared_TestErrorA': [],
+            'errors_TestErrorB': [],
+            'errors_cleared_TestErrorB': [],
+            'errors_TestErrorC': [],
+            'errors_cleared_TestErrorC': [],
+            'errors_TestErrorD': [],
+            'errors_cleared_TestErrorD': [],
+        }
+
+        self.__test_error_handling_conn_id = 'test_error_handling'
+        self.__test_error_handling_not_req_conn_id = 'test_error_handling_not_req'
+        self.__test_error_handling_ful = self.__probe_module._setup.connections[self.__test_error_handling_conn_id][0]
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_subscribe_TestErrorA',
+            self.__handle_errors_subscribe_TestErrorA
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_cleared_subscribe_TestErrorA',
+            self.__handle_errors_cleared_subscribe_TestErrorA
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_subscribe_TestErrorB',
+            self.__handle_errors_subscribe_TestErrorB
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_cleared_subscribe_TestErrorB',
+            self.__handle_errors_cleared_subscribe_TestErrorB
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_subscribe_all',
+            self.__handle_errors_subscribe_all
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_cleared_subscribe_all',
+            self.__handle_errors_cleared_subscribe_all
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_subscribe_global_all',
+            self.__handle_errors_subscribe_global_all
+        )
+        self.__probe_module._mod.subscribe_variable(
+            self.__test_error_handling_ful,
+            'errors_cleared_subscribe_global_all',
+            self.__handle_errors_cleared_subscribe_global_all
+        )
+
+        self.__probe_module._mod.subscribe_error(
+            self.__test_error_handling_ful,
+            'test_errors/TestErrorA',
+            self.__handle_test_errors_TestErrorA,
+            self.__handle_test_errors_TestErrorA_cleared
+        )
+        self.__probe_module._mod.subscribe_error(
+            self.__test_error_handling_ful,
+            'test_errors/TestErrorB',
+            self.__handle_test_errors_TestErrorB,
+            self.__handle_test_errors_TestErrorB_cleared
+        )
+        self.__probe_module._mod.subscribe_error(
+            self.__test_error_handling_ful,
+            'test_errors/TestErrorC',
+            self.__handle_test_errors_TestErrorC,
+            self.__handle_test_errors_TestErrorC_cleared
+        )
+        self.__probe_module._mod.subscribe_error(
+            self.__test_error_handling_ful,
+            'test_errors/TestErrorD',
+            self.__handle_test_errors_TestErrorD,
+            self.__handle_test_errors_TestErrorD_cleared
+        )
+
+    # subscribe var handlers
+    def __handle_errors_subscribe_TestErrorA(self, error):
+        logging.debug(f'handle_test_errors_TestErrorA: {error}')
+        self.test_error_handling['errors_TestErrorA'].append(error)
+    def __handle_errors_cleared_subscribe_TestErrorA(self, error):
+        logging.debug(f'handle_test_errors_TestErrorA_cleared: {error}')
+        self.test_error_handling['errors_cleared_TestErrorA'].append(error)
+    def __handle_errors_subscribe_TestErrorB(self, error):
+        logging.debug(f'handle_test_errors_TestErrorB: {error}')
+        self.test_error_handling['errors_TestErrorB'].append(error)
+    def __handle_errors_cleared_subscribe_TestErrorB(self, error):
+        logging.debug(f'handle_test_errors_TestErrorB_cleared: {error}')
+        self.test_error_handling['errors_cleared_TestErrorB'].append(error)
+    def __handle_errors_subscribe_all(self, error):
+        logging.debug(f'handle_test_errors_all: {error}')
+        self.test_error_handling['errors_all'].append(error)
+    def __handle_errors_cleared_subscribe_all(self, error):
+        logging.debug(f'handle_test_errors_all_cleared: {error}')
+        self.test_error_handling['errors_cleared_all'].append(error)
+    def __handle_errors_subscribe_global_all(self, error):
+        logging.debug(f'handle_test_errors_global_all: {error}')
+        self.test_error_handling['errors_global_all'].append(error)
+    def __handle_errors_cleared_subscribe_global_all(self, error):
+        logging.debug(f'handle_test_errors_global_all_cleared: {error}')
+        self.test_error_handling['errors_cleared_global_all'].append(error)
+
+    # subscribe error handlers
+    def __handle_test_errors_TestErrorA(self, error: error.Error):
+        logging.debug(f'handle_test_errors_TestErrorA: {error}')
+        self.probe_module['errors_TestErrorA'].append(error)
+    def __handle_test_errors_TestErrorA_cleared(self, error: error.Error):
+        logging.debug(f'handle_test_errors_TestErrorA_cleared: {error}')
+        self.probe_module['errors_cleared_TestErrorA'].append(error)
+    def __handle_test_errors_TestErrorB(self, error):
+        logging.debug(f'handle_test_errors_TestErrorB: {error}')
+        self.probe_module['errors_TestErrorB'].append(error)
+    def __handle_test_errors_TestErrorB_cleared(self, error: error.Error):
+        logging.debug(f'handle_test_errors_TestErrorB_cleared: {error}')
+        self.probe_module['errors_cleared_TestErrorB'].append(error)
+    def __handle_test_errors_TestErrorC(self, error):
+        logging.debug(f'handle_test_errors_TestErrorC: {error}')
+        self.probe_module['errors_TestErrorC'].append(error)
+    def __handle_test_errors_TestErrorC_cleared(self, error: error.Error):
+        logging.debug(f'handle_test_errors_TestErrorC_cleared: {error}')
+        self.probe_module['errors_cleared_TestErrorC'].append(error)
+    def __handle_test_errors_TestErrorD(self, error):
+        logging.debug(f'handle_test_errors_TestErrorD: {error}')
+        self.probe_module['errors_TestErrorD'].append(error)
+    def __handle_test_errors_TestErrorD_cleared(self, error: error.Error):
+        logging.debug(f'handle_test_errors_TestErrorD_cleared: {error}')
+        self.probe_module['errors_cleared_TestErrorD'].append(error)
+
+    # raise test error functions on probe module
+    def probe_module_main_raise_error_a(self) -> error.Error:
+        """
+        Raises an test error of type TestErrorA on the probe module (main)
+        Returns the error args and the uuid of the error
+        """
+        err_object = self.__probe_module._mod.get_error_factory('main').create_error(
+            'test_errors/TestErrorA',
+            '',
+            'Test error message',
+            error.Severity.Medium
+        )
+        self.__probe_module._mod.raise_error(
+            'main',
+            err_object
+        )
+        return err_object
+    def probe_module_main_raise_error_b(self) -> error.Error:
+        """
+        Raises an test error of type TestErrorB on the probe modulee (main)
+        Returns the error and the uuid of the error
+        """
+        err_object = self.__probe_module._mod.get_error_factory('main').create_error(
+            'test_errors/TestErrorB',
+            '',
+            'Test error message',
+            error.Severity.Low
+        )
+        self.__probe_module._mod.raise_error(
+            'main',
+            err_object
+        )
+        return err_object
+    def probe_module_main_raise_error_c(self) -> error.Error:
+        """
+        Raises an test error of type TestErrorC on the probe modulee (main)
+        Returns the error and the uuid of the error
+        """
+        err_object = self.__probe_module._mod.get_error_factory('main').create_error(
+            'test_errors/TestErrorC',
+            '',
+            'Test error message',
+            error.Severity.High
+        )
+        self.__probe_module._mod.raise_error(
+            'main',
+            err_object
+        )
+        return err_object
+    def probe_module_main_raise_error_d(self) -> error.Error:
+        """
+        Raises an test error of type TestErrorD on the probe modulee (main)
+        Returns the error and the uuid of the error
+        """
+        err_object = self.__probe_module._mod.get_error_factory('main').create_error(
+            'test_errors/TestErrorD',
+            '',
+            'Test error message',
+            error.Severity.Medium
+        )
+        self.__probe_module._mod.raise_error(
+            'main',
+            err_object
+        )
+        return err_object
+    def probe_module_main_clear_error(self, type: str, sub_type: str):
+        """
+        Clears an error on the probe module (main)
+        """
+        self.__probe_module._mod.clear_error(
+            'main',
+            type,
+            sub_type
+        )
+    # raise test error functions on test_error_handling module
+    async def test_error_handling_raise_error_a(self) -> dict:
+        """
+        Raises an test error of type TestErrorA on the test_error_handling module
+        Returns the error and the uuid of the error
+        """
+        err_args = {
+            'type': 'test_errors/TestErrorA',
+            'sub_type': '',
+            'message': 'Test error message',
+            'severity': 'Medium'
+        }
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'raise_error',
+            err_args
+        )
+        return err_args
+    async def test_error_handling_raise_error_b(self) -> dict:
+        """
+        Raises an test error of type TestErrorB on the test_error_handling module
+        Returns the error and the uuid of the error
+        """
+        err_args = {
+            'type': 'test_errors/TestErrorB',
+            'sub_type': '',
+            'message': 'Test error message',
+            'severity': 'Low'
+        }
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'raise_error',
+            err_args
+        )
+        return err_args
+    async def test_error_handling_raise_error_c(self) -> dict:
+        """
+        Raises an test error of type TestErrorC on the test_error_handling module
+        Returns the error and the uuid of the error
+        """
+        err_args = {
+            'type': 'test_errors/TestErrorC',
+            'sub_type': '',
+            'message': 'Test error message',
+            'severity': 'High'
+        }
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'raise_error',
+            err_args
+        )
+        return err_args
+    async def test_error_handling_raise_error_d(self) -> dict:
+        """
+        Raises an test error of type TestErrorD on the test_error_handling module
+        Returns the error and the uuid of the error
+        """
+        err_args = {
+            'type': 'test_errors/TestErrorD',
+            'sub_type': '',
+            'message': 'Test error message',
+            'severity': 'Medium'
+        }
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'raise_error',
+            err_args
+        )
+        return err_args
+    async def test_error_handling_clear_a(self):
+        """
+        Clears all errors of type TestErrorA on the test_error_handling module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'clear_error',
+            {
+                'type': 'test_errors/TestErrorA',
+                'sub_type': ''
+            }
+        )
+    async def test_error_handling_clear_b(self):
+        """
+        Clears all errors of type TestErrorB on the test_error_handling module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'clear_error',
+            {
+                'type': 'test_errors/TestErrorB',
+                'sub_type': ''
+            }
+        )
+    async def test_error_handling_clear_c(self):
+        """
+        Clears all errors of type TestErrorC on the test_error_handling module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'clear_error',
+            {
+                'type': 'test_errors/TestErrorC',
+                'sub_type': ''
+            }
+        )
+    async def test_error_handling_clear_d(self):
+        """
+        Clears all errors of type TestErrorD on the test_error_handling module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'clear_error',
+            {
+                'type': 'test_errors/TestErrorD',
+                'sub_type': ''
+            }
+        )
+    async def test_error_handling_clear_all(self):
+        """
+        Clears all errors on the test_error_handling module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_conn_id,
+            'clear_all_errors',
+            {}
+        )
+
+    async def test_error_handling_not_req_raise_error_a(self) -> dict:
+        """
+        Raises an test error of type TestErrorA on the test_error_handling_not_req module
+        Returns the error and the uuid of the error
+        """
+        err_args = {
+            'type': 'test_errors/TestErrorA',
+            'sub_type': '',
+            'message': 'Test error message',
+            'severity': 'Medium'
+        }
+        await self.__probe_module.call_command(
+            self.__test_error_handling_not_req_conn_id,
+            'raise_error',
+            err_args
+        )
+        return err_args
+
+    async def test_error_handling_not_req_clear_error(self, type: str, sub_type: str):
+        """
+        Clears an error on the test_error_handling_not_req module
+        """
+        await self.__probe_module.call_command(
+            self.__test_error_handling_not_req_conn_id,
+            'clear_error',
+            {
+                'type': type,
+                'sub_type': sub_type
+            }
+        )
+
+    def get_state(self) -> ErrorHandlingTesterState:
+        state = ErrorHandlingTesterState(
+            len_probe_module_errors_TestErrorA=len(self.probe_module['errors_TestErrorA']),
+            len_probe_module_errors_cleared_TestErrorA=len(self.probe_module['errors_cleared_TestErrorA']),
+            len_probe_module_errors_TestErrorB=len(self.probe_module['errors_TestErrorB']),
+            len_probe_module_errors_cleared_TestErrorB=len(self.probe_module['errors_cleared_TestErrorB']),
+            len_probe_module_errors_TestErrorC=len(self.probe_module['errors_TestErrorC']),
+            len_probe_module_errors_cleared_TestErrorC=len(self.probe_module['errors_cleared_TestErrorC']),
+            len_probe_module_errors_TestErrorD=len(self.probe_module['errors_TestErrorD']),
+            len_probe_module_errors_cleared_TestErrorD=len(self.probe_module['errors_cleared_TestErrorD']),
+            len_test_error_handling_errors_TestErrorA=len(self.test_error_handling['errors_TestErrorA']),
+            len_test_error_handling_errors_cleared_TestErrorA=len(self.test_error_handling['errors_cleared_TestErrorA']),
+            len_test_error_handling_errors_TestErrorB=len(self.test_error_handling['errors_TestErrorB']),
+            len_test_error_handling_errors_cleared_TestErrorB=len(self.test_error_handling['errors_cleared_TestErrorB']),
+            len_test_error_handling_errors_all=len(self.test_error_handling['errors_all']),
+            len_test_error_handling_errors_cleared_all=len(self.test_error_handling['errors_cleared_all']),
+            len_test_error_handling_errors_global_all=len(self.test_error_handling['errors_global_all']),
+            len_test_error_handling_errors_cleared_global_all=len(self.test_error_handling['errors_cleared_global_all']),
+        )
+        return state
+
+@pytest.mark.probe_module(
+    connections={
+        "test_error_handling": [
+            Requirement(module_id="test_error_handling", implementation_id="main")
+        ],
+        "test_error_handling_not_req": [
+            Requirement(module_id="test_error_handling_not_req", implementation_id="main")
+        ]
+    }
+)
+class TestErrorHandling:
+    """
+    Tests for error handling
+    """
+    @pytest.fixture
+    def probe_module(self, started_test_controller, everest_core):
+        return ProbeModule(everest_core.get_runtime_session())
+
+    @pytest.fixture
+    def error_handling_tester(self, probe_module: ProbeModule):
+        """
+        Fixture to allow reusing testing mechanisms.
+        """
+        return ErrorHandlingTester(probe_module)
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_raise_error(
+        self,
+        error_handling_tester: ErrorHandlingTester,
+    ):
+        """
+        Tests that errors are raised correctly.
+        The probe module triggers the TestErrorHandling module to raise an error,
+        and then checks that the error is raised by subscribing to it.
+        """
+        err_args = await error_handling_tester.test_error_handling_raise_error_a()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_probe_module_errors_TestErrorA=1,
+            len_test_error_handling_errors_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        recieved_error = error_handling_tester.probe_module['errors_TestErrorA'][0]
+        assert recieved_error.type == err_args['type'], 'Received wrong error type'
+        assert recieved_error.sub_type == err_args['sub_type'], 'Received wrong error sub type'
+        assert recieved_error.message == err_args['message'], 'Received wrong error message'
+        assert recieved_error.severity.name == err_args['severity'], 'Received wrong error severity'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_clear_errors_by_type(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        Tests that errors are cleared correctly.
+        The probe module triggers the TestErrorHandling module to raise multiple errors,
+        and then triggers the TestErrorHandling module to clear errors by type,
+        and then checks that the correct errors are cleared.
+        """
+
+        await error_handling_tester.test_error_handling_raise_error_a()
+        await error_handling_tester.test_error_handling_raise_error_b()
+        await error_handling_tester.test_error_handling_raise_error_c()
+        await asyncio.sleep(0.5)
+        await error_handling_tester.test_error_handling_clear_b()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_probe_module_errors_TestErrorA=1,
+            len_probe_module_errors_TestErrorB=1,
+            len_probe_module_errors_TestErrorC=1,
+            len_probe_module_errors_cleared_TestErrorB=1,
+            len_test_error_handling_errors_global_all=3,
+            len_test_error_handling_errors_cleared_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_errors_b = error_handling_tester.probe_module['errors_TestErrorB']
+        cleared_errors_B = error_handling_tester.probe_module['errors_cleared_TestErrorB']
+        for raised_error in raised_errors_b:
+            res = False
+            for cleared_error in cleared_errors_B:
+                if raised_error.type == cleared_error.type:
+                    res = True
+                    break
+            assert res, 'Raised errors should be cleared'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_clear_all_errors(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        Tests that errors are cleared correctly.
+        The probe module triggers the TestErrorHandling module to raise multiple errors,
+        and then triggers the TestErrorHandling module to clear all errors,
+        and then checks that all errors are cleared.
+        """
+
+        await error_handling_tester.test_error_handling_raise_error_a()
+        await error_handling_tester.test_error_handling_raise_error_b()
+        await error_handling_tester.test_error_handling_raise_error_c()
+        await asyncio.sleep(0.5)
+        await error_handling_tester.test_error_handling_clear_all()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_probe_module_errors_TestErrorA=1,
+            len_probe_module_errors_TestErrorB=1,
+            len_probe_module_errors_TestErrorC=1,
+            len_probe_module_errors_cleared_TestErrorA=1,
+            len_probe_module_errors_cleared_TestErrorB=1,
+            len_probe_module_errors_cleared_TestErrorC=1,
+            len_test_error_handling_errors_global_all=3,
+            len_test_error_handling_errors_cleared_global_all=3
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_errors = error_handling_tester.probe_module['errors_TestErrorA']
+        raised_errors.extend(error_handling_tester.probe_module['errors_TestErrorB'])
+        raised_errors.extend(error_handling_tester.probe_module['errors_TestErrorC'])
+        raised_errors.extend(error_handling_tester.probe_module['errors_TestErrorD'])
+        cleared_errors = error_handling_tester.probe_module['errors_cleared_TestErrorA']
+        cleared_errors.extend(error_handling_tester.probe_module['errors_cleared_TestErrorB'])
+        cleared_errors.extend(error_handling_tester.probe_module['errors_cleared_TestErrorC'])
+        cleared_errors.extend(error_handling_tester.probe_module['errors_cleared_TestErrorD'])
+        for raised_error in raised_errors:
+            res = False
+            for cleared_error in cleared_errors:
+                if raised_error.type == cleared_error.type:
+                    res = True
+                    break
+            assert res, 'Raised errors should be cleared'
+
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_req_error(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe module raises an error of type TestErrorA on the main implementation,
+        TestErrorHandling should be subscribed to this error type.
+        Checks that the error is subscribed correctly.
+        """
+
+        err_object = error_handling_tester.probe_module_main_raise_error_a()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_TestErrorA=1,
+            len_test_error_handling_errors_all=1,
+            len_test_error_handling_errors_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_TestErrorA'][0]
+        assert raised_error['type']== err_object.type, 'Raised error type does not match expected error'
+        assert raised_error['message'] == err_object.message, 'Raised error message does not match expected error'
+        assert raised_error['severity'] == err_object.severity.name, 'Raised error severity does not match expected error'
+        assert raised_error == error_handling_tester.test_error_handling['errors_all'][0], 'Equal error should be received by all'
+        assert raised_error == error_handling_tester.test_error_handling['errors_global_all'][0], 'Equal error should be received by global all'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_req_error_cleared(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe module raises an error of type TestErrorA on the main implementation,
+        then clears this error,
+        TestErrorHandling should be subscribed to this error type.
+        Checks that the error_cleared is subscribed correctly.
+        """
+
+        err_object = error_handling_tester.probe_module_main_raise_error_a()
+        await asyncio.sleep(0.5)
+        error_handling_tester.probe_module_main_clear_error(err_object.type, err_object.sub_type)
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_TestErrorA=1,
+            len_test_error_handling_errors_all=1,
+            len_test_error_handling_errors_global_all=1,
+            len_test_error_handling_errors_cleared_TestErrorA=1,
+            len_test_error_handling_errors_cleared_all=1,
+            len_test_error_handling_errors_cleared_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_TestErrorA'][0]
+        cleared_error = error_handling_tester.test_error_handling['errors_cleared_TestErrorA'][0]
+        assert raised_error['type'] == cleared_error['type'], 'Raised error does not match cleared error'
+        assert raised_error == error_handling_tester.test_error_handling['errors_all'][0], 'Equal error should be received by all'
+        assert raised_error == error_handling_tester.test_error_handling['errors_global_all'][0], 'Equal error should be received by global all'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_req_not_sub_error(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe module raises an error of type TestErrorC on the main implementation,
+        TestErrorHandling shouldn't be subscribed to this error type.
+        Checks that the error is subscribed correctly.
+        """
+
+        err_object = error_handling_tester.probe_module_main_raise_error_c()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_all=1,
+            len_test_error_handling_errors_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_all'][0]
+        assert raised_error['type'] == err_object.type, 'Raised error type does not match expected error'
+        assert raised_error['message'] == err_object.message, 'Raised error message does not match expected error'
+        assert raised_error['severity'] == err_object.severity.name, 'Raised error severity does not match expected error'
+        assert raised_error == error_handling_tester.test_error_handling['errors_global_all'][0], 'Equal error should be received by global all'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_req_not_sub_error_cleared(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe module raises an error of type TestErrorC on the main implementation,
+        then clears this error,
+        TestErrorHandling shouldn't be subscribed to this error type.
+        Checks that the error_cleared is subscribed correctly.
+        """
+
+        err_object = error_handling_tester.probe_module_main_raise_error_c()
+        await asyncio.sleep(0.5)
+        error_handling_tester.probe_module_main_clear_error(err_object.type, err_object.sub_type)
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_all=1,
+            len_test_error_handling_errors_global_all=1,
+            len_test_error_handling_errors_cleared_all=1,
+            len_test_error_handling_errors_cleared_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_all'][0]
+        cleared_error = error_handling_tester.test_error_handling['errors_cleared_all'][0]
+        assert raised_error['type'] == cleared_error['type'], 'Raised error does not match cleared error'
+        assert raised_error == error_handling_tester.test_error_handling['errors_global_all'][0], 'Equal error should be received by global all'
+
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_not_req_error(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe modules triggers the test_error_handling_not_req module
+        to raise an error of type TestErrorA. This implementation is not required
+        by TestErrorHandling, so it shouldn't be subscribed to this error type.
+        Checks that the error is subscribed correctly.
+        """
+
+        err_arg = await error_handling_tester.test_error_handling_not_req_raise_error_a()
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_global_all'][0]
+        assert raised_error['type'] == err_arg['type'], 'Raised error type does not match expected error'
+        assert raised_error['message'] == err_arg['message'], 'Raised error message does not match expected error'
+        assert raised_error['severity'] == err_arg['severity'], 'Raised error severity does not match expected error'
+
+    @pytest.mark.everest_core_config('config-test-cpp-error-handling.yaml')
+    @pytest.mark.asyncio
+    async def test_receive_not_req_error_cleared(
+        self,
+        error_handling_tester: ErrorHandlingTester
+    ):
+        """
+        The probe modules triggers the test_error_handling_not_req module
+        to raise an error of type TestErrorA.
+        Then triggers the test_error_handling_not_req module to clear this error.
+        This implementation is not required
+        by TestErrorHandling, so it shouldn't be subscribed to this error type.
+        Checks that the error is subscribed correctly.
+        """
+
+        err_arg = await error_handling_tester.test_error_handling_not_req_raise_error_a()
+        await asyncio.sleep(0.5)
+        await error_handling_tester.test_error_handling_not_req_clear_error(err_arg['type'], err_arg['sub_type'])
+        await asyncio.sleep(0.5)
+        expected_state = ErrorHandlingTesterState(
+            len_test_error_handling_errors_global_all=1,
+            len_test_error_handling_errors_cleared_global_all=1
+        )
+        assert error_handling_tester.get_state() == expected_state, 'State does not match expected state'
+        raised_error = error_handling_tester.test_error_handling['errors_global_all'][0]
+        cleared_error = error_handling_tester.test_error_handling['errors_cleared_global_all'][0]
+        assert raised_error['type'] == cleared_error['type'], 'Raised error does not match cleared error'

tools/EVerest-main/tests/include/ModuleAdapterStub.hpp

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#ifndef MODULEADAPRERSTUB_H_
+#define MODULEADAPRERSTUB_H_
+
+#include <framework/ModuleAdapter.hpp>
+
+#include <optional>
+#include <utils/error/error_database_map.hpp>
+#include <utils/error/error_factory.hpp>
+#include <utils/error/error_manager_impl.hpp>
+#include <utils/error/error_manager_req.hpp>
+#include <utils/error/error_state_monitor.hpp>
+#include <utils/error/error_type_map.hpp>
+
+//-----------------------------------------------------------------------------
+namespace module::stub {
+
+struct ModuleAdapterStub : public Everest::ModuleAdapter {
+
+    ModuleAdapterStub() : Everest::ModuleAdapter() {
+        call = [this](const Requirement& req, const std::string& str, Parameters p) {
+            return this->call_fn(req, str, p);
+        };
+        publish = [this](const std::string& s1, const std::string& s2, Value v) { this->publish_fn(s1, s2, v); };
+        subscribe = [this](const Requirement& req, const std::string& str, ValueCallback cb) {
+            this->subscribe_fn(req, str, cb);
+        };
+        get_error_manager_impl = [this](const std::string& str) { return this->get_error_manager_impl_fn(str); };
+        get_error_state_monitor_impl = [this](const std::string& str) {
+            return this->get_error_state_monitor_impl_fn(str);
+        };
+        get_error_factory = [this](const std::string& str) { return this->get_error_factory_fn(str); };
+        get_error_manager_req = [this](const Requirement& req) { return this->get_error_manager_req_fn(req); };
+        get_error_state_monitor_req = [this](const Requirement& req) {
+            return this->get_error_state_monitor_req_fn(req);
+        };
+        get_global_error_manager = [this]() { return this->get_global_error_manager_fn(); };
+        get_global_error_state_monitor = [this]() { return this->get_global_error_state_monitor_fn(); };
+        ext_mqtt_publish = [this](const std::string& s1, const std::string& s2, bool retain) {
+            this->ext_mqtt_publish_fn(s1, s2);
+        };
+        ext_mqtt_subscribe = [this](const std::string& str, StringHandler sh) {
+            return this->ext_mqtt_subscribe_fn(str, sh);
+        };
+        ext_mqtt_subscribe_pair = [this](const std::string& topic, const StringPairHandler& handler) {
+            return this->ext_mqtt_subscribe_pair_fn(topic, handler);
+        };
+        telemetry_publish = [this](const std::string& s1, const std::string& s2, const std::string& s3,
+                                   const Everest::TelemetryMap& tm) { this->telemetry_publish_fn(s1, s2, s3, tm); };
+        get_mapping = [this]() { return this->get_mapping_fn(); };
+    }
+
+    virtual Result call_fn(const Requirement&, const std::string&, Parameters) {
+        std::printf("call_fn\n");
+        return std::nullopt;
+    }
+    virtual void publish_fn(const std::string&, const std::string&, Value) {
+        std::printf("publish_fn\n");
+    }
+    virtual void subscribe_fn(const Requirement&, const std::string& fn, ValueCallback) {
+        std::printf("subscribe_fn(%s)\n", fn.c_str());
+    }
+    virtual std::shared_ptr<Everest::error::ErrorManagerImpl> get_error_manager_impl_fn(const std::string&) {
+        std::printf("get_error_manager_impl_fn\n");
+        return std::make_shared<Everest::error::ErrorManagerImpl>(
+            std::make_shared<Everest::error::ErrorTypeMap>(), std::make_shared<Everest::error::ErrorDatabaseMap>(),
+            std::list<Everest::error::ErrorType>(),
+            [](const Everest::error::Error&) { std::printf("publish_raised_error\n"); },
+            [](const Everest::error::Error&) { std::printf("publish_cleared_error\n"); });
+    }
+    virtual std::shared_ptr<Everest::error::ErrorStateMonitor> get_error_state_monitor_impl_fn(const std::string&) {
+        std::printf("get_error_state_monitor_impl_fn\n");
+        return std::make_shared<Everest::error::ErrorStateMonitor>(
+            std::make_shared<Everest::error::ErrorDatabaseMap>());
+    }
+    virtual std::shared_ptr<Everest::error::ErrorManagerReqGlobal> get_global_error_manager_fn() {
+        std::printf("get_global_error_manager_fn\n");
+        return {};
+    }
+    virtual std::shared_ptr<Everest::error::ErrorStateMonitor> get_global_error_state_monitor_fn() {
+        std::printf("get_global_error_state_monitor_fn\n");
+        return {};
+    }
+    virtual std::shared_ptr<Everest::error::ErrorFactory> get_error_factory_fn(const std::string&) {
+        std::printf("get_error_factory_fn\n");
+        return std::make_shared<Everest::error::ErrorFactory>(std::make_shared<Everest::error::ErrorTypeMap>());
+    }
+    virtual std::shared_ptr<Everest::error::ErrorManagerReq> get_error_manager_req_fn(const Requirement&) {
+        std::printf("get_error_manager_req_fn\n");
+        return std::make_shared<Everest::error::ErrorManagerReq>(
+            std::make_shared<Everest::error::ErrorTypeMap>(), std::make_shared<Everest::error::ErrorDatabaseMap>(),
+            std::list<Everest::error::ErrorType>(),
+            [](const Everest::error::ErrorType&, const Everest::error::ErrorCallback&,
+               const Everest::error::ErrorCallback&) { std::printf("subscribe_error\n"); });
+    }
+    virtual std::shared_ptr<Everest::error::ErrorStateMonitor> get_error_state_monitor_req_fn(const Requirement&) {
+        std::printf("get_error_state_monitor_req_fn\n");
+        return std::make_shared<Everest::error::ErrorStateMonitor>(
+            Everest::error::ErrorStateMonitor(std::make_shared<Everest::error::ErrorDatabaseMap>()));
+    }
+    virtual void ext_mqtt_publish_fn(const std::string&, const std::string&) {
+        std::printf("ext_mqtt_publish_fn\n");
+    }
+    virtual std::function<void()> ext_mqtt_subscribe_fn(const std::string&, StringHandler) {
+        std::printf("ext_mqtt_subscribe_fn\n");
+        return nullptr;
+    }
+    virtual std::function<void()> ext_mqtt_subscribe_pair_fn(const std::string& topic,
+                                                             const StringPairHandler& handler) {
+        std::printf("ext_mqtt_subscribe_pair_fn\n");
+        return {};
+    }
+    virtual void telemetry_publish_fn(const std::string&, const std::string&, const std::string&,
+                                      const Everest::TelemetryMap&) {
+        std::printf("telemetry_publish_fn\n");
+    }
+    virtual std::optional<ModuleTierMappings> get_mapping_fn() {
+        std::printf("get_mapping_fn\n");
+        return {};
+    }
+};
+
+struct QuietModuleAdapterStub : public ModuleAdapterStub {
+    Result call_fn(const Requirement&, const std::string&, Parameters) override {
+        return {};
+    }
+    void publish_fn(const std::string&, const std::string&, Value) override {
+    }
+    void subscribe_fn(const Requirement&, const std::string& fn, ValueCallback) override {
+    }
+    std::shared_ptr<Everest::error::ErrorManagerImpl> get_error_manager_impl_fn(const std::string&) override {
+        return std::make_shared<Everest::error::ErrorManagerImpl>(
+            std::make_shared<Everest::error::ErrorTypeMap>(), std::make_shared<Everest::error::ErrorDatabaseMap>(),
+            std::list<Everest::error::ErrorType>(), [](const Everest::error::Error&) {},
+            [](const Everest::error::Error&) {});
+    }
+    std::shared_ptr<Everest::error::ErrorStateMonitor> get_error_state_monitor_impl_fn(const std::string&) override {
+        return std::make_shared<Everest::error::ErrorStateMonitor>(
+            std::make_shared<Everest::error::ErrorDatabaseMap>());
+    }
+    std::shared_ptr<Everest::error::ErrorManagerReqGlobal> get_global_error_manager_fn() override {
+        return {};
+    }
+    std::shared_ptr<Everest::error::ErrorStateMonitor> get_global_error_state_monitor_fn() override {
+        return {};
+    }
+    std::shared_ptr<Everest::error::ErrorFactory> get_error_factory_fn(const std::string&) override {
+        return std::make_shared<Everest::error::ErrorFactory>(std::make_shared<Everest::error::ErrorTypeMap>());
+    }
+    std::shared_ptr<Everest::error::ErrorManagerReq> get_error_manager_req_fn(const Requirement&) override {
+        return std::make_shared<Everest::error::ErrorManagerReq>(
+            std::make_shared<Everest::error::ErrorTypeMap>(), std::make_shared<Everest::error::ErrorDatabaseMap>(),
+            std::list<Everest::error::ErrorType>(),
+            [](const Everest::error::ErrorType&, const Everest::error::ErrorCallback&,
+               const Everest::error::ErrorCallback&) { std::printf("subscribe_error\n"); });
+    }
+    std::shared_ptr<Everest::error::ErrorStateMonitor> get_error_state_monitor_req_fn(const Requirement&) override {
+        return std::make_shared<Everest::error::ErrorStateMonitor>(
+            Everest::error::ErrorStateMonitor(std::make_shared<Everest::error::ErrorDatabaseMap>()));
+    }
+    void ext_mqtt_publish_fn(const std::string&, const std::string&) override {
+    }
+    std::function<void()> ext_mqtt_subscribe_fn(const std::string&, StringHandler) override {
+        return nullptr;
+    }
+    std::function<void()> ext_mqtt_subscribe_pair_fn(const std::string& topic,
+                                                     const StringPairHandler& handler) override {
+        return {};
+    }
+    void telemetry_publish_fn(const std::string&, const std::string&, const std::string&,
+                              const Everest::TelemetryMap&) override {
+    }
+    std::optional<ModuleTierMappings> get_mapping_fn() override {
+        return {};
+    }
+};
+
+} // namespace module::stub
+
+#endif

tools/EVerest-main/tests/include/everest/logging.hpp

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#pragma once
+
+#include <filesystem>
+#include <iostream>
+
+namespace {
+class UTestLogger {
+private:
+    std::ostream& m_stream;
+
+public:
+    UTestLogger() = delete;
+    UTestLogger(const char* file, int line) : UTestLogger(std::cerr, "Error: ", file, line) {
+    }
+    UTestLogger(std::ostream& stream, const char* level, const char* file, int line) : m_stream(stream) {
+        const auto f = std::filesystem::path((file == nullptr) ? "(unknown)" : file);
+        m_stream << level << f.filename().string() << ':' << line << ' ';
+    }
+    ~UTestLogger() {
+        m_stream << std::endl;
+    }
+    template <typename T> constexpr std::ostream& operator<<(const T& item) {
+        return m_stream << item;
+    }
+};
+
+#define EVLOG_critical UTestLogger(std::cerr, "Critical: ", __FILE__, __LINE__)
+#define EVLOG_error    UTestLogger(std::cerr, "Error:    ", __FILE__, __LINE__)
+#define EVLOG_warning  UTestLogger(std::cout, "Warning:  ", __FILE__, __LINE__)
+#define EVLOG_info     UTestLogger(std::cout, "Info:     ", __FILE__, __LINE__)
+#define EVLOG_debug    UTestLogger(std::cout, "Debug:    ", __FILE__, __LINE__)
+#define EVLOG_AND_THROW(ex)                                                                                            \
+    do {                                                                                                               \
+        try {                                                                                                          \
+            throw ex;                                                                                                  \
+        } catch (std::exception & e) {                                                                                 \
+            EVLOG_error << e.what();                                                                                   \
+            throw;                                                                                                     \
+        }                                                                                                              \
+    } while (0)
+} // namespace

tools/EVerest-main/tests/ocpp_tests/.gitignore

@@ -0,0 +1,10 @@
+build
+__pycache__
+*.egg-info
+.pytest_cache
+.venv
+results.xml
+result.xml
+report.html
+**/.DS_Store
+**/.idea

tools/EVerest-main/tests/ocpp_tests/README.md

@@ -0,0 +1,43 @@
+# OCPP Integration Tests
+
+This directory contains some test tooling and integration tests
+for OCPP1.6 and OCPP2.0.1.
+
+## Run the tests
+
+All tests are run via the unified `tests/run-tests.sh` script from the
+repository root. The script handles parallel execution, network-isolation
+setup/teardown and certificate/config installation automatically.
+
+```bash
+# From the repository root:
+tests/run-tests.sh ocpp          # all OCPP tests (1.6, 2.0.1, 2.1)
+tests/run-tests.sh ocpp16        # OCPP 1.6 only
+tests/run-tests.sh ocpp201       # OCPP 2.0.1 only
+tests/run-tests.sh ocpp21        # OCPP 2.1 only
+tests/run-tests.sh --serial ocpp # run serially
+tests/run-tests.sh -j4 ocpp     # limit to 4 parallel workers
+tests/run-tests.sh --help        # show all options
+```
+
+Tests run in parallel by default. The time depends on your system;
+it usually takes a couple of minutes.
+Check the generated `report.html` for detailed results.
+
+You can also run individual test sets or test cases using
+
+```bash
+python3 -m pytest test_sets/ocpp201/remote_control.py::test_F01_F02_F03
+```
+
+This runs test case `test_F01_F02_F03`
+specified in `test_sets/ocpp201/remote_control.py`.
+
+If you run the test cases individually,
+make sure to have all required certificates and configs
+for the test cases installed using the
+convenience scripts inside [test_sets/everest-aux](test_sets/everest-aux/)
+
+```bash
+./install_certs <path-to-EVerest-installation-directory>
+./install_configs <path-to-EVerest-installation-directory>

tools/EVerest-main/tests/ocpp_tests/conftest.py

@@ -0,0 +1,487 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Pionix GmbH and Contributors to EVerest
+
+# noinspection PyUnresolvedReferences
+from everest.testing.core_utils.fixtures import *
+from everest.testing.core_utils.probe_module import ProbeModule
+from everest.testing.ocpp_utils.charge_point_utils import OcppTestConfiguration
+
+# pylint: disable-next=unused-import
+from everest.testing.ocpp_utils.fixtures import (
+    ocpp_config,
+    ocpp_version,
+    charge_point,
+    charge_point_v201,
+    charge_point_v21,
+    central_system,
+    central_system_v16,
+    central_system_v201,
+    central_system_v21,
+    central_system_v16_standalone,
+    test_utility,
+)
+
+import test_sets.everest_test_utils as everest_test_utils
+
+from typing import Any, Callable
+
+import logging
+
+import pytest
+
+
+
+def pytest_addoption(parser):
+    # Guard against duplicate registration when tests/conftest.py is also loaded
+    # (e.g. when invoked via run-tests.sh with --config-file pointing to tests/pytest.ini).
+    try:
+        parser.addoption(
+            "--everest-prefix",
+            action="store",
+            default="../../build/dist",
+            help="everest prefix path; default = '../../build/dist'",
+        )
+    except ValueError:
+        logging.error("Option --everest-prefix already registered, skipping duplicate registration.")
+
+
+def pytest_sessionfinish(session, exitstatus):
+    pass
+
+
+@pytest.fixture(scope="session")
+def exi_generator():
+    certs_path = str(Path(__file__).parent / "test_sets" / "everest-aux" / "certs")
+    return everest_test_utils.EXIGenerator(certs_path)
+
+
+@pytest.fixture
+def test_config() -> OcppTestConfiguration:
+    return everest_test_utils.load_test_config()
+
+
+@pytest.fixture
+def core_config(request) -> EverestEnvironmentCoreConfiguration:
+    everest_prefix = Path(request.config.getoption("--everest-prefix"))
+
+    marker = request.node.get_closest_marker("everest_core_config")
+
+    if marker is None:
+        test_function_name = request.function.__name__
+        test_module_name = request.module.__name__
+        everest_config_path = everest_test_utils.get_everest_config(
+            test_function_name, test_module_name
+        )
+    else:
+        everest_config_path = (
+            Path(__file__).parent /
+            "test_sets/everest-aux/config" / marker.args[0]
+        )
+
+    return EverestEnvironmentCoreConfiguration(
+        everest_core_path=everest_prefix,
+        template_everest_config_path=everest_config_path,
+    )
+
+
+@pytest.fixture
+def started_test_controller(test_controller):
+    test_controller.start()
+    yield test_controller
+    test_controller.stop()
+
+
+@pytest.fixture
+def skip_implementation():
+    return None
+
+
+@pytest.fixture
+def overwrite_implementation():
+    return None
+
+
+def implement_command(
+    module: ProbeModule,
+    skip_implementation: dict,
+    implementation_id: str,
+    command_name: str,
+    handler: Callable[[dict], Any],
+):
+    skip = False
+    if skip_implementation:
+        if implementation_id in skip_implementation:
+            to_skip = skip_implementation[implementation_id]
+            if command_name in to_skip:
+                logging.info(f"Skipping implementation of {command_name}")
+                skip = True
+    if not skip:
+        module.implement_command(implementation_id, command_name, handler)
+
+
+@pytest.fixture
+def probe_module(
+    started_test_controller, everest_core, skip_implementation
+) -> ProbeModule:
+    # initiate the probe module, connecting to the same runtime session the test controller started
+    module = ProbeModule(everest_core.get_runtime_session())
+
+    logging.info(f"hello: {skip_implementation}")
+
+    # implement necessary commands for initialization in the module
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "get_evse",
+        lambda arg: {"id": 1, "connectors": [{"id": 1}]},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "enable_disable",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "authorize_response",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "update_allowed_energy_transfer_modes",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "withdraw_authorization",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "reserve",
+        lambda arg: False,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "cancel_reservation",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "pause_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "resume_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "stop_transaction",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "force_unlock",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleIso15118Extensions",
+        "set_get_certificate_response",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "external_ready_to_start_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorA",
+        "set_plug_and_charge_configuration",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "get_evse",
+        lambda arg: {"id": 2, "connectors": [{"id": 1}]},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "enable_disable",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "authorize_response",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "update_allowed_energy_transfer_modes",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "withdraw_authorization",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "reserve",
+        lambda arg: False,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "cancel_reservation",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "pause_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "resume_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "stop_transaction",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "force_unlock",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "external_ready_to_start_charging",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleConnectorB",
+        "set_plug_and_charge_configuration",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "get_boot_reason",
+        lambda arg: "PowerUp",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "update_firmware",
+        lambda arg: "Accepted",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "allow_firmware_installation",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "upload_logs",
+        lambda arg: "Accepted",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "is_reset_allowed",
+        lambda arg: True,
+    )
+    implement_command(
+        module, skip_implementation, "ProbeModuleSystem", "reset", lambda arg: None
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSystem",
+        "set_system_time",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_leaf_expiry_days_count",
+        lambda arg: 42,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_v2g_ocsp_request_data",
+        lambda arg: {"ocsp_request_data_list": []},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_mo_ocsp_request_data",
+        lambda arg: {"ocsp_request_data_list": []},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "install_ca_certificate",
+        lambda arg: "Accepted",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "delete_certificate",
+        lambda arg: "Accepted",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "update_leaf_certificate",
+        lambda arg: "Accepted",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "verify_certificate",
+        lambda arg: "Valid",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_installed_certificates",
+        lambda arg: {"status": "Accepted", "certificate_hash_data_chain": []},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "update_ocsp_cache",
+        lambda arg: None,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "is_ca_certificate_installed",
+        lambda arg: False,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "generate_certificate_signing_request",
+        lambda arg: {"status": "Accepted"},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_leaf_certificate_info",
+        lambda arg: {"status": "Accepted"},
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_verify_file",
+        lambda arg: "",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_verify_location",
+        lambda arg: "",
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "verify_file_signature",
+        lambda arg: True,
+    )
+    implement_command(
+        module,
+        skip_implementation,
+        "ProbeModuleSecurity",
+        "get_all_valid_certificates_info",
+        lambda arg: {"status": "NotFound", "info": []},
+    )
+
+    return module
+
+
+@pytest.fixture()
+def ocpp_config_reader(ocpp_config, ocpp_configuration):
+    """
+    Returns a reader over the final OCPP config (after all adaptations during test setup) for convenience.
+    """
+    return everest_test_utils.OCPPConfigReader(ocpp_configuration)

tools/EVerest-main/tests/ocpp_tests/pytest.ini

@@ -0,0 +1,18 @@
+[pytest]
+log_cli=true
+log_level=DEBUG
+asyncio_mode=strict
+asyncio_default_fixture_loop_scope=function
+markers=
+    ocpp_version: Ocpp version
+    everest_core_config: Override EVerest config file to use in the test
+    inject_csms_mock: Inject a unittest.mock into chargepoint methods
+    probe_module: Enable the use of the probe module in this test.
+    source_certs_dir: Specify a Path to a directory to copy the initial certificates from
+    use_temporary_persistent_store: Use a test-local temporary file for the persistent store database
+    csms_tls: Use a CSMS with TLS
+    ocpp_config_adaptions: Adaptions to the libocpp configuration
+    ocpp_config: Select a specific libocpp configuration file
+    everest_config_adaptions: Adaptions to the EVerest configuration
+python_files=test_sets/*.py
+pythonpath=test_sets

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/CSMS_SERVER.key

@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFLTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQIQp0AVHO1RxECAggA
+MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBAi8SQDuVzHGLigOLpx49A7BIIE
+0I5Z4VrRDtaRX1RiLyn8+XulrA9c3LbcLwLG54fMTLhpoT5D0gUYwlyLXogNQQeK
+ad9Y0xfKzHTlWSRxMDuO9AnZ8XGWi8AuezIbBXsmDdkYHxT4RLN/XB86wT2jS53H
+1pxzu+dmv1A650rQv2Mo8rOH4vyBiBFiGHNcrBL9JMVu7wRseWxY5riAf/1A/EH9
+eSwvYWNOTuNJBNEJWQo3g97brACMR3CKzvCCXNAyrtk6dBzn81JJCqHskFUAAVf8
+Rb1VrgIth4Oh58bAJvs7A1ZubdDbesMP4GG6uaeJxfgbIyWuIrEBHUNRy8MzDtmu
+QLSqJ09enIfEX0TuZaycMFsrWHkyTF4T7A8LmFGRaiBmRNgGHhR+5au+Qp+sFUwp
+6cOLAP5Mr/wwhlLFt3CTM3Fe++NGxpd7qp6g0VfhdGDy7dKtgVLwdnWMCm3PT8LS
+MsDlsHDl/Dxp33EPHcAHhP+KUFWHL5PZ5aw4J8o4IPNzOd91wyWcg8UCKO2ULQph
+dvfu2/7wphv6UVdvjdOmj6a9cqiPE/5gcgsaf7eAkYkhkydi4K5j6Z1LBCx/SJs6
+XMYSRfKOZ8jUSFrimF7wGbnEQj3jt2KRWh9mHI+6YjOT040Rk/Xl9sJ9JXqka++3
+QKdDpMAv7cWtAOYozI3B/MrES75BbmCACds8566rSeC5MSj6y+ed+CclNrV256iR
+az8NXaTI/Cd9rz13d7CRjHTXPhYI446b+KiKJ6xpzK+2vQdoYtZRcTSsLkQ43l1+
+cZ1LhzbeTgCy5flizfkv7pDSk84ff81pcJrCctUxHJWwtr5bvSmCam9Flq0LOcMy
+6BtXbL7RgTzCb/cdGuHoSSgjhA64qR7iBRlG3plzthbKh1KJpGScgxCkHf8BAEqf
+6fzX+X2dpnbzaA+NoQDzuvJGHosZ7lTNuZdAgm2VQWm96YeX0gk/+Pra8fZfc8FY
+N22dTHN5YAVh8Y46VaE00Rq+bgcoedZPMgyHrpNnHNojoOsOkoBXRN7OuuGlxuJW
+me09XbC1bxdz/OnLZQTLbUBXcVy+rsX0nCFGnBcmkSwsvztejoc1RvHhM6vfAVH7
+pPhyCcmXzM8bu5AtktQ+OI1OcxhAOgONgTbarKR4B0zNfXM0mFrZMbSvhikITvvY
+9YSc30LM6ntVDKq0u00v3WMbFsMQhA6npobj8TQRv5/3wtdhbckk7t+NJ4HJjGze
+fNWUGayiZfq3TN2bZ4aL373EzvX5F4cyEjJf6EoWOLdKF+sMn65mmvorloQwNjYZ
+v7ZKnmOlB+bEiYXs7kLviQacNxHBKlSuVsKhGrDT6nDOBmb8ZfhTzKdG742idYoZ
+nLwQdrIDq5Mm8EKR9mqhAORLhQ3fcXVM5/WPzNaZ60pExEjg7XNtdL/VS3h3UfWb
+wrrDIggc92yTpL1Py3R+ILCwxPzf9SfDjhHmVblsd1PUAOFgDtMY+5QYgJBd/4fe
+N76KCtpbamni6keggi1im9zvt+hHExR/N1hQDT9aT2WoGRsWvlvBtPaXGKwC55o/
+/2D9kFfTmiskLJZyG06N8JjPD/cWZ6/VQsEbufXwvQiBeemvZex51hBRHsIyOYVy
+3TobYslI9r1scv7rat2K4zNAMFtbuJdmCrd97i89R6UW
+-----END ENCRYPTED PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/CSMS_SERVER.pem

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC9DCCAdwCFCIpbxSzML1UlNW/bodFk/00Hfu+MA0GCSqGSIb3DQEBCwUAMDMx
+CzAJBgNVBAYTAkRFMQ8wDQYDVQQKDAZQaW9uaXgxEzARBgNVBAMMCkNTTVNSb290
+Q0EwIBcNMjQxMTA2MTAzMDA1WhgPMjEyNDEwMTMxMDMwMDVaMDgxCzAJBgNVBAYT
+AkRFMQ8wDQYDVQQKDAZQaW9uaXgxGDAWBgNVBAMMD3Bpb25peC5jc21zLmNvbTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOhTRohwKCuqYsXP0lhVNSNf
+G6AbB71SWwD4Sp3fNbMk5i67I0VpSYpf6pS/GoMgcjEiPP0KLirNaMsMedM/RU/a
+7jJhjDN3fQPsG+CO2ia6uFkQuntJXMyncQImfxL+ursJR5SB7Q2lh6bRyWxDcXff
+wdDL62ZBfjZtTg9ppdB/3BM2Mxd+/Hu1BpiWtn+k73PqWJt0GKa9E+Ue2l2Y0FTh
+Bw39LdVn1ZIDgrS5Xe6M/wpG9hMKPqnXYmTnXH1mBM5lukgRGzutP3WrfEdNXX2n
+W0tDFqW9Qx6BqgLsvYnWgPq3GMmrNDJ5++/FASyntCQhPSl9Lbjvq3EJQAQvhJkC
+AwEAATANBgkqhkiG9w0BAQsFAAOCAQEAM2tUtCQXSB21LwflnvhDRNrrM5UoCu1B
+5qHr1XJaYrH14fgdj24iORLVzecNdU0HS4F7yYP6M67reURntY0Ctaw6u0QbV1wU
+5ruaWkSBIYsEc7Tujm8QqVSz4cwvdmzkTTgVFfPRkOpvZ1PgPbq8Q9GyitUEJXuJ
+sqB+Q2/JFPwh+6y1TckPq70/gWu0z4CSap9VQU3ed3Fr+RMf9lNh4+q88Mt2tdIV
+cvlpQrlneKGbo8mBv9gZ9dOFFjYMWAZWSx8lsJeV6uFlq+7VSGRVmNTva3XAuTcs
+WOvMQ5AiSxGVasGIUmbm2mybTMO7eypXXCvKBWidtsBlNnGNqfpNwA==
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/cps/CPS_SUB_CA1.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB6DCCAY+gAwIBAgICMEUwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJVjJHUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSTETMBEG
+A1UEAwwKUHJvdlN1YkNBMTEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUx
+EzARBgoJkiaJk/IsZAEZFgNDUFMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATv
+5jV2NbYx1OebIXgjbp+fImlGtDoDaH9plx/+DkjpI5MTb1/SngF5eW7ik0Bk82K2
++IZ/+IP4vP47GBk67ovAo2YwZDASBgNVHRMBAf8ECDAGAQH/AgEBMA4GA1UdDwEB
+/wQEAwIBBjAdBgNVHQ4EFgQUQJMEvROBa1y6eidJyuk0pnGeNEUwHwYDVR0jBBgw
+FoAUZ8ap4nueZjMRXRWNB7elswXz4z4wCgYIKoZIzj0EAwIDRwAwRAIgTBwzZ2ke
+NLzUKTaXRItUjIathvG+UGSnMEUYTR0M3XgCIES1rMZ7vw0lDCDZfcs21O6YL+c1
+u319fD6e/O/PWYga
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/cps/CPS_SUB_CA2.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB6TCCAZCgAwIBAgICMEYwCgYIKoZIzj0EAwIwSTETMBEGA1UEAwwKUHJvdlN1
+YkNBMTEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEzARBgoJkiaJk/Is
+ZAEZFgNDUFMwIBcNMjMwOTI2MDczODM0WhgPMjIyMzA4MDkwNzM4MzRaMEkxEzAR
+BgNVBAMMClByb3ZTdWJDQTIxEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRF
+MRMwEQYKCZImiZPyLGQBGRYDQ1BTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
+MUw55nn9M8smH52TtU8LkM6n8szWVIRAJmz88z1dY5UPrA4Zvd0ad+YdVJRnGUoK
+QRLGsqBg0PzPcySqpc/uuKNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFD2NLMFiCvyvVwx6mXCv304tovlQMB8GA1UdIwQY
+MBaAFECTBL0TgWtcunonScrpNKZxnjRFMAoGCCqGSM49BAMCA0cAMEQCID2D0Jkb
+I+nwsJdMGv0Al0QxnHyRVYfWUmBHiaLpAHiqAiARcpQm91Q8Q7oZQ/S3OFeCnai3
+67cHM5XXmueZ/ZLSXw==
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/cps/INTERMEDIATE_CPS_CA_CERTS.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIB6TCCAZCgAwIBAgICMEYwCgYIKoZIzj0EAwIwSTETMBEGA1UEAwwKUHJvdlN1
+YkNBMTEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEzARBgoJkiaJk/Is
+ZAEZFgNDUFMwIBcNMjMwOTI2MDczODM0WhgPMjIyMzA4MDkwNzM4MzRaMEkxEzAR
+BgNVBAMMClByb3ZTdWJDQTIxEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRF
+MRMwEQYKCZImiZPyLGQBGRYDQ1BTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
+MUw55nn9M8smH52TtU8LkM6n8szWVIRAJmz88z1dY5UPrA4Zvd0ad+YdVJRnGUoK
+QRLGsqBg0PzPcySqpc/uuKNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFD2NLMFiCvyvVwx6mXCv304tovlQMB8GA1UdIwQY
+MBaAFECTBL0TgWtcunonScrpNKZxnjRFMAoGCCqGSM49BAMCA0cAMEQCID2D0Jkb
+I+nwsJdMGv0Al0QxnHyRVYfWUmBHiaLpAHiqAiARcpQm91Q8Q7oZQ/S3OFeCnai3
+67cHM5XXmueZ/ZLSXw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB6DCCAY+gAwIBAgICMEUwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJVjJHUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSTETMBEG
+A1UEAwwKUHJvdlN1YkNBMTEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUx
+EzARBgoJkiaJk/IsZAEZFgNDUFMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATv
+5jV2NbYx1OebIXgjbp+fImlGtDoDaH9plx/+DkjpI5MTb1/SngF5eW7ik0Bk82K2
++IZ/+IP4vP47GBk67ovAo2YwZDASBgNVHRMBAf8ECDAGAQH/AgEBMA4GA1UdDwEB
+/wQEAwIBBjAdBgNVHQ4EFgQUQJMEvROBa1y6eidJyuk0pnGeNEUwHwYDVR0jBBgw
+FoAUZ8ap4nueZjMRXRWNB7elswXz4z4wCgYIKoZIzj0EAwIDRwAwRAIgTBwzZ2ke
+NLzUKTaXRItUjIathvG+UGSnMEUYTR0M3XgCIES1rMZ7vw0lDCDZfcs21O6YL+c1
+u319fD6e/O/PWYga
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/csms/CSMS_ROOT_CA.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDCAs2pQSpksFxt
+Xcvt/Fnu+nQ/VxfkhdrPB1plrCOGdy+2HtbZ6hwHeKfdGmcCRt1eAlJPUrgLWiT3
+LIVMjrJ9qTtZOpfhCt0YOSD97ZP7vTVLE7bW/lSsRmuqMsvymxttAk3TIdGQpBQ0
+BZZENhDYCSbbCAcWq948dtXKyNzX0BZdCSDkd1b0AbnY7LE0x0atQZFm9jHr9irb
+AgK6QZdYp9HMERewWxgta7jtDCusHDCit5Yt9ahtBfB5pS/pmk5gnRAlYpOEGhlb
+CdD5dTKQOLKbHmW94c6p0G7BTOl1EtN2CTW06KZxxZaipVQzqz2WGwGjYmcdnhVQ
+MDU0hy+pAgMBAAECggEAR/BcLC9ytcVDcHZAQO26t0d9RWNZA66ylOPIHD05KwoU
+0fYbetA5NngB3pWErq5yNQKtXKZyghsZ6+FBSEL9YmUXEZ4NZS/vDaVZW2712Xmu
+Qjl8KbpC0WKHV6PgRgRHpiMdknVOzNBagXO05XQayNCT7NHMNxbhoA/8dGYIpajo
+qyaJpNx3zin3k87RigBtbLf4w6BWyv6pmzxby4aeiesJtwzx4jf8h6KdwlHpNbrF
+unIDlpooRtdx0ALPefyJvnJ/95D4tndGOdgiRnuz9I9VvjsVOfKkzAmWOgC/M0IS
+7Z/bE+2URuzu/ry6Urp0U5b+JLstcbRsirdL7qnlxQKBgQDS5lSKGOD8nJYAJiuh
+q4kxdmqOGzwgb7u2M5NgkMyi8SUJJZXG7ALoCdQe1OHfAIhwsE6slJYHWpzaTXAN
+p2MAbKt5VK6yvq1mUE1A47pi3ihGNctpd3xAw4haP9cDtw1Iqu2yJYo10Vn7QKl2
+cIetJMcUMptAbgT0hL03ZoByNwKBgQDrf+Zgogmy+6giGRUiHENTF7TFQGau1hVN
+9jMHVkGDisZC7IInMihwBkXkT5n7LcNkiU8yg0Oj4niAln6bbdxJ8y7CRQEy2g0n
+gAZALzPWjQAk9IBCE5m5W58v/qHd0ftSWjtqZ+OYLbUbect6/v+hXFb0J2l3Ln+p
+27SoLi/9HwKBgFJfLfPGJdHkYt3qCq6ZbftIsfORBZnxqhJO8KgNxi96GioJaQeJ
+1NTGSfhE03ejIKdK5V+YpUR4Cr1k83gRwaQ/zXWVMqqTuOw2PwYyK/FDrd1GU418
+4qX0+QOu3Y8Q5vpT8ITdDq9Ydlmg9s9Qwl1I+QyVe3fdwMe0NKc3vMFfAoGAXzXW
+bjsUsMgNsbtyT9gdX/q1mwnuecET2/EtsEmvMv9oKKZ1+GLO9nuSxjtohaR62qqo
+2kM3lYp6LYKqrSw9Y6htvx0m3uhJaS7ZWBm9W4CmDkrLj+tcuxPPyBeqWYQLl7/j
+RaG64kuYbQNQwOlXcGVkwlEs0oJ6GrI418XUoQECgYEAtUwMgJr5xeqvDqNJ065H
+SdRSOewUaUPxOtYITqihj0YR22BSWs3X4PPXGDJ2yyRCuvs0gHpPX/F7cmEjF+N5
+QHb/AlePECiCSb8rcMF4phEXZOE+1poVcPvn5dckNeg2YrSo6WMOS7e7NP6hZcrt
++/FBHitjRK8olut1Y/bz+x4=
+-----END PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/csms/CSMS_ROOT_CA.pem

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC7zCCAdcCFFnSdVg5iSwTLqqaSa1scWOM6AErMA0GCSqGSIb3DQEBCwUAMDMx
+CzAJBgNVBAYTAkRFMQ8wDQYDVQQKDAZQaW9uaXgxEzARBgNVBAMMCkNTTVNSb290
+Q0EwIBcNMjQwOTIwMTMyNTUzWhgPMjA1MjAzMDExMzI1NTNaMDMxCzAJBgNVBAYT
+AkRFMQ8wDQYDVQQKDAZQaW9uaXgxEzARBgNVBAMMCkNTTVNSb290Q0EwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCAs2pQSpksFxtXcvt/Fnu+nQ/Vxfk
+hdrPB1plrCOGdy+2HtbZ6hwHeKfdGmcCRt1eAlJPUrgLWiT3LIVMjrJ9qTtZOpfh
+Ct0YOSD97ZP7vTVLE7bW/lSsRmuqMsvymxttAk3TIdGQpBQ0BZZENhDYCSbbCAcW
+q948dtXKyNzX0BZdCSDkd1b0AbnY7LE0x0atQZFm9jHr9irbAgK6QZdYp9HMERew
+Wxgta7jtDCusHDCit5Yt9ahtBfB5pS/pmk5gnRAlYpOEGhlbCdD5dTKQOLKbHmW9
+4c6p0G7BTOl1EtN2CTW06KZxxZaipVQzqz2WGwGjYmcdnhVQMDU0hy+pAgMBAAEw
+DQYJKoZIhvcNAQELBQADggEBAI085Iyhy9dLD4Dz5HEyY1sCrWZRcbwScCMOyjkI
+yMQbWl3HNrwNvd57L18E/Co61qz8m+ZsvFh7VZMnw/tVxOAyzEyTK+iwsj2XLcs0
+P93LeqNXemmO3OcyOjrjGToOCGTqIJVSrPzPsrTxSLPQyUt0llvfPGF2p9fid9eK
+wBc2mE34lfdMl1dfWCDiMk8gngOo5cPOvnGob9Mc2m4U517iGyYbQAe/Ew6r6Mrg
+GCh1uUaBIkW9Diiq+1Dox5Hp4jWPoSJ4laoTXk27zRxDmAaVCqCM/CtuZdNws6qA
+Pa0mUpan/kSQO+RLbScnbFOE4gfBQJaCgxyeuFMJqRqoVhg=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/cso/CPO_SUB_CA1.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICWTCCAf+gAwIBAgICMDowCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJVjJHUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJQ1BPU3ViQ0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA1YyRzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMqy
+mpvtNjA3+U5TdcucSgdWpXFj8XXwAlb6luBEYCytUD7AREB9P+ksVgcN6GiiZGn8
+0Pdnu+NCuyDLwlUvX6ejgdYwgdMwEgYDVR0TAQH/BAgwBgEB/wIBATAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFCcnBk2/j/EjG9W6yXgudPVyOgWwMG0GCCsGAQUF
+BwEBBGEwXzAkBggrBgEFBQcwAYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcG
+CCsGAQUFBzAChitodHRwczovL3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUt
+Q0EuY2VyMB8GA1UdIwQYMBaAFGfGqeJ7nmYzEV0VjQe3pbMF8+M+MAoGCCqGSM49
+BAMCA0gAMEUCICZt4DhW92hiDyUr8oqOUHocKfLRMf5I0vTvajqTbQiVAiEA6as1
+yudx0oHSYf7e7IZBQ6KP1gjC6wcRvfvlBQNbySQ=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/cso/CPO_SUB_CA2.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICWTCCAf+gAwIBAgICMDswCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJQ1BPU3Vi
+Q0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yMTIzMDkwMjA3MzgzNFowSDESMBAG
+A1UEAwwJQ1BPU3ViQ0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA1YyRzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEat
+pC4ruZ4wc/Hb5JA68ICxU7TQNvLDTJ+Qjc9QetO91h8gAoVRAHKvg8Hoe+lqfu5d
++Q6Ax05xUuFwTzyc3eejgdYwgdMwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFDYZY4lJbs1mKm1gGVf3Jw9cDOWPMG0GCCsGAQUF
+BwEBBGEwXzAkBggrBgEFBQcwAYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcG
+CCsGAQUFBzAChitodHRwczovL3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUt
+Q0EuY2VyMB8GA1UdIwQYMBaAFCcnBk2/j/EjG9W6yXgudPVyOgWwMAoGCCqGSM49
+BAMCA0gAMEUCIQDsQM6q7ecToESugkNzZS3R6il0TKNXeeVgwC84kgb0RAIgfjZh
+VXfKo/V7VIHRG9zgM5mO8XdLp+ip25FZbc+V5wU=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/mf/MF_ROOT_CA.pem

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIUefSpxKT9V9AskQWsKw26gKbfryIwDQYJKoZIhvcNAQEL
+BQAwZzELMAkGA1UEBhMCREUxCzAJBgNVBAgMAkJXMRMwEQYDVQQHDApIZWlkZWxi
+ZXJnMQ8wDQYDVQQKDAZQaW9uaXgxFDASBgNVBAsMC0RldmVsb3BtZW50MQ8wDQYD
+VQQDDAZQaW9uaXgwHhcNMjIwNTI1MDgxMjE1WhcNMzIwNTIyMDgxMjE1WjBnMQsw
+CQYDVQQGEwJERTELMAkGA1UECAwCQlcxEzARBgNVBAcMCkhlaWRlbGJlcmcxDzAN
+BgNVBAoMBlBpb25peDEUMBIGA1UECwwLRGV2ZWxvcG1lbnQxDzANBgNVBAMMBlBp
+b25peDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALovuIM86s4FrYts
+Ordg6SO9PhTr4Cd9xyux53XttAlCP2GmPC3XWSWUFHj8Mn9UB+8UInvfpIieHCbP
+wG/wJGycvIDy2IiteS/bei9H3W25BpDTW7aaIsXauwlGfHJR70GoFXjl3NqrFdeH
+IKSPX7haMHDvnTL3YK5d7LdIFPEB8m8rGtYEg7sVN+cqqQDbHNGuDmGto86OIEXh
++mXvDBuoDi3jxCCFaro9FGnE1LddI/FiZvHHPpGvfFFBqQtgXhIc0qdkH6xJL4oY
+zvzVlc83wPsTZqmQOiG/+3VCWISLkQRZ94X7SU3KEQ7vTxU7um0O/6NmTOLwEgHY
+pNqHNy8CAwEAAaNTMFEwHQYDVR0OBBYEFIsoJXpl8ZCHAGmvi7A2l7ncKjpYMB8G
+A1UdIwQYMBaAFIsoJXpl8ZCHAGmvi7A2l7ncKjpYMA8GA1UdEwEB/wQFMAMBAf8w
+DQYJKoZIhvcNAQELBQADggEBAHxzfbjod5nzxv0s7PjZ2t5S/RhmW43C6fkveB3o
+earwORJaEHY0I8tBizfha39JaF/b1JyGBi4anqluXNRM/1dRXIDxsrIX/z3Un/0f
+18wHWZAL5FpG8PqseNFR6zaLYcLIouqRPTLX+rtbQ+l1N+0lAemR4TC7zV+2iyAj
+fppq49jwQXZhi7iBotoV4uZJ0ZnWXpFPp67dyRoyAJUKOGVWuKCuQqsWULlkx4i8
+bIW8QQ9uCY/YDUldkONT+LE+uD8inmekaOsxtCkcIv4jKHP3Znxe4iooVqCI/vpn
+AL+JtFpWF+lBqjIg7LYKhb4EL41CcF2jp2nsNTEGz4mHZZA=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/mo/INTERMEDIATE_MO_CA_CERTS.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIICdzCCAh2gAwIBAgICMEMwCgYIKoZIzj0EAwIwVzEiMCAGA1UEAwwZUEtJLUV4
+dF9DUlRfTU9fU1VCMV9WQUxJRDEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMC
+REUxEjAQBgoJkiaJk/IsZAEZFgJNTzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYy
+MTA3MzgzNFowVzEiMCAGA1UEAwwZUEtJLUV4dF9DUlRfTU9fU1VCMl9WQUxJRDEQ
+MA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEjAQBgoJkiaJk/IsZAEZFgJN
+TzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCy609nf5hPrm5RTmxDGx/NIZBUT
+mMjTmzJdeFeNv/KR8vhA7ttt4U71fdkXnV7v9wqhUKzdZ1/aY/UPxdmTYNWjgdYw
+gdMwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0OBBYE
+FA1kQYEMG643y6vTSx9WZwZU5LKZMG0GCCsGAQUFBwEBBGEwXzAkBggrBgEFBQcw
+AYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcGCCsGAQUFBzAChitodHRwczov
+L3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUtQ0EuY2VyMB8GA1UdIwQYMBaA
+FCERWVHh0/KaD6/4zx8a/IFC+bleMAoGCCqGSM49BAMCA0gAMEUCIHyiGWfR0Blg
+fBmNz1vgcce+DWlZXhtucfkZnu0iFSKnAiEA24l7RzuuPhEWQVcZiCz4JNYlRQCi
+DJMbo6rhh2OkFg4=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICZjCCAgygAwIBAgICMEIwCgYIKoZIzj0EAwIwRjERMA8GA1UEAwwITU9Sb290
+Q0ExEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRFMRIwEAYKCZImiZPyLGQB
+GRYCTU8wIBcNMjMwOTI2MDczODM0WhgPMjQyMzA2MjEwNzM4MzRaMFcxIjAgBgNV
+BAMMGVBLSS1FeHRfQ1JUX01PX1NVQjFfVkFMSUQxEDAOBgNVBAoMB0VWZXJlc3Qx
+CzAJBgNVBAYTAkRFMRIwEAYKCZImiZPyLGQBGRYCTU8wWTATBgcqhkjOPQIBBggq
+hkjOPQMBBwNCAATCeOBV70uDeFPTzSn/0q/vtTIIUoyi17jtJcBJIJ6HKQ5erQWX
+LNHNeWAb67AzhveWaNEidGTCEy8FEfpKQMTJo4HWMIHTMBIGA1UdEwEB/wQIMAYB
+Af8CAQEwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQhEVlR4dPymg+v+M8fGvyB
+Qvm5XjBtBggrBgEFBQcBAQRhMF8wJAYIKwYBBQUHMAGGGGh0dHBzOi8vd3d3LmV4
+YW1wbGUuY29tLzA3BggrBgEFBQcwAoYraHR0cHM6Ly93d3cuZXhhbXBsZS5jb20v
+SW50ZXJtZWRpYXRlLUNBLmNlcjAfBgNVHSMEGDAWgBTzye4wMVvPhaamN7ESwws6
+ssEXDjAKBggqhkjOPQQDAgNIADBFAiB+nBAlxposIDJxiloT2ELP5+o0MiUTxshl
+t3OtZTc7WAIhANJEMAyviGwEpO+EcBFjMKkMUYujjpLQFufl4lnmYIn0
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/mo/MO_ROOT_CA.pem

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICMTCCAdegAwIBAgICMEEwCgYIKoZIzj0EAwIwRjERMA8GA1UEAwwITU9Sb290
+Q0ExEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRFMRIwEAYKCZImiZPyLGQB
+GRYCTU8wIBcNMjMwOTI2MDczODM0WhgPMzAyMzAxMjcwNzM4MzRaMEYxETAPBgNV
+BAMMCE1PUm9vdENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTESMBAG
+CgmSJomT8ixkARkWAk1PMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOPhLNwtB
+1KK0b2zA/+s3UTSeonYiynypWR77zac0/wRBicfWI6BbN5ASCs7AeStsfMclRyzN
+/BMTZicBr3hzn6OBsjCBrzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQU88nuMDFbz4WmpjexEsMLOrLBFw4wbQYIKwYBBQUHAQEEYTBf
+MCQGCCsGAQUFBzABhhhodHRwczovL3d3dy5leGFtcGxlLmNvbS8wNwYIKwYBBQUH
+MAKGK2h0dHBzOi8vd3d3LmV4YW1wbGUuY29tL0ludGVybWVkaWF0ZS1DQS5jZXIw
+CgYIKoZIzj0EAwIDSAAwRQIhANeKAfZicdBRO4KfW7+E6aPCkyYWPIJzTKqXVvOZ
+gVREAiABTYfSqnxXUMkdRWb5ku7gZLdsvFJStRKt1UuQTeOnUQ==
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/mo/MO_SUB_CA1.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICZjCCAgygAwIBAgICMEIwCgYIKoZIzj0EAwIwRjERMA8GA1UEAwwITU9Sb290
+Q0ExEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRFMRIwEAYKCZImiZPyLGQB
+GRYCTU8wIBcNMjMwOTI2MDczODM0WhgPMjQyMzA2MjEwNzM4MzRaMFcxIjAgBgNV
+BAMMGVBLSS1FeHRfQ1JUX01PX1NVQjFfVkFMSUQxEDAOBgNVBAoMB0VWZXJlc3Qx
+CzAJBgNVBAYTAkRFMRIwEAYKCZImiZPyLGQBGRYCTU8wWTATBgcqhkjOPQIBBggq
+hkjOPQMBBwNCAATCeOBV70uDeFPTzSn/0q/vtTIIUoyi17jtJcBJIJ6HKQ5erQWX
+LNHNeWAb67AzhveWaNEidGTCEy8FEfpKQMTJo4HWMIHTMBIGA1UdEwEB/wQIMAYB
+Af8CAQEwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQhEVlR4dPymg+v+M8fGvyB
+Qvm5XjBtBggrBgEFBQcBAQRhMF8wJAYIKwYBBQUHMAGGGGh0dHBzOi8vd3d3LmV4
+YW1wbGUuY29tLzA3BggrBgEFBQcwAoYraHR0cHM6Ly93d3cuZXhhbXBsZS5jb20v
+SW50ZXJtZWRpYXRlLUNBLmNlcjAfBgNVHSMEGDAWgBTzye4wMVvPhaamN7ESwws6
+ssEXDjAKBggqhkjOPQQDAgNIADBFAiB+nBAlxposIDJxiloT2ELP5+o0MiUTxshl
+t3OtZTc7WAIhANJEMAyviGwEpO+EcBFjMKkMUYujjpLQFufl4lnmYIn0
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/mo/MO_SUB_CA2.pem

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICdzCCAh2gAwIBAgICMEMwCgYIKoZIzj0EAwIwVzEiMCAGA1UEAwwZUEtJLUV4
+dF9DUlRfTU9fU1VCMV9WQUxJRDEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMC
+REUxEjAQBgoJkiaJk/IsZAEZFgJNTzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYy
+MTA3MzgzNFowVzEiMCAGA1UEAwwZUEtJLUV4dF9DUlRfTU9fU1VCMl9WQUxJRDEQ
+MA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEjAQBgoJkiaJk/IsZAEZFgJN
+TzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCy609nf5hPrm5RTmxDGx/NIZBUT
+mMjTmzJdeFeNv/KR8vhA7ttt4U71fdkXnV7v9wqhUKzdZ1/aY/UPxdmTYNWjgdYw
+gdMwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0OBBYE
+FA1kQYEMG643y6vTSx9WZwZU5LKZMG0GCCsGAQUFBwEBBGEwXzAkBggrBgEFBQcw
+AYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcGCCsGAQUFBzAChitodHRwczov
+L3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUtQ0EuY2VyMB8GA1UdIwQYMBaA
+FCERWVHh0/KaD6/4zx8a/IFC+bleMAoGCCqGSM49BAMCA0gAMEUCIHyiGWfR0Blg
+fBmNz1vgcce+DWlZXhtucfkZnu0iFSKnAiEA24l7RzuuPhEWQVcZiCz4JNYlRQCi
+DJMbo6rhh2OkFg4=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/oem/INTERMEDIATE_OEM_CA.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIB6DCCAY6gAwIBAgICMD8wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNU3Vi
+Q0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE+5
+Jw399yjF4tspXmzAomIEET7u6OZ4794J3rmtQBzrwdWi6PXNK1XlwQBw9tgkF1/G
+7ASHMNMk02nUQVRoIv2jZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBQ4i1PCQGVLiFD8YkvM3DP3yrGWTTAfBgNVHSMEGDAW
+gBRzjJliU3xcjw98B5VT04G6ZyGxDzAKBggqhkjOPQQDAgNIADBFAiEA+UA/zGcv
+HttMd1GtcU4IGW78jmP6SlLizNytu3Yg++cCIC0CGpCPsUKPbHBzyCvMwp0DebYL
++atLjhDjPqVGQvYJ
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB5zCCAY6gAwIBAgICMD4wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGx6
+mv9UeTG4ywVfu1GJ6prtuX7WNbFP377RChPD4sL4TWHldLMKOJu0b0bc2KGWyBu3
+tmq+CbiHJTkEZ+ekEDOjZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBRzjJliU3xcjw98B5VT04G6ZyGxDzAfBgNVHSMEGDAW
+gBTpHbunA9uW7U/2N8XBh9uc22LiwTAKBggqhkjOPQQDAgNHADBEAiB6OibJal2K
+JE1xAU7Wp7K/iDb6XxCkI+EmPd4mE1JG4wIgFbI0VgPlDNioRWfExCqgzMWNeEj+
+xXt2PfIIpifz3Sk=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/oem/OEM_CERT_CHAIN.pem

@@ -0,0 +1,39 @@
+-----BEGIN CERTIFICATE-----
+MIIB5DCCAYqgAwIBAgICMEAwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNU3Vi
+Q0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSjEUMBIG
+A1UEAwwLT0VNUHJvdkNlcnQxEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRF
+MRMwEQYKCZImiZPyLGQBGRYDT0VNMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
+1Qza34iaHRAxMwvGUOTnBvlFicTCFl1cddIvnsd1qbaEyIIRotrOkXhfIQDv4kmi
+ue85Cpa2vdn+m1p48W7icaNgMF4wDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMC
+A4gwHQYDVR0OBBYEFK5Xv8jMo4+1pvU2GWsZU7BG/kQEMB8GA1UdIwQYMBaAFDiL
+U8JAZUuIUPxiS8zcM/fKsZZNMAoGCCqGSM49BAMCA0gAMEUCIQDxjoscE/RMTLZh
+9u/ElkpavrVQpkhVmhYOEbQWr/4ijQIgQaHykyPuRZMen3ZCVXqioqsDj6Dq5WAw
+Nsf1XdB+Nz8=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB6DCCAY6gAwIBAgICMD8wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNU3Vi
+Q0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE+5
+Jw399yjF4tspXmzAomIEET7u6OZ4794J3rmtQBzrwdWi6PXNK1XlwQBw9tgkF1/G
+7ASHMNMk02nUQVRoIv2jZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBQ4i1PCQGVLiFD8YkvM3DP3yrGWTTAfBgNVHSMEGDAW
+gBRzjJliU3xcjw98B5VT04G6ZyGxDzAKBggqhkjOPQQDAgNIADBFAiEA+UA/zGcv
+HttMd1GtcU4IGW78jmP6SlLizNytu3Yg++cCIC0CGpCPsUKPbHBzyCvMwp0DebYL
++atLjhDjPqVGQvYJ
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB5zCCAY6gAwIBAgICMD4wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGx6
+mv9UeTG4ywVfu1GJ6prtuX7WNbFP377RChPD4sL4TWHldLMKOJu0b0bc2KGWyBu3
+tmq+CbiHJTkEZ+ekEDOjZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBRzjJliU3xcjw98B5VT04G6ZyGxDzAfBgNVHSMEGDAW
+gBTpHbunA9uW7U/2N8XBh9uc22LiwTAKBggqhkjOPQQDAgNHADBEAiB6OibJal2K
+JE1xAU7Wp7K/iDb6XxCkI+EmPd4mE1JG4wIgFbI0VgPlDNioRWfExCqgzMWNeEj+
+xXt2PfIIpifz3Sk=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/oem/OEM_ROOT_CA.pem

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBxTCCAWqgAwIBAgICMD0wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8zMDIzMDEyNzA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNUm9vdENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABIX6
+D9hpCtQJnHR0+E3EmCsn03Bnx9HxnmFxz8S1i5M6Bp3Poap8Gi12WW06sHAp1UFV
+hVzew+MZryodYsO58+6jQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBTpHbunA9uW7U/2N8XBh9uc22LiwTAKBggqhkjOPQQDAgNJ
+ADBGAiEA8bIzMNN3MhUXQvoBTli9wDBJLbr/ZFDFoIhFczKcgdUCIQCaUomBA4Gb
+VIGVs3tKXn5XDG1YO2bqNlbycy5Ktb+xVA==
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/oem/OEM_SUB_CA1.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB5zCCAY6gAwIBAgICMD4wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGx6
+mv9UeTG4ywVfu1GJ6prtuX7WNbFP377RChPD4sL4TWHldLMKOJu0b0bc2KGWyBu3
+tmq+CbiHJTkEZ+ekEDOjZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBRzjJliU3xcjw98B5VT04G6ZyGxDzAfBgNVHSMEGDAW
+gBTpHbunA9uW7U/2N8XBh9uc22LiwTAKBggqhkjOPQQDAgNHADBEAiB6OibJal2K
+JE1xAU7Wp7K/iDb6XxCkI+EmPd4mE1JG4wIgFbI0VgPlDNioRWfExCqgzMWNeEj+
+xXt2PfIIpifz3Sk=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/oem/OEM_SUB_CA2.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB6DCCAY6gAwIBAgICMD8wCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNU3Vi
+Q0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJT0VNU3ViQ0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA09FTTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE+5
+Jw399yjF4tspXmzAomIEET7u6OZ4794J3rmtQBzrwdWi6PXNK1XlwQBw9tgkF1/G
+7ASHMNMk02nUQVRoIv2jZjBkMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdDgQWBBQ4i1PCQGVLiFD8YkvM3DP3yrGWTTAfBgNVHSMEGDAW
+gBRzjJliU3xcjw98B5VT04G6ZyGxDzAKBggqhkjOPQQDAgNIADBFAiEA+UA/zGcv
+HttMd1GtcU4IGW78jmP6SlLizNytu3Yg++cCIC0CGpCPsUKPbHBzyCvMwp0DebYL
++atLjhDjPqVGQvYJ
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/ca/v2g/V2G_ROOT_CA.pem

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBxTCCAWqgAwIBAgICMDkwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJVjJHUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8zMDIzMDEyNzA3MzgzNFowSDESMBAG
+A1UEAwwJVjJHUm9vdENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA1YyRzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJjZ
+qKsQaffrsSSRTQE57gcpjuxtkKluOMbQWHmpBHgK7coPhm/xlmfDn/rRmQ0fvEqi
+zx/oDCt8yAObxSTyj3CjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBRnxqnie55mMxFdFY0Ht6WzBfPjPjAKBggqhkjOPQQDAgNJ
+ADBGAiEAzmGWz+ES3AskIzWkpyLReF5uumL3P9M6oGbuWQNI7oUCIQCxMh9YfpQ9
+ODORWoaQhzzcGylXRfW0Vo+KbGSUIM5UJQ==
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cps/CPS_LEAF.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,28FD4B20429D2EE2D5A4CD16DC96D9E7
+
+6mD0qWchx9nnoG0k6OWhYHAnO/Kt096OWdC2zb7LpxJpPR1QeSLLbGD2C2ZR1HIV
+BU6JC5oK4WaLx/n9nN/inyJxnukc+PcsPJfPFMapVB/6cf21TrTQRBo8FXCORzVU
+RGbxT7lGQ6N0ygBWy5gen+4Fgvj3ZvCovtHT3E0776Q=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cps/CPS_LEAF.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB4TCCAYagAwIBAgICMEcwCgYIKoZIzj0EAwIwSTETMBEGA1UEAwwKUHJvdlN1
+YkNBMjEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEzARBgoJkiaJk/Is
+ZAEZFgNDUFMwHhcNMjMwOTI2MDczODM0WhcNNDgwNTE3MDczODM0WjBHMREwDwYD
+VQQDDAhDUFMgTGVhZjEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMCREUxEzAR
+BgoJkiaJk/IsZAEZFgNDUFMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASindZ1
+hlVRT/odxEf1LFbYuoTyOh2Oa6CqDX8Um/RSmLG52OVxdKfAGk4R8ORJRNh7QyLd
+H09I0ie8IjK4icZeo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAd
+BgNVHQ4EFgQUZv5eVYYpEgF/SaUSX3f0y0fHPi4wHwYDVR0jBBgwFoAUPY0swWIK
+/K9XDHqZcK/fTi2i+VAwCgYIKoZIzj0EAwIDSQAwRgIhAOyfs/F2IngcG+zT68sb
+NyRXTGZSxlwT/lCxM8CyGkR6AiEAo6N6SCi7PLplvLUFqSzZv+71QWiuXptDa+s+
+EWTROjA=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cps/CPS_LEAF_PASSWORD.txt

@@ -0,0 +1 @@
+123456

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cps/CPS_SUB_CA1.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,92A9EC2A77B81ABF10BC8E6AE11B43B6
+
+nnH3OCZrUZBdMhocSDduVmuce8nVFaJF4jcq29d+jDABB8ibYppoPHxR6b8+etui
+Qhd6iE2TZXtlSctsZvIp4LVh2Tri0WUO678YndrGg06oZgIf+Y8nXyx6G8VyxUGb
+QzTtj+wLR1NJVPZtLJcih8GpIHQHUyn5N0c+LzvgoB4=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cps/CPS_SUB_CA2.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,73E1007AF27ADEF53BF5063E7FABAF83
+
+Qc1kobAi7yJ3Acx/rsb6+RUE81jv1WY8sFQ172b77P2Yaq7vL+TjWLlChLmFm0No
+KiNK+5gY+ylgvItcvrSiCj2UoJgJuHY8MPGGMeVs841VkI8B+cqvnmbfGOcOpl4s
+AbTzenCYKABWlsgv+6evQCqHA0DFmFNmH7xbyflh55Q=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/csms/CSMS_RSA.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDlaoH7m9gUXbSb
+AvKGZr7/9iOLa5pewkPkgKkBzcFW4clJyFfnk8R84JO1zk9AsIhsjs4sDtePl1I2
+cvmKUcZTi07Et/LbIDyur4DFGQIHwDNVHjElWmm6N1SfyKSx4rhInMwMhvx4JBBH
+l8OupQdwroIkCsT2OfFoD198+rwzdaPkrE1854+FvMSdKyF+KeLjSG5xcl2MTO9T
+YQ8e4Ql1PcSvQHhxuAdG03pLiMiVTCFEFqzu3vd8VqNwbABhVNH6O/SxyUvePuUn
+6VCd8//D6fG9FmlTUIMO1C+MTIwU6cKCL0cI/MZo88BjYvzntpxsscut34iR8/WF
+S+J/O9HlAgMBAAECggEAFORy5O263mC9CooL3+bqFjGD6Cj+KT4D/jW9uzvR+e5C
++gF3bxzH/cVbJLXrbFoHR1E0AAaNmMNWydc4cXr9lp/u2VkuxS51rqtHjOuFNOmx
+SXTTISWcNkireYer5yuqAHbcpqsBjmFeZPhMHXkxXCop3bI0+kvcxIJasSBWblGB
+2fCIdgLpmfhbVENE/z1iUDiE2/eEVT17sRAdBjIEDxpMunzLQ4/Hdc7VcKAOjA7y
+fjGwGkLzRPkzbLZFFzOrvTkRKOu8bVBH6giN411xxQYIRCpa+BDjb3syoyVHgw6q
+o2KYanJ1He41wF0+9o0KlFrz0pXpOgjsYd1vWD3iqwKBgQD42F14RoWI6HbquFQi
+wQ6LXcurHT3rcRvHOMUzD3dvelkr7L4thqtYNOSlBM/8QBo1xkMi3k6CgwUuScRi
+yHHyMxjXgGsZRcR6ICMDvVVRc+DoC5195OL/HW6PXqD6CNJR5+0NH1JdCruaXzrx
+NpcYxfbQFajc+qXcTBoNwvKuDwKBgQDsAyI8l4h2QxQiMalo6XwpoTQfw7p6incQ
+EaBzIl+4iDplEu25qo7BvxA5Nfaudy35zaA1hRlKGvcHsxvqlmvoaITC5yrDIqIB
+5N6Rgpirie/Wp5Winny8+Iu9aIcUJkqtE1qEQxy4LkFBacz+sxvfDplzJA2Elypp
+G75OXEN0ywKBgFIdQ6q+yq3E2AjYTpsxTZVbnCuY+KfKqTnyV9BjmCvnGanO82qe
+d8ghnBmAHwnENWHtTJYi+ZFDnuAJY46dSkx75ASo0a6DQTRzilpfjdnU/TBVNOEo
+OGeq1KLmvQQFCTIR8D1WSp19Py7Poema8/0uxiUgIJra8wRg8G/+FoqtAoGAbW/i
+j0Agyd2+10A58ujZZyBV4CjNLodIQE48HUciJZodocKOMxqwSYzEBBNOyIWA7yV3
+FXobSO6J/6sA1d1cOg9FCG9St9s2TjSHM+ffzSMP8HQTAa4F30ZM3c47XI+I7wpb
+XZsVFR51qdRadvwsf1jwtKBSGFpUExsHOqSzrtMCgYAuCoK7JHZUU+U8RqfJkpci
+m522Ldhz+rICT/rByItKFpm9WaKwouZfNB2I45kIHvcl7h9RSCPkFcMs2kTjNF1h
+AyAlGnawOe8EOzVc2jVR+0PPcgwSoZ9ZHyPDUXdHCdAzdA256z1zipk1rIEqp7ZH
+Y2XZai5tF8r3+sAv5Umr1Q==
+-----END PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/csms/CSMS_RSA.pem

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC7TCCAdUCFGQ2LxV6E0juGIHth9kSN7+JXgf0MA0GCSqGSIb3DQEBCwUAMDMx
+CzAJBgNVBAYTAkRFMQ8wDQYDVQQKDAZQaW9uaXgxEzARBgNVBAMMCkNTTVNSb290
+Q0EwIBcNMjQwOTIwMTMzMzEyWhgPMjA1MjAyMDYxMzMzMTJaMDExCzAJBgNVBAYT
+AkRFMQ8wDQYDVQQKDAZQaW9uaXgxETAPBgNVBAMMCENzbXNMZWFmMIIBIjANBgkq
+hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5WqB+5vYFF20mwLyhma+//Yji2uaXsJD
+5ICpAc3BVuHJSchX55PEfOCTtc5PQLCIbI7OLA7Xj5dSNnL5ilHGU4tOxLfy2yA8
+rq+AxRkCB8AzVR4xJVppujdUn8ikseK4SJzMDIb8eCQQR5fDrqUHcK6CJArE9jnx
+aA9ffPq8M3Wj5KxNfOePhbzEnSshfini40hucXJdjEzvU2EPHuEJdT3Er0B4cbgH
+RtN6S4jIlUwhRBas7t73fFajcGwAYVTR+jv0sclL3j7lJ+lQnfP/w+nxvRZpU1CD
+DtQvjEyMFOnCgi9HCPzGaPPAY2L857acbLHLrd+IkfP1hUvifzvR5QIDAQABMA0G
+CSqGSIb3DQEBCwUAA4IBAQA0d5+3ml1bXHbusG8kINGV81sXX6HyusBFPDGYROaW
+5HR2CsLPIHdKWn7gyQV9holsI4aB+ZtQ/XVlZmtUTpHZkRFN2SmAs1tXbbQTBsWG
+5tVBO1/JtbRwxOsPU249y8xKFCslPCMLgbaw7FBUpFDpHDd2Q2YimqF3VY49cRjf
+vwEaWDqmPPPdF3pNtvS5KeiSsAQdQYB4wF26/nO52qAEpt7FaoG8GNUJqLRpLQj3
+/4fWPo7nxdntTKkaushW/XlfbvgS47lgiuQqzyDZF5lC/LLGs0Ml7N/k1nBsg7wZ
+0KLKRNKUb01kz/Na6WpkVY/8T9KL1D0mymHhDAaIVrWc
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cso/CPO_CERT_CHAIN.pem

@@ -0,0 +1,43 @@
+-----BEGIN CERTIFICATE-----
+MIIB3jCCAYWgAwIBAgICMDwwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJQ1BPU3Vi
+Q0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAeFw0yMzA5MjYwNzM4MzRaFw00MDAyMjkwNzM4MzRaMEcxETAPBgNV
+BAMMCFNFQ0NDZXJ0MRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEG
+CgmSJomT8ixkARkWA0NQTzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKBdMxlw
+3aS5nb5nJcL6wrXy7wpHuA1zQUHd4Lu9JjJjsmbFJ1aU/YjeNjd486cBnNFjef2J
+k7ugxFPGzgcgCRijYDBeMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgOIMB0G
+A1UdDgQWBBTsh2ntDu+kucMCihpJHD7K+ayx2TAfBgNVHSMEGDAWgBQ2GWOJSW7N
+ZiptYBlX9ycPXAzljzAKBggqhkjOPQQDAgNHADBEAiBm1ez6tTr5EBCL4lc0GxE2
+gFBov4vf4QbI4V5/a8XlaAIgB+XyVyd20UJsJu6zIZS3mowJ1OMzZ8lWJxXAJznu
+hQQ=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICWTCCAf+gAwIBAgICMDswCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJQ1BPU3Vi
+Q0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yMTIzMDkwMjA3MzgzNFowSDESMBAG
+A1UEAwwJQ1BPU3ViQ0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA1YyRzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABEat
+pC4ruZ4wc/Hb5JA68ICxU7TQNvLDTJ+Qjc9QetO91h8gAoVRAHKvg8Hoe+lqfu5d
++Q6Ax05xUuFwTzyc3eejgdYwgdMwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFDYZY4lJbs1mKm1gGVf3Jw9cDOWPMG0GCCsGAQUF
+BwEBBGEwXzAkBggrBgEFBQcwAYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcG
+CCsGAQUFBzAChitodHRwczovL3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUt
+Q0EuY2VyMB8GA1UdIwQYMBaAFCcnBk2/j/EjG9W6yXgudPVyOgWwMAoGCCqGSM49
+BAMCA0gAMEUCIQDsQM6q7ecToESugkNzZS3R6il0TKNXeeVgwC84kgb0RAIgfjZh
+VXfKo/V7VIHRG9zgM5mO8XdLp+ip25FZbc+V5wU=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICWTCCAf+gAwIBAgICMDowCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJVjJHUm9v
+dENBMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSDESMBAG
+A1UEAwwJQ1BPU3ViQ0ExMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTET
+MBEGCgmSJomT8ixkARkWA1YyRzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMqy
+mpvtNjA3+U5TdcucSgdWpXFj8XXwAlb6luBEYCytUD7AREB9P+ksVgcN6GiiZGn8
+0Pdnu+NCuyDLwlUvX6ejgdYwgdMwEgYDVR0TAQH/BAgwBgEB/wIBATAOBgNVHQ8B
+Af8EBAMCAQYwHQYDVR0OBBYEFCcnBk2/j/EjG9W6yXgudPVyOgWwMG0GCCsGAQUF
+BwEBBGEwXzAkBggrBgEFBQcwAYYYaHR0cHM6Ly93d3cuZXhhbXBsZS5jb20vMDcG
+CCsGAQUFBzAChitodHRwczovL3d3dy5leGFtcGxlLmNvbS9JbnRlcm1lZGlhdGUt
+Q0EuY2VyMB8GA1UdIwQYMBaAFGfGqeJ7nmYzEV0VjQe3pbMF8+M+MAoGCCqGSM49
+BAMCA0gAMEUCICZt4DhW92hiDyUr8oqOUHocKfLRMf5I0vTvajqTbQiVAiEA6as1
+yudx0oHSYf7e7IZBQ6KP1gjC6wcRvfvlBQNbySQ=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cso/SECC_LEAF.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,E286B477F370D35ED00DFB2037181B4E
+
+WidZNEVp7+k899BFCl9vEI5GtR3xQlHtyRmtUxB26EnHWlNZkNv7WqIZcH0ovLrs
+ycR9YteLo6mVW/ecDYkkfiaaog1YOylyxWjYwEB1A6zySU+tav/o6TNqRcynLCpX
+ypWR6wIDkjOso56mnD24hT0dFQL94ZCjYHb5d0tNPBs=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cso/SECC_LEAF.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB3jCCAYWgAwIBAgICMDwwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJQ1BPU3Vi
+Q0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA1YyRzAeFw0yMzA5MjYwNzM4MzRaFw00MDAyMjkwNzM4MzRaMEcxETAPBgNV
+BAMMCFNFQ0NDZXJ0MRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEG
+CgmSJomT8ixkARkWA0NQTzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKBdMxlw
+3aS5nb5nJcL6wrXy7wpHuA1zQUHd4Lu9JjJjsmbFJ1aU/YjeNjd486cBnNFjef2J
+k7ugxFPGzgcgCRijYDBeMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgOIMB0G
+A1UdDgQWBBTsh2ntDu+kucMCihpJHD7K+ayx2TAfBgNVHSMEGDAWgBQ2GWOJSW7N
+ZiptYBlX9ycPXAzljzAKBggqhkjOPQQDAgNHADBEAiBm1ez6tTr5EBCL4lc0GxE2
+gFBov4vf4QbI4V5/a8XlaAIgB+XyVyd20UJsJu6zIZS3mowJ1OMzZ8lWJxXAJznu
+hQQ=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/cso/SECC_LEAF_PASSWORD.txt

@@ -0,0 +1 @@
+123456

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_LEAF.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,524C74F543317C05FACD9FAFCA52345A
+
+WTtugwCb+B1t64NAsJlhcSJlyWvNfi2/i+X5YjsCoLVksBEdrhaXmNgBNKC2jD3j
+y+Y+ljw1pGyAvBhNjHOyCno/0HBZrCSMFXRrwp4g0rqDK16yF/ZjMI9k8F1qtv7m
+kfy2xqSLcHYc0+ntlD1mgIWCsnlTejWbsdAl9BFB2ps=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_LEAF.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICZjCCAg2gAwIBAgICMEQwCgYIKoZIzj0EAwIwVzEiMCAGA1UEAwwZUEtJLUV4
+dF9DUlRfTU9fU1VCMl9WQUxJRDEQMA4GA1UECgwHRVZlcmVzdDELMAkGA1UEBhMC
+REUxEjAQBgoJkiaJk/IsZAEZFgJNTzAgFw0yMzA5MjYwNzM4MzRaGA8yMjIzMDgw
+OTA3MzgzNFowTTEYMBYGA1UEAwwPVUtTV0kxMjM0NTY3ODlBMRAwDgYDVQQKDAdF
+VmVyZXN0MQswCQYDVQQGEwJERTESMBAGCgmSJomT8ixkARkWAk1PMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAE9isd5jdi0yk3WytwQk6YuYRwN0ZaZ/WqRGetcHxi
+uHO+xp4cEIMHSLzUgp1FuXm6ypD9SQSPSnj0nGUc1It2ZKOB0DCBzTAMBgNVHRMB
+Af8EAjAAMA4GA1UdDwEB/wQEAwID6DAdBgNVHQ4EFgQUTc1VvSACKpeoXyBwGuzU
+zZcOQNEwbQYIKwYBBQUHAQEEYTBfMCQGCCsGAQUFBzABhhhodHRwczovL3d3dy5l
+eGFtcGxlLmNvbS8wNwYIKwYBBQUHMAKGK2h0dHBzOi8vd3d3LmV4YW1wbGUuY29t
+L0ludGVybWVkaWF0ZS1DQS5jZXIwHwYDVR0jBBgwFoAUDWRBgQwbrjfLq9NLH1Zn
+BlTkspkwCgYIKoZIzj0EAwIDRwAwRAIgDHw5J2ecr7QCbgfa1EhfueoqYSIVCFBD
+Am9629lXT+ACIAVcRW8WgW/ZuR5/wCeejntf2Xg94ywrZuRIVNLFQuVY
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_LEAF_PASSWORD.txt

@@ -0,0 +1 @@
+123456

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_ROOT_CA.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,60045B8B69CF8543559A43B31FD9CA7B
+
+20P+XV/6fRKTiQ4l0pKeluDw1txdq0IdejYAfAH65MME9NKoSTagLTHRYAEdczJ5
+oQqven3M25hAVN+X0QRUl6ZcbyVThM7U0zL1pFtdG8Rwb3l3tk60qBr4S5yJpDel
+U674NwEC5gKNhSQiwiTBij2CJGVidOpKIDT6IYubIK0=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_SUB_CA1.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,AAC5A3AA533020F7E51F4B27F20A57D9
+
++VYyK1UaLoZHmjn9pCKblfjUfp/daTvhH9gnDVlU34gKFOeqs+jqnqhdPXO5bboW
+uljn51J17IvJ3Z8K62mQ//t/13f5FXRG/66pukF2/8qRknk9gNswI0FA7g6hndS2
+2fFcJp1kmW8qaS+/uzVQ5+JVthbu37UXyJTgFDakoNk=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/mo/MO_SUB_CA2.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,11DD29A4D8FA7BE406A00F6F753D69F4
+
+h94ykrzzFgmAYtzcc2LPIKuyqgyi9fUMTA0bxvQSq/8ftXY+2gC6Rpm5RLyiSFvo
+ok71wI//901HIKlY37Qf7BSaGK7hVQDphF2PpyVKm3j/P/ADah8aQBQov4Qb1G0i
+tfg5wvk4uTk5qq8ake6npLQ/ub0XVIU03TrJMd6GFHU=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_LEAF.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,2E1E9BBA33EED7A28A60F6807E4ED742
+
+fuKzuGIoh9KQVmL1iYdbxxBfIzcCMdwAkLUSF8m1nLTzW+9mSFrkA3wjRMmjOBbf
+LsiSFawr0fOcf1N80jpoc2jsXAyOBcxhL9rucLc11uCFaxNFtowCO+g/B8vqSDYo
+Pu/QI3P1c5XNPoELhPGfN6tTCc9dGhXzWMCFSW8aRm4=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_LEAF.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB5DCCAYqgAwIBAgICMEAwCgYIKoZIzj0EAwIwSDESMBAGA1UEAwwJT0VNU3Vi
+Q0EyMRAwDgYDVQQKDAdFVmVyZXN0MQswCQYDVQQGEwJERTETMBEGCgmSJomT8ixk
+ARkWA09FTTAgFw0yMzA5MjYwNzM4MzRaGA8yNDIzMDYyMTA3MzgzNFowSjEUMBIG
+A1UEAwwLT0VNUHJvdkNlcnQxEDAOBgNVBAoMB0VWZXJlc3QxCzAJBgNVBAYTAkRF
+MRMwEQYKCZImiZPyLGQBGRYDT0VNMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
+1Qza34iaHRAxMwvGUOTnBvlFicTCFl1cddIvnsd1qbaEyIIRotrOkXhfIQDv4kmi
+ue85Cpa2vdn+m1p48W7icaNgMF4wDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMC
+A4gwHQYDVR0OBBYEFK5Xv8jMo4+1pvU2GWsZU7BG/kQEMB8GA1UdIwQYMBaAFDiL
+U8JAZUuIUPxiS8zcM/fKsZZNMAoGCCqGSM49BAMCA0gAMEUCIQDxjoscE/RMTLZh
+9u/ElkpavrVQpkhVmhYOEbQWr/4ijQIgQaHykyPuRZMen3ZCVXqioqsDj6Dq5WAw
+Nsf1XdB+Nz8=
+-----END CERTIFICATE-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_LEAF_PASSWORD.txt

@@ -0,0 +1 @@
+123456

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_ROOT_CA.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,68D8ECF4F203CAE620E97FB653C99ED8
+
+vf/skaF4qWk9CUE/Ng1axJV1H5TMX4j3+LlQOBEWg8sMgfhmEvSdS0G6TX0vYF+/
+31dz5e9+YIMQDmW2u5uUTM9Gi714TDHG5u284OgmHtAo7fAu+EQ13/uBqJEAs4yl
+hEqbosHz6/j/GeiJHAmAq+QO9EG1ebFuMPCb6UFCfjA=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_SUB_CA1.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,F7E3640B1C8474AA78E0129947CD6737
+
+6TiKhKc0a0UaGxzajYDDk/Zcy8YVZWY2XGSTdlGtpcfTxWyzFWhWoNUce/aEBYOD
+x1pZg6gIZTR7KCEt8T9ItMHg0OY6q2Ug+r8UTc0hgkFDUIQ3UQiRNEJh4Ke3Kzra
+q9oJ72gO78bfc/zqFvwXb2pyAtr2gkVFuBdjb4SLWgA=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/oem/OEM_SUB_CA2.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,71F99C97FCE7E48910234807353204A9
+
+dv2wPXFoffxT5UJhk1r+Owrc7Mm0wR5FUNWTE2RNs8HlWmXHWkyzAk6g6wteh27H
+m7FhVpzEK56VvTW+vHgUx6ux6xKz9qJzyBi+AQvyi2Rcf40CarOBqpJahkA2lJ4w
+XNyN16eTnjloztq/ZG/lO02++sOQ0VysdF+bzGd/oMA=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/v2g/V2G_ROOT_CA.key

@@ -0,0 +1,8 @@
+-----BEGIN EC PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,B8F5097C93B64415AC2940579510AFAA
+
+rTMIQLlcPnSkAH8ZWNUKCtue0KYoKK+AtaNwQkdenavGpQ5gl3wlzH6hf2pYLVAX
+ADUtPwz6WGDMuH1qT9vQ20FdfPde4TIdXbmX1GsIS8VrHh3JRG5gkYnktdki6m4F
+u+UTTLgZJ+qcDVA/6InzuBBffUkie91y1T1d3TMw0Kk=
+-----END EC PRIVATE KEY-----

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/certs/client/v2g/V2G_ROOT_CA_PASSWORD.txt

@@ -0,0 +1 @@
+123456

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-042_1.yaml

@@ -0,0 +1,100 @@
+active_modules:
+  connector_1:
+    module: EvseManager
+    config_module:
+      connector_id: 1
+      has_ventilation: true
+      evse_id: '1'
+      external_ready_to_start_charging: true
+    connections:
+      bsp:
+      - module_id: yeti_driver
+        implementation_id: board_support
+      powermeter_grid_side:
+      - module_id: yeti_driver
+        implementation_id: powermeter
+  yeti_driver:
+    module: YetiSimulator
+    config_module:
+      connector_id: 1
+  car_simulator:
+    module: EvManager
+    config_module:
+      connector_id: 1
+      auto_enable: true
+      auto_exec: false
+      auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug
+    connections:
+      ev_board_support:
+        - module_id: yeti_driver
+          implementation_id: ev_board_support
+  ocpp:
+    module: OCPP
+    config_module:
+      ChargePointConfigPath: libocpp-config-042_1.json
+      UserConfigPath: user_config.json
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+      - module_id: connector_1
+        implementation_id: evse
+      reservation:
+      - module_id: auth
+        implementation_id: reservation
+      auth:
+      - module_id: auth
+        implementation_id: main
+      system:
+      - module_id: system
+        implementation_id: main
+      security:
+        - module_id: evse_security
+          implementation_id: main
+  evse_security:
+    module: EvseSecurity
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 20
+    connections:
+      token_provider:
+      - module_id: token_provider_manual
+        implementation_id: main
+      - module_id: ocpp
+        implementation_id: auth_provider
+      token_validator:
+      - module_id: ocpp
+        implementation_id: auth_validator
+      evse_manager:
+      - module_id: connector_1
+        implementation_id: evse
+  token_provider_manual:
+    module: DummyTokenProviderManual
+    connections: {}
+    config_implementation:
+      main:
+        mqtt_topic: 'everest_api/dummy_token_provider/cmd/provide'
+        token: '123'
+        type: dummy
+  energy_manager:
+    module: EnergyManager
+    connections:
+      energy_trunk:
+      - module_id: grid_connection_point
+        implementation_id: energy_grid
+  grid_connection_point:
+    module: EnergyNode
+    config_module:
+      fuse_limit_A: 63.0
+      phase_count: 3
+    connections:
+      price_information: []
+      energy_consumer:
+      - module_id: connector_1
+        implementation_id: energy_grid
+      powermeter:
+      - module_id: yeti_driver
+        implementation_id: powermeter
+  system:
+    module: System
+x-module-layout: {}

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-078.yaml

@@ -0,0 +1,99 @@
+active_modules:
+  connector_1:
+    module: EvseManager
+    config_module:
+      connector_id: 1
+      has_ventilation: true
+      evse_id: '1'
+      external_ready_to_start_charging: true
+    connections:
+      bsp:
+      - module_id: yeti_driver
+        implementation_id: board_support
+      powermeter_grid_side:
+      - module_id: yeti_driver
+        implementation_id: powermeter
+  yeti_driver:
+    module: YetiSimulator
+    config_module:
+      connector_id: 1
+  car_simulator:
+    module: EvManager
+    config_module:
+      connector_id: 1
+      auto_enable: true
+      auto_exec: false
+      auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug
+    connections:
+      ev_board_support:
+        - module_id: yeti_driver
+          implementation_id: ev_board_support
+  ocpp:
+    module: OCPP
+    config_module:
+      ChargePointConfigPath: libocpp-config-078.json
+      EnableExternalWebsocketControl: true
+      UserConfigPath: user_config.json
+    connections:
+      evse_manager:
+      - module_id: connector_1
+        implementation_id: evse
+      reservation:
+      - module_id: auth
+        implementation_id: reservation
+      auth:
+      - module_id: auth
+        implementation_id: main
+      system:
+      - module_id: system
+        implementation_id: main
+      security:
+        - module_id: evse_security
+          implementation_id: main
+  evse_security:
+    module: EvseSecurity
+    config_module:
+      csms_ca_bundle: ca/csms/CSMS_ROOT_CA.pem
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 20
+    connections:
+      token_provider:
+      - module_id: token_provider_manual
+        implementation_id: main
+      - module_id: ocpp
+        implementation_id: auth_provider
+      token_validator:
+      - module_id: ocpp
+        implementation_id: auth_validator
+      evse_manager:
+      - module_id: connector_1
+        implementation_id: evse
+  token_provider_manual:
+    module: DummyTokenProviderManual
+    config_implementation:
+      main:
+        mqtt_topic: 'everest_api/dummy_token_provider/cmd/provide'
+  energy_manager:
+    module: EnergyManager
+    connections:
+      energy_trunk:
+      - module_id: grid_connection_point
+        implementation_id: energy_grid
+  grid_connection_point:
+    module: EnergyNode
+    config_module:
+      fuse_limit_A: 63.0
+      phase_count: 3
+    connections:
+      price_information: []
+      energy_consumer:
+      - module_id: connector_1
+        implementation_id: energy_grid
+      powermeter:
+      - module_id: yeti_driver
+        implementation_id: powermeter
+  system:
+    module: System
+x-module-layout: {}

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp16-costandprice.yaml

@@ -0,0 +1,111 @@
+active_modules:
+  evse_manager:
+    module: EvseManager
+    config_module:
+      connector_id: 1
+      has_ventilation: true
+      evse_id: "1"
+      external_ready_to_start_charging: true
+    connections:
+      bsp:
+        - module_id: yeti_driver
+          implementation_id: board_support
+      powermeter_grid_side:
+        - module_id: yeti_driver
+          implementation_id: powermeter
+  yeti_driver:
+    module: YetiSimulator
+    config_module:
+      connector_id: 1
+  ev_manager:
+    module: EvManager
+    config_module:
+      connector_id: 1
+      auto_enable: true
+      auto_exec: false
+      auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug
+    connections:
+      ev_board_support:
+        - module_id: yeti_driver
+          implementation_id: ev_board_support
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 10
+      selection_algorithm: FindFirst
+    connections:
+      token_provider:
+        - module_id: token_provider
+          implementation_id: main
+        - module_id: ocpp
+          implementation_id: auth_provider
+      token_validator:
+        - module_id: ocpp
+          implementation_id: auth_validator
+      evse_manager:
+        - module_id: evse_manager
+          implementation_id: evse
+  ocpp:
+    module: OCPP
+    config_module:
+      ChargePointConfigPath: libocpp-config-costandprice.json
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: evse_manager
+          implementation_id: evse
+      reservation:
+        - module_id: auth
+          implementation_id: reservation
+      auth:
+        - module_id: auth
+          implementation_id: main
+      system:
+        - module_id: system
+          implementation_id: main
+      security:
+        - module_id: evse_security
+          implementation_id: main
+  session_cost:
+    module: TerminalCostAndPriceMessage
+    connections:
+      session_cost:
+        - module_id: ocpp
+          implementation_id: session_cost
+  evse_security:
+    module: EvseSecurity
+    config_module:
+      private_key_password: "123456"
+  token_provider:
+    module: DummyTokenProviderManual
+    config_implementation:
+      main:
+        mqtt_topic: 'everest_api/dummy_token_provider/cmd/provide'
+  energy_manager:
+    module: EnergyManager
+    connections:
+      energy_trunk:
+        - module_id: grid_connection_point
+          implementation_id: energy_grid
+  grid_connection_point:
+    module: EnergyNode
+    config_module:
+      fuse_limit_A: 40.0
+      phase_count: 3
+    connections:
+      price_information: []
+      energy_consumer:
+        - module_id: evse_manager
+          implementation_id: energy_grid
+      powermeter:
+        - module_id: yeti_driver
+          implementation_id: powermeter
+  error_history:
+    module: ErrorHistory
+    config_implementation:
+      error_history:
+        database_path: /tmp/error_history.db
+  system:
+    module: System
+
+x-module-layout: {}

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp16-probe-module.yaml

@@ -0,0 +1,27 @@
+active_modules:
+  ocpp:
+    module: OCPP
+    config_module:
+      ChargePointConfigPath: libocpp-config-test.json
+      UserConfigPath: user_config.json
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: probe
+          implementation_id: evse_manager
+        - module_id: probe
+          implementation_id: evse_manager_b
+      reservation:
+        - module_id: probe
+          implementation_id: reservation
+      auth:
+        - module_id: probe
+          implementation_id: auth
+      system:
+        - module_id: probe
+          implementation_id: system
+      security:
+        - module_id: probe
+          implementation_id: security
+x-module-layout: {}
+

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp201-costandprice.yaml

@@ -0,0 +1,167 @@
+active_modules:
+  connector_1:
+    module: EvseManager
+    config_module:
+      connector_id: 1
+      has_ventilation: true
+      evse_id: "1"
+      session_logging: true
+      session_logging_xml: false
+      ac_hlc_enabled: false
+      ac_hlc_use_5percent: false
+      ac_enforce_hlc: false
+    connections:
+      bsp:
+        - module_id: yeti_driver_1
+          implementation_id: board_support
+      powermeter_grid_side:
+        - module_id: yeti_driver_1
+          implementation_id: powermeter
+  connector_2:
+    module: EvseManager
+    config_module:
+      connector_id: 2
+      has_ventilation: true
+      evse_id: "2"
+      session_logging: true
+      session_logging_xml: false
+      ac_hlc_enabled: false
+      ac_hlc_use_5percent: false
+      ac_enforce_hlc: false
+    connections:
+      bsp:
+        - module_id: yeti_driver_2
+          implementation_id: board_support
+      powermeter_grid_side:
+        - module_id: yeti_driver_2
+          implementation_id: powermeter
+  yeti_driver_1:
+    module: YetiSimulator
+    config_module:
+      connector_id: 1
+  yeti_driver_2:
+    module: YetiSimulator
+    config_module:
+      connector_id: 2
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 30
+      selection_algorithm: FindFirst
+    connections:
+      token_provider:
+        - module_id: ocpp
+          implementation_id: auth_provider
+        - module_id: token_provider_manual
+          implementation_id: main
+      token_validator:
+        - module_id: ocpp
+          implementation_id: auth_validator
+      evse_manager:
+        - module_id: connector_1
+          implementation_id: evse
+        - module_id: connector_2
+          implementation_id: evse
+  ocpp:
+    module: OCPP201
+    config_module:
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: connector_1
+          implementation_id: evse
+        - module_id: connector_2
+          implementation_id: evse
+      auth:
+        - module_id: auth
+          implementation_id: main
+      system:
+        - module_id: system
+          implementation_id: main
+      security:
+        - module_id: evse_security
+          implementation_id: main
+      display_message:
+        - module_id: display_message
+          implementation_id: display_message
+  persistent_store:
+    module: PersistentStore
+    config_module:
+      sqlite_db_file_path: persistent_store.db
+  display_message:
+    module: TerminalDisplayMessage
+  session_cost:
+    module: TerminalCostAndPriceMessage
+    connections:
+      session_cost:
+        - module_id: ocpp
+          implementation_id: session_cost
+  evse_security:
+    module: EvseSecurity
+    config_module:
+      csms_ca_bundle: "ca/csms/CSMS_ROOT_CA.pem"
+      csms_leaf_cert_directory: "client/csms"
+      csms_leaf_key_directory: "client/csms"
+      mf_ca_bundle: "ca/mf/MF_ROOT_CA.pem"
+      mo_ca_bundle: "ca/mo/MO_ROOT_CA.pem"
+      v2g_ca_bundle: "ca/v2g/V2G_ROOT_CA.pem"
+      secc_leaf_cert_directory: "client/cso"
+      secc_leaf_key_directory: "client/cso"
+      private_key_password: "123456"
+  token_provider_manual:
+    module: DummyTokenProviderManual
+    config_implementation:
+      main:
+        mqtt_topic: 'everest_api/dummy_token_provider/cmd/provide'
+  energy_manager:
+    module: EnergyManager
+    connections:
+      energy_trunk:
+        - module_id: grid_connection_point
+          implementation_id: energy_grid
+  grid_connection_point:
+    module: EnergyNode
+    config_module:
+      fuse_limit_A: 40.0
+      phase_count: 3
+    connections:
+      price_information: []
+      energy_consumer:
+        - module_id: connector_1
+          implementation_id: energy_grid
+        - module_id: connector_2
+          implementation_id: energy_grid
+      powermeter:
+        - module_id: yeti_driver_1
+          implementation_id: powermeter
+  ev_manager_1:
+    module: EvManager
+    config_module:
+      connector_id: 1
+      auto_enable: true
+      auto_exec: false
+      auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug
+    connections:
+      ev_board_support:
+        - module_id: yeti_driver_1
+          implementation_id: ev_board_support
+  ev_manager_2:
+    module: EvManager
+    config_module:
+      connector_id: 2
+      auto_enable: true
+      auto_exec: false
+      auto_exec_commands: sleep 1;iec_wait_pwr_ready;sleep 1;draw_power_regulated 16,3;sleep 30;unplug
+    connections:
+      ev_board_support:
+        - module_id: yeti_driver_2
+          implementation_id: ev_board_support
+  error_history:
+    module: ErrorHistory
+    config_implementation:
+      error_history:
+        database_path: /tmp/error_history.db
+  system:
+    module: System
+
+x-module-layout: {}

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp201-data-transfer.yaml

@@ -0,0 +1,129 @@
+active_modules:
+  connector_1:
+    module: EvseManager
+    config_module:
+      connector_id: 1
+      has_ventilation: true
+      evse_id: "1"
+      session_logging: true
+      session_logging_xml: false
+      ac_hlc_enabled: false
+      ac_hlc_use_5percent: false
+      ac_enforce_hlc: false
+    connections:
+      bsp:
+        - module_id: yeti_driver_1
+          implementation_id: board_support
+      powermeter_grid_side:
+        - module_id: yeti_driver_1
+          implementation_id: powermeter
+  connector_2:
+    module: EvseManager
+    config_module:
+      connector_id: 2
+      has_ventilation: true
+      evse_id: "2"
+      session_logging: true
+      session_logging_xml: false
+      ac_hlc_enabled: false
+      ac_hlc_use_5percent: false
+      ac_enforce_hlc: false
+    connections:
+      bsp:
+        - module_id: yeti_driver_2
+          implementation_id: board_support
+      powermeter_grid_side:
+        - module_id: yeti_driver_2
+          implementation_id: powermeter
+  yeti_driver_1:
+    module: YetiSimulator
+    config_module:
+      connector_id: 1
+  yeti_driver_2:
+    module: YetiSimulator
+    config_module:
+      connector_id: 2
+  ocpp:
+    module: OCPP201
+    config_module:
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: connector_1
+          implementation_id: evse
+        - module_id: connector_2
+          implementation_id: evse
+      auth:
+        - module_id: auth
+          implementation_id: main
+      system:
+        - module_id: system
+          implementation_id: main
+      security:
+        - module_id: evse_security
+          implementation_id: main
+  persistent_store:
+    module: PersistentStore
+    config_module:
+      sqlite_db_file_path: persistent_store.db
+  evse_security:
+    module: EvseSecurity
+    config_module:
+      csms_ca_bundle: "ca/csms/CSMS_ROOT_CA.pem"
+      csms_leaf_cert_directory: "client/csms"
+      csms_leaf_key_directory: "client/csms"
+      mf_ca_bundle: "ca/mf/MF_ROOT_CA.pem"
+      mo_ca_bundle: "ca/mo/MO_ROOT_CA.pem"
+      v2g_ca_bundle: "ca/v2g/V2G_ROOT_CA.pem"
+      secc_leaf_cert_directory: "client/cso"
+      secc_leaf_key_directory: "client/cso"
+      private_key_password: "123456"
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 30
+      selection_algorithm: FindFirst
+    connections:
+      token_provider:
+        - module_id: ocpp
+          implementation_id: auth_provider
+        - module_id: token_provider_manual
+          implementation_id: main
+      token_validator:
+        - module_id: ocpp
+          implementation_id: auth_validator
+      evse_manager:
+        - module_id: connector_1
+          implementation_id: evse
+        - module_id: connector_2
+          implementation_id: evse
+  token_provider_manual:
+    module: DummyTokenProviderManual
+    config_implementation:
+      main:
+        mqtt_topic: 'everest_api/dummy_token_provider/cmd/provide'
+  energy_manager:
+    module: EnergyManager
+    connections:
+      energy_trunk:
+        - module_id: grid_connection_point
+          implementation_id: energy_grid
+  grid_connection_point:
+    module: EnergyNode
+    config_module:
+      fuse_limit_A: 40.0
+      phase_count: 3
+    connections:
+      price_information: []
+      energy_consumer:
+        - module_id: connector_1
+          implementation_id: energy_grid
+        - module_id: connector_2
+          implementation_id: energy_grid
+      powermeter:
+        - module_id: yeti_driver_1
+          implementation_id: powermeter
+  system:
+    module: System
+
+x-module-layout: {}

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp201-probe-module-data-transfer.yaml

@@ -0,0 +1,28 @@
+active_modules:
+  ocpp:
+    module: OCPP201
+    config_module:
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorA
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorB
+      auth:
+        - module_id: auth
+          implementation_id: main
+      system:
+        - module_id: probe
+          implementation_id: ProbeModuleSystem
+      security:
+        - module_id: probe
+          implementation_id: ProbeModuleSecurity
+      data_transfer:
+        - module_id: probe
+          implementation_id: ProbeModuleDataTransfer
+      extensions_15118:
+        - module_id: probe
+          implementation_id: ProbeModuleIso15118Extensions
+x-module-layout: {}
+

tools/EVerest-main/tests/ocpp_tests/test_sets/everest-aux/config/everest-config-ocpp201-probe-module.yaml

@@ -0,0 +1,42 @@
+active_modules:
+  ocpp:
+    module: OCPP201
+    config_module:
+      EnableExternalWebsocketControl: true
+    connections:
+      evse_manager:
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorA
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorB
+      auth:
+        - module_id: auth
+          implementation_id: main
+      system:
+        - module_id: probe
+          implementation_id: ProbeModuleSystem
+      security:
+        - module_id: probe
+          implementation_id: ProbeModuleSecurity
+      extensions_15118:
+        - module_id: probe
+          implementation_id: ProbeModuleIso15118Extensions
+  auth:
+    module: Auth
+    config_module:
+      connection_timeout: 30
+      selection_algorithm: FindFirst
+    connections:
+      token_provider:
+        - module_id: ocpp
+          implementation_id: auth_provider
+      token_validator:
+        - module_id: ocpp
+          implementation_id: auth_validator
+      evse_manager:
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorA
+        - module_id: probe
+          implementation_id: ProbeModuleConnectorB
+x-module-layout: {}
+