Return-Path: Delivered-To: apmail-incubator-stdcxx-commits-archive@www.apache.org Received: (qmail 97862 invoked from network); 13 Oct 2005 21:49:04 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 13 Oct 2005 21:49:04 -0000 Received: (qmail 30815 invoked by uid 500); 13 Oct 2005 21:49:04 -0000 Delivered-To: apmail-incubator-stdcxx-commits-archive@incubator.apache.org Received: (qmail 30796 invoked by uid 500); 13 Oct 2005 21:49:04 -0000 Mailing-List: contact stdcxx-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: stdcxx-dev@incubator.apache.org Delivered-To: mailing list stdcxx-commits@incubator.apache.org Received: (qmail 30785 invoked by uid 500); 13 Oct 2005 21:49:03 -0000 Delivered-To: apmail-incubator-stdcxx-cvs@incubator.apache.org Received: (qmail 30782 invoked by uid 99); 13 Oct 2005 21:49:03 -0000 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received: from [209.237.227.194] (HELO minotaur.apache.org) (209.237.227.194) by apache.org (qpsmtpd/0.29) with SMTP; Thu, 13 Oct 2005 14:49:03 -0700 Received: (qmail 97814 invoked by uid 65534); 13 Oct 2005 21:48:43 -0000 Message-ID: <20051013214843.97813.qmail@minotaur.apache.org> Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r320933 - in /incubator/stdcxx/trunk/tests/numerics: ./ 26.c.math.cpp Date: Thu, 13 Oct 2005 21:48:42 -0000 To: stdcxx-cvs@incubator.apache.org From: sebor@apache.org X-Mailer: svnmailer-1.0.5 X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Author: sebor Date: Thu Oct 13 14:48:39 2005 New Revision: 320933 URL: http://svn.apache.org/viewcvs?rev=320933&view=rev Log: 2005-10-13 Martin Sebor STDCXX-46 * 26.c.math.cpp: New test exercising lib.c.math. Added: incubator/stdcxx/trunk/tests/numerics/ incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp (with props) Added: incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp?rev=320933&view=auto ============================================================================== --- incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp (added) +++ incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp Thu Oct 13 14:48:39 2005 @@ -0,0 +1,346 @@ +/*************************************************************************** + * + * 26.c.math.cpp - test exercising [lib.c.math] + * + * $Id$ + * + *************************************************************************** + * + * Copyright (c) 1994-2005 Quovadx, Inc., acting through its Rogue Wave + * Software division. Licensed under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0. Unless required by + * applicable law or agreed to in writing, software distributed under + * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License + * for the specific language governing permissions and limitations under + * the License. + * + **************************************************************************/ + +// this may be the "native" header that comes with the compiler +// do not assume that any of our stuff (i.e., macros) is available + +#if defined (__IBMCPP__) && !defined (_RWSTD_NO_IMPLICIT_INCLUSION) +// Disable implicit inclusion to work around +// a limitation in IBM's VisualAge 5.0.2.0 (see PR#26959) + +# define _RWSTD_NO_IMPLICIT_INCLUSION +#endif + +#include +#include + +#include +#include +#include + + +// define function templates with the same signatures as +// the required overloads; if the required overloads are +// not defined, the corresponding specializations of the +// function templates will be instantiated and called, +// triggering an assertion + +#define FUN_1(name) \ + template \ + T name (T) { \ + static const char* const tname = rw_any (T ()).type_name (); \ + rw_assert (0, 0, __LINE__, "std::%s(%s) not declared\n", \ + #name, tname); \ + return T (); \ + } typedef void unused_typedef + +#define FUN_2(name) \ + template \ + T name (T, T) { \ + static const char* const tname = rw_any (T ()).type_name (); \ + rw_assert (0, 0, __LINE__, "std::%s (%s, %s) not declared\n", \ + #name, tname, tname); \ + return T (); \ + } typedef void unused_typedef + +#define FUN_2_PTR(name) \ + template \ + T name (T, T*) { \ + static const char* const tname = rw_any (T ()).type_name (); \ + rw_assert (0, 0, __LINE__, "std::%s (%s, %s*) not declared\n", \ + #name, tname, tname); \ + return T (); \ + } typedef void unused_typedef + +#define FUN_2_INT(name) \ + template \ + T name (T, int) { \ + static const char* const tname = rw_any (T ()).type_name (); \ + rw_assert (0, 0, __LINE__, "std::%s (%s, int) not declared\n", \ + #name, tname); \ + return T (); \ + } typedef void unused_typedef + +#define FUN_2_PINT(name) \ + template \ + T name (T, int*) { \ + static const char* const tname = rw_any (T ()).type_name (); \ + rw_assert (0, 0, __LINE__, "std::%s (%s, int*) not declared\n", \ + #name, tname); \ + return T (); \ + } typedef void unused_typedef + + +_RWSTD_NAMESPACE (std) { + +// abs() is not declared in the C header but is required +// to be declared in the C++ headers and +FUN_1 (abs); +FUN_1 (acos); +FUN_1 (asin); +FUN_1 (atan); +FUN_2 (atan2); +FUN_1 (ceil); +FUN_1 (cos); +FUN_1 (cosh); +FUN_1 (div); +FUN_1 (exp); +FUN_1 (fabs); +FUN_1 (floor); +FUN_2 (fmod); +FUN_2_PINT (frexp); +FUN_2_INT (ldexp); +FUN_1 (log); +FUN_1 (log10); +FUN_2_PTR (modf); +FUN_2 (pow); +FUN_2_INT (pow); +FUN_1 (sin); +FUN_1 (sinh); +FUN_1 (sqrt); +FUN_1 (tan); +FUN_1 (tanh); + +} // namespace std + + +// returns true if all `size' bytes starting at `s' are 0 +static bool +check_bits (const char *s, unsigned size) +{ + while (size-- && !s [size]); + return unsigned (-1) == size; +} + + +static void +clear_bytes (void *pb, _RWSTD_SIZE_T size) +{ + for (_RWSTD_SIZE_T i = 0; i != size; ++i) + ((char*)pb)[i] = 0; +} + + +static void +test_behavior () +{ + union { + float f; + double d; + +#ifndef _RWSTD_NO_LONG_DOUBLE + long double l; +#endif // _RWSTD_NO_LONG_DOUBLE + + char buf [sizeof (long double) * 2]; + } u; + +#if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530 + + // make sure functions do not overflow buffer + clear_bytes (u.buf, sizeof u); + + const float f = std::modf (3.141592f, &u.f); + + rw_assert ( 3000 == int (u.f * 1000) && 141592 == int (f * 1000000) + && check_bits (u.buf + sizeof u.f, sizeof u - sizeof u.f), + 0, __LINE__, "float std::modf (float)"); + +#endif // SunPro > 5.3 + + clear_bytes (u.buf, sizeof u); + const double d = std::modf (3.1415926, &u.d); + + rw_assert ( 3000 == int (u.d * 1000) && 1415926 == int (d * 10000000) + && check_bits (u.buf + sizeof u.d, sizeof u - sizeof u.d), + 0, __LINE__, "double std::modf (double)"); + +#ifndef _RWSTD_NO_LONG_DOUBLE + +# if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530 + + clear_bytes (u.buf, sizeof u); + const long double l = std::modf (3.1415926L, &u.l); + + rw_assert ( 3000 == int (u.l * 1000) && 1415926 == int (l * 10000000) + && check_bits (u.buf + sizeof u.l, sizeof u - sizeof u.l), + 0, __LINE__, "long double std::modf (long double)"); + +# endif // SunPro > 5.3 + +#endif // _RWSTD_NO_LONG_DOUBLE + + + // check overloads of std::pow() + for (int i = -10; i != 10; ++i) { + for (int j = -10; j != 10; ++j) { + + if (-9 < j && j < 9) { + // verify that both versions are equivalent + const float xf = std::pow (float (i), int (j)); + const float yf = std::pow (float (i), float (j)); + + rw_assert (rw_equal (xf, yf) || !i && j < 0, + 0, __LINE__, + "std::pow (%d.0f, %d) = %g, " + "std::pow (%d,0f, %d.0f) = %g", + i, j, xf, i, j, yf); + } + + const float xd = std::pow (double (i), int (j)); + const float yd = std::pow (double (i), double (j)); + + rw_assert (rw_equal (xd, yd) || !i && j < 0, + 0, __LINE__, + "std::pow (%d.0, %d) = %g, " + "std::pow (%d.0, %d.0) = %g", + i, j, xd, i, j, yd); + +#ifndef _RWSTD_NO_LONG_DOUBLE + + const long double xl = std::pow ((long double)i, int (j)); + const long double yl = std::pow ((long double)i, (long double)j); + + rw_assert (rw_equal (xl, yl) || !i && j < 0, + 0, __LINE__, + "std::pow (%d.0L, %d) = %Lg, " + "std::pow (%d.0L, %d.0L) = %Lg", + i, j, xl, i, j, yl); + +#endif // _RWSTD_NO_LONG_DOUBLE + + } + } +} + + +static void +test_declarations () +{ + _USING (namespace std); + + int i = 1; + long l = 1; + + float f = 0.1; + double d = 0.1; + +#ifndef _RWSTD_NO_LONG_DOUBLE + + long double ld = 0.1; + +# define CHECK_OVERLOADS(name) \ + rw_info (0, 0, __LINE__, "std::%s() overloads ", #name); \ + (void)name (f); \ + (void)name (d); \ + (void)name (ld) +#else // if defined (_RWSTD_NO_LONG_DOUBLE) +# define CHECK_OVERLOADS(name) \ + rw_info (0, 0, __LINE__, "std::%s() overloads", #name); \ + (void)name (f); \ + (void)name (d) +#endif // _RWSTD_NO_LONG_DOUBLE + + CHECK_OVERLOADS (abs); + CHECK_OVERLOADS (acos); + CHECK_OVERLOADS (asin); + CHECK_OVERLOADS (atan); + CHECK_OVERLOADS (atan); + CHECK_OVERLOADS (ceil); + CHECK_OVERLOADS (cos); + CHECK_OVERLOADS (cosh); + CHECK_OVERLOADS (exp); + CHECK_OVERLOADS (fabs); + CHECK_OVERLOADS (floor); + + rw_info (0, 0, __LINE__, "std::%s() overloads", "fmod"); + (void)fmod (f, f); (void)fmod (d, d); + + rw_info (0, 0, __LINE__, "std::%s() overloads", "frexp"); + (void)frexp (f, &i); (void)frexp (d, &i); + + rw_info (0, 0, __LINE__, "std::%s() overloads", "ldexp"); + (void)ldexp (f, i); (void)ldexp (d, i); + + CHECK_OVERLOADS (log); + CHECK_OVERLOADS (log10); + + rw_info (0, 0, __LINE__, "std::%s() overloads", "modf"); + (void)modf (f, &f); (void)modf (d, &d); + + rw_info (0, 0, __LINE__, "std::%s() overloads", "pow"); + (void)pow (f, f); (void)pow (d, d); + (void)pow (f, i); (void)pow (d, i); + + CHECK_OVERLOADS (sin); + CHECK_OVERLOADS (sinh); + CHECK_OVERLOADS (sqrt); + CHECK_OVERLOADS (tan); + CHECK_OVERLOADS (tanh); + +#ifndef _RWSTD_NO_LONG_DOUBLE + + (void)atan2 (ld, ld); + (void)fmod (ld, ld); + (void)frexp (ld, &i); + (void)ldexp (ld, i); + (void)modf (ld, &d); + (void)pow (ld, ld); + (void)pow (ld, i); + +#endif // _RWSTD_NO_LONG_DOUBLE + + rw_info (0, 0, __LINE__, "std::%s() overloads", "div"); + (void)div (i, i); + (void)div (l, l); +} + +/**************************************************************************/ + +static int no_declarations; +static int no_behavior; + + +int run_test (int, char*[]) +{ + if (no_declarations) + rw_note (0, __FILE__, __LINE__, "test of declarations disabled"); + else + test_declarations (); + + if (no_behavior) + rw_note (0, __FILE__, __LINE__, "test of behavior disabled"); + else + test_behavior (); + + return 0; +} + +/**************************************************************************/ + +int main (int argc, char *argv[]) +{ + return rw_test (argc, argv, __FILE__, + "lib.c.math", + 0 /* no comment */, run_test, + "|-no-declarations# |-no-behavior#", + &no_declarations, &no_behavior); +} Propchange: incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp ------------------------------------------------------------------------------ svn:eol-style = native Propchange: incubator/stdcxx/trunk/tests/numerics/26.c.math.cpp ------------------------------------------------------------------------------ svn:keywords = Id