CXX-2745 refactor test directory structure by ABI namespace (#1403)

* test: upgrade Catch2 from 3.7.0 to 3.8.1
* test: restructure test files by ABI namespace
* test: add Catch2 string maker for std::error_condition
* test: add equivalent to Catch::Detail::stringify
* test: extract StringMaker specializations into separate headers
* evg: avoid building example and test targets during CMake compat tasks
* test: add StringMaker test cases for string_view and optional<T>

Author: eramongodb

.clang-format

@@ -161,31 +161,35 @@ IncludeCategories:
   - Regex: 'mongocxx/v1/.*\.hh' # v1 internal headers
     Priority: 27
   - Regex: 'bsoncxx/private/.*' # private headers
-    Priority: 60
+    Priority: 70
   - Regex: 'mongocxx/private/.*' # private headers
-    Priority: 61
+    Priority: 71
   - Regex: 'bsoncxx/config/prelude\.(hpp|hh)' # v_noabi preludes
-    Priority: 62
+    Priority: 72
   - Regex: 'mongocxx/config/prelude\.(hpp|hh)' # v_noabi preludes
-    Priority: 63
+    Priority: 73
+  - Regex: 'bsoncxx/test/(v.*|private)' # library test headers
+    Priority: 30
+  - Regex: 'mongocxx/test/(v.*|private)' # library test headers
+    Priority: 31
   - Regex: 'bsoncxx/test/.*' # test headers
-    Priority: 70
+    Priority: 84
   - Regex: 'mongocxx/test/.*' # test headers
-    Priority: 71
+    Priority: 85
   - Regex: '<[[:alnum:]_.]+>' # system headers
-    Priority: 30
-  - Regex: 'bsoncxx/.*(-|\/)fwd\.(hpp|hh)' # all remaining forward headers
     Priority: 40
+  - Regex: 'bsoncxx/.*(-|\/)fwd\.(hpp|hh)' # all remaining forward headers
+    Priority: 50
   - Regex: 'mongocxx/.*(-|\/)fwd\.(hpp|hh)' # all remaining forward headers
-    Priority: 41
+    Priority: 51
   - Regex: 'bsoncxx/.*\.hpp' # all remaining public headers
-    Priority: 50
+    Priority: 60
   - Regex: 'mongocxx/.*\.hpp' # all remaining public headers
-    Priority: 51
+    Priority: 61
   - Regex: 'bsoncxx/.*\.hh' # all remaining internal headers
-    Priority: 52
+    Priority: 62
   - Regex: 'mongocxx/.*\.hh' # all remaining internal headers
-    Priority: 53
+    Priority: 63
   - Regex: '.*' # all other headers (third party)
     Priority: 90
 IncludeIsMainRegex: '([-_](test|unittest))?$'

.evergreen/scripts/cmake-compat-check.sh

@@ -104,6 +104,9 @@ echo "Importing C++ Driver via add_subdirectory()..."
 cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION:?}.${CMAKE_MINOR_VERSION:?})
 project(cmake-compat)
 
+set(ENABLE_EXAMPLES OFF)
+set(ENABLE_TESTS OFF)
+
 add_subdirectory(mongoc)
 add_subdirectory(mongo-cxx-driver)
 

CHANGELOG.md

@@ -13,6 +13,10 @@ Changes prior to 3.9.0 are documented as [release notes on GitHub](https://githu
 
 - CMake option `ENABLE_TESTS` (`OFF` by default) is no longer overwritten by the auto-downloaded C Driver (`ON` by default) during CMake configuration.
 
+### Changed
+
+- CMake 3.16.0 or newer is required when `ENABLE_TESTS=ON` for compatibility with the updated Catch2 library version (3.7.0 -> 3.8.1).
+
 ## 4.1.0
 
 ### Fixed

cmake/FetchCatch2.cmake

@@ -12,7 +12,7 @@ function(fetch_catch2)
         EP_Catch2
 
         GIT_REPOSITORY https://github.com/catchorg/Catch2
-        GIT_TAG v3.7.0
+        GIT_TAG v3.8.1
         GIT_SHALLOW TRUE
         LOG_DOWNLOAD ON
 

src/bsoncxx/test/CMakeLists.txt

@@ -26,27 +26,49 @@ endif()
 
 target_compile_definitions(bsoncxx_testing PUBLIC BSONCXX_TESTING)
 
-add_executable(test_bson
-    array.cpp
-    bson_b_date.cpp
-    bson_builder.cpp
-    bson_get_values.cpp
-    bson_serialization.cpp
-    bson_types.cpp
-    bson_util_itoa.cpp
-    bson_validate.cpp
-    bson_value.cpp
+set(bsoncxx_test_sources_private
+    private/make_unique.test.cpp
+    private/bson_version.cpp
+)
+
+set(bsoncxx_test_sources_v_noabi
+    v_noabi/array.cpp
+    v_noabi/bson_b_date.cpp
+    v_noabi/bson_builder.cpp
+    v_noabi/bson_get_values.cpp
+    v_noabi/bson_serialization.cpp
+    v_noabi/bson_types.cpp
+    v_noabi/bson_util_itoa.cpp
+    v_noabi/bson_validate.cpp
+    v_noabi/bson_value.cpp
+    v_noabi/json.cpp
+    v_noabi/oid.cpp
+    v_noabi/vector.cpp
+    v_noabi/view_or_value.cpp
+)
+
+set(bsoncxx_test_sources_v1
+    v1/stdx/optional.test.cpp
+    v1/stdx/string_view.test.cpp
+    v1/stdx/type_traits.test.cpp
+)
+
+set(bsoncxx_test_sources
+    ${bsoncxx_test_sources_private}
+    ${bsoncxx_test_sources_v_noabi}
+    ${bsoncxx_test_sources_v1}
     catch.cpp
     exception_guard.cpp
-    json.cpp
-    oid.cpp
-    vector.cpp
-    version.cpp
-    optional.test.cpp
-    view_or_value.cpp
-    make_unique.test.cpp
-    string_view.test.cpp
-    type_traits.test.cpp
+)
+
+file(GLOB_RECURSE bsoncxx_test_headers
+    RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+    CONFIGURE_DEPENDS
+    "*.hh"
+)
+
+add_executable(test_bson
+    ${bsoncxx_test_sources}
 )
 
 # Common target properties for test executables.
@@ -140,28 +162,7 @@ endif()
 
 set_dist_list(src_bsoncxx_test_DIST
     CMakeLists.txt
-    array.cpp
-    bson_b_date.cpp
-    bson_builder.cpp
-    bson_get_values.cpp
-    bson_serialization.cpp
-    bson_types.cpp
-    bson_util_itoa.cpp
-    bson_validate.cpp
-    bson_value.cpp
-    catch.cpp
-    catch.hh
-    exception_guard.cpp
-    exception_guard.hh
-    json.cpp
-    oid.cpp
-    vector.cpp
-    optional.test.cpp
+    ${bsoncxx_test_sources}
+    ${bsoncxx_test_headers}
     test_macro_guards.cpp.in
-    to_string.hh
-    view_or_value.cpp
-    version.cpp
-    make_unique.test.cpp
-    string_view.test.cpp
-    type_traits.test.cpp
 )

src/bsoncxx/test/catch.hh

@@ -16,56 +16,24 @@
 
 #include <bsoncxx/v1/detail/macros.hpp>
 
+#include <bsoncxx/test/v1/stdx/optional.hh>
+#include <bsoncxx/test/v1/stdx/string_view.hh>
+#include <bsoncxx/test/v_noabi/to_string.hh>
+
 #include <bsoncxx/document/view_or_value.hpp>
 #include <bsoncxx/json.hpp>
 #include <bsoncxx/oid.hpp>
 #include <bsoncxx/stdx/operators.hpp>
 #include <bsoncxx/stdx/optional.hpp>
 
-#include <bsoncxx/test/to_string.hh>
+#include <bsoncxx/test/stringify.hh>
+#include <bsoncxx/test/system_error.hh>
 
 #include <catch2/catch_test_macros.hpp> // TEST_CASE, SECTION, CHECK, etc.
 #include <catch2/catch_tostring.hpp>    // Catch::StringMaker
 
-#define THROWS_WITH_CODE_IMPL(_assertion, _expr, _code)                               \
-    if (1) {                                                                          \
-        try {                                                                         \
-            (void)(_expr);                                                            \
-            INFO("expected an exception to be thrown: " #_expr);                      \
-            _assertion(false);                                                        \
-        } catch (Catch::TestFailureException const&) {                                \
-            throw; /* Propagate Catch exceptions. */                                  \
-        } catch (Catch::TestSkipException const&) {                                   \
-            throw; /* Propagate Catch exceptions. */                                  \
-        } catch (std::system_error const& ex) {                                       \
-            using std::make_error_code;                                               \
-            (void)ex; /* Avoid unused variable warnings. */                           \
-            _assertion(ex.code() == (_code));                                         \
-        } catch (...) {                                                               \
-            /* Reuse `*_THROWS_AS` to handle the unexpected exception type. */        \
-            BSONCXX_PRIVATE_CONCAT(_assertion, _THROWS_AS)(throw, std::system_error); \
-        }                                                                             \
-    } else                                                                            \
-        ((void)0)
-
-#define CHECK_THROWS_WITH_CODE(_expr, _code) THROWS_WITH_CODE_IMPL(CHECK, _expr, _code)
-#define REQUIRE_THROWS_WITH_CODE(_expr, _code) THROWS_WITH_CODE_IMPL(REQUIRE, _expr, _code)
-
 namespace Catch {
 
-template <>
-struct StringMaker<std::error_condition> {
-    static std::string convert(std::error_condition const& value) {
-        std::string res;
-
-        res += value.category().name();
-        res += ':';
-        res += Catch::StringMaker<int>::convert(value.value());
-
-        return res;
-    }
-};
-
 template <>
 struct StringMaker<bsoncxx::oid> {
     static std::string convert(bsoncxx::oid const& value) {
@@ -83,14 +51,14 @@ struct StringMaker<bsoncxx::document::view> {
 template <>
 struct StringMaker<bsoncxx::document::view_or_value> {
     static std::string convert(bsoncxx::document::view_or_value const& value) {
-        return StringMaker<bsoncxx::document::view>::convert(value.view());
+        return bsoncxx::test::stringify(value.view());
     }
 };
 
 template <>
 struct StringMaker<bsoncxx::document::value> {
     static std::string convert(bsoncxx::document::value const& value) {
-        return StringMaker<bsoncxx::document::view>::convert(value.view());
+        return bsoncxx::test::stringify(value.view());
     }
 };
 
@@ -105,32 +73,14 @@ struct StringMaker<bsoncxx::types::bson_value::view> {
 template <>
 struct StringMaker<bsoncxx::types::bson_value::value> {
     static std::string convert(bsoncxx::types::bson_value::value const& value) {
-        return StringMaker<bsoncxx::types::bson_value::view>::convert(value.view());
+        return bsoncxx::test::stringify(value.view());
     }
 };
 
 template <>
 struct StringMaker<bsoncxx::types::bson_value::view_or_value> {
     static std::string convert(bsoncxx::types::bson_value::view_or_value const& value) {
-        return StringMaker<bsoncxx::types::bson_value::view>::convert(value.view());
-    }
-};
-
-template <typename T>
-struct StringMaker<bsoncxx::stdx::optional<T>> {
-    static std::string convert(bsoncxx::stdx::optional<T> const& value) {
-        if (value) {
-            return StringMaker<T>::convert(value.value());
-        }
-
-        return "{nullopt}";
-    }
-};
-
-template <>
-struct StringMaker<bsoncxx::stdx::optional<bsoncxx::stdx::nullopt_t>> {
-    static std::string convert(bsoncxx::stdx::optional<bsoncxx::stdx::nullopt_t> const&) {
-        return "{nullopt}";
+        return bsoncxx::test::stringify(value.view());
     }
 };
 

src/bsoncxx/test/version.cpp renamed to src/bsoncxx/test/private/bson_version.cpp

@@ -0,0 +1,33 @@
+// Copyright 2009-present MongoDB, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <string>
+#include <type_traits>
+
+#include <catch2/catch_tostring.hpp>
+
+namespace bsoncxx {
+namespace test {
+
+// Equivalent to `Catch::Detail::stringify`.
+template <typename Param>
+std::string stringify(Param const& param) {
+    using T = typename std::remove_cv<typename std::remove_reference<Param>::type>::type;
+    return Catch::StringMaker<T>::convert(param);
+}
+
+} // namespace test
+} // namespace bsoncxx

src/bsoncxx/test/make_unique.test.cpp renamed to src/bsoncxx/test/private/make_unique.test.cpp

@@ -0,0 +1,68 @@
+// Copyright 2009-present MongoDB, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <bsoncxx/v1/detail/macros.hpp>
+
+#include <system_error>
+
+#include <bsoncxx/test/stringify.hh>
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_tostring.hpp>
+
+#define THROWS_WITH_CODE_IMPL(_assertion, _expr, _code)                               \
+    if (1) {                                                                          \
+        try {                                                                         \
+            (void)(_expr);                                                            \
+            INFO("expected an exception to be thrown: " #_expr);                      \
+            _assertion(false);                                                        \
+        } catch (Catch::TestFailureException const&) {                                \
+            throw; /* Propagate Catch exceptions. */                                  \
+        } catch (Catch::TestSkipException const&) {                                   \
+            throw; /* Propagate Catch exceptions. */                                  \
+        } catch (std::system_error const& ex) {                                       \
+            using std::make_error_code;                                               \
+            (void)ex; /* Avoid unused variable warnings. */                           \
+            _assertion(ex.code() == (_code));                                         \
+        } catch (...) {                                                               \
+            /* Reuse `*_THROWS_AS` to handle the unexpected exception type. */        \
+            BSONCXX_PRIVATE_CONCAT(_assertion, _THROWS_AS)(throw, std::system_error); \
+        }                                                                             \
+    } else                                                                            \
+        ((void)0)
+
+#define CHECK_THROWS_WITH_CODE(_expr, _code) THROWS_WITH_CODE_IMPL(CHECK, _expr, _code)
+#define REQUIRE_THROWS_WITH_CODE(_expr, _code) THROWS_WITH_CODE_IMPL(REQUIRE, _expr, _code)
+
+template <>
+struct Catch::StringMaker<std::error_category> {
+    static std::string convert(std::error_category const& value) {
+        return value.name();
+    }
+};
+
+template <>
+struct Catch::StringMaker<std::error_condition> {
+    static std::string convert(std::error_condition const& value) {
+        std::string res;
+
+        res += value.category().name();
+        res += ':';
+        res += bsoncxx::test::stringify(value.value());
+
+        return res;
+    }
+};