280 lines
7.8 KiB
C++
280 lines
7.8 KiB
C++
|
|
#include <test.hpp>
|
|
|
|
#include <vtzero/builder.hpp>
|
|
#include <vtzero/geometry.hpp>
|
|
#include <vtzero/index.hpp>
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
struct point_handler {
|
|
|
|
std::vector<vtzero::point> data;
|
|
|
|
void points_begin(uint32_t count) {
|
|
data.reserve(count);
|
|
}
|
|
|
|
void points_point(const vtzero::point point) {
|
|
data.push_back(point);
|
|
}
|
|
|
|
void points_end() const noexcept {
|
|
}
|
|
|
|
};
|
|
|
|
static void test_point_builder(bool with_id, bool with_prop) {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
|
|
{
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
if (with_id) {
|
|
fbuilder.set_id(17);
|
|
}
|
|
|
|
SECTION("add point using coordinates / property using key/value") {
|
|
fbuilder.add_point(10, 20);
|
|
if (with_prop) {
|
|
fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
|
|
}
|
|
}
|
|
|
|
SECTION("add point using vtzero::point / property using key/value") {
|
|
fbuilder.add_point(vtzero::point{10, 20});
|
|
if (with_prop) {
|
|
fbuilder.add_property("foo", vtzero::encoded_property_value{22});
|
|
}
|
|
}
|
|
|
|
SECTION("add point using mypoint / property using property") {
|
|
vtzero::encoded_property_value pv{3.5};
|
|
vtzero::property p{"foo", vtzero::property_value{pv.data()}};
|
|
fbuilder.add_point(mypoint{10, 20});
|
|
if (with_prop) {
|
|
fbuilder.add_property(p);
|
|
}
|
|
}
|
|
|
|
fbuilder.commit();
|
|
}
|
|
|
|
const std::string data = tbuilder.serialize();
|
|
|
|
vtzero::vector_tile tile{data};
|
|
|
|
auto layer = tile.next_layer();
|
|
REQUIRE(layer.name() == "test");
|
|
REQUIRE(layer.version() == 2);
|
|
REQUIRE(layer.extent() == 4096);
|
|
REQUIRE(layer.num_features() == 1);
|
|
|
|
const auto feature = layer.next_feature();
|
|
REQUIRE(feature.id() == (with_id ? 17 : 0));
|
|
|
|
point_handler handler;
|
|
vtzero::decode_point_geometry(feature.geometry(), handler);
|
|
|
|
const std::vector<vtzero::point> result = {{10, 20}};
|
|
REQUIRE(handler.data == result);
|
|
}
|
|
|
|
TEST_CASE("Point builder without id/without properties") {
|
|
test_point_builder(false, false);
|
|
}
|
|
|
|
TEST_CASE("Point builder without id/with properties") {
|
|
test_point_builder(false, true);
|
|
}
|
|
|
|
TEST_CASE("Point builder with id/without properties") {
|
|
test_point_builder(true, false);
|
|
}
|
|
|
|
TEST_CASE("Point builder with id/with properties") {
|
|
test_point_builder(true, true);
|
|
}
|
|
|
|
TEST_CASE("Calling add_points() with bad values throws assert") {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
SECTION("0") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_points(0), const assert_error&);
|
|
}
|
|
SECTION("2^29") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_points(1ul << 29u), const assert_error&);
|
|
}
|
|
}
|
|
|
|
static void test_multipoint_builder(bool with_id, bool with_prop) {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
if (with_id) {
|
|
fbuilder.set_id(17);
|
|
}
|
|
|
|
fbuilder.add_points(3);
|
|
fbuilder.set_point(10, 20);
|
|
fbuilder.set_point(vtzero::point{20, 30});
|
|
fbuilder.set_point(mypoint{30, 40});
|
|
|
|
if (with_prop) {
|
|
fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
|
|
}
|
|
|
|
fbuilder.commit();
|
|
|
|
const std::string data = tbuilder.serialize();
|
|
|
|
vtzero::vector_tile tile{data};
|
|
|
|
auto layer = tile.next_layer();
|
|
REQUIRE(layer.name() == "test");
|
|
REQUIRE(layer.version() == 2);
|
|
REQUIRE(layer.extent() == 4096);
|
|
REQUIRE(layer.num_features() == 1);
|
|
|
|
const auto feature = layer.next_feature();
|
|
REQUIRE(feature.id() == (with_id ? 17 : 0));
|
|
|
|
point_handler handler;
|
|
vtzero::decode_point_geometry(feature.geometry(), handler);
|
|
|
|
const std::vector<vtzero::point> result = {{10, 20}, {20, 30}, {30, 40}};
|
|
REQUIRE(handler.data == result);
|
|
}
|
|
|
|
|
|
TEST_CASE("Multipoint builder without id/without properties") {
|
|
test_multipoint_builder(false, false);
|
|
}
|
|
|
|
TEST_CASE("Multipoint builder without id/with properties") {
|
|
test_multipoint_builder(false, true);
|
|
}
|
|
|
|
TEST_CASE("Multipoint builder with id/without properties") {
|
|
test_multipoint_builder(true, false);
|
|
}
|
|
|
|
TEST_CASE("Multipoint builder with id/with properties") {
|
|
test_multipoint_builder(true, true);
|
|
}
|
|
|
|
TEST_CASE("Calling add_point() and then other geometry functions throws assert") {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
fbuilder.add_point(10, 20);
|
|
|
|
SECTION("add_point()") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_point(10, 20), const assert_error&);
|
|
}
|
|
SECTION("add_points()") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_points(2), const assert_error&);
|
|
}
|
|
SECTION("set_point()") {
|
|
REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Calling point_feature_builder::set_point() throws assert") {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
|
|
}
|
|
|
|
TEST_CASE("Calling add_points() and then other geometry functions throws assert") {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
fbuilder.add_points(2);
|
|
|
|
SECTION("add_point()") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_point(10, 20), const assert_error&);
|
|
}
|
|
SECTION("add_points()") {
|
|
REQUIRE_THROWS_AS(fbuilder.add_points(2), const assert_error&);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Calling point_feature_builder::set_point() too often throws assert") {
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
fbuilder.add_points(2);
|
|
fbuilder.set_point(10, 20);
|
|
fbuilder.set_point(20, 20);
|
|
REQUIRE_THROWS_AS(fbuilder.set_point(30, 20), const assert_error&);
|
|
}
|
|
|
|
TEST_CASE("Add points from container") {
|
|
const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}};
|
|
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
|
|
{
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
/* SECTION("using iterators") {
|
|
fbuilder.add_points(points.cbegin(), points.cend());
|
|
}
|
|
|
|
SECTION("using iterators and size") {
|
|
fbuilder.add_points(points.cbegin(), points.cend(), static_cast<uint32_t>(points.size()));
|
|
}*/
|
|
|
|
SECTION("using container directly") {
|
|
fbuilder.add_points_from_container(points);
|
|
}
|
|
|
|
fbuilder.commit();
|
|
}
|
|
|
|
const std::string data = tbuilder.serialize();
|
|
|
|
vtzero::vector_tile tile{data};
|
|
|
|
auto layer = tile.next_layer();
|
|
REQUIRE(layer);
|
|
REQUIRE(layer.name() == "test");
|
|
REQUIRE(layer.version() == 2);
|
|
REQUIRE(layer.extent() == 4096);
|
|
REQUIRE(layer.num_features() == 1);
|
|
|
|
const auto feature = layer.next_feature();
|
|
|
|
point_handler handler;
|
|
vtzero::decode_point_geometry(feature.geometry(), handler);
|
|
|
|
REQUIRE(handler.data == points);
|
|
}
|
|
/*
|
|
TEST_CASE("Add points from iterator with wrong count throws assert") {
|
|
const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}};
|
|
|
|
vtzero::tile_builder tbuilder;
|
|
vtzero::layer_builder lbuilder{tbuilder, "test"};
|
|
vtzero::point_feature_builder fbuilder{lbuilder};
|
|
|
|
REQUIRE_THROWS_AS(fbuilder.add_points(points.cbegin(),
|
|
points.cend(),
|
|
static_cast<uint32_t>(points.size() + 1)), const assert_error&);
|
|
}*/
|
|
|