Test that various Standard headers provide iterator range access functions

tests/std/test.lst

@@ -277,6 +277,7 @@ tests\GH_005546_containers_size_type_cast
 tests\GH_005553_regex_character_translation
 tests\GH_005768_pow_accuracy
 tests\GH_005800_stable_sort_large_alignment
+tests\GH_005968_headers_provide_begin_end
 tests\LWG2381_num_get_floating_point
 tests\LWG2510_tag_classes
 tests\LWG2597_complex_branch_cut

tests/std/tests/GH_005968_headers_provide_begin_end/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

tests/std/tests/GH_005968_headers_provide_begin_end/custom_format.py

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import os
+
+from stl.test.format import STLTestFormat, TestStep
+from stl.test.tests import TestType
+
+
+class CustomTestFormat(STLTestFormat):
+    def getBuildSteps(self, test, litConfig, shared):
+        exeSourceDir = os.path.dirname(test.getSourcePath())
+        _, outputBase = test.getTempPaths()
+
+        sourceFiles = []
+        for filename in os.listdir(exeSourceDir):
+            if filename.endswith('.cpp'):
+                sourceFiles.append(os.path.join(exeSourceDir, filename))
+
+        if TestType.COMPILE in test.testType:
+            cmd = [test.cxx, '/c', *sourceFiles, *test.flags, *test.compileFlags]
+        elif TestType.RUN in test.testType:
+            shared.execFile = outputBase + '.exe'
+            cmd = [test.cxx, *sourceFiles, *test.flags, *test.compileFlags, '/Fe' + shared.execFile,
+                   '/link', *test.linkFlags]
+
+        yield TestStep(cmd, shared.execDir, shared.env, False)

tests/std/tests/GH_005968_headers_provide_begin_end/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_matrix.lst

tests/std/tests/GH_005968_headers_provide_begin_end/lit.local.cfg

@@ -0,0 +1,9 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import os
+import site
+site.addsitedir(os.path.dirname(os.path.dirname(__file__)))
+import GH_005968_headers_provide_begin_end.custom_format
+
+config.test_format = GH_005968_headers_provide_begin_end.custom_format.CustomTestFormat()

