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
etl/test/test_message_router.cpp
John Wellbelove 97a6e6a035 Squashed commit of the following: 
commit 04ba91bcccc8e12867962bc3746665f430672a23
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Sat Feb 6 10:43:34 2021 +0000

    Updated shared message unit test

commit fababc5cf748073464b4294a50c201cb0aa4fa13
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Fri Feb 5 09:41:52 2021 +0000

    Updated FSM generator

commit ff287bcf0a833ca70933354b42b8b036b422ff81
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Fri Feb 5 09:35:56 2021 +0000

    Updated message router generator

commit 52724e1e62b55dad81e2f80dd656026d828b3214
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Thu Feb 4 13:06:50 2021 +0000

    Updated unit tests

commit 0d89105262aa050577ccc17ddc6eece9f4fc5d18
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Tue Feb 2 20:09:35 2021 +0000

    Interim commit

commit ce8385ff24826103c7a55267ccf3f8a31f517e0b
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Tue Feb 2 18:13:29 2021 +0000

    Squashed commit of the following:

    commit 007b56d03513887636b84fc246e57d6c4f8b777e
    Author: John Wellbelove <github@wellbelove.co.uk>
    Date:   Tue Feb 2 18:09:51 2021 +0000

        Squashed commit of the following:

        commit 6107c4538be149137209d85e5f41031291bc7150
        Author: John Wellbelove <github@wellbelove.co.uk>
        Date:   Tue Feb 2 12:15:31 2021 +0000

            Added move constructor and move assignment to etl::shared_message

        commit c9a5716012db9b614ea67660ebf64dcb790ce571
        Author: John Wellbelove <github@wellbelove.co.uk>
        Date:   Sun Jan 31 12:36:29 2021 +0000

            Squashed commit of the following:

            commit e5f4eb6fb38c337c82fcc250f17a8f21eb788975
            Author: John Wellbelove <github@wellbelove.co.uk>
            Date:   Sun Jan 31 12:34:49 2021 +0000

                Squashed commit of the following:

                commit 23c5f1d3f9b13ff9e46ce3de96aefeb655d5ed97
                Author: John Wellbelove <github@wellbelove.co.uk>
                Date:   Sun Jan 31 12:32:35 2021 +0000

                    Fixed rollover error for etl::queue_spsc_atomic

                    Added 'required_alignment' parameter to 'allocate' for etl::imemeory_block_allocator.
                    Updated QueuedMessageRouter example

    commit e5f4eb6fb38c337c82fcc250f17a8f21eb788975
    Author: John Wellbelove <github@wellbelove.co.uk>
    Date:   Sun Jan 31 12:34:49 2021 +0000

        Squashed commit of the following:

        commit 23c5f1d3f9b13ff9e46ce3de96aefeb655d5ed97
        Author: John Wellbelove <github@wellbelove.co.uk>
        Date:   Sun Jan 31 12:32:35 2021 +0000

            Fixed rollover error for etl::queue_spsc_atomic

            Added 'required_alignment' parameter to 'allocate' for etl::imemeory_block_allocator.
            Updated QueuedMessageRouter example

commit c9a5716012db9b614ea67660ebf64dcb790ce571
Author: John Wellbelove <github@wellbelove.co.uk>
Date:   Sun Jan 31 12:36:29 2021 +0000

    Squashed commit of the following:

    commit e5f4eb6fb38c337c82fcc250f17a8f21eb788975
    Author: John Wellbelove <github@wellbelove.co.uk>
    Date:   Sun Jan 31 12:34:49 2021 +0000

        Squashed commit of the following:

        commit 23c5f1d3f9b13ff9e46ce3de96aefeb655d5ed97
        Author: John Wellbelove <github@wellbelove.co.uk>
        Date:   Sun Jan 31 12:32:35 2021 +0000

            Fixed rollover error for etl::queue_spsc_atomic

            Added 'required_alignment' parameter to 'allocate' for etl::imemeory_block_allocator.
            Updated QueuedMessageRouter example
2021-02-07 11:02:49 +00:00

582 lines
17 KiB
C++
Raw Blame History

