diff --git a/libcxx/test/std/iterators/iterator.range/begin-end.compile.fail.cpp b/libcxx/test/std/iterators/iterator.range/begin-end.compile.fail.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/begin-end.compile.fail.cpp +++ /dev/null @@ -1,52 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "test_macros.h" - -#if TEST_STD_VER < 11 -#error -#else - -// -// template auto begin(C& c) -> decltype(c.begin()); -// template auto begin(const C& c) -> decltype(c.begin()); -// template auto end(C& c) -> decltype(c.end()); -// template auto end(const C& c) -> decltype(c.end()); -// template reverse_iterator rbegin(initializer_list il); -// template reverse_iterator rend(initializer_list il); - - -#include -#include - -namespace Foo { - struct FakeContainer {}; - typedef int FakeIter; - - FakeIter begin(const FakeContainer &) { return 1; } - FakeIter end (const FakeContainer &) { return 2; } - FakeIter rbegin(const FakeContainer &) { return 3; } - FakeIter rend (const FakeContainer &) { return 4; } - - FakeIter cbegin(const FakeContainer &) { return 11; } - FakeIter cend (const FakeContainer &) { return 12; } - FakeIter crbegin(const FakeContainer &) { return 13; } - FakeIter crend (const FakeContainer &) { return 14; } -} - - -int main(int, char**) { -// Bug #28927 - shouldn't find these via ADL - TEST_IGNORE_NODISCARD std::cbegin (Foo::FakeContainer()); - TEST_IGNORE_NODISCARD std::cend (Foo::FakeContainer()); - TEST_IGNORE_NODISCARD std::crbegin(Foo::FakeContainer()); - TEST_IGNORE_NODISCARD std::crend (Foo::FakeContainer()); - - return 0; -} -#endif diff --git a/libcxx/test/std/iterators/iterator.range/begin-end.pass.cpp b/libcxx/test/std/iterators/iterator.range/begin-end.pass.cpp --- a/libcxx/test/std/iterators/iterator.range/begin-end.pass.cpp +++ b/libcxx/test/std/iterators/iterator.range/begin-end.pass.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -// XFAIL: c++03 +// UNSUPPORTED: c++03 // // template constexpr auto begin(C& c) -> decltype(c.begin()); @@ -29,169 +29,253 @@ // // All of these are constexpr in C++17 -#include "test_macros.h" - -#include -#include -#include #include -#include +#include #include +#include +#include +#include -template -void test_const_container( const C & c, typename C::value_type val ) { - assert ( std::begin(c) == c.begin()); - assert (*std::begin(c) == val ); - assert ( std::begin(c) != c.end()); - assert ( std::end(c) == c.end()); +#include "test_macros.h" + +// Throughout this test, we consistently compare against c.begin() instead of c.cbegin() +// because some STL types (e.g. initializer_list) don't syntactically support il.cbegin(). +// Note that std::cbegin(x) effectively calls std::as_const(x).begin(), not x.cbegin(); +// see the ContainerHijacker test case below. + +TEST_CONSTEXPR_CXX14 bool test_arrays_and_initializer_lists_forward() +{ + { + int a[] = {1, 2, 3}; + ASSERT_SAME_TYPE(decltype(std::begin(a)), int*); + ASSERT_SAME_TYPE(decltype(std::end(a)), int*); + assert(std::begin(a) == a); + assert(std::end(a) == a + 3); +#if TEST_STD_VER > 11 + ASSERT_SAME_TYPE(decltype(std::cbegin(a)), const int*); + ASSERT_SAME_TYPE(decltype(std::cend(a)), const int*); + assert(std::cbegin(a) == a); + assert(std::cend(a) == a + 3); +#endif + + const auto& ca = a; + ASSERT_SAME_TYPE(decltype(std::begin(ca)), const int*); + ASSERT_SAME_TYPE(decltype(std::end(ca)), const int*); + assert(std::begin(ca) == a); + assert(std::end(ca) == a + 3); +#if TEST_STD_VER > 11 + ASSERT_SAME_TYPE(decltype(std::cbegin(ca)), const int*); + ASSERT_SAME_TYPE(decltype(std::cend(ca)), const int*); + assert(std::cbegin(ca) == a); + assert(std::cend(ca) == a + 3); +#endif + } + { + std::initializer_list il = {1, 2, 3}; + ASSERT_SAME_TYPE(decltype(std::begin(il)), const int*); + ASSERT_SAME_TYPE(decltype(std::end(il)), const int*); + assert(std::begin(il) == il.begin()); + assert(std::end(il) == il.end()); #if TEST_STD_VER > 11 - assert ( std::cbegin(c) == c.cbegin()); - assert ( std::cbegin(c) != c.cend()); - assert ( std::cend(c) == c.cend()); - assert ( std::rbegin(c) == c.rbegin()); - assert ( std::rbegin(c) != c.rend()); - assert ( std::rend(c) == c.rend()); - assert ( std::crbegin(c) == c.crbegin()); - assert ( std::crbegin(c) != c.crend()); - assert ( std::crend(c) == c.crend()); + ASSERT_SAME_TYPE(decltype(std::cbegin(il)), const int*); + ASSERT_SAME_TYPE(decltype(std::cend(il)), const int*); + assert(std::cbegin(il) == il.begin()); + assert(std::cend(il) == il.end()); #endif - } - -template -void test_const_container( const std::initializer_list & c, T val ) { - assert ( std::begin(c) == c.begin()); - assert (*std::begin(c) == val ); - assert ( std::begin(c) != c.end()); - assert ( std::end(c) == c.end()); + + const auto& cil = il; + ASSERT_SAME_TYPE(decltype(std::begin(cil)), const int*); + ASSERT_SAME_TYPE(decltype(std::end(cil)), const int*); + assert(std::begin(cil) == il.begin()); + assert(std::end(cil) == il.end()); +#if TEST_STD_VER > 11 + ASSERT_SAME_TYPE(decltype(std::cbegin(cil)), const int*); + ASSERT_SAME_TYPE(decltype(std::cend(cil)), const int*); + assert(std::cbegin(cil) == il.begin()); + assert(std::cend(cil) == il.end()); +#endif + } + return true; +} + #if TEST_STD_VER > 11 -// initializer_list doesn't have cbegin/cend/rbegin/rend -// but std::cbegin(),etc work (b/c they're general fn templates) -// assert ( std::cbegin(c) == c.cbegin()); -// assert ( std::cbegin(c) != c.cend()); -// assert ( std::cend(c) == c.cend()); -// assert ( std::rbegin(c) == c.rbegin()); -// assert ( std::rbegin(c) != c.rend()); -// assert ( std::rend(c) == c.rend()); -// assert ( std::crbegin(c) == c.crbegin()); -// assert ( std::crbegin(c) != c.crend()); -// assert ( std::crend(c) == c.crend()); +TEST_CONSTEXPR_CXX17 bool test_arrays_and_initializer_lists_backward() +{ + { + int a[] = {1, 2, 3}; + ASSERT_SAME_TYPE(decltype(std::rbegin(a)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(a)), std::reverse_iterator); + assert(std::rbegin(a).base() == a + 3); + assert(std::rend(a).base() == a); + ASSERT_SAME_TYPE(decltype(std::crbegin(a)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(a)), std::reverse_iterator); + assert(std::crbegin(a).base() == a + 3); + assert(std::crend(a).base() == a); + + const auto& ca = a; + ASSERT_SAME_TYPE(decltype(std::rbegin(ca)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(ca)), std::reverse_iterator); + assert(std::rbegin(ca).base() == a + 3); + assert(std::rend(ca).base() == a); + ASSERT_SAME_TYPE(decltype(std::crbegin(ca)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(ca)), std::reverse_iterator); + assert(std::crbegin(ca).base() == a + 3); + assert(std::crend(ca).base() == a); + } + { + std::initializer_list il = {1, 2, 3}; + ASSERT_SAME_TYPE(decltype(std::rbegin(il)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(il)), std::reverse_iterator); + assert(std::rbegin(il).base() == il.end()); + assert(std::rend(il).base() == il.begin()); + ASSERT_SAME_TYPE(decltype(std::crbegin(il)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(il)), std::reverse_iterator); + assert(std::crbegin(il).base() == il.end()); + assert(std::crend(il).base() == il.begin()); + + const auto& cil = il; + ASSERT_SAME_TYPE(decltype(std::rbegin(cil)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(cil)), std::reverse_iterator); + assert(std::rbegin(cil).base() == il.end()); + assert(std::rend(cil).base() == il.begin()); + ASSERT_SAME_TYPE(decltype(std::crbegin(cil)), std::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(cil)), std::reverse_iterator); + assert(std::crbegin(cil).base() == il.end()); + assert(std::crend(cil).base() == il.begin()); + } + return true; +} #endif - } template -void test_container( C & c, typename C::value_type val ) { - assert ( std::begin(c) == c.begin()); - assert (*std::begin(c) == val ); - assert ( std::begin(c) != c.end()); - assert ( std::end(c) == c.end()); +TEST_CONSTEXPR_CXX14 bool test_container() { + C c = {1, 2, 3}; + ASSERT_SAME_TYPE(decltype(std::begin(c)), typename C::iterator); + ASSERT_SAME_TYPE(decltype(std::end(c)), typename C::iterator); + assert(std::begin(c) == c.begin()); + assert(std::end(c) == c.end()); #if TEST_STD_VER > 11 - assert ( std::cbegin(c) == c.cbegin()); - assert ( std::cbegin(c) != c.cend()); - assert ( std::cend(c) == c.cend()); - assert ( std::rbegin(c) == c.rbegin()); - assert ( std::rbegin(c) != c.rend()); - assert ( std::rend(c) == c.rend()); - assert ( std::crbegin(c) == c.crbegin()); - assert ( std::crbegin(c) != c.crend()); - assert ( std::crend(c) == c.crend()); + ASSERT_SAME_TYPE(decltype(std::cbegin(c)), typename C::const_iterator); + ASSERT_SAME_TYPE(decltype(std::cend(c)), typename C::const_iterator); + assert(std::cbegin(c) == c.begin()); + assert(std::cend(c) == c.end()); + ASSERT_SAME_TYPE(decltype(std::rbegin(c)), typename C::reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(c)), typename C::reverse_iterator); + assert(std::rbegin(c).base() == c.end()); + assert(std::rend(c).base() == c.begin()); + ASSERT_SAME_TYPE(decltype(std::crbegin(c)), typename C::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(c)), typename C::const_reverse_iterator); + assert(std::crbegin(c).base() == c.end()); + assert(std::crend(c).base() == c.begin()); #endif - } - -template -void test_container( std::initializer_list & c, T val ) { - assert ( std::begin(c) == c.begin()); - assert (*std::begin(c) == val ); - assert ( std::begin(c) != c.end()); - assert ( std::end(c) == c.end()); + + const C& cc = c; + ASSERT_SAME_TYPE(decltype(std::begin(cc)), typename C::const_iterator); + ASSERT_SAME_TYPE(decltype(std::end(cc)), typename C::const_iterator); + assert(std::begin(cc) == c.begin()); + assert(std::end(cc) == c.end()); #if TEST_STD_VER > 11 -// initializer_list doesn't have cbegin/cend/rbegin/rend -// assert ( std::cbegin(c) == c.cbegin()); -// assert ( std::cbegin(c) != c.cend()); -// assert ( std::cend(c) == c.cend()); -// assert ( std::rbegin(c) == c.rbegin()); -// assert ( std::rbegin(c) != c.rend()); -// assert ( std::rend(c) == c.rend()); -// assert ( std::crbegin(c) == c.crbegin()); -// assert ( std::crbegin(c) != c.crend()); -// assert ( std::crend(c) == c.crend()); + ASSERT_SAME_TYPE(decltype(std::cbegin(cc)), typename C::const_iterator); + ASSERT_SAME_TYPE(decltype(std::cend(cc)), typename C::const_iterator); + assert(std::cbegin(cc) == c.begin()); + assert(std::cend(cc) == c.end()); + ASSERT_SAME_TYPE(decltype(std::rbegin(cc)), typename C::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::rend(cc)), typename C::const_reverse_iterator); + assert(std::rbegin(cc).base() == c.end()); + assert(std::rend(cc).base() == c.begin()); + ASSERT_SAME_TYPE(decltype(std::crbegin(cc)), typename C::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(std::crend(cc)), typename C::const_reverse_iterator); + assert(std::crbegin(cc).base() == c.end()); + assert(std::crend(cc).base() == c.begin()); #endif - } - -template -void test_const_array( const T (&array)[Sz] ) { - assert ( std::begin(array) == array ); - assert (*std::begin(array) == array[0] ); - assert ( std::begin(array) != std::end(array)); - assert ( std::end(array) == array + Sz); + + return true; +} + +struct ArrayHijacker { + friend constexpr int begin(ArrayHijacker(&)[3]) { return 42; } + friend constexpr int end(ArrayHijacker(&)[3]) { return 42; } + friend constexpr int begin(const ArrayHijacker(&)[3]) { return 42; } + friend constexpr int end(const ArrayHijacker(&)[3]) { return 42; } +}; + +struct ContainerHijacker { + int *a_; + constexpr int *begin() const { return a_; } + constexpr int *end() const { return a_ + 3; } + constexpr int *rbegin() const { return a_; } + constexpr int *rend() const { return a_ + 3; } + friend constexpr int begin(ContainerHijacker&) { return 42; } + friend constexpr int end(ContainerHijacker&) { return 42; } + friend constexpr int begin(const ContainerHijacker&) { return 42; } + friend constexpr int end(const ContainerHijacker&) { return 42; } + friend constexpr int cbegin(ContainerHijacker&) { return 42; } + friend constexpr int cend(ContainerHijacker&) { return 42; } + friend constexpr int cbegin(const ContainerHijacker&) { return 42; } + friend constexpr int cend(const ContainerHijacker&) { return 42; } + friend constexpr int rbegin(ContainerHijacker&) { return 42; } + friend constexpr int rend(ContainerHijacker&) { return 42; } + friend constexpr int rbegin(const ContainerHijacker&) { return 42; } + friend constexpr int rend(const ContainerHijacker&) { return 42; } + friend constexpr int crbegin(ContainerHijacker&) { return 42; } + friend constexpr int crend(ContainerHijacker&) { return 42; } + friend constexpr int crbegin(const ContainerHijacker&) { return 42; } + friend constexpr int crend(const ContainerHijacker&) { return 42; } +}; + +TEST_CONSTEXPR_CXX17 bool test_adl_proofing() { + // https://llvm.org/PR28927 + { + ArrayHijacker a[3] = {}; + assert(begin(a) == 42); + assert(end(a) == 42); + assert(std::begin(a) == a); + assert(std::end(a) == a + 3); #if TEST_STD_VER > 11 - assert ( std::cbegin(array) == array ); - assert (*std::cbegin(array) == array[0] ); - assert ( std::cbegin(array) != std::cend(array)); - assert ( std::cend(array) == array + Sz); + assert(std::cbegin(a) == a); + assert(std::cend(a) == a + 3); + assert(std::rbegin(a).base() == a + 3); + assert(std::rend(a).base() == a); + assert(std::crbegin(a).base() == a + 3); + assert(std::crend(a).base() == a); #endif - } + } + { + int a[3] = {}; + ContainerHijacker c{a}; + assert(begin(c) == 42); + assert(end(c) == 42); + assert(std::begin(c) == a); + assert(std::end(c) == a + 3); +#if TEST_STD_VER > 11 + assert(std::cbegin(c) == a); + assert(std::cend(c) == a + 3); + assert(std::rbegin(c) == a); + assert(std::rend(c) == a + 3); + assert(std::crbegin(c) == a); + assert(std::crend(c) == a + 3); +#endif + } + return true; +} int main(int, char**) { - std::vector v; v.push_back(1); - std::list l; l.push_back(2); - std::array a; a[0] = 3; - std::initializer_list il = { 4 }; - - test_container ( v, 1 ); - test_container ( l, 2 ); - test_container ( a, 3 ); - test_container ( il, 4 ); - - test_const_container ( v, 1 ); - test_const_container ( l, 2 ); - test_const_container ( a, 3 ); - test_const_container ( il, 4 ); - - static constexpr int arrA [] { 1, 2, 3 }; - test_const_array ( arrA ); + test_arrays_and_initializer_lists_forward(); #if TEST_STD_VER > 11 - constexpr const int *b = std::cbegin(arrA); - constexpr const int *e = std::cend(arrA); - static_assert(e - b == 3, ""); + test_arrays_and_initializer_lists_backward(); #endif + test_container>(); + test_container>(); + test_container>(); + test_adl_proofing(); +#if TEST_STD_VER > 11 + static_assert(test_arrays_and_initializer_lists_forward(), ""); +#endif #if TEST_STD_VER > 14 - { - typedef std::array C; - constexpr const C c{0,1,2,3,4}; - - static_assert ( c.begin() == std::begin(c), ""); - static_assert ( c.cbegin() == std::cbegin(c), ""); - static_assert ( c.end() == std::end(c), ""); - static_assert ( c.cend() == std::cend(c), ""); - - static_assert ( c.rbegin() == std::rbegin(c), ""); - static_assert ( c.crbegin() == std::crbegin(c), ""); - static_assert ( c.rend() == std::rend(c), ""); - static_assert ( c.crend() == std::crend(c), ""); - - static_assert ( std::begin(c) != std::end(c), ""); - static_assert ( std::rbegin(c) != std::rend(c), ""); - static_assert ( std::cbegin(c) != std::cend(c), ""); - static_assert ( std::crbegin(c) != std::crend(c), ""); - - static_assert ( *c.begin() == 0, ""); - static_assert ( *c.rbegin() == 4, ""); - - static_assert ( *std::begin(c) == 0, "" ); - static_assert ( *std::cbegin(c) == 0, "" ); - static_assert ( *std::rbegin(c) == 4, "" ); - static_assert ( *std::crbegin(c) == 4, "" ); - } - - { - static constexpr const int c[] = {0,1,2,3,4}; - - static_assert ( *std::begin(c) == 0, "" ); - static_assert ( *std::cbegin(c) == 0, "" ); - static_assert ( *std::rbegin(c) == 4, "" ); - static_assert ( *std::crbegin(c) == 4, "" ); - } + static_assert(test_arrays_and_initializer_lists_backward()); + static_assert(test_container>()); + static_assert(test_adl_proofing()); #endif return 0; diff --git a/libcxx/test/std/iterators/iterator.range/begin_array.pass.cpp b/libcxx/test/std/iterators/iterator.range/begin_array.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/begin_array.pass.cpp +++ /dev/null @@ -1,27 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template T* begin(T (&array)[N]); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - int* i = std::begin(ia); - assert(*i == 1); - *i = 2; - assert(ia[0] == 2); - - return 0; -} diff --git a/libcxx/test/std/iterators/iterator.range/begin_const.pass.cpp b/libcxx/test/std/iterators/iterator.range/begin_const.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/begin_const.pass.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template auto begin(const C& c) -> decltype(c.begin()); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - const std::vector v(ia, ia + sizeof(ia)/sizeof(ia[0])); - std::vector::const_iterator i = begin(v); - assert(*i == 1); - - return 0; -} diff --git a/libcxx/test/std/iterators/iterator.range/begin_non_const.pass.cpp b/libcxx/test/std/iterators/iterator.range/begin_non_const.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/begin_non_const.pass.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template auto begin(C& c) -> decltype(c.begin()); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - std::vector v(ia, ia + sizeof(ia)/sizeof(ia[0])); - std::vector::iterator i = begin(v); - assert(*i == 1); - *i = 2; - assert(*i == 2); - - return 0; -} diff --git a/libcxx/test/std/iterators/iterator.range/end_array.pass.cpp b/libcxx/test/std/iterators/iterator.range/end_array.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/end_array.pass.cpp +++ /dev/null @@ -1,27 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template T* end(T (&array)[N]); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - int* i = std::begin(ia); - int* e = std::end(ia); - assert(e == ia + 3); - assert(e - i == 3); - - return 0; -} diff --git a/libcxx/test/std/iterators/iterator.range/end_const.pass.cpp b/libcxx/test/std/iterators/iterator.range/end_const.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/end_const.pass.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template auto end(const C& c) -> decltype(c.end()); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - const std::vector v(ia, ia + sizeof(ia)/sizeof(ia[0])); - std::vector::const_iterator i = end(v); - assert(i == v.cend()); - - return 0; -} diff --git a/libcxx/test/std/iterators/iterator.range/end_non_const.pass.cpp b/libcxx/test/std/iterators/iterator.range/end_non_const.pass.cpp deleted file mode 100644 --- a/libcxx/test/std/iterators/iterator.range/end_non_const.pass.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// - -// template auto end(C& c) -> decltype(c.end()); - -#include -#include - -#include "test_macros.h" - -int main(int, char**) -{ - int ia[] = {1, 2, 3}; - std::vector v(ia, ia + sizeof(ia)/sizeof(ia[0])); - std::vector::iterator i = end(v); - assert(i == v.end()); - - return 0; -}