This is an automated email from the ASF dual-hosted git repository.
dinglei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/rocketmq-client-cpp.git
The following commit(s) were added to refs/heads/master by this push:
new 7908162 unit-test-protocol-1 (#112)
7908162 is described below
commit 7908162002a36ad9a6e504a9a32b5709f545c8c3
Author: githublaohu <[email protected]>
AuthorDate: Thu Apr 4 15:07:07 2019 +0800
unit-test-protocol-1 (#112)
---
test/src/protocol/ProcessQueueInfoTest.cpp | 78 ++++++++
test/src/protocol/RemotingCommandTest.cpp | 285 +++++++++++++++++++++++++++++
test/src/protocol/TopicRouteDataTest.cpp | 93 ++++++++++
3 files changed, 456 insertions(+)
diff --git a/test/src/protocol/ProcessQueueInfoTest.cpp
b/test/src/protocol/ProcessQueueInfoTest.cpp
new file mode 100644
index 0000000..9f00d51
--- /dev/null
+++ b/test/src/protocol/ProcessQueueInfoTest.cpp
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "MQMessageExt.h"
+#include "ProcessQueueInfo.h"
+
+using ::testing::InitGoogleMock;
+using ::testing::InitGoogleTest;
+using testing::Return;
+
+using rocketmq::MQMessageExt;
+using rocketmq::ProcessQueueInfo;
+
+TEST(processQueueInfo, init) {
+ ProcessQueueInfo processQueueInfo;
+ EXPECT_EQ(processQueueInfo.commitOffset, 0);
+ EXPECT_EQ(processQueueInfo.cachedMsgMinOffset, 0);
+ EXPECT_EQ(processQueueInfo.cachedMsgMaxOffset, 0);
+ EXPECT_EQ(processQueueInfo.cachedMsgCount, 0);
+ EXPECT_EQ(processQueueInfo.transactionMsgMinOffset, 0);
+ EXPECT_EQ(processQueueInfo.transactionMsgMaxOffset, 0);
+ EXPECT_EQ(processQueueInfo.transactionMsgCount, 0);
+ EXPECT_EQ(processQueueInfo.locked, false);
+ EXPECT_EQ(processQueueInfo.tryUnlockTimes, 0);
+ EXPECT_EQ(processQueueInfo.lastLockTimestamp, 123);
+ EXPECT_EQ(processQueueInfo.droped, false);
+ EXPECT_EQ(processQueueInfo.lastPullTimestamp, 0);
+ EXPECT_EQ(processQueueInfo.lastConsumeTimestamp, 0);
+
+ processQueueInfo.setLocked(true);
+ EXPECT_EQ(processQueueInfo.isLocked(), true);
+
+ processQueueInfo.setDroped(true);
+ EXPECT_EQ(processQueueInfo.isDroped(), true);
+
+ processQueueInfo.setCommitOffset(456);
+ EXPECT_EQ(processQueueInfo.getCommitOffset(), 456);
+
+ Json::Value outJson = processQueueInfo.toJson();
+
+ EXPECT_EQ(outJson["commitOffset"], "456");
+ EXPECT_EQ(outJson["cachedMsgMinOffset"], "0");
+ EXPECT_EQ(outJson["cachedMsgMaxOffset"], "0");
+ EXPECT_EQ(outJson["cachedMsgCount"].asInt(), 0);
+ EXPECT_EQ(outJson["transactionMsgMinOffset"], "0");
+ EXPECT_EQ(outJson["transactionMsgMaxOffset"], "0");
+ EXPECT_EQ(outJson["transactionMsgCount"].asInt(), 0);
+ EXPECT_EQ(outJson["locked"].asBool(), true);
+ EXPECT_EQ(outJson["tryUnlockTimes"].asInt(), 0);
+ EXPECT_EQ(outJson["lastLockTimestamp"], "123");
+ EXPECT_EQ(outJson["droped"].asBool(), true);
+ EXPECT_EQ(outJson["lastPullTimestamp"], "0");
+ EXPECT_EQ(outJson["lastConsumeTimestamp"], "0");
+}
+
+int main(int argc, char *argv[]) {
+ InitGoogleMock(&argc, argv);
+ testing::GTEST_FLAG(throw_on_failure) = true;
+ testing::GTEST_FLAG(filter) = "processQueueInfo.init";
+ int itestts = RUN_ALL_TESTS();
+ return itestts;
+}
diff --git a/test/src/protocol/RemotingCommandTest.cpp
b/test/src/protocol/RemotingCommandTest.cpp
new file mode 100644
index 0000000..1da4c14
--- /dev/null
+++ b/test/src/protocol/RemotingCommandTest.cpp
@@ -0,0 +1,285 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <iostream>
+#include <memory>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "CommandHeader.h"
+#include "MQProtos.h"
+#include "MQVersion.h"
+#include "MemoryOutputStream.h"
+#include "RemotingCommand.h"
+#include "dataBlock.h"
+
+using std::shared_ptr;
+
+using ::testing::InitGoogleMock;
+using ::testing::InitGoogleTest;
+using testing::Return;
+
+using rocketmq::CommandHeader;
+using rocketmq::GetConsumerRunningInfoRequestHeader;
+using rocketmq::GetEarliestMsgStoretimeResponseHeader;
+using rocketmq::GetMaxOffsetResponseHeader;
+using rocketmq::GetMinOffsetResponseHeader;
+using rocketmq::GetRouteInfoRequestHeader;
+using rocketmq::MemoryBlock;
+using rocketmq::MemoryOutputStream;
+using rocketmq::MQRequestCode;
+using rocketmq::MQVersion;
+using rocketmq::NotifyConsumerIdsChangedRequestHeader;
+using rocketmq::PullMessageResponseHeader;
+using rocketmq::QueryConsumerOffsetResponseHeader;
+using rocketmq::RemotingCommand;
+using rocketmq::ResetOffsetRequestHeader;
+using rocketmq::SearchOffsetResponseHeader;
+using rocketmq::SendMessageResponseHeader;
+
+TEST(remotingCommand, init) {
+ RemotingCommand remotingCommand;
+ EXPECT_EQ(remotingCommand.getCode(), 0);
+ EXPECT_EQ(remotingCommand.getOpaque(), 0);
+ EXPECT_EQ(remotingCommand.getRemark(), "");
+ EXPECT_EQ(remotingCommand.getVersion(), 0);
+ // EXPECT_EQ(remotingCommand.getFlag() , 0);
+ EXPECT_EQ(remotingCommand.getMsgBody(), "");
+ EXPECT_TRUE(remotingCommand.getCommandHeader() == nullptr);
+
+ RemotingCommand twoRemotingCommand(13);
+ EXPECT_EQ(twoRemotingCommand.getCode(), 13);
+ EXPECT_EQ(twoRemotingCommand.getOpaque(), 0);
+ EXPECT_EQ(twoRemotingCommand.getRemark(), "");
+ EXPECT_EQ(twoRemotingCommand.getVersion(), MQVersion::s_CurrentVersion);
+ // EXPECT_EQ(twoRemotingCommand.getFlag() , 0);
+ EXPECT_EQ(twoRemotingCommand.getMsgBody(), "");
+ EXPECT_TRUE(twoRemotingCommand.getCommandHeader() == nullptr);
+
+ RemotingCommand threeRemotingCommand(13, new
GetRouteInfoRequestHeader("topic"));
+ EXPECT_FALSE(threeRemotingCommand.getCommandHeader() == nullptr);
+
+ RemotingCommand frouRemotingCommand(13, "CPP",
MQVersion::s_CurrentVersion, 12, 3, "remark",
+ new
GetRouteInfoRequestHeader("topic"));
+ EXPECT_EQ(frouRemotingCommand.getCode(), 13);
+ EXPECT_EQ(frouRemotingCommand.getOpaque(), 12);
+ EXPECT_EQ(frouRemotingCommand.getRemark(), "remark");
+ EXPECT_EQ(frouRemotingCommand.getVersion(), MQVersion::s_CurrentVersion);
+ EXPECT_EQ(frouRemotingCommand.getFlag(), 3);
+ EXPECT_EQ(frouRemotingCommand.getMsgBody(), "");
+ EXPECT_FALSE(frouRemotingCommand.getCommandHeader() == nullptr);
+
+ RemotingCommand sixRemotingCommand(frouRemotingCommand);
+ EXPECT_EQ(sixRemotingCommand.getCode(), 13);
+ EXPECT_EQ(sixRemotingCommand.getOpaque(), 12);
+ EXPECT_EQ(sixRemotingCommand.getRemark(), "remark");
+ EXPECT_EQ(sixRemotingCommand.getVersion(), MQVersion::s_CurrentVersion);
+ EXPECT_EQ(sixRemotingCommand.getFlag(), 3);
+ EXPECT_EQ(sixRemotingCommand.getMsgBody(), "");
+ EXPECT_TRUE(sixRemotingCommand.getCommandHeader() == nullptr);
+
+ RemotingCommand *sevenRemotingCommand = new RemotingCommand();
+ EXPECT_EQ(sevenRemotingCommand->getCode(), 0);
+ EXPECT_EQ(sevenRemotingCommand->getOpaque(), 0);
+ EXPECT_EQ(sevenRemotingCommand->getRemark(), "");
+ EXPECT_EQ(sevenRemotingCommand->getVersion(), 0);
+ EXPECT_EQ(sevenRemotingCommand->getFlag(), 0);
+ EXPECT_EQ(sevenRemotingCommand->getMsgBody(), "");
+ EXPECT_TRUE(sevenRemotingCommand->getCommandHeader() == nullptr);
+
+ RemotingCommand *egthRemotingCommand = sevenRemotingCommand;
+ EXPECT_EQ(egthRemotingCommand->getCode(), 0);
+ EXPECT_EQ(egthRemotingCommand->getOpaque(), 0);
+ EXPECT_EQ(egthRemotingCommand->getRemark(), "");
+ EXPECT_EQ(egthRemotingCommand->getVersion(), 0);
+ EXPECT_EQ(egthRemotingCommand->getFlag(), 0);
+ EXPECT_EQ(egthRemotingCommand->getMsgBody(), "");
+ EXPECT_TRUE(egthRemotingCommand->getCommandHeader() == nullptr);
+
+ sevenRemotingCommand = &sixRemotingCommand;
+ EXPECT_EQ(sevenRemotingCommand->getCode(), 13);
+ EXPECT_EQ(sevenRemotingCommand->getOpaque(), 12);
+ EXPECT_EQ(sevenRemotingCommand->getRemark(), "remark");
+ EXPECT_EQ(sevenRemotingCommand->getVersion(), MQVersion::s_CurrentVersion);
+ EXPECT_EQ(sevenRemotingCommand->getFlag(), 3);
+ EXPECT_EQ(sevenRemotingCommand->getMsgBody(), "");
+ EXPECT_TRUE(sevenRemotingCommand->getCommandHeader() == nullptr);
+
+ // Assign
+ delete egthRemotingCommand;
+}
+
+TEST(remotingCommand, info) {
+ RemotingCommand remotingCommand;
+
+ remotingCommand.setCode(13);
+ EXPECT_EQ(remotingCommand.getCode(), 13);
+
+ remotingCommand.setOpaque(12);
+ EXPECT_EQ(remotingCommand.getOpaque(), 12);
+
+ remotingCommand.setRemark("123");
+ EXPECT_EQ(remotingCommand.getRemark(), "123");
+
+ remotingCommand.setMsgBody("msgBody");
+ EXPECT_EQ(remotingCommand.getMsgBody(), "msgBody");
+
+ remotingCommand.addExtField("key", "value");
+}
+
+TEST(remotingCommand, flag) {
+ RemotingCommand remotingCommand(13, "CPP", MQVersion::s_CurrentVersion,
12, 0, "remark",
+ new GetRouteInfoRequestHeader("topic"));
+ ;
+ EXPECT_EQ(remotingCommand.getFlag(), 0);
+
+ remotingCommand.markResponseType();
+ int bits = 1 << 0;
+ int flag = 0;
+ flag |= bits;
+ EXPECT_EQ(remotingCommand.getFlag(), flag);
+ EXPECT_TRUE(remotingCommand.isResponseType());
+
+ bits = 1 << 1;
+ flag |= bits;
+ remotingCommand.markOnewayRPC();
+ EXPECT_EQ(remotingCommand.getFlag(), flag);
+ EXPECT_TRUE(remotingCommand.isOnewayRPC());
+}
+
+TEST(remotingCommand, encodeAndDecode) {
+ RemotingCommand remotingCommand(13, "CPP", MQVersion::s_CurrentVersion,
12, 3, "remark", NULL);
+ remotingCommand.SetBody("123123", 6);
+ remotingCommand.Encode();
+ // no delete
+ const MemoryBlock *head = remotingCommand.GetHead();
+ const MemoryBlock *body = remotingCommand.GetBody();
+
+ unique_ptr<MemoryOutputStream> result(new MemoryOutputStream(1024));
+ result->write(head->getData() + 4, head->getSize() - 4);
+ result->write(body->getData(), body->getSize());
+
+ shared_ptr<RemotingCommand>
decodeRemtingCommand(RemotingCommand::Decode(result->getMemoryBlock()));
+ EXPECT_EQ(remotingCommand.getCode(), decodeRemtingCommand->getCode());
+ EXPECT_EQ(remotingCommand.getOpaque(), decodeRemtingCommand->getOpaque());
+ EXPECT_EQ(remotingCommand.getRemark(), decodeRemtingCommand->getRemark());
+ EXPECT_EQ(remotingCommand.getVersion(),
decodeRemtingCommand->getVersion());
+ EXPECT_EQ(remotingCommand.getFlag(), decodeRemtingCommand->getFlag());
+ EXPECT_TRUE(decodeRemtingCommand->getCommandHeader() == NULL);
+
+ // ~RemotingCommand delete
+ GetConsumerRunningInfoRequestHeader *requestHeader = new
GetConsumerRunningInfoRequestHeader();
+ requestHeader->setClientId("client");
+ requestHeader->setConsumerGroup("consumerGroup");
+ requestHeader->setJstackEnable(false);
+
+ RemotingCommand encodeRemotingCommand(307, "CPP",
MQVersion::s_CurrentVersion, 12, 3, "remark", requestHeader);
+ encodeRemotingCommand.SetBody("123123", 6);
+ encodeRemotingCommand.Encode();
+
+ // no delete
+ const MemoryBlock *phead = encodeRemotingCommand.GetHead();
+ const MemoryBlock *pbody = encodeRemotingCommand.GetBody();
+
+ unique_ptr<MemoryOutputStream> results(new MemoryOutputStream(1024));
+ results->write(phead->getData() + 4, phead->getSize() - 4);
+ results->write(pbody->getData(), pbody->getSize());
+
+ shared_ptr<RemotingCommand>
decodeRemtingCommandTwo(RemotingCommand::Decode(results->getMemoryBlock()));
+
+ decodeRemtingCommandTwo->SetExtHeader(encodeRemotingCommand.getCode());
+ GetConsumerRunningInfoRequestHeader *header =
+ reinterpret_cast<GetConsumerRunningInfoRequestHeader
*>(decodeRemtingCommandTwo->getCommandHeader());
+ EXPECT_EQ(requestHeader->getClientId(), header->getClientId());
+ EXPECT_EQ(requestHeader->getConsumerGroup(), header->getConsumerGroup());
+}
+
+TEST(remotingCommand, SetExtHeader) {
+ shared_ptr<RemotingCommand> remotingCommand(new RemotingCommand());
+
+ remotingCommand->SetExtHeader(-1);
+ EXPECT_TRUE(remotingCommand->getCommandHeader() == NULL);
+
+ Json::Value object;
+ Json::Value extFields;
+ extFields["id"] = 1;
+ object["extFields"] = extFields;
+ remotingCommand->setParsedJson(object);
+
+ remotingCommand->SetExtHeader(MQRequestCode::SEND_MESSAGE);
+ SendMessageResponseHeader *sendMessageResponseHeader =
+ reinterpret_cast<SendMessageResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(sendMessageResponseHeader->msgId, "");
+
+ remotingCommand->SetExtHeader(MQRequestCode::PULL_MESSAGE);
+ PullMessageResponseHeader *pullMessageResponseHeader =
+ reinterpret_cast<PullMessageResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(pullMessageResponseHeader->suggestWhichBrokerId, 0);
+
+ remotingCommand->SetExtHeader(MQRequestCode::GET_MIN_OFFSET);
+ GetMinOffsetResponseHeader *getMinOffsetResponseHeader =
+ reinterpret_cast<GetMinOffsetResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(getMinOffsetResponseHeader->offset, 0);
+
+ remotingCommand->SetExtHeader(MQRequestCode::GET_MAX_OFFSET);
+ GetMaxOffsetResponseHeader *getMaxOffsetResponseHeader =
+ reinterpret_cast<GetMaxOffsetResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(getMaxOffsetResponseHeader->offset, 0);
+
+ remotingCommand->SetExtHeader(MQRequestCode::SEARCH_OFFSET_BY_TIMESTAMP);
+ SearchOffsetResponseHeader *searchOffsetResponseHeader =
+ reinterpret_cast<SearchOffsetResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(searchOffsetResponseHeader->offset, 0);
+
+ remotingCommand->SetExtHeader(MQRequestCode::GET_EARLIEST_MSG_STORETIME);
+ GetEarliestMsgStoretimeResponseHeader
*getEarliestMsgStoretimeResponseHeader =
+ reinterpret_cast<GetEarliestMsgStoretimeResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(getEarliestMsgStoretimeResponseHeader->timestamp, 0);
+
+ remotingCommand->SetExtHeader(MQRequestCode::QUERY_CONSUMER_OFFSET);
+ QueryConsumerOffsetResponseHeader *queryConsumerOffsetResponseHeader =
+ reinterpret_cast<QueryConsumerOffsetResponseHeader
*>(remotingCommand->getCommandHeader());
+ EXPECT_EQ(queryConsumerOffsetResponseHeader->offset, 0);
+
+ extFields["isForce"] = "true";
+ object["extFields"] = extFields;
+ remotingCommand->setParsedJson(object);
+ remotingCommand->SetExtHeader(MQRequestCode::RESET_CONSUMER_CLIENT_OFFSET);
+ ResetOffsetRequestHeader *resetOffsetRequestHeader =
+ reinterpret_cast<ResetOffsetRequestHeader
*>(remotingCommand->getCommandHeader());
+ resetOffsetRequestHeader->setGroup("group");
+
+ remotingCommand->SetExtHeader(MQRequestCode::GET_CONSUMER_RUNNING_INFO);
+ GetConsumerRunningInfoRequestHeader *getConsumerRunningInfoRequestHeader =
+ reinterpret_cast<GetConsumerRunningInfoRequestHeader
*>(remotingCommand->getCommandHeader());
+ getConsumerRunningInfoRequestHeader->setClientId("id");
+
+ remotingCommand->SetExtHeader(MQRequestCode::NOTIFY_CONSUMER_IDS_CHANGED);
+ NotifyConsumerIdsChangedRequestHeader
*notifyConsumerIdsChangedRequestHeader =
+ reinterpret_cast<NotifyConsumerIdsChangedRequestHeader
*>(remotingCommand->getCommandHeader());
+ notifyConsumerIdsChangedRequestHeader->setGroup("group");
+}
+
+int main(int argc, char *argv[]) {
+ InitGoogleMock(&argc, argv);
+ testing::GTEST_FLAG(throw_on_failure) = true;
+ testing::GTEST_FLAG(filter) = "remotingCommand.*";
+ int itestts = RUN_ALL_TESTS();
+ return itestts;
+}
diff --git a/test/src/protocol/TopicRouteDataTest.cpp
b/test/src/protocol/TopicRouteDataTest.cpp
new file mode 100644
index 0000000..8ddba9f
--- /dev/null
+++ b/test/src/protocol/TopicRouteDataTest.cpp
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "TopicRouteData.h"
+#include "dataBlock.h"
+
+using ::testing::InitGoogleMock;
+using ::testing::InitGoogleTest;
+using testing::Return;
+
+using rocketmq::BrokerData;
+using rocketmq::MemoryBlock;
+using rocketmq::QueueData;
+using rocketmq::TopicRouteData;
+
+TEST(topicRouteData, topicRouteData) {
+ Json::Value root;
+ root["orderTopicConf"] = "orderTopicConf";
+
+ Json::Value queueDatas;
+ Json::Value queueData;
+
+ queueData["brokerName"] = "brokerTest";
+ queueData["readQueueNums"] = 8;
+ queueData["writeQueueNums"] = 8;
+ queueData["perm"] = 7;
+ queueDatas[0] = queueData;
+
+ root["queueDatas"] = queueDatas;
+
+ Json::Value brokerDatas;
+ Json::Value brokerData;
+ brokerData["brokerName"] = "testBroker";
+
+ Json::Value brokerAddrs;
+ brokerAddrs["0"] = "127.0.0.1:10091";
+ brokerAddrs["1"] = "127.0.0.2:10092";
+ brokerData["brokerAddrs"] = brokerAddrs;
+
+ brokerDatas[0] = brokerData;
+
+ root["brokerDatas"] = brokerDatas;
+ string out = root.toStyledString();
+
+ MemoryBlock *block = new MemoryBlock(out.c_str(), out.size());
+ TopicRouteData *topicRouteData = TopicRouteData::Decode(block);
+ EXPECT_EQ(root["orderTopicConf"], topicRouteData->getOrderTopicConf());
+
+ BrokerData broker;
+ broker.brokerName = "testBroker";
+ broker.brokerAddrs[0] = "127.0.0.1:10091";
+ broker.brokerAddrs[1] = "127.0.0.2:10092";
+
+ vector<BrokerData> brokerDataSt = topicRouteData->getBrokerDatas();
+ EXPECT_EQ(broker, brokerDataSt[0]);
+
+ QueueData queue;
+ queue.brokerName = "brokerTest";
+ queue.readQueueNums = 8;
+ queue.writeQueueNums = 8;
+ queue.perm = 7;
+ vector<QueueData> queueDataSt = topicRouteData->getQueueDatas();
+ EXPECT_EQ(queue, queueDataSt[0]);
+
+ EXPECT_EQ(topicRouteData->selectBrokerAddr(), "127.0.0.1:10091");
+
+ delete block;
+ delete topicRouteData;
+}
+
+int main(int argc, char *argv[]) {
+ InitGoogleMock(&argc, argv);
+ testing::GTEST_FLAG(throw_on_failure) = true;
+ testing::GTEST_FLAG(filter) = "topicRouteData.topicRouteData";
+ int itestts = RUN_ALL_TESTS();
+ return itestts;
+}
