[libc++] Fix .compile.fail.cpp tests that should have been marked as UNSUPPORTED in C++03/11

[ldionne]

Spurious CI failures, shipping.

[Mordante]

Nice catch! I like this cleanup!

libcxx/test/std/containers/associative/map/map.ops/count1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/count2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/count3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/equal_range1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // pair<iterator,iterator>             equal_range(const key_type& k);
 // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/equal_range2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // pair<iterator,iterator>             equal_range(const key_type& k);
 // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/equal_range3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 // pair<iterator,iterator>             equal_range(const key_type& k);
 // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/find1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/find2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/find3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/lower_bound1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/lower_bound2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/lower_bound3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
-
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/upper_bound1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/upper_bound2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/map/map.ops/upper_bound3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/count1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/count2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/count3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // size_type count(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // pair<iterator, iterator>             equal_range(const key_type& k);
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // pair<iterator, iterator>             equal_range(const key_type& k);
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 // pair<iterator, iterator>             equal_range(const key_type& k);
 // pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/find1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/find2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class map
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/find3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound1.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound2.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound3.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03, c++11
+
 // <map>
 
 // class multimap
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
 //
 //   The member function templates find, count, lower_bound, upper_bound, and
 // equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 
 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
-#if TEST_STD_VER <= 11
-#error "This test requires is C++14 (or later)"
-#else
-
 int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
     TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
-#endif

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.compile.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03
+
 // <iterator>
 
 // class istream_iterator
 
 // constexpr istream_iterator();
 
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct S { S(); }; // not constexpr
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 11
-    {
-    constexpr std::istream_iterator<S> it;
-    }
-#else
-#error "C++11 only test"
-#endif
 
   return 0;
 }