coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
John Wellbelove 2021-03-05 09:58:57 +00:00
parent dbfa71944f
commit 11d0005f1b
5 changed files with 185 additions and 718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/etl/file_error_numbers.h
View File

@ -90,5 +90,6 @@ SOFTWARE.
#define ETL_MULTI_LOOP_ID "57"
#define ETL_REFERENCE_COUNTER_MESSAGE_POOL_ID "58"
#define ETL_QUEUE_SPSC_LOCKABLE "59"
#define ETL_MESSAGE_ROUTER_REGISTRY "60"
#endif

145
include/etl/message_router_registry.h
View File

@ -43,31 +43,31 @@ SOFTWARE.
namespace etl
{
////***************************************************************************
///// Base exception class for message router
////***************************************************************************
//class message_router_registry_exception : public etl::exception
//{
//public:
//***************************************************************************
/// Base exception class for message router registry.
//***************************************************************************
class message_router_registry_exception : public etl::exception
{
public:
// message_router_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
// : etl::exception(reason_, file_name_, line_number_)
// {
// }
//};
message_router_registry_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
: etl::exception(reason_, file_name_, line_number_)
{
}
};
////***************************************************************************
///// Router id is out of the legal range.
////***************************************************************************
//class message_router_illegal_id : public etl::message_router_registry_exception
//{
//public:
//***************************************************************************
/// The registry is full.
//***************************************************************************
class message_router_registry_full : public etl::message_router_registry_exception
{
public:
// message_router_illegal_id(string_type file_name_, numeric_type line_number_)
// : message_router_exception(ETL_ERROR_TEXT("message router:illegal id", ETL_FILE"A"), file_name_, line_number_)
// {
// }
//};
message_router_registry_full(string_type file_name_, numeric_type line_number_)
: message_router_registry_exception(ETL_ERROR_TEXT("message router registry:full", ETL_FILE"A"), file_name_, line_number_)
{
}
};
//***************************************************************************
/// This is the base of all message router registries.
@ -76,6 +76,35 @@ namespace etl
{
public:
//********************************************
/// Registers a router.
/// If the resgitry is full then an ETL assert is called.
//********************************************
void register_message_router(etl::imessage_router& router)
{
if (!registry.full())
{
typename IRegistry::value_type element(router.get_message_router_id(), &router);
registry.insert(element);
}
else
{
ETL_ALWAYS_ASSERT(ETL_ERROR(etl::message_router_registry_full));
}
}
//********************************************
/// Unregisters a router.
//********************************************
void unregister_message_router(etl::message_router_id_t id)
{
registry.erase(id);
}
//********************************************
/// Get a pointer to a router that has the specified ID.
/// Returns ETL_NULLPTR if not found.
//********************************************
etl::imessage_router* get_message_router(etl::message_router_id_t id) const
{
@ -92,31 +121,75 @@ namespace etl
}
//********************************************
bool contains(etl::message_router_id_t id) const
/// Returns <b>true</b> if the registry contains a router that has the specified ID.
/// Returns <b>false</b> if not found.
//********************************************
bool contains(const etl::message_router_id_t id) const
{
return registry.find(id) != registry.end();
}
//********************************************
bool register_message_router(etl::imessage_router& router)
/// Returns <b>true</b> if the registry contains the router.
/// Returns <b>false</b> if not found.
//********************************************
bool contains(const etl::imessage_router* const p_router) const
{
if (!registry.full())
{
typename IRegistry::value_type element(router.get_message_router_id(), &router);
registry.insert(element);
return true;
}
else
if (p_router == ETL_NULLPTR)
{
return false;
}
return registry.find(p_router->get_message_router_id()) != registry.end();
}
//********************************************
void unregister_message_router(etl::message_router_id_t id)
/// Returns <b>true</b> if the registry contains the router.
/// Returns <b>false</b> if not found.
//********************************************
bool contains(const etl::imessage_router& router) const
{
registry.erase(id);
return registry.find(router.get_message_router_id()) != registry.end();
}
//********************************************
/// Returns <b>true</b> if the registry is empty, otherwise <b>false</b>.
//********************************************
bool empty() const
{
return registry.empty();
}
//********************************************
/// Returns <b>true</b> if the registry is full, otherwise <b>false</b>.
//********************************************
bool full() const
{
return registry.full();
}
//********************************************
/// Returns the size of the registry.
//********************************************
size_t size() const
{
return registry.size();
}
//********************************************
/// Returns the available size of the registry.
//********************************************
size_t available() const
{
return registry.available();
}
//********************************************
/// Returns the maximum size of the registry.
//********************************************
size_t max_size() const
{
return registry.max_size();
}
protected:
@ -129,7 +202,7 @@ namespace etl
{
}
private:
private:
IRegistry& registry;
};
@ -144,7 +217,7 @@ namespace etl
//********************************************
message_router_registry()
: message_router_registry(registry)
: imessage_router_registry(registry)
{
}

753
test/test_message_router_registry.cpp
View File

@ -29,6 +29,7 @@ SOFTWARE.
#include "unit_test_framework.h"
#include "etl/message_router.h"
#include "etl/message_router_registry.h"
//***************************************************************************
// The set of messages.
@ -37,731 +38,119 @@ namespace
{
enum
{
MESSAGE1,
MESSAGE2,
MESSAGE3,
MESSAGE4,
MESSAGE5
ROUTER1 = 10,
ROUTER2 = 20,
ROUTER3 = 30,
ROUTER4 = 40
};
enum
{
ROUTER1 = 1,
ROUTER2 = 2,
ROUTER3 = 3,
ROUTER4 = 4,
ROUTER5 = 5
};
constexpr size_t Registry_Size = 4U;
struct Message1 : public etl::message<MESSAGE1>
{
Message1(etl::imessage_router& callback_)
: callback(callback_)
{
}
etl::imessage_router& callback;
};
struct Message2 : public etl::message<MESSAGE2>
{
Message2(etl::imessage_router& callback_)
: callback(callback_)
{
}
etl::imessage_router& callback;
};
struct Message3 : public etl::message<MESSAGE3>
{
Message3(etl::imessage_router& callback_)
: callback(callback_)
{
}
etl::imessage_router& callback;
int value[10];
};
struct Message4 : public etl::message<MESSAGE4>
{
Message4(etl::imessage_router& callback_)
: callback(callback_)
{
}
etl::imessage_router& callback;
};
struct Response : public etl::message<MESSAGE5>
struct Message1 : public etl::message<1>
{
};
Response response;
int call_order;
//***************************************************************************
// Router that handles messages 1, 2, 3, 4, 5.
// Router1
//***************************************************************************
class RouterA : public etl::message_router<RouterA, Message1, Message2, Message3, Message4, Response>
class Router1 : public etl::message_router<Router1, Message1>
{
public:
RouterA(etl::message_router_id_t id)
: message_router(id),
message1_count(0),
message2_count(0),
message3_count(0),
message4_count(0),
message5_count(0),
message_unknown_count(0)
Router1()
: message_router(ROUTER1)
{
}
void on_receive(const Message1& msg)
{
++message1_count;
etl::send_message(msg.callback, response);
order = call_order++;
}
void on_receive(const Message2& msg)
{
++message2_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Message3& msg)
{
++message3_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Message4& msg)
{
++message4_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Response&)
{
++message5_count;
}
void on_receive_unknown(const etl::imessage&)
{
++message_unknown_count;
}
int message1_count;
int message2_count;
int message3_count;
int message4_count;
int message5_count;
int message_unknown_count;
int order;
};
//***************************************************************************
// Router that handles messages 1, 2, 4 and 5 and returns nothing.
// Router2
//***************************************************************************
class RouterB : public etl::message_router<RouterB, Message1, Message2, Message4, Response>
class Router2 : public etl::message_router<Router2, Message1>
{
public:
RouterB(etl::message_router_id_t id)
: message_router(id),
message1_count(0),
message2_count(0),
message4_count(0),
message5_count(0),
message_unknown_count(0)
Router2()
: message_router(ROUTER2)
{
}
void on_receive(const Message1& msg)
{
++message1_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Message2& msg)
void on_receive_unknown(const etl::imessage&)
{
++message2_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Message4& msg)
{
++message4_count;
etl::send_message(msg.callback, response);
}
void on_receive(const Response&)
{
++message5_count;
}
void on_receive_unknown(const etl::imessage& msg)
{
++message_unknown_count;
//etl::send_message(msg.callback, response);
}
int message1_count;
int message2_count;
int message4_count;
int message5_count;
int message_unknown_count;
};
SUITE(test_message_router)
//***************************************************************************
// Router3
//***************************************************************************
class Router3 : public etl::message_router<Router2, Message1>
{
public:
Router3()
: message_router(ROUTER3)
{
}
void on_receive(const Message1& msg)
{
}
void on_receive_unknown(const etl::imessage&)
{
}
};
//***************************************************************************
// Router4
//***************************************************************************
class Router4 : public etl::message_router<Router4, Message1>
{
public:
Router4()
: message_router(ROUTER4)
{
}
void on_receive(const Message1& msg)
{
}
void on_receive_unknown(const etl::imessage&)
{
}
};
Router1 router1;
Router2 router2;
Router3 router3;
Router4 router4;
SUITE(test_message_router_registry)
{
//*************************************************************************
TEST(message_bus_subscribe_unsubscribe)
TEST(test_default_construction)
{
etl::message_bus<2> bus1;
etl::message_router_registry<Registry_Size> registry;
RouterA router1(0);
RouterB router2(1);
RouterA router3(2);
CHECK_EQUAL(0U, bus1.size());
CHECK_NO_THROW(bus1.subscribe(router1));
CHECK_EQUAL(1U, bus1.size());
CHECK_NO_THROW(bus1.subscribe(router2));
CHECK_EQUAL(2U, bus1.size());
CHECK_THROW(bus1.subscribe(router3), etl::message_bus_too_many_subscribers);
CHECK_EQUAL(2U, bus1.size());
bus1.unsubscribe(router1);
CHECK_EQUAL(1U, bus1.size());
// Erase router not in list.
bus1.unsubscribe(router3);
CHECK_EQUAL(1U, bus1.size());
// Erase using id.
bus1.unsubscribe(router2.get_message_router_id());
CHECK_EQUAL(0U, bus1.size());
// Erase router from empty list.
bus1.unsubscribe(router2);
CHECK_EQUAL(0U, bus1.size());
}
//*************************************************************************
TEST(message_bus_subscribe_unsubscribe_sub_bus)
{
etl::message_bus<4> bus1;
etl::message_bus<2> bus2;
etl::message_bus<3> bus3;
RouterA router1(ROUTER1);
RouterA router2(ROUTER2);
RouterA router3(ROUTER3);
RouterA router4(ROUTER4);
bus1.subscribe(bus2);
bus1.subscribe(router1);
bus1.subscribe(bus3);
bus1.subscribe(router2);
bus2.subscribe(router3);
bus3.subscribe(router4);
CHECK_EQUAL(4U, bus1.size());
bus1.unsubscribe(etl::imessage_bus::MESSAGE_BUS);
CHECK_EQUAL(2U, bus1.size());
bus1.unsubscribe(etl::imessage_bus::ALL_MESSAGE_ROUTERS);
CHECK_EQUAL(0U, bus1.size());
}
//*************************************************************************
TEST(message_bus_broadcast)
{
etl::message_bus<2> bus1;
RouterA router1(ROUTER1);
RouterB router2(ROUTER2);
RouterA callback(ROUTER3);
bus1.subscribe(router1);
bus1.subscribe(router2);
Message1 message1(callback);
Message2 message2(callback);
Message3 message3(callback);
Message4 message4(callback);
bus1.receive(message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(2, callback.message5_count);
bus1.receive(message2);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(4, callback.message5_count);
bus1.receive(message3);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(5, callback.message5_count);
// Use global function.
etl::send_message(bus1, message4);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(1, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(1, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(7, callback.message5_count);
}
//*************************************************************************
TEST(message_bus_broadcast_as_router)
{
etl::message_bus<2> bus1;
RouterA router1(ROUTER1);
RouterB router2(ROUTER2);
RouterA callback(ROUTER3);
bus1.subscribe(router1);
bus1.subscribe(router2);
Message1 message1(callback);
Message2 message2(callback);
Message3 message3(callback);
Message4 message4(callback);
// Reference to router sub-type
etl::imessage_router& irouter = bus1;
irouter.receive(message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(2, callback.message5_count);
irouter.receive(message2);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(4, callback.message5_count);
irouter.receive(message3);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(5, callback.message5_count);
// Use global function.
etl::send_message(irouter, message4);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(1, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(1, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(1, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(7, callback.message5_count);
}
//*************************************************************************
TEST(message_bus_addressed)
{
etl::message_bus<2> bus1;
RouterA router1(ROUTER1);
RouterB router2(ROUTER2);
RouterA callback(ROUTER3);
bus1.subscribe(router1);
bus1.subscribe(router2);
Message1 message1(callback);
Message2 message2(callback);
Message3 message3(callback);
Message4 message4(callback);
bus1.receive(ROUTER1, message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(0, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(1, callback.message5_count);
bus1.receive(ROUTER2, message2);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(0, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(2, callback.message5_count);
bus1.receive(ROUTER1, message3);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(0, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(3, callback.message5_count);
// Use global function.
etl::send_message(bus1, ROUTER2, message4);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(0, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(1, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(4, callback.message5_count);
// Send to a router not subscribed to the bus.
bus1.receive(ROUTER5, message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(1, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(0, router2.message1_count);
CHECK_EQUAL(1, router2.message2_count);
CHECK_EQUAL(1, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(4, callback.message5_count);
}
//*************************************************************************
TEST(message_bus_addressed_duplicate_router_id)
{
etl::message_bus<3> bus1;
RouterA router1(ROUTER1);
RouterB router2(ROUTER1);
RouterB router3(ROUTER2);
RouterA callback(ROUTER3);
bus1.subscribe(router1);
bus1.subscribe(router2);
bus1.subscribe(router3);
Message1 message1(callback);
Message2 message2(callback);
Message3 message3(callback);
bus1.receive(ROUTER1, message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(0, router3.message1_count);
CHECK_EQUAL(0, router3.message2_count);
CHECK_EQUAL(0, router3.message4_count);
CHECK_EQUAL(0, router3.message5_count);
CHECK_EQUAL(0, router3.message_unknown_count);
CHECK_EQUAL(2, callback.message5_count);
}
//*************************************************************************
TEST(message_bus_broadcast_addressed_sub_bus)
{
etl::message_bus<3> bus1;
etl::message_bus<2> bus2;
RouterA router1(ROUTER1);
RouterA router2(ROUTER2);
RouterA router3(ROUTER3);
RouterA router4(ROUTER4);
RouterA callback(ROUTER5);
bus1.subscribe(router1);
bus1.subscribe(router2);
bus1.subscribe(bus2);
bus2.subscribe(router3);
bus2.subscribe(router4);
Message1 message1(callback);
Message2 message2(callback);
Message3 message3(callback);
Message4 message4(callback);
// Broadcast to bus1
bus1.receive(message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(1, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(1, router3.message1_count);
CHECK_EQUAL(0, router3.message2_count);
CHECK_EQUAL(0, router3.message4_count);
CHECK_EQUAL(0, router3.message5_count);
CHECK_EQUAL(0, router3.message_unknown_count);
CHECK_EQUAL(1, router4.message1_count);
CHECK_EQUAL(0, router4.message2_count);
CHECK_EQUAL(0, router4.message4_count);
CHECK_EQUAL(0, router4.message5_count);
CHECK_EQUAL(0, router4.message_unknown_count);
CHECK_EQUAL(4, callback.message5_count);
// Addressed to ROUTER2
bus1.receive(ROUTER2, message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(2, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(1, router3.message1_count);
CHECK_EQUAL(0, router3.message2_count);
CHECK_EQUAL(0, router3.message4_count);
CHECK_EQUAL(0, router3.message5_count);
CHECK_EQUAL(0, router3.message_unknown_count);
CHECK_EQUAL(1, router4.message1_count);
CHECK_EQUAL(0, router4.message2_count);
CHECK_EQUAL(0, router4.message4_count);
CHECK_EQUAL(0, router4.message5_count);
CHECK_EQUAL(0, router4.message_unknown_count);
CHECK_EQUAL(5, callback.message5_count);
// Addressed to ROUTER3 via bus2
bus1.receive(ROUTER3, message1);
CHECK_EQUAL(1, router1.message1_count);
CHECK_EQUAL(0, router1.message2_count);
CHECK_EQUAL(0, router1.message3_count);
CHECK_EQUAL(0, router1.message4_count);
CHECK_EQUAL(0, router1.message5_count);
CHECK_EQUAL(0, router1.message_unknown_count);
CHECK_EQUAL(2, router2.message1_count);
CHECK_EQUAL(0, router2.message2_count);
CHECK_EQUAL(0, router2.message4_count);
CHECK_EQUAL(0, router2.message5_count);
CHECK_EQUAL(0, router2.message_unknown_count);
CHECK_EQUAL(2, router3.message1_count);
CHECK_EQUAL(0, router3.message2_count);
CHECK_EQUAL(0, router3.message4_count);
CHECK_EQUAL(0, router3.message5_count);
CHECK_EQUAL(0, router3.message_unknown_count);
CHECK_EQUAL(1, router4.message1_count);
CHECK_EQUAL(0, router4.message2_count);
CHECK_EQUAL(0, router4.message4_count);
CHECK_EQUAL(0, router4.message5_count);
CHECK_EQUAL(0, router4.message_unknown_count);
CHECK_EQUAL(6, callback.message5_count);
}
//*************************************************************************
TEST(message_bus_broadcast_order)
{
etl::message_bus<4> bus1;
etl::message_bus<2> bus2;
etl::message_bus<2> bus3;
RouterA router1(ROUTER1);
RouterA router2(ROUTER2);
RouterA router3(ROUTER3);
RouterA router4a(ROUTER4);
RouterA router4b(ROUTER4);
RouterA callback(ROUTER5);
bus1.subscribe(router1);
bus1.subscribe(bus3);
bus1.subscribe(bus2);
bus1.subscribe(router2);
bus2.subscribe(router3);
bus3.subscribe(router4b);
bus3.subscribe(router4a);
Message1 message1(callback);
call_order = 0;
bus1.receive(message1);
CHECK_EQUAL(0, router1.order);
CHECK_EQUAL(1, router2.order);
CHECK_EQUAL(2, router4b.order);
CHECK_EQUAL(3, router4a.order);
CHECK_EQUAL(4, router3.order);
CHECK(registry.empty());
CHECK(!registry.full());
CHECK_EQUAL(0U, registry.size());
CHECK_EQUAL(Registry_Size, registry.available());
CHECK_EQUAL(Registry_Size, registry.max_size());
}
};
}

1
test/vs2019/etl.vcxproj
View File

@ -1544,6 +1544,7 @@
<ClCompile Include="..\test_list_shared_pool.cpp" />
<ClCompile Include="..\test_make_string.cpp" />
<ClCompile Include="..\test_message_packet.cpp" />
<ClCompile Include="..\test_message_router_registry.cpp" />
<ClCompile Include="..\test_multi_array.cpp" />
<ClCompile Include="..\test_array.cpp">
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../unittest-cpp</AdditionalIncludeDirectories>

3
test/vs2019/etl.vcxproj.filters
View File

@ -1508,6 +1508,9 @@
<ClCompile Include="..\test_state_chart_with_rvalue_data_parameter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_message_router_registry.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">