Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-21 01:01:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

[ntcore] Unify listeners (#4536)

Browse Source 
This combines all 4 NT listener APIs (topic, value, connection, and
logging) into a single unified listener API.
This commit is contained in:
Peter Johnson
2022-10-31 21:52:14 -07:00
committed by GitHub
parent 32fbfb7da6
commit b114006543
71 changed files with 3613 additions and 5786 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
ntcore/src/test/native/cpp/ConnectionListenerTest.cpp
View File

@@ -49,10 +49,10 @@ void ConnectionListenerTest::Connect(const char* address, unsigned int port3,
TEST_F(ConnectionListenerTest, Polled) {
// set up the poller
NT_ConnectionListenerPoller poller =
nt::CreateConnectionListenerPoller(server_inst);
NT_ListenerPoller poller = nt::CreateListenerPoller(server_inst);
ASSERT_NE(poller, 0u);
NT_ConnectionListener handle = nt::AddPolledConnectionListener(poller, false);
NT_Listener handle =
nt::AddPolledListener(poller, server_inst, nt::EventFlags::kConnection);
ASSERT_NE(handle, 0u);
// trigger a connect event
@@ -62,10 +62,11 @@ TEST_F(ConnectionListenerTest, Polled) {
bool timed_out = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timed_out));
ASSERT_FALSE(timed_out);
auto result = nt::ReadConnectionListenerQueue(poller);
auto result = nt::ReadListenerQueue(poller);
ASSERT_EQ(result.size(), 1u);
EXPECT_EQ(handle, result[0].listener);
EXPECT_TRUE(result[0].connected);
EXPECT_TRUE(result[0].GetConnectionInfo());
EXPECT_EQ(result[0].flags, nt::EventFlags::kConnected);
// trigger a disconnect event
nt::StopClient(client_inst);
@@ -75,10 +76,11 @@ TEST_F(ConnectionListenerTest, Polled) {
timed_out = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timed_out));
ASSERT_FALSE(timed_out);
result = nt::ReadConnectionListenerQueue(poller);
result = nt::ReadListenerQueue(poller);
ASSERT_EQ(result.size(), 1u);
EXPECT_EQ(handle, result[0].listener);
EXPECT_FALSE(result[0].connected);
EXPECT_TRUE(result[0].GetConnectionInfo());
EXPECT_EQ(result[0].flags, nt::EventFlags::kDisconnected);
}
class ConnectionListenerVariantTest
@@ -87,12 +89,12 @@ class ConnectionListenerVariantTest
TEST_P(ConnectionListenerVariantTest, Threaded) {
wpi::mutex m;
std::vector<nt::ConnectionNotification> result;
auto handle = nt::AddConnectionListener(
server_inst, false, [&](const nt::ConnectionNotification& event) {
std::scoped_lock lock{m};
result.push_back(event);
});
std::vector<nt::Event> result;
auto handle = nt::AddListener(server_inst, nt::EventFlags::kConnection,
[&](auto& event) {
std::scoped_lock lock{m};
result.push_back(event);
});
// trigger a connect event
Connect(GetParam().first, 0, 20001 + GetParam().second);
@@ -106,7 +108,8 @@ TEST_P(ConnectionListenerVariantTest, Threaded) {
std::scoped_lock lock{m};
ASSERT_EQ(result.size(), 1u);
EXPECT_EQ(handle, result[0].listener);
EXPECT_TRUE(result[0].connected);
EXPECT_TRUE(result[0].GetConnectionInfo());
EXPECT_EQ(result[0].flags, nt::EventFlags::kConnected);
result.clear();
}
@@ -115,14 +118,15 @@ TEST_P(ConnectionListenerVariantTest, Threaded) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
// wait for thread
nt::WaitForConnectionListenerQueue(server_inst, 1.0);
nt::WaitForListenerQueue(server_inst, 1.0);
// get the event
{
std::scoped_lock lock{m};
ASSERT_EQ(result.size(), 1u);
EXPECT_EQ(handle, result[0].listener);
EXPECT_FALSE(result[0].connected);
EXPECT_TRUE(result[0].GetConnectionInfo());
EXPECT_EQ(result[0].flags, nt::EventFlags::kDisconnected);
}
}

4
ntcore/src/test/native/cpp/LocalStorageTest.cpp
View File

