This is an archive of the discontinued LLVM Phabricator instance.

Differential D5956

[libcxx] Mark most tuple tests UNSUPPORTED for c++03 and c++98.
ClosedPublic

Authored by EricWF on Oct 23 2014, 8:16 PM.

Details

Reviewers
mclow.lists
danalbert
jroelofs
Commits
rG0a52cd7937f2: [libcxx] Mark most tuple tests UNSUPPORTED for c++03 and c++98.
rCXX229808: [libcxx] Mark most tuple tests UNSUPPORTED for c++03 and c++98.
rL229808: [libcxx] Mark most tuple tests UNSUPPORTED for c++03 and c++98.
Summary

No declaration for the type tuple is given in c++03 or c++98 modes. Mark all tests that use the actual tuple type as UNSUPPORTED.

Diff Detail

Event Timeline

EricWF updated this revision to Diff 15376.Oct 23 2014, 8:16 PM
EricWF retitled this revision from to [libcxx] Mark most tuple tests UNSUPPORTED for c++03 and c++98..
EricWF updated this object.
EricWF edited the test plan for this revision. (Show Details)
EricWF added reviewers: mclow.lists, danalbert, jroelofs.
EricWF added a subscriber: Unknown Object (MLST).
jroelofs added inline comments.Oct 27 2014, 3:11 PM
test/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
11

Don't we require that the set of LIT directives happen in the first continuous block of '//' comments?

EricWF added inline comments.Oct 27 2014, 3:55 PM
test/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
11

Almost. Lines containing only white space are also allowed.

jroelofs added inline comments.Oct 27 2014, 3:57 PM
test/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
11

Ah. Awkward. Why don't we allow it throughout the whole file?

EricWF added a comment.Oct 27 2014, 6:47 PM

N

test/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
11

Not sure. There has never been a need to do that. Perhaps to enforce the style that these comments go at the top?

danalbert accepted this revision.Dec 16 2014, 6:09 PM
danalbert edited edge metadata.

LGTM.

This revision is now accepted and ready to land.Dec 16 2014, 6:09 PM
mclow.lists edited edge metadata.EditedDec 17 2014, 5:16 PM

Do we actually care about C++98?
[ Other than that, LGTM ]

danalbert added a comment.Dec 17 2014, 5:18 PM
In D5956#102627, @mclow.lists wrote:

Do we actually care about C++98?

It's the default compilation mode for g++ (well, gnu++98 is anyway), so definitely worth testing against.

EricWF added a comment.Dec 19 2014, 10:10 AM

I think I'm coming around to @danalbert's way of thinking. Shouldn't these be XFAIL instead?

EricWF updated this revision to Diff 20247.Feb 18 2015, 6:00 PM
EricWF edited edge metadata.

Rebase against ToT.

EricWF updated this revision to Diff 20249.Feb 18 2015, 6:09 PM

Remove unsupported markings from some of the tests.

EricWF closed this revision.Feb 18 2015, 6:12 PM

Revision Contents

PathSize
test/
utilities/
tuple/
tuple.general/
3 lines
tuple.tuple/
2 lines
2 lines
tuple.helper/
1 line
2 lines
2 lines
tuple.assign/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tuple.cnstr/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tuple.creation/
2 lines
2 lines
2 lines
2 lines
tuple.elem/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tuple.rel/
2 lines
2 lines
tuple.special/
2 lines
tuple.swap/
2 lines
tuple.traits/
2 lines

Diff 15376

test/utilities/tuple/tuple.general/nothing_to_do.pass.cpp

  • This file was deleted.
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

test/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: c++98, c++03
jroelofsUnsubmitted
Not Done
ReplyInline Actions

Don't we require that the set of LIT directives happen in the first continuous block of '//' comments?

jroelofs: Don't we require that the set of LIT directives happen in the first continuous block of '//'…
EricWFAuthorUnsubmitted
Not Done
ReplyInline Actions

Almost. Lines containing only white space are also allowed.

EricWF: Almost. Lines containing only white space are also allowed.
jroelofsUnsubmitted
Not Done
ReplyInline Actions

Ah. Awkward. Why don't we allow it throughout the whole file?

