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 ↗(On Diff #15376)

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 ↗(On Diff #15376)

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 ↗(On Diff #15376)

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 ↗(On Diff #15376)

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/
std/
utilities/
tuple/
tuple.general/
3 lines
tuple.tuple/
2 lines
tuple.helper/
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 20249

test/std/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/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: c++98, c++03
// 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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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 <utility> #include <utility>
#include <cassert> #include <cassert>
Context not available.

test/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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 <utility> #include <utility>
#include <string> #include <string>
Context not available.

test/std/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/std/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/std/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/std/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/std/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 <utility> #include <utility>
#include <cassert> #include <cassert>
Context not available.

test/std/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/std/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 <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
Context not available.

test/std/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/std/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/std/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/std/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/std/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/std/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/std/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 <utility> #include <utility>
#include <memory> #include <memory>
Context not available.

test/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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/std/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.