@@ -3,6 +3,7 @@
// the WPILib BSD license file in the root directory of this project.
#include "LocalStorage.h"
#include "MockListenerStorage.h"
#include "MockLogger.h"
#include "PubSubOptionsMatcher.h"
#include "SpanMatcher.h"
@@ -36,7 +37,8 @@ class LocalStorageTest : public ::testing::Test {
::testing::StrictMock<net::MockNetworkStartupInterface> startup;
::testing::StrictMock<net::MockNetworkInterface> network;
wpi::MockLogger logger;
LocalStorage storage{0, logger};
MockListenerStorage listenerStorage;
LocalStorage storage{0, listenerStorage, logger};
NT_Topic fooTopic{storage.GetTopic("foo")};
NT_Topic barTopic{storage.GetTopic("bar")};
NT_Topic bazTopic{storage.GetTopic("baz")};

96
ntcore/src/test/native/cpp/LoggerTest.cpp Normal file
View File

@@ -0,0 +1,96 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/Synchronization.h>
#include "Handle.h"
#include "TestPrinters.h"
#include "gtest/gtest.h"
#include "ntcore_cpp.h"
class LoggerTest : public ::testing::Test {
public:
LoggerTest() : m_inst(nt::CreateInstance()) {}
~LoggerTest() override { nt::DestroyInstance(m_inst); }
void Generate();
void Check(const std::vector<nt::Event>& events, NT_Listener handle,
bool infoMsg, bool errMsg);
protected:
NT_Inst m_inst;
};
void LoggerTest::Generate() {
// generate info message
nt::StartClient4(m_inst, "");
// generate error message
nt::Publish(nt::Handle(nt::Handle{m_inst}.GetInst(), 5, nt::Handle::kTopic),
NT_DOUBLE, "");
}
void LoggerTest::Check(const std::vector<nt::Event>& events, NT_Listener handle,
bool infoMsg, bool errMsg) {
size_t count = (infoMsg ? 1u : 0u) + (errMsg ? 1u : 0u);
ASSERT_EQ(events.size(), count);
for (size_t i = 0; i < count; ++i) {
ASSERT_EQ(events[i].listener, handle);
ASSERT_EQ(events[i].flags & nt::EventFlags::kLogMessage,
nt::EventFlags::kLogMessage);
auto log = events[i].GetLogMessage();
ASSERT_TRUE(log);
if (infoMsg) {
ASSERT_EQ(log->message, "starting network client");
ASSERT_EQ(log->level, NT_LOG_INFO);
infoMsg = false;
} else if (errMsg) {
ASSERT_EQ(log->message,
"trying to publish invalid topic handle (386924549)");
ASSERT_EQ(log->level, NT_LOG_ERROR);
errMsg = false;
}
}
}
TEST_F(LoggerTest, DefaultLogRange) {
auto poller = nt::CreateListenerPoller(m_inst);
auto handle =
nt::AddPolledListener(poller, m_inst, nt::EventFlags::kLogMessage);
Generate();
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadListenerQueue(poller);
Check(events, handle, true, true);
}
TEST_F(LoggerTest, InfoOnly) {
auto poller = nt::CreateListenerPoller(m_inst);
auto handle = nt::AddPolledLogger(poller, NT_LOG_INFO, NT_LOG_INFO);
Generate();
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadListenerQueue(poller);
Check(events, handle, true, false);
}
TEST_F(LoggerTest, Error) {
auto poller = nt::CreateListenerPoller(m_inst);
auto handle = nt::AddPolledLogger(poller, NT_LOG_ERROR, 100);
Generate();
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadListenerQueue(poller);
Check(events, handle, false, true);
}

41
ntcore/src/test/native/cpp/MockListenerStorage.h Normal file
View File

@@ -0,0 +1,41 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#pragma once
#include <memory>
#include <span>
#include <string_view>
#include "IListenerStorage.h"
#include "gmock/gmock.h"
namespace nt {
class MockListenerStorage : public IListenerStorage {
public:
MOCK_METHOD(void, Activate,
(NT_Listener listenerHandle, unsigned int mask,
FinishEventFunc finishEvent),
(override));
MOCK_METHOD(void, Notify,
(std::span<const NT_Listener> handles, unsigned int flags,
std::span<ConnectionInfo const* const> infos),
(override));
MOCK_METHOD(void, Notify,
(std::span<const NT_Listener> handles, unsigned int flags,
std::span<const TopicInfo> infos),
(override));
MOCK_METHOD(void, Notify,
(std::span<const NT_Listener> handles, unsigned int flags,
NT_Topic topic, NT_Handle subentry, const Value& value),
(override));
MOCK_METHOD(void, Notify,
(unsigned int flags, unsigned int level,
std::string_view filename, unsigned int line,
std::string_view message),
(override));
};
} // namespace nt

36
ntcore/src/test/native/cpp/TestPrinters.cpp
View File

@@ -20,44 +20,32 @@ void PrintTo(const json& val, ::std::ostream* os) {
} // namespace wpi
namespace nt {
#if 0
void PrintTo(const EntryNotification& event, std::ostream* os) {
*os << "EntryNotification{listener=";
void PrintTo(const Event& event, std::ostream* os) {
*os << "Event{listener=";
PrintTo(Handle{event.listener}, os);
*os << ", entry=";
PrintTo(Handle{event.entry}, os);
*os << ", name=\"" << event.name << "\", flags=" << event.flags << ", value=";
PrintTo(event.value, os);
*os << ", flags=" << event.flags;
// *os << ", name=\"" << event.name << "\", flags=" << event.flags
// << "value=";
// PrintTo(event.value, os);
*os << '}';
}
#endif
void PrintTo(const Handle& handle, std::ostream* os) {
*os << "Handle{";
switch (handle.GetType()) {
case Handle::kConnectionListener:
*os << "kConnectionListener";
case Handle::kListener:
*os << "kListener";
break;
case Handle::kConnectionListenerPoller:
*os << "kConnectionListenerPoller";
case Handle::kListenerPoller:
*os << "kListenerPoller";
break;
case Handle::kEntry:
*os << "kEntry";
break;
case Handle::kEntryListener:
*os << "kEntryListener";
break;
case Handle::kEntryListenerPoller:
*os << "kEntryListenerPoller";
break;
case Handle::kInstance:
*os << "kInstance";
break;
case Handle::kLogger:
*os << "kLogger";
break;
case Handle::kLoggerPoller:
*os << "kLoggerPoller";
break;
case Handle::kTopic:
*os << "kTopic";
break;

4
ntcore/src/test/native/cpp/TestPrinters.h
View File

@@ -49,12 +49,12 @@ struct ClientMessage;
struct ServerMessage;
} // namespace net
// class EntryNotification;
class Event;
class Handle;
class PubSubOptions;
class Value;
// void PrintTo(const EntryNotification& event, std::ostream* os);
void PrintTo(const Event& event, std::ostream* os);
void PrintTo(const Handle& handle, std::ostream* os);
void PrintTo(const net3::Message3& msg, std::ostream* os);
void PrintTo(const net::ClientMessage& msg, std::ostream* os);

159
ntcore/src/test/native/cpp/TopicListenerTest.cpp
View File

@@ -19,16 +19,16 @@ class TopicListenerTest : public ::testing::Test {
TopicListenerTest()
: m_serverInst(nt::CreateInstance()), m_clientInst(nt::CreateInstance()) {
#if 0
nt::AddLogger(server_inst,
[](const nt::LogMessage& msg) {
std::fprintf(stderr, "SERVER: %s\n", msg.message.c_str());
},
0, UINT_MAX);
nt::AddLogger(client_inst,
[](const nt::LogMessage& msg) {
std::fprintf(stderr, "CLIENT: %s\n", msg.message.c_str());
},
0, UINT_MAX);
nt::AddLogger(m_serverInst, 0, UINT_MAX, [](auto& event) {
if (auto msg = event.GetLogMessage()) {
std::fprintf(stderr, "SERVER: %s\n", msg->message.c_str());
}
});
nt::AddLogger(m_clientInst, 0, UINT_MAX, [](auto& event) {
if (auto msg = event.GetLogMessage()) {
std::fprintf(stderr, "CLIENT: %s\n", msg.message.c_str());
}
});
#endif
}
@@ -39,9 +39,8 @@ class TopicListenerTest : public ::testing::Test {
void Connect(unsigned int port);
static void PublishTopics(NT_Inst inst);
void CheckEvents(const std::vector<nt::TopicNotification>& events,
NT_TopicListener handle, unsigned int flags,
std::string_view topicName = "/foo/bar");
void CheckEvents(const std::vector<nt::Event>& events, NT_Listener handle,
unsigned int flags, std::string_view topicName = "/foo/bar");
protected:
NT_Inst m_serverInst;
@@ -54,9 +53,8 @@ void TopicListenerTest::Connect(unsigned int port) {
nt::SetServer(m_clientInst, "127.0.0.1", port);
// Use connection listener to ensure we've connected
NT_ConnectionListenerPoller poller =
nt::CreateConnectionListenerPoller(m_clientInst);
nt::AddPolledConnectionListener(poller, false);
NT_ListenerPoller poller = nt::CreateListenerPoller(m_clientInst);
nt::AddPolledListener(poller, m_clientInst, nt::EventFlags::kConnected);
bool timedOut = false;
if (!wpi::WaitForObject(poller, 1.0, &timedOut)) {
FAIL() << "client didn't connect to server";
@@ -69,27 +67,29 @@ void TopicListenerTest::PublishTopics(NT_Inst inst) {
nt::Publish(nt::GetTopic(inst, "/baz"), NT_DOUBLE, "double");
}
void TopicListenerTest::CheckEvents(
const std::vector<nt::TopicNotification>& events, NT_TopicListener handle,
unsigned int flags, std::string_view topicName) {
void TopicListenerTest::CheckEvents(const std::vector<nt::Event>& events,
NT_Listener handle, unsigned int flags,
std::string_view topicName) {
ASSERT_EQ(events.size(), 1u);
ASSERT_EQ(events[0].listener, handle);
ASSERT_EQ(events[0].info.topic, nt::GetTopic(m_serverInst, topicName));
ASSERT_EQ(events[0].info.name, topicName);
ASSERT_EQ(events[0].flags, flags);
auto topicInfo = events[0].GetTopicInfo();
ASSERT_TRUE(topicInfo);
ASSERT_EQ(topicInfo->topic, nt::GetTopic(m_serverInst, topicName));
ASSERT_EQ(topicInfo->name, topicName);
}
TEST_F(TopicListenerTest, TopicNewLocal) {
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
poller, nt::GetTopic(m_serverInst, "/foo"), NT_TOPIC_NOTIFY_PUBLISH);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, nt::GetTopic(m_serverInst, "/foo"), nt::EventFlags::kPublish);
PublishTopics(m_serverInst);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PUBLISH, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kPublish, "/foo");
}
TEST_F(TopicListenerTest, DISABLED_TopicNewRemote) {
@@ -97,9 +97,9 @@ TEST_F(TopicListenerTest, DISABLED_TopicNewRemote) {
if (HasFatalFailure()) {
return;
}
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
poller, nt::GetTopic(m_serverInst, "/foo"), NT_TOPIC_NOTIFY_PUBLISH);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, nt::GetTopic(m_serverInst, "/foo"), nt::EventFlags::kPublish);
PublishTopics(m_clientInst);
@@ -108,54 +108,54 @@ TEST_F(TopicListenerTest, DISABLED_TopicNewRemote) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PUBLISH, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kPublish, "/foo");
}
TEST_F(TopicListenerTest, TopicPublishImm) {
PublishTopics(m_serverInst);
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, nt::GetTopic(m_serverInst, "/foo"),
NT_TOPIC_NOTIFY_PUBLISH | NT_TOPIC_NOTIFY_IMMEDIATE);
nt::EventFlags::kPublish | nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle,
NT_TOPIC_NOTIFY_PUBLISH | NT_TOPIC_NOTIFY_IMMEDIATE, "/foo");
nt::EventFlags::kPublish | nt::EventFlags::kImmediate, "/foo");
}
TEST_F(TopicListenerTest, TopicUnpublishPropsImm) {
PublishTopics(m_serverInst);
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
nt::AddPolledTopicListener(poller, nt::GetTopic(m_serverInst, "/foo"),
NT_TOPIC_NOTIFY_UNPUBLISH |
NT_TOPIC_NOTIFY_PROPERTIES |
NT_TOPIC_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_serverInst);
nt::AddPolledListener(poller, nt::GetTopic(m_serverInst, "/foo"),
nt::EventFlags::kUnpublish |
nt::EventFlags::kProperties |
nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_FALSE(wpi::WaitForObject(poller, 0.02, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
auto events = nt::ReadListenerQueue(poller);
ASSERT_TRUE(events.empty());
}
TEST_F(TopicListenerTest, TopicUnpublishLocal) {
auto topic = nt::GetTopic(m_serverInst, "/foo");
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle =
nt::AddPolledTopicListener(poller, topic, NT_TOPIC_NOTIFY_UNPUBLISH);
nt::AddPolledListener(poller, topic, nt::EventFlags::kUnpublish);
auto pub = nt::Publish(topic, NT_DOUBLE, "double");
nt::Unpublish(pub);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_UNPUBLISH, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kUnpublish, "/foo");
}
TEST_F(TopicListenerTest, DISABLED_TopicUnpublishRemote) {
@@ -163,9 +163,9 @@ TEST_F(TopicListenerTest, DISABLED_TopicUnpublishRemote) {
if (HasFatalFailure()) {
return;
}
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
poller, nt::GetTopic(m_serverInst, "/foo"), NT_TOPIC_NOTIFY_UNPUBLISH);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, nt::GetTopic(m_serverInst, "/foo"), nt::EventFlags::kUnpublish);
auto pub =
nt::Publish(nt::GetTopic(m_clientInst, "/foo"), NT_DOUBLE, "double");
@@ -179,23 +179,23 @@ TEST_F(TopicListenerTest, DISABLED_TopicUnpublishRemote) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_UNPUBLISH, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kUnpublish, "/foo");
}
TEST_F(TopicListenerTest, TopicPropertiesLocal) {
auto topic = nt::GetTopic(m_serverInst, "/foo");
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle =
nt::AddPolledTopicListener(poller, topic, NT_TOPIC_NOTIFY_PROPERTIES);
nt::AddPolledListener(poller, topic, nt::EventFlags::kProperties);
nt::SetTopicProperty(topic, "foo", 5);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PROPERTIES, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kProperties, "/foo");
}
TEST_F(TopicListenerTest, DISABLED_TopicPropertiesRemote) {
@@ -206,9 +206,9 @@ TEST_F(TopicListenerTest, DISABLED_TopicPropertiesRemote) {
// the topic needs to actually exist
nt::Publish(nt::GetTopic(m_serverInst, "/foo"), NT_BOOLEAN, "boolean");
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
poller, nt::GetTopic(m_serverInst, "/foo"), NT_TOPIC_NOTIFY_PROPERTIES);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, nt::GetTopic(m_serverInst, "/foo"), nt::EventFlags::kProperties);
nt::FlushLocal(m_serverInst);
nt::SetTopicProperty(nt::GetTopic(m_clientInst, "/foo"), "foo", 5);
@@ -217,21 +217,21 @@ TEST_F(TopicListenerTest, DISABLED_TopicPropertiesRemote) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PROPERTIES, "/foo");
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kProperties, "/foo");
}
TEST_F(TopicListenerTest, PrefixPublishLocal) {
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle =
nt::AddPolledTopicListener(poller, {{"/foo/"}}, NT_TOPIC_NOTIFY_PUBLISH);
nt::AddPolledListener(poller, {{"/foo/"}}, nt::EventFlags::kPublish);
PublishTopics(m_serverInst);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PUBLISH);
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kPublish);
}
TEST_F(TopicListenerTest, DISABLED_PrefixPublishRemote) {
@@ -239,9 +239,9 @@ TEST_F(TopicListenerTest, DISABLED_PrefixPublishRemote) {
if (HasFatalFailure()) {
return;
}
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle =
nt::AddPolledTopicListener(poller, {{"/foo/"}}, NT_TOPIC_NOTIFY_PUBLISH);
nt::AddPolledListener(poller, {{"/foo/"}}, nt::EventFlags::kPublish);
PublishTopics(m_clientInst);
@@ -250,35 +250,36 @@ TEST_F(TopicListenerTest, DISABLED_PrefixPublishRemote) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
CheckEvents(events, handle, NT_TOPIC_NOTIFY_PUBLISH);
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle, nt::EventFlags::kPublish);
}
TEST_F(TopicListenerTest, PrefixPublishImm) {
PublishTopics(m_serverInst);
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
auto handle = nt::AddPolledTopicListener(
poller, {{"/foo/"}}, NT_TOPIC_NOTIFY_PUBLISH | NT_TOPIC_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_serverInst);
auto handle = nt::AddPolledListener(
poller, {{"/foo/"}},
nt::EventFlags::kPublish | nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
auto events = nt::ReadListenerQueue(poller);
CheckEvents(events, handle,
NT_TOPIC_NOTIFY_PUBLISH | NT_TOPIC_NOTIFY_IMMEDIATE);
nt::EventFlags::kPublish | nt::EventFlags::kImmediate);
}
TEST_F(TopicListenerTest, PrefixUnpublishPropsImm) {
PublishTopics(m_serverInst);
auto poller = nt::CreateTopicListenerPoller(m_serverInst);
nt::AddPolledTopicListener(poller, {{"/foo/"}},
NT_TOPIC_NOTIFY_UNPUBLISH |
NT_TOPIC_NOTIFY_PROPERTIES |
NT_TOPIC_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_serverInst);
nt::AddPolledListener(poller, {{"/foo/"}},
nt::EventFlags::kUnpublish |
nt::EventFlags::kProperties |
nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_FALSE(wpi::WaitForObject(poller, 0.02, &timedOut));
auto events = nt::ReadTopicListenerQueue(poller);
auto events = nt::ReadListenerQueue(poller);
ASSERT_TRUE(events.empty());
}

255
ntcore/src/test/native/cpp/ValueListenerTest.cpp
View File

@@ -34,12 +34,12 @@ TEST_F(ValueListenerTest, MultiPollSub) {
auto pub = nt::Publish(topic, NT_DOUBLE, "double");
auto sub = nt::Subscribe(topic, NT_DOUBLE, "double");
auto poller1 = nt::CreateValueListenerPoller(m_inst);
auto poller2 = nt::CreateValueListenerPoller(m_inst);
auto poller3 = nt::CreateValueListenerPoller(m_inst);
auto h1 = nt::AddPolledValueListener(poller1, sub, NT_VALUE_NOTIFY_LOCAL);
auto h2 = nt::AddPolledValueListener(poller2, sub, NT_VALUE_NOTIFY_LOCAL);
auto h3 = nt::AddPolledValueListener(poller3, sub, NT_VALUE_NOTIFY_LOCAL);
auto poller1 = nt::CreateListenerPoller(m_inst);
auto poller2 = nt::CreateListenerPoller(m_inst);
auto poller3 = nt::CreateListenerPoller(m_inst);
auto h1 = nt::AddPolledListener(poller1, sub, nt::EventFlags::kValueLocal);
auto h2 = nt::AddPolledListener(poller2, sub, nt::EventFlags::kValueLocal);
auto h3 = nt::AddPolledListener(poller3, sub, nt::EventFlags::kValueLocal);
nt::SetDouble(pub, 0);
@@ -50,30 +50,36 @@ TEST_F(ValueListenerTest, MultiPollSub) {
ASSERT_FALSE(timedOut);
ASSERT_TRUE(wpi::WaitForObject(poller3, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results1 = nt::ReadValueListenerQueue(poller1);
auto results2 = nt::ReadValueListenerQueue(poller2);
auto results3 = nt::ReadValueListenerQueue(poller3);
auto results1 = nt::ReadListenerQueue(poller1);
auto results2 = nt::ReadListenerQueue(poller2);
auto results3 = nt::ReadListenerQueue(poller3);
ASSERT_EQ(results1.size(), 1u);
EXPECT_EQ(results1[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results1[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results1[0].listener, h1);
EXPECT_EQ(results1[0].subentry, sub);
EXPECT_EQ(results1[0].topic, topic);
EXPECT_EQ(results1[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results1[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
ASSERT_EQ(results2.size(), 1u);
EXPECT_EQ(results2[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results2[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results2[0].listener, h2);
EXPECT_EQ(results2[0].subentry, sub);
EXPECT_EQ(results2[0].topic, topic);
EXPECT_EQ(results2[0].value, nt::Value::MakeDouble(0.0));
valueData = results2[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
ASSERT_EQ(results3.size(), 1u);
EXPECT_EQ(results3[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results3[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results3[0].listener, h3);
EXPECT_EQ(results3[0].subentry, sub);
EXPECT_EQ(results3[0].topic, topic);
EXPECT_EQ(results3[0].value, nt::Value::MakeDouble(0.0));
valueData = results3[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
}
TEST_F(ValueListenerTest, PollMultiSub) {
@@ -82,29 +88,33 @@ TEST_F(ValueListenerTest, PollMultiSub) {
auto sub1 = nt::Subscribe(topic, NT_DOUBLE, "double");
auto sub2 = nt::Subscribe(topic, NT_DOUBLE, "double");
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h1 = nt::AddPolledValueListener(poller, sub1, NT_VALUE_NOTIFY_LOCAL);
auto h2 = nt::AddPolledValueListener(poller, sub2, NT_VALUE_NOTIFY_LOCAL);
auto poller = nt::CreateListenerPoller(m_inst);
auto h1 = nt::AddPolledListener(poller, sub1, nt::EventFlags::kValueLocal);
auto h2 = nt::AddPolledListener(poller, sub2, nt::EventFlags::kValueLocal);
nt::SetDouble(pub, 0);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 2u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h1);
EXPECT_EQ(results[0].subentry, sub1);
EXPECT_EQ(results[0].topic, topic);
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub1);
EXPECT_EQ(valueData->topic, topic);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
EXPECT_EQ(results[1].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[1].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[1].listener, h2);
EXPECT_EQ(results[1].subentry, sub2);
EXPECT_EQ(results[1].topic, topic);
EXPECT_EQ(results[1].value, nt::Value::MakeDouble(0.0));
valueData = results[1].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub2);
EXPECT_EQ(valueData->topic, topic);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
}
TEST_F(ValueListenerTest, PollMultiSubTopic) {
@@ -115,9 +125,9 @@ TEST_F(ValueListenerTest, PollMultiSubTopic) {
auto sub1 = nt::Subscribe(topic1, NT_DOUBLE, "double");
auto sub2 = nt::Subscribe(topic2, NT_DOUBLE, "double");
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h1 = nt::AddPolledValueListener(poller, sub1, NT_VALUE_NOTIFY_LOCAL);
auto h2 = nt::AddPolledValueListener(poller, sub2, NT_VALUE_NOTIFY_LOCAL);
auto poller = nt::CreateListenerPoller(m_inst);
auto h1 = nt::AddPolledListener(poller, sub1, nt::EventFlags::kValueLocal);
auto h2 = nt::AddPolledListener(poller, sub2, nt::EventFlags::kValueLocal);
nt::SetDouble(pub1, 0);
nt::SetDouble(pub2, 1);
@@ -125,20 +135,24 @@ TEST_F(ValueListenerTest, PollMultiSubTopic) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 2u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h1);
EXPECT_EQ(results[0].subentry, sub1);
EXPECT_EQ(results[0].topic, topic1);
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub1);
EXPECT_EQ(valueData->topic, topic1);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
EXPECT_EQ(results[1].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[1].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[1].listener, h2);
EXPECT_EQ(results[1].subentry, sub2);
EXPECT_EQ(results[1].topic, topic2);
EXPECT_EQ(results[1].value, nt::Value::MakeDouble(1.0));
valueData = results[1].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub2);
EXPECT_EQ(valueData->topic, topic2);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(1.0));
}
TEST_F(ValueListenerTest, PollSubMultiple) {
@@ -148,8 +162,8 @@ TEST_F(ValueListenerTest, PollSubMultiple) {
auto pub2 = nt::Publish(topic2, NT_DOUBLE, "double");
auto sub = nt::SubscribeMultiple(m_inst, {{"foo"}});
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h = nt::AddPolledValueListener(poller, sub, NT_VALUE_NOTIFY_LOCAL);
auto poller = nt::CreateListenerPoller(m_inst);
auto h = nt::AddPolledListener(poller, sub, nt::EventFlags::kValueLocal);
nt::SetDouble(pub1, 0);
nt::SetDouble(pub2, 1);
@@ -157,90 +171,139 @@ TEST_F(ValueListenerTest, PollSubMultiple) {
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 2u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h);
EXPECT_EQ(results[0].subentry, sub);
EXPECT_EQ(results[0].topic, topic1);
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic1);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
EXPECT_EQ(results[1].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[1].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[1].listener, h);
EXPECT_EQ(results[1].subentry, sub);
EXPECT_EQ(results[1].topic, topic2);
EXPECT_EQ(results[1].value, nt::Value::MakeDouble(1.0));
valueData = results[1].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic2);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(1.0));
}
TEST_F(ValueListenerTest, PollSubPrefixCreated) {
auto poller = nt::CreateListenerPoller(m_inst);
auto h =
nt::AddPolledListener(poller, {{"foo"}}, nt::EventFlags::kValueLocal);
auto topic1 = nt::GetTopic(m_inst, "foo/1");
auto topic2 = nt::GetTopic(m_inst, "foo/2");
auto topic3 = nt::GetTopic(m_inst, "bar/3");
auto pub1 = nt::Publish(topic1, NT_DOUBLE, "double");
auto pub2 = nt::Publish(topic2, NT_DOUBLE, "double");
auto pub3 = nt::Publish(topic3, NT_DOUBLE, "double");
nt::SetDouble(pub1, 0);
nt::SetDouble(pub2, 1);
nt::SetDouble(pub3, 1);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 2u);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h);
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->topic, topic1);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
EXPECT_EQ(results[1].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[1].listener, h);
valueData = results[1].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->topic, topic2);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(1.0));
}
TEST_F(ValueListenerTest, PollEntry) {
auto entry = nt::GetEntry(m_inst, "foo");
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h = nt::AddPolledValueListener(poller, entry, NT_VALUE_NOTIFY_LOCAL);
auto poller = nt::CreateListenerPoller(m_inst);
auto h = nt::AddPolledListener(poller, entry, nt::EventFlags::kValueLocal);
ASSERT_TRUE(nt::SetDouble(entry, 0));
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 1u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h);
EXPECT_EQ(results[0].subentry, entry);
EXPECT_EQ(results[0].topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, entry);
EXPECT_EQ(valueData->topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
}
TEST_F(ValueListenerTest, PollImmediate) {
auto entry = nt::GetEntry(m_inst, "foo");
ASSERT_TRUE(nt::SetDouble(entry, 0));
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h = nt::AddPolledValueListener(
poller, entry, NT_VALUE_NOTIFY_LOCAL | NT_VALUE_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_inst);
auto h = nt::AddPolledListener(
poller, entry, nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 1u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_IMMEDIATE);
EXPECT_EQ(results[0].flags &
(nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate),
nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
EXPECT_EQ(results[0].listener, h);
EXPECT_EQ(results[0].subentry, entry);
EXPECT_EQ(results[0].topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, entry);
EXPECT_EQ(valueData->topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
}
TEST_F(ValueListenerTest, PollImmediateNoValue) {
auto entry = nt::GetEntry(m_inst, "foo");
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h = nt::AddPolledValueListener(
poller, entry, NT_VALUE_NOTIFY_LOCAL | NT_VALUE_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_inst);
auto h = nt::AddPolledListener(
poller, entry, nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_FALSE(wpi::WaitForObject(poller, 0.02, &timedOut));
ASSERT_TRUE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_TRUE(results.empty());
// now set a value
ASSERT_TRUE(nt::SetDouble(entry, 0));
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
results = nt::ReadValueListenerQueue(poller);
results = nt::ReadListenerQueue(poller);
ASSERT_FALSE(timedOut);
ASSERT_EQ(results.size(), 1u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_LOCAL);
EXPECT_EQ(results[0].flags, nt::EventFlags::kValueLocal);
EXPECT_EQ(results[0].listener, h);
EXPECT_EQ(results[0].subentry, entry);
EXPECT_EQ(results[0].topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, entry);
EXPECT_EQ(valueData->topic, nt::GetTopic(m_inst, "foo"));
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
}
TEST_F(ValueListenerTest, PollImmediateSubMultiple) {
@@ -252,27 +315,35 @@ TEST_F(ValueListenerTest, PollImmediateSubMultiple) {
nt::SetDouble(pub1, 0);
nt::SetDouble(pub2, 1);
auto poller = nt::CreateValueListenerPoller(m_inst);
auto h = nt::AddPolledValueListener(
poller, sub, NT_VALUE_NOTIFY_LOCAL | NT_VALUE_NOTIFY_IMMEDIATE);
auto poller = nt::CreateListenerPoller(m_inst);
auto h = nt::AddPolledListener(
poller, sub, nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
bool timedOut = false;
ASSERT_TRUE(wpi::WaitForObject(poller, 1.0, &timedOut));
ASSERT_FALSE(timedOut);
auto results = nt::ReadValueListenerQueue(poller);
auto results = nt::ReadListenerQueue(poller);
ASSERT_EQ(results.size(), 2u);
EXPECT_EQ(results[0].flags, NT_VALUE_NOTIFY_IMMEDIATE);
EXPECT_EQ(results[0].flags &
(nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate),
nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
EXPECT_EQ(results[0].listener, h);
EXPECT_EQ(results[0].subentry, sub);
EXPECT_EQ(results[0].topic, topic1);
EXPECT_EQ(results[0].value, nt::Value::MakeDouble(0.0));
auto valueData = results[0].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic1);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(0.0));
EXPECT_EQ(results[1].flags, NT_VALUE_NOTIFY_IMMEDIATE);
EXPECT_EQ(results[1].flags &
(nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate),
nt::EventFlags::kValueLocal | nt::EventFlags::kImmediate);
EXPECT_EQ(results[1].listener, h);
EXPECT_EQ(results[1].subentry, sub);
EXPECT_EQ(results[1].topic, topic2);
EXPECT_EQ(results[1].value, nt::Value::MakeDouble(1.0));
valueData = results[1].GetValueEventData();
ASSERT_TRUE(valueData);
EXPECT_EQ(valueData->subentry, sub);
EXPECT_EQ(valueData->topic, topic2);
EXPECT_EQ(valueData->value, nt::Value::MakeDouble(1.0));
}
} // namespace nt

13
ntcore/src/test/native/cpp/main.cpp
View File

@@ -8,13 +8,12 @@
#include "ntcore.h"
int main(int argc, char** argv) {
nt::AddLogger(
nt::GetDefaultInstance(),
[](const nt::LogMessage& msg) {
std::fputs(msg.message.c_str(), stderr);
std::fputc('\n', stderr);
},
0, UINT_MAX);
nt::AddLogger(nt::GetDefaultInstance(), 0, UINT_MAX, [](auto& event) {
if (auto msg = event.GetLogMessage()) {
std::fputs(msg->message.c_str(), stderr);
std::fputc('\n', stderr);
}
});
::testing::InitGoogleMock(&argc, argv);
int ret = RUN_ALL_TESTS();
return ret;