From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../testsuite/tr1/8_c_compatibility/cmath/51083.cc | 62 +++++ .../tr1/8_c_compatibility/cmath/functions.cc | 193 ++++++++++++++++ .../tr1/8_c_compatibility/cmath/overloads.cc | 257 +++++++++++++++++++++ .../tr1/8_c_compatibility/cmath/templates.cc | 64 +++++ .../tr1/8_c_compatibility/cmath/types_std_tr1.cc | 34 +++ 5 files changed, 610 insertions(+) create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/51083.cc create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/templates.cc create mode 100644 libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/types_std_tr1.cc (limited to 'libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath') diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/51083.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/51083.cc new file mode 100644 index 000000000..504305a30 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/51083.cc @@ -0,0 +1,62 @@ +// { dg-options "-std=gnu++0x" } +// +// Copyright (C) 2011 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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 this library; see the file COPYING3. If not see +// . + +#include + +namespace a +{ + template class Mat { }; + + template struct Mat2 : Mat { }; + + template + int fdim(Mat) { return 1; } + + template + int floor(Mat, U) { return 1; } + template + int floor(T, Mat) { return 1; } + + template + int fma(Mat, U, V) { return 1; } + template + int fma(T, Mat, V) { return 1; } + template + int fma(T, U, Mat) { return 1; } +} + +int main() +{ + int __attribute__((unused)) i; + + using namespace std::tr1; + + a::Mat2 c; + i = fdim(c); + i = floor(c, 0.); + i = floor(0., c); + i = floor(c, 1); + i = floor(1, c); + i = fma(c, 0., 1.); + i = fma(0., c, 1.); + i = fma(0., 1., c); + i = fma(c, 0., 1); + i = fma(0., c, 1); + i = fma(0., 1, c); +} diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc new file mode 100644 index 000000000..ae31a48ec --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/functions.cc @@ -0,0 +1,193 @@ +// { dg-do compile } + +// 2006-02-07 Paolo Carlini +// +// Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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 this library; see the file COPYING3. If not see +// . + +// 8.16 Additions to header + +#include + +void test01() +{ +#if _GLIBCXX_USE_C99_MATH_TR1 + + double d0 = 0.0; + float f0 = 0.0f; + long double ld0 = 0.0l; + const char* str = "NAN"; + int* pquo = 0; + long lex = 0l; + int ex = 0; + + double ret; + float fret; + long double ldret; + int iret; + long lret; + long long llret; + + ret = std::tr1::acosh(d0); + fret = std::tr1::acoshf(f0); + ldret = std::tr1::acoshl(ld0); + + ret = std::tr1::asinh(d0); + fret = std::tr1::asinhf(f0); + ldret = std::tr1::asinhl(ld0); + + ret = std::tr1::atanh(d0); + fret = std::tr1::atanhf(f0); + ldret = std::tr1::atanhl(ld0); + + ret = std::tr1::cbrt(d0); + fret = std::tr1::cbrtf(f0); + ldret = std::tr1::cbrtl(ld0); + + ret = std::tr1::copysign(d0, d0); + fret = std::tr1::copysignf(f0, f0); + ldret = std::tr1::copysignl(ld0, ld0); + + ret = std::tr1::erf(d0); + fret = std::tr1::erff(f0); + ldret = std::tr1::erfl(ld0); + + ret = std::tr1::erfc(d0); + fret = std::tr1::erfcf(f0); + ldret = std::tr1::erfcl(ld0); + + ret = std::tr1::exp2(d0); + fret = std::tr1::exp2f(f0); + ldret = std::tr1::exp2l(ld0); + + ret = std::tr1::expm1(d0); + fret = std::tr1::expm1f(f0); + ldret = std::tr1::expm1l(ld0); + + ret = std::tr1::fdim(d0, d0); + fret = std::tr1::fdimf(f0, f0); + ldret = std::tr1::fdiml(ld0, ld0); + + ret = std::tr1::fma(d0, d0, d0); + fret = std::tr1::fmaf(f0, f0, f0); + ldret = std::tr1::fmal(ld0, ld0, ld0); + + ret = std::tr1::fmax(d0, d0); + fret = std::tr1::fmaxf(f0, f0); + ldret = std::tr1::fmaxl(ld0, ld0); + + ret = std::tr1::fmin(d0, d0); + fret = std::tr1::fminf(f0, f0); + ldret = std::tr1::fminl(ld0, ld0); + + ret = std::tr1::hypot(d0, d0); + fret = std::tr1::hypotf(f0, f0); + ldret = std::tr1::hypotl(ld0, ld0); + + iret = std::tr1::ilogb(d0); + iret = std::tr1::ilogbf(f0); + iret = std::tr1::ilogbl(ld0); + + ret = std::tr1::lgamma(d0); + fret = std::tr1::lgammaf(f0); + ldret = std::tr1::lgammal(ld0); + + llret = std::tr1::llrint(d0); + llret = std::tr1::llrintf(f0); + llret = std::tr1::llrintl(ld0); + + llret = std::tr1::llround(d0); + llret = std::tr1::llroundf(f0); + llret = std::tr1::llroundl(ld0); + + ret = std::tr1::log1p(d0); + fret = std::tr1::log1pf(f0); + ldret = std::tr1::log1pl(ld0); + + ret = std::tr1::log2(d0); + fret = std::tr1::log2f(f0); + ldret = std::tr1::log2l(ld0); + + ret = std::tr1::logb(d0); + fret = std::tr1::logbf(f0); + ldret = std::tr1::logbl(ld0); + + lret = std::tr1::lrint(d0); + lret = std::tr1::lrintf(f0); + lret = std::tr1::lrintl(ld0); + + lret = std::tr1::lround(d0); + lret = std::tr1::lroundf(f0); + lret = std::tr1::lroundl(ld0); + + ret = std::tr1::nan(str); + fret = std::tr1::nanf(str); + ldret = std::tr1::nanl(str); + + ret = std::tr1::nearbyint(d0); + fret = std::tr1::nearbyintf(f0); + ldret = std::tr1::nearbyintl(ld0); + + ret = std::tr1::nextafter(d0, d0); + fret = std::tr1::nextafterf(f0, f0); + ldret = std::tr1::nextafterl(ld0, ld0); + + ret = std::tr1::nexttoward(d0, ld0); + fret = std::tr1::nexttowardf(f0, ld0); + ldret = std::tr1::nexttowardl(ld0, ld0); + + ret = std::tr1::remainder(d0, d0); + fret = std::tr1::remainderf(f0, f0); + ldret = std::tr1::remainderl(ld0, ld0); + + ret = std::tr1::remquo(d0, d0, pquo); + fret = std::tr1::remquof(f0, f0, pquo); + ldret = std::tr1::remquol(ld0, ld0, pquo); + + ret = std::tr1::rint(d0); + fret = std::tr1::rintf(f0); + ldret = std::tr1::rintl(ld0); + + ret = std::tr1::round(d0); + fret = std::tr1::roundf(f0); + ldret = std::tr1::roundl(ld0); + + ret = std::tr1::scalbln(d0, lex); + fret = std::tr1::scalblnf(f0, lex); + ldret = std::tr1::scalblnl(ld0, lex); + + ret = std::tr1::scalbn(d0, ex); + fret = std::tr1::scalbnf(f0, ex); + ldret = std::tr1::scalbnl(ld0, ex); + + ret = std::tr1::tgamma(d0); + fret = std::tr1::tgammaf(f0); + ldret = std::tr1::tgammal(ld0); + + ret = std::tr1::trunc(d0); + fret = std::tr1::truncf(f0); + ldret = std::tr1::truncl(ld0); + + ret = ret; // Suppress unused warnings. + iret = iret; + lret = lret; + llret = llret; + fret = fret; + ldret = ldret; + +#endif +} diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc new file mode 100644 index 000000000..04bc91275 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/overloads.cc @@ -0,0 +1,257 @@ +// { dg-do compile } + +// 2006-03-07 Paolo Carlini +// +// Copyright (C) 2006, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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 this library; see the file COPYING3. If not see +// . + +// 8.16.4 Additional overloads + +#include +#include + +void test01() +{ +#if _GLIBCXX_USE_C99_MATH_TR1 + + using namespace __gnu_test; + + double d0 = 0.0; + float f0 = 0.0f; + long double ld0 = 0.0l; + int i0 = 0; + int* pquo = 0; + long lex = 0l; + int ex = 0; + + check_ret_type(std::tr1::atan2(d0, d0)); + check_ret_type(std::tr1::atan2(d0, f0)); + check_ret_type(std::tr1::atan2(f0, f0)); + check_ret_type(std::tr1::atan2(ld0, ld0)); + check_ret_type(std::tr1::atan2(ld0, d0)); + check_ret_type(std::tr1::atan2(i0, i0)); + check_ret_type(std::tr1::atan2(d0, i0)); + + check_ret_type(std::tr1::acosh(d0)); + check_ret_type(std::tr1::acosh(f0)); + check_ret_type(std::tr1::acosh(ld0)); + check_ret_type(std::tr1::acosh(i0)); + + check_ret_type(std::tr1::asinh(d0)); + check_ret_type(std::tr1::asinh(f0)); + check_ret_type(std::tr1::asinh(ld0)); + check_ret_type(std::tr1::asinh(i0)); + + check_ret_type(std::tr1::atanh(d0)); + check_ret_type(std::tr1::atanh(f0)); + check_ret_type(std::tr1::atanh(ld0)); + check_ret_type(std::tr1::atanh(i0)); + + check_ret_type(std::tr1::cbrt(d0)); + check_ret_type(std::tr1::cbrt(f0)); + check_ret_type(std::tr1::cbrt(ld0)); + check_ret_type(std::tr1::cbrt(i0)); + + check_ret_type(std::tr1::copysign(d0, d0)); + check_ret_type(std::tr1::copysign(d0, f0)); + check_ret_type(std::tr1::copysign(f0, f0)); + check_ret_type(std::tr1::copysign(ld0, ld0)); + check_ret_type(std::tr1::copysign(ld0, d0)); + check_ret_type(std::tr1::copysign(i0, i0)); + check_ret_type(std::tr1::copysign(d0, i0)); + + check_ret_type(std::tr1::erf(d0)); + check_ret_type(std::tr1::erf(f0)); + check_ret_type(std::tr1::erf(ld0)); + check_ret_type(std::tr1::erf(i0)); + + check_ret_type(std::tr1::erfc(d0)); + check_ret_type(std::tr1::erfc(f0)); + check_ret_type(std::tr1::erfc(ld0)); + check_ret_type(std::tr1::erfc(i0)); + + check_ret_type(std::tr1::exp2(d0)); + check_ret_type(std::tr1::exp2(f0)); + check_ret_type(std::tr1::exp2(ld0)); + check_ret_type(std::tr1::exp2(i0)); + + check_ret_type(std::tr1::expm1(d0)); + check_ret_type(std::tr1::expm1(f0)); + check_ret_type(std::tr1::expm1(ld0)); + check_ret_type(std::tr1::expm1(i0)); + + check_ret_type(std::tr1::fdim(d0, d0)); + check_ret_type(std::tr1::fdim(d0, f0)); + check_ret_type(std::tr1::fdim(f0, f0)); + check_ret_type(std::tr1::fdim(ld0, ld0)); + check_ret_type(std::tr1::fdim(ld0, d0)); + check_ret_type(std::tr1::fdim(i0, i0)); + check_ret_type(std::tr1::fdim(d0, i0)); + + check_ret_type(std::tr1::fma(d0, d0, d0)); + check_ret_type(std::tr1::fma(d0, f0, d0)); + check_ret_type(std::tr1::fma(f0, f0, f0)); + check_ret_type(std::tr1::fma(ld0, ld0, ld0)); + check_ret_type(std::tr1::fma(ld0, d0, f0)); + check_ret_type(std::tr1::fma(i0, i0, i0)); + check_ret_type(std::tr1::fma(d0, i0, f0)); + + check_ret_type(std::tr1::fmax(d0, d0)); + check_ret_type(std::tr1::fmax(d0, f0)); + check_ret_type(std::tr1::fmax(f0, f0)); + check_ret_type(std::tr1::fmax(ld0, ld0)); + check_ret_type(std::tr1::fmax(ld0, d0)); + check_ret_type(std::tr1::fmax(i0, i0)); + check_ret_type(std::tr1::fmax(d0, i0)); + + check_ret_type(std::tr1::fmin(d0, d0)); + check_ret_type(std::tr1::fmin(d0, f0)); + check_ret_type(std::tr1::fmin(f0, f0)); + check_ret_type(std::tr1::fmin(ld0, ld0)); + check_ret_type(std::tr1::fmin(ld0, d0)); + check_ret_type(std::tr1::fmin(i0, i0)); + check_ret_type(std::tr1::fmin(d0, i0)); + + check_ret_type(std::tr1::hypot(d0, d0)); + check_ret_type(std::tr1::hypot(d0, f0)); + check_ret_type(std::tr1::hypot(f0, f0)); + check_ret_type(std::tr1::hypot(ld0, ld0)); + check_ret_type(std::tr1::hypot(ld0, d0)); + check_ret_type(std::tr1::hypot(i0, i0)); + check_ret_type(std::tr1::hypot(d0, i0)); + + check_ret_type(std::tr1::ilogb(d0)); + check_ret_type(std::tr1::ilogb(f0)); + check_ret_type(std::tr1::ilogb(ld0)); + check_ret_type(std::tr1::ilogb(i0)); + + check_ret_type(std::tr1::lgamma(d0)); + check_ret_type(std::tr1::lgamma(f0)); + check_ret_type(std::tr1::lgamma(ld0)); + check_ret_type(std::tr1::lgamma(i0)); + + check_ret_type(std::tr1::llrint(d0)); + check_ret_type(std::tr1::llrint(f0)); + check_ret_type(std::tr1::llrint(ld0)); + check_ret_type(std::tr1::llrint(i0)); + + check_ret_type(std::tr1::llround(d0)); + check_ret_type(std::tr1::llround(f0)); + check_ret_type(std::tr1::llround(ld0)); + check_ret_type(std::tr1::llround(i0)); + + check_ret_type(std::tr1::log1p(d0)); + check_ret_type(std::tr1::log1p(f0)); + check_ret_type(std::tr1::log1p(ld0)); + check_ret_type(std::tr1::log1p(i0)); + + // DR 568. + check_ret_type(std::tr1::log2(d0)); + check_ret_type(std::tr1::log2(f0)); + check_ret_type(std::tr1::log2(ld0)); + check_ret_type(std::tr1::log2(i0)); + + check_ret_type(std::tr1::logb(d0)); + check_ret_type(std::tr1::logb(f0)); + check_ret_type(std::tr1::logb(ld0)); + check_ret_type(std::tr1::logb(i0)); + + check_ret_type(std::tr1::lrint(d0)); + check_ret_type(std::tr1::lrint(f0)); + check_ret_type(std::tr1::lrint(ld0)); + check_ret_type(std::tr1::lrint(i0)); + + check_ret_type(std::tr1::lround(d0)); + check_ret_type(std::tr1::lround(f0)); + check_ret_type(std::tr1::lround(ld0)); + check_ret_type(std::tr1::lround(i0)); + + check_ret_type(std::tr1::nearbyint(d0)); + check_ret_type(std::tr1::nearbyint(f0)); + check_ret_type(std::tr1::nearbyint(ld0)); + check_ret_type(std::tr1::nearbyint(i0)); + + check_ret_type(std::tr1::nextafter(d0, d0)); + check_ret_type(std::tr1::nextafter(d0, f0)); + check_ret_type(std::tr1::nextafter(f0, f0)); + check_ret_type(std::tr1::nextafter(ld0, ld0)); + check_ret_type(std::tr1::nextafter(ld0, d0)); + check_ret_type(std::tr1::nextafter(i0, i0)); + check_ret_type(std::tr1::nextafter(d0, i0)); + + check_ret_type(std::tr1::nexttoward(d0, ld0)); + check_ret_type(std::tr1::nexttoward(f0, ld0)); + check_ret_type(std::tr1::nexttoward(ld0, ld0)); + check_ret_type(std::tr1::nexttoward(i0, ld0)); + + check_ret_type(std::tr1::pow(d0, d0)); + check_ret_type(std::tr1::pow(d0, f0)); + check_ret_type(std::tr1::pow(f0, f0)); + check_ret_type(std::tr1::pow(ld0, ld0)); + check_ret_type(std::tr1::pow(ld0, d0)); + check_ret_type(std::tr1::pow(i0, i0)); + check_ret_type(std::tr1::pow(d0, i0)); + check_ret_type(std::tr1::pow(f0, i0)); + + check_ret_type(std::tr1::remainder(d0, d0)); + check_ret_type(std::tr1::remainder(d0, f0)); + check_ret_type(std::tr1::remainder(f0, f0)); + check_ret_type(std::tr1::remainder(ld0, ld0)); + check_ret_type(std::tr1::remainder(ld0, d0)); + check_ret_type(std::tr1::remainder(i0, i0)); + check_ret_type(std::tr1::remainder(d0, i0)); + + check_ret_type(std::tr1::remquo(d0, d0, pquo)); + check_ret_type(std::tr1::remquo(d0, f0, pquo)); + check_ret_type(std::tr1::remquo(f0, f0, pquo)); + check_ret_type(std::tr1::remquo(ld0, ld0, pquo)); + check_ret_type(std::tr1::remquo(ld0, d0, pquo)); + check_ret_type(std::tr1::remquo(i0, i0, pquo)); + check_ret_type(std::tr1::remquo(d0, i0, pquo)); + + check_ret_type(std::tr1::rint(d0)); + check_ret_type(std::tr1::rint(f0)); + check_ret_type(std::tr1::rint(ld0)); + check_ret_type(std::tr1::rint(i0)); + + check_ret_type(std::tr1::round(d0)); + check_ret_type(std::tr1::round(f0)); + check_ret_type(std::tr1::round(ld0)); + check_ret_type(std::tr1::round(i0)); + + check_ret_type(std::tr1::scalbln(d0, lex)); + check_ret_type(std::tr1::scalbln(f0, lex)); + check_ret_type(std::tr1::scalbln(ld0, lex)); + check_ret_type(std::tr1::scalbln(i0, lex)); + + check_ret_type(std::tr1::scalbn(d0, ex)); + check_ret_type(std::tr1::scalbn(f0, ex)); + check_ret_type(std::tr1::scalbn(ld0, ex)); + check_ret_type(std::tr1::scalbn(i0, ex)); + + check_ret_type(std::tr1::tgamma(d0)); + check_ret_type(std::tr1::tgamma(f0)); + check_ret_type(std::tr1::tgamma(ld0)); + check_ret_type(std::tr1::tgamma(i0)); + + check_ret_type(std::tr1::trunc(d0)); + check_ret_type(std::tr1::trunc(f0)); + check_ret_type(std::tr1::trunc(ld0)); + check_ret_type(std::tr1::trunc(i0)); + +#endif +} diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/templates.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/templates.cc new file mode 100644 index 000000000..cbf8c9592 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/templates.cc @@ -0,0 +1,64 @@ +// { dg-do compile } + +// 2006-02-26 Paolo Carlini +// +// Copyright (C) 2006, 2009, 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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 this library; see the file COPYING3. If not see +// . + +// 8.16 Additions to header + +#include + +#if _GLIBCXX_USE_C99 +#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC + +template + void test01_do() + { + T x = T(); + + bool ret; + int iret; + + ret = std::tr1::signbit(x); + + iret = std::tr1::fpclassify(x); + iret = iret; // Suppress unused warning. + + ret = std::tr1::isfinite(x); + ret = std::tr1::isinf(x); + ret = std::tr1::isnan(x); + ret = std::tr1::isnormal(x); + + ret = std::tr1::isgreater(x, x); + ret = std::tr1::isgreaterequal(x, x); + ret = std::tr1::isless(x, x); + ret = std::tr1::islessequal(x, x); + ret = std::tr1::islessgreater(x, x); + ret = std::tr1::isunordered(x, x); + ret = ret; // Suppress unused warning. + } + +void test01() +{ + test01_do(); + test01_do(); + test01_do(); +} + +#endif +#endif diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/types_std_tr1.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/types_std_tr1.cc new file mode 100644 index 000000000..8786c8eff --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/cmath/types_std_tr1.cc @@ -0,0 +1,34 @@ +// { dg-do compile } + +// 2006-03-10 Paolo Carlini +// +// Copyright (C) 2006, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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 this library; see the file COPYING3. If not see +// . + +// 8.16 Additions to header + +#include + +void test01() +{ +#if _GLIBCXX_USE_C99_MATH_TR1 + + typedef std::tr1::double_t my_double_t; + typedef std::tr1::float_t my_float_t; + +#endif +} -- cgit v1.2.3