/**
 * 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 RS

#include <gtest/gtest.h>
#define private public
#include "rootserver/ob_locality_util.h"
#include "lib/container/ob_se_array.h"
#include "share/schema/ob_schema_struct.h"
#include "share/ob_cluster_version.h"
#undef private

using namespace oceanbase;
using namespace oceanbase::common;
using namespace oceanbase::share;
using namespace oceanbase::share::schema;
namespace oceanbase
{
namespace rootserver
{
class TestLocalityDistribution : public ::testing::Test
{
public:
  virtual void SetUp() {
    common::ObClusterVersion::get_instance().init(cal_version(1, 4, 0, 60));
    ASSERT_EQ(OB_SUCCESS, locality_dist_.init());
    ASSERT_EQ(OB_SUCCESS, zone_list_A_.push_back(ObZone("zone1")));
    ASSERT_EQ(OB_SUCCESS, zone_list_A_.push_back(ObZone("zone2")));
    ASSERT_EQ(OB_SUCCESS, zone_list_A_.push_back(ObZone("zone3")));
    ASSERT_EQ(OB_SUCCESS, zone_list_A_.push_back(ObZone("zone4")));
    ASSERT_EQ(OB_SUCCESS, zone_list_A_.push_back(ObZone("zone5")));
    ASSERT_EQ(OB_SUCCESS, zone_list_B_.push_back(ObString("zone1")));
    ASSERT_EQ(OB_SUCCESS, zone_list_B_.push_back(ObString("zone2")));
    ASSERT_EQ(OB_SUCCESS, zone_list_B_.push_back(ObString("zone3")));
    ASSERT_EQ(OB_SUCCESS, zone_list_B_.push_back(ObString("zone4")));
    ASSERT_EQ(OB_SUCCESS, zone_list_B_.push_back(ObString("zone5")));
    ASSERT_EQ(OB_SUCCESS, zone_region_list_.push_back(ObZoneRegion("zone1", "HZ")));
    ASSERT_EQ(OB_SUCCESS, zone_region_list_.push_back(ObZoneRegion("zone2", "HZ")));
    ASSERT_EQ(OB_SUCCESS, zone_region_list_.push_back(ObZoneRegion("zone3", "SH")));
    ASSERT_EQ(OB_SUCCESS, zone_region_list_.push_back(ObZoneRegion("zone4", "SH")));
    ASSERT_EQ(OB_SUCCESS, zone_region_list_.push_back(ObZoneRegion("zone5", "SZ")));
  }
  virtual void TearDown() {
    zone_list_A_.reset();
    zone_list_B_.reset();
    zone_region_list_.reset();
  }
  static void SetUpTestCase() {}
  static void TearDownTestCase() {}
public:
  ObLocalityDistribution locality_dist_;
  common::ObSEArray<common::ObZone, 64> zone_list_A_;
  common::ObSEArray<common::ObString, 64> zone_list_B_;
  common::ObSEArray<share::schema::ObZoneRegion, 64> zone_region_list_;
};

TEST_F(TestLocalityDistribution, empty_locality_A)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString empty_locality;
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(empty_locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, empty_locality_B)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString empty_locality;
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(empty_locality, zone_list_B_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("F {1 } @ zone1,F{      1}@zone3, F{   1} @zone4, F  {1}@zone2, F{1}@zone5        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks2)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("F{      1}@zone3, F{   1} @zone4, F  {1}@zone2, F{1}@zone5,F{1}@zone1        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks_lower_case)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("f {1 } @ zone1,F{      1}@zone3, f{   1} @zone4, f  {1}@zone2, F{1}@zone5        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks_lower_case_and_full_name)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("fULl {1 } @ zone1,FulL{      1}@zone3, f{   1} @zone4, fulL  {1}@zone2, F{1}@zone5        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks_lower_case_and_full_name_plus_token)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("fULl {+1 } @ zone1,FulL{      +1}@zone3, f{   1} @zone4, fulL  {1}@zone2, F{1}@zone5        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, random_blanks_lower_case_and_full_name_diff_replica_type)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "READONLY{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, READONLY{1}@zone4, LOGONLY{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("readonly {1 } @ zone1,FulL{      1}@zone3, readonly{   1} @zone4, f  {1}@zone2, logonly{1}@zone5        ");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, all_server)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "READONLY{ALL_SERVER}@zone1, FULL{1}@zone2, FULL{1}@zone3, READONLY{ALL_SERVER}@zone4, LOGONLY{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("readonly {all_server } @ zone1,FulL{      1}@zone3, READonly{   All_server} @zone4, f  {1 }@zone2, logonly{1}@zone5");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, all_server_test)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "READONLY{ALL_SERVER}@zone1, FULL{1}@zone2, FULL{1}@zone3, READONLY{ALL_SERVER}@zone4, LOGONLY{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("readonly {all_server } @ zone1,FulL{      1}@zone3, READonly{   All_server} @zone4, f  {1 }@zone2, logonly{1}@zone5");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, all_server_with_multiple_replica_type_one_zone)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1},READONLY{ALL_SERVER}@zone1, FULL{1},READONLY{2}@zone2, "
                                  "READONLY{ALL_SERVER}@zone3, FULL{1}@zone4, LOGONLY{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("readonly {all_server } , F@ zone1,FulL{      1}, r{2}@zone2, READonly{   All_server} @zone3, f  {1 }@zone4, logonly{1}@zone5");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, every_zone)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, FULL{1}@zone2, FULL{1}@zone3, FULL{1}@zone4, FULL{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("f@everyzone");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, zone_split)
{
  const char *expected_locality = "FULL{1},READONLY{ALL_SERVER}@zone1, FULL{1},READONLY{2}@zone2, "
                                  "READONLY{ALL_SERVER}@zone3, FULL{1}@zone4, LOGONLY{1}@zone5";
  UNUSED(expected_locality);
  ObString locality("r{all_server}@zone1, f@zone1, F{1}, r{2}@zone2, R{All_server} @zone3,f{1}@zone4, logonly{1}@zone5");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, every_zone_and_all_server)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1},READONLY{ALL_SERVER}@zone1, FULL{1},READONLY{ALL_SERVER}@zone2, "
                                  "FULL{1},READONLY{ALL_SERVER}@zone3, FULL{1},READONLY{ALL_SERVER}@zone4, "
                                  "FULL{1},READONLY{ALL_SERVER}@zone5";
  UNUSED(expected_locality);
  ObString locality("f, r{ALL_SERVER}@everyzone");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, every_zone_and_all_server2)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1},READONLY{ALL_SERVER}@zone1, FULL{1},READONLY{ALL_SERVER}@zone2, "
                                  "FULL{1},READONLY{ALL_SERVER}@zone3, FULL{1},READONLY{ALL_SERVER}@zone4, "
                                  "FULL{1},READONLY{ALL_SERVER}@zone5";
  UNUSED(expected_locality);
  ObString locality("FULL{1},READONLY{ALL_SERVER}@zone1, FULL{1,MEMSTORE_PERCENT:100},READONLY{ALL_SERVER}@zone2, "
                    "FULL{1},READONLY{ALL_SERVER}@zone3, FULL{1,MEMSTORE_PERCENT:100},READONLY{ALL_SERVER}@zone4, "
                    "FULL{1},READONLY{ALL_SERVER}@zone5");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, hybrid)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1},LOGONLY{1}@[zone1,zone2]";
  UNUSED(expected_locality);
  ObString locality("F{1},l@[zone1, zone2]");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, hybrid2)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, LOGONLY{1}@zone2, FULL{1}@zone5, FULL{1},LOGONLY{1}@[zone3,zone4]";
  UNUSED(expected_locality);
  ObString locality("F@zone1, L@zone2,F{1},l@[zone4, zone3], F@[zone5]");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, memstore_percent_0)
{
  char output_locality[MAX_LOCALITY_LENGTH + 1];
  int64_t pos = 0;
  const char *expected_locality = "FULL{1}@zone1, LOGONLY{1}@zone2, FULL{1,MEMSTORE_PERCENT:0}@zone3, FULL{1,MEMSTORE_PERCENT:99}@zone4";
  UNUSED(expected_locality);
  ObString locality("F@zone1, L@zone2, F{1,memstore_percent:0}@[zone3], F{1,memstore_percent:99}@[zone4]");
  ASSERT_EQ(OB_SUCCESS, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
  ASSERT_EQ(OB_SUCCESS, locality_dist_.output_normalized_locality(output_locality, MAX_LOCALITY_LENGTH, pos));
  ASSERT_EQ(0, strncmp(output_locality, expected_locality, strlen(expected_locality)));
}

TEST_F(TestLocalityDistribution, logonly_with_memstore_error)
{
  ObString locality("l{1, memstore_percent:10}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, zone_name_intersect)
{
  ObString locality("f{1, memstore_percent:10},l@[zone1,zone2], f{1, memstore_percent:10},l@[zone1,zone2]");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, replica_num_zero_error)
{
  ObString locality("F{0, memstore_percent:10}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, memstore_percent_negative_error)
{
  ObString locality("F{1, memstore_percent:-1}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, memstore_percent_too_large_error)
{
  ObString locality("F{1, memstore_percent:101}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, attribute_multiple_error1)
{
  ObString locality("F{memstore_percent:1,memstore_percent:2, 1}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, attribute_multiple_error2)
{
  ObString locality("F{memstore_percent:1, 2, 1}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, replica_num_not_set_error2)
{
  ObString locality("F{memstore_percent:1}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, full_replica_greater_than_1_error)
{
  ObString locality("F{2}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, replica_in_region_greater_than_1_error)
{
  ObString locality("F{2},l@[z1, z2]");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, replica_in_region_greater_than_2_error)
{
  ObString locality("F{2},l@[zone1, zone2]");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, specific_zero_err)
{
  ObString locality("readonly{0}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, missing_left_brace_err)
{
  ObString locality("readonly 1}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, missing_right_brace_err)
{
  ObString locality("FulL{1@zone3");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, extrace_comma_err)
{
  ObString locality("readonly{1},@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, all_server_with_plus)
{
  ObString locality("readonly{+All_server}@zone4");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, extrace_special_token_err)
{
  ObString locality("readonly  {1..} @ zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, zone_not_exist_err)
{
  ObString locality("readonly @zone6");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

TEST_F(TestLocalityDistribution, empty_replica_error)
{
  ObString locality("   @zone3");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, empty_locality_error)
{
  ObString locality("   ,   ");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, empty_locality_error2)
{
  ObString locality("         ");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, invalid_replica_type_err)
{
  ObString locality("k@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, invalid_replica_type_err2)
{
  ObString locality("fulll@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, invalid_replica_type_err3)
{
  ObString locality("ful@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, overflow_err)
{
  ObString locality("r{1111111111111111111111111111111111111111111111111}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, negative_num_err)
{
  ObString locality("r{-111}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, num_begin_with_zero)
{
  ObString locality("r{011}@zone1");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, extra_comma)
{
  ObString locality("f{1}@zone1,");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_));
}

TEST_F(TestLocalityDistribution, l_not_allowed_for_set)
{
  ObString locality("f{1},l,r@[zone1,zone2]");
  ASSERT_EQ(OB_INVALID_ARGUMENT, locality_dist_.parse_locality(locality, zone_list_A_, &zone_region_list_));
}

}
}

int main(int argc, char **argv)
{
  system("rm -f test_locality_util.log*");
  ObLogger &logger = ObLogger::get_logger();
  logger.set_file_name("test_locality_util.log", true);
  logger.set_log_level(OB_LOG_LEVEL_DEBUG);

  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}