jroelofs: Ah. Awkward. Why don't we allow it throughout the whole file?
EricWFAuthorUnsubmitted
Not Done
ReplyInline Actions

Not sure. There has never been a need to do that. Perhaps to enforce the style that these comments go at the top?

EricWF: Not sure. There has never been a need to do that. Perhaps to enforce the style that these…
// Tuples of smart pointers; based on bug #18350 // Tuples of smart pointers; based on bug #18350
// auto_ptr doesn't have a copy constructor that takes a const &, but tuple does. // auto_ptr doesn't have a copy constructor that takes a const &, but tuple does.
Context not available.

test/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// This is for bugs 18853 and 19118 // This is for bugs 18853 and 19118
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
Context not available.

test/utilities/tuple/tuple.tuple/empty_member.pass.cpp

Context not available.
// template <class... Types> class tuple; // template <class... Types> class tuple;
// UNSUPPORTED: c++98, c++03
// This is not a portable test // This is not a portable test
#include <tuple> #include <tuple>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp

Context not available.
// LWG #2212 says that tuple_size and tuple_element must be // LWG #2212 says that tuple_size and tuple_element must be
// available after including <utility> // available after including <utility>
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp

Context not available.
// typedef Ti type; // typedef Ti type;
// }; // };
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp

Context not available.
// class tuple_size<tuple<Types...>> // class tuple_size<tuple<Types...>>
// : public integral_constant<size_t, sizeof...(Types)> { }; // : public integral_constant<size_t, sizeof...(Types)> { };
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp

Context not available.
// template <class U1, class U2> // template <class U1, class U2>
// tuple& operator=(const pair<U1, U2>& u); // tuple& operator=(const pair<U1, U2>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

Context not available.
// template <class... UTypes> // template <class... UTypes>
// tuple& operator=(const tuple<UTypes...>& u); // tuple& operator=(const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

Context not available.
// template <class... UTypes> // template <class... UTypes>
// tuple& operator=(tuple<UTypes...>&& u); // tuple& operator=(tuple<UTypes...>&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp

Context not available.
// tuple& operator=(const tuple& u); // tuple& operator=(const tuple& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp

Context not available.
// tuple& operator=(const tuple& u); // tuple& operator=(const tuple& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

Context not available.
// tuple& operator=(tuple&& u); // tuple& operator=(tuple&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp

Context not available.
// template <class U1, class U2> // template <class U1, class U2>
// tuple& operator=(pair<U1, U2>&& u); // tuple& operator=(pair<U1, U2>&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp

