108 lines
3.8 KiB
C++
108 lines
3.8 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX SHARE_PT
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "share/partition_table/ob_partition_location.h"
|
|
|
|
namespace oceanbase {
|
|
namespace share {
|
|
using namespace common;
|
|
|
|
TEST(ObPartitionLocation, common)
|
|
{
|
|
ObPartitionLocation location;
|
|
location.set_table_id(combine_id(1, 1));
|
|
location.set_partition_id(0);
|
|
location.set_partition_cnt(1);
|
|
location.set_renew_time(ObTimeUtility::current_time());
|
|
ObReplicaLocation replica_loc;
|
|
|
|
ASSERT_FALSE(replica_loc.is_valid());
|
|
|
|
const char* ip1 = "127.0.0.1";
|
|
const char* ip2 = "127.0.0.2";
|
|
const char* ip3 = "127.0.0.3";
|
|
const int32_t port = 5555;
|
|
|
|
const uint64_t table_id = 1;
|
|
const int64_t partition_id = 1;
|
|
const int64_t now = ::oceanbase::common::ObTimeUtility::current_time();
|
|
|
|
// add invalid replica location
|
|
ASSERT_EQ(OB_INVALID_ARGUMENT, location.add(replica_loc));
|
|
|
|
// add same replica location twice
|
|
replica_loc.server_.set_ip_addr(ip1, port);
|
|
ASSERT_EQ(OB_SUCCESS, location.add(replica_loc));
|
|
ASSERT_EQ(OB_ERR_ALREADY_EXISTS, location.add(replica_loc));
|
|
ASSERT_EQ(1, location.size());
|
|
ASSERT_EQ(0, memcmp(&replica_loc, &location.get_replica_locations().at(0), sizeof(replica_loc)));
|
|
|
|
// leader releated
|
|
ObReplicaLocation tmp_replica_loc;
|
|
ASSERT_EQ(OB_LOCATION_LEADER_NOT_EXIST, location.get_strong_leader(tmp_replica_loc));
|
|
replica_loc.server_.set_ip_addr(ip2, port);
|
|
replica_loc.role_ = LEADER;
|
|
ASSERT_EQ(OB_SUCCESS, location.add(replica_loc));
|
|
ASSERT_EQ(OB_SUCCESS, location.get_strong_leader(tmp_replica_loc));
|
|
ASSERT_EQ(LEADER, tmp_replica_loc.role_);
|
|
|
|
// del replica location
|
|
ASSERT_EQ(2, location.size());
|
|
ObAddr tmp_server;
|
|
tmp_server.set_ip_addr(ip3, port);
|
|
ASSERT_EQ(OB_ENTRY_NOT_EXIST, location.del(tmp_server));
|
|
ASSERT_EQ(2, location.size());
|
|
ObAddr leader_server;
|
|
leader_server.set_ip_addr(ip2, port);
|
|
ASSERT_EQ(OB_SUCCESS, location.del(leader_server));
|
|
ASSERT_EQ(1, location.size());
|
|
ASSERT_EQ(OB_LOCATION_LEADER_NOT_EXIST, location.get_strong_leader(tmp_replica_loc));
|
|
|
|
// set get funcs
|
|
location.set_table_id(table_id);
|
|
location.set_partition_id(partition_id);
|
|
location.set_renew_time(now);
|
|
ASSERT_EQ(table_id, location.get_table_id());
|
|
ASSERT_EQ(partition_id, location.get_partition_id());
|
|
ASSERT_EQ(now, location.get_renew_time());
|
|
|
|
// to_string and serialization/deserailization
|
|
LOG_INFO("replica location", K(replica_loc));
|
|
LOG_INFO("location", K(location));
|
|
const int64_t OB_MAX_BUFFER_LEN = 1024;
|
|
char buffer[OB_MAX_BUFFER_LEN];
|
|
int64_t pos = 0;
|
|
ASSERT_EQ(OB_SUCCESS, location.serialize(buffer, OB_MAX_BUFFER_LEN, pos));
|
|
int64_t serialize_size = pos;
|
|
ObPartitionLocation cmp_location;
|
|
pos = 0;
|
|
ASSERT_EQ(OB_SUCCESS, cmp_location.deserialize(buffer, serialize_size, pos));
|
|
ASSERT_EQ(location.size(), cmp_location.size());
|
|
for (int64_t i = 0; i < location.size(); ++i) {
|
|
ASSERT_EQ(location.get_replica_locations().at(i).server_, cmp_location.get_replica_locations().at(i).server_);
|
|
ASSERT_EQ(location.get_replica_locations().at(i).role_, cmp_location.get_replica_locations().at(i).role_);
|
|
ASSERT_EQ(location.get_replica_locations().at(i).reserved_, cmp_location.get_replica_locations().at(i).reserved_);
|
|
}
|
|
}
|
|
|
|
} // end namespace share
|
|
} // end namespace oceanbase
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|