eric/cariflex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ce67b8e9f6c2ef5ee0846faf1d6aa799e12c29cd
cariflex/tools/EVerest-main/modules/EVSE/EvseManager/tests/ErrorHandlingTest.cpp
Eric F d398a6ced2 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
2026-06-08 00:38:27 -04:00

353 lines
14 KiB
C++
Raw Blame History

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
#include "ErrorHandling.hpp"
#include "EvseManagerStub.hpp"
#include "evse_board_supportIntfStub.hpp"
#include <gtest/gtest.h>
#include <memory>
#include <set>
namespace Everest::error {
bool operator<(const Error& lhs, const Error& rhs) {
return lhs.type < rhs.type;
}
bool operator==(const Error& lhs, const Error& rhs) {
return (lhs.type == rhs.type) && (lhs.sub_type == rhs.sub_type);
}
} // namespace Everest::error
namespace {
struct ErrorHandlingTest : public module::ErrorHandling {
using module::ErrorHandling::ErrorHandling;
using module::ErrorHandling::raise_inoperative_error;
};
struct ErrorDatabaseStub : public Everest::error::ErrorDatabase {
using Error = Everest::error::Error;
using ErrorPtr = Everest::error::ErrorPtr;
using ErrorFilter = Everest::error::ErrorFilter;
std::list<Error>& active_errors;
ErrorDatabaseStub(std::list<Error>& active) : Everest::error::ErrorDatabase(), active_errors(active) {
}
virtual void add_error(ErrorPtr error) {
}
virtual std::list<ErrorPtr> get_errors(const std::list<ErrorFilter>& filters) const {
std::list<ErrorPtr> result;
for (const auto& error : active_errors) {
result.push_back(std::make_shared<Error>(error));
}
return result;
}
virtual std::list<ErrorPtr> edit_errors(const std::list<ErrorFilter>& filters, EditErrorFunc edit_func) {
return {};
}
virtual std::list<ErrorPtr> remove_errors(const std::list<ErrorFilter>& filters) {
return {};
}
};
struct EvseManagerModuleAdapterStub : public module::stub::EvseManagerModuleAdapter {
std::shared_ptr<Everest::error::ErrorTypeMap> error_type_map;
std::shared_ptr<ErrorDatabaseStub> error_database;
std::list<Everest::error::ErrorType> error_list;
std::list<Everest::error::Error> active_errors;
EvseManagerModuleAdapterStub() :
module::stub::EvseManagerModuleAdapter(),
error_type_map(std::make_shared<Everest::error::ErrorTypeMap>()),
error_database(std::make_shared<ErrorDatabaseStub>(active_errors)),
error_list{} {
}
virtual std::shared_ptr<Everest::error::ErrorManagerImpl> get_error_manager_impl_fn(const std::string& str) {
return std::make_shared<Everest::error::ErrorManagerImpl>(
error_type_map, std::make_shared<Everest::error::ErrorDatabaseMap>(), error_list,
[this](const Everest::error::Error& error) {
if (error_raise.find(error.type) == error_raise.end()) {
throw std::runtime_error("Error type " + error.type + " not found");
}
error_raise[error.type](error);
active_errors.push_back(error);
},
[this](const Everest::error::Error& error) {
if (error_raise.find(error.type) == error_raise.end()) {
throw std::runtime_error("Error type " + error.type + " not found");
}
error_clear[error.type](error);
active_errors.remove(error);
},
false);
}
virtual std::shared_ptr<Everest::error::ErrorManagerReq> get_error_manager_req_fn(const Requirement& req) {
return std::make_shared<Everest::error::ErrorManagerReq>(
error_type_map, std::make_shared<Everest::error::ErrorDatabaseMap>(), error_list,
[this](const Everest::error::ErrorType& error_type, const Everest::error::ErrorCallback& callback,
const Everest::error::ErrorCallback& clear_callback) {
error_raise[error_type] = callback;
error_clear[error_type] = clear_callback;
});
}
virtual std::shared_ptr<Everest::error::ErrorFactory> get_error_factory_fn(const std::string&) {
return std::make_shared<Everest::error::ErrorFactory>(error_type_map);
}
virtual std::shared_ptr<Everest::error::ErrorStateMonitor> get_error_state_monitor_impl_fn(const std::string&) {
return std::make_shared<Everest::error::ErrorStateMonitor>(error_database);
}
};
struct ErrorHandlingTesting : public testing::Test {
EvseManagerModuleAdapterStub adapter;
std::map<Everest::error::ErrorType, std::string> error_types_map;
std::unique_ptr<evse_board_supportIntf> r_bsp{};
const std::vector<std::unique_ptr<ISO15118_chargerIntf>> r_hlc{};
const std::vector<std::unique_ptr<connector_lockIntf>> r_connector_lock{};
const std::vector<std::unique_ptr<ac_rcdIntf>> r_ac_rcd{};
std::unique_ptr<evse_managerImplBase> p_evse{};
const std::vector<std::unique_ptr<isolation_monitorIntf>> _r_imd{};
const std::vector<std::unique_ptr<power_supply_DCIntf>> _r_powersupply{};
const std::vector<std::unique_ptr<powermeterIntf>> _r_powermeter{};
const std::vector<std::unique_ptr<over_voltage_monitorIntf>> _r_over_voltage_monitor{};
std::unique_ptr<ErrorHandlingTest> error_handler;
void construct(bool _inoperative_error_use_vendor_id) {
error_types_map = {{"evse_board_support/VendorWarning", "warning"},
{"evse_manager/Inoperative", "inoperative"}};
adapter.error_type_map->load_error_types_map(error_types_map);
adapter.active_errors.clear();
for (const auto& [error, description] : error_types_map) {
adapter.error_list.push_back(error);
}
r_bsp = std::make_unique<module::stub::evse_board_supportIntfStub>(adapter);
p_evse = std::make_unique<module::stub::evse_managerImplStub>(&adapter, "manager");
error_handler = std::make_unique<ErrorHandlingTest>(r_bsp, r_hlc, r_connector_lock, r_ac_rcd, p_evse, _r_imd,
_r_powersupply, _r_powermeter, _r_over_voltage_monitor,
_inoperative_error_use_vendor_id);
}
static constexpr std::string_view default_description{"description"};
static constexpr std::string_view default_no_vendor_id{"EVerest"};
static constexpr std::string_view default_vendor_id{"vendor_id"};
Everest::error::Error test_description(const std::string& type, const std::string& subtype) {
Everest::error::Error error{};
error.type = type;
error.sub_type = subtype;
error.message = "message";
error.description = default_description;
error.vendor_id = default_vendor_id;
error_handler->raise_inoperative_error(error);
EXPECT_EQ(adapter.active_errors.size(), 1);
auto& active = adapter.active_errors.front();
EXPECT_EQ(active.type, "evse_manager/Inoperative");
EXPECT_EQ(active.sub_type, "");
EXPECT_EQ(active.message, error.type);
return active;
}
};
TEST_F(ErrorHandlingTesting, NoType) {
construct(true);
auto error = test_description("", "sub-type");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("", "sub-type");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeNoSlashA) {
construct(true);
auto error = test_description("type", "sub-type");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("type", "sub-type");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeNoSlashB) {
construct(true);
auto error = test_description("type", "");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("type", "");
EXPECT_EQ(error.description, default_description);
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeSlashEndA) {
construct(true);
auto error = test_description("type/", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("type/", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeSlashEndB) {
construct(true);
auto error = test_description("type/", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("type/", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeSlashBeginA) {
construct(true);
auto error = test_description("/type", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("/type", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeSlashBeginB) {
construct(true);
auto error = test_description("/type", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("/type", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeFullA) {
construct(true);
auto error = test_description("module/type", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("module/type", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeFullB) {
construct(true);
auto error = test_description("module/type", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("module/type", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeFullC) {
construct(true);
auto error = test_description("module/type/", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("module/type/", "sub-type");
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, TypeFullD) {
construct(true);
auto error = test_description("module/type/", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_vendor_id);
construct(false);
error = test_description("module/type/", "");
EXPECT_EQ(error.description, "type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, NoVendorId) {
Everest::error::Error raised_error{};
raised_error.type = "module/type";
raised_error.sub_type = "sub-type";
raised_error.message = "message";
raised_error.description = default_description;
raised_error.vendor_id = "";
construct(true);
error_handler->raise_inoperative_error(raised_error);
EXPECT_EQ(adapter.active_errors.size(), 1);
auto& error = adapter.active_errors.front();
EXPECT_EQ(error.type, "evse_manager/Inoperative");
EXPECT_EQ(error.sub_type, "");
EXPECT_EQ(error.message, raised_error.type);
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
construct(false);
error_handler->raise_inoperative_error(raised_error);
EXPECT_EQ(adapter.active_errors.size(), 1);
error = adapter.active_errors.front();
EXPECT_EQ(error.type, "evse_manager/Inoperative");
EXPECT_EQ(error.sub_type, "");
EXPECT_EQ(error.message, raised_error.type);
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, default_no_vendor_id);
}
TEST_F(ErrorHandlingTesting, IsActive) {
Everest::error::Error first_error{};
first_error.type = "module/type";
first_error.sub_type = "sub-type";
first_error.message = "message";
first_error.description = "description";
first_error.vendor_id = "vendor_id";
construct(true);
EXPECT_FALSE(p_evse->error_state_monitor->is_error_active("evse_manager/Inoperative", ""));
error_handler->raise_inoperative_error(first_error);
EXPECT_EQ(adapter.active_errors.size(), 1);
auto error = adapter.active_errors.front();
EXPECT_EQ(error.type, "evse_manager/Inoperative");
EXPECT_EQ(error.sub_type, "");
EXPECT_EQ(error.message, first_error.type);
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, first_error.vendor_id);
EXPECT_TRUE(p_evse->error_state_monitor->is_error_active("evse_manager/Inoperative", ""));
Everest::error::Error raised_error{};
raised_error.type = "module/new-type";
raised_error.sub_type = "new-sub-type";
raised_error.message = "new-message";
raised_error.description = "new-description";
raised_error.vendor_id = "new-vendor_id";
// should not be a new error
error_handler->raise_inoperative_error(raised_error);
EXPECT_EQ(adapter.active_errors.size(), 1);
error = adapter.active_errors.front();
// should be first error
EXPECT_EQ(error.type, "evse_manager/Inoperative");
EXPECT_EQ(error.sub_type, "");
EXPECT_EQ(error.message, first_error.type);
EXPECT_EQ(error.description, "type/sub-type");
EXPECT_EQ(error.vendor_id, first_error.vendor_id);
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink