Mark more tests as NoDB

joto · joto · commit dd36e43c7297 · 2020-12-12T15:17:18.000+01:00
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -38,7 +38,7 @@ add_definitions(-DOSM2PGSQLDATA_DIR=\"${osm2pgsql_SOURCE_DIR}/\")
 
 add_library(catch_main_lib STATIC catch-main.cpp)
 
-set_test(test-check-input)
+set_test(test-check-input LABELS NoDB)
 set_test(test-db-copy-thread)
 set_test(test-db-copy-mgr)
 set_test(test-domain-matcher LABELS NoDB)
diff --git a/tests/test-check-input.cpp b/tests/test-check-input.cpp
@@ -2,7 +2,7 @@
 
 #include "input.hpp"
 
-TEST_CASE("it's good if input data is ordered")
+TEST_CASE("it's good if input data is ordered", "[NoDB]")
 {
     type_id_version const tiv1{osmium::item_type::node, 1, 1};
     type_id_version const tiv2{osmium::item_type::node, 1, 2};
@@ -20,7 +20,7 @@ TEST_CASE("it's good if input data is ordered")
     REQUIRE_NOTHROW(check_input(tiv6, tiv7));
 }
 
-TEST_CASE("negative OSM object ids are not allowed")
+TEST_CASE("negative OSM object ids are not allowed", "[NoDB]")
 {
     type_id_version const tivn{osmium::item_type::node, -17, 1};
     type_id_version const tivw{osmium::item_type::way, -1, 1};
@@ -36,7 +36,7 @@ TEST_CASE("negative OSM object ids are not allowed")
         "Negative OSM object ids are not allowed: relation id -999.");
 }
 
-TEST_CASE("objects of the same type must be ordered")
+TEST_CASE("objects of the same type must be ordered", "[NoDB]")
 {
     type_id_version const tiv1{osmium::item_type::node, 42, 1};
     type_id_version const tiv2{osmium::item_type::node, 3, 1};
@@ -45,7 +45,7 @@ TEST_CASE("objects of the same type must be ordered")
                         "Input data is not ordered: node id 3 after 42.");
 }
 
-TEST_CASE("a node after a way or relation is not allowed")
+TEST_CASE("a node after a way or relation is not allowed", "[NoDB]")
 {
     type_id_version const tiv1w{osmium::item_type::way, 42, 1};
     type_id_version const tiv1r{osmium::item_type::relation, 42, 1};
@@ -57,7 +57,7 @@ TEST_CASE("a node after a way or relation is not allowed")
                         "Input data is not ordered: node after relation.");
 }
 
-TEST_CASE("a way after a relation is not allowed")
+TEST_CASE("a way after a relation is not allowed", "[NoDB]")
 {
     type_id_version const tiv1{osmium::item_type::relation, 42, 1};
     type_id_version const tiv2{osmium::item_type::way, 100, 1};
@@ -66,7 +66,7 @@ TEST_CASE("a way after a relation is not allowed")
                         "Input data is not ordered: way after relation.");
 }
 
-TEST_CASE("versions must be ordered")
+TEST_CASE("versions must be ordered", "[NoDB]")
 {
     type_id_version const tiv1{osmium::item_type::way, 42, 2};
     type_id_version const tiv2{osmium::item_type::way, 42, 1};
diff --git a/tests/test-domain-matcher.cpp b/tests/test-domain-matcher.cpp
@@ -20,7 +20,7 @@ static osmium::Tag &fill_buffer(osmium::memory::Buffer &buffer, char const *key,
     return *buffer.get<osmium::TagList>(0).begin();
 }
 
-TEST_CASE("DomainMatcher: name")
+TEST_CASE("DomainMatcher: name", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
@@ -32,7 +32,7 @@ TEST_CASE("DomainMatcher: name")
     REQUIRE(std::strcmp(result, "name") == 0);
 }
 
-TEST_CASE("DomainMatcher: name with language")
+TEST_CASE("DomainMatcher: name with language", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
@@ -45,7 +45,7 @@ TEST_CASE("DomainMatcher: name with language")
     REQUIRE(std::strcmp(result, "name:en") == 0);
 }
 
-TEST_CASE("DomainMatcher: no :name")
+TEST_CASE("DomainMatcher: no :name", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
@@ -56,7 +56,7 @@ TEST_CASE("DomainMatcher: no :name")
     REQUIRE_FALSE(result);
 }
 
-TEST_CASE("DomainMatcher: empty matcher")
+TEST_CASE("DomainMatcher: empty matcher", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{""};
@@ -68,7 +68,7 @@ TEST_CASE("DomainMatcher: empty matcher")
     REQUIRE_FALSE(result);
 }
 
-TEST_CASE("DomainMatcher: names")
+TEST_CASE("DomainMatcher: names", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
@@ -80,7 +80,7 @@ TEST_CASE("DomainMatcher: names")
     REQUIRE_FALSE(result);
 }
 
-TEST_CASE("DomainMatcher: not matching")
+TEST_CASE("DomainMatcher: not matching", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
@@ -91,7 +91,7 @@ TEST_CASE("DomainMatcher: not matching")
     REQUIRE_FALSE(result);
 }
 
-TEST_CASE("DomainMatcher: empty tag")
+TEST_CASE("DomainMatcher: empty tag", "[NoDB]")
 {
     osmium::memory::Buffer buffer{1024};
     DomainMatcher matcher{"bridge"};
diff --git a/tests/test-taginfo.cpp b/tests/test-taginfo.cpp
@@ -3,7 +3,7 @@
 
 #include "taginfo-impl.hpp"
 
-TEST_CASE("parse_tag_flags")
+TEST_CASE("parse_tag_flags", "[NoDB]")
 {
     CHECK(parse_tag_flags("", 0) == 0);
     CHECK(parse_tag_flags("polygon", 0) == FLAG_POLYGON);
diff --git a/tests/test-util.cpp b/tests/test-util.cpp
@@ -5,37 +5,37 @@
 #include <cstring>
 #include <limits>
 
-TEST_CASE("integer_to_buffer 1")
+TEST_CASE("integer_to_buffer 1", "[NoDB]")
 {
     util::integer_to_buffer buffer{1};
     REQUIRE(std::strcmp(buffer.c_str(), "1") == 0);
 }
 
-TEST_CASE("integer_to_buffer max")
+TEST_CASE("integer_to_buffer max", "[NoDB]")
 {
     util::integer_to_buffer buffer{std::numeric_limits<osmid_t>::max()};
     REQUIRE(std::strcmp(buffer.c_str(), "9223372036854775807") == 0);
 }
 
-TEST_CASE("integer_to_buffer min")
+TEST_CASE("integer_to_buffer min", "[NoDB]")
 {
     util::integer_to_buffer buffer{std::numeric_limits<osmid_t>::min()};
     REQUIRE(std::strcmp(buffer.c_str(), "-9223372036854775808") == 0);
 }
 
-TEST_CASE("double_to_buffer 0")
+TEST_CASE("double_to_buffer 0", "[NoDB]")
 {
     util::double_to_buffer buffer{0.0};
     REQUIRE(std::strcmp(buffer.c_str(), "0") == 0);
 }
 
-TEST_CASE("double_to_buffer 3.141")
+TEST_CASE("double_to_buffer 3.141", "[NoDB]")
 {
     util::double_to_buffer buffer{3.141};
     REQUIRE(std::strcmp(buffer.c_str(), "3.141") == 0);
 }
 
-TEST_CASE("human readable time durations")
+TEST_CASE("human readable time durations", "[NoDB]")
 {
     REQUIRE(util::human_readable_duration(0) == "0s");
     REQUIRE(util::human_readable_duration(17) == "17s");

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "input.hpp"`
`4`	`4`
`5`		`-TEST_CASE("it's good if input data is ordered")`
	`5`	`+TEST_CASE("it's good if input data is ordered", "[NoDB]")`
`6`	`6`	`{`
`7`	`7`	`type_id_version const tiv1{osmium::item_type::node, 1, 1};`
`8`	`8`	`type_id_version const tiv2{osmium::item_type::node, 1, 2};`
`@@ -20,7 +20,7 @@ TEST_CASE("it's good if input data is ordered")`
`20`	`20`	`REQUIRE_NOTHROW(check_input(tiv6, tiv7));`
`21`	`21`	`}`
`22`	`22`
`23`		`-TEST_CASE("negative OSM object ids are not allowed")`
	`23`	`+TEST_CASE("negative OSM object ids are not allowed", "[NoDB]")`
`24`	`24`	`{`
`25`	`25`	`type_id_version const tivn{osmium::item_type::node, -17, 1};`
`26`	`26`	`type_id_version const tivw{osmium::item_type::way, -1, 1};`
`@@ -36,7 +36,7 @@ TEST_CASE("negative OSM object ids are not allowed")`
`36`	`36`	`"Negative OSM object ids are not allowed: relation id -999.");`
`37`	`37`	`}`
`38`	`38`
`39`		`-TEST_CASE("objects of the same type must be ordered")`
	`39`	`+TEST_CASE("objects of the same type must be ordered", "[NoDB]")`
`40`	`40`	`{`
`41`	`41`	`type_id_version const tiv1{osmium::item_type::node, 42, 1};`
`42`	`42`	`type_id_version const tiv2{osmium::item_type::node, 3, 1};`
`@@ -45,7 +45,7 @@ TEST_CASE("objects of the same type must be ordered")`
`45`	`45`	`"Input data is not ordered: node id 3 after 42.");`
`46`	`46`	`}`
`47`	`47`
`48`		`-TEST_CASE("a node after a way or relation is not allowed")`
	`48`	`+TEST_CASE("a node after a way or relation is not allowed", "[NoDB]")`
`49`	`49`	`{`
`50`	`50`	`type_id_version const tiv1w{osmium::item_type::way, 42, 1};`
`51`	`51`	`type_id_version const tiv1r{osmium::item_type::relation, 42, 1};`
`@@ -57,7 +57,7 @@ TEST_CASE("a node after a way or relation is not allowed")`
`57`	`57`	`"Input data is not ordered: node after relation.");`
`58`	`58`	`}`
`59`	`59`
`60`		`-TEST_CASE("a way after a relation is not allowed")`
	`60`	`+TEST_CASE("a way after a relation is not allowed", "[NoDB]")`
`61`	`61`	`{`
`62`	`62`	`type_id_version const tiv1{osmium::item_type::relation, 42, 1};`
`63`	`63`	`type_id_version const tiv2{osmium::item_type::way, 100, 1};`
`@@ -66,7 +66,7 @@ TEST_CASE("a way after a relation is not allowed")`
`66`	`66`	`"Input data is not ordered: way after relation.");`
`67`	`67`	`}`
`68`	`68`
`69`		`-TEST_CASE("versions must be ordered")`
	`69`	`+TEST_CASE("versions must be ordered", "[NoDB]")`
`70`	`70`	`{`
`71`	`71`	`type_id_version const tiv1{osmium::item_type::way, 42, 2};`
`72`	`72`	`type_id_version const tiv2{osmium::item_type::way, 42, 1};`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ static osmium::Tag &fill_buffer(osmium::memory::Buffer &buffer, char const *key,`
`20`	`20`	`return *buffer.get<osmium::TagList>(0).begin();`
`21`	`21`	`}`
`22`	`22`
`23`		`-TEST_CASE("DomainMatcher: name")`
	`23`	`+TEST_CASE("DomainMatcher: name", "[NoDB]")`
`24`	`24`	`{`
`25`	`25`	`osmium::memory::Buffer buffer{1024};`
`26`	`26`	`DomainMatcher matcher{"bridge"};`
`@@ -32,7 +32,7 @@ TEST_CASE("DomainMatcher: name")`
`32`	`32`	`REQUIRE(std::strcmp(result, "name") == 0);`
`33`	`33`	`}`
`34`	`34`
`35`		`-TEST_CASE("DomainMatcher: name with language")`
	`35`	`+TEST_CASE("DomainMatcher: name with language", "[NoDB]")`
`36`	`36`	`{`
`37`	`37`	`osmium::memory::Buffer buffer{1024};`
`38`	`38`	`DomainMatcher matcher{"bridge"};`
`@@ -45,7 +45,7 @@ TEST_CASE("DomainMatcher: name with language")`
`45`	`45`	`REQUIRE(std::strcmp(result, "name:en") == 0);`
`46`	`46`	`}`
`47`	`47`
`48`		`-TEST_CASE("DomainMatcher: no :name")`
	`48`	`+TEST_CASE("DomainMatcher: no :name", "[NoDB]")`
`49`	`49`	`{`
`50`	`50`	`osmium::memory::Buffer buffer{1024};`
`51`	`51`	`DomainMatcher matcher{"bridge"};`
`@@ -56,7 +56,7 @@ TEST_CASE("DomainMatcher: no :name")`
`56`	`56`	`REQUIRE_FALSE(result);`
`57`	`57`	`}`
`58`	`58`
`59`		`-TEST_CASE("DomainMatcher: empty matcher")`
	`59`	`+TEST_CASE("DomainMatcher: empty matcher", "[NoDB]")`
`60`	`60`	`{`
`61`	`61`	`osmium::memory::Buffer buffer{1024};`
`62`	`62`	`DomainMatcher matcher{""};`
`@@ -68,7 +68,7 @@ TEST_CASE("DomainMatcher: empty matcher")`
`68`	`68`	`REQUIRE_FALSE(result);`
`69`	`69`	`}`
`70`	`70`
`71`		`-TEST_CASE("DomainMatcher: names")`
	`71`	`+TEST_CASE("DomainMatcher: names", "[NoDB]")`
`72`	`72`	`{`
`73`	`73`	`osmium::memory::Buffer buffer{1024};`
`74`	`74`	`DomainMatcher matcher{"bridge"};`
`@@ -80,7 +80,7 @@ TEST_CASE("DomainMatcher: names")`
`80`	`80`	`REQUIRE_FALSE(result);`
`81`	`81`	`}`
`82`	`82`
`83`		`-TEST_CASE("DomainMatcher: not matching")`
	`83`	`+TEST_CASE("DomainMatcher: not matching", "[NoDB]")`
`84`	`84`	`{`
`85`	`85`	`osmium::memory::Buffer buffer{1024};`
`86`	`86`	`DomainMatcher matcher{"bridge"};`
`@@ -91,7 +91,7 @@ TEST_CASE("DomainMatcher: not matching")`
`91`	`91`	`REQUIRE_FALSE(result);`
`92`	`92`	`}`
`93`	`93`
`94`		`-TEST_CASE("DomainMatcher: empty tag")`
	`94`	`+TEST_CASE("DomainMatcher: empty tag", "[NoDB]")`
`95`	`95`	`{`
`96`	`96`	`osmium::memory::Buffer buffer{1024};`
`97`	`97`	`DomainMatcher matcher{"bridge"};`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`#include "taginfo-impl.hpp"`
`5`	`5`
`6`		`-TEST_CASE("parse_tag_flags")`
	`6`	`+TEST_CASE("parse_tag_flags", "[NoDB]")`
`7`	`7`	`{`
`8`	`8`	`CHECK(parse_tag_flags("", 0) == 0);`
`9`	`9`	`CHECK(parse_tag_flags("polygon", 0) == FLAG_POLYGON);`
Original file line number	Diff line number	Diff line change
`@@ -5,37 +5,37 @@`
`5`	`5`	`#include <cstring>`
`6`	`6`	`#include <limits>`
`7`	`7`
`8`		`-TEST_CASE("integer_to_buffer 1")`
	`8`	`+TEST_CASE("integer_to_buffer 1", "[NoDB]")`
`9`	`9`	`{`
`10`	`10`	`util::integer_to_buffer buffer{1};`
`11`	`11`	`REQUIRE(std::strcmp(buffer.c_str(), "1") == 0);`
`12`	`12`	`}`
`13`	`13`
`14`		`-TEST_CASE("integer_to_buffer max")`
	`14`	`+TEST_CASE("integer_to_buffer max", "[NoDB]")`
`15`	`15`	`{`
`16`	`16`	`util::integer_to_buffer buffer{std::numeric_limits<osmid_t>::max()};`
`17`	`17`	`REQUIRE(std::strcmp(buffer.c_str(), "9223372036854775807") == 0);`
`18`	`18`	`}`
`19`	`19`
`20`		`-TEST_CASE("integer_to_buffer min")`
	`20`	`+TEST_CASE("integer_to_buffer min", "[NoDB]")`
`21`	`21`	`{`
`22`	`22`	`util::integer_to_buffer buffer{std::numeric_limits<osmid_t>::min()};`
`23`	`23`	`REQUIRE(std::strcmp(buffer.c_str(), "-9223372036854775808") == 0);`
`24`	`24`	`}`
`25`	`25`
`26`		`-TEST_CASE("double_to_buffer 0")`
	`26`	`+TEST_CASE("double_to_buffer 0", "[NoDB]")`
`27`	`27`	`{`
`28`	`28`	`util::double_to_buffer buffer{0.0};`
`29`	`29`	`REQUIRE(std::strcmp(buffer.c_str(), "0") == 0);`
`30`	`30`	`}`
`31`	`31`
`32`		`-TEST_CASE("double_to_buffer 3.141")`
	`32`	`+TEST_CASE("double_to_buffer 3.141", "[NoDB]")`
`33`	`33`	`{`
`34`	`34`	`util::double_to_buffer buffer{3.141};`
`35`	`35`	`REQUIRE(std::strcmp(buffer.c_str(), "3.141") == 0);`
`36`	`36`	`}`
`37`	`37`
`38`		`-TEST_CASE("human readable time durations")`
	`38`	`+TEST_CASE("human readable time durations", "[NoDB]")`
`39`	`39`	`{`
`40`	`40`	`REQUIRE(util::human_readable_duration(0) == "0s");`
`41`	`41`	`REQUIRE(util::human_readable_duration(17) == "17s");`