using namespace AittTCPNamespace;
-TEST(TCPServer, Positive_Create_Anytime)
+TEST(TCPServer, Create_P_Anytime)
{
unsigned short port = TEST_SERVER_PORT;
std::unique_ptr<TCP::Server> tcp(new TCP::Server(TEST_SERVER_ADDRESS, port));
ASSERT_NE(tcp, nullptr);
}
-TEST(TCPServer, Negative_Create_Anytime)
+TEST(TCPServer, Create_N_Anytime)
{
try {
unsigned short port = TEST_SERVER_PORT;
}
}
-TEST(TCPServer, Positive_Create_AutoPort_Anytime)
+TEST(TCPServer, Create_AutoPort_P_Anytime)
{
unsigned short port = TEST_SERVER_AVAILABLE_PORT;
std::unique_ptr<TCP::Server> tcp(new TCP::Server(TEST_SERVER_ADDRESS, port));
ASSERT_NE(port, 0);
}
-TEST(TCPServer, Positive_GetPort_Anytime)
+TEST(TCPServer, GetPort_P_Anytime)
{
unsigned short port = TEST_SERVER_PORT;
std::unique_ptr<TCP::Server> tcp(new TCP::Server(TEST_SERVER_ADDRESS, port));
ASSERT_EQ(tcp->GetPort(), TEST_SERVER_PORT);
}
-TEST(TCPServer, Positive_GetHandle_Anytime)
+TEST(TCPServer, GetHandle_P_Anytime)
{
unsigned short port = TEST_SERVER_PORT;
std::unique_ptr<TCP::Server> tcp(new TCP::Server(TEST_SERVER_ADDRESS, port));
ASSERT_GE(tcp->GetHandle(), 0);
}
-TEST(TCPServer, Positive_GetPort_AutoPort_Anytime)
+TEST(TCPServer, GetPort_AutoPort_P_Anytime)
{
unsigned short port = TEST_SERVER_AVAILABLE_PORT;
std::unique_ptr<TCP::Server> tcp(new TCP::Server(TEST_SERVER_ADDRESS, port));
ASSERT_EQ(tcp->GetPort(), port);
}
-TEST(TCPServer, Positive_AcceptPeer_Anytime)
+TEST(TCPServer, AcceptPeer_P_Anytime)
{
std::mutex m;
std::condition_variable ready_cv;
std::function<void(void)> customTest;
};
-TEST(TCP, Negative_Create_InvalidPort_Anytime)
+TEST(TCP, Create_InvalidPort_N_Anytime)
{
try {
TCP::ConnectInfo info;
}
}
-TEST(TCP, Negative_Create_InvalidAddress_Anytime)
+TEST(TCP, Create_InvalidAddress_N_Anytime)
{
try {
TCP::ConnectInfo info;
}
}
-TEST_F(TCPTest, Positive_GetPeerInfo_Anytime)
+TEST_F(TCPTest, GetPeerInfo_P_Anytime)
{
std::string peerHost;
unsigned short peerPort = 0;
ASSERT_GT(peerPort, 0);
}
-TEST_F(TCPTest, Positive_GetHandle_Anytime)
+TEST_F(TCPTest, GetHandle_P_Anytime)
{
RunServer();
int handle = peer->GetHandle();
ASSERT_GE(handle, 0);
}
-TEST_F(TCPTest, Positive_GetPort_Anytime)
+TEST_F(TCPTest, GetPort_P_Anytime)
{
RunServer();
unsigned short port = peer->GetPort();
ASSERT_GT(port, 0);
}
-TEST_F(TCPTest, Positive_SendRecv_Anytime)
+TEST_F(TCPTest, SendRecv_P_Anytime)
{
char helloBuffer[TEST_BUFFER_SIZE];
char byeBuffer[TEST_BUFFER_SIZE];
}
}
-TEST_F(MqttServerTest, Positive_Connect_Anytime)
+TEST_F(MqttServerTest, Connect_P_Anytime)
{
try {
MqttServer server(webrtc_src_config_);
}
}
-TEST_F(MqttServerTest, Positive_Connect_Src_Sinks_Anytime)
+TEST_F(MqttServerTest, Connect_Src_Sinks_P_Anytime)
{
try {
Positive_Connect_Src_Sinks_Anytime_connect_count = 0;
}
}
-TEST_F(MqttServerTest, Negative_Disconnect_Anytime)
+TEST_F(MqttServerTest, Disconnect_N_Anytime)
{
EXPECT_THROW(
{
aitt::AittException);
}
-TEST_F(MqttServerTest, Positive_Disconnect_Anytime)
+TEST_F(MqttServerTest, Disconnect_P_Anytime)
{
try {
MqttServer server(webrtc_src_config_);
}
}
-TEST_F(MqttServerTest, Negative_Register_Anytime)
+TEST_F(MqttServerTest, Register_N_Anytime)
{
EXPECT_THROW(
{
std::runtime_error);
}
-TEST_F(MqttServerTest, Negative_JoinRoom_Invalid_Parameter_Anytime)
+TEST_F(MqttServerTest, JoinRoom_Invalid_Parameter_N_Anytime)
{
EXPECT_THROW(
{
}
}
-TEST_F(MqttServerTest, Positive_JoinRoom_Anytime)
+TEST_F(MqttServerTest, JoinRoom_P_Anytime)
{
try {
MqttServer server(webrtc_src_config_);
}
}
-TEST_F(MqttServerTest, Positive_src_sink)
+TEST_F(MqttServerTest, src_sink_P)
{
try {
MqttServer src_server(webrtc_src_config_);
}
}
-TEST_F(MqttServerTest, Positive_sink_src)
+TEST_F(MqttServerTest, sink_src_P)
{
try {
MqttServer sink_server(webrtc_first_sink_config_);
}
}
-TEST_F(MqttServerTest, Positive_src_sink_disconnect_src_first_Anytime)
+TEST_F(MqttServerTest, src_sink_disconnect_src_first_P_Anytime)
{
try {
MqttServer src_server(webrtc_src_config_);
}
}
-TEST_F(MqttServerTest, Positive_sink_src_disconnect_src_first_Anytime)
+TEST_F(MqttServerTest, sink_src_disconnect_src_first_P_Anytime)
{
try {
MqttServer sink_server(webrtc_first_sink_config_);
}
}
-TEST_F(MqttServerTest, Positive_SendMessageThreeWay_Src_Sinks1_Anytime)
+TEST_F(MqttServerTest, SendMessageThreeWay_Src_Sinks1_P_Anytime)
{
try {
handled_sink = 0;
}
};
-TEST_F(AITTTest, Positive_Create_Anytime)
+TEST_F(AITTTest, Create_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Connect_Anytime)
+TEST_F(AITTTest, Connect_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Disconnect_Anytime)
+TEST_F(AITTTest, Disconnect_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Connect_twice_Anytime)
+TEST_F(AITTTest, Connect_twice_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Publish_MQTT_Anytime)
+TEST_F(AITTTest, Publish_MQTT_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Publish_TCP_Anytime)
+TEST_F(AITTTest, Publish_TCP_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Publish_SECURE_TCP_Anytime)
+TEST_F(AITTTest, Publish_SECURE_TCP_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Publish_Multiple_Protocols_Anytime)
+TEST_F(AITTTest, Publish_Multiple_Protocols_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Subscribe_WebRTC_Anytime)
+TEST_F(AITTTest, Subscribe_WebRTC_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Unsubscribe_MQTT_Anytime)
+TEST_F(AITTTest, Unsubscribe_MQTT_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Unsubscribe_TCP_Anytime)
+TEST_F(AITTTest, Unsubscribe_TCP_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positive_Unsubscribe_SECURE_TCP_Anytime)
+TEST_F(AITTTest, Unsubscribe_SECURE_TCP_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positve_PublishSubscribe_MQTT_Anytime)
+TEST_F(AITTTest, PublishSubscribe_MQTT_P_Anytime)
{
PubsubTemplate(TEST_MSG, AITT_TYPE_MQTT);
}
PubsubTemplate("", AITT_TYPE_MQTT);
}
-TEST_F(AITTTest, Positve_Unsubscribe_in_Subscribe_MQTT_Anytime)
+TEST_F(AITTTest, Unsubscribe_in_Subscribe_MQTT_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positve_Subscribe_in_Subscribe_MQTT_Anytime)
+TEST_F(AITTTest, Subscribe_in_Subscribe_MQTT_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positve_PublishSubscribe_TCP_Anytime)
+TEST_F(AITTTest, PublishSubscribe_TCP_P_Anytime)
{
PubsubTemplate(TEST_MSG, AITT_TYPE_TCP);
}
-TEST_F(AITTTest, Positve_PublishSubscribe_SECURE_TCP_Anytime)
+TEST_F(AITTTest, PublishSubscribe_SECURE_TCP_P_Anytime)
{
PubsubTemplate(TEST_MSG, AITT_TYPE_TCP_SECURE);
}
-TEST_F(AITTTest, Positve_Publish_0_TCP_Anytime)
+TEST_F(AITTTest, Publish_0_TCP_P_Anytime)
{
PubsubTemplate("", AITT_TYPE_TCP);
}
-TEST_F(AITTTest, Positve_Publish_0_SECURE_TCP_Anytime)
+TEST_F(AITTTest, Publish_0_SECURE_TCP_P_Anytime)
{
PubsubTemplate("", AITT_TYPE_TCP_SECURE);
}
-TEST_F(AITTTest, Positve_PublishSubscribe_Multiple_Protocols_Anytime)
+TEST_F(AITTTest, PublishSubscribe_Multiple_Protocols_P_Anytime)
{
try {
AITT aitt(clientId, LOCAL_IP, AittOption(true, false));
}
}
-TEST_F(AITTTest, Positve_PublishSubscribe_TCP_twice_Anytime)
+TEST_F(AITTTest, PublishSubscribe_TCP_twice_P_Anytime)
{
PublishSubscribeTCPTwiceTemplate(AITT_TYPE_TCP);
}
-TEST_F(AITTTest, Positve_PublishSubscribe_SECURE_TCP_twice_Anytime)
+TEST_F(AITTTest, PublishSubscribe_SECURE_TCP_twice_P_Anytime)
{
PublishSubscribeTCPTwiceTemplate(AITT_TYPE_TCP_SECURE);
}
-TEST_F(AITTTest, Positive_Subscribe_Retained_TCP_Anytime)
+TEST_F(AITTTest, Subscribe_Retained_TCP_P_Anytime)
{
SubscribeRetainedTCPTemplate(AITT_TYPE_TCP);
}
-TEST_F(AITTTest, Positive_Subscribe_Retained_SECURE_TCP_Anytime)
+TEST_F(AITTTest, Subscribe_Retained_SECURE_TCP_P_Anytime)
{
SubscribeRetainedTCPTemplate(AITT_TYPE_TCP_SECURE);
}
-TEST_F(AITTTest, TCP_Publish_Disconnect_TCP_Anytime)
+TEST_F(AITTTest, Publish_Disconnect_TCP_P_Anytime)
{
PublishDisconnectTemplate(AITT_TYPE_TCP);
}
-TEST_F(AITTTest, TCP_Publish_Disconnect_SECURE_TCP_Anytime)
+TEST_F(AITTTest, Publish_Disconnect_SECURE_TCP_P_Anytime)
{
PublishDisconnectTemplate(AITT_TYPE_TCP_SECURE);
}
#define TEST_HOST "localhost"
#define TEST_HANDLE reinterpret_cast<mosquitto *>(0xbeefbeef)
-TEST_F(MQMockTest, Negative_Create_lib_init_Anytime)
+TEST_F(MQMockTest, Create_lib_init_N_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_NOT_SUPPORTED));
EXPECT_CALL(GetMock(), mosquitto_destroy(nullptr)).WillOnce(Return());
}
}
-TEST_F(MQMockTest, Negative_Create_new_Anytime)
+TEST_F(MQMockTest, Create_new_N_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Publish_Anytime)
+TEST_F(MQMockTest, Publish_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Subscribe_Anytime)
+TEST_F(MQMockTest, Subscribe_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Unsubscribe_Anytime)
+TEST_F(MQMockTest, Unsubscribe_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Create_Anytime)
+TEST_F(MQMockTest, Create_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Negative_Connect_will_set_Anytime)
+TEST_F(MQMockTest, Connect_will_set_N_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Connect_Anytime)
+TEST_F(MQMockTest, Connect_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
}
}
-TEST_F(MQMockTest, Positive_Connect_User_Anytime)
+TEST_F(MQMockTest, Connect_User_P_Anytime)
{
std::string username = "test";
std::string password = "test";
}
}
-TEST_F(MQMockTest, Positive_Disconnect_Anytime)
+TEST_F(MQMockTest, Disconnect_P_Anytime)
{
EXPECT_CALL(GetMock(), mosquitto_lib_init()).WillOnce(Return(MOSQ_ERR_SUCCESS));
EXPECT_CALL(GetMock(), mosquitto_new(testing::StrEq(TEST_CLIENT_ID), true, testing::_))
#include "AittTests.h"
+#define TEST_C_WILL_TOPIC "test/topic_will"
+
TEST(AITT_C_MANUAL, will_set_P)
{
int ret;
GMainLoop *loop = g_main_loop_new(nullptr, FALSE);
aitt_sub_h sub_handle = nullptr;
ret = aitt_subscribe(
- handle, "test/topic_will",
+ handle, TEST_C_WILL_TOPIC,
[](aitt_msg_h msg_handle, const void *msg, size_t msg_len, void *user_data) {
std::string received_data((const char *)msg, msg_len);
EXPECT_STREQ(received_data.c_str(), TEST_C_MSG);
- EXPECT_STREQ(aitt_msg_get_topic(msg_handle), TEST_C_TOPIC);
+ EXPECT_STREQ(aitt_msg_get_topic(msg_handle), TEST_C_WILL_TOPIC);
sub_called = true;
},
loop, &sub_handle);
aitt_h handle_will = aitt_new("test_will", nullptr);
ASSERT_NE(handle_will, nullptr);
- ret = aitt_will_set(handle_will, "test/topic_will", TEST_C_MSG, strlen(TEST_C_MSG),
+ ret = aitt_will_set(handle_will, TEST_C_WILL_TOPIC, TEST_C_MSG, strlen(TEST_C_MSG),
AITT_QOS_AT_LEAST_ONCE, false);
ASSERT_EQ(ret, AITT_ERROR_NONE);
void FlexbufPrinter::PrettyBlob(const flexbuffers::Reference &data, bool inline_value)
{
auto blob = data.AsBlob();
- auto root = flexbuffers::GetRoot(static_cast<const uint8_t *>(blob.data()), blob.size());
+ DBG_HEX_DUMP(blob.data(), blob.size());
+ // auto root = flexbuffers::GetRoot(static_cast<const uint8_t *>(blob.data()), blob.size());
- PrettyParsing(root, true);
+ // PrettyParsing(root, true);
}
void FlexbufPrinter::PrettyParsing(const flexbuffers::Reference &data, bool inline_value)