first commit
This commit is contained in:
bing
19
testing/CMakeLists.txt
Normal file
19
testing/CMakeLists.txt
Normal file
@@ -0,0 +1,19 @@
|
||||
include_directories(BEFORE SYSTEM ${gtest_SOURCE_DIR}/include)
|
||||
include_directories(../src)
|
||||
|
||||
add_executable(test_api
|
||||
connected_test.h
|
||||
test_connect.cpp
|
||||
test_channels.cpp
|
||||
test_exchange.cpp
|
||||
test_queue.cpp
|
||||
test_publish.cpp
|
||||
test_get.cpp
|
||||
test_consume.cpp
|
||||
test_message.cpp
|
||||
test_table.cpp
|
||||
test_ack.cpp
|
||||
test_nack.cpp
|
||||
)
|
||||
target_link_libraries(test_api SimpleAmqpClient gtest gtest_main)
|
||||
add_test(test_api test_api)
|
||||
58
testing/connected_test.h
Normal file
58
testing/connected_test.h
Normal file
@@ -0,0 +1,58 @@
|
||||
#ifndef CONNECTED_TEST_H
|
||||
#define CONNECTED_TEST_H
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <SimpleAmqpClient/SimpleAmqpClient.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
class connected_test : public ::testing::Test {
|
||||
public:
|
||||
virtual void SetUp() { channel = Channel::Open(GetTestOpenOpts()); }
|
||||
|
||||
Channel::ptr_t channel;
|
||||
|
||||
static Channel::OpenOpts GetTestOpenOpts() {
|
||||
Channel::OpenOpts ret;
|
||||
ret.host = GetBrokerHost();
|
||||
ret.auth = Channel::OpenOpts::BasicAuth("guest", "guest");
|
||||
return ret;
|
||||
}
|
||||
|
||||
static std::string GetBrokerHost() {
|
||||
const char *host = getenv("AMQP_BROKER");
|
||||
if (NULL != host) {
|
||||
return std::string(host);
|
||||
}
|
||||
return std::string("");
|
||||
}
|
||||
};
|
||||
|
||||
#endif // CONNECTED_TEST_H
|
||||
61
testing/test_ack.cpp
Normal file
61
testing/test_ack.cpp
Normal file
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, basic_ack_envelope) {
|
||||
const BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage(consumer);
|
||||
|
||||
channel->BasicAck(env);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_ack_deliveryinfo) {
|
||||
const BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
Envelope::DeliveryInfo info;
|
||||
{
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage(consumer);
|
||||
info = env->GetDeliveryInfo();
|
||||
}
|
||||
|
||||
channel->BasicAck(info);
|
||||
}
|
||||
147
testing/test_channels.cpp
Normal file
147
testing/test_channels.cpp
Normal file
@@ -0,0 +1,147 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, first_channel) {
|
||||
channel->DeclareExchange("test_channel_exchange",
|
||||
Channel::EXCHANGE_TYPE_FANOUT, false, false, true);
|
||||
channel->DeleteExchange("test_channel_exchange");
|
||||
}
|
||||
|
||||
// Check to see that channels are reused properly
|
||||
TEST_F(connected_test, channel_reuse) {
|
||||
channel->DeclareExchange("test_channel_exchange1",
|
||||
Channel::EXCHANGE_TYPE_FANOUT, false, false, true);
|
||||
channel->DeclareExchange("test_channel_exchange2",
|
||||
Channel::EXCHANGE_TYPE_FANOUT, false, false, true);
|
||||
channel->DeleteExchange("test_channel_exchange1");
|
||||
channel->DeleteExchange("test_channel_exchange2");
|
||||
}
|
||||
|
||||
// Check to see that a new channel is created when a channel is put in an
|
||||
// exception state
|
||||
TEST_F(connected_test, channel_recover_from_error) {
|
||||
EXPECT_THROW(channel->DeclareExchange("test_channel_exchangedoesnotexist",
|
||||
Channel::EXCHANGE_TYPE_FANOUT, true,
|
||||
false, true),
|
||||
ChannelException);
|
||||
|
||||
channel->DeclareExchange("test_channel_exchange",
|
||||
Channel::EXCHANGE_TYPE_FANOUT, false, false, true);
|
||||
channel->DeleteExchange("test_channel_exchange");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_success1) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
|
||||
channel->BasicPublish("", "test_channel_routingkey", message, false, false);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_success2) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
|
||||
channel->BasicPublish("", "test_channel_routingkey", message, false, false);
|
||||
channel->BasicPublish("", "test_channel_routingkey", message, false, false);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_returned_mandatory) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
|
||||
EXPECT_THROW(
|
||||
channel->BasicPublish("", "test_channel_noqueue", message, true, false),
|
||||
MessageReturnedException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_full_rejected) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
Table args;
|
||||
args.insert(TableEntry("x-max-length", 0));
|
||||
args.insert(TableEntry("x-overflow", "reject-publish"));
|
||||
std::string queue = channel->DeclareQueue("", false, false, true, true, args);
|
||||
|
||||
EXPECT_THROW(channel->BasicPublish("", queue, message),
|
||||
MessageRejectedException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_bad_exchange) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
|
||||
EXPECT_THROW(channel->BasicPublish("test_channel_badexchange",
|
||||
"test_channel_rk", message, false, false),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_publish_bad_exchange_recover) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
|
||||
EXPECT_THROW(channel->BasicPublish("test_channel_badexchange",
|
||||
"test_channel_rk", message, false, false),
|
||||
ChannelException);
|
||||
|
||||
channel->BasicPublish("", "test_channel_rk", message, false, false);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_consume_success) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
|
||||
Envelope::ptr_t consumed_envelope;
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, consumed_envelope));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, channel_consume_success_timeout) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Test message");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
Envelope::ptr_t consumed_envelope;
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, consumed_envelope, 5000));
|
||||
}
|
||||
|
||||
TEST(test_channels, big_message) {
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.frame_max = 4096;
|
||||
Channel::ptr_t channel = Channel::Open(opts);
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(std::string(4099, 'a'));
|
||||
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
Envelope::ptr_t consumed_envelope;
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, consumed_envelope));
|
||||
}
|
||||
131
testing/test_connect.cpp
Normal file
131
testing/test_connect.cpp
Normal file
@@ -0,0 +1,131 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "SimpleAmqpClient/SimpleAmqpClient.h"
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST(connecting_test, connect_default) {
|
||||
Channel::ptr_t channel = Channel::Create(connected_test::GetBrokerHost());
|
||||
}
|
||||
|
||||
TEST(connecting_test, connect_badhost) {
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Create("HostDoesntExist"),
|
||||
std::runtime_error);
|
||||
}
|
||||
|
||||
TEST(connecting_test, open_badhost) {
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.host = "HostDoesNotExist";
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Open(opts),
|
||||
std::runtime_error);
|
||||
}
|
||||
|
||||
TEST(connecting_test, connect_badauth) {
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Create(
|
||||
connected_test::GetBrokerHost(), 5672, "baduser", "badpass"),
|
||||
AccessRefusedException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, open_badauth) {
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.auth = Channel::OpenOpts::BasicAuth("baduser", "badpass");
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Open(opts),
|
||||
AccessRefusedException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, connect_badframesize) {
|
||||
// AMQP Spec says we have a minimum frame size of 4096
|
||||
EXPECT_THROW(
|
||||
Channel::ptr_t channel = Channel::Create(
|
||||
connected_test::GetBrokerHost(), 5672, "guest", "guest", "/", 400),
|
||||
AmqpResponseLibraryException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, open_badframesize) {
|
||||
// AMQP Spec says we have a minimum frame size of 4096
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.frame_max = 400;
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Open(opts),
|
||||
AmqpResponseLibraryException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, connect_badvhost) {
|
||||
EXPECT_THROW(Channel::ptr_t channel =
|
||||
Channel::Create(connected_test::GetBrokerHost(), 5672,
|
||||
"guest", "guest", "nonexitant_vhost"),
|
||||
NotAllowedException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, open_badvhost) {
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.vhost = "bad_vhost";
|
||||
EXPECT_THROW(Channel::ptr_t channel = Channel::Open(opts),
|
||||
NotAllowedException);
|
||||
}
|
||||
|
||||
TEST(connecting_test, connect_using_uri) {
|
||||
std::string host_uri = "amqp://" + connected_test::GetBrokerHost();
|
||||
Channel::ptr_t channel = Channel::CreateFromUri(host_uri);
|
||||
}
|
||||
|
||||
TEST(connecting_test, openopts_from_uri) {
|
||||
Channel::OpenOpts expected;
|
||||
expected.host = "host";
|
||||
expected.vhost = "vhost";
|
||||
expected.port = 123;
|
||||
expected.auth = Channel::OpenOpts::BasicAuth("user", "pass");
|
||||
|
||||
EXPECT_EQ(expected,
|
||||
Channel::OpenOpts::FromUri("amqp://user:pass@host:123/vhost"));
|
||||
}
|
||||
|
||||
TEST(connecting_test, openopts_from_uri_defaults) {
|
||||
Channel::OpenOpts expected;
|
||||
expected.host = "host";
|
||||
expected.vhost = "/";
|
||||
expected.port = 5672;
|
||||
expected.auth = Channel::OpenOpts::BasicAuth("guest", "guest");
|
||||
EXPECT_EQ(expected, Channel::OpenOpts::FromUri("amqp://host"));
|
||||
}
|
||||
|
||||
TEST(connecting_test, openopts_from_amqps_uri) {
|
||||
Channel::OpenOpts expected;
|
||||
expected.host = "host";
|
||||
expected.vhost = "vhost";
|
||||
expected.port = 123;
|
||||
expected.auth = Channel::OpenOpts::BasicAuth("user", "pass");
|
||||
expected.tls_params = Channel::OpenOpts::TLSParams();
|
||||
}
|
||||
|
||||
TEST(connecting_test, openopts_fromuri_bad) {
|
||||
EXPECT_THROW(Channel::OpenOpts::FromUri("not-a-valid-uri"), BadUriException);
|
||||
}
|
||||
228
testing/test_consume.cpp
Normal file
228
testing/test_consume.cpp
Normal file
@@ -0,0 +1,228 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, basic_consume) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_badqueue) {
|
||||
EXPECT_THROW(channel->BasicConsume("test_consume_noexistqueue"),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_duplicatetag) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
EXPECT_THROW(channel->BasicConsume(queue, consumer), ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_cancel_consumer) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
channel->BasicCancel(consumer);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_cancel_bad_consumer) {
|
||||
EXPECT_THROW(channel->BasicCancel("test_consume_noexistconsumer"),
|
||||
ConsumerTagNotFoundException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_cancel_cancelled_consumer) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
channel->BasicCancel(consumer);
|
||||
EXPECT_THROW(channel->BasicCancel(consumer), ConsumerTagNotFoundException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_message) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue);
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
Envelope::ptr_t delivered;
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, delivered, -1));
|
||||
EXPECT_EQ(consumer, delivered->ConsumerTag());
|
||||
EXPECT_EQ("", delivered->Exchange());
|
||||
EXPECT_EQ(queue, delivered->RoutingKey());
|
||||
EXPECT_EQ(message->Body(), delivered->Message()->Body());
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_message_bad_consumer) {
|
||||
EXPECT_THROW(channel->BasicConsumeMessage("test_consume_noexistconsumer"),
|
||||
ConsumerTagNotFoundException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_inital_qos) {
|
||||
BasicMessage::ptr_t message1 = BasicMessage::Create("Message1");
|
||||
BasicMessage::ptr_t message2 = BasicMessage::Create("Message2");
|
||||
BasicMessage::ptr_t message3 = BasicMessage::Create("Message3");
|
||||
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message1, true);
|
||||
channel->BasicPublish("", queue, message2, true);
|
||||
channel->BasicPublish("", queue, message3, true);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
Envelope::ptr_t received1, received2;
|
||||
ASSERT_TRUE(channel->BasicConsumeMessage(consumer, received1, 100));
|
||||
|
||||
EXPECT_FALSE(channel->BasicConsumeMessage(consumer, received2, 100));
|
||||
channel->BasicAck(received1);
|
||||
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, received2, 100));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_2consumers) {
|
||||
BasicMessage::ptr_t message1 = BasicMessage::Create("Message1");
|
||||
BasicMessage::ptr_t message2 = BasicMessage::Create("Message2");
|
||||
BasicMessage::ptr_t message3 = BasicMessage::Create("Message3");
|
||||
|
||||
std::string queue1 = channel->DeclareQueue("");
|
||||
std::string queue2 = channel->DeclareQueue("");
|
||||
std::string queue3 = channel->DeclareQueue("");
|
||||
|
||||
channel->BasicPublish("", queue1, message1);
|
||||
channel->BasicPublish("", queue2, message2);
|
||||
channel->BasicPublish("", queue3, message3);
|
||||
|
||||
std::string consumer1 = channel->BasicConsume(queue1, "", true, false);
|
||||
std::string consumer2 = channel->BasicConsume(queue2, "", true, false);
|
||||
|
||||
Envelope::ptr_t envelope1;
|
||||
Envelope::ptr_t envelope2;
|
||||
Envelope::ptr_t envelope3;
|
||||
|
||||
channel->BasicConsumeMessage(consumer1, envelope1);
|
||||
channel->BasicAck(envelope1);
|
||||
channel->BasicConsumeMessage(consumer2, envelope2);
|
||||
channel->BasicAck(envelope2);
|
||||
channel->BasicGet(envelope3, queue3);
|
||||
channel->BasicAck(envelope3);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_consume_1000messages) {
|
||||
BasicMessage::ptr_t message1 = BasicMessage::Create("Message1");
|
||||
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "");
|
||||
|
||||
Envelope::ptr_t msg;
|
||||
for (int i = 0; i < 1000; ++i) {
|
||||
message1->Timestamp(i);
|
||||
channel->BasicPublish("", queue, message1, true);
|
||||
channel->BasicConsumeMessage(consumer, msg);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_recover) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message1");
|
||||
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
Envelope::ptr_t message1;
|
||||
Envelope::ptr_t message2;
|
||||
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, message1));
|
||||
channel->BasicRecover(consumer);
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, message2));
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_recover_badconsumer) {
|
||||
EXPECT_THROW(channel->BasicRecover("consumer_notexist"),
|
||||
ConsumerTagNotFoundException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_qos) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
channel->BasicPublish("", queue, BasicMessage::Create("Message1"));
|
||||
channel->BasicPublish("", queue, BasicMessage::Create("Message2"));
|
||||
|
||||
Envelope::ptr_t incoming;
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, incoming, 100));
|
||||
EXPECT_FALSE(channel->BasicConsumeMessage(consumer, incoming, 100));
|
||||
|
||||
channel->BasicQos(consumer, 2);
|
||||
EXPECT_TRUE(channel->BasicConsumeMessage(consumer, incoming, 100));
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_qos_badconsumer) {
|
||||
EXPECT_THROW(channel->BasicQos("consumer_notexist", 1),
|
||||
ConsumerTagNotFoundException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, consumer_cancelled) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
channel->DeleteQueue(queue);
|
||||
|
||||
EXPECT_THROW(channel->BasicConsumeMessage(consumer),
|
||||
ConsumerCancelledException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, consumer_cancelled_one_message) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
channel->BasicPublish("", queue, BasicMessage::Create("Message"));
|
||||
channel->BasicConsumeMessage(consumer);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
|
||||
EXPECT_THROW(channel->BasicConsumeMessage(consumer),
|
||||
ConsumerCancelledException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, consume_multiple) {
|
||||
std::string queue1 = channel->DeclareQueue("");
|
||||
std::string queue2 = channel->DeclareQueue("");
|
||||
|
||||
std::string Body = "Message 1";
|
||||
channel->BasicPublish("", queue1, BasicMessage::Create(Body));
|
||||
|
||||
channel->BasicConsume(queue1);
|
||||
channel->BasicConsume(queue2);
|
||||
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage();
|
||||
|
||||
EXPECT_EQ(Body, env->Message()->Body());
|
||||
}
|
||||
164
testing/test_exchange.cpp
Normal file
164
testing/test_exchange.cpp
Normal file
@@ -0,0 +1,164 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <SimpleAmqpClient/SimpleAmqpClient.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
TEST_F(connected_test, declare_exchange_defaults) {
|
||||
channel->DeclareExchange("declare_defaults");
|
||||
channel->DeleteExchange("declare_defaults");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_direct) {
|
||||
channel->DeclareExchange("declare_direct", Channel::EXCHANGE_TYPE_DIRECT);
|
||||
channel->DeleteExchange("declare_direct");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_fanout) {
|
||||
channel->DeclareExchange("declare_fanout", Channel::EXCHANGE_TYPE_FANOUT);
|
||||
channel->DeleteExchange("declare_fanout");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_topic) {
|
||||
channel->DeclareExchange("declare_topic", Channel::EXCHANGE_TYPE_TOPIC);
|
||||
channel->DeleteExchange("declare_topic");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, check_exchange_exists_succeeds) {
|
||||
channel->DeclareExchange("declare_exists");
|
||||
EXPECT_TRUE(channel->CheckExchangeExists("declare_exists"));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_passive_good) {
|
||||
channel->DeclareExchange("declare_passive", Channel::EXCHANGE_TYPE_DIRECT);
|
||||
channel->DeclareExchange("declare_passive", Channel::EXCHANGE_TYPE_DIRECT,
|
||||
true);
|
||||
|
||||
channel->DeleteExchange("declare_passive");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, check_exchange_exists_fails) {
|
||||
EXPECT_FALSE(channel->CheckExchangeExists("declare_notexist"));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_passive_notexist) {
|
||||
EXPECT_THROW(channel->DeclareExchange("declare_passive_notexist",
|
||||
Channel::EXCHANGE_TYPE_DIRECT, true),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_typemismatch) {
|
||||
channel->DeclareExchange("declare_typemismatch",
|
||||
Channel::EXCHANGE_TYPE_DIRECT);
|
||||
EXPECT_THROW(channel->DeclareExchange("declare_typemismatch",
|
||||
Channel::EXCHANGE_TYPE_FANOUT),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteExchange("declare_typemismatch");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_typemismatch2) {
|
||||
channel->DeclareExchange("declare_typemismatch",
|
||||
Channel::EXCHANGE_TYPE_DIRECT);
|
||||
EXPECT_THROW(
|
||||
channel->DeclareExchange("declare_typemismatch",
|
||||
Channel::EXCHANGE_TYPE_DIRECT, false, true),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteExchange("declare_typemismatch");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_durable) {
|
||||
channel->DeclareExchange("declare_durable", Channel::EXCHANGE_TYPE_DIRECT,
|
||||
false, true);
|
||||
|
||||
channel->DeleteExchange("declare_durable");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, declare_exchange_autodelete) {
|
||||
channel->DeclareExchange("declare_autodelete", Channel::EXCHANGE_TYPE_DIRECT,
|
||||
false, false, true);
|
||||
|
||||
channel->DeleteExchange("declare_autodelete");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, delete_exchange) {
|
||||
channel->DeclareExchange("delete_exchange");
|
||||
channel->DeleteExchange("delete_exchange");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, delete_exhange_ifunused) {
|
||||
channel->DeclareExchange("exchange_used", Channel::EXCHANGE_TYPE_DIRECT);
|
||||
|
||||
channel->DeleteExchange("exchange_used", true);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, delete_exhange_ifused) {
|
||||
channel->DeclareExchange("exchange_used", Channel::EXCHANGE_TYPE_DIRECT);
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BindQueue(queue, "exchange_used", "whatever");
|
||||
|
||||
EXPECT_THROW(channel->DeleteExchange("exchange_used", true),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
channel->DeleteExchange("exchange_used");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, bind_exchange) {
|
||||
channel->DeclareExchange("exchange_bind_dest");
|
||||
channel->DeclareExchange("exchange_bind_src");
|
||||
|
||||
channel->BindExchange("exchange_bind_dest", "exchange_bind_src", "rk");
|
||||
|
||||
channel->DeleteExchange("exchange_bind_dest");
|
||||
channel->DeleteExchange("exchange_bind_src");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, bind_exchange_badexchange) {
|
||||
channel->DeclareExchange("exchange_bind_dest");
|
||||
|
||||
EXPECT_THROW(channel->BindExchange("exchange_bind_dest",
|
||||
"exchange_bind_notexist", "rk"),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteExchange("exchange_bind_dest");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, unbind_exchange) {
|
||||
channel->DeclareExchange("exchange_bind_dest");
|
||||
channel->DeclareExchange("exchange_bind_src");
|
||||
|
||||
channel->BindExchange("exchange_bind_dest", "exchange_bind_src", "rk");
|
||||
channel->UnbindExchange("exchange_bind_dest", "exchange_bind_src", "rk");
|
||||
|
||||
channel->DeleteExchange("exchange_bind_dest");
|
||||
channel->DeleteExchange("exchange_bind_src");
|
||||
}
|
||||
81
testing/test_get.cpp
Normal file
81
testing/test_get.cpp
Normal file
@@ -0,0 +1,81 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, get_ok) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
|
||||
Envelope::ptr_t new_message;
|
||||
EXPECT_TRUE(channel->BasicGet(new_message, queue));
|
||||
EXPECT_EQ(message->Body(), new_message->Message()->Body());
|
||||
}
|
||||
|
||||
TEST_F(connected_test, get_empty) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
|
||||
Envelope::ptr_t new_message;
|
||||
EXPECT_FALSE(channel->BasicGet(new_message, queue));
|
||||
}
|
||||
|
||||
TEST(test_get, get_big) {
|
||||
// Smallest frame size allowed by AMQP
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.frame_max = 4096;
|
||||
Channel::ptr_t channel = Channel::Open(opts);
|
||||
// Create a message with a body larger than a single frame
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(std::string(4099, 'a'));
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
|
||||
channel->BasicPublish("", queue, message);
|
||||
Envelope::ptr_t new_message;
|
||||
EXPECT_TRUE(channel->BasicGet(new_message, queue));
|
||||
EXPECT_EQ(message->Body(), new_message->Message()->Body());
|
||||
}
|
||||
|
||||
TEST_F(connected_test, bad_queue) {
|
||||
Envelope::ptr_t new_message;
|
||||
EXPECT_THROW(channel->BasicGet(new_message, "test_get_nonexistantqueue"),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, ack_message) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
|
||||
Envelope::ptr_t new_message;
|
||||
EXPECT_TRUE(channel->BasicGet(new_message, queue, false));
|
||||
channel->BasicAck(new_message);
|
||||
EXPECT_FALSE(channel->BasicGet(new_message, queue, false));
|
||||
}
|
||||
134
testing/test_message.cpp
Normal file
134
testing/test_message.cpp
Normal file
@@ -0,0 +1,134 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <amqp.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <boost/array.hpp>
|
||||
#include <iostream>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST(basic_message, empty_message) {
|
||||
BasicMessage::ptr_t empty_message = BasicMessage::Create();
|
||||
|
||||
EXPECT_EQ(std::string(), empty_message->Body());
|
||||
|
||||
// Allow the message to destruct
|
||||
}
|
||||
|
||||
TEST(basic_message, empty_message_add_body) {
|
||||
BasicMessage::ptr_t empty_message = BasicMessage::Create();
|
||||
|
||||
EXPECT_EQ(std::string(), empty_message->Body());
|
||||
|
||||
const std::string body("Message Body");
|
||||
empty_message->Body(body);
|
||||
|
||||
EXPECT_EQ(body, empty_message->Body());
|
||||
|
||||
// Allow the message to destruct
|
||||
}
|
||||
|
||||
TEST(basic_message, empty_message_add_body2) {
|
||||
BasicMessage::ptr_t empty_message = BasicMessage::Create();
|
||||
|
||||
EXPECT_EQ(std::string(), empty_message->Body());
|
||||
|
||||
const std::string body("Message Body");
|
||||
empty_message->Body(body);
|
||||
|
||||
EXPECT_EQ(body, empty_message->Body());
|
||||
|
||||
const std::string body2("Second body");
|
||||
empty_message->Body(body2);
|
||||
EXPECT_EQ(body2, empty_message->Body());
|
||||
|
||||
// Allow the message to destruct
|
||||
}
|
||||
|
||||
TEST(basic_message, initial_message_replace) {
|
||||
const std::string first_body("First message Body");
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(first_body);
|
||||
|
||||
EXPECT_EQ(first_body, message->Body());
|
||||
|
||||
const std::string second_body("Second message Body");
|
||||
message->Body(second_body);
|
||||
|
||||
EXPECT_EQ(second_body, message->Body());
|
||||
|
||||
// Allow the message to destruct
|
||||
}
|
||||
|
||||
TEST(basic_message, initial_message_replace2) {
|
||||
const std::string first_body("First message body");
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(first_body);
|
||||
EXPECT_EQ(first_body, message->Body());
|
||||
|
||||
const std::string second_body("second message body");
|
||||
message->Body(second_body);
|
||||
EXPECT_EQ(second_body, message->Body());
|
||||
|
||||
const std::string third_body("3rd Body");
|
||||
message->Body(third_body);
|
||||
EXPECT_EQ(third_body, message->Body());
|
||||
}
|
||||
|
||||
TEST(basic_message, embedded_nulls) {
|
||||
const boost::array<char, 7> message_data = {
|
||||
{'a', 'b', 'c', 0, '1', '2', '3'}};
|
||||
const std::string body(message_data.data(), message_data.size());
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(body);
|
||||
EXPECT_EQ(body, message->Body());
|
||||
|
||||
const boost::array<char, 7> message_data2 = {
|
||||
{'1', '2', '3', 0, 'a', 'b', 'c'}};
|
||||
const std::string body2(message_data2.data(), message_data2.size());
|
||||
message->Body(body2);
|
||||
EXPECT_EQ(body2, message->Body());
|
||||
}
|
||||
|
||||
TEST_F(connected_test, replaced_received_body) {
|
||||
const std::string queue = channel->DeclareQueue("");
|
||||
const std::string consumer = channel->BasicConsume(queue);
|
||||
|
||||
const std::string body("First Message Body");
|
||||
BasicMessage::ptr_t out_message = BasicMessage::Create(body);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
|
||||
Envelope::ptr_t envelope = channel->BasicConsumeMessage(consumer);
|
||||
BasicMessage::ptr_t in_message = envelope->Message();
|
||||
EXPECT_EQ(out_message->Body(), in_message->Body());
|
||||
|
||||
const std::string body2("Second message body");
|
||||
in_message->Body(body2);
|
||||
EXPECT_EQ(body2, in_message->Body());
|
||||
}
|
||||
77
testing/test_nack.cpp
Normal file
77
testing/test_nack.cpp
Normal file
@@ -0,0 +1,77 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, basic_nack_envelope) {
|
||||
const BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage(consumer);
|
||||
|
||||
channel->BasicReject(env, false);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_nack_deliveryinfo) {
|
||||
const BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
Envelope::DeliveryInfo info;
|
||||
{
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage(consumer);
|
||||
info = env->GetDeliveryInfo();
|
||||
}
|
||||
|
||||
channel->BasicReject(info, false);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_nack_envelope_with_requeue) {
|
||||
const BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->BasicPublish("", queue, message);
|
||||
|
||||
std::string consumer = channel->BasicConsume(queue, "", true, false);
|
||||
|
||||
Envelope::ptr_t env = channel->BasicConsumeMessage(consumer);
|
||||
|
||||
channel->BasicReject(env, true);
|
||||
|
||||
Envelope::ptr_t env2 = channel->BasicConsumeMessage(consumer);
|
||||
|
||||
channel->BasicReject(env2, false);
|
||||
}
|
||||
88
testing/test_publish.cpp
Normal file
88
testing/test_publish.cpp
Normal file
@@ -0,0 +1,88 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST_F(connected_test, publish_success) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
|
||||
channel->BasicPublish("", "test_publish_rk", message);
|
||||
}
|
||||
|
||||
TEST(test_publish, publish_large_message) {
|
||||
// Smallest frame size allowed by AMQP
|
||||
Channel::OpenOpts opts = connected_test::GetTestOpenOpts();
|
||||
opts.frame_max = 4096;
|
||||
Channel::ptr_t channel = Channel::Open(opts);
|
||||
// Create a message with a body larger than a single frame
|
||||
BasicMessage::ptr_t message = BasicMessage::Create(std::string(4099, 'a'));
|
||||
|
||||
channel->BasicPublish("", "test_publish_rk", message);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, publish_badexchange) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
|
||||
EXPECT_THROW(channel->BasicPublish("test_publish_notexist", "test_publish_rk",
|
||||
message),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, publish_recover_from_error) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
|
||||
EXPECT_THROW(channel->BasicPublish("test_publish_notexist", "test_publish_rk",
|
||||
message),
|
||||
ChannelException);
|
||||
channel->BasicPublish("", "test_publish_rk", message);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, publish_mandatory_fail) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
|
||||
EXPECT_THROW(
|
||||
channel->BasicPublish("", "test_publish_notexist", message, true),
|
||||
MessageReturnedException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, publish_mandatory_success) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, publish_immediate_success) {
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("message body");
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string consumer = channel->BasicConsume(queue, "");
|
||||
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
}
|
||||
247
testing/test_queue.cpp
Normal file
247
testing/test_queue.cpp
Normal file
@@ -0,0 +1,247 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
TEST_F(connected_test, queue_declare) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_named) {
|
||||
std::string queue = channel->DeclareQueue("declare_queue_test");
|
||||
EXPECT_EQ("declare_queue_test", queue);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, check_queue_exists_success) {
|
||||
channel->DeclareQueue("declare_queue_passive");
|
||||
EXPECT_TRUE(channel->CheckQueueExists("declare_queue_passive"));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_passive) {
|
||||
std::string queue = channel->DeclareQueue("declare_queue_passive");
|
||||
channel->DeclareQueue("declare_queue_passive", true);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, check_queue_exists_fail) {
|
||||
EXPECT_FALSE(channel->CheckQueueExists("declare_queue_notexist"));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_passive_fail) {
|
||||
EXPECT_THROW(channel->DeclareQueue("declare_queue_notexist", true),
|
||||
ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_durable) {
|
||||
std::string queue =
|
||||
channel->DeclareQueue("declare_queue_durable", false, true, false);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_notexclusive) {
|
||||
std::string queue =
|
||||
channel->DeclareQueue("declare_queue_notexclusive", false, false, false);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_notautodelete) {
|
||||
std::string queue = channel->DeclareQueue("declare_queue_notautodelete",
|
||||
false, false, false, false);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_counts) {
|
||||
boost::uint32_t message_count = 123;
|
||||
boost::uint32_t consumer_count = 123;
|
||||
|
||||
std::string queue = channel->DeclareQueueWithCounts(
|
||||
"queue_declare_counts", message_count, consumer_count);
|
||||
|
||||
EXPECT_NE("", queue);
|
||||
EXPECT_EQ(0, message_count);
|
||||
EXPECT_EQ(0, consumer_count);
|
||||
|
||||
const std::string body("Test Message");
|
||||
BasicMessage::ptr_t out_message = BasicMessage::Create(body);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
|
||||
std::string queue2 = channel->DeclareQueueWithCounts(
|
||||
"queue_declare_counts", message_count, consumer_count);
|
||||
|
||||
EXPECT_NE("", queue2);
|
||||
EXPECT_EQ(3, message_count);
|
||||
EXPECT_EQ(0, consumer_count);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_declare_counts_table) {
|
||||
boost::uint32_t message_count = 123;
|
||||
boost::uint32_t consumer_count = 123;
|
||||
|
||||
Table qTable;
|
||||
|
||||
qTable.insert(TableEntry(TableKey("IsATest"), TableValue(true)));
|
||||
|
||||
std::string queue = channel->DeclareQueueWithCounts(
|
||||
"queue_declare_counts_table", message_count, consumer_count, false, false,
|
||||
true, true, qTable);
|
||||
|
||||
EXPECT_NE("", queue);
|
||||
EXPECT_EQ(0, message_count);
|
||||
EXPECT_EQ(0, consumer_count);
|
||||
|
||||
const std::string body("Test Message");
|
||||
BasicMessage::ptr_t out_message = BasicMessage::Create(body);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
channel->BasicPublish("", queue, out_message);
|
||||
|
||||
std::string queue2 = channel->DeclareQueueWithCounts(
|
||||
"queue_declare_counts_table", message_count, consumer_count, false, false,
|
||||
true, true, qTable);
|
||||
|
||||
EXPECT_NE("", queue2);
|
||||
EXPECT_EQ(3, message_count);
|
||||
EXPECT_EQ(0, consumer_count);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_delete) {
|
||||
std::string queue = channel->DeclareQueue("delete_queue");
|
||||
channel->DeleteQueue(queue);
|
||||
EXPECT_THROW(channel->DeclareQueue(queue, true), ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_delete_ifunused) {
|
||||
std::string queue = channel->DeclareQueue("delete_queue_ifunused");
|
||||
channel->DeleteQueue(queue, true);
|
||||
EXPECT_THROW(channel->DeclareQueue(queue, true), ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_delete_ifused) {
|
||||
std::string queue = channel->DeclareQueue("delete_queue_ifused");
|
||||
channel->BasicConsume(queue);
|
||||
EXPECT_THROW(channel->DeleteQueue(queue, true), ChannelException);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_delete_ifempty) {
|
||||
std::string queue = channel->DeclareQueue("delete_queue_ifempty");
|
||||
channel->DeleteQueue(queue, false, true);
|
||||
|
||||
EXPECT_THROW(channel->DeclareQueue(queue, true), ChannelException);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_delete_ifnotempty) {
|
||||
std::string queue = channel->DeclareQueue("delete_queue_ifnotempty");
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message body");
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
|
||||
EXPECT_THROW(channel->DeleteQueue(queue, false, true), ChannelException);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_bind) {
|
||||
channel->DeclareExchange("queue_bind_exchange");
|
||||
std::string queue = channel->DeclareQueue("queue_bind_queue");
|
||||
|
||||
channel->BindQueue(queue, "queue_bind_exchange", "rk");
|
||||
|
||||
channel->DeleteExchange("queue_bind_exchange");
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_bind_badexchange) {
|
||||
std::string queue = channel->DeclareQueue("queue_bind_badexchange");
|
||||
|
||||
EXPECT_THROW(channel->BindQueue(queue, "queue_bind_exchangenotexist", "rk"),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_bind_badqueue) {
|
||||
channel->DeclareExchange("queue_bind_badqueue");
|
||||
|
||||
EXPECT_THROW(channel->BindQueue("queue_bind_queuenotexist",
|
||||
"queue_bind_badqueue", "rk"),
|
||||
ChannelException);
|
||||
|
||||
channel->DeleteExchange("queue_bind_badqueue");
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_bind_nokey) {
|
||||
channel->DeclareExchange("queue_bind_exchange");
|
||||
std::string queue = channel->DeclareQueue("queue_bind_queue");
|
||||
|
||||
channel->BindQueue(queue, "queue_bind_exchange");
|
||||
|
||||
channel->DeleteExchange("queue_bind_exchange");
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_unbind) {
|
||||
channel->DeclareExchange("queue_unbind_exchange");
|
||||
std::string queue = channel->DeclareQueue("queue_unbind_queue");
|
||||
channel->BindQueue(queue, "queue_unbind_exchange", "rk");
|
||||
|
||||
channel->UnbindQueue(queue, "queue_unbind_exchange", "rk");
|
||||
|
||||
channel->DeleteExchange("queue_unbind_exchange");
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_purge) {
|
||||
std::string queue = channel->DeclareQueue("queue_purge");
|
||||
BasicMessage::ptr_t message = BasicMessage::Create("Message Body");
|
||||
channel->BasicPublish("", queue, message, true);
|
||||
|
||||
channel->PurgeQueue(queue);
|
||||
Envelope::ptr_t envelope;
|
||||
EXPECT_FALSE(channel->BasicGet(envelope, queue));
|
||||
|
||||
channel->DeleteQueue(queue);
|
||||
}
|
||||
|
||||
TEST_F(connected_test, queue_purge_badqueue) {
|
||||
EXPECT_THROW(channel->PurgeQueue("purge_queue_queuenotexist"),
|
||||
ChannelException);
|
||||
}
|
||||
896
testing/test_table.cpp
Normal file
896
testing/test_table.cpp
Normal file
@@ -0,0 +1,896 @@
|
||||
/*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MIT
|
||||
*
|
||||
* Copyright (c) 2010-2013 Alan Antonuk
|
||||
*
|
||||
* 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.
|
||||
* ***** END LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <algorithm>
|
||||
#include <boost/type_traits/remove_cv.hpp>
|
||||
#include <boost/variant/get.hpp>
|
||||
#include <ctime>
|
||||
|
||||
#include "connected_test.h"
|
||||
|
||||
using namespace AmqpClient;
|
||||
|
||||
TEST(table_value, void_value) {
|
||||
TableValue value;
|
||||
EXPECT_EQ(TableValue::VT_void, value.GetType());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set();
|
||||
EXPECT_EQ(TableValue::VT_void, value.GetType());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, bool_value) {
|
||||
bool v1 = true;
|
||||
bool v2 = false;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_bool, value.GetType());
|
||||
|
||||
EXPECT_EQ(v1, value.GetBool());
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_bool, value.GetType());
|
||||
|
||||
EXPECT_EQ(v2, value.GetBool());
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, uint8_value) {
|
||||
boost::uint8_t v1 = 1;
|
||||
boost::uint8_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_uint8, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetUint8());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_uint8, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetUint8());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, int8_value) {
|
||||
boost::int8_t v1 = 1;
|
||||
boost::int8_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_int8, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetInt8());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_int8, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetInt8());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, uint16_value) {
|
||||
boost::uint16_t v1 = 1;
|
||||
boost::uint16_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_uint16, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetUint16());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_uint16, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetUint16());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, int16_value) {
|
||||
boost::int16_t v1 = 1;
|
||||
boost::int16_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_int16, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetInt16());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_int16, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetInt16());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, uint32_value) {
|
||||
boost::uint32_t v1 = 1;
|
||||
boost::uint32_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_uint32, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetUint32());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_uint32, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetUint32());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, int32_value) {
|
||||
boost::int32_t v1 = 1;
|
||||
boost::int32_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_int32, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetInt32());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_int32, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetInt32());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, timestamp_value) {
|
||||
std::time_t v1 = 1;
|
||||
std::time_t v2 = 2;
|
||||
|
||||
TableValue value = TableValue::Timestamp(v1);
|
||||
EXPECT_EQ(TableValue::VT_timestamp, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetTimestamp());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.SetTimestamp(v2);
|
||||
EXPECT_EQ(TableValue::VT_timestamp, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetTimestamp());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, int64_value) {
|
||||
boost::int64_t v1 = 1;
|
||||
boost::int64_t v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_int64, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetInt64());
|
||||
EXPECT_EQ(v1, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_int64, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetInt64());
|
||||
EXPECT_EQ(v2, value.GetInteger());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, float_value) {
|
||||
float v1 = 1.;
|
||||
float v2 = 2.;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_float, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetFloat());
|
||||
EXPECT_EQ(v1, value.GetReal());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_float, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetFloat());
|
||||
EXPECT_EQ(v2, value.GetReal());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, double_value) {
|
||||
double v1 = 1;
|
||||
double v2 = 2;
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_double, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetDouble());
|
||||
EXPECT_EQ(v1, value.GetReal());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_double, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetDouble());
|
||||
EXPECT_EQ(v2, value.GetReal());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, string_value) {
|
||||
std::string v1 = "1";
|
||||
std::string v2 = "2";
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_string, value.GetType());
|
||||
EXPECT_EQ(v1, value.GetString());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_string, value.GetType());
|
||||
EXPECT_EQ(v2, value.GetString());
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, array_value) {
|
||||
Array v1;
|
||||
v1.push_back(TableValue("first"));
|
||||
|
||||
Array v2;
|
||||
v2.push_back(TableValue((int32_t)2));
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_array, value.GetType());
|
||||
Array v1a = value.GetArray();
|
||||
EXPECT_TRUE(v1.size() == v1a.size());
|
||||
EXPECT_TRUE(std::equal(v1.begin(), v1.end(), v1a.begin()));
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_array, value.GetType());
|
||||
Array v2a = value.GetArray();
|
||||
EXPECT_TRUE(v2.size() == v2a.size());
|
||||
EXPECT_TRUE(std::equal(v2.begin(), v2.end(), v2a.begin()));
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTable(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, table_value) {
|
||||
Table v1;
|
||||
v1.insert(TableEntry("one", 10));
|
||||
|
||||
Table v2;
|
||||
v2.insert(TableEntry("two", 22.2));
|
||||
|
||||
TableValue value(v1);
|
||||
EXPECT_EQ(TableValue::VT_table, value.GetType());
|
||||
Table v1a = value.GetTable();
|
||||
EXPECT_TRUE(v1.size() == v1a.size());
|
||||
EXPECT_TRUE(std::equal(v1.begin(), v1.end(), v1a.begin()));
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
|
||||
value.Set(v2);
|
||||
EXPECT_EQ(TableValue::VT_table, value.GetType());
|
||||
Table v2a = value.GetTable();
|
||||
EXPECT_TRUE(v2.size() == v2a.size());
|
||||
EXPECT_TRUE(std::equal(v2.begin(), v2.end(), v2a.begin()));
|
||||
|
||||
EXPECT_THROW(value.GetBool(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt8(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt16(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetUint32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt32(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInt64(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetInteger(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetFloat(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetDouble(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetReal(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetString(), boost::bad_get);
|
||||
EXPECT_THROW(value.GetArray(), boost::bad_get);
|
||||
}
|
||||
|
||||
TEST(table_value, equality) {
|
||||
TableValue void_val1;
|
||||
TableValue void_val2;
|
||||
EXPECT_EQ(void_val1, void_val1);
|
||||
EXPECT_EQ(void_val1, void_val2);
|
||||
|
||||
TableValue bool_val1(true);
|
||||
TableValue bool_val2(bool_val1);
|
||||
TableValue bool_val3(false);
|
||||
TableValue bool_val4;
|
||||
bool_val4.Set(bool_val3.GetBool());
|
||||
EXPECT_EQ(bool_val1, bool_val1);
|
||||
EXPECT_EQ(bool_val1, bool_val2);
|
||||
EXPECT_NE(bool_val1, bool_val3);
|
||||
EXPECT_NE(void_val1, bool_val1);
|
||||
EXPECT_EQ(bool_val3, bool_val4);
|
||||
|
||||
TableValue int8_val1(int8_t(8));
|
||||
TableValue int8_val2(int8_val1);
|
||||
TableValue int8_val3(int8_t(9));
|
||||
EXPECT_EQ(int8_val1, int8_val1);
|
||||
EXPECT_EQ(int8_val1, int8_val2);
|
||||
EXPECT_NE(int8_val1, int8_val3);
|
||||
|
||||
TableValue string_val1("one");
|
||||
TableValue string_val2(std::string("one"));
|
||||
std::string empty;
|
||||
TableValue string_val3(empty);
|
||||
EXPECT_EQ(string_val1, string_val1);
|
||||
EXPECT_EQ(string_val1, string_val2);
|
||||
EXPECT_NE(string_val1, string_val3);
|
||||
|
||||
std::vector<TableValue> vec_val1;
|
||||
vec_val1.push_back(void_val1);
|
||||
vec_val1.push_back(int8_val1);
|
||||
std::vector<TableValue> vec_val2;
|
||||
vec_val2.push_back(bool_val1);
|
||||
vec_val2.push_back(void_val1);
|
||||
TableValue array_val1(vec_val1);
|
||||
TableValue array_val2(array_val1);
|
||||
TableValue array_val3(vec_val2);
|
||||
|
||||
EXPECT_EQ(array_val1, array_val1);
|
||||
EXPECT_EQ(array_val1, array_val2);
|
||||
EXPECT_NE(array_val1, array_val3);
|
||||
|
||||
Table tbl1;
|
||||
tbl1.insert(TableEntry("key1", int8_val1));
|
||||
tbl1.insert(TableEntry("key2", "string"));
|
||||
Table tbl2;
|
||||
tbl2.insert(TableEntry("key1", void_val1));
|
||||
tbl2.insert(TableEntry("array", array_val1));
|
||||
|
||||
TableValue table_val1(tbl1);
|
||||
TableValue table_val2(tbl1);
|
||||
TableValue table_val3(tbl2);
|
||||
|
||||
EXPECT_EQ(table_val1, table_val1);
|
||||
EXPECT_EQ(table_val1, table_val2);
|
||||
EXPECT_NE(table_val1, table_val3);
|
||||
}
|
||||
|
||||
TEST(table, convert_to_rabbitmq) {
|
||||
Table table_in;
|
||||
table_in.insert(TableEntry("void_key", TableValue()));
|
||||
table_in.insert(TableEntry("bool_key", true));
|
||||
table_in.insert(TableEntry("uint8_key", uint8_t(8)));
|
||||
table_in.insert(TableEntry("int8_key", int8_t(8)));
|
||||
table_in.insert(TableEntry("uint16_key", uint16_t(16)));
|
||||
table_in.insert(TableEntry("int16_key", int16_t(16)));
|
||||
table_in.insert(TableEntry("uint32_key", uint32_t(32)));
|
||||
table_in.insert(TableEntry("int32_key", int32_t(32)));
|
||||
table_in.insert(TableEntry("timestamp_key", TableValue::Timestamp(64)));
|
||||
table_in.insert(TableEntry("int64_key", int64_t(64)));
|
||||
table_in.insert(TableEntry("float_key", float(1.5)));
|
||||
table_in.insert(TableEntry("double_key", double(2.25)));
|
||||
table_in.insert(TableEntry("string_key", "A string!"));
|
||||
|
||||
std::vector<TableValue> array_in;
|
||||
array_in.push_back(TableValue(false));
|
||||
array_in.push_back(TableValue(int32_t(10)));
|
||||
array_in.push_back(TableValue(std::string("Another string")));
|
||||
|
||||
table_in.insert(TableEntry("array_key", array_in));
|
||||
|
||||
Table table_inner;
|
||||
table_inner.insert(TableEntry("inner_string", "An inner table"));
|
||||
table_inner.insert(TableEntry("inner array", array_in));
|
||||
|
||||
table_in.insert(TableEntry("table_key", table_inner));
|
||||
|
||||
BasicMessage::ptr_t message = BasicMessage::Create();
|
||||
message->HeaderTable(table_in);
|
||||
|
||||
EXPECT_TRUE(message->HeaderTableIsSet());
|
||||
Table table_out = message->HeaderTable();
|
||||
EXPECT_EQ(table_in.size(), table_out.size());
|
||||
EXPECT_TRUE(std::equal(table_in.begin(), table_in.end(), table_out.begin()));
|
||||
}
|
||||
|
||||
TEST(table, convert_to_rabbitmq_empty) {
|
||||
Table table_in;
|
||||
|
||||
BasicMessage::ptr_t message = BasicMessage::Create();
|
||||
message->HeaderTable(table_in);
|
||||
|
||||
Table table_out = message->HeaderTable();
|
||||
EXPECT_EQ(0, table_out.size());
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_message_header_roundtrip) {
|
||||
Table table_in;
|
||||
table_in.insert(TableEntry("void_key", TableValue()));
|
||||
table_in.insert(TableEntry("bool_key", true));
|
||||
table_in.insert(TableEntry("uint8_key", uint8_t(8)));
|
||||
table_in.insert(TableEntry("int8_key", int8_t(8)));
|
||||
table_in.insert(TableEntry("uint16_key", uint16_t(16)));
|
||||
table_in.insert(TableEntry("int16_key", int16_t(16)));
|
||||
table_in.insert(TableEntry("uint32_key", uint32_t(32)));
|
||||
table_in.insert(TableEntry("int32_key", int32_t(32)));
|
||||
table_in.insert(TableEntry("timestamp_key", TableValue::Timestamp(64)));
|
||||
table_in.insert(TableEntry("int64_key", int64_t(64)));
|
||||
table_in.insert(TableEntry("float_key", float(1.5)));
|
||||
table_in.insert(TableEntry("double_key", double(2.25)));
|
||||
table_in.insert(TableEntry("string_key", "A string!"));
|
||||
|
||||
std::vector<TableValue> array_in;
|
||||
array_in.push_back(TableValue(false));
|
||||
array_in.push_back(TableValue(int32_t(10)));
|
||||
array_in.push_back(TableValue(std::string("Another string")));
|
||||
|
||||
table_in.insert(TableEntry("array_key", array_in));
|
||||
|
||||
Table table_inner;
|
||||
table_inner.insert(TableEntry("inner_string", "An inner table"));
|
||||
table_inner.insert(TableEntry("inner array", array_in));
|
||||
|
||||
table_in.insert(TableEntry("table_key", table_inner));
|
||||
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string tag = channel->BasicConsume(queue, "");
|
||||
|
||||
BasicMessage::ptr_t message_in = BasicMessage::Create("Body");
|
||||
message_in->HeaderTable(table_in);
|
||||
|
||||
channel->BasicPublish("", queue, message_in);
|
||||
|
||||
Envelope::ptr_t envelope = channel->BasicConsumeMessage(tag);
|
||||
BasicMessage::ptr_t message_out = envelope->Message();
|
||||
Table table_out = message_out->HeaderTable();
|
||||
|
||||
EXPECT_EQ(table_in.size(), table_out.size());
|
||||
EXPECT_TRUE(std::equal(table_in.begin(), table_in.end(), table_out.begin()));
|
||||
}
|
||||
|
||||
TEST_F(connected_test, basic_message_empty_table_roundtrip) {
|
||||
std::string queue = channel->DeclareQueue("");
|
||||
std::string tag = channel->BasicConsume(queue, "");
|
||||
|
||||
Table table_in;
|
||||
|
||||
BasicMessage::ptr_t message_in = BasicMessage::Create("Body");
|
||||
message_in->HeaderTable(table_in);
|
||||
|
||||
channel->BasicPublish("", queue, message_in);
|
||||
|
||||
Envelope::ptr_t envelope = channel->BasicConsumeMessage(tag);
|
||||
BasicMessage::ptr_t message_out = envelope->Message();
|
||||
Table table_out = message_out->HeaderTable();
|
||||
|
||||
EXPECT_EQ(table_in.size(), table_out.size());
|
||||
EXPECT_TRUE(std::equal(table_in.begin(), table_in.end(), table_out.begin()));
|
||||
}
|
||||
Reference in New Issue
Block a user