/**
 * Copyright (c) 2023 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.
 */

#include <gtest/gtest.h>
#define BOOST_GEOMETRY_DISABLE_DEPRECATED_03_WARNING 1
#define BOOST_ALLOW_DEPRECATED_HEADERS 1
#define USING_LOG_PREFIX LIB
#include <boost/geometry.hpp>
#define private public
#include "lib/geo/ob_geo_bin.h"
#include "lib/geo/ob_geo_ibin.h"
#include "lib/geo/ob_geo_bin_traits.h"
#include "lib/geo/ob_geo_tree.h"
#include "lib/geo/ob_geo_tree_traits.h"
#include "lib/json_type/ob_json_common.h"
#include "lib/geo/ob_geo_wkb_visitor.h"
#include "lib/geo/ob_geo_wkb_size_visitor.h"
#include "lib/geo/ob_geo_coordinate_range_visitor.h"
#include "lib/geo/ob_geo_longtitude_correct_visitor.h"
#include "lib/geo/ob_geo_to_tree_visitor.h"
#include "lib/geo/ob_geo_reverse_coordinate_visitor.h"
#include "lib/geo/ob_geo_segment_collect_visitor.h"
#include "lib/geo/ob_geo_vertex_collect_visitor.h"
#include "lib/geo/ob_geo_cache.h"
#include "lib/geo/ob_srs_info.h"
#include "lib/geo/ob_geo_utils.h"
#include "lib/geo/ob_sdo_geo_func_to_wkb.h"
#include "lib/geo/ob_sdo_geo_object.h"
#include "observer/omt/ob_tenant_srs.h"
#include "lib/geo/ob_geo_3d.h"
#include "share/schema/ob_multi_version_schema_service.h"
#include "lib/random/ob_random.h"
#include "lib/string/ob_hex_utils_base.h"
#include "lib/geo/ob_wkb_to_json_visitor.h"
#include "lib/geo/ob_wkb_byte_order_visitor.h"
#include "lib/geo/ob_geo_interior_point_visitor.h"
#include "lib/geo/ob_wkt_parser.h"
#include "lib/geo/ob_geo_mvt_encode_visitor.h"
#undef private

#include <sys/time.h>
#include <iostream>

namespace oceanbase {

using namespace oceanbase::share::schema;
using namespace omt;
namespace common {

class TestGeoBin : public ::testing::Test {
public:
  TestGeoBin()
  {}
  ~TestGeoBin()
  {}
  virtual void SetUp()
  {}
  virtual void TearDown()
  {}

  static void SetUpTestCase()
  {}

  static void TearDownTestCase()
  {}

private:
  // disallow copy
  DISALLOW_COPY_AND_ASSIGN(TestGeoBin);
};

enum class GeogValueValidType {
    NOT_DEFINED = 0,
    IN_RANGE,
    OUT_RANGE
};

static const ObSrsItem *srs_item = NULL;
static ObArenaAllocator allocator_(ObModIds::TEST);

class ObMockProjectedSrsBase : public ObSpatialReferenceSystemBase
{
public:
  ObMockProjectedSrsBase(){}
  virtual ~ObMockProjectedSrsBase(){}
  ObSrsType srs_type() const { return ObSrsType::PROJECTED_SRS; }
  double prime_meridian() const { return 0.0; }
  double linear_unit() const { return 0.0; }
  double angular_unit() const { return 0.0; }
  double semi_major_axis() const { return 0.0; }
  double inverse_flattening() const { return 0.0; }
  bool is_wgs84() const { return true; }
  bool has_wgs84_value() const { return true; }
  void set_bounds(double min_x, double min_y, double max_x, double max_y) { UNUSEDx(min_x, min_y, max_x, max_y); }
  int set_proj4text(ObIAllocator &allocator, const ObString &src_proj4) { UNUSEDx(allocator, src_proj4); return OB_SUCCESS; }
  void set_proj4text(ObString &src_proj4) { UNUSED(src_proj4); }
  const ObSrsBoundsItem* get_bounds() const { return NULL; }
  ObString get_proj4text() { return ObString(); }

  ObAxisDirection axis_direction(uint8_t axis_index) const { UNUSED(axis_index); return ObAxisDirection::EAST; }
  int get_proj4_param(ObIAllocator *allocator, ObString &proj4_param) const { UNUSEDx(allocator, proj4_param); return OB_SUCCESS; }
  uint32_t get_srid() const { return 0; }
private:
  DISALLOW_COPY_AND_ASSIGN(ObMockProjectedSrsBase);
};

static ObMockProjectedSrsBase mock_projected_srs;
static ObSrsItem project_srs(&mock_projected_srs);
static const ObSrsItem *mock_projected_srs_item = &project_srs;

int append_srid(ObJsonBuffer& data, uint32_t srid = 0, ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
  INIT_SUCC(ret);
  uint32_t ssrid = static_cast<uint32_t>(srid);
  if (OB_FAIL(data.reserve(sizeof(uint32_t)))) {
  } else {
    char *ptr = data.ptr() + data.length();
    ObGeoWkbByteOrderUtil::write<uint32_t>(ptr, ssrid, bo);
    ret = data.set_length(data.length() + sizeof(uint32_t));
  }
  return ret;
}

int append_bo(ObJsonBuffer& data, ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    uint8_t sbo = static_cast<uint8_t>(bo);
    return data.append(reinterpret_cast<char*>(&sbo), sizeof(uint8_t));
}

int append_type(ObJsonBuffer& data, ObGeoType type, ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    INIT_SUCC(ret);
    uint32_t stype = static_cast<uint32_t>(type);
    if (OB_FAIL(data.reserve(sizeof(uint32_t)))) {
    } else {
        char *ptr = data.ptr() + data.length();
        ObGeoWkbByteOrderUtil::write<uint32_t>(ptr, stype, bo);
        ret = data.set_length(data.length() + sizeof(uint32_t));
    }
    return ret;
}

int append_uint32(ObJsonBuffer& data, uint32_t val, ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    INIT_SUCC(ret);
    if (OB_FAIL(data.reserve(sizeof(uint32_t)))) {
    } else {
        char *ptr = data.ptr() + data.length();
        ObGeoWkbByteOrderUtil::write<uint32_t>(ptr, val, bo);
        ret = data.set_length(data.length() + sizeof(uint32_t));
    }
    return ret;
}

int append_double(ObJsonBuffer& data, double val, ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    INIT_SUCC(ret);
    if (OB_FAIL(data.reserve(sizeof(double)))) {
    } else {
        char *ptr = data.ptr() + data.length();
        ObGeoWkbByteOrderUtil::write<double>(ptr, val, bo);
        ret = data.set_length(data.length() + sizeof(double));
    }
    return ret;
}

void append_random_inner_point(ObJsonBuffer& data, common::ObVector<double>& xv, common::ObVector<double>& yv,
  GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
  ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    if (type == GeogValueValidType::NOT_DEFINED) {
        double x = static_cast<double>(rand())/static_cast<double>(rand());
        double y = static_cast<double>(rand())/static_cast<double>(rand());
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        xv.push_back(x);
        yv.push_back(y);
    } else if (type == GeogValueValidType::IN_RANGE) {
        ASSERT_TRUE(srs_item != NULL);
        double x = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
        x *= srs_item->angular_unit();
        double y = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(90));
        y *= srs_item->angular_unit();
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        xv.push_back(x);
        yv.push_back(y);
    } else {
        ASSERT_TRUE(srs_item != NULL);
        double x = static_cast<double>(rand())/static_cast<double>(rand());
        x += static_cast<double>(180);
        double y = static_cast<double>(rand())/static_cast<double>(rand());
        y += static_cast<double>(90);
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        xv.push_back(x);
        yv.push_back(y);
    }
}

void append_random_point(ObJsonBuffer& data, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    append_random_inner_point(data, xv, yv, type);
}

void append_ring(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    for (int k = 0; k < pnum; k++) {
        if (type == GeogValueValidType::OUT_RANGE && k == pnum - 1) {
            append_random_inner_point(data, xv, yv, GeogValueValidType::OUT_RANGE, bo);
        } else {
            append_random_inner_point(data, xv, yv, type, bo);
        }
    }
}

void append_line(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING, bo));
    append_ring(data, pnum, xv, yv, type, bo);
}

void append_random_inner_point_3d(ObJsonBuffer& data, common::ObVector<double>& xv, common::ObVector<double>& yv,
  common::ObVector<double>& zv,
  GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
  ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_TRUE(srs_item != NULL);
    double x = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
    x *= srs_item->angular_unit();
    double y = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(90));
    y *= srs_item->angular_unit();
    double z = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
    ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, z, bo));
    xv.push_back(x);
    yv.push_back(y);
    zv.push_back(z);
}

void append_line_3d(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRINGZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    for (int k = 0; k < pnum; k++) {
      append_random_inner_point_3d(data, xv, yv, zv, type, bo);
    }
}

void append_ring_3d(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    for (int k = 0; k < pnum; k++) {
      append_random_inner_point_3d(data, xv, yv, zv, type, bo);
    }
}

void append_poly_3d(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGONZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    // push rings
    for (int j = 0; j < lnum; j++) {
        append_ring_3d(data, pnum, xv, yv, zv, type, bo);
    }
}

void append_multi_line_3d(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRINGZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    // push lines
    for (int j = 0; j < lnum; j++) {
        append_line_3d(data, pnum, xv, yv, zv, type, bo);
    }
}

void append_poly(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    // push rings
    for (int j = 0; j < lnum; j++) {
        if (type == GeogValueValidType::OUT_RANGE && j == lnum - 1) {
            append_ring(data, pnum, xv, yv, GeogValueValidType::OUT_RANGE, bo);
        } else {
            append_ring(data, pnum, xv, yv, type, bo);
        }
    }
}

void append_multi_point(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
    for (int i = 0; i < pnum; i++) {
        if (type == GeogValueValidType::OUT_RANGE && i == pnum - 1) {
            append_random_point(data, xv, yv, GeogValueValidType::OUT_RANGE);
        } else {
            append_random_point(data, xv, yv, type);
        }
    }
}

void append_multi_line(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRING, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    // push lines
    for (int j = 0; j < lnum; j++) {
        append_line(data, pnum, xv, yv, type, bo);
    }
}

void append_rectangle(ObJsonBuffer& data, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    uint32_t pnum = 5;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    ASSERT_TRUE(srs_item != NULL);

    double lower_left_x = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
    lower_left_x *= srs_item->angular_unit();
    double lower_left_y = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(90));
    lower_left_y *= srs_item->angular_unit();
    xv.push_back(lower_left_x);
    yv.push_back(lower_left_y);

    double upper_right_x = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
    upper_right_x *= srs_item->angular_unit();
    double upper_right_y = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(90));
    upper_right_y *= srs_item->angular_unit();
    xv.push_back(upper_right_x);
    yv.push_back(upper_right_y);

    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, upper_right_x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, upper_right_x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, upper_right_y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, upper_right_y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, lower_left_y, bo));
}

void append_sdo_multi_point(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    for (int i = 0; i < pnum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT, bo));
        append_random_inner_point(data, xv, yv, type, bo);
    }
}

void append_sdo_multi_point_3d(ObJsonBuffer& data, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINTZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum, bo));
    for (int i = 0; i < pnum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINTZ, bo));
        append_random_inner_point_3d(data, xv, yv, zv, type, bo);
    }
}

void append_sdo_multi_poly_3d(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    common::ObVector<uint64_t>& pnumv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGONZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    uint32_t fix_poly_num = 1;
    // push rings
    for (int j = 0; j < lnum; j++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGONZ, bo));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, fix_poly_num, bo));
        append_ring_3d(data, pnum, xv, yv, zv, type, bo);
        pnumv.push_back(pnum);
        // to do : rectangle
    }
}

void append_sdo_multi_poly(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<uint64_t>& pnumv,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    uint32_t fix_poly_num = 1;
    // push rings
    for (int j = 0; j < lnum; j++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, fix_poly_num, bo));
        if (rand() % 2) {
            append_ring(data, pnum, xv, yv, type, bo); // 1604
            pnumv.push_back(pnum);
        } else {
            append_rectangle(data, xv, yv, type, bo); // 84
            pnumv.push_back(2);
        }
    }
}

void append_sdo_collection(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<ObGeoType>& types,
    common::ObVector<uint64_t>& pnums,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    for (int j = 0; j < lnum; j++) {
        if (rand() % 5 == 0) {
            // point
            double x = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(180));
            x *= srs_item->angular_unit();
            double y = fmod(static_cast<double>(rand())/static_cast<double>(rand()), static_cast<double>(90));
            y *= srs_item->angular_unit();
            xv.push_back(x);
            yv.push_back(y);
            ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
            ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT, bo));
            ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
            ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
            types.push_back(ObGeoType::POINT);
            pnums.push_back(1);
        } else if (rand() % 5 == 1) {
            // multipoint with pnum point
            append_sdo_multi_point(data, pnum, xv, yv, type, bo);
            types.push_back(ObGeoType::MULTILINESTRING);
            pnums.push_back(pnum);
        } else if (rand() % 5 == 2) {
            // ring with pnum point
            ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
            ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
            ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1, bo));
            append_ring(data, pnum, xv, yv, type, bo);
            types.push_back(ObGeoType::POLYGON);
            pnums.push_back(pnum);
        } else if (rand() % 5 == 3) {
            // rectangle
            ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
            ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
            ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1, bo));
            append_rectangle(data, xv, yv, type, bo);
            types.push_back(ObGeoType::POLYGON);
            pnums.push_back(2);
        } else {
            // linestring with pnum point
            append_line(data, pnum, xv, yv, type, bo);
            types.push_back(ObGeoType::LINESTRING);
            pnums.push_back(pnum);
        }
    }
}

void append_sdo_collection_3d(ObJsonBuffer& data, uint32_t lnum, uint32_t pnum, common::ObVector<double>& xv, common::ObVector<double>& yv,
    common::ObVector<double>& zv,
    common::ObVector<ObGeoType>& types,
    common::ObVector<uint64_t>& pnums,
    GeogValueValidType type = GeogValueValidType::NOT_DEFINED,
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::LittleEndian)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTIONZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum, bo));
    for (int j = 0; j < lnum; j++) {
        if (j % 4 == 0) {
            // point
            ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
            ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINTZ, bo));
            append_random_inner_point_3d(data, xv, yv, zv, type, bo);
            types.push_back(ObGeoType::POINTZ);
            pnums.push_back(1);
        } else if (j % 4 == 1) {
            // multipoint with pnum point
            append_sdo_multi_point_3d(data, pnum, xv, yv, zv,type, bo);
            types.push_back(ObGeoType::MULTIPOINTZ);
            pnums.push_back(pnum);
        } else if (j % 4 == 2) {
            // polygon
            append_poly_3d(data, 1, 5, xv, yv, zv, type, bo);
            types.push_back(ObGeoType::POLYGONZ);
            pnums.push_back(5);
        } else {
            // linestring with pnum point
            append_line_3d(data, pnum, xv, yv, zv, type, bo);
            types.push_back(ObGeoType::LINESTRINGZ);
            pnums.push_back(pnum);
        }
    }
}

template<typename T>
void check_lines(T& line, uint32_t& pc, common::ObVector<double>& xv, common::ObVector<double>& yv, bool is_const = false)
{
    auto lei = line.end();
    auto lbi = line.begin();
    if (is_const) {
        typename T::const_iterator iter = lbi;

        for (; iter != lei; ++iter, ++pc) {
            ASSERT_EQ(xv[pc], iter->template get<0>());
            ASSERT_EQ(yv[pc], iter->template get<1>());
        }
        uint32_t ii = pc;
        --iter;
        --ii;
        for (; iter >= lbi; --iter, --ii) {
            ASSERT_EQ(xv[ii], iter->template get<0>());
            ASSERT_EQ(yv[ii], iter->template get<1>());
        }
    } else {
        typename T::iterator iter = lbi;
        for (; iter != lei; ++iter, ++pc) {
            ASSERT_EQ(xv[pc], iter->template get<0>());
            ASSERT_EQ(yv[pc], iter->template get<1>());
        }
        uint32_t ii = pc;
        --iter;
        --ii;
        for (; iter >= lbi; --iter, --ii) {
            ASSERT_EQ(xv[ii], iter->template get<0>());
            ASSERT_EQ(yv[ii], iter->template get<1>());
        }
    }
}

// Cartesian
TEST_F(TestGeoBin, point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));
    ObWkbGeomPoint& p = *reinterpret_cast<ObWkbGeomPoint*>(data.ptr());
    ASSERT_EQ(1.323, p.get<0>());
    ASSERT_EQ(999.5456, p.get<1>());
    p.set<0>(3.321);
    p.set<1>(4.444);
    ObWkbGeomPoint& p2 = *reinterpret_cast<ObWkbGeomPoint*>(data.ptr());
    ASSERT_EQ(3.321, p2.get<0>());
    ASSERT_EQ(4.444, p2.get<1>());
}

TEST_F(TestGeoBin, wkb_to_json_visitor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));

    ObIWkbGeomPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;

    visitor.reset();
    res.reset();
    ObIWkbGeogPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;

}

TEST_F(TestGeoBin, wkb_to_json_visitor_linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    uint32_t num = 5;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, num, xv, yv);

    ObIWkbGeomLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;

    visitor.reset();
    res.reset();
    ObIWkbGeogLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, wkb_to_json_visitor_polygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObString res;
    ObJsonBuffer data(&allocator);
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    uint32_t rnum = 3;
    uint32_t pnum = 2;
    append_poly(data, rnum, pnum, xv, yv);

    ObIWkbGeogPolygon iwkb_geog_poly;
    iwkb_geog_poly.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog_poly.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;

    visitor.reset();
    res.reset();
    ObIWkbGeomPolygon iwkb_geom_poly;
    iwkb_geom_poly.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geom_poly.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json: " << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, wkb_to_json_visitor_multi_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    uint32_t num = 2;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_point(data, num, xv, yv);

    ObIWkbGeogMultiPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;

    ObIWkbGeomMultiPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    res.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, wkb_to_json_visitor_multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    uint32_t pnum = 2;
    uint32_t lnum = 3;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv);

    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;

    ObIWkbGeomMultiLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    res.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, wkb_to_json_visitor_multi_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    uint32_t polynum = 2;
    uint32_t lnum = 3;
    uint32_t pnum = 2;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(data, lnum, pnum, xv[i], yv[i]);
    }

    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;

    ObIWkbGeomMultiPolygon iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    res.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, wkb_to_json_visitor_geom_collection)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObString res;
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 2, xv[1], yv[1]);
    // polygon
    append_poly(data, 3, 2, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 3, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 2, 2, xv[4], yv[4]);
    // multipolygon
    int64_t polygon_num = 2;
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polygon_num));
    for (int i = 0; i < polygon_num; i++) {
        append_poly(data, 3, 2, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObWkbToJsonVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;

    ObIWkbGeomCollection iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    res.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    visitor.get_geojson(res);
    ASSERT_EQ(false, res.empty());
    std::cout << "geo json:" << std::string(res.ptr(), res.length()) << std::endl;
}

TEST_F(TestGeoBin, linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, num, xv, yv);

    ObWkbGeomLineString& line = *reinterpret_cast<ObWkbGeomLineString*>(data.ptr());
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomLineString::iterator iter = line.begin();
    auto ei = line.end();
    auto bi = line.begin();
    for (int i = 0; iter != ei; ++iter, i++) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = num - 1; iter >= bi; --iter, i--) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomLineString::const_iterator citer = line.begin();
    for (int i = 0; citer != ei; ++citer, i++) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = num - 1; citer >= bi; --citer, i--) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, polygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_poly(data, lnum, pnum, xv, yv);

    ObWkbGeomPolygon& poly = *reinterpret_cast<ObWkbGeomPolygon*>(data.ptr());
    ObWkbGeomLinearRing& exterior = poly.exterior_ring();
    ObWkbGeomPolygonInnerRings& inner_rings = poly.inner_rings();
    uint32_t pc = 0;
    // check exterior
    check_lines(exterior, pc, xv, yv);
    // check inner rings
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomPolygonInnerRings::iterator iter = inner_rings.begin();
    auto irei = inner_rings.end();
    auto irbi = inner_rings.begin();
    for (; iter != irei; iter++) {
        check_lines(*iter, pc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    pc -= pnum;
    for (; iter >= irbi; iter--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*iter, tpc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    pc = pnum;
    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomPolygonInnerRings::const_iterator citer = inner_rings.begin();
    for (; citer != irei; citer++) {
        check_lines(*citer, pc, xv, yv, true);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    pc -= pnum;
    for (; citer >= irbi; citer--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*citer, tpc, xv, yv, true);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, multi_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_point(data, num, xv, yv);

    ObWkbGeomMultiPoint& mp = *reinterpret_cast<ObWkbGeomMultiPoint*>(data.ptr());
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomMultiPoint::iterator iter = mp.begin();
    auto mpbi = mp.begin();
    auto mpei = mp.end();
    for (int i = 0; iter != mpei; ++iter, i++) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = num - 1; iter >= mpbi; --iter, i--) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomMultiPoint::const_iterator citer = mp.begin();
    for (int i = 0; citer != mpei; ++citer, i++) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = num - 1; citer >= mpbi; --citer, i--) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv);

    ObWkbGeomMultiLineString& ml = *reinterpret_cast<ObWkbGeomMultiLineString*>(data.ptr());
    uint32_t pc = 0;
    // check lines
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomMultiLineString::iterator iter = ml.begin();
    auto mlbi = ml.begin();
    auto mlei = ml.end();
    for (; iter != mlei; iter++) {
        check_lines(*iter, pc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    pc -= pnum;
    for (; iter >= mlbi; iter--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*iter, tpc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    pc = 0;
    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomMultiLineString::const_iterator citer = ml.begin();
    for (; citer != mlei; citer++) {
        check_lines(*citer, pc, xv, yv, true);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    pc -= pnum;
    for (; citer >= mlbi; citer--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*citer, tpc, xv, yv, true);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, multi_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 99 inner line, every line has 100 point
    uint32_t polynum = 100;
    uint32_t lnum = 100;
    uint32_t pnum = 100;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(data, lnum, pnum, xv[i], yv[i]);
    }

    ObWkbGeomMultiPolygon& mp = *reinterpret_cast<ObWkbGeomMultiPolygon*>(data.ptr());
    ObWkbGeomMultiPolygon::iterator iter = mp.begin();
    auto mpei = mp.end();
    auto mpbi = mp.begin();
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; iter != mpei; ++iter, i++) {
        typename ObWkbGeomMultiPolygon::value_type& poly = *iter;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i]);
        auto& inner_rings = iter->inner_rings();
        ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
        auto irei = inner_rings.end();
        auto irbi = inner_rings.begin();
        for (; riter != irei; riter++) {
            check_lines(*riter, pc, xv[i], yv[i]);
        }
        --riter;
        pc -= pnum;
        for (; riter >= irbi; riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i]);
        }
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = polynum - 1; iter >= mpbi; --iter, --i) {
        typename ObWkbGeomMultiPolygon::value_type& poly = *iter;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i]);
        auto& inner_rings = iter->inner_rings();
        ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
        auto irei = inner_rings.end();
        auto irbi = inner_rings.begin();
        for (; riter != irei; riter++) {
            check_lines(*riter, pc, xv[i], yv[i]);
        }
        --riter;
        pc -= pnum;
        for (; riter >= irbi; riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i]);
        }
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    // const_iter
    ObWkbGeomMultiPolygon::const_iterator citer = mp.begin();
    t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; citer != mpei; ++citer, i++) {
        typename ObWkbGeomMultiPolygon::value_type& poly = *citer;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i], true);
        auto& inner_rings = citer->inner_rings();
        ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
        auto irei = inner_rings.end();
        auto irbi = inner_rings.begin();
        for (; riter != irei; riter++) {
            check_lines(*riter, pc, xv[i], yv[i], true);
        }
        --riter;
        pc -= pnum;
        for (; riter >= irbi; riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i], true);
        }
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = polynum - 1; citer >= mpbi; --citer, --i) {
        typename ObWkbGeomMultiPolygon::value_type& poly = *citer;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i], true);
        auto& inner_rings = citer->inner_rings();
        ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
        auto irei = inner_rings.end();
        auto irbi = inner_rings.begin();
        for (; riter != irei; riter++) {
            check_lines(*riter, pc, xv[i], yv[i], true);
        }
        --riter;
        pc -= pnum;
        for (; riter >= irbi; riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i], true);
        }
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, geom_collection)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 100, xv[1], yv[1]);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    // check
    ObWkbGeomCollection& gc = *reinterpret_cast<ObWkbGeomCollection*>(data.ptr());
    ObWkbGeomCollection::iterator iter = gc.begin();
    for (int i = 0; iter != gc.end(); ++iter, ++i) {
        typename ObWkbGeomCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = gc.get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeomPoint* point = reinterpret_cast<const ObWkbGeomPoint*>(sub_ptr);
            ASSERT_EQ(xv[0][0], point->get<0>());
            ASSERT_EQ(yv[0][0], point->get<1>());
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeomLineString* line = reinterpret_cast<const ObWkbGeomLineString*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, line->size());
            check_lines(*line, pc, xv[1], yv[1]);
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeomPolygon* poly = reinterpret_cast<const ObWkbGeomPolygon*>(sub_ptr);
            uint32_t pc = 0;
            check_lines(poly->exterior_ring(), pc, xv[2], yv[2]);
            auto& inner_rings = poly->inner_rings();
            ASSERT_EQ(99, inner_rings.size());
            ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
            for (; riter != inner_rings.end(); riter++) {
                check_lines(*riter, pc, xv[2], yv[2]);
            }
            --riter;
            pc -= 100;
            for (; riter >= inner_rings.begin(); riter--, pc -= 100) {
                uint32_t tpc = pc;
                check_lines(*riter, tpc, xv[2], yv[2]);
            }
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeomMultiPoint* mp = reinterpret_cast<const ObWkbGeomMultiPoint*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, mp->size());
            check_lines(*mp, pc, xv[3], yv[3]);
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeomMultiLineString* ml = reinterpret_cast<const ObWkbGeomMultiLineString*>(sub_ptr);
            ASSERT_EQ(1000, ml->size());
            uint32_t pc = 0;
            ObWkbGeomMultiLineString::iterator liter = ml->begin();
            for (; liter != ml->end(); liter++) {
                check_lines(*liter, pc, xv[4], yv[4]);
            }
            liter--;
            pc -= 10;
            for (; liter >= ml->begin(); liter--, pc -= 10) {
                uint32_t tpc = pc;
                check_lines(*liter, tpc, xv[4], yv[4]);
            }
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeomMultiPolygon* mp = reinterpret_cast<const ObWkbGeomMultiPolygon*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(10, mp->size());
            ObWkbGeomMultiPolygon::iterator mpiter = mp->begin();
            for (; mpiter != mp->end(); ++mpiter) {
                ASSERT_EQ(10, mpiter->size());
                check_lines(mpiter->exterior_ring(), pc, xv[5], yv[5]);
                auto& inner_rings = mpiter->inner_rings();
                ASSERT_EQ(9, inner_rings.size());
                ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
                for (; riter != inner_rings.end(); riter++) {
                    check_lines(*riter, pc, xv[5], yv[5]);
                }
                uint32_t rpc = pc;
                --riter;
                rpc -= 100;
                for (; riter >= inner_rings.begin(); riter--, rpc -= 100) {
                    uint32_t tpc = rpc;
                    check_lines(*riter, tpc, xv[5], yv[5]);
                }
            }
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeomCollection* subgc = reinterpret_cast<const ObWkbGeomCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
    --iter;
    for (int i = 6; iter >= gc.begin(); --iter, --i) {
        typename ObWkbGeomCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = gc.get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeomPoint* point = reinterpret_cast<const ObWkbGeomPoint*>(sub_ptr);
            ASSERT_EQ(xv[0][0], point->get<0>());
            ASSERT_EQ(yv[0][0], point->get<1>());
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeomLineString* line = reinterpret_cast<const ObWkbGeomLineString*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, line->size());
            check_lines(*line, pc, xv[1], yv[1]);
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeomPolygon* poly = reinterpret_cast<const ObWkbGeomPolygon*>(sub_ptr);
            uint32_t pc = 0;
            check_lines(poly->exterior_ring(), pc, xv[2], yv[2]);
            auto& inner_rings = poly->inner_rings();
            ASSERT_EQ(99, inner_rings.size());
            ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
            for (; riter != inner_rings.end(); riter++) {
                check_lines(*riter, pc, xv[2], yv[2]);
            }
            --riter;
            pc -= 100;
            for (; riter >= inner_rings.begin(); riter--, pc -= 100) {
                uint32_t tpc = pc;
                check_lines(*riter, tpc, xv[2], yv[2]);
            }
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeomMultiPoint* mp = reinterpret_cast<const ObWkbGeomMultiPoint*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, mp->size());
            check_lines(*mp, pc, xv[3], yv[3]);
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeomMultiLineString* ml = reinterpret_cast<const ObWkbGeomMultiLineString*>(sub_ptr);
            ASSERT_EQ(1000, ml->size());
            uint32_t pc = 0;
            ObWkbGeomMultiLineString::iterator liter = ml->begin();
            for (; liter != ml->end(); liter++) {
                check_lines(*liter, pc, xv[4], yv[4]);
            }
            liter--;
            pc -= 10;
            for (; liter >= ml->begin(); liter--, pc -= 10) {
                uint32_t tpc = pc;
                check_lines(*liter, tpc, xv[4], yv[4]);
            }
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeomMultiPolygon* mp = reinterpret_cast<const ObWkbGeomMultiPolygon*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(10, mp->size());
            ObWkbGeomMultiPolygon::iterator mpiter = mp->begin();
            for (; mpiter != mp->end(); ++mpiter) {
                ASSERT_EQ(10, mpiter->size());
                check_lines(mpiter->exterior_ring(), pc, xv[5], yv[5]);
                auto& inner_rings = mpiter->inner_rings();
                ASSERT_EQ(9, inner_rings.size());
                ObWkbGeomPolygonInnerRings::iterator riter = inner_rings.begin();
                for (; riter != inner_rings.end(); riter++) {
                    check_lines(*riter, pc, xv[5], yv[5]);
                }
                uint32_t rpc = pc;
                --riter;
                rpc -= 100;
                for (; riter >= inner_rings.begin(); riter--, rpc -= 100) {
                    uint32_t tpc = rpc;
                    check_lines(*riter, tpc, xv[5], yv[5]);
                }
            }
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeomCollection* subgc = reinterpret_cast<const ObWkbGeomCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
}

// Geograpgic
TEST_F(TestGeoBin, Geo_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));
    ObWkbGeogPoint& p = *reinterpret_cast<ObWkbGeogPoint*>(data.ptr());
    ASSERT_EQ(1.323, p.get<0>());
    ASSERT_EQ(999.5456, p.get<1>());
    p.set<0>(3.321);
    p.set<1>(4.444);
    ObWkbGeogPoint& p2 = *reinterpret_cast<ObWkbGeogPoint*>(data.ptr());
    ASSERT_EQ(3.321, p2.get<0>());
    ASSERT_EQ(4.444, p2.get<1>());
}

TEST_F(TestGeoBin, Geo_linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, num, xv, yv);

    ObWkbGeogLineString& line = *reinterpret_cast<ObWkbGeogLineString*>(data.ptr());
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogLineString::iterator iter = line.begin();
    for (int i = 0; iter != line.end(); ++iter, i++) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = num - 1; iter >= line.begin(); --iter, i--) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogLineString::const_iterator citer = line.begin();
    for (int i = 0; citer != line.end(); ++citer, i++) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = num - 1; citer >= line.begin(); --citer, i--) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, Geo_polygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_poly(data, lnum, pnum, xv, yv);

    ObWkbGeogPolygon& poly = *reinterpret_cast<ObWkbGeogPolygon*>(data.ptr());
    ObWkbGeogLinearRing& exterior = poly.exterior_ring();
    ObWkbGeogPolygonInnerRings& inner_rings = poly.inner_rings();
    uint32_t pc = 0;
    // check exterior
    check_lines(exterior, pc, xv, yv);
    // check inner rings
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogPolygonInnerRings::iterator iter = inner_rings.begin();
    for (; iter != inner_rings.end(); iter++) {
        check_lines(*iter, pc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    pc -= pnum;
    for (; iter >= inner_rings.begin(); iter--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*iter, tpc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    pc = pnum;
    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogPolygonInnerRings::const_iterator citer = inner_rings.begin();
    for (; citer != inner_rings.end(); citer++) {
        check_lines(*citer, pc, xv, yv, true);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    pc -= pnum;
    for (; citer >= inner_rings.begin(); citer--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*citer, tpc, xv, yv, true);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, Geo_multi_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_point(data, num, xv, yv);

    ObWkbGeogMultiPoint& mp = *reinterpret_cast<ObWkbGeogMultiPoint*>(data.ptr());
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogMultiPoint::iterator iter = mp.begin();
    for (int i = 0; iter != mp.end(); ++iter, i++) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = num - 1; iter >= mp.begin(); --iter, i--) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogMultiPoint::const_iterator citer = mp.begin();
    for (int i = 0; citer != mp.end(); ++citer, i++) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = num - 1; citer >= mp.begin(); --citer, i--) {
        ASSERT_EQ(xv[i], citer->get<0>());
        ASSERT_EQ(yv[i], citer->get<1>());
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, Geo_multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv);

    ObWkbGeogMultiLineString& ml = *reinterpret_cast<ObWkbGeogMultiLineString*>(data.ptr());
    uint32_t pc = 0;
    // check lines
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogMultiLineString::iterator iter = ml.begin();
    for (; iter != ml.end(); iter++) {
        check_lines(*iter, pc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    pc -= pnum;
    for (; iter >= ml.begin(); iter--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*iter, tpc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    pc = 0;
    t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeogMultiLineString::const_iterator citer = ml.begin();
    for (; citer != ml.end(); citer++) {
        check_lines(*citer, pc, xv, yv, true);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    pc -= pnum;
    for (; citer >= ml.begin(); citer--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*citer, tpc, xv, yv, true);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, Geo_multi_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 99 inner line, every line has 100 point
    uint32_t polynum = 100;
    uint32_t lnum = 100;
    uint32_t pnum = 100;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(data, lnum, pnum, xv[i], yv[i]);
    }

    ObWkbGeogMultiPolygon& mp = *reinterpret_cast<ObWkbGeogMultiPolygon*>(data.ptr());
    ObWkbGeogMultiPolygon::iterator iter = mp.begin();
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; iter != mp.end(); ++iter, i++) {
        typename ObWkbGeogMultiPolygon::value_type& poly = *iter;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i]);
        auto& inner_rings = iter->inner_rings();
        ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
        for (; riter != inner_rings.end(); riter++) {
            check_lines(*riter, pc, xv[i], yv[i]);
        }
        --riter;
        pc -= pnum;
        for (; riter >= inner_rings.begin(); riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i]);
        }
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = polynum - 1; iter >= mp.begin(); --iter, --i) {
        typename ObWkbGeogMultiPolygon::value_type& poly = *iter;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i]);
        auto& inner_rings = iter->inner_rings();
        ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
        for (; riter != inner_rings.end(); riter++) {
            check_lines(*riter, pc, xv[i], yv[i]);
        }
        --riter;
        pc -= pnum;
        for (; riter >= inner_rings.begin(); riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i]);
        }
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
    // const_iter
    ObWkbGeogMultiPolygon::const_iterator citer = mp.begin();
    t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; citer != mp.end(); ++citer, i++) {
        typename ObWkbGeogMultiPolygon::value_type& poly = *citer;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i], true);
        auto& inner_rings = citer->inner_rings();
        ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
        for (; riter != inner_rings.end(); riter++) {
            check_lines(*riter, pc, xv[i], yv[i], true);
        }
        --riter;
        pc -= pnum;
        for (; riter >= inner_rings.begin(); riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i], true);
        }
    }
    t2 = std::chrono::high_resolution_clock::now();
    --citer;
    for (int i = polynum - 1; citer >= mp.begin(); --citer, --i) {
        typename ObWkbGeogMultiPolygon::value_type& poly = *citer;
        uint32_t pc = 0;
        check_lines(poly.exterior_ring(), pc, xv[i], yv[i], true);
        auto& inner_rings = citer->inner_rings();
        ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
        for (; riter != inner_rings.end(); riter++) {
            check_lines(*riter, pc, xv[i], yv[i], true);
        }
        --riter;
        pc -= pnum;
        for (; riter >= inner_rings.begin(); riter--, pc -= pnum) {
            uint32_t tpc = pc;
            check_lines(*riter, tpc, xv[i], yv[i], true);
        }
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("citer:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());
}

TEST_F(TestGeoBin, geog_collection)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 100, xv[1], yv[1]);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    // check
    ObWkbGeogCollection& gc = *reinterpret_cast<ObWkbGeogCollection*>(data.ptr());
    ObWkbGeogCollection::iterator iter = gc.begin();
    for (int i = 0; iter != gc.end(); ++iter, ++i) {
        typename ObWkbGeogCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = gc.get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeogPoint* point = reinterpret_cast<const ObWkbGeogPoint*>(sub_ptr);
            ASSERT_EQ(xv[0][0], point->get<0>());
            ASSERT_EQ(yv[0][0], point->get<1>());
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeogLineString* line = reinterpret_cast<const ObWkbGeogLineString*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, line->size());
            check_lines(*line, pc, xv[1], yv[1]);
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeogPolygon* poly = reinterpret_cast<const ObWkbGeogPolygon*>(sub_ptr);
            uint32_t pc = 0;
            check_lines(poly->exterior_ring(), pc, xv[2], yv[2]);
            auto& inner_rings = poly->inner_rings();
            ASSERT_EQ(99, inner_rings.size());
            ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
            for (; riter != inner_rings.end(); riter++) {
                check_lines(*riter, pc, xv[2], yv[2]);
            }
            --riter;
            pc -= 100;
            for (; riter >= inner_rings.begin(); riter--, pc -= 100) {
                uint32_t tpc = pc;
                check_lines(*riter, tpc, xv[2], yv[2]);
            }
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeogMultiPoint* mp = reinterpret_cast<const ObWkbGeogMultiPoint*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, mp->size());
            check_lines(*mp, pc, xv[3], yv[3]);
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeogMultiLineString* ml = reinterpret_cast<const ObWkbGeogMultiLineString*>(sub_ptr);
            ASSERT_EQ(1000, ml->size());
            uint32_t pc = 0;
            ObWkbGeogMultiLineString::iterator liter = ml->begin();
            for (; liter != ml->end(); liter++) {
                check_lines(*liter, pc, xv[4], yv[4]);
            }
            liter--;
            pc -= 10;
            for (; liter >= ml->begin(); liter--, pc -= 10) {
                uint32_t tpc = pc;
                check_lines(*liter, tpc, xv[4], yv[4]);
            }
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeogMultiPolygon* mp = reinterpret_cast<const ObWkbGeogMultiPolygon*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(10, mp->size());
            ObWkbGeogMultiPolygon::iterator mpiter = mp->begin();
            for (; mpiter != mp->end(); ++mpiter) {
                ASSERT_EQ(10, mpiter->size());
                check_lines(mpiter->exterior_ring(), pc, xv[5], yv[5]);
                auto& inner_rings = mpiter->inner_rings();
                ASSERT_EQ(9, inner_rings.size());
                ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
                for (; riter != inner_rings.end(); riter++) {
                    check_lines(*riter, pc, xv[5], yv[5]);
                }
                uint32_t rpc = pc;
                --riter;
                rpc -= 100;
                for (; riter >= inner_rings.begin(); riter--, rpc -= 100) {
                    uint32_t tpc = rpc;
                    check_lines(*riter, tpc, xv[5], yv[5]);
                }
            }
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeogCollection* subgc = reinterpret_cast<const ObWkbGeogCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
    --iter;
    for (int i = 6; iter >= gc.begin(); --iter, --i) {
        typename ObWkbGeogCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = gc.get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeogPoint* point = reinterpret_cast<const ObWkbGeogPoint*>(sub_ptr);
            ASSERT_EQ(xv[0][0], point->get<0>());
            ASSERT_EQ(yv[0][0], point->get<1>());
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeogLineString* line = reinterpret_cast<const ObWkbGeogLineString*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, line->size());
            check_lines(*line, pc, xv[1], yv[1]);
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeogPolygon* poly = reinterpret_cast<const ObWkbGeogPolygon*>(sub_ptr);
            uint32_t pc = 0;
            check_lines(poly->exterior_ring(), pc, xv[2], yv[2]);
            auto& inner_rings = poly->inner_rings();
            ASSERT_EQ(99, inner_rings.size());
            ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
            for (; riter != inner_rings.end(); riter++) {
                check_lines(*riter, pc, xv[2], yv[2]);
            }
            --riter;
            pc -= 100;
            for (; riter >= inner_rings.begin(); riter--, pc -= 100) {
                uint32_t tpc = pc;
                check_lines(*riter, tpc, xv[2], yv[2]);
            }
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeogMultiPoint* mp = reinterpret_cast<const ObWkbGeogMultiPoint*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, mp->size());
            check_lines(*mp, pc, xv[3], yv[3]);
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeogMultiLineString* ml = reinterpret_cast<const ObWkbGeogMultiLineString*>(sub_ptr);
            ASSERT_EQ(1000, ml->size());
            uint32_t pc = 0;
            ObWkbGeogMultiLineString::iterator liter = ml->begin();
            for (; liter != ml->end(); liter++) {
                check_lines(*liter, pc, xv[4], yv[4]);
            }
            liter--;
            pc -= 10;
            for (; liter >= ml->begin(); liter--, pc -= 10) {
                uint32_t tpc = pc;
                check_lines(*liter, tpc, xv[4], yv[4]);
            }
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeogMultiPolygon* mp = reinterpret_cast<const ObWkbGeogMultiPolygon*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(10, mp->size());
            ObWkbGeogMultiPolygon::iterator mpiter = mp->begin();
            for (; mpiter != mp->end(); ++mpiter) {
                ASSERT_EQ(10, mpiter->size());
                check_lines(mpiter->exterior_ring(), pc, xv[5], yv[5]);
                auto& inner_rings = mpiter->inner_rings();
                ASSERT_EQ(9, inner_rings.size());
                ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
                for (; riter != inner_rings.end(); riter++) {
                    check_lines(*riter, pc, xv[5], yv[5]);
                }
                uint32_t rpc = pc;
                --riter;
                rpc -= 100;
                for (; riter >= inner_rings.begin(); riter--, rpc -= 100) {
                    uint32_t tpc = rpc;
                    check_lines(*riter, tpc, xv[5], yv[5]);
                }
            }
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeogCollection* subgc = reinterpret_cast<const ObWkbGeogCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
}


template<typename T>
void check_null_str(ObString& str)
{
    T obj;
    obj.set_data(str);
    ASSERT_EQ(0, obj.length());
    ASSERT_EQ(true, obj.is_empty());
}

// bin interface
TEST_F(TestGeoBin, i_null_ptr)
{
    ObString str(NULL);
    { // point
        check_null_str<ObIWkbGeomPoint>(str);
        check_null_str<ObIWkbGeogPoint>(str);
    }
    { // linestring
        check_null_str<ObIWkbGeomLineString>(str);
        check_null_str<ObIWkbGeogLineString>(str);
    }
    { // polygon
        check_null_str<ObIWkbGeomPolygon>(str);
        check_null_str<ObIWkbGeogPolygon>(str);
    }
    { // multipoint
        check_null_str<ObIWkbGeomMultiPoint>(str);
        check_null_str<ObIWkbGeogMultiPoint>(str);
    }
    { // multiline
        check_null_str<ObIWkbGeomMultiLineString>(str);
        check_null_str<ObIWkbGeogMultiLineString>(str);
    }
    { // multipoly
        check_null_str<ObIWkbGeomMultiPolygon>(str);
        check_null_str<ObIWkbGeogMultiPolygon>(str);
    }
    { // gc
        check_null_str<ObIWkbGeomCollection>(str);
        check_null_str<ObIWkbGeogCollection>(str);
    }
}

TEST_F(TestGeoBin, ipoint)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));
    ObIWkbGeomPoint p;
    p.set_data(data.string());
    ASSERT_EQ(false, p.is_empty());
    ASSERT_EQ(1.323, p.x());
    ASSERT_EQ(999.5456, p.y());
    ObWkbGeomPoint& bp = *reinterpret_cast<ObWkbGeomPoint*>(const_cast<char*>(p.val()));
    bp.set<0>(3.321);
    bp.set<1>(4.444);
    ASSERT_EQ(false, p.is_empty());
    ASSERT_EQ(3.321, p.x());
    ASSERT_EQ(4.444, p.y());
    bp.set<0>(NAN);
    bp.set<1>(NAN);
    ASSERT_EQ(true, p.is_empty());
}

TEST_F(TestGeoBin, ilinestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 100;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, 0, xv, yv);

    ObIWkbGeomLineString line;
    line.set_data(data.string());
    ASSERT_EQ(true, line.is_empty());

    ObJsonBuffer data2(&allocator);
    append_line(data2, num, xv, yv);

    line.set_data(data2.string());
    ASSERT_EQ(false, line.is_empty());
}

TEST_F(TestGeoBin, ipolygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 11;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_poly(data, 1, 0, xv, yv);

    ObIWkbGeomPolygon p;
    p.set_data(data.string());
    ASSERT_EQ(p.is_empty(), true);

    ObJsonBuffer data2(&allocator);
    append_poly(data2, lnum, pnum, xv, yv);
    p.set_data(data2.string());
    ASSERT_EQ(p.is_empty(), false);
}

// iter cost test
class testPoint{
public:
    testPoint(double ix, double iy) : x(ix), y(iy) {}
    double x;
    double y;
};

class testLine{
public:
    testLine() {}
    ~testLine() {}
    common::ObVector<testPoint> points;
};

class testPolygon{
public:
    testLine exterior;
    common::ObVector<testLine> inners;
};

TEST_F(TestGeoBin, cost_iter_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<testPoint> pv;
    append_line(data, num, xv, yv);
    for (int i = 0; i < xv.size(); i++) {
        pv.push_back(testPoint(xv[i], yv[i]));
    }

    ObWkbGeomLineString& line = *reinterpret_cast<ObWkbGeomLineString*>(data.ptr());
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomLineString::iterator iter = line.begin();
    auto ei = line.end();
    auto bi = line.begin();
    for (int i = 0; iter != ei; ++iter, i++) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    for (int i = num - 1; iter >= bi; --iter, i--) {
        ASSERT_EQ(xv[i], iter->get<0>());
        ASSERT_EQ(yv[i], iter->get<1>());
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    auto pi = pv.begin();
    for (int i = 0; pi != pv.end(); ++pi, ++i) {
        ASSERT_EQ(xv[i], pi->x);
        ASSERT_EQ(yv[i], pi->y);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --pi;
    for (int i = num - 1; pi >= pv.begin(); --pi, --i) {
        ASSERT_EQ(xv[i], pi->x);
        ASSERT_EQ(yv[i], pi->y);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("vector:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    iter = line.begin();

    for (int i = 0; iter != ei; ++iter, i++) {
    }
    t2 = std::chrono::high_resolution_clock::now();
    --iter;

    for (int i = num - 1; iter >= bi; --iter, i--) {
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("iter only move:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    pi = pv.begin();
    auto pvb = pv.begin();
    auto pve = pv.end();
    for (int i = 0; pi != pve; ++pi, ++i) {
    }
    t2 = std::chrono::high_resolution_clock::now();
    --pi;
    for (int i = num - 1; pi >= pvb; --pi, --i) {
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("vector only move:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    iter = line.begin();
    for (int i = 0; i < num; i++) {
        ASSERT_EQ(xv[0], iter->get<0>());
        ASSERT_EQ(yv[0], iter->get<1>());
    }
    t2 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    printf("iter only access: %lfms\n", b2e.count());

    t1 = std::chrono::high_resolution_clock::now();
    pi = pv.begin();
    for (int i = 0; i < num; i++) {
        ASSERT_EQ(xv[0], pi->x);
        ASSERT_EQ(yv[0], pi->y);
    }
    t2 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    printf("vector only access: %lfms\n", b2e.count());
}

void check_test_lines(testLine& line, uint32_t& pc, common::ObVector<double>& xv, common::ObVector<double>& yv)
{
    auto lei = line.points.end();
    auto lbi = line.points.begin();

    auto iter = lbi;
    for (; iter != lei; ++iter, ++pc) {
        ASSERT_EQ(xv[pc], iter->x);
        ASSERT_EQ(yv[pc], iter->y);
    }
    uint32_t ii = pc;
    --iter;
    --ii;
    for (; iter >= lbi; --iter, --ii) {
        ASSERT_EQ(xv[ii], iter->x);
        ASSERT_EQ(yv[ii], iter->y);
    }
}
/*
TEST_F(TestGeoBin, cost_iter_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 100001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    testPolygon tp;
    append_poly(data, lnum, pnum, xv, yv);
    for (int i = 0; i < lnum - 1; i++) {
        tp.inners.push_back(testLine());
    }
    for (int i = 0; i < xv.size(); i++) {
        if (i < pnum) {
            tp.exterior.points.push_back(testPoint(xv[i], yv[i]));
        } else {
            tp.inners[(i-pnum)/pnum].points.push_back(testPoint(xv[i], yv[i]));
        }
    }

    ObWkbGeomPolygon& poly = *reinterpret_cast<ObWkbGeomPolygon*>(data.ptr());
    ObWkbGeomLinearRing& exterior = poly.exterior_ring();
    ObWkbGeomPolygonInnerRings& inner_rings = poly.inner_rings();
    uint32_t pc = 0;
    // check exterior
    check_lines(exterior, pc, xv, yv);
    // check inner rings
    std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
    ObWkbGeomPolygonInnerRings::iterator iter = inner_rings.begin();
    auto irei = inner_rings.end();
    auto irbi = inner_rings.begin();
    for (; iter != irei; iter++) {
        check_lines(*iter, pc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
    --iter;
    pc -= pnum;
    for (; iter >= irbi; iter--, pc -= pnum) {
        uint32_t tpc = pc;
        check_lines(*iter, tpc, xv, yv);
    }
    std::chrono::high_resolution_clock::time_point t3 = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> b2e = t2-t1;
    std::chrono::duration<double, std::milli> e2b = t3-t2;
    printf("iter:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    pc = pnum;
    t1 = std::chrono::high_resolution_clock::now();
    auto pi = tp.inners.begin();
    for (; pi != tp.inners.end(); ++pi) {
        check_test_lines(*pi, pc, xv, yv);
    }
    t2 = std::chrono::high_resolution_clock::now();
    --pi;
    pc -= pnum;
    for (; pi >= tp.inners.begin(); pi--, pc -= pnum) {
        uint32_t tpc = pc;
        check_test_lines(*pi, tpc, xv, yv);
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("vector:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    pc = pnum;
    t1 = std::chrono::high_resolution_clock::now();
    auto miterb = inner_rings.begin();
    for (; miterb != irei; miterb++) {
        auto lb = miterb->begin();
        auto le = miterb->end();
        for (auto li = lb; li != le; ++li) {}
    }
    t2 = std::chrono::high_resolution_clock::now();
    auto mitere = inner_rings.end();
    --mitere;
    pc -= pnum;
    for (; mitere >= irbi; mitere--, pc -= pnum) {
        auto lb = mitere->begin();
        auto le = mitere->end();
        for (auto li = lb; li != le; ++li) {}
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("iter only move:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    pc = pnum;
    t1 = std::chrono::high_resolution_clock::now();
    pi = tp.inners.begin();
    for (; pi != tp.inners.end(); ++pi) {
        auto lb = pi->points.begin();
        auto le = pi->points.end();
        for (auto li = lb; li != le; ++li) {}
    }
    t2 = std::chrono::high_resolution_clock::now();
    pi = tp.inners.end();
    --pi;
    pc -= pnum;
    for (; pi >= tp.inners.begin(); pi--, pc -= pnum) {
        auto lb = pi->points.begin();
        auto le = pi->points.end();
        for (auto li = lb; li != le; ++li) {}
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("vector only move:\nbegin to end : %lfms\nend to begin : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    auto aiterb = inner_rings.begin();
    auto aiterbb = aiterb->begin();
    for (int i = 0; i < lnum - 1; i++) {
        for (int j = 0; j < pnum; j++) {
            ASSERT_EQ(xv[pnum], aiterbb->get<0>());
            ASSERT_EQ(yv[pnum], aiterbb->get<1>());
        }
    }
    t2 = std::chrono::high_resolution_clock::now();
    auto aitere = inner_rings.end();
    --aitere;
    auto aiteree = aitere->end();
    --aiteree;
    uint32_t last_idx = xv.size() - 1;
    for (int i = 0; i < lnum - 1; i++) {
        for (int j = 0; j < pnum; j++) {
            ASSERT_EQ(xv[last_idx], aiteree->get<0>());
            ASSERT_EQ(yv[last_idx], aiteree->get<1>());
        }
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("iter only access:\nbegin : %lfms\nend : %lfms\n", b2e.count(), e2b.count());

    t1 = std::chrono::high_resolution_clock::now();
    auto tpb = tp.inners.begin();
    auto tpbb = tpb->points.begin();
    for (int i = 0; i < lnum - 1; i++) {
        for (int j = 0; j < pnum; j++) {
            ASSERT_EQ(xv[pnum], tpbb->x);
            ASSERT_EQ(yv[pnum], tpbb->y);
        }
    }
    t2 = std::chrono::high_resolution_clock::now();
    auto tpe = tp.inners.end();
    --tpe;
    auto tpee = tpe->points.end();
    --tpee;
    last_idx = xv.size() - 1;
    for (int i = 0; i < lnum - 1; i++) {
        for (int j = 0; j < pnum; j++) {
            ASSERT_EQ(xv[last_idx], tpee->x);
            ASSERT_EQ(yv[last_idx], tpee->y);
        }
    }
    t3 = std::chrono::high_resolution_clock::now();
    b2e = t2-t1;
    e2b = t3-t2;
    printf("vector only access:\nbegin : %lfms\nend : %lfms\n", b2e.count(), e2b.count());

}
*/
TEST_F(TestGeoBin, traits_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 0));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 0));
    ObWkbGeomPoint& p = *reinterpret_cast<ObWkbGeomPoint*>(data.ptr());

    ObJsonBuffer data2(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data2));
    ASSERT_EQ(OB_SUCCESS, append_type(data2, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 1));
    ObWkbGeomPoint& p2 = *reinterpret_cast<ObWkbGeomPoint*>(data2.ptr());

    double d = boost::geometry::distance(p, p2);
    ASSERT_DOUBLE_EQ(sqrt(2), d);
}

TEST_F(TestGeoBin, traits_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 0));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 0));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 99));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 99));
    ObWkbGeomLineString& line = *reinterpret_cast<ObWkbGeomLineString*>(data.ptr());

    ObJsonBuffer data2(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data2));
    ASSERT_EQ(OB_SUCCESS, append_type(data2, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, -1));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 1));
    ObWkbGeomPoint& p2 = *reinterpret_cast<ObWkbGeomPoint*>(data2.ptr());

    double d = boost::geometry::distance(line, p2);
    printf("d:%lf\n", d);
    ASSERT_DOUBLE_EQ(sqrt(2), d);
}

TEST_F(TestGeoBin, intersection_ml)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
    ObWkbGeomLineString& line1 = *reinterpret_cast<ObWkbGeomLineString*>(data.ptr());

    ObJsonBuffer data2(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data2));
    ASSERT_EQ(OB_SUCCESS, append_type(data2, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data2, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 3));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 3));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, 1));
    ObWkbGeomLineString& line2 = *reinterpret_cast<ObWkbGeomLineString*>(data2.ptr());

    ObCartesianMultilinestring ml(0, allocator);
    bool d = boost::geometry::intersection(line1, line2, ml);
    for (int i = 0; i < ml.size(); i++) {
		for (int j = 0; j < ml[i].size(); j++) {
            ASSERT_EQ(2U, ml[i][j].get<0>());
            ASSERT_EQ(2U, ml[i][j].get<1>());
		}
	}
}

TEST_F(TestGeoBin, mvt_encode_visitor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
    ObVector<uint32_t> expect;
    expect.push_back(9);
    expect.push_back(4);
    expect.push_back(6);

    ObIWkbGeomPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoMvtEncodeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ObVector<uint32_t> &res = visitor.get_encode_buffer();
    ASSERT_EQ(expect.size(), res.size());
    for (int i = 0; i < res.size(); i++) {
      ASSERT_EQ(expect.at(i), res.at(i));
    }
}

TEST_F(TestGeoBin, mvt_encode_visitor_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));

    ObVector<uint32_t> expect;
    expect.push_back(9);
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(10);
    expect.push_back(4);
    expect.push_back(4);

    ObIWkbGeomLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoMvtEncodeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ObVector<uint32_t> &res = visitor.get_encode_buffer();
    ASSERT_EQ(expect.size(), res.size());
    for (int i = 0; i < res.size(); i++) {
      ASSERT_EQ(expect.at(i), res.at(i));
    }
}

TEST_F(TestGeoBin, mvt_encode_visitor_multipoint)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 3)); // point number

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 2));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 3));

    ObVector<uint32_t> expect;
    expect.push_back(25);
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(2);

    ObIWkbGeomMultiPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoMvtEncodeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ObVector<uint32_t> &res = visitor.get_encode_buffer();
    ASSERT_EQ(expect.size(), res.size());
    for (int i = 0; i < res.size(); i++) {
      ASSERT_EQ(expect.at(i), res.at(i));
    }
}

TEST_F(TestGeoBin, mvt_encode_visitor_multiline)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRING));
    uint32_t lnum = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));

    uint32_t pnum = 3;
    for (uint32_t i = 0; i < lnum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 1));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 3));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 5));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 5));
    }
    ObVector<uint32_t> expect;
    expect.push_back(9); // move to
    expect.push_back(2);
    expect.push_back(2);
    expect.push_back(18); // line to
    expect.push_back(4);
    expect.push_back(4);
    expect.push_back(4);
    expect.push_back(4);
    expect.push_back(9);
    expect.push_back(7);
    expect.push_back(7);
    expect.push_back(18);
    expect.push_back(4);
    expect.push_back(4);
    expect.push_back(4);
    expect.push_back(4);

    ObIWkbGeomMultiLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoMvtEncodeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ObVector<uint32_t> &res = visitor.get_encode_buffer();
    ASSERT_EQ(expect.size(), res.size());
    for (int i = 0; i < res.size(); i++) {
      ASSERT_EQ(expect.at(i), res.at(i));
    }
}


TEST_F(TestGeoBin, mvt_encode_visitor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 4));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 160));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 200));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 310));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 160));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 200));

  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 4));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 160));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 200));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 260));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 40));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 70));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 40));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 160));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 200));

  /* POLYGON((160 200,310 20,20 20,160 200),(160 200,260 40,70 40,160 200)) */

  ObVector<uint32_t> expect;
    expect.push_back(9); // move to
    expect.push_back(320);
    expect.push_back(400);
    expect.push_back(18); // line to
    expect.push_back(300);
    expect.push_back(359);
    expect.push_back(579);
    expect.push_back(0);
    expect.push_back(15);

    expect.push_back(9); // move to
    expect.push_back(280);
    expect.push_back(360);
    expect.push_back(18); // line to
    expect.push_back(200);
    expect.push_back(319);
    expect.push_back(379);
    expect.push_back(0);
    expect.push_back(15);

    ObIWkbGeomPolygon iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoMvtEncodeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ObVector<uint32_t> &res = visitor.get_encode_buffer();
    ASSERT_EQ(expect.size(), res.size());
    for (int i = 0; i < res.size(); i++) {
      ASSERT_EQ(expect.at(i), res.at(i));
    }
}

TEST_F(TestGeoBin, wkb_size_visitor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));

    ObIWkbGeomPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    visitor.reset();
    ObIWkbGeogPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, num, xv, yv);

    ObIWkbGeomLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    visitor.reset();
    ObIWkbGeogLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_polygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    uint32_t rnum = 100;
    uint32_t pnum = 100;
    append_poly(data, rnum, pnum, xv, yv);

    ObIWkbGeogPolygon iwkb_geog_poly;
    iwkb_geog_poly.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog_poly.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    ObIWkbGeomPolygon iwkb_geom_poly;
    iwkb_geom_poly.set_data(data.string());
    visitor.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom_poly.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_multi_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_point(data, num, xv, yv);

    ObIWkbGeogMultiPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    ObIWkbGeomMultiPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv);

    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    ObIWkbGeomMultiLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_multi_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 99 inner line, every line has 100 point
    uint32_t polynum = 100;
    uint32_t lnum = 100;
    uint32_t pnum = 100;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(data, lnum, pnum, xv[i], yv[i]);
    }

    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    ObIWkbGeomMultiPolygon iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

TEST_F(TestGeoBin, wkb_size_visitor_geom_collection)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 100, xv[1], yv[1]);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoWkbSizeVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());

    ObIWkbGeomCollection iwkb_geom;
    iwkb_geom.set_data(data.string());
    visitor.reset();
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(data.length(), visitor.geo_size());
}

int mock_get_tenant_srs_item(ObIAllocator &allocator, uint64_t tenant_id, uint64_t srs_id, const ObSrsItem *&srs_item)
{
    UNUSEDx( tenant_id);
    int ret = OB_SUCCESS;
    ObGeographicRs rs;
    rs.rs_name.assign_ptr("ED50", strlen("ED50"));
    rs.datum_info.name.assign_ptr("European Datum 1950", strlen("European Datum 1950"));
    rs.datum_info.spheroid.name.assign_ptr("International 1924", strlen("International 1924"));
    rs.datum_info.spheroid.inverse_flattening = 297;
    rs.datum_info.spheroid.semi_major_axis = 6378388;
    rs.primem.longtitude = 0;
    rs.unit.conversion_factor = 0.017453292519943278;
    rs.axis.x.direction = ObAxisDirection::NORTH;
    rs.axis.y.direction = ObAxisDirection::EAST;
    rs.datum_info.towgs84.value[0] = -157.89;
    rs.datum_info.towgs84.value[1] = -17.16;
    rs.datum_info.towgs84.value[2] = -78.41;
    rs.datum_info.towgs84.value[3] = 2.118;
    rs.datum_info.towgs84.value[4] = 2.697;
    rs.datum_info.towgs84.value[5] = -1.434;
    rs.datum_info.towgs84.value[6] = -5.38;
    rs.authority.is_valid = false;

    ObSpatialReferenceSystemBase *srs_info;
    if (OB_FAIL(ObSpatialReferenceSystemBase::create_geographic_srs(&allocator, srs_id, &rs, srs_info))) {
        printf("faild to create geographical srs, ret=%d", ret);
    }
    ObSrsItem *tmp_srs_item = NULL;
    if (OB_ISNULL(tmp_srs_item = OB_NEWx(ObSrsItem, (&allocator_), srs_info))) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        printf("fail to alloc memory for srs item, ret=%d", ret);
    } else {
        srs_item = tmp_srs_item;
    }
    return ret;
}

void get_srs_item(ObIAllocator &allocator, uint64_t srs_id, const ObSrsItem *&srs_item)
{
  ASSERT_EQ(OB_SUCCESS, mock_get_tenant_srs_item(allocator, OB_SYS_TENANT_ID, srs_id, srs_item));
}

TEST_F(TestGeoBin, coordinate_range_visitor_point)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 179 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 89 * srs_item->angular_unit()));

    ObGeoCoordinateRangeVisitor visitor(srs_item);
    ObIWkbGeogPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 181 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 89 * srs_item->angular_unit()));

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(visitor.value_out_of_range() - 181) < 0.001);

    data.reset();
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 180 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 91 * srs_item->angular_unit()));

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(true, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(visitor.value_out_of_range() - 91) < 0.001);

    ObIWkbGeomPoint iwkb_geom;
    visitor.reset();
    iwkb_geom.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));
}

TEST_F(TestGeoBin, coordinate_range_visitor_linestring)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t p_num = 20;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_ring(data, p_num, xv, yv, GeogValueValidType::IN_RANGE);

    ObIWkbGeogLinearRing iwkb_geog;
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    append_ring(data, p_num, xv, yv, GeogValueValidType::OUT_RANGE);

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_lineString)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
    uint32_t p_num = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, p_num));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 179 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 89 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1 * srs_item->angular_unit()));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1 * srs_item->angular_unit()));

    ObIWkbGeogLineString iwkb_geog;
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    p_num = 20;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, p_num, xv, yv, GeogValueValidType::OUT_RANGE);

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_polygon)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    uint32_t rnum = 100;
    uint32_t pnum = 100;
    append_poly(data, rnum, pnum, xv, yv, GeogValueValidType::IN_RANGE);

    ObIWkbGeogPolygon iwkb_geog;
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    append_poly(data, rnum, pnum, xv, yv, GeogValueValidType::OUT_RANGE);

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_multipoint)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    uint32_t pnum = 100;
    append_multi_point(data, pnum, xv, yv, GeogValueValidType::IN_RANGE);

    ObIWkbGeogMultiPoint iwkb_geog;
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    append_multi_point(data, pnum, xv, yv, GeogValueValidType::OUT_RANGE);

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_multi_line)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv, GeogValueValidType::IN_RANGE);

    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    append_multi_line(data, lnum, pnum, xv, yv, GeogValueValidType::OUT_RANGE);

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_multi_poly)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 99 inner line, every line has 100 point
    uint32_t polynum = 100;
    uint32_t lnum = 100;
    uint32_t pnum = 100;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(data, lnum, pnum, xv[i], yv[i], GeogValueValidType::IN_RANGE);
    }

    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        if (i < polynum - 1) {
            append_poly(data, lnum, pnum, xv[i], yv[i],  GeogValueValidType::IN_RANGE);
        } else {
            append_poly(data, lnum, pnum, xv[i], yv[i], GeogValueValidType::OUT_RANGE);
        }
    }

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, coordinate_range_visitor_geom_collection)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0], GeogValueValidType::IN_RANGE);
    // line
    append_line(data, 100, xv[1], yv[1], GeogValueValidType::IN_RANGE);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2], GeogValueValidType::IN_RANGE);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3], GeogValueValidType::IN_RANGE);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4], GeogValueValidType::IN_RANGE);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5], GeogValueValidType::IN_RANGE);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoCoordinateRangeVisitor visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(isnan(visitor.value_out_of_range()));

    data.reset();
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    // point
    append_random_point(data, xv[0], yv[0],  GeogValueValidType::IN_RANGE);
    // line
    append_line(data, 100, xv[1], yv[1],  GeogValueValidType::IN_RANGE);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2], GeogValueValidType::IN_RANGE);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3], GeogValueValidType::IN_RANGE);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4], GeogValueValidType::OUT_RANGE);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5],  GeogValueValidType::IN_RANGE);
    }

    visitor.reset();
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(false, visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, wkb_visitor_point)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 90));

    ObGeographPoint p(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit());
    char tmp[1024];
    ObString wkb(1024, 0, tmp);

    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, p.do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    // coordinate range visitor for geograph tree
    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, p.do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    ObGeoWkbSizeVisitor size_visitor;
    ObIWkbGeogLineString iwkb_geog;
    ASSERT_EQ(OB_SUCCESS, p.do_visit(size_visitor));
    ASSERT_EQ(sizeof(uint8_t) + sizeof(uint32_t) + 2* sizeof(double), size_visitor.geo_size());

    // cartesian test
    ObCartesianPoint p_c(181 , 90);
    size_visitor.reset();
    // tree wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, p_c.do_visit(size_visitor));
    ASSERT_EQ(sizeof(uint8_t) + sizeof(uint32_t) + 2* sizeof(double), size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree wkb visitor test
    ASSERT_EQ(OB_SUCCESS, p_c.do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);

    // geograph longtitude correction for tree
    ObGeoLongtitudeCorrectVisitor longti_correction_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, p.do_visit(longti_correction_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, p.do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());
}

TEST_F(TestGeoBin, wkb_visitor_linestring)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObGeoWkbSizeVisitor size_visitor;
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
    uint32_t pnum = 3;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 30));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 40));

    ObIWkbGeogLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(size_visitor));
    uint32_t wkb_size = size_visitor.geo_size();
    size_visitor.reset();

    ObLineString *l = NULL;
    ASSERT_EQ(OB_SUCCESS, ObLineString::create_linestring(ObGeoCRS::Geographic, 0, allocator, l));
    ObGeographLineString *line = static_cast<ObGeographLineString *>(l);
    ASSERT_EQ(ObGeoType::LINESTRING, line->type());
    ASSERT_EQ(1, line->dimension());
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(10 * srs_item->angular_unit(), 20 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(30 * srs_item->angular_unit(), 40 * srs_item->angular_unit())));

    ASSERT_EQ(OB_SUCCESS, line->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    char tmp[1024];
    ObString wkb(1024, 0, tmp);
    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    ObGeoLongtitudeCorrectVisitor long_correct_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(long_correct_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, line->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());

    // cartesian test
    ASSERT_EQ(OB_SUCCESS, ObLineString::create_linestring(ObGeoCRS::Cartesian, 0, allocator, l));
    ObCartesianLineString *carte_line = static_cast<ObCartesianLineString *>(l);
    ASSERT_EQ(ObGeoType::LINESTRING, carte_line->type());
    ASSERT_EQ(1, carte_line->dimension());
    ASSERT_EQ(OB_SUCCESS, carte_line->push_back(ObWkbGeomInnerPoint(181, 90)));
    ASSERT_EQ(OB_SUCCESS, carte_line->push_back(ObWkbGeomInnerPoint(10, 20)));
    ASSERT_EQ(OB_SUCCESS, carte_line->push_back(ObWkbGeomInnerPoint(30, 40)));

    size_visitor.reset();
    // tree cartesian wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, carte_line->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree cartesian wkb visitor test
    ASSERT_EQ(OB_SUCCESS, carte_line->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, wkb_visitor_polygon)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    uint32_t ring_num = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, ring_num));
    for (uint32_t i = 0; i < ring_num; i++) {
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 3));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 30));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 40));
    }

    ObGeoWkbSizeVisitor size_visitor;
    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(size_visitor));
    uint32_t wkb_size = size_visitor.geo_size();

    ObPolygon *l = NULL;
    ASSERT_EQ(OB_SUCCESS, ObPolygon::create_polygon(ObGeoCRS::Geographic, 0, allocator, l));
    ObGeographPolygon *pol = static_cast<ObGeographPolygon *>(l);
    ASSERT_EQ(ObGeoType::POLYGON, pol->type());

    ObGeographLinearring out_ring(0, allocator);
    ASSERT_EQ(OB_SUCCESS, out_ring.push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, out_ring.push_back(ObWkbGeogInnerPoint(10 * srs_item->angular_unit(), 20 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, out_ring.push_back(ObWkbGeogInnerPoint(30 * srs_item->angular_unit(), 40 * srs_item->angular_unit())));
    pol->push_back(out_ring);

    ObGeographLinearring inner_ring(0, allocator);
    ASSERT_EQ(OB_SUCCESS, inner_ring.push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, inner_ring.push_back(ObWkbGeogInnerPoint(10 * srs_item->angular_unit(), 20 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, inner_ring.push_back(ObWkbGeogInnerPoint(30 * srs_item->angular_unit(), 40 * srs_item->angular_unit())));
    pol->push_back(inner_ring);

    char tmp[1024];
    ObString wkb(1024, 0, tmp);
    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, pol->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    size_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, pol->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, pol->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    ObGeoLongtitudeCorrectVisitor long_correct_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, pol->do_visit(long_correct_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, pol->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());

    // cartesian test
    ASSERT_EQ(OB_SUCCESS, ObPolygon::create_polygon(ObGeoCRS::Cartesian, 0, allocator, l));
    ObCartesianPolygon *cartesian_pol = static_cast<ObCartesianPolygon *>(l);
    ASSERT_EQ(ObGeoType::POLYGON, cartesian_pol->type());

    ObCartesianLinearring cart_out_ring(0, allocator);
    ASSERT_EQ(OB_SUCCESS, cart_out_ring.push_back(ObWkbGeomInnerPoint(181, 90)));
    ASSERT_EQ(OB_SUCCESS, cart_out_ring.push_back(ObWkbGeomInnerPoint(10, 20)));
    ASSERT_EQ(OB_SUCCESS, cart_out_ring.push_back(ObWkbGeomInnerPoint(30, 40)));
    cartesian_pol->push_back(cart_out_ring);

    ObCartesianLinearring cart_inner_ring(0, allocator);
    ASSERT_EQ(OB_SUCCESS, cart_inner_ring.push_back(ObWkbGeomInnerPoint(181, 90)));
    ASSERT_EQ(OB_SUCCESS, cart_inner_ring.push_back(ObWkbGeomInnerPoint(10, 20)));
    ASSERT_EQ(OB_SUCCESS, cart_inner_ring.push_back(ObWkbGeomInnerPoint(30, 40)));
    cartesian_pol->push_back(cart_inner_ring);

    size_visitor.reset();
    // tree cartesian wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, cartesian_pol->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree cartesian wkb visitor test
    ASSERT_EQ(OB_SUCCESS, cartesian_pol->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, wkb_visitor_multipoint)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT));
    uint32_t pnum = 3;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 30));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 40));

    ObMultipoint *l = NULL;
    ASSERT_EQ(OB_SUCCESS, ObMultipoint::create_multipoint(ObGeoCRS::Geographic, 0, allocator, l));
    ObGeographMultipoint *line = static_cast<ObGeographMultipoint *>(l);
    ASSERT_EQ(ObGeoType::MULTIPOINT, line->type());
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(10 * srs_item->angular_unit(), 20 * srs_item->angular_unit())));
    ASSERT_EQ(OB_SUCCESS, line->push_back(ObWkbGeogInnerPoint(30 * srs_item->angular_unit(), 40 * srs_item->angular_unit())));

    char tmp[1024];
    ObString wkb(1024, 0, tmp);
    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    ObGeoWkbSizeVisitor size_visitor;
    ObIWkbGeogMultiPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(size_visitor));
    uint32_t wkb_size = size_visitor.geo_size();

    size_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, line->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    // coordinate range visitor for geograph tree
    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    // geograph longtitude correction for tree
    ObGeoLongtitudeCorrectVisitor longti_correction_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, line->do_visit(longti_correction_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, line->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());

    // cartesian test
    ASSERT_EQ(OB_SUCCESS, ObMultipoint::create_multipoint(ObGeoCRS::Cartesian, 0, allocator, l));
    ObCartesianMultipoint *cartesian_multi_point = static_cast<ObCartesianMultipoint *>(l);
    ASSERT_EQ(ObGeoType::MULTIPOINT, cartesian_multi_point->type());

    ASSERT_EQ(OB_SUCCESS, cartesian_multi_point->push_back(ObWkbGeomInnerPoint(181, 90)));
    ASSERT_EQ(OB_SUCCESS, cartesian_multi_point->push_back(ObWkbGeomInnerPoint(10, 20)));
    ASSERT_EQ(OB_SUCCESS, cartesian_multi_point->push_back(ObWkbGeomInnerPoint(30, 40)));

    size_visitor.reset();
    // tree cartesian wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, cartesian_multi_point->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree cartesian wkb visitor test
    ASSERT_EQ(OB_SUCCESS, cartesian_multi_point->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, wkb_visitor_multiline)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRING));
    uint32_t lnum = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));

    uint32_t pnum = 3;
    for (uint32_t i = 0; i < lnum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 180));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 180));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
    }

    ObMultilinestring *mls_ptr = NULL;
    ASSERT_EQ(OB_SUCCESS, ObMultilinestring::create_multilinestring(ObGeoCRS::Geographic, 0, allocator, mls_ptr));
    ObGeographMultilinestring *mls = static_cast<ObGeographMultilinestring *>(mls_ptr);
    ASSERT_EQ(ObGeoType::MULTILINESTRING, mls_ptr->type());

    ObGeographLineString ls(0, allocator);
    ls.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    ls.push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    ls.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    mls->push_back(ls);

    ObGeographLineString ls2(0, allocator);
    ls2.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    ls2.push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    ls2.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
    mls->push_back(ls2);

    char tmp[1024];
    ObString wkb(1024, 0, tmp);
    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, mls->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    ObGeoWkbSizeVisitor size_visitor;
    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(size_visitor));
    uint32_t wkb_size = size_visitor.geo_size();

    size_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, mls->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    // coordinate range visitor for geograph tree
    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, mls->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    // geograph longtitude correction for tree
    ObGeoLongtitudeCorrectVisitor longti_correction_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, mls->do_visit(longti_correction_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, mls->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());

    // cartesian tree test
    ASSERT_EQ(OB_SUCCESS, ObMultilinestring::create_multilinestring(ObGeoCRS::Cartesian, 0, allocator, mls_ptr));
    ObCartesianMultilinestring *cart_mls = static_cast<ObCartesianMultilinestring *>(mls_ptr);
    ASSERT_EQ(ObGeoType::MULTILINESTRING, mls_ptr->type());

    ObCartesianLineString cart_ls(0, allocator);
    cart_ls.push_back(ObWkbGeomInnerPoint(180, 90));
    cart_ls.push_back(ObWkbGeomInnerPoint(181, 90));
    cart_ls.push_back(ObWkbGeomInnerPoint(180, 90));
    cart_mls->push_back(cart_ls);

    ObCartesianLineString cart_ls2(0, allocator);
    cart_ls2.push_back(ObWkbGeomInnerPoint(180, 90));
    cart_ls2.push_back(ObWkbGeomInnerPoint(181, 90));
    cart_ls2.push_back(ObWkbGeomInnerPoint(180, 90));
    cart_mls->push_back(cart_ls2);

    size_visitor.reset();
    // tree cartesian wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, cart_mls->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree cartesian wkb visitor test
    ASSERT_EQ(OB_SUCCESS, cart_mls->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, wkb_visitor_multi_poly)
{
    get_srs_item(allocator_, 4326, srs_item);
    ASSERT_TRUE(srs_item != NULL);

    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t polynum = 2;
    uint32_t lnum = 2;
    uint32_t pnum = 3;

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));
        // push rings
        for (int j = 0; j < lnum; j++) {
            ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
            for (int k = 0; k < pnum; k++) {
                ASSERT_EQ(OB_SUCCESS, append_double(data, 181.0));
                ASSERT_EQ(OB_SUCCESS, append_double(data, 90.0));
            }
        }
    }

    ObMultipolygon *mpy_ptr = NULL;
    ASSERT_EQ(OB_SUCCESS, ObMultipolygon::create_multipolygon(ObGeoCRS::Geographic, 0, allocator, mpy_ptr));
    ObGeographMultipolygon *cartMpy = static_cast<ObGeographMultipolygon *>(mpy_ptr);
    ASSERT_EQ(ObGeoType::MULTIPOLYGON, cartMpy->type());
    ASSERT_EQ(ObGeoCRS::Geographic, cartMpy->crs());
    ASSERT_TRUE(cartMpy->empty());
    ASSERT_TRUE(cartMpy->is_empty());

    ObGeographLinearring inner_ring(0, allocator);
    inner_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));
    inner_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));
    inner_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));

    ObGeographLinearring outer_ring(0, allocator);
    outer_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));
    outer_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));
    outer_ring.push_back(ObWkbGeogInnerPoint(181.0 * srs_item->angular_unit(), 90.0 * srs_item->angular_unit()));

    ObGeographPolygon py(0, allocator);
    py.push_back(outer_ring);
    py.push_back(inner_ring);
    cartMpy->push_back(py);
    cartMpy->push_back(py);
    ASSERT_EQ(2U, cartMpy->size());

    ObGeoWkbSizeVisitor size_visitor;
    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(size_visitor));
    uint32_t wkb_size = size_visitor.geo_size();

    size_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, cartMpy->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    char tmp[1024];
    ObString wkb(1024, 0, tmp);
    ObGeoWkbVisitor visitor(srs_item, &wkb);
    ASSERT_EQ(OB_SUCCESS, cartMpy->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(wkb) == 0);

    // coordinate range visitor for geograph tree
    ObGeoCoordinateRangeVisitor range_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, cartMpy->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
    ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

    // geograph longtitude correction for tree
    ObGeoLongtitudeCorrectVisitor longti_correction_visitor(srs_item);
    ASSERT_EQ(OB_SUCCESS, cartMpy->do_visit(longti_correction_visitor));
    range_visitor.reset();
    ASSERT_EQ(OB_SUCCESS, cartMpy->do_visit(range_visitor));
    ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
    ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());

    // cartesian tree test
    ASSERT_EQ(OB_SUCCESS, ObMultipolygon::create_multipolygon(ObGeoCRS::Cartesian, 0, allocator, mpy_ptr));
    ObCartesianMultipolygon *cart_Mpy = static_cast<ObCartesianMultipolygon *>(mpy_ptr);
    ASSERT_EQ(ObGeoType::MULTIPOLYGON, cart_Mpy->type());
    ASSERT_EQ(ObGeoCRS::Cartesian, cart_Mpy->crs());
    ASSERT_TRUE(cart_Mpy->empty());
    ASSERT_TRUE(cart_Mpy->is_empty());

    ObCartesianLinearring cart_inner_ring(0, allocator);
    cart_inner_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));
    cart_inner_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));
    cart_inner_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));

    ObCartesianLinearring cart_outer_ring(0, allocator);
    cart_outer_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));
    cart_outer_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));
    cart_outer_ring.push_back(ObWkbGeomInnerPoint(181.0, 90.0));

    ObCartesianPolygon cart_py(0, allocator);
    cart_py.push_back(cart_outer_ring);
    cart_py.push_back(cart_inner_ring);
    cart_Mpy->push_back(cart_py);
    cart_Mpy->push_back(cart_py);
    ASSERT_EQ(2U, cart_Mpy->size());

    size_visitor.reset();
    // tree cartesian wkb size visitor test
    ASSERT_EQ(OB_SUCCESS, cart_Mpy->do_visit(size_visitor));
    ASSERT_EQ(wkb_size, size_visitor.geo_size());

    ObString cart_wkb(1024, 0, tmp);
    visitor.set_wkb_buffer(&cart_wkb);
    visitor.set_srs(mock_projected_srs_item);
    // tree cartesian wkb visitor test
    ASSERT_EQ(OB_SUCCESS, cart_Mpy->do_visit(visitor));
    ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, visitor_Geometrycollection)
{
  get_srs_item(allocator_, 4326, srs_item);
  ASSERT_TRUE(srs_item != NULL);

  ObArenaAllocator allocator(ObModIds::TEST);
  ObJsonBuffer data(&allocator);

  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 6));

  // point
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
  append_double(data, 10.0);
  append_double(data, 0.0);
  // line
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 3));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 180));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 180));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
  // polygon
  uint32_t lnum = 1;
  uint32_t pnum = 2;
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));
  for (int j = 0; j < lnum; j++) {
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
    for (int k = 0; k < pnum; k++) {
      ASSERT_EQ(OB_SUCCESS, append_double(data, 55.0));
      ASSERT_EQ(OB_SUCCESS, append_double(data, 66.0));
    }
  }

  // multipoint
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1));
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 0.0));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 0.0));
  // multiline
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRING));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1));
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 1.0));
  ASSERT_EQ(OB_SUCCESS, append_double(data, 1.0));

  // empty geometry
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

  ObGeoWkbSizeVisitor size_visitor;
  ObIWkbGeogCollection iwkb_gc;
  iwkb_gc.set_data(data.string());
  ASSERT_EQ(OB_SUCCESS, iwkb_gc.do_visit(size_visitor));
  uint32_t wkb_size = size_visitor.geo_size();

  ObGeometrycollection* gc = NULL;
  ASSERT_EQ(OB_SUCCESS, ObGeometrycollection::create_collection(ObGeoCRS::Geographic, 0, allocator, gc));

  ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, gc->type());
  ASSERT_EQ(ObGeoCRS::Geographic, gc->crs());

  ObGeographGeometrycollection *GeographGc = static_cast<ObGeographGeometrycollection *>(gc);
  // point
  GeographGc->push_back(ObGeographPoint(10.0 * srs_item->angular_unit(), 0.0 * srs_item->angular_unit(), 0));
  // lineString
  ObGeographLineString ls(0, allocator);
  ls.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit() ));
  ls.push_back(ObWkbGeogInnerPoint(180 * srs_item->angular_unit(), 90 * srs_item->angular_unit()));
  ls.push_back(ObWkbGeogInnerPoint(10 * srs_item->angular_unit(), 10 * srs_item->angular_unit()));
  GeographGc->push_back(ls);
  // polygon
  ObGeographLinearring outer_ring(0, allocator);
  outer_ring.push_back(ObWkbGeogInnerPoint(55.0 * srs_item->angular_unit(), 66.0 * srs_item->angular_unit()));
  outer_ring.push_back(ObWkbGeogInnerPoint(55.0 * srs_item->angular_unit(), 66.0 * srs_item->angular_unit()));
  ObGeographPolygon py(0, allocator);
  py.push_back(outer_ring);
  GeographGc->push_back(py);

  // multi point
  ObGeographMultipoint mpt(0, allocator);
  mpt.push_back(ObWkbGeogInnerPoint(0.0 * srs_item->angular_unit() , 0.0 * srs_item->angular_unit()));
  GeographGc->push_back(mpt);

  // multi line
  ObGeographLineString ls2(0, allocator);
  ls2.push_back(ObWkbGeogInnerPoint(181 * srs_item->angular_unit() , 90 * srs_item->angular_unit()));
  ls2.push_back(ObWkbGeogInnerPoint(1.0 * srs_item->angular_unit() , 1.0 * srs_item->angular_unit()));
  ObGeographMultilinestring mls;
  mls.push_back(ls2);
  GeographGc->push_back(mls);

  // empty gc
  ObGeographGeometrycollection inner_gc(0, allocator);
  GeographGc->push_back(inner_gc);

  size_visitor.reset();
  ASSERT_EQ(OB_SUCCESS, GeographGc->do_visit(size_visitor));
  ASSERT_EQ(wkb_size, size_visitor.geo_size());

  char tmp[1024];
  ObString wkb(1024, 0, tmp);
  ObGeoWkbVisitor visitor(srs_item, &wkb);
  ASSERT_EQ(OB_SUCCESS, GeographGc->do_visit(visitor));
  ASSERT_TRUE(data.string().compare(wkb) == 0);

  // coordinate range visitor for geograph tree
  ObGeoCoordinateRangeVisitor range_visitor(srs_item);
  ASSERT_EQ(OB_SUCCESS, GeographGc->do_visit(range_visitor));
  ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
  ASSERT_EQ(true, range_visitor.is_longtitude_out_of_range());
  ASSERT_TRUE(std::abs(range_visitor.value_out_of_range() - 181) < 0.001);

  // geograph longtitude correction for tree
  ObGeoLongtitudeCorrectVisitor longti_correction_visitor(srs_item);
  ASSERT_EQ(OB_SUCCESS, GeographGc->do_visit(longti_correction_visitor));
  range_visitor.reset();
  ASSERT_EQ(OB_SUCCESS, GeographGc->do_visit(range_visitor));
  ASSERT_EQ(false, range_visitor.is_latitude_out_of_range());
  ASSERT_EQ(false, range_visitor.is_longtitude_out_of_range());
  // cartesian test
  ASSERT_EQ(OB_SUCCESS, ObGeometrycollection::create_collection(ObGeoCRS::Cartesian, 0, allocator, gc));

  ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, gc->type());
  ASSERT_EQ(ObGeoCRS::Cartesian, gc->crs());

  ObCartesianGeometrycollection *CartesianGc = static_cast<ObCartesianGeometrycollection *>(gc);
  // point
  CartesianGc->push_back(ObCartesianPoint(10.0, 0.0, 0));
  // lineString
  ObCartesianLineString cart_ls(0, allocator);
  cart_ls.push_back(ObWkbGeomInnerPoint(180, 90 ));
  cart_ls.push_back(ObWkbGeomInnerPoint(180, 90));
  cart_ls.push_back(ObWkbGeomInnerPoint(10, 10));
  CartesianGc->push_back(cart_ls);
  // polygon
  ObCartesianLinearring cart_outer_ring(0, allocator);
  cart_outer_ring.push_back(ObWkbGeomInnerPoint(55.0, 66.0));
  cart_outer_ring.push_back(ObWkbGeomInnerPoint(55.0, 66.0));
  ObCartesianPolygon cart_py(0, allocator);
  cart_py.push_back(cart_outer_ring);
  CartesianGc->push_back(cart_py);

  // multi point
  ObCartesianMultipoint cart_mpt(0, allocator);
  cart_mpt.push_back(ObWkbGeomInnerPoint(0.0 , 0.0));
  CartesianGc->push_back(cart_mpt);

  // multi line
  ObCartesianLineString cart_ls2(0, allocator);
  cart_ls2.push_back(ObWkbGeomInnerPoint(181 , 90));
  cart_ls2.push_back(ObWkbGeomInnerPoint(1.0 , 1.0));
  ObCartesianMultilinestring cart_mls;
  cart_mls.push_back(cart_ls2);
  CartesianGc->push_back(cart_mls);

  // empty gc
  ObCartesianGeometrycollection cart_inner_gc(0, allocator);
  CartesianGc->push_back(cart_inner_gc);

  size_visitor.reset();
  // tree cartesian wkb size visitor test
  ASSERT_EQ(OB_SUCCESS, CartesianGc->do_visit(size_visitor));
  ASSERT_EQ(wkb_size, size_visitor.geo_size());

  ObString cart_wkb(1024, 0, tmp);
  visitor.set_wkb_buffer(&cart_wkb);
  visitor.set_srs(mock_projected_srs_item);
  // tree cartesian wkb visitor test
  ASSERT_EQ(OB_SUCCESS, CartesianGc->do_visit(visitor));
  ASSERT_TRUE(data.string().compare(cart_wkb) == 0);
}

TEST_F(TestGeoBin, wkb_invalid_visitor)
{
  get_srs_item(allocator_, 4326, srs_item);
  ASSERT_TRUE(srs_item != NULL);

  ObArenaAllocator allocator(ObModIds::TEST);
  ObJsonBuffer data(&allocator);
  // 1 exterior line 100 inner line, every line has 100 point
  uint32_t pnum = 100;
  uint32_t lnum = 10000;
  common::ObVector<double> xv;
  common::ObVector<double> yv;
  append_multi_line(data, lnum, pnum, xv, yv);

  ObIWkbGeogMultiLineString iwkb_geog;
  iwkb_geog.set_data(data.string());

  char tmp[1024];
  ObString wkb(1024, 0, tmp);
  ObGeoWkbVisitor visitor(srs_item, &wkb);
  ASSERT_EQ(OB_BUF_NOT_ENOUGH, iwkb_geog.do_visit(visitor));
}

TEST_F(TestGeoBin, longti_correct_invalid_visitor)
{
  get_srs_item(allocator_, 4326, srs_item);
  ASSERT_TRUE(srs_item != NULL);

  ObArenaAllocator allocator(ObModIds::TEST);
  ObJsonBuffer data(&allocator);

  uint32_t polynum = 100;
  uint32_t lnum = 100;
  uint32_t pnum = 100;
  common::ObVector<double> xv[polynum];
  common::ObVector<double> yv[polynum];
  ASSERT_EQ(OB_SUCCESS, append_bo(data));
  ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
  ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
  for (int i = 0; i < polynum; i++) {
    append_poly(data, lnum, pnum, xv[i], yv[i]);
  }

  ObIWkbGeomMultiPolygon iwkb_geom;
  iwkb_geom.set_data(data.string());

  ObGeoLongtitudeCorrectVisitor correct_visitor(srs_item);
  // not support wkb geo convert to wkb
  ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(correct_visitor));
}

TEST_F(TestGeoBin, to_tree_visitor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 1.323));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 999.5456));
    ObIWkbGeomPoint p;
    p.set_data(data.string());

    ObGeoToTreeVisitor cart_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, p.do_visit(cart_visitor));
    const ObCartesianPoint *point = static_cast<const ObCartesianPoint *>(cart_visitor.get_geometry());
    ASSERT_EQ(point->x(), 1.323);
    ASSERT_EQ(point->y(), 999.5456);

    ObIWkbGeogPoint p1;
    p1.set_data(data.string());
    ObGeoToTreeVisitor geog_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, p1.do_visit(geog_visitor));
    const ObGeographPoint *point1 = static_cast<const ObGeographPoint *>(geog_visitor.get_geometry());
    ASSERT_EQ(point1->x(), 1.323);
    ASSERT_EQ(point1->y(), 999.5456);
}

TEST_F(TestGeoBin, to_tree_visitor_linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_line(data, num, xv, yv);

    ObWkbGeogLineString& line = *reinterpret_cast<ObWkbGeogLineString*>(data.ptr());
    ObWkbGeogLineString::iterator iter = line.begin();

    ObIWkbGeogLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor geog_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(geog_visitor));
    const ObGeographLineString *line_tree = static_cast<const ObGeographLineString *>(geog_visitor.get_geometry());
    ASSERT_EQ(num, line_tree->size());
    for (int i = 0; iter != line.end(); ++iter, i++) {
        ASSERT_EQ((*line_tree)[i].get<0>(), iter->get<0>());
        ASSERT_EQ((*line_tree)[i].get<1>(), iter->get<1>());
    }

    ObIWkbGeomLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoToTreeVisitor geom_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(geom_visitor));
    const ObCartesianLineString *cart_line_tree = static_cast<const ObCartesianLineString *>(geom_visitor.get_geometry());
    ASSERT_EQ(num, cart_line_tree->size());
    for (int i = 0; iter != line.end(); ++iter, i++) {
        ASSERT_EQ((*cart_line_tree)[i].get<0>(), iter->get<0>());
        ASSERT_EQ((*cart_line_tree)[i].get<1>(), iter->get<1>());
    }
}

template<typename T>
void check_tree_lines(T& line, uint32_t& pc, common::ObVector<double>& xv, common::ObVector<double>& yv)
{
    for (uint32_t i = 0; i < line.size(); i++) {
        ASSERT_EQ(xv[pc], line[i].template get<0>());
        ASSERT_EQ(yv[pc], line[i].template get<1>());
        pc++;
    }
}

TEST_F(TestGeoBin, to_tree_visitor_multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv);

    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor geog_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(geog_visitor));
    ObGeographMultilinestring *geog_multiline = static_cast<ObGeographMultilinestring *>(geog_visitor.get_geometry());
    ASSERT_EQ(lnum, geog_multiline->size());
    uint32_t index = 0;
    for (uint32_t i = 0; i < lnum; i++) {
        ObGeographLineString& line = (*geog_multiline)[i];
        ASSERT_EQ(line.size(), pnum);
        check_tree_lines(line, index, xv, yv);
    }

    ObIWkbGeomMultiLineString iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoToTreeVisitor geom_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(geom_visitor));
    ObCartesianMultilinestring *geom_multiline = static_cast<ObCartesianMultilinestring *>(geom_visitor.get_geometry());
    ASSERT_EQ(lnum, geom_multiline->size());
    index = 0;
    for (uint32_t i = 0; i < lnum; i++) {
        ObCartesianLineString& line = (*geom_multiline)[i];
        ASSERT_EQ(line.size(), pnum);
        check_tree_lines(line, index, xv, yv);
    }
}

TEST_F(TestGeoBin, to_tree_visitor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_poly(data, lnum, pnum, xv, yv);

    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor geog_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(geog_visitor));
    ObGeographPolygon *geog_polygon = static_cast<ObGeographPolygon *>(geog_visitor.get_geometry());
    ASSERT_EQ(lnum, geog_polygon->size());
    ObGeographLinearring& ext = geog_polygon->exterior_ring();
    uint32_t index = 0;
    ASSERT_EQ(ext.size(), pnum);
    check_tree_lines(ext, index, xv, yv);
    for (uint32_t i = 0; i < lnum - 1; i++) {
        ObGeographLinearring& inner = geog_polygon->inner_ring(i);
        ASSERT_EQ(inner.size(), pnum);
        check_tree_lines(inner, index, xv, yv);
    }

    ObIWkbGeomPolygon iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoToTreeVisitor geom_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(geom_visitor));
    ObCartesianPolygon *geom_polygon = static_cast<ObCartesianPolygon *>(geom_visitor.get_geometry());
    ASSERT_EQ(lnum, geom_polygon->size());
    ObCartesianLinearring& cart_ext = geom_polygon->exterior_ring();
    index = 0;
    ASSERT_EQ(cart_ext.size(), pnum);
    check_tree_lines(cart_ext, index, xv, yv);
    for (uint32_t i = 0; i < lnum - 1; i++) {
        ObCartesianLinearring& inner = geom_polygon->inner_ring(i);
        ASSERT_EQ(inner.size(), pnum);
        check_tree_lines(inner, index, xv, yv);
    }
}

TEST_F(TestGeoBin, to_tree_visitor_multipoint)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT));
    uint32_t pnum = 3;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 30));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 40));

    ObIWkbGeogMultiPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ObGeographMultipoint *multi_point = static_cast<ObGeographMultipoint *>(visitor.get_geometry());
    ASSERT_EQ(3, multi_point->size());

    const ObWkbGeogInnerPoint &point1 =  (*multi_point)[0];
    ASSERT_EQ(181, point1.get<0>());
    ASSERT_EQ(90, point1.get<1>());
    const ObWkbGeogInnerPoint &point2 =  (*multi_point)[1];
    ASSERT_EQ(10, point2.get<0>());
    ASSERT_EQ(20, point2.get<1>());
    const ObWkbGeogInnerPoint &point3 =  (*multi_point)[2];
    ASSERT_EQ(30, point3.get<0>());
    ASSERT_EQ(40, point3.get<1>());
}

TEST_F(TestGeoBin, to_tree_visitor_multi_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t polynum = 2;
    uint32_t lnum = 2;
    uint32_t pnum = 3;

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, polynum));
    for (int i = 0; i < polynum; i++) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));
        // push rings
        for (int j = 0; j < lnum; j++) {
            ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
            for (int k = 0; k < pnum; k++) {
                ASSERT_EQ(OB_SUCCESS, append_double(data, 181.0));
                ASSERT_EQ(OB_SUCCESS, append_double(data, 90.0));
            }
        }
    }

    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ObGeographMultipolygon *multi_polygon = static_cast<ObGeographMultipolygon *>(visitor.get_geometry());
    ASSERT_EQ(2, multi_polygon->size());

    for (uint32_t i = 0; i < multi_polygon->size(); i++) {
      ObGeographPolygon &pol = (*multi_polygon)[i];
      ASSERT_EQ(lnum, pol.size());
      ObGeographLinearring &ext = pol.exterior_ring();
      for (uint32_t j = 0; j < pnum; j++) {
        const ObWkbGeogInnerPoint &point =  ext[j];
        ASSERT_EQ(181.0, point.get<0>());
        ASSERT_EQ(90.0, point.get<1>());
      }
      ObGeographLinearring &inner = pol.inner_ring(0);
      for (uint32_t j = 0; j < pnum; j++) {
        const ObWkbGeogInnerPoint &point =  inner[j];
        ASSERT_EQ(181.0, point.get<0>());
        ASSERT_EQ(90.0, point.get<1>());
      }
    }

    ObIWkbGeogMultiPolygon iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoToTreeVisitor geom_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(geom_visitor));
    ObCartesianMultipolygon *cart_multi_polygon = static_cast<ObCartesianMultipolygon *>(geom_visitor.get_geometry());
    ASSERT_EQ(2, cart_multi_polygon->size());

    for (uint32_t i = 0; i < cart_multi_polygon->size(); i++) {
      ObCartesianPolygon &pol = (*cart_multi_polygon)[i];
      ASSERT_EQ(lnum, pol.size());
      ObCartesianLinearring &ext = pol.exterior_ring();
      for (uint32_t j = 0; j < pnum; j++) {
        const ObWkbGeomInnerPoint &point =  ext[j];
        ASSERT_EQ(181.0, point.get<0>());
        ASSERT_EQ(90.0, point.get<1>());
      }
      ObCartesianLinearring &inner = pol.inner_ring(0);
      for (uint32_t j = 0; j < pnum; j++) {
        const ObWkbGeomInnerPoint &point =  inner[j];
        ASSERT_EQ(181.0, point.get<0>());
        ASSERT_EQ(90.0, point.get<1>());
      }
    }

}

TEST_F(TestGeoBin, to_tree_visitor_geom_collection)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 100, xv[1], yv[1]);
    // polygon
    append_poly(data, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObGeoToTreeVisitor visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ObGeographGeometrycollection *geog_coll = static_cast<ObGeographGeometrycollection *>(visitor.get_geometry());
    ASSERT_EQ(7, geog_coll->size());
    ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, geog_coll->type());

    ASSERT_EQ(ObGeoType::POINT, (*geog_coll)[0].type());
    {
        ObGeographPoint &point = static_cast<ObGeographPoint &>((*geog_coll)[0]);
        ASSERT_EQ(xv[0][0], point.x());
        ASSERT_EQ(yv[0][0], point.y());
    }
    ASSERT_EQ(ObGeoType::LINESTRING, (*geog_coll)[1].type());
    {
        ObGeographLineString &line = static_cast<ObGeographLineString &>((*geog_coll)[1]);
        ASSERT_EQ(100, line.size());
        uint32_t index = 0;
        check_tree_lines(line, index, xv[1], yv[1]);
    }
    ASSERT_EQ(ObGeoType::POLYGON, (*geog_coll)[2].type());
    {
        ObGeographPolygon &polygon = static_cast<ObGeographPolygon &>((*geog_coll)[2]);
        auto &exter_ring = polygon.exterior_ring();
        uint32_t index = 0;
        check_tree_lines(exter_ring, index, xv[2], yv[2]);
        uint32_t ring_num = polygon.size();
        ASSERT_EQ(100, ring_num);
        for (uint32_t i = 0; i < ring_num - 1; i++) {
            auto& inner = polygon.inner_ring(i);
            ASSERT_EQ(inner.size(), 100);
            check_tree_lines(inner, index, xv[2], yv[2]);
        }
    }
    ASSERT_EQ(ObGeoType::MULTIPOINT, (*geog_coll)[3].type());
    {
        ObGeographMultipoint &multi_point = static_cast<ObGeographMultipoint &>((*geog_coll)[3]);
        ASSERT_EQ(100, multi_point.size());
        uint32_t index = 0;
        check_tree_lines(multi_point, index, xv[3], yv[3]);
    }
    ASSERT_EQ(ObGeoType::MULTILINESTRING, (*geog_coll)[4].type());
    {
        ObGeographMultilinestring &multi_line = static_cast<ObGeographMultilinestring &>((*geog_coll)[4]);
        ASSERT_EQ(1000, multi_line.size());
        uint32_t index = 0;
        for (uint32_t i = 0; i < multi_line.size(); i++) {
            check_tree_lines(multi_line[i], index, xv[4], yv[4]);
        }
    }
    ASSERT_EQ(ObGeoType::MULTIPOLYGON, (*geog_coll)[5].type());
    {
        ObGeographMultipolygon &multi_polygon = static_cast<ObGeographMultipolygon &>((*geog_coll)[5]);
        ASSERT_EQ(10, multi_polygon.size());
        uint32_t index = 0;
        for (uint32_t i = 0; i < multi_polygon.size(); i++) {
            auto &exter_ring = multi_polygon[i].exterior_ring();
            check_tree_lines(exter_ring, index, xv[5], yv[5]);
            uint32_t ring_num = multi_polygon[i].size();
            ASSERT_EQ(10, ring_num);
            for (uint32_t j = 0; j < ring_num - 1; j++) {
                auto& inner = multi_polygon[i].inner_ring(j);
                ASSERT_EQ(inner.size(), 100);
                check_tree_lines(inner, index, xv[5], yv[5]);
            }
        }
    }
    ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, (*geog_coll)[6].type());
    {
        ObGeographGeometrycollection &collection = static_cast<ObGeographGeometrycollection &>((*geog_coll)[6]);
        ASSERT_EQ(0, collection.size());
    }


    ObIWkbGeomCollection iwkb_geom;
    iwkb_geom.set_data(data.string());
    ObGeoToTreeVisitor cart_visitor(&allocator);
    ASSERT_EQ(OB_SUCCESS, iwkb_geom.do_visit(cart_visitor));
    ObCartesianGeometrycollection *geom_coll = static_cast<ObCartesianGeometrycollection *>(cart_visitor.get_geometry());
    ASSERT_EQ(7, geom_coll->size());
    ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, geom_coll->type());

    ASSERT_EQ(ObGeoType::POINT, (*geom_coll)[0].type());
    {
        ObCartesianPoint &point = static_cast<ObCartesianPoint &>((*geom_coll)[0]);
        ASSERT_EQ(xv[0][0], point.x());
        ASSERT_EQ(yv[0][0], point.y());
    }
    ASSERT_EQ(ObGeoType::LINESTRING, (*geom_coll)[1].type());
    {
        ObCartesianLineString &line = static_cast<ObCartesianLineString &>((*geom_coll)[1]);
        ASSERT_EQ(100, line.size());
        uint32_t index = 0;
        check_tree_lines(line, index, xv[1], yv[1]);
    }
    ASSERT_EQ(ObGeoType::POLYGON, (*geom_coll)[2].type());
    {
        ObCartesianPolygon &polygon = static_cast<ObCartesianPolygon &>((*geom_coll)[2]);
        auto &exter_ring = polygon.exterior_ring();
        uint32_t index = 0;
        check_tree_lines(exter_ring, index, xv[2], yv[2]);
        uint32_t ring_num = polygon.size();
        ASSERT_EQ(100, ring_num);
        for (uint32_t i = 0; i < ring_num - 1; i++) {
            auto& inner = polygon.inner_ring(i);
            ASSERT_EQ(inner.size(), 100);
            check_tree_lines(inner, index, xv[2], yv[2]);
        }
    }
    ASSERT_EQ(ObGeoType::MULTIPOINT, (*geom_coll)[3].type());
    {
        ObCartesianMultipoint &multi_point = static_cast<ObCartesianMultipoint &>((*geom_coll)[3]);
        ASSERT_EQ(100, multi_point.size());
        uint32_t index = 0;
        check_tree_lines(multi_point, index, xv[3], yv[3]);
    }
    ASSERT_EQ(ObGeoType::MULTILINESTRING, (*geom_coll)[4].type());
    {
        ObCartesianMultilinestring &multi_line = static_cast<ObCartesianMultilinestring &>((*geom_coll)[4]);
        ASSERT_EQ(1000, multi_line.size());
        uint32_t index = 0;
        for (uint32_t i = 0; i < multi_line.size(); i++) {
            check_tree_lines(multi_line[i], index, xv[4], yv[4]);
        }
    }
    ASSERT_EQ(ObGeoType::MULTIPOLYGON, (*geom_coll)[5].type());
    {
        ObCartesianMultipolygon &multi_polygon = static_cast<ObCartesianMultipolygon &>((*geom_coll)[5]);
        ASSERT_EQ(10, multi_polygon.size());
        uint32_t index = 0;
        for (uint32_t i = 0; i < multi_polygon.size(); i++) {
            auto &exter_ring = multi_polygon[i].exterior_ring();
            check_tree_lines(exter_ring, index, xv[5], yv[5]);
            uint32_t ring_num = multi_polygon[i].size();
            ASSERT_EQ(10, ring_num);
            for (uint32_t j = 0; j < ring_num - 1; j++) {
                auto& inner = multi_polygon[i].inner_ring(j);
                ASSERT_EQ(inner.size(), 100);
                check_tree_lines(inner, index, xv[5], yv[5]);
            }
        }
    }
    ASSERT_EQ(ObGeoType::GEOMETRYCOLLECTION, (*geom_coll)[6].type());
    {
        ObCartesianGeometrycollection &collection = static_cast<ObCartesianGeometrycollection &>((*geom_coll)[6]);
        ASSERT_EQ(0, collection.size());
    }


}

TEST_F(TestGeoBin, reverse_coordinate_visitor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ObGeoReverseCoordinateVisitor visitor;

    double x_val = 179.8;
    double y_val = 89.2;
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT));
    ASSERT_EQ(OB_SUCCESS, append_double(data, x_val));
    ASSERT_EQ(OB_SUCCESS, append_double(data, y_val));

    // wkb geographical point
    ObIWkbGeogPoint iwkb_geog;
    iwkb_geog.set_data(data.string());
    ASSERT_EQ(iwkb_geog.x(), x_val);
    ASSERT_EQ(iwkb_geog.y(), y_val);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(iwkb_geog.x(), y_val);
    ASSERT_EQ(iwkb_geog.y(), x_val);

    // wkb cartesian point
    ObIWkbGeomPoint iwkb_geom;
    iwkb_geom.set_data(data.string());
    ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(visitor));

    // tree geographical point
    ObGeographPoint t_geog(x_val, y_val);
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geog.do_visit(visitor));

    // tree cartesian point
    ObCartesianPoint t_geom(x_val, y_val);
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geom.do_visit(visitor));
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_linestring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);
    uint32_t num = 100;
    common::ObVector<double> xv;
    common::ObVector<double> yv;

    append_line(buffer, num, xv, yv);
    ObString data = buffer.string();
    ObWkbGeogLineString& line = *reinterpret_cast<ObWkbGeogLineString*>(data.ptr());

    // wkb geographical linestring
    ObIWkbGeogLineString iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));

    ObWkbGeogLineString::iterator line_iter = line.begin();
    ObWkbGeogLineString::iterator line_end = line.end();
    ASSERT_EQ(line.size(), num);
    for (int i = 0; line_iter != line_end; ++line_iter, ++i) {
        ASSERT_EQ(line_iter->get<0>(), yv[i]);
        ASSERT_EQ(line_iter->get<1>(), xv[i]);
    }

    // wkb cartesian linestring
    ObIWkbGeomLineString iwkb_geom;
    iwkb_geom.set_data(data);
    ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(visitor));

    // tree geographical linestring
    ObGeographLineString t_geog;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geog.do_visit(visitor));

    // tree cartesian linestring
    ObCartesianLineString t_geom;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geom.do_visit(visitor));
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);
    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_poly(buffer, lnum, pnum, xv, yv);
    ObString data = buffer.string();

    // wkb geographical polygon
    ObWkbGeogPolygon& poly = *reinterpret_cast<ObWkbGeogPolygon*>(data.ptr());
    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(lnum, poly.size());
    ObWkbGeogLinearRing& ext = poly.exterior_ring();
    uint32_t index = 0;
    ASSERT_EQ(ext.size(), pnum);
    check_lines(ext, index, yv, xv);
    ObWkbGeogPolygonInnerRings::iterator iring_iter = poly.inner_rings().begin();
    ObWkbGeogPolygonInnerRings::iterator iring_end = poly.inner_rings().end();
    for (; iring_iter != iring_end; ++iring_iter) {
        ASSERT_EQ(iring_iter->size(), pnum);
        check_lines(*iring_iter, index, yv, xv);
    }

    // wkb cartesian polygon
    ObIWkbGeomPolygon iwkb_geom;
    iwkb_geom.set_data(data);
    ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(visitor));

    // tree geographical polygon
    ObGeographPolygon t_geog;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geog.do_visit(visitor));

    // tree cartesian polygon
    ObCartesianPolygon t_geom;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geom.do_visit(visitor));
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_multi_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);
    uint32_t num = 100;
    common::ObVector<double> xv;
    common::ObVector<double> yv;

    append_multi_point(buffer, num, xv, yv);
    ObString data = buffer.string();
    ObWkbGeogMultiPoint& mpt = *reinterpret_cast<ObWkbGeogMultiPoint*>(data.ptr());

    // wkb geographical linestring
    ObIWkbGeogMultiPoint iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));

    ObWkbGeogMultiPoint::iterator mpt_iter = mpt.begin();
    ObWkbGeogMultiPoint::iterator mpt_end = mpt.begin();
    ASSERT_EQ(mpt.size(), num);
    for (int i = 0; mpt_iter != mpt_end; ++mpt_iter, ++i) {
        ASSERT_EQ(mpt_iter->get<0>(), yv[i]);
        ASSERT_EQ(mpt_iter->get<1>(), xv[i]);
    }

    // wkb cartesian linestring
    ObIWkbGeomMultiPoint iwkb_geom;
    iwkb_geom.set_data(data);
    ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(visitor));

    // tree geographical linestring
    ObGeographMultipoint t_geog;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geog.do_visit(visitor));

    // tree cartesian linestring
    ObCartesianMultipoint t_geom;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geom.do_visit(visitor));
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_multi_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);

    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(buffer, lnum, pnum, xv, yv);

    ObString data = buffer.string();
    ObWkbGeogMultiLineString& mline = *reinterpret_cast<ObWkbGeogMultiLineString*>(data.ptr());
    ObIWkbGeogMultiLineString iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(lnum, mline.size());

    ObWkbGeogMultiLineString::iterator mline_iter = mline.begin();
    ObWkbGeogMultiLineString::iterator mline_end = mline.begin();
    uint32_t index = 0;
    for (; mline_iter != mline_end; ++mline_iter) {
        ASSERT_EQ(mline_iter->size(), pnum);
        check_lines(*mline_iter, index, yv, xv);
    }
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_multi_polygon)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);
    uint32_t polynum = 100;
    uint32_t lnum = 100;
    uint32_t pnum = 100;
    common::ObVector<double> xv[polynum];
    common::ObVector<double> yv[polynum];
    ASSERT_EQ(OB_SUCCESS, append_bo(buffer));
    ASSERT_EQ(OB_SUCCESS, append_type(buffer, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(buffer, polynum));
    for (int i = 0; i < polynum; i++) {
        append_poly(buffer, lnum, pnum, xv[i], yv[i]);
    }

    ObString data = buffer.string();
    ObWkbGeogMultiPolygon& mp = *reinterpret_cast<ObWkbGeogMultiPolygon*>(data.ptr());
    ObIWkbGeogMultiPolygon iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(polynum, mp.size());
    ObWkbGeogMultiPolygon::iterator iter = mp.begin();
    for (int i = 0; iter != mp.end(); ++iter, i++) {
        ASSERT_EQ(lnum, iter->size());
        uint32_t pc = 0;
        auto &ext_ring = iter->exterior_ring();
        ASSERT_EQ(pnum, ext_ring.size());
        check_lines(ext_ring, pc, yv[i], xv[i]);
        auto& inner_rings = iter->inner_rings();
        ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
        for (; riter != inner_rings.end(); riter++) {
            ASSERT_EQ(pnum, riter->size());
            check_lines(*riter, pc, yv[i], xv[i]);
        }
    }

    // wkb cartesian polygon
    ObIWkbGeomMultiPolygon iwkb_geom;
    iwkb_geom.set_data(data);
    ASSERT_EQ(OB_INVALID_ARGUMENT, iwkb_geom.do_visit(visitor));

    // tree geographical polygon
    ObGeographMultipolygon t_geog;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geog.do_visit(visitor));

    // tree cartesian polygon
    ObCartesianMultipolygon t_geom;
    ASSERT_EQ(OB_INVALID_ARGUMENT, t_geom.do_visit(visitor));
}

TEST_F(TestGeoBin, reverse_coordinate_visitor_gc)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer buffer(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(buffer));
    ASSERT_EQ(OB_SUCCESS, append_type(buffer, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(buffer, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(buffer, xv[0], yv[0]);
    // line
    append_line(buffer, 100, xv[1], yv[1]);
    // polygon
    append_poly(buffer, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(buffer, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(buffer, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(buffer));
    ASSERT_EQ(OB_SUCCESS, append_type(buffer, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(buffer, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(buffer, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(buffer));
    ASSERT_EQ(OB_SUCCESS, append_type(buffer, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(buffer, 0));

    ObString data = buffer.string();
    ObWkbGeogCollection &gc = *reinterpret_cast<ObWkbGeogCollection*>(data.ptr());
    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data);
    ObGeoReverseCoordinateVisitor visitor;
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(visitor));
    ASSERT_EQ(7, gc.size());

    ObWkbGeogCollection::iterator iter = gc.begin();
    for (int i = 0; iter != gc.end(); ++iter, ++i) {
        typename ObWkbGeogCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = gc.get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeogPoint* point = reinterpret_cast<const ObWkbGeogPoint*>(sub_ptr);
            ASSERT_EQ(yv[0][0], point->get<0>());
            ASSERT_EQ(xv[0][0], point->get<1>());
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeogLineString* line = reinterpret_cast<const ObWkbGeogLineString*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, line->size());
            check_lines(*line, pc, yv[1], xv[1]);
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeogPolygon* poly = reinterpret_cast<const ObWkbGeogPolygon*>(sub_ptr);
            uint32_t pc = 0;
            check_lines(poly->exterior_ring(), pc, yv[2], xv[2]);
            auto& inner_rings = poly->inner_rings();
            ASSERT_EQ(99, inner_rings.size());
            ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
            for (; riter != inner_rings.end(); riter++) {
                check_lines(*riter, pc, yv[2], xv[2]);
            }
            --riter;
            pc -= 100;
            for (; riter >= inner_rings.begin(); riter--, pc -= 100) {
                uint32_t tpc = pc;
                check_lines(*riter, tpc, yv[2], xv[2]);
            }
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeogMultiPoint* mp = reinterpret_cast<const ObWkbGeogMultiPoint*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(100, mp->size());
            check_lines(*mp, pc, yv[3], xv[3]);
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeogMultiLineString* ml = reinterpret_cast<const ObWkbGeogMultiLineString*>(sub_ptr);
            ASSERT_EQ(1000, ml->size());
            uint32_t pc = 0;
            ObWkbGeogMultiLineString::iterator liter = ml->begin();
            for (; liter != ml->end(); liter++) {
                check_lines(*liter, pc, yv[4], xv[4]);
            }
            liter--;
            pc -= 10;
            for (; liter >= ml->begin(); liter--, pc -= 10) {
                uint32_t tpc = pc;
                check_lines(*liter, tpc, yv[4], xv[4]);
            }
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeogMultiPolygon* mp = reinterpret_cast<const ObWkbGeogMultiPolygon*>(sub_ptr);
            uint32_t pc = 0;
            ASSERT_EQ(10, mp->size());
            ObWkbGeogMultiPolygon::iterator mpiter = mp->begin();
            for (; mpiter != mp->end(); ++mpiter) {
                ASSERT_EQ(10, mpiter->size());
                check_lines(mpiter->exterior_ring(), pc, yv[5], xv[5]);
                auto& inner_rings = mpiter->inner_rings();
                ASSERT_EQ(9, inner_rings.size());
                ObWkbGeogPolygonInnerRings::iterator riter = inner_rings.begin();
                for (; riter != inner_rings.end(); riter++) {
                    check_lines(*riter, pc, yv[5], xv[5]);
                }
                uint32_t rpc = pc;
                --riter;
                rpc -= 100;
                for (; riter >= inner_rings.begin(); riter--, rpc -= 100) {
                    uint32_t tpc = rpc;
                    check_lines(*riter, tpc, yv[5], xv[5]);
                }
            }
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeogCollection* subgc = reinterpret_cast<const ObWkbGeogCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
}

void create_polygon(ObJsonBuffer &data, int lnum, int pnum, std::vector< std::pair<double, double> > &value)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, lnum));
    int i = 0;
    for (int l = 0; l < lnum; l++) {
      ASSERT_EQ(OB_SUCCESS, append_uint32(data, pnum));
      for (int p = 0; p < pnum; p++) {
        ASSERT_EQ(OB_SUCCESS, append_double(data, value[i].first));
        ASSERT_EQ(OB_SUCCESS, append_double(data, value[i].second));
        i++;
      }
    }
}

TEST_F(TestGeoBin, geo_close_ring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 4;
    uint32_t lnum = 2;

    std::vector< std::pair<double, double> > val1;
    val1.push_back(std::make_pair(1.0, 0.5));
    val1.push_back(std::make_pair(3.0, 0.5));
    val1.push_back(std::make_pair(3.0, 1.0));
    val1.push_back(std::make_pair(1.0, 1.0));
    val1.push_back(std::make_pair(1.0, 0.5));
    val1.push_back(std::make_pair(3.0, 0.5));
    val1.push_back(std::make_pair(3.0, 1.0));
    val1.push_back(std::make_pair(1.0, 1.0));
    create_polygon(data, lnum, pnum, val1);

    ObWkbGeogPolygon& poly = *reinterpret_cast<ObWkbGeogPolygon*>(data.ptr());
    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    std::cout << "poly: " << boost::geometry::dsv(poly) << std::endl;
    ASSERT_EQ(OB_SUCCESS, ObGeoTypeUtil::geo_close_ring(iwkb_geog, allocator));
    ObWkbGeogPolygon *res_poly = reinterpret_cast<ObWkbGeogPolygon*>(iwkb_geog.val());
    std::cout << "after do close poly: " << boost::geometry::dsv(*res_poly) << std::endl;


  ObJsonBuffer data1(&allocator);
  ASSERT_EQ(OB_SUCCESS, append_bo(data1));
  ASSERT_EQ(OB_SUCCESS, append_type(data1, ObGeoType::MULTIPOLYGON));
  uint32_t polygon_num = 2;
  ASSERT_EQ(OB_SUCCESS, append_uint32(data1, polygon_num));
  for (uint32_t i = 0; i < polygon_num; i++) {
    std::vector< std::pair<double, double> > val;
    val.push_back(std::make_pair(0.0, 0.0 + 2 * i));
    val.push_back(std::make_pair(2.0, 0.0 + 2 * i));
    val.push_back(std::make_pair(2.0, 1.0 + 2 * i));
    val.push_back(std::make_pair(0.0, 1.0 + 2 * i));

    val.push_back(std::make_pair(0.0, 0.0 + 2 * i));
    val.push_back(std::make_pair(2.0, 0.0 + 2 * i));
    val.push_back(std::make_pair(2.0, 1.0 + 2 * i));
    val.push_back(std::make_pair(0.0, 1.0 + 2 * i));

    create_polygon(data1, 2, 4, val);
  }

  ObIWkbGeogMultiPolygon multi_poly;
  multi_poly.set_data(data1.string());

  const ObWkbGeogMultiPolygon *geo2 = reinterpret_cast<const ObWkbGeogMultiPolygon *>(multi_poly.val());
  ASSERT_EQ(OB_SUCCESS, ObGeoTypeUtil::geo_close_ring(multi_poly, allocator));
  std::cout << "after do close multipoly: " << multi_poly.size() << std::endl;
  ObWkbGeogMultiPolygon *res_multipoly = reinterpret_cast<ObWkbGeogMultiPolygon*>(multi_poly.val());
  std::cout << "after do close multipoly: " << boost::geometry::dsv(*res_multipoly) << std::endl;
}

TEST_F(TestGeoBin, collection_close_ring)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data, xv[0], yv[0]);
    // line
    append_line(data, 1, xv[1], yv[1]);
    // polygon
    append_poly(data, 2, 4, xv[2], yv[2]);
    // multipoint
    append_multi_point(data, 1, xv[3], yv[3]);
    // multiline
    append_multi_line(data, 1, 3, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2));
    for (int i = 0; i < 2; i++) {
        append_poly(data, 2, 4, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 0));

    ObIWkbGeogCollection iwkb_geog;
    iwkb_geog.set_data(data.string());

    const ObWkbGeogCollection *geo2 = reinterpret_cast<const ObWkbGeogCollection *>(iwkb_geog.val());
    ObWkbGeogCollection::iterator iter = geo2->begin();
    for (int i = 0; iter != geo2->end(); ++iter, ++i) {
        typename ObWkbGeogCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = geo2->get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeogPoint* point = reinterpret_cast<const ObWkbGeogPoint*>(sub_ptr);
            std::cout << "point: " << boost::geometry::dsv(*point) << std::endl;
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeogLineString* line = reinterpret_cast<const ObWkbGeogLineString*>(sub_ptr);
            std::cout << "line: " << boost::geometry::dsv(*line) << std::endl;
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeogPolygon* poly = reinterpret_cast<const ObWkbGeogPolygon*>(sub_ptr);
            std::cout << "poly: " << boost::geometry::dsv(*poly) << std::endl;
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeogMultiPoint* mp = reinterpret_cast<const ObWkbGeogMultiPoint*>(sub_ptr);
            std::cout << "multipoint: " << boost::geometry::dsv(*mp) << std::endl;
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeogMultiLineString* ml = reinterpret_cast<const ObWkbGeogMultiLineString*>(sub_ptr);
            std::cout << "multiline: " << boost::geometry::dsv(*ml) << std::endl;
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeogMultiPolygon* mp = reinterpret_cast<const ObWkbGeogMultiPolygon*>(sub_ptr);
            std::cout << "multipoly: " << boost::geometry::dsv(*mp) << std::endl;
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeogCollection* subgc = reinterpret_cast<const ObWkbGeogCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
    ASSERT_EQ(OB_SUCCESS, ObGeoTypeUtil::geo_close_ring(iwkb_geog, allocator));
    geo2 = reinterpret_cast<const ObWkbGeogCollection *>(iwkb_geog.val());
    iter = geo2->begin();
    for (int i = 0; iter != geo2->end(); ++iter, ++i) {
        typename ObWkbGeogCollection::const_pointer sub_ptr = iter.operator->();
        ObGeoType sub_type = geo2->get_sub_type(sub_ptr);
        ASSERT_EQ(i + 1, static_cast<int>(sub_type));
        if (sub_type == ObGeoType::POINT) {
            const ObWkbGeogPoint* point = reinterpret_cast<const ObWkbGeogPoint*>(sub_ptr);
            std::cout << "point: " << boost::geometry::dsv(*point) << std::endl;
        } else if (sub_type == ObGeoType::LINESTRING) {
            const ObWkbGeogLineString* line = reinterpret_cast<const ObWkbGeogLineString*>(sub_ptr);
            std::cout << "line: " << boost::geometry::dsv(*line) << std::endl;
        } else if (sub_type == ObGeoType::POLYGON) {
            const ObWkbGeogPolygon* poly = reinterpret_cast<const ObWkbGeogPolygon*>(sub_ptr);
            std::cout << "poly: " << boost::geometry::dsv(*poly) << std::endl;
        } else if (sub_type == ObGeoType::MULTIPOINT) {
            const ObWkbGeogMultiPoint* mp = reinterpret_cast<const ObWkbGeogMultiPoint*>(sub_ptr);
            std::cout << "multipoint: " << boost::geometry::dsv(*mp) << std::endl;
        } else if (sub_type == ObGeoType::MULTILINESTRING) {
            const ObWkbGeogMultiLineString* ml = reinterpret_cast<const ObWkbGeogMultiLineString*>(sub_ptr);
            std::cout << "multiline: " << boost::geometry::dsv(*ml) << std::endl;
        } else if (sub_type == ObGeoType::MULTIPOLYGON) {
            const ObWkbGeogMultiPolygon* mp = reinterpret_cast<const ObWkbGeogMultiPolygon*>(sub_ptr);
            std::cout << "multipoly: " << boost::geometry::dsv(*mp) << std::endl;
        } else if (sub_type == ObGeoType::GEOMETRYCOLLECTION) {
            const ObWkbGeogCollection* subgc = reinterpret_cast<const ObWkbGeogCollection*>(sub_ptr);
            ASSERT_EQ(0, subgc->size());
            ASSERT_EQ(subgc->begin(), subgc->end());
        }
    }
}

TEST_F(TestGeoBin, mbr_polygon_1)
{
    ObSrsBoundsItem srsbound_max;
    srsbound_max.minX_ = (double)-10000000;
    srsbound_max.maxX_ = (double)10000000;
    srsbound_max.minY_ = (double)-10000000;
    srsbound_max.maxY_ = (double)10000000;

    ObArenaAllocator allocator(ObModIds::TEST);

    ObJsonBuffer data(&allocator);
    // ------------------ test polygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 5));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)2394090));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)355520));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)2394090));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)355520));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)2727385));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)2727385));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)2394090));

    ObIWkbGeomPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());

    ObGeometry *geo1 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo1);
    ObWkbGeomPolygon *mbr_polygon1 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo1->val()));
    std::cout << "ob::poly" << boost::geometry::dsv(*mbr_polygon1) << std::endl;

    // change point order invalid test
    ObJsonBuffer data2(&allocator);
    // ------------------ test invalid polygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data2));
    ASSERT_EQ(OB_SUCCESS, append_type(data2, ObGeoType::POLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data2, 1));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data2, 5));

    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)2394090));

    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)355520));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)2394090));

    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)2727385));

    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)355520));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)2727385));

    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)250000));
    ASSERT_EQ(OB_SUCCESS, append_double(data2, (double)2394090));

    ObIWkbGeomPolygon iwkb_geog2;
    iwkb_geog2.set_data(data2.string());

    ObGeometry *geo2 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo2);
    ObWkbGeomPolygon *mbr_polygon2 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo2->val()));
    std::cout << "ob::invalid poly" << boost::geometry::dsv(*mbr_polygon2) << std::endl;

    // line string test2
    ObJsonBuffer data3b(&allocator);
    // ------------------ test linestring
    ASSERT_EQ(OB_SUCCESS, append_bo(data3b));
    ASSERT_EQ(OB_SUCCESS, append_type(data3b, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data3b, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(data3b, (double)10));
    ASSERT_EQ(OB_SUCCESS, append_double(data3b, (double)10));

    ASSERT_EQ(OB_SUCCESS, append_double(data3b, (double)20));
    ASSERT_EQ(OB_SUCCESS, append_double(data3b, (double)20));

    ObIWkbGeomLineString iwkb_geog3b;
    iwkb_geog3b.set_data(data3b.string());

    ObGeometry *geo3b = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog3b, geo3b);
    ObWkbGeomPolygon *mbr_polygon3b = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo3b->val()));
    std::cout << "ob::linestring1" << boost::geometry::dsv(*mbr_polygon3b) << std::endl;

    // line string test
    ObJsonBuffer data3(&allocator);
    // ------------------ test linestring
    ASSERT_EQ(OB_SUCCESS, append_bo(data3));
    ASSERT_EQ(OB_SUCCESS, append_type(data3, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data3, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(data3, (double)10));
    ASSERT_EQ(OB_SUCCESS, append_double(data3, (double)15));

    ASSERT_EQ(OB_SUCCESS, append_double(data3, (double)20));
    ASSERT_EQ(OB_SUCCESS, append_double(data3, (double)15));

    ObIWkbGeomLineString iwkb_geog3;
    iwkb_geog3.set_data(data3.string());

    ObGeometry *geo3 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog3, geo3);
    ASSERT_EQ(ObGeoType::LINESTRING, geo3->type());
    ObWkbGeomLineString *mbr_polygon3 = reinterpret_cast<ObWkbGeomLineString *>(const_cast<char *>(geo3->val()));
    std::cout << "ob::linestring2" << boost::geometry::dsv(*mbr_polygon3) << std::endl;

    // test point
    ObJsonBuffer data4(&allocator);
    // ------------------ test point
    ASSERT_EQ(OB_SUCCESS, append_bo(data4));
    ASSERT_EQ(OB_SUCCESS, append_type(data4, ObGeoType::POINT));

    ASSERT_EQ(OB_SUCCESS, append_double(data4, (double)-10));
    ASSERT_EQ(OB_SUCCESS, append_double(data4, (double)-15));

    ObIWkbGeomPoint iwkb_geog4;
    iwkb_geog4.set_data(data4.string());

    ObGeometry *geo4 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog4, geo4);
    ASSERT_EQ(ObGeoType::POINT, geo4->type());
    ObWkbGeomPoint *mbr_polygon4 = reinterpret_cast<ObWkbGeomPoint *>(const_cast<char *>(geo4->val()));
    std::cout << "ob::point" << boost::geometry::dsv(*mbr_polygon4) << std::endl;

    // test collection
    ObJsonBuffer data5(&allocator);
    // ------------------ test collection
    ASSERT_EQ(OB_SUCCESS, append_bo(data5));
    ASSERT_EQ(OB_SUCCESS, append_type(data5, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data5, 7));
    common::ObVector<double> xv[7];
    common::ObVector<double> yv[7];
    // point
    append_random_point(data5, xv[0], yv[0]);
    // line
    append_line(data5, 100, xv[1], yv[1]);
    // polygon
    append_poly(data5, 100, 100, xv[2], yv[2]);
    // multipoint
    append_multi_point(data5, 100, xv[3], yv[3]);
    // multiline
    append_multi_line(data5, 1000, 10, xv[4], yv[4]);
    // multipolygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data5));
    ASSERT_EQ(OB_SUCCESS, append_type(data5, ObGeoType::MULTIPOLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data5, 10));
    for (int i = 0; i < 10; i++) {
        append_poly(data5, 10, 100, xv[5], yv[5]);
    }
    // empty geometry
    ASSERT_EQ(OB_SUCCESS, append_bo(data5));
    ASSERT_EQ(OB_SUCCESS, append_type(data5, ObGeoType::GEOMETRYCOLLECTION));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data5, 0));

    ObIWkbGeomCollection iwkb_geog5;
    iwkb_geog5.set_data(data5.string());

    ObGeometry *geo5 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog5, geo5);
    ASSERT_EQ(ObGeoType::POLYGON, geo5->type());
    ObWkbGeomPolygon *mbr_polygon5 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo5->val()));
    std::cout << "ob::mpoly5" << boost::geometry::dsv(*mbr_polygon5) << std::endl;
}

static void test_geo_bin_make_rect(ObIAllocator &allocator, ObJsonBuffer &data, double minx, double maxx, double miny, double maxy)
{
    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 1));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 5));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)minx));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)miny));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)maxx));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)miny));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)maxx));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)maxy));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)minx));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)maxy));

    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)minx));
    ASSERT_EQ(OB_SUCCESS, append_double(data, (double)miny));
}

TEST_F(TestGeoBin, mbr_polygon_2)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // ------------------ test polygon
    test_geo_bin_make_rect(allocator, data, (double)-1, (double)1, (double)-1, (double)1);

    ObIWkbGeomPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());

    ObSrsBoundsItem srsbound_max;
    srsbound_max.minX_ = (double)0;
    srsbound_max.maxX_ = (double)2;
    srsbound_max.minY_ = (double)0;
    srsbound_max.maxY_ = (double)2;

    ObGeometry *geo1 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo1);
    ObWkbGeomPolygon *mbr_polygon1 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo1->val()));
    std::cout << "ob::poly 1" << boost::geometry::dsv(*mbr_polygon1) << std::endl;

    srsbound_max.minX_ = (double)-2;
    srsbound_max.maxX_ = (double)0;
    srsbound_max.minY_ = (double)0;
    srsbound_max.maxY_ = (double)2;

    ObGeometry *geo2 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo2);
    ObWkbGeomPolygon *mbr_polygon2 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo2->val()));
    std::cout << "ob::poly 2" << boost::geometry::dsv(*mbr_polygon2) << std::endl;

    srsbound_max.minX_ = (double)-2;
    srsbound_max.maxX_ = (double)0;
    srsbound_max.minY_ = (double)-2;
    srsbound_max.maxY_ = (double)0;

    ObGeometry *geo3 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo3);
    ObWkbGeomPolygon *mbr_polygon3 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo3->val()));
    std::cout << "ob::poly 3" << boost::geometry::dsv(*mbr_polygon3) << std::endl;

    srsbound_max.minX_ = (double)0;
    srsbound_max.maxX_ = (double)2;
    srsbound_max.minY_ = (double)-2;
    srsbound_max.maxY_ = (double)0;

    ObGeometry *geo4 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geog, geo4);
    ObWkbGeomPolygon *mbr_polygon4 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geo4->val()));
    std::cout << "ob::poly 4" << boost::geometry::dsv(*mbr_polygon4) << std::endl;


    srsbound_max.minX_ = (double)-1;
    srsbound_max.maxX_ = (double)1;
    srsbound_max.minY_ = (double)-1;
    srsbound_max.maxY_ = (double)1;
    // ------------------ test linestring
    ObJsonBuffer datal1(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(datal1));
    ASSERT_EQ(OB_SUCCESS, append_type(datal1, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(datal1, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(datal1, (double)0));
    ASSERT_EQ(OB_SUCCESS, append_double(datal1, (double)-2));

    ASSERT_EQ(OB_SUCCESS, append_double(datal1, (double)0));
    ASSERT_EQ(OB_SUCCESS, append_double(datal1, (double)2));

    ObIWkbGeomLineString iwkb_geogl1;
    iwkb_geogl1.set_data(datal1.string());

    ObGeometry *geol1 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogl1, geol1);
    ASSERT_EQ(ObGeoType::LINESTRING, geol1->type());
    ObWkbGeomLineString *mbr_polygonl1 = reinterpret_cast<ObWkbGeomLineString *>(const_cast<char *>(geol1->val()));
    std::cout << "ob::linestring1" << boost::geometry::dsv(*mbr_polygonl1) << std::endl;


    ObJsonBuffer datal2(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(datal2));
    ASSERT_EQ(OB_SUCCESS, append_type(datal2, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(datal2, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(datal2, (double)-2));
    ASSERT_EQ(OB_SUCCESS, append_double(datal2, (double)0));

    ASSERT_EQ(OB_SUCCESS, append_double(datal2, (double)2));
    ASSERT_EQ(OB_SUCCESS, append_double(datal2, (double)0));

    ObIWkbGeomLineString iwkb_geogl2;
    iwkb_geogl2.set_data(datal2.string());

    ObGeometry *geol2 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogl2, geol2);
    ASSERT_EQ(ObGeoType::LINESTRING, geol2->type());
    ObWkbGeomLineString *mbr_polygonl2 = reinterpret_cast<ObWkbGeomLineString *>(const_cast<char *>(geol2->val()));
    std::cout << "ob::linestring2" << boost::geometry::dsv(*mbr_polygonl2) << std::endl;


    ObJsonBuffer datal3(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(datal3));
    ASSERT_EQ(OB_SUCCESS, append_type(datal3, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(datal3, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(datal3, (double)-10));
    ASSERT_EQ(OB_SUCCESS, append_double(datal3, (double)-10));

    ASSERT_EQ(OB_SUCCESS, append_double(datal3, (double)10));
    ASSERT_EQ(OB_SUCCESS, append_double(datal3, (double)10));

    ObIWkbGeomLineString iwkb_geogl3;
    iwkb_geogl3.set_data(datal3.string());

    ObGeometry *geol3 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogl3, geol3);
    ASSERT_EQ(ObGeoType::POLYGON, geol3->type());
    ObWkbGeomPolygon *mbr_polygonl3 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geol3->val()));
    std::cout << "ob::linestring3(poly)" << boost::geometry::dsv(*mbr_polygonl3) << std::endl;


    ObJsonBuffer datal4(&allocator);
    ASSERT_EQ(OB_SUCCESS, append_bo(datal4));
    ASSERT_EQ(OB_SUCCESS, append_type(datal4, ObGeoType::LINESTRING));
    ASSERT_EQ(OB_SUCCESS, append_uint32(datal4, 2));

    ASSERT_EQ(OB_SUCCESS, append_double(datal4, (double)-2));
    ASSERT_EQ(OB_SUCCESS, append_double(datal4, (double)1));

    ASSERT_EQ(OB_SUCCESS, append_double(datal4, (double)2));
    ASSERT_EQ(OB_SUCCESS, append_double(datal4, (double)1));

    ObIWkbGeomLineString iwkb_geogl4;
    iwkb_geogl4.set_data(datal4.string());

    ObGeometry *geol4 = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogl4, geol4);
    ASSERT_EQ(ObGeoType::POLYGON, geol4->type());
    ObWkbGeomPolygon *mbr_polygonl4 = reinterpret_cast<ObWkbGeomPolygon *>(const_cast<char *>(geol4->val()));
    std::cout << "ob::linestring5(poly)" << boost::geometry::dsv(*mbr_polygonl4) << std::endl;


    srsbound_max.minX_ = (double)0;
    srsbound_max.maxX_ = (double)2;
    srsbound_max.minY_ = (double)0;
    srsbound_max.maxY_ = (double)2;


    ObJsonBuffer datap(&allocator);
    // ------------------ test point1
    ASSERT_EQ(OB_SUCCESS, append_bo(datap));
    ASSERT_EQ(OB_SUCCESS, append_type(datap, ObGeoType::POINT));

    ASSERT_EQ(OB_SUCCESS, append_double(datap, (double)1));
    ASSERT_EQ(OB_SUCCESS, append_double(datap, (double)1));

    ObIWkbGeomPoint iwkb_geogp;
    iwkb_geogp.set_data(datap.string());

    ObGeometry *geop = NULL;
    ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogp, geop);
    ASSERT_EQ(ObGeoType::POINT, geop->type());
    ObWkbGeomPoint *mbr_polygonp = reinterpret_cast<ObWkbGeomPoint *>(const_cast<char *>(geop->val()));
    std::cout << "ob::point1" << boost::geometry::dsv(*mbr_polygonp) << std::endl;


    ObJsonBuffer datap2(&allocator);
    // ------------------ test point2
    ASSERT_EQ(OB_SUCCESS, append_bo(datap2));
    ASSERT_EQ(OB_SUCCESS, append_type(datap2, ObGeoType::POINT));

    ASSERT_EQ(OB_SUCCESS, append_double(datap2, (double)-1));
    ASSERT_EQ(OB_SUCCESS, append_double(datap2, (double)-1));

    ObIWkbGeomPoint iwkb_geogp2;
    iwkb_geogp2.set_data(datap2.string());

    ObGeometry *geop2 = NULL;
    ASSERT_EQ(ObGeoTypeUtil::get_mbr_polygon(allocator, &srsbound_max, iwkb_geogp2, geop2), OB_EMPTY_RESULT);
}

/*********************************************************/
/*                test for ObSdoGeoToWkb                 */
/*********************************************************/

TEST_F(TestGeoBin, sdo_point) {
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeoStringBuffer data(&allocator);
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    double x = 19;
    double y = 9.5456;
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo)); // 00
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    ObString res = data.string();

    // case 1: SDO_ELEM_INFO = NULL, SDO_POINT_TYPE = (x, y, NULL)
    ObSdoPoint point(x, y);
    ObSdoGeoObject geo(ObGeoType::POINT, point, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);

    // case 2: SDO_ELEM_INFO = (1,1,1), SDO_ORDINATES = (x, y)
    ObArray<uint64_t> elem_info;
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));

    ObArray<double> ordinate;
    ASSERT_EQ(OB_SUCCESS, ordinate.push_back(x));
    ASSERT_EQ(OB_SUCCESS, ordinate.push_back(y));

    // ObSdoGeoToWkb trans2(&allocator);
    ObSdoGeoObject geo2(ObGeoType::POINT, elem_info, ordinate, allocator);
    ObString wkb2;
    trans.reset();
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo2, wkb2));
    ASSERT_EQ(wkb2 == res, true);
}

TEST_F(TestGeoBin, sdo_point_3d) {
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeoStringBuffer data(&allocator);
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    double x = 19;
    double y = 9.5456;
    double z = 18.5;
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo)); // 00
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINTZ, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, z, bo));
    ObString res = data.string();

    // case 1: SDO_ELEM_INFO = NULL, SDO_POINT_TYPE = (x, y, NULL)
    ObSdoPoint point(x, y, z);
    ObSdoGeoObject geo(ObGeoType::POINTZ, point, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);

    // case 2: SDO_ELEM_INFO = (1,1,1), SDO_ORDINATES = (x, y)
    ObArray<uint64_t> elem_info;
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));

    ObArray<double> ordinate;
    ASSERT_EQ(OB_SUCCESS, ordinate.push_back(x));
    ASSERT_EQ(OB_SUCCESS, ordinate.push_back(y));
    ASSERT_EQ(OB_SUCCESS, ordinate.push_back(z));
    // ObSdoGeoToWkb trans2(&allocator);
    ObSdoGeoObject geo2(ObGeoType::POINTZ, elem_info, ordinate, allocator);
    ObString wkb2;
    trans.reset();
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo2, wkb2));
    ASSERT_EQ(wkb2 == res, true);

    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb2);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_linestring) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_line(data, num, xv, yv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(2));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ObArray<double> ordinate;
    for (uint32_t k = 0; k < num; k++) {
        ordinate.push_back(xv[k]);
        ordinate.push_back(yv[k]);
    }
    ObSdoGeoObject geo(ObGeoType::LINESTRING, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
}

TEST_F(TestGeoBin, sdo_linestring_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 10;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_line_3d(data, num, xv, yv, zv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(2));
    ASSERT_EQ(OB_SUCCESS, elem_info.push_back(1));
    ObArray<double> ordinate;
    for (uint32_t k = 0; k < num; k++) {
        ordinate.push_back(xv[k]);
        ordinate.push_back(yv[k]);
        ordinate.push_back(zv[k]);
    }
    ObSdoGeoObject geo(ObGeoType::LINESTRINGZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_polygon) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line [lnum] inner line, every line has [pnum] point
    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_poly(data, lnum, pnum, xv, yv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    for (uint64_t j = 0; j < lnum; j++) {
        elem_info.push_back(ordinate.size() + 1);
        if (j == 0) {
            elem_info.push_back(1003); // ext ring
        } else {
            elem_info.push_back(2003); // inner ring
        }

        elem_info.push_back(1);

        for (uint32_t k = 0; k < pnum; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
        }
    }

    ObSdoGeoObject geo(ObGeoType::POLYGON, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
}


TEST_F(TestGeoBin, sdo_polygon_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line [lnum] inner line, every line has [pnum] point
    uint32_t pnum = 5;
    uint32_t lnum = 3;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_poly_3d(data, lnum, pnum, xv, yv, zv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    size_t z_idx = 0;
    for (uint64_t j = 0; j < lnum; j++) {
        elem_info.push_back(ordinate.size() + 1);
        if (j == 0) {
            elem_info.push_back(1003); // ext ring
        } else {
            elem_info.push_back(2003); // inner ring
        }

        elem_info.push_back(1);

        for (uint32_t k = 0; k < pnum; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
            ordinate.push_back(zv[z_idx++]);
        }
    }

    ObSdoGeoObject geo(ObGeoType::POLYGONZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_multipoint) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 1000000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_multi_point(data, num, xv, yv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    for (uint32_t k = 0; k < num; k++) {
        elem_info.push_back(k * 2 + 1);
        elem_info.push_back(1);
        elem_info.push_back(1);
        ordinate.push_back(xv[k]);
        ordinate.push_back(yv[k]);
    }
    ObSdoGeoObject geo(ObGeoType::MULTIPOINT, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
}

TEST_F(TestGeoBin, sdo_multipoint_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    uint32_t num = 10;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_multi_point_3d(data, num, xv, yv, zv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    elem_info.push_back(1);
    elem_info.push_back(1);
    elem_info.push_back(num);
    for (uint32_t k = 0; k < num; k++) {
        ordinate.push_back(xv[k]);
        ordinate.push_back(yv[k]);
        ordinate.push_back(zv[k]);
    }
    ObSdoGeoObject geo(ObGeoType::MULTIPOINTZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_multilinestring) {
    get_srs_item(allocator_, 4326, srs_item);
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 100;
    uint32_t lnum = 10000;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    append_multi_line(data, lnum, pnum, xv, yv, type, bo);
    ObString res = data.string();

    // <index, 2, 1>
    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    uint64_t index = 1;
    for (size_t k = 0; k < lnum; k++) {
        elem_info.push_back(index);
        index += pnum * 2;
        elem_info.push_back(2);
        elem_info.push_back(1);
        for (size_t j = 0; j < pnum; ++j) {
            ordinate.push_back(xv[k * pnum + j]);
            ordinate.push_back(yv[k * pnum + j]);
        }
    }

    ObSdoGeoObject geo(ObGeoType::MULTILINESTRING, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
}

TEST_F(TestGeoBin, sdo_multilinestring_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line 100 inner line, every line has 100 point
    uint32_t pnum = 10;
    uint32_t lnum = 2;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    append_multi_line_3d(data, lnum, pnum, xv, yv, zv, type, bo);
    ObString res = data.string();

    // <index, 2, 1>
    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    uint64_t index = 1;
    for (size_t k = 0; k < lnum; k++) {
        elem_info.push_back(index);
        index += pnum * 3;
        elem_info.push_back(2);
        elem_info.push_back(1);
        for (size_t j = 0; j < pnum; ++j) {
            ordinate.push_back(xv[k * pnum + j]);
            ordinate.push_back(yv[k * pnum + j]);
            ordinate.push_back(zv[k * pnum + j]);
        }
    }

    ObSdoGeoObject geo(ObGeoType::MULTILINESTRINGZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_multipolygon) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line [lnum] inner polygon, every polygon has [pnum] point
    uint32_t pnum = 100;
    uint32_t lnum = 10001;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<uint64_t> pnumv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_multi_poly(data, lnum, pnum, xv, yv, pnumv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    int rec_num = 0;
    uint64_t ordinate_sum = 1;
    for (uint64_t j = 0; j < lnum; j++) {
        if (j == 0) {
            elem_info.push_back(1);
        } else {
            ordinate_sum += pnumv[j - 1] * 2;
            elem_info.push_back(ordinate_sum);
        }
        elem_info.push_back(1003);

        if (pnumv[j] == 2) {
            elem_info.push_back(3); // rectangle
            ++rec_num;
        } else {
            elem_info.push_back(1);
        }

        for (uint32_t k = 0; k < pnumv[j]; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
        }
    }
    ObSdoGeoObject geo(ObGeoType::MULTIPOLYGON, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
}

TEST_F(TestGeoBin, sdo_multipolygon_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // 1 exterior line [lnum] inner polygon, every polygon has [pnum] point
    uint32_t pnum = 5;
    uint32_t lnum = 3;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    common::ObVector<uint64_t> pnumv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_multi_poly_3d(data, lnum, pnum, xv, yv, zv, pnumv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    size_t z_idx = 0;
    int rec_num = 0;
    uint64_t ordinate_sum = 1;
    for (uint64_t j = 0; j < lnum; j++) {
        if (j == 0) {
            elem_info.push_back(1);
        } else {
            ordinate_sum += pnumv[j - 1] * 3;
            elem_info.push_back(ordinate_sum);
        }
        elem_info.push_back(1003);
        // to do : rectangle
        elem_info.push_back(1);

        for (uint32_t k = 0; k < pnumv[j]; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
            ordinate.push_back(zv[z_idx++]);
        }
    }
    ObSdoGeoObject geo(ObGeoType::MULTIPOLYGONZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}

TEST_F(TestGeoBin, sdo_collection) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // [lnum] geometry
    uint32_t lnum = 1024;
    uint32_t pnum = 100;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<ObGeoType> types;
    common::ObVector<uint64_t> pnumv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_collection(data, lnum, pnum, xv, yv, types, pnumv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    int rec_num = 0;
    uint64_t ordinate_sum = 1;
    for (uint64_t j = 0; j < lnum; j++) {
        elem_info.push_back(ordinate.size() + 1);
        if (types[j] == ObGeoType::POINT) {
            elem_info.push_back(1);
            elem_info.push_back(1);
        } else if (types[j] == ObGeoType::MULTILINESTRING) {
            elem_info.push_back(1);
            elem_info.push_back(pnum);
        } else if (types[j] == ObGeoType::LINESTRING) {
            elem_info.push_back(2);
            elem_info.push_back(1);
        } else if (types[j] == ObGeoType::POLYGON) {
            elem_info.push_back(1003);
            if (pnumv[j] == 2) {
                elem_info.push_back(3); // rectangle
                ++rec_num;
            } else {
                elem_info.push_back(1);
            }
        }
        for (uint32_t k = 0; k < pnumv[j]; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
        }
    }
    ObSdoGeoObject geo(ObGeoType::GEOMETRYCOLLECTION, elem_info, ordinate, allocator);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb, res);
    ASSERT_EQ(wkb == res, true);
}

TEST_F(TestGeoBin, sdo_collection_3d) {
    get_srs_item(allocator_, 4326, srs_item);
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);
    // [lnum] geometry
    uint32_t lnum = 24;
    uint32_t pnum = 6;
    common::ObVector<double> xv;
    common::ObVector<double> yv;
    common::ObVector<double> zv;
    common::ObVector<ObGeoType> types;
    common::ObVector<uint64_t> pnumv;
    GeogValueValidType type = GeogValueValidType::IN_RANGE;
    ObGeoWkbByteOrder bo = ObGeoWkbByteOrder::BigEndian;
    append_sdo_collection_3d(data, lnum, pnum, xv, yv, zv, types, pnumv, type, bo);
    ObString res = data.string();

    ObArray<uint64_t> elem_info;
    ObArray<double> ordinate;
    size_t x_idx = 0;
    size_t y_idx = 0;
    size_t z_idx = 0;
    int rec_num = 0;
    uint64_t ordinate_sum = 1;
    for (uint64_t j = 0; j < lnum; j++) {
        elem_info.push_back(ordinate.size() + 1);
        if (types[j] == ObGeoType::POINTZ) {
            elem_info.push_back(1);
            elem_info.push_back(1);
        } else if (types[j] == ObGeoType::MULTIPOINTZ) {
            elem_info.push_back(1);
            elem_info.push_back(pnum);
        } else if (types[j] == ObGeoType::LINESTRINGZ) {
            elem_info.push_back(2);
            elem_info.push_back(1);
        } else if (types[j] == ObGeoType::POLYGONZ) {
            elem_info.push_back(1003);
            elem_info.push_back(1);
            // to do rectangle
        }
        for (uint32_t k = 0; k < pnumv[j]; k++) {
            ordinate.push_back(xv[x_idx++]);
            ordinate.push_back(yv[y_idx++]);
            ordinate.push_back(zv[z_idx++]);
        }
    }
    ObSdoGeoObject geo(ObGeoType::GEOMETRYCOLLECTIONZ, elem_info, ordinate, allocator, 0);
    ObSdoGeoToWkb trans(&allocator);
    ObString wkb;
    ASSERT_EQ(OB_SUCCESS, trans.translate(&geo, wkb));
    ASSERT_EQ(wkb, res);
    ASSERT_EQ(wkb == res, true);
    ObGeometry3D geo_3d;
    geo_3d.set_data(wkb);
    ObSdoGeoObject geo3(allocator);
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_sdo_geometry(geo3));
    geo3.set_srid(geo.get_srid());
    ASSERT_EQ(geo == geo3, true);

    ObString geo_json;
    ASSERT_EQ(OB_SUCCESS, geo_3d.to_geo_json(&allocator, geo_json));
    std::cout << "geo json: " << std::string(geo_json.ptr(), geo_json.length()) << std::endl;
}
/******************************************************************/
/*                test for ObWkbByteOrderVisitor                  */
/******************************************************************/
ObString to_hex(const ObString &str) {
    uint64_t out_str_len = str.length() * 2;
    int64_t pos = 0;
    char *data = static_cast<char *>(allocator_.alloc(out_str_len));
    hex_print(str.ptr(), str.length(), data, out_str_len, pos);
    return ObString(out_str_len, data);
}

void mock_wkb_collection(ObJsonBuffer& data, ObGeoWkbByteOrder bo) {
    int geo_num = 6;
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::GEOMETRYCOLLECTION, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, geo_num, bo));
    double x = 1.234;
    double y = 5.678;
    // point
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
    ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    // line with 2 point
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    for (int i = 0; i < 2; ++i) {
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    }
    // polygon with 2 ring (1 polygon ring ,1 rectangle ring)
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 5, bo));
    for (int i = 0; i < 5; ++i) {
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    }
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    for (int i = 0; i < 2; ++i) {
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    }
    // multipoint with 2 point
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOINT, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    for (int i = 0; i < 2; ++i) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POINT, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
        ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
    }
    // multilinestring with 2 linestring
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTILINESTRING, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    for (int j = 0; j < 2; ++j) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::LINESTRING, bo));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
        for (int i = 0; i < 2; ++i) {
            ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
            ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        }
    }
    // multipolygon with 2 polygon
    ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::MULTIPOLYGON, bo));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
    for (int j = 0; j < 2; ++j) {
        ASSERT_EQ(OB_SUCCESS, append_bo(data, bo));
        ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON, bo));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 5, bo));
        for (int i = 0; i < 5; ++i) {
            ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
            ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        }
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 2, bo));
        for (int i = 0; i < 2; ++i) {
            ASSERT_EQ(OB_SUCCESS, append_double(data, x, bo));
            ASSERT_EQ(OB_SUCCESS, append_double(data, y, bo));
        }
    }
}

