async_if_test_helper.hxx

// Helper classes for writing unittests testing the entire asynchronous
// stack. Allows to send incoming messages (in gridconnect format) and set
// expectations on messages produced.
//
// Only include this file in unittests.
 
#ifndef _UTILS_ASYNC_IF_TEST_HELPER_HXX_
#define _UTILS_ASYNC_IF_TEST_HELPER_HXX_
 
#include "openlcb/AliasAllocator.hxx"
#include "openlcb/IfCan.hxx"
#include "openlcb/EventService.hxx"
#include "openlcb/DefaultNode.hxx"
#include "openlcb/NodeInitializeFlow.hxx"
#include "executor/CallableFlow.hxx"
#include "nmranet_config.h"
#include "utils/GridConnectHub.hxx"
#include "utils/test_main.hxx"
 
using ::testing::AtLeast;
using ::testing::AtMost;
using ::testing::Eq;
using ::testing::Field;
using ::testing::Invoke;
using ::testing::IsNull;
using ::testing::Mock;
using ::testing::NiceMock;
using ::testing::NotNull;
using ::testing::Pointee;
using ::testing::Return;
using ::testing::StrCaseEq;
using ::testing::StrictMock;
using ::testing::WithArg;
using ::testing::SaveArg;
using ::testing::_;
 
class TrainTestHelper;
 
// void (*g_invoke)(Notifiable *) = &InvokeNotification;
 
HubFlow gc_hub0(&g_service);
CanHubFlow can_hub0(&g_service);
GCAdapterBase *g_gc_adapter = nullptr;
 
HubFlow gc_hub1(&g_service);
CanHubFlow can_hub1(&g_service);
GCAdapterBase *g_gc_adapter1 = nullptr;
 
openlcb::InitializeFlow g_init_flow(&g_service);
 
class MockSend : public HubPort
{
public:
    MockSend()
        : HubPort(&g_service)
    {
    }
 
    MOCK_METHOD1(mwrite, void(const string &s));
 
    virtual Action entry()
    {
        string s(message()->data()->data(), message()->data()->size());
        mwrite(s);
        return release_and_exit();
    }
};
 
void InvokeNotification(Notifiable *done)
{
    done->notify();
}
 
static void print_packet(const string &pkt)
{
    fprintf(stderr, "%s\n", pkt.c_str());
}
 
class AsyncCanTest : public testing::Test
{
public:
    static void SetUpTestCase()
    {
        g_gc_adapter =
            GCAdapterBase::CreateGridConnectAdapter(&gc_hub0, &can_hub0, false);
    }
 
    static void TearDownTestCase()
    {
        delete g_gc_adapter;
    }
 
protected:
    AsyncCanTest()
    {
        gc_hub0.register_port(&canBus_);
    }
 
    ~AsyncCanTest()
    {
        gc_hub0.unregister_port(&canBus_);
        if (printer_.get())
        {
            gc_hub0.unregister_port(printer_.get());
        }
    }
 
    void wait()
    {
        wait_for_main_executor();
    }
 
    void twait()
    {
        wait_for_main_timers();
    }
 
#ifdef __EMSCRIPTEN__
    void usleep(unsigned long usecs) {
        long long deadline = usecs;
        deadline *= 1000;
        deadline += os_get_time_monotonic();
        while (os_get_time_monotonic() < deadline) {
            os_emscripten_yield();
        }
    }
#endif
 
#define expect_packet(gc_packet)                                               \
    EXPECT_CALL(canBus_, mwrite(StrCaseEq(gc_packet)))
 
#define expect_packet_and_send_response(gc_packet, resp_packet)                \
    EXPECT_CALL(canBus_, mwrite(StrCaseEq(gc_packet)))                         \
        .WillOnce(::testing::InvokeWithoutArgs(                                \
            [this]() { send_packet(resp_packet); }))
 
    void expect_any_packet()
    {
        if (!printer_) { print_all_packets(); }
        EXPECT_CALL(canBus_, mwrite(_)).Times(AtLeast(0));
        //.WillRepeatedly(WithArg<0>(Invoke(print_packet)));
    }
 
    void print_all_packets()
    {
        HASSERT(!printer_ && "cannot have more than one print_all_packets call");
        NiceMock<MockSend> *m = new NiceMock<MockSend>();
        EXPECT_CALL(*m, mwrite(_)).Times(AtLeast(0)).WillRepeatedly(
            WithArg<0>(Invoke(print_packet)));
        gc_hub0.register_port(m);
        printer_.reset(m);
    }
 