Context not available.
// template <class... UTypes> // template <class... UTypes>
// explicit tuple(UTypes&&... u); // explicit tuple(UTypes&&... u);
// UNSUPPORTED: c++98, c++03
/* /*
This is testing an extension whereby only Types having an explicit conversion This is testing an extension whereby only Types having an explicit conversion
from UTypes are bound by the explicit tuple constructor. from UTypes are bound by the explicit tuple constructor.
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp

Context not available.
// template <class... UTypes> // template <class... UTypes>
// explicit tuple(UTypes&&... u); // explicit tuple(UTypes&&... u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <type_traits> #include <type_traits>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp

Context not available.
// template <class Alloc> // template <class Alloc>
// tuple(allocator_arg_t, const Alloc& a); // tuple(allocator_arg_t, const Alloc& a);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp

Context not available.
// template <class Alloc, class... UTypes> // template <class Alloc, class... UTypes>
// tuple(allocator_arg_t, const Alloc& a, UTypes&&...); // tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp

Context not available.
// template <class Alloc> // template <class Alloc>
// tuple(allocator_arg_t, const Alloc& a, const Types&...); // tuple(allocator_arg_t, const Alloc& a, const Types&...);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp

Context not available.
// template <class Alloc, class U1, class U2> // template <class Alloc, class U1, class U2>
// tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&); // tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp

Context not available.
// template <class Alloc, class... UTypes> // template <class Alloc, class... UTypes>
// tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&); // tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp

Context not available.
// template <class Alloc, class... UTypes> // template <class Alloc, class... UTypes>
// tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&); // tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp

Context not available.
// template <class Alloc> // template <class Alloc>
// tuple(allocator_arg_t, const Alloc& a, const tuple&); // tuple(allocator_arg_t, const Alloc& a, const tuple&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp

Context not available.
// template <class Alloc> // template <class Alloc>
// tuple(allocator_arg_t, const Alloc& a, tuple&&); // tuple(allocator_arg_t, const Alloc& a, tuple&&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp

Context not available.
// template <class Alloc, class U1, class U2> // template <class Alloc, class U1, class U2>
// tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&); // tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp

Context not available.
// explicit tuple(const T&...); // explicit tuple(const T&...);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp

Context not available.
// explicit tuple(const T&...); // explicit tuple(const T&...);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp

Context not available.
// explicit tuple(const T&...); // explicit tuple(const T&...);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp

Context not available.
// template <class U1, class U2> tuple(const pair<U1, U2>& u); // template <class U1, class U2> tuple(const pair<U1, U2>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp

Context not available.
// template <class... UTypes> tuple(const tuple<UTypes...>& u); // template <class... UTypes> tuple(const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp

Context not available.
// template <class... UTypes> tuple(tuple<UTypes...>&& u); // template <class... UTypes> tuple(tuple<UTypes...>&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp

Context not available.
// tuple(const tuple& u) = default; // tuple(const tuple& u) = default;
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp

Context not available.
// tuple(const tuple& u) = default; // tuple(const tuple& u) = default;
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp

Context not available.
// constexpr tuple(); // constexpr tuple();
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

Context not available.
// tuple(tuple&& u); // tuple(tuple&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp

Context not available.
// template <class U1, class U2> tuple(pair<U1, U2>&& u); // template <class U1, class U2> tuple(pair<U1, U2>&& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp

Context not available.
// template<class... Types> // template<class... Types>
// tuple<Types&&...> forward_as_tuple(Types&&... t); // tuple<Types&&...> forward_as_tuple(Types&&... t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

Context not available.
// template<class... Types> // template<class... Types>
// tuple<VTypes...> make_tuple(Types&&... t); // tuple<VTypes...> make_tuple(Types&&... t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <functional> #include <functional>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp

Context not available.
// template<class... Types> // template<class... Types>
// tuple<Types&...> tie(Types&... t); // tuple<Types&...> tie(Types&... t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp

Context not available.
// template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <array> #include <array>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp

Context not available.
// typename tuple_element<I, tuple<Types...> >::type const& // typename tuple_element<I, tuple<Types...> >::type const&
// get(const tuple<Types...>& t); // get(const tuple<Types...>& t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp

Context not available.
// typename tuple_element<I, tuple<Types...> >::type const& // typename tuple_element<I, tuple<Types...> >::type const&
// get(const tuple<Types...>& t); // get(const tuple<Types...>& t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp

Context not available.
// typename tuple_element<I, tuple<Types...> >::type& // typename tuple_element<I, tuple<Types...> >::type&
// get(tuple<Types...>& t); // get(tuple<Types...>& t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp

Context not available.
// typename tuple_element<I, tuple<Types...> >::type&& // typename tuple_element<I, tuple<Types...> >::type&&
// get(tuple<Types...>&& t); // get(tuple<Types...>&& t);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type1.fail.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type2.fail.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type3.fail.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type4.fail.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <memory> #include <memory>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp

Context not available.
// bool // bool
// operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u); // operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp

Context not available.
// bool // bool
// operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u); // operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp

Context not available.
// template <class... Types> // template <class... Types>
// void swap(tuple<Types...>& x, tuple<Types...>& y); // void swap(tuple<Types...>& x, tuple<Types...>& y);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp

Context not available.
// void swap(tuple& rhs); // void swap(tuple& rhs);
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
Context not available.

test/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp

Context not available.
// template <class... Types, class Alloc> // template <class... Types, class Alloc>
// struct uses_allocator<tuple<Types...>, Alloc> : true_type { }; // struct uses_allocator<tuple<Types...>, Alloc> : true_type { };
// UNSUPPORTED: c++98, c++03
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
Context not available.