TEST_F(TestGeoBin, big_endian_collection) {
    int ret = 1;
    ObArenaAllocator allocator(ObModIds::TEST);

    ObJsonBuffer big_data(&allocator);
    mock_wkb_collection(big_data, ObGeoWkbByteOrder::BigEndian);
    ObString big_wkb = big_data.string();

    ObJsonBuffer little_data(&allocator);
    mock_wkb_collection(little_data, ObGeoWkbByteOrder::LittleEndian);
    ObString res_little_wkb = little_data.string();

    ObGeometry *geo = NULL;
    ASSERT_EQ(ObGeoTypeUtil::create_geo_by_type(allocator, ObGeoType::GEOMETRYCOLLECTION, false, true, geo), OB_SUCCESS);
    ASSERT_EQ(geo != NULL, true);
    geo->set_data(big_wkb);
    ObWkbByteOrderVisitor be_visitor(&allocator, ObGeoWkbByteOrder::LittleEndian);
    ASSERT_EQ(geo->do_visit(be_visitor), OB_SUCCESS);
    ObString cal_little_wkb = be_visitor.get_wkb();
    ASSERT_EQ(res_little_wkb == cal_little_wkb , true) << res_little_wkb.length() << cal_little_wkb.length();
}

/************************************************
** test for ObGeoInteriorPointVisitor
************************************************/
TEST_F(TestGeoBin, interior_point_vistor_point)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeometry *geo = NULL;
    ObGeometry *interior_point = NULL;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, "POINT(10 0)", geo, true, false), OB_SUCCESS);
    lib::MemoryContext mem_context;
    ASSERT_EQ(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context,
        lib::ContextParam().set_mem_attr(MTL_ID(), "GIS_UT", ObCtxIds::DEFAULT_CTX_ID)), OB_SUCCESS);
    ObGeoInteriorPointVisitor visitor(mem_context);
    ASSERT_EQ(geo->do_visit(visitor), OB_SUCCESS);
    ASSERT_EQ(visitor.get_interior_point(interior_point) , OB_SUCCESS);
    ASSERT_EQ(interior_point->type(), ObGeoType::POINT);
    ObCartesianPoint *pt = reinterpret_cast<ObCartesianPoint *>(interior_point);
    ASSERT_EQ(pt->x(), 10);
    ASSERT_EQ(pt->y(), 0);
}

TEST_F(TestGeoBin, interior_point_vistor_line)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeometry *geo = NULL;
    ObGeometry *interior_point = NULL;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, "LINESTRING(0 0, 5 0, 10 0)", geo, true, false), OB_SUCCESS);
    lib::MemoryContext mem_context;
    ASSERT_EQ(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context,
        lib::ContextParam().set_mem_attr(MTL_ID(), "GIS_UT", ObCtxIds::DEFAULT_CTX_ID)), OB_SUCCESS);
    ObGeoInteriorPointVisitor visitor(mem_context);
    ASSERT_EQ(geo->do_visit(visitor), OB_SUCCESS);
    ASSERT_EQ(visitor.get_interior_point(interior_point) , OB_SUCCESS);
    ASSERT_EQ(interior_point->type(), ObGeoType::POINT);
    ObCartesianPoint *pt = reinterpret_cast<ObCartesianPoint *>(interior_point);
    ASSERT_EQ(pt->x(), 5);
    ASSERT_EQ(pt->y(), 0);
}

TEST_F(TestGeoBin, interior_point_vistor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeometry *geo = NULL;
    ObGeometry *interior_point = NULL;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, "POLYGON(("
                             "182635.760119718 141846.477712277,182826.153168283 141974.473039044,"
                             "182834.952846998 141857.67730337,182862.151853936 141851.277537031,"
                             "182860.551912351 141779.280165725,182824.553226698 141748.881275618,"
                             "182814.953577191 141758.480925126,182766.155358861 141721.682268681,"
                             "182742.156235092 141744.881421657,182692.558045971 141716.882443927,"
                             "182635.760119718 141846.477712277))", geo, true, false), OB_SUCCESS);
    lib::MemoryContext mem_context;
    ASSERT_EQ(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context,
        lib::ContextParam().set_mem_attr(MTL_ID(), "GIS_UT", ObCtxIds::DEFAULT_CTX_ID)), OB_SUCCESS);
    ObGeoInteriorPointVisitor visitor(mem_context);
    ASSERT_EQ(geo->do_visit(visitor), OB_SUCCESS);
    ASSERT_EQ(visitor.get_interior_point(interior_point) , OB_SUCCESS);
    ASSERT_EQ(interior_point->type(), ObGeoType::POINT);
    ObCartesianPoint *pt = reinterpret_cast<ObCartesianPoint *>(interior_point);
    ASSERT_DOUBLE_EQ(pt->x(), 182755.89202988159);
    ASSERT_DOUBLE_EQ(pt->y(), 141812.87893900101);
}

TEST_F(TestGeoBin, interior_point_vistor_empty)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObGeometry *geo = NULL;
    ObGeometry *interior_point = NULL;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, "GEOMETRYCOLLECTION EMPTY", geo, true, false), OB_SUCCESS);
    lib::MemoryContext mem_context;
    ASSERT_EQ(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context,
        lib::ContextParam().set_mem_attr(MTL_ID(), "GIS_UT", ObCtxIds::DEFAULT_CTX_ID)), OB_SUCCESS);
    ObGeoInteriorPointVisitor visitor(mem_context);
    ASSERT_EQ(geo->do_visit(visitor), OB_SUCCESS);
    ASSERT_EQ(visitor.get_interior_point(interior_point) , OB_SUCCESS);
    ASSERT_EQ(interior_point->type(), ObGeoType::GEOMETRYCOLLECTION);
    ASSERT_EQ(interior_point->is_empty(), true);
}

void elevation_visitor_checker(ObIAllocator &allocator, const ObString &wkt1, const ObString &wkt2, const ObString &cal_wkt, const ObString &real_wkt)
{
    const double TOLERANCE = 0.00001;
    ObGeometry *geo1 = nullptr;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, wkt1, geo1, true, false), OB_SUCCESS);
    ASSERT_EQ(ObGeoTypeUtil::is_3d_geo_type(geo1->type()), true);
    ObGeometry *geo2 = nullptr;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, wkt2, geo2, true, false), OB_SUCCESS);
    ASSERT_EQ(ObGeoTypeUtil::is_3d_geo_type(geo2->type()), true);
    ObGeometry *geo_cal = nullptr;
    ASSERT_EQ(ObWktParser::parse_wkt(allocator, cal_wkt, geo_cal, true, false), OB_SUCCESS);
    ASSERT_EQ(ObGeoTypeUtil::is_3d_geo_type(geo_cal->type()), false);

    lib::MemoryContext mem_context;
    ASSERT_EQ(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context,
      lib::ContextParam().set_mem_attr(MTL_ID(), "GIS_UT", ObCtxIds::DEFAULT_CTX_ID)), OB_SUCCESS);
    ObGeoElevationVisitor visitor(mem_context, nullptr);
    ObGeometry *res_geo = nullptr;
    ASSERT_EQ(visitor.init(*geo1, *geo2), OB_SUCCESS);
    ASSERT_EQ(geo_cal->do_visit(visitor), OB_SUCCESS);
    ASSERT_EQ(visitor.get_geometry_3D(res_geo), OB_SUCCESS);
    ObString wkt;
    ObGeometry3D *geo_3d = static_cast<ObGeometry3D *>(res_geo);
    ASSERT_EQ(geo_3d->to_wkt(allocator, wkt), OB_SUCCESS);
    ASSERT_EQ(wkt == real_wkt, true);
}

TEST_F(TestGeoBin, elevation_visitor) {
    ObArenaAllocator allocator(ObModIds::TEST);
    elevation_visitor_checker(allocator, "LINESTRING Z (0 0 0, 10 10 10)", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(-1 11, 11 11, 0 10, 5 10, 10 10, 0 5, 5 5, 10 5, 0 0, 5 0, 10 0, -1 -1, 5 -1, 11 -1)",
        "MULTIPOINT Z ((-1 11 5),(11 11 10),(0 10 5),(5 10 5),(10 10 10),(0 5 5),(5 5 5),(10 5 5),(0 0 0),(5 0 5),(10 0 5),(-1 -1 0),(5 -1 5),(11 -1 5))");
    elevation_visitor_checker(allocator, "POLYGON Z ((1 6 50, 9 6 60, 9 4 50, 1 4 40, 1 6 50))", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(0 10,5 10,10 10,0 5,5 5,10 5,0 4,5 4,10 4,0 0,5 0,10 0)",
        "MULTIPOINT Z ((0 10 50),(5 10 50),(10 10 60),(0 5 50),(5 5 50),(10 5 50),(0 4 40),(5 4 50),(10 4 50),(0 0 40),(5 0 50),(10 0 50))");
    elevation_visitor_checker(allocator, "MULTILINESTRING Z ((0 0 0, 10 10 8), (1 2 2, 9 8 6))", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(-1 11,11 11,0 10,5 10,10 10,0 5,5 5,10 5,0 0,5 0,10 0,-1 -1,5 -1,11 -1)",
        "MULTIPOINT Z ((-1 11 4),(11 11 7),(0 10 4),(5 10 4),(10 10 7),(0 5 4),(5 5 4),(10 5 4),(0 0 1),(5 0 4),(10 0 4),(-1 -1 1),(5 -1 4),(11 -1 4))");
    elevation_visitor_checker(allocator, "LINESTRING Z (0 0 0, 10 10 8)", "LINESTRING Z (1 2 2, 9 8 6)",
        "MULTIPOINT(-1 11,11 11,0 10,5 10,10 10,0 5,5 5,10 5,0 0,5 0,10 0,-1 -1,5 -1,11 -1)",
        "MULTIPOINT Z ((-1 11 4),(11 11 7),(0 10 4),(5 10 4),(10 10 7),(0 5 4),(5 5 4),(10 5 4),(0 0 1),(5 0 4),(10 0 4),(-1 -1 1),(5 -1 4),(11 -1 4))");
    elevation_visitor_checker(allocator, "LINESTRING Z (0 5 0, 10 5 10)", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(0 10,5 10,10 10,0 5,5 5,10 5,0 0,5 0,10 0)",
        "MULTIPOINT Z ((0 10 0),(5 10 5),(10 10 10),(0 5 0),(5 5 5),(10 5 10),(0 0 0),(5 0 5),(10 0 10))");
    elevation_visitor_checker(allocator, "LINESTRING Z (5 0 0, 5 10 10)", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(0 10,5 10,10 10,0 5,5 5,10 5,0 0,5 0,10 0)",
        "MULTIPOINT Z ((0 10 10),(5 10 10),(10 10 10),(0 5 5),(5 5 5),(10 5 5),(0 0 0),(5 0 0),(10 0 0))");
    elevation_visitor_checker(allocator, "POINT Z (5 5 5)", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(0 9,5 9,9 9,0 5,5 5,9 5,0 0,5 0,9 0)",
        "MULTIPOINT Z ((0 9 5),(5 9 5),(9 9 5),(0 5 5),(5 5 5),(9 5 5),(0 0 5),(5 0 5),(9 0 5))");
    elevation_visitor_checker(allocator, "MULTIPOINT Z ((5 5 5), (5 5 9))", "GEOMETRYCOLLECTION Z EMPTY",
        "MULTIPOINT(0 9,5 9,9 9,0 5,5 5,9 5,0 0,5 0,9 0)",
        "MULTIPOINT Z ((0 9 7),(5 9 7),(9 9 7),(0 5 7),(5 5 7),(9 5 7),(0 0 7),(5 0 7),(9 0 7))");
    elevation_visitor_checker(allocator, "LINESTRING Z (0 0 0, 10 10 10)", "GEOMETRYCOLLECTION Z EMPTY",
        "LINESTRING (1 1, 9 9)",
        "LINESTRING Z (1 1 0,9 9 10)");
    elevation_visitor_checker(allocator, "LINESTRING Z (0 0 0, 10 10 10)", "GEOMETRYCOLLECTION Z EMPTY",
        "POLYGON ((1 9, 9 9, 9 1, 1 1, 1 9))",
        "POLYGON Z ((1 9 5,9 9 10,9 1 5,1 1 0,1 9 5))");
}
TEST_F(TestGeoBin, collect_visitor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    uint32_t ring_num = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, ring_num));
    for (uint32_t i = 0; i < ring_num; i++) {
        ASSERT_EQ(OB_SUCCESS, append_uint32(data, 3));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 181));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 90));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 10));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 20));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 30));
        ASSERT_EQ(OB_SUCCESS, append_double(data, 40));
    }

    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObVertexes vertexes;
    ObGeoVertexCollectVisitor vertex_visitor(vertexes);
    ObLineSegments segments;
    ObGeoSegmentCollectVisitor seg_visitor(&segments);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(vertex_visitor));
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(seg_visitor));

    ASSERT_EQ(6, vertexes.size());
    for (uint32_t i = 0; i < ring_num; i++) {
      ASSERT_EQ(181, vertexes[i * 3].x);
      ASSERT_EQ(90, vertexes[i * 3].y);
      ASSERT_EQ(10, vertexes[i * 3 + 1].x);
      ASSERT_EQ(20, vertexes[i * 3 + 1].y);
      ASSERT_EQ(30, vertexes[i * 3 + 2].x);
      ASSERT_EQ(40, vertexes[i * 3 + 2].y);
    }
    for (uint32_t i = 0; i < segments.segs_.size(); i++) {
      uint32_t start_idx = segments.segs_[i].begin;
      uint32_t end_idx = segments.segs_[i].end;
      std::cout << "linestring(" << i << ": ";
      for (; start_idx <= end_idx; start_idx++) {
        std::cout << segments.verts_[start_idx].x << " " <<  segments.verts_[start_idx].y << ",";
      }
      std::cout << ")" << std::endl;
    }
}


TEST_F(TestGeoBin, linesegments_collect_visitor_poly)
{
    ObArenaAllocator allocator(ObModIds::TEST);
    ObJsonBuffer data(&allocator);

    /*POLYGON((121.48017238084356 31.227565780172494,
               121.48388535915394 31.22429103925363,
               121.48462793947535 31.221579898137527,
               121.48242817125481 31.21807789724289,
               121.47703361713795 31.222376670115178,
               121.48017238084356 31.227565780172494),
              (121.479 31.223,
               121.480 31.2233,
               121.48088 31.2238,
               121.48098 31.2234,
               121.4813 31.223,
               121.479 31.223))*/

    ASSERT_EQ(OB_SUCCESS, append_bo(data));
    ASSERT_EQ(OB_SUCCESS, append_type(data, ObGeoType::POLYGON));
    uint32_t ring_num = 2;
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, ring_num));
    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 6));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48017238084356));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.227565780172494));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48388535915394));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.22429103925363));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48462793947535));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.221579898137527));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48242817125481));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.21807789724289));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.47703361713795));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.222376670115178));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48017238084356));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.227565780172494));

    ASSERT_EQ(OB_SUCCESS, append_uint32(data, 6));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.479));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.223));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.480));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.2233));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48088));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.2238));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.48098));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.2234));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.4813));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.223));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 121.479));
    ASSERT_EQ(OB_SUCCESS, append_double(data, 31.223));

    ObIWkbGeogPolygon iwkb_geog;
    iwkb_geog.set_data(data.string());
    ObLineSegments segments;
    ObGeoSegmentCollectVisitor seg_visitor(&segments);
    ASSERT_EQ(OB_SUCCESS, iwkb_geog.do_visit(seg_visitor));
    for (uint32_t i = 0; i < segments.segs_.size(); i++) {
      uint32_t start_idx = segments.segs_[i].begin;
      uint32_t end_idx = segments.segs_[i].end;
      std::cout << "linestring(" << i << ": ";
      for (; start_idx <= end_idx; start_idx++) {
        std::cout << segments.verts_[start_idx].x << " " <<  segments.verts_[start_idx].y << ",";
      }
      std::cout << ")" << std::endl;
    }
}

} // namespace common
} // namespace oceanbase

int main(int argc, char** argv)
{
  ::testing::InitGoogleTest(&argc, argv);
  system("rm -f test_geo_bin.log");
  OB_LOGGER.set_file_name("test_geo_bin.log");
  OB_LOGGER.set_log_level("DEBUG");
  return RUN_ALL_TESTS();
}