Page MenuHomePhabricator
Differential D116621 Diff 439539 libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap_const.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap_const.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// <tuple>
// void swap(const tuple& rhs);
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
#include <cassert>
ldionneUnsubmitted
Done
ReplyInline Actions

Why does it fail on GCC?

ldionne: Why does it fail on GCC?
huixie90AuthorUnsubmitted
Done
ReplyInline Actions

good catch. gcc only fail when running the test at compile time because it doesn't allow mutable member in constexpr. but this test can run at time with gcc so I enable the runtime test for gcc now

huixie90: good catch. gcc only fail when running the test at compile time because it doesn't allow…
#include <tuple>
#include <utility>
#include "test_macros.h"
#ifndef TEST_HAS_NO_EXCEPTIONS
class SwapThrower {
void swap(SwapThrower&) = delete;
void swap(const SwapThrower&) const = delete;
};
void swap(const SwapThrower&, const SwapThrower&) { throw 0.f; }
static_assert(std::is_swappable_v<const SwapThrower>);
static_assert(std::is_swappable_with_v<const SwapThrower&, const SwapThrower&>);
void test_noexcept() {
const std::tuple<SwapThrower> t1;
const std::tuple<SwapThrower> t2;
try {
t1.swap(t2);
std::swap(t1, t2);
assert(false);
} catch (float) {
}
try {
std::swap(std::as_const(t1), std::as_const(t2));
assert(false);
} catch (float) {
}
}
#endif // TEST_HAS_NO_EXCEPTIONS
struct ConstSwappable {
mutable int i;
};
constexpr void swap(const ConstSwappable& lhs, const ConstSwappable& rhs) { std::swap(lhs.i, rhs.i); }
constexpr bool test() {
{
typedef std::tuple<const ConstSwappable> T;
const T t0(ConstSwappable{0});
T t1(ConstSwappable{1});
t0.swap(t1);
assert(std::get<0>(t0).i == 1);
assert(std::get<0>(t1).i == 0);
}
{
typedef std::tuple<ConstSwappable, ConstSwappable> T;
const T t0({0}, {1});
const T t1({2}, {3});
t0.swap(t1);
assert(std::get<0>(t0).i == 2);
assert(std::get<1>(t0).i == 3);
assert(std::get<0>(t1).i == 0);
assert(std::get<1>(t1).i == 1);
}
{
typedef std::tuple<ConstSwappable, const ConstSwappable, const ConstSwappable> T;
const T t0({0}, {1}, {2});
const T t1({3}, {4}, {5});
t0.swap(t1);
assert(std::get<0>(t0).i == 3);
assert(std::get<1>(t0).i == 4);
assert(std::get<2>(t0).i == 5);
assert(std::get<0>(t1).i == 0);
assert(std::get<1>(t1).i == 1);
assert(std::get<2>(t1).i == 2);
}
return true;
}
int main(int, char**) {
#ifndef TEST_HAS_NO_EXCEPTIONS
test_noexcept();
#endif
test();
// gcc cannot have mutable member in constant expression
#if !defined(TEST_COMPILER_GCC)
static_assert(test());
#endif
return 0;
}