    void send_packet(const string &gc_packet)
    {
        Buffer<HubData> *packet;
        mainBufferPool->alloc(&packet);
        packet->data()->assign(gc_packet);
        packet->data()->skipMember_ = &canBus_;
        gc_hub0.send(packet);
    }
 
    void clear_expect(bool strict = false)
    {
        Mock::VerifyAndClear(&canBus_);
        if (strict) {
            EXPECT_CALL(canBus_, mwrite(_)).Times(0);
        }
    }
 
#define send_packet_and_expect_response(pkt, resp)                             \
    do                                                                         \
    {                                                                          \
        expect_packet(resp);                                                   \
        send_packet_and_flush_expect(pkt);                                     \
    } while (0)
 
    void send_packet_and_flush_expect(const string &pkt)
    {
        send_packet(pkt);
        wait();
        Mock::VerifyAndClear(&canBus_);
    }
 
    NiceMock<MockSend> canBus_;
    std::unique_ptr<HubPort> printer_;
};
 
class AsyncCan1Test {
protected:
  AsyncCan1Test() { gc_hub1.register_port(&canBus1_); }
  ~AsyncCan1Test() {
    wait_for_main_executor();
    gc_hub1.unregister_port(&canBus1_);
  }
  
  static void SetUpTestCase() {
    g_gc_adapter1 =
        GCAdapterBase::CreateGridConnectAdapter(&gc_hub1, &can_hub1, false);
  }
 
  static void TearDownTestCase() {
    delete g_gc_adapter1;
  }
 
#define expect_packet1(gc_packet) \
  EXPECT_CALL(canBus1_, mwrite(StrCaseEq(gc_packet)))
 
  void send_packet1(const string &gc_packet) {
    Buffer<HubData> *packet;
    mainBufferPool->alloc(&packet);
    packet->data()->assign(gc_packet);
    packet->data()->skipMember_ = &canBus1_;
    gc_hub1.send(packet);
  }
 
  StrictMock<MockSend> canBus1_;
};
 
namespace openlcb
{
 
static const NodeID TEST_NODE_ID = 0x02010d000003ULL;
 
class LocalIf : public If
{
public:
    LocalIf(int local_nodes_count, NodeID gateway_node_id)
        : If(&g_executor, local_nodes_count)
        , gatewayNodeID_(gateway_node_id)
    {
    }
 
    void add_owned_flow(Executable *e) override
    {
        ownedFlows_.emplace_back(e);
    }
 
    void delete_local_node(Node *node) override
    {
        remove_local_node_from_map(node);
    }
 
    bool matching_node(NodeHandle expected, NodeHandle actual) override
    {
        if (expected.id && actual.id)
        {
            return expected.id == actual.id;
        }
        // Cannot reconcile.
        LOG(VERBOSE, "Cannot reconcile expected and actual NodeHandles for "
                     "equality testing.");
        return false;
    }
 
    NodeID get_default_node_id() override
    {
        return gatewayNodeID_;
    }
 
private:
    std::vector<std::unique_ptr<Destructable>> ownedFlows_;
    NodeID gatewayNodeID_;
};
 
class AsyncIfTest : public AsyncCanTest
{
protected:
    static int local_alias_cache_size;
    static int local_node_count;
    static int remote_alias_cache_size;
 
    AsyncIfTest()
        : pendingAliasAllocation_(false)
    {
        ifCan_.reset(new IfCan(&g_executor, &can_hub0, local_alias_cache_size, remote_alias_cache_size, local_node_count));
        run_x([this]() { ifCan_->local_aliases()->add(TEST_NODE_ID, 0x22A); });
        ifCan_->set_alias_allocator(
            new AliasAllocator(TEST_NODE_ID, ifCan_.get()));
 
    }
 
    ~AsyncIfTest()
    {
        wait();
        if (pendingAliasAllocation_)
        {
            run_x([this]() {
                ifCan_->alias_allocator()->TEST_finish_pending_allocation();
            });
            wait();
        }
    }
 
    friend class ::TrainTestHelper;
 
    void create_allocated_alias()
    {
        inject_allocated_alias(0x33A);
        aliasSeed_ = 0x44C;
        pendingAliasAllocation_ = false;
    }
 
    void inject_allocated_alias(NodeAlias alias)
    {
        if (!ifCan_->alias_allocator()) {
            ifCan_->set_alias_allocator(
                new AliasAllocator(TEST_NODE_ID, ifCan_.get()));
        }
        run_x([this, alias]() {
            ifCan_->alias_allocator()->TEST_add_allocated_alias(alias);
        });
    }
 
    void expect_next_alias_allocation(NodeAlias a = 0)
    {
        pendingAliasAllocation_ = true;
        if (!a)
        {
            ifCan_->alias_allocator()->seed_ = aliasSeed_;
            a = aliasSeed_;
            aliasSeed_++;
        }
        EXPECT_CALL(canBus_, mwrite(StringPrintf(":X17020%03XN;", a)))
            .Times(1)
            .RetiresOnSaturation();
        EXPECT_CALL(canBus_, mwrite(StringPrintf(":X1610D%03XN;", a)))
            .Times(1)
            .RetiresOnSaturation();
        EXPECT_CALL(canBus_, mwrite(StringPrintf(":X15000%03XN;", a)))
            .Times(1)
            .RetiresOnSaturation();
        EXPECT_CALL(canBus_, mwrite(StringPrintf(":X14003%03XN;", a)))
            .Times(1)
            .RetiresOnSaturation();
 
        EXPECT_CALL(canBus_, mwrite(StringPrintf(":X10700%03XN;", a)))
            .Times(AtMost(1))
            .RetiresOnSaturation();
    }
 
 
    BarrierNotifiable *get_notifiable()
    {
        bn_.reset(&n_);
        return &bn_;
    }
 
    void wait_for_notification()
    {
        n_.wait_for_notification();
    }
 
    SyncNotifiable n_;
    BarrierNotifiable bn_;
 
    std::unique_ptr<IfCan> ifCan_;
    AliasInfo testAlias_;
    NodeAlias aliasSeed_;
    bool pendingAliasAllocation_;
};
 
int AsyncIfTest::local_alias_cache_size = 10;
int AsyncIfTest::local_node_count = 9;
int AsyncIfTest::remote_alias_cache_size = 10;
 
class AsyncNodeTest : public AsyncIfTest
{
protected:
    AsyncNodeTest()
        : eventService_(ifCan_.get())
    {
        EXPECT_CALL(canBus_, mwrite(":X1910022AN02010D000003;")).Times(1);
        ownedNode_.reset(new DefaultNode(ifCan_.get(), TEST_NODE_ID));
        node_ = ownedNode_.get();
        ifCan_->add_addressed_message_support();
        wait();
        Mock::VerifyAndClear(&canBus_);
        // AddEventHandlerToIf(ifCan_.get());
    }
 
    ~AsyncNodeTest()
    {
        wait_for_event_thread();
    }
 
    void wait_for_event_thread()
    {
        while (EventService::instance->event_processing_pending())
        {
#ifdef __EMSCRIPTEN__
            os_emscripten_yield();
#else
            usleep(100);
#endif
        }
        AsyncIfTest::wait();
    }
 
    EventService eventService_;
    std::unique_ptr<DefaultNode> ownedNode_;
    Node *node_;
};
 
class MockMessageHandler : public MessageHandler
{
public:
    MOCK_METHOD2(handle_message,
                 void(GenMessage *message, unsigned priority));
    virtual void send(Buffer<GenMessage> *message, unsigned priority)
    {
        handle_message(message->data(), priority);
        message->unref();
    }
};
 
MATCHER_P(IsBufferValue, id, "")
{
    uint64_t value = htobe64(id);
    if (arg.size() != 8)
        return false;
    if (memcmp(&value, arg.data(), 8))
        return false;
    return true;
}
 
MATCHER_P(IsBufferValueString, expected, "")
{
    string s(expected);
    return arg == s;
}
 
MATCHER_P(IsBufferNodeValue, id, "")
{
    uint64_t value = htobe64(id);
    if (arg->used() != 6)
        return false;
    const uint8_t *expected = reinterpret_cast<const uint8_t *>(&value) + 2;
    const uint8_t *actual = static_cast<const uint8_t *>(arg->start());
    if (memcmp(expected, actual, 6))
    {
        for (int i = 0; i < 6; ++i)
        {
            if (expected[i] != actual[i])
            {
                LOG(INFO, "mismatch at position %d, expected %02x actual %02x",
                    i, expected[i], actual[i]);
            }
        }
        return false;
    }
    return true;
}
 
MATCHER_P(IsBufferNodeValueString, id, "")
{
    uint64_t value = htobe64(id);
    if (arg.size() != 6)
        return false;
    const uint8_t *expected = reinterpret_cast<const uint8_t *>(&value) + 2;
    const uint8_t *actual = reinterpret_cast<const uint8_t *>(arg.data());
    if (memcmp(expected, actual, 6))
    {
        for (int i = 0; i < 6; ++i)
        {
            if (expected[i] != actual[i])
            {
                LOG(INFO, "mismatch at position %d, expected %02x actual %02x",
                    i, expected[i], actual[i]);
            }
        }
        return false;
    }
    return true;
}
 
} // namespace openlcb
 
#endif // _UTILS_ASYNC_IF_TEST_HELPER_HXX_