Haiku/buildtools
1
0
Fork 0
mirror of https://review.haiku-os.org/buildtools synced 2025-02-07 14:34:51 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
buildtools/gcc/gmp/tests/cxx/t-cxx11.cc
Fredrik Holmqvist 4c74403188 Update GMP to 6.2.0 
Change-Id: Iae65e95cfa0d92091b8b0a424ae36d88efa76aa9
Reviewed-on: https://review.haiku-os.org/c/buildtools/+/3020
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>
2020-07-17 10:33:46 +00:00

233 lines
7.1 KiB
C++
Raw Permalink Blame History

/* Test C++11 features
Copyright 2011, 2012 Free Software Foundation, Inc.
This file is part of the GNU MP Library test suite.
The GNU MP Library test suite is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 3 of the License,
or (at your option) any later version.
The GNU MP Library test suite is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with
the GNU MP Library test suite. If not, see https://www.gnu.org/licenses/. */
#include "config.h"
#include "gmpxx.h"
#include "gmp-impl.h"
#include "tests.h"
#if __GMPXX_USE_CXX11
#include <utility>
#include <type_traits>
void check_noexcept ()
{
mpz_class z1, z2;
mpq_class q1, q2;
mpf_class f1, f2;
static_assert(noexcept(z1 = std::move(z2)), "sorry");
static_assert(noexcept(q1 = std::move(q2)), "sorry");
static_assert(noexcept(f1 = std::move(f2)), "sorry");
static_assert(noexcept(q1 = std::move(z1)), "sorry");
// Only mpz has lazy allocation for now
static_assert(std::is_nothrow_default_constructible<mpz_class>::value, "sorry");
static_assert(std::is_nothrow_move_constructible<mpz_class>::value, "sorry");
static_assert(!std::is_nothrow_default_constructible<mpq_class>::value, "sorry");
static_assert(!std::is_nothrow_move_constructible<mpq_class>::value, "sorry");
static_assert(!std::is_nothrow_default_constructible<mpf_class>::value, "sorry");
static_assert(!std::is_nothrow_move_constructible<mpf_class>::value, "sorry");
}
void check_common_type ()
{
#define CHECK_COMMON_TYPE1(T, Res) \
static_assert(std::is_same<std::common_type<T>::type, Res>::value, "sorry")
#define CHECK_COMMON_TYPE(T, U, Res) \
static_assert(std::is_same<std::common_type<T, U>::type, Res>::value, "sorry")
#define CHECK_COMMON_TYPE_BUILTIN1(T, Res) \
CHECK_COMMON_TYPE( signed char , T, Res); \
CHECK_COMMON_TYPE(unsigned char , T, Res); \
CHECK_COMMON_TYPE( signed short, T, Res); \
CHECK_COMMON_TYPE(unsigned short, T, Res); \
CHECK_COMMON_TYPE( signed int , T, Res); \
CHECK_COMMON_TYPE(unsigned int , T, Res); \
CHECK_COMMON_TYPE( signed long , T, Res); \
CHECK_COMMON_TYPE(unsigned long , T, Res); \
CHECK_COMMON_TYPE(float , T, Res); \
CHECK_COMMON_TYPE(double, T, Res)
#define CHECK_COMMON_TYPE_BUILTIN2(T, Res) \
CHECK_COMMON_TYPE(T, signed char , Res); \
CHECK_COMMON_TYPE(T, unsigned char , Res); \
CHECK_COMMON_TYPE(T, signed short, Res); \
CHECK_COMMON_TYPE(T, unsigned short, Res); \
CHECK_COMMON_TYPE(T, signed int , Res); \
CHECK_COMMON_TYPE(T, unsigned int , Res); \
CHECK_COMMON_TYPE(T, signed long , Res); \
CHECK_COMMON_TYPE(T, unsigned long , Res); \
CHECK_COMMON_TYPE(T, float , Res); \
CHECK_COMMON_TYPE(T, double, Res)
#define CHECK_COMMON_TYPE_BUILTIN(T, Res) \
CHECK_COMMON_TYPE_BUILTIN1(T, Res); \
CHECK_COMMON_TYPE_BUILTIN2(T, Res)
/* These would just work with implicit conversions */
CHECK_COMMON_TYPE (mpz_class, mpq_class, mpq_class);
CHECK_COMMON_TYPE (mpz_class, mpf_class, mpf_class);
CHECK_COMMON_TYPE (mpf_class, mpq_class, mpf_class);
CHECK_COMMON_TYPE_BUILTIN (mpz_class, mpz_class);
CHECK_COMMON_TYPE_BUILTIN (mpq_class, mpq_class);
CHECK_COMMON_TYPE_BUILTIN (mpf_class, mpf_class);
mpz_class z; mpq_class q; mpf_class f;
CHECK_COMMON_TYPE (decltype(-z), mpz_class, mpz_class);
CHECK_COMMON_TYPE (decltype(-q), mpq_class, mpq_class);
CHECK_COMMON_TYPE (decltype(-f), mpf_class, mpf_class);
CHECK_COMMON_TYPE (decltype(-z), mpq_class, mpq_class);
CHECK_COMMON_TYPE (decltype(-z), mpf_class, mpf_class);
CHECK_COMMON_TYPE (decltype(-q), mpf_class, mpf_class);
/* These require a common_type specialization */
CHECK_COMMON_TYPE (decltype(-z), decltype(z+z), mpz_class);
CHECK_COMMON_TYPE (decltype(-q), decltype(q+q), mpq_class);
CHECK_COMMON_TYPE (decltype(-f), decltype(f+f), mpf_class);
CHECK_COMMON_TYPE (decltype(-q), mpz_class, mpq_class);
CHECK_COMMON_TYPE (decltype(-f), mpz_class, mpf_class);
CHECK_COMMON_TYPE (decltype(-f), mpq_class, mpf_class);
CHECK_COMMON_TYPE (decltype(-z), decltype(-q), mpq_class);
CHECK_COMMON_TYPE (decltype(-z), decltype(-f), mpf_class);
CHECK_COMMON_TYPE (decltype(-q), decltype(-f), mpf_class);
/* common_type now decays */
CHECK_COMMON_TYPE (decltype(-z), decltype(-z), mpz_class);
CHECK_COMMON_TYPE (decltype(-q), decltype(-q), mpq_class);
CHECK_COMMON_TYPE (decltype(-f), decltype(-f), mpf_class);
CHECK_COMMON_TYPE1 (decltype(-z), mpz_class);
CHECK_COMMON_TYPE1 (decltype(-q), mpq_class);
CHECK_COMMON_TYPE1 (decltype(-f), mpf_class);
/* Painful */
CHECK_COMMON_TYPE_BUILTIN (decltype(-z), mpz_class);
CHECK_COMMON_TYPE_BUILTIN (decltype(-q), mpq_class);
CHECK_COMMON_TYPE_BUILTIN (decltype(-f), mpf_class);
}
template<class T, class U = T>
void check_move_init ()
{
{
// Delete moved-from x1
T x1 = 3;
U x2 = std::move(x1);
ASSERT_ALWAYS (x2 == 3);
}
{
// Assign to moved-from x1
T x1 = 2;
U x2 = std::move(x1);
x1 = -7;
ASSERT_ALWAYS (x1 == -7);
ASSERT_ALWAYS (x2 == 2);
}
}
template<class T, class U = T>
void check_move_assign ()
{
{
// Delete moved-from x1
T x1 = 3; U x2;
x2 = std::move(x1);
ASSERT_ALWAYS (x2 == 3);
}
{
// Assign to moved-from x1
T x1 = 2; U x2;
x2 = std::move(x1);
x1 = -7;
ASSERT_ALWAYS (x1 == -7);
ASSERT_ALWAYS (x2 == 2);
}
{
// Self move-assign (not necessary, but it happens to work...)
T x = 4;
x = std::move(x);
ASSERT_ALWAYS (x == 4);
}
}
void check_user_defined_literal ()
{
ASSERT_ALWAYS (123_mpz % 5 == 3);
ASSERT_ALWAYS (-11_mpq / 22 == -.5);
ASSERT_ALWAYS (112.5e-1_mpf * 4 == 45);
{
mpz_class ref ( "123456789abcdef0123456789abcdef0123", 16);
ASSERT_ALWAYS (0x123456789abcdef0123456789abcdef0123_mpz == ref);
}
}
// Check for explicit conversion to bool
void implicit_bool(bool);
int implicit_bool(...);
void check_bool_conversion ()
{
const mpz_class zn = -2;
const mpq_class qn = -2;
const mpf_class fn = -2;
const mpz_class z0 = 0;
const mpq_class q0 = 0;
const mpf_class f0 = 0;
const mpz_class zp = +2;
const mpq_class qp = +2;
const mpf_class fp = +2;
if (zn && qn && fn && zp && qp && fp && !z0 && !q0 && !f0)
{
if (z0 || q0 || f0) ASSERT_ALWAYS(false);
}
else ASSERT_ALWAYS(false);
decltype(implicit_bool(zn)) zi = 1;
decltype(implicit_bool(qn)) qi = 1;
decltype(implicit_bool(fn)) fi = 1;
(void)(zi+qi+fi);
}
int
main (void)
{
tests_start();
check_noexcept();
check_common_type();
check_move_init<mpz_class>();
check_move_init<mpq_class>();
check_move_init<mpf_class>();
check_move_assign<mpz_class>();
check_move_assign<mpq_class>();
check_move_assign<mpf_class>();
check_move_init<mpz_class,mpq_class>();
check_move_assign<mpz_class,mpq_class>();
check_user_defined_literal();
check_bool_conversion();
tests_end();
return 0;
}
#else
int main () { return 0; }
#endif
Reference in New Issue View Git Blame Copy Permalink