/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2017 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "UnitTest++/UnitTest++.h"
#include "ExtraCheckMacros.h"
#include "etl/message_router.h"
#include "etl/queue.h"
#include "etl/largest.h"
//***************************************************************************
// The set of messages.
//***************************************************************************
namespace
{
enum
{
MESSAGE1,
MESSAGE2,
MESSAGE3,
MESSAGE4,
MESSAGE5
};
enum
{
ROUTER1,
ROUTER2,
ROUTER3
};
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 Message5 : public etl::message<MESSAGE5>
{
};
Message5 message5;
//***************************************************************************
// Router that handles messages 1, 2, 3, 4 and 5 and returns nothing.
//***************************************************************************
class Router1 : public etl::message_router<Router1, Message1, Message2, Message3, Message4, Message5>
{
public:
Router1()
: message_router(ROUTER1),
message1_count(0),
message2_count(0),
message3_count(0),
message4_count(0),
message_unknown_count(0),
callback_count(0)
{
}
void on_receive(const Message1& msg)
{
++message1_count;
etl::send_message(msg.callback, message5);
}
void on_receive(const Message2& msg)
{
++message2_count;
etl::send_message(msg.callback, message5);
}
void on_receive(const Message3& msg)
{
++message3_count;
etl::send_message(msg.callback, message5);
}
void on_receive(const Message4& msg)
{
++message4_count;
etl::send_message(msg.callback, message5);
}
void on_receive(const Message5&)
{
++callback_count;
}
void on_receive_unknown(const etl::imessage&)
{
++message_unknown_count;
}
int message1_count;
int message2_count;
int message3_count;
int message4_count;
int message_unknown_count;
int callback_count;
};
//***************************************************************************
// Router that handles messages 1, 2, 4 and 5 and returns nothing.
//***************************************************************************
class Router2 : public etl::message_router<Router2, Message1, Message2, Message4, Message5>
{
public:
Router2()
: message_router(ROUTER2),
message1_count(0),
message2_count(0),
message4_count(0),
message_unknown_count(0),
callback_count(0),
sender_id(0)
{
}
void on_receive(const Message1& msg)
{
++message1_count;
sender_id = msg.callback.get_message_router_id();
etl::send_message(msg.callback, message5);
}
void on_receive(const Message2& msg)
{
++message2_count;
sender_id = msg.callback.get_message_router_id();
etl::send_message(msg.callback, message5);
}
void on_receive(const Message4& msg)
{
++message4_count;
sender_id = msg.callback.get_message_router_id();
etl::send_message(msg.callback, message5);
}
void on_receive(const Message5& msg)
{
++callback_count;
}
void on_receive_unknown(const etl::imessage&)
{
++message_unknown_count;
sender_id = 0;
}
int message1_count;
int message2_count;
int message4_count;
int message_unknown_count;
int callback_count;
int sender_id;
};
etl::imessage_router* p_router;
SUITE(test_message_router)
{
//*************************************************************************
TEST(message_router)
{
Router1 r1;
Router2 r2;
p_router = &r1;
Message1 message1(r2);
Message2 message2(r2);
Message3 message3(r2);
Message4 message4(r2);
// CHECK(!r1.is_null_router());
CHECK(r1.is_producer());
CHECK(r1.is_consumer());
p_router->receive(message1);
CHECK_EQUAL(1, r1.message1_count);
CHECK_EQUAL(0, r1.message2_count);
CHECK_EQUAL(0, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
CHECK_EQUAL(1, r2.callback_count);
p_router->receive(message2);
CHECK_EQUAL(1, r1.message1_count);
CHECK_EQUAL(1, r1.message2_count);
CHECK_EQUAL(0, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
CHECK_EQUAL(2, r2.callback_count);
p_router->receive(message3);
CHECK_EQUAL(1, r1.message1_count);
CHECK_EQUAL(1, r1.message2_count);
CHECK_EQUAL(1, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
CHECK_EQUAL(3, r2.callback_count);
p_router->receive(message4);
CHECK_EQUAL(1, r1.message1_count);
CHECK_EQUAL(1, r1.message2_count);
CHECK_EQUAL(1, r1.message3_count);
CHECK_EQUAL(1, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
CHECK_EQUAL(4, r2.callback_count);
}
//*************************************************************************
TEST(message_null_router)
{
Router2 router;
etl::null_message_router null_router;
Message1 message1(null_router);
Message2 message2(null_router);
Message3 message3(null_router);
Message4 message4(null_router);
// CHECK(null_router.is_null_router());
CHECK(!null_router.is_producer());
CHECK(!null_router.is_consumer());
// Send from the null router.
etl::send_message(router, message1);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(0, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(0, router.message_unknown_count);
etl::send_message(router, message2);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(0, router.message_unknown_count);
etl::send_message(router, message3);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(router, message4);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
// Send to the null router.
etl::send_message(null_router, message1);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(null_router, message2);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(null_router, message3);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(null_router, message4);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
}
//*************************************************************************
TEST(message_producer)
{
Router2 router;
etl::message_producer producer(ROUTER3);
Message1 message1(producer);
Message2 message2(producer);
Message3 message3(producer);
Message4 message4(producer);
// CHECK(!producer.is_null_router());
CHECK(producer.is_producer());
CHECK(!producer.is_consumer());
CHECK_EQUAL(0, router.sender_id);
// Send from the producer.
etl::send_message(router, message1);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(0, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(0, router.message_unknown_count);
CHECK_EQUAL(ROUTER3, router.sender_id);
etl::send_message(router, message2);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(0, router.message_unknown_count);
CHECK_EQUAL(ROUTER3, router.sender_id);
etl::send_message(router, message3);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(0, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
CHECK_EQUAL(0, router.sender_id);
etl::send_message(router, message4);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
CHECK_EQUAL(ROUTER3, router.sender_id);
// Send to the producer.
etl::send_message(producer, message1);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(producer, message2);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(producer, message3);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
etl::send_message(producer, message4);
CHECK_EQUAL(1, router.message1_count);
CHECK_EQUAL(1, router.message2_count);
CHECK_EQUAL(1, router.message4_count);
CHECK_EQUAL(1, router.message_unknown_count);
}
//*************************************************************************
TEST(message_router_accepts)
{
Router2 r2;
etl::null_message_router null_router;
Message1 message1(null_router);
Message2 message2(null_router);
Message3 message3(null_router);
Message4 message4(null_router);
CHECK(r2.accepts(message1));
CHECK(r2.accepts(message1.get_message_id()));
CHECK(r2.accepts(message2));
CHECK(r2.accepts(message2.get_message_id()));
CHECK(!r2.accepts(message3));
CHECK(!r2.accepts(message3.get_message_id()));
CHECK(r2.accepts(message4));
CHECK(r2.accepts(message4.get_message_id()));
CHECK(r2.accepts(message5));
CHECK(r2.accepts(message5.get_message_id()));
}
//*************************************************************************
TEST(message_router_queue)
{
Router1 r1;
Router2 r2;
typedef Router2::message_packet Packet;
typedef etl::queue<Packet, 4> Queue;
Queue queue;
etl::imessage* im;
Message1 message1(r1);
Message2 message2(r1);
Message3 message3(r1);
Message4 message4(r1);
// Queue some messages in the message packet queue.
im = &message1;
queue.emplace(*im);
im = &message2;
queue.emplace(*im);
// The router2 queue doesn't accept Message3 types.
im = &message3;
CHECK_THROW(queue.emplace(*im), etl::unhandled_message_exception);
im = &message4;
queue.emplace(*im);
im = &message4;
queue.emplace(*im);
etl::imessage& imr1 = queue.front().get();
r2.receive(imr1);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(0, r2.message2_count);
CHECK_EQUAL(0, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(1, r1.callback_count);
queue.pop();
etl::imessage& imr2 = queue.front().get();
r2.receive(imr2);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(0, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(2, r1.callback_count);
queue.pop();
const etl::imessage& imr3 = queue.front().get();
r2.receive(imr3);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(1, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(3, r1.callback_count);
queue.pop();
const Queue& crqueue = queue;
const etl::imessage& imr4 = crqueue.front().get();
r2.receive(imr4);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(2, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(4, r1.callback_count);
queue.pop();
}
//*************************************************************************
TEST(message_router_successor)
{
Router1 r1;
Router2 r2;
etl::null_message_router null_router;
Message1 message1(r2);
Message2 message2(r2);
Message3 message3(r2);
Message4 message4(r2);
r2.set_successor(r1);
etl::send_message(r2, message1);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(0, r2.message2_count);
CHECK_EQUAL(0, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(0, r1.message1_count);
CHECK_EQUAL(0, r1.message2_count);
CHECK_EQUAL(0, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
etl::send_message(r2, message2);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(0, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(0, r1.message1_count);
CHECK_EQUAL(0, r1.message2_count);
CHECK_EQUAL(0, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
etl::send_message(r2, message3);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(0, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(0, r1.message1_count);
CHECK_EQUAL(0, r1.message2_count);
CHECK_EQUAL(1, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
etl::send_message(r2, message4);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(1, r2.message2_count);
CHECK_EQUAL(1, r2.message4_count);
CHECK_EQUAL(0, r2.message_unknown_count);
CHECK_EQUAL(0, r1.message1_count);
CHECK_EQUAL(0, r1.message2_count);
CHECK_EQUAL(1, r1.message3_count);
CHECK_EQUAL(0, r1.message4_count);
CHECK_EQUAL(0, r1.message_unknown_count);
}
};
}
Reference in New Issue View Git Blame Copy Permalink