tests/std/tests/GH_005968_headers_provide_begin_end/shared_test.hpp

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+// Intentionally avoid including anything. Order assumption: shared_test.hpp assumes
+// that the relevant Standard headers have already been included by the .cpp files.
+
+// Test requirements of N5032 [iterator.range]/1.
+
+namespace detail {
+
+    // file test_iterator.cpp uses a non-std container and thus we can't rely on ADL to find begin/end etc.
+    using namespace std;
+
+    // Define minimal metaprogramming tools, avoid including anything
+
+#define DEFINE_CONDITIONAL_CALLER_OF_FREE_MEMBER(free_name, member_name)                                     \
+    template <class T, class = void>                                                                         \
+    struct conditional_caller_of_##free_name {                                                               \
+        constexpr void operator()(T&) {}                                                                     \
+    };                                                                                                       \
+                                                                                                             \
+    template <class T>                                                                                       \
+    struct conditional_caller_of_##free_name<T&, decltype((void) static_cast<T*>(nullptr)->member_name())> { \
+        constexpr auto operator()(T& t) {                                                                    \
+            return free_name(t);                                                                             \
+        }                                                                                                    \
+    };
+
+#define DEFINE_CONDITIONAL_CALLER_OF(name) DEFINE_CONDITIONAL_CALLER_OF_FREE_MEMBER(name, name)
+
+#define CONDITIONALLY_CALL(c, name) conditional_caller_of_##name<decltype(c)>{}(c)
+
+    DEFINE_CONDITIONAL_CALLER_OF(rbegin);
+    DEFINE_CONDITIONAL_CALLER_OF(rend);
+    DEFINE_CONDITIONAL_CALLER_OF(crbegin);
+    DEFINE_CONDITIONAL_CALLER_OF(crend);
+    DEFINE_CONDITIONAL_CALLER_OF(size);
+#if _HAS_CXX20
+    DEFINE_CONDITIONAL_CALLER_OF_FREE_MEMBER(ssize, size); // N5032 [iterator.range]/18
+#endif
+    DEFINE_CONDITIONAL_CALLER_OF(empty);
+    DEFINE_CONDITIONAL_CALLER_OF(data);
+
+    template <class C>
+    void test_free_container_functions(C& c) {
+        (void) begin(c);
+        (void) end(c);
+        (void) cbegin(c);
+        (void) cend(c);
+        CONDITIONALLY_CALL(c, rbegin); // missing e.g. for forward_list
+        CONDITIONALLY_CALL(c, rend); // missing e.g. for forward_list
+        CONDITIONALLY_CALL(c, crbegin); // missing e.g. for forward_list
+        CONDITIONALLY_CALL(c, crend); // missing e.g. for forward_list
+        CONDITIONALLY_CALL(c, size); // missing e.g. for optional
+#if _HAS_CXX20
+        CONDITIONALLY_CALL(c, ssize); // missing e.g. for optional
+#endif
+        CONDITIONALLY_CALL(c, empty); // missing e.g. for valarray
+        CONDITIONALLY_CALL(c, data); // missing e.g. for valarray
+    }
+
+    inline void test_free_array_functions() {
+        int a[]{1, 2, 3};
+
+        (void) begin(a);
+        (void) end(a);
+        (void) cbegin(a);
+        (void) cend(a);
+        (void) rbegin(a);
+        (void) rend(a);
+        (void) crbegin(a);
+        (void) crend(a);
+        (void) size(a);
+#if _HAS_CXX20
+        (void) ssize(a);
+#endif
+        (void) empty(a);
+        (void) data(a);
+    }
+} // namespace detail
+
+template <class C>
+void shared_test(C& c) {
+    detail::test_free_container_functions(c);
+    // as_const from <utility> not required to be available
+    detail::test_free_container_functions(const_cast<const C&>(c));
+
+    detail::test_free_array_functions();
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test.cpp

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+void test_array();
+void test_deque();
+void test_flat_map();
+void test_flat_set();
+void test_forward_list();
+void test_hive();
+void test_inplace_vector();
+void test_iterator();
+void test_list();
+void test_map();
+void test_optional();
+void test_regex();
+void test_set();
+void test_span();
+void test_stacktrace();
+void test_string();
+void test_string_view();
+void test_unordered_map();
+void test_unordered_set();
+void test_valarray();
+void test_vector();
+
+int main() {
+    test_array();
+    test_deque();
+    test_flat_map();
+    test_flat_set();
+    test_forward_list();
+    test_hive();
+    test_inplace_vector();
+    test_iterator();
+    test_list();
+    test_map();
+    test_optional();
+    test_regex();
+    test_set();
+    test_span();
+    test_stacktrace();
+    test_string();
+    test_string_view();
+    test_unordered_map();
+    test_unordered_set();
+    test_valarray();
+    test_vector();
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test_array.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+
+#include "shared_test.hpp"
+
+void test_array() {
+    std::array<int, 3> container{1, 2, 3};
+    shared_test(container);
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test_deque.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <deque>
+
+#include "shared_test.hpp"
+
+void test_deque() {
+    std::deque<int> container{1, 2, 3};
+    shared_test(container);
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_map.cpp

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if defined(__cpp_lib_flat_map)
+static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+
+#include <flat_map>
+
+#include "shared_test.hpp"
+
+void test_flat_map() {
+    {
+        std::flat_map<int, int> container{
+            {1, 5},
+            {3, 7},
+        };
+        shared_test(container);
+    }
+
+    {
+        std::flat_multimap<int, int> container2{
+            {1, 5},
+            {3, 7},
+        };
+        shared_test(container2);
+    }
+}
+
+#else // ^^^ defined(__cpp_lib_flat_map) / !defined(__cpp_lib_flat_map) vvv
+
+void test_flat_map() {}
+
+#endif // ^^^ !defined(__cpp_lib_flat_map) ^^^

tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_set.cpp

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if defined(__cpp_lib_flat_set)
+static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+
+#include <flat_set>
+
+#include "shared_test.hpp"
+
+void test_flat_set() {
+    {
+        std::flat_set<int> container{1, 2, 3};
+        shared_test(container);
+    }
+
+    {
+        std::flat_multiset<int> container2{1, 2, 3};
+        shared_test(container2);
+    }
+}
+
+#else // ^^^ defined(__cpp_lib_flat_set) / !defined(__cpp_lib_flat_set) vvv
+
+void test_flat_set() {}
+
+#endif // ^^^ !defined(__cpp_lib_flat_set) ^^^

tests/std/tests/GH_005968_headers_provide_begin_end/test_forward_list.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <forward_list>
+
+#include "shared_test.hpp"
+
+void test_forward_list() {
+    std::forward_list<int> container{1, 2, 3};
+    shared_test(container);
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test_hive.cpp

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if defined(__cpp_lib_hive)
+static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+
+#include <hive>
+
+#include "shared_test.hpp"
+
+void test_hive() {
+    std::hive<int> container{1, 2, 3};
+    shared_test(container);
+}
+
+#else // ^^^ defined(__cpp_lib_hive) / !defined(__cpp_lib_hive) vvv
+
+void test_hive() {}
+
+#endif // ^^^ !defined(__cpp_lib_hive) ^^^

tests/std/tests/GH_005968_headers_provide_begin_end/test_inplace_vector.cpp

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if defined(__cpp_lib_inplace_vector)
+static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+
+#include <inplace_vector>
+
+#include "shared_test.hpp"
+
+void test_inplace_vector() {
+    std::inplace_vector<int, 3> container{1, 2, 3};
+    shared_test(container);
+}
+
+#else // ^^^ defined(__cpp_lib_inplace_vector) / !defined(__cpp_lib_inplace_vector) vvv
+
+void test_inplace_vector() {}
+
+#endif // ^^^ !defined(__cpp_lib_inplace_vector) ^^^

tests/std/tests/GH_005968_headers_provide_begin_end/test_iterator.cpp

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <iterator>
+
+#include "shared_test.hpp"
+
+struct minimal_container {
+    static constexpr size_t magic_value = 3376942;
+
+    constexpr void begin() const {}
+    constexpr void end() const {}
+    constexpr void cbegin() const {}
+    constexpr void cend() const {}
+    constexpr void rbegin() const {}
+    constexpr void rend() const {}
+    constexpr void crbegin() const {}
+    constexpr void crend() const {}
+    constexpr size_t size() const {
+        return magic_value;
+    }
+    constexpr void empty() const {}
+    constexpr void data() const {}
+};
+
+
+// Self-test the template machinery to check it properly detects member functions
+namespace detail {
+    template <class C>
+    constexpr bool minimal_container_test(C& c) {
+        // when the CONDITIONALLY_CALL expression fails to detect the member, it has type void, i.e. clearly
+        // incompatible with operator==. If the detection mechanism did not work properly, this would fail to compile.
+        return CONDITIONALLY_CALL(c, size) == minimal_container::magic_value;
+    }
+
+    constexpr minimal_container min_cont;
+    static_assert(minimal_container_test(min_cont), "The member detection utility is broken");
+} // namespace detail
+
+void test_iterator() {
+    minimal_container container;
+
+    shared_test(container);
+}

tests/std/tests/GH_005968_headers_provide_begin_end/test_list.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <list>
+
+#include "shared_test.hpp"
+
+void test_list() {
+    std::list<int> container{1, 2, 3};
+    shared_test(container);
+}