1272343Sngie/* $NetBSD: t_scalbn.c,v 1.11 2014/03/03 10:39:08 martin Exp $ */ 2272343Sngie 3272343Sngie/*- 4272343Sngie * Copyright (c) 2011 The NetBSD Foundation, Inc. 5272343Sngie * All rights reserved. 6272343Sngie * 7272343Sngie * This code is derived from software contributed to The NetBSD Foundation 8272343Sngie * by Jukka Ruohonen. 9272343Sngie * 10272343Sngie * Redistribution and use in source and binary forms, with or without 11272343Sngie * modification, are permitted provided that the following conditions 12272343Sngie * are met: 13272343Sngie * 1. Redistributions of source code must retain the above copyright 14272343Sngie * notice, this list of conditions and the following disclaimer. 15272343Sngie * 2. Redistributions in binary form must reproduce the above copyright 16272343Sngie * notice, this list of conditions and the following disclaimer in the 17272343Sngie * documentation and/or other materials provided with the distribution. 18272343Sngie * 19272343Sngie * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20272343Sngie * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21272343Sngie * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22272343Sngie * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23272343Sngie * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24272343Sngie * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25272343Sngie * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26272343Sngie * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27272343Sngie * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28272343Sngie * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29272343Sngie * POSSIBILITY OF SUCH DAMAGE. 30272343Sngie */ 31272343Sngie#include <sys/cdefs.h> 32272343Sngie__RCSID("$NetBSD: t_scalbn.c,v 1.11 2014/03/03 10:39:08 martin Exp $"); 33272343Sngie 34272343Sngie#include <math.h> 35272343Sngie#include <limits.h> 36272343Sngie#include <float.h> 37272343Sngie#include <errno.h> 38272343Sngie 39272343Sngie#include <atf-c.h> 40272343Sngie 41272343Sngiestatic const int exps[] = { 0, 1, -1, 100, -100 }; 42272343Sngie 43272343Sngie/* tests here do not require specific precision, so we just use double */ 44272343Sngiestruct testcase { 45272343Sngie int exp; 46272343Sngie double inval; 47272343Sngie double result; 48272343Sngie int error; 49272343Sngie}; 50272343Sngiestruct testcase test_vals[] = { 51272343Sngie { 0, 1.00085, 1.00085, 0 }, 52272343Sngie { 0, 0.99755, 0.99755, 0 }, 53272343Sngie { 0, -1.00085, -1.00085, 0 }, 54272343Sngie { 0, -0.99755, -0.99755, 0 }, 55272343Sngie { 1, 1.00085, 2.0* 1.00085, 0 }, 56272343Sngie { 1, 0.99755, 2.0* 0.99755, 0 }, 57272343Sngie { 1, -1.00085, 2.0* -1.00085, 0 }, 58272343Sngie { 1, -0.99755, 2.0* -0.99755, 0 }, 59272343Sngie 60272343Sngie /* 61272343Sngie * We could add more corner test cases here, but we would have to 62272343Sngie * add some ifdefs for the exact format and use a reliable 63272343Sngie * generator program - bail for now and only do trivial stuff above. 64272343Sngie */ 65272343Sngie}; 66272343Sngie 67272343Sngie/* 68272343Sngie * scalbn(3) 69272343Sngie */ 70272343SngieATF_TC(scalbn_val); 71272343SngieATF_TC_HEAD(scalbn_val, tc) 72272343Sngie{ 73272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn() for a few values"); 74272343Sngie} 75272343Sngie 76272343SngieATF_TC_BODY(scalbn_val, tc) 77272343Sngie{ 78272343Sngie const struct testcase *tests = test_vals; 79272343Sngie const size_t tcnt = __arraycount(test_vals); 80272343Sngie size_t i; 81272343Sngie double rv; 82272343Sngie 83272343Sngie for (i = 0; i < tcnt; i++) { 84274598Sngie#ifdef __FreeBSD__ 85274598Sngie errno = 0; 86274598Sngie#endif 87272343Sngie rv = scalbn(tests[i].inval, tests[i].exp); 88272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 89272343Sngie "test %zu: errno %d instead of %d", i, errno, 90272343Sngie tests[i].error); 91272343Sngie ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*DBL_EPSILON, 92272343Sngie "test %zu: return value %g instead of %g (difference %g)", 93272343Sngie i, rv, tests[i].result, tests[i].result-rv); 94272343Sngie } 95272343Sngie} 96272343Sngie 97272343SngieATF_TC(scalbn_nan); 98272343SngieATF_TC_HEAD(scalbn_nan, tc) 99272343Sngie{ 100272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(NaN, n) == NaN"); 101272343Sngie} 102272343Sngie 103272343SngieATF_TC_BODY(scalbn_nan, tc) 104272343Sngie{ 105272343Sngie const double x = 0.0L / 0.0L; 106272343Sngie double y; 107272343Sngie size_t i; 108272343Sngie 109272343Sngie ATF_REQUIRE(isnan(x) != 0); 110272343Sngie 111272343Sngie for (i = 0; i < __arraycount(exps); i++) { 112272343Sngie y = scalbn(x, exps[i]); 113272343Sngie ATF_CHECK(isnan(y) != 0); 114272343Sngie } 115272343Sngie} 116272343Sngie 117272343SngieATF_TC(scalbn_inf_neg); 118272343SngieATF_TC_HEAD(scalbn_inf_neg, tc) 119272343Sngie{ 120272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(-Inf, n) == -Inf"); 121272343Sngie} 122272343Sngie 123272343SngieATF_TC_BODY(scalbn_inf_neg, tc) 124272343Sngie{ 125272343Sngie const double x = -1.0L / 0.0L; 126272343Sngie size_t i; 127272343Sngie 128272343Sngie for (i = 0; i < __arraycount(exps); i++) 129272343Sngie ATF_CHECK(scalbn(x, exps[i]) == x); 130272343Sngie} 131272343Sngie 132272343SngieATF_TC(scalbn_inf_pos); 133272343SngieATF_TC_HEAD(scalbn_inf_pos, tc) 134272343Sngie{ 135272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(+Inf, n) == +Inf"); 136272343Sngie} 137272343Sngie 138272343SngieATF_TC_BODY(scalbn_inf_pos, tc) 139272343Sngie{ 140272343Sngie const double x = 1.0L / 0.0L; 141272343Sngie size_t i; 142272343Sngie 143272343Sngie for (i = 0; i < __arraycount(exps); i++) 144272343Sngie ATF_CHECK(scalbn(x, exps[i]) == x); 145272343Sngie} 146272343Sngie 147272343SngieATF_TC(scalbn_ldexp); 148272343SngieATF_TC_HEAD(scalbn_ldexp, tc) 149272343Sngie{ 150272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(x, n) == ldexp(x, n)"); 151272343Sngie} 152272343Sngie 153272343SngieATF_TC_BODY(scalbn_ldexp, tc) 154272343Sngie{ 155272343Sngie#if FLT_RADIX == 2 156272343Sngie const double x = 2.91288191221812821; 157272343Sngie double y; 158272343Sngie size_t i; 159272343Sngie 160272343Sngie for (i = 0; i < __arraycount(exps); i++) { 161272343Sngie y = scalbn(x, exps[i]); 162272343Sngie ATF_CHECK_MSG(y == ldexp(x, exps[i]), "test %zu: exponent=%d, " 163272343Sngie "y=%g, expected %g (diff: %g)", i, exps[i], y, 164272343Sngie ldexp(x, exps[i]), y - ldexp(x, exps[i])); 165272343Sngie } 166272343Sngie#endif 167272343Sngie} 168272343Sngie 169272343SngieATF_TC(scalbn_zero_neg); 170272343SngieATF_TC_HEAD(scalbn_zero_neg, tc) 171272343Sngie{ 172272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(-0.0, n) == -0.0"); 173272343Sngie} 174272343Sngie 175272343SngieATF_TC_BODY(scalbn_zero_neg, tc) 176272343Sngie{ 177272343Sngie const double x = -0.0L; 178272343Sngie double y; 179272343Sngie size_t i; 180272343Sngie 181272343Sngie ATF_REQUIRE(signbit(x) != 0); 182272343Sngie 183272343Sngie for (i = 0; i < __arraycount(exps); i++) { 184272343Sngie y = scalbn(x, exps[i]); 185272343Sngie ATF_CHECK(x == y); 186272343Sngie ATF_CHECK(signbit(y) != 0); 187272343Sngie } 188272343Sngie} 189272343Sngie 190272343SngieATF_TC(scalbn_zero_pos); 191272343SngieATF_TC_HEAD(scalbn_zero_pos, tc) 192272343Sngie{ 193272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(+0.0, n) == +0.0"); 194272343Sngie} 195272343Sngie 196272343SngieATF_TC_BODY(scalbn_zero_pos, tc) 197272343Sngie{ 198272343Sngie const double x = 0.0L; 199272343Sngie double y; 200272343Sngie size_t i; 201272343Sngie 202272343Sngie ATF_REQUIRE(signbit(x) == 0); 203272343Sngie 204272343Sngie for (i = 0; i < __arraycount(exps); i++) { 205272343Sngie y = scalbn(x, exps[i]); 206272343Sngie ATF_CHECK(x == y); 207272343Sngie ATF_CHECK(signbit(y) == 0); 208272343Sngie } 209272343Sngie} 210272343Sngie 211272343Sngie/* 212272343Sngie * scalbnf(3) 213272343Sngie */ 214272343SngieATF_TC(scalbnf_val); 215272343SngieATF_TC_HEAD(scalbnf_val, tc) 216272343Sngie{ 217272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf() for a few values"); 218272343Sngie} 219272343Sngie 220272343SngieATF_TC_BODY(scalbnf_val, tc) 221272343Sngie{ 222272343Sngie const struct testcase *tests = test_vals; 223272343Sngie const size_t tcnt = __arraycount(test_vals); 224272343Sngie size_t i; 225272343Sngie double rv; 226272343Sngie 227272343Sngie for (i = 0; i < tcnt; i++) { 228276521Sngie#ifdef __FreeBSD__ 229276521Sngie errno = 0; 230276521Sngie#endif 231272343Sngie rv = scalbnf(tests[i].inval, tests[i].exp); 232272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 233272343Sngie "test %zu: errno %d instead of %d", i, errno, 234272343Sngie tests[i].error); 235272343Sngie ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*FLT_EPSILON, 236272343Sngie "test %zu: return value %g instead of %g (difference %g)", 237272343Sngie i, rv, tests[i].result, tests[i].result-rv); 238272343Sngie } 239272343Sngie} 240272343Sngie 241272343SngieATF_TC(scalbnf_nan); 242272343SngieATF_TC_HEAD(scalbnf_nan, tc) 243272343Sngie{ 244272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(NaN, n) == NaN"); 245272343Sngie} 246272343Sngie 247272343SngieATF_TC_BODY(scalbnf_nan, tc) 248272343Sngie{ 249272343Sngie const float x = 0.0L / 0.0L; 250272343Sngie float y; 251272343Sngie size_t i; 252272343Sngie 253272343Sngie ATF_REQUIRE(isnan(x) != 0); 254272343Sngie 255272343Sngie for (i = 0; i < __arraycount(exps); i++) { 256272343Sngie y = scalbnf(x, exps[i]); 257272343Sngie ATF_CHECK(isnan(y) != 0); 258272343Sngie } 259272343Sngie} 260272343Sngie 261272343SngieATF_TC(scalbnf_inf_neg); 262272343SngieATF_TC_HEAD(scalbnf_inf_neg, tc) 263272343Sngie{ 264272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(-Inf, n) == -Inf"); 265272343Sngie} 266272343Sngie 267272343SngieATF_TC_BODY(scalbnf_inf_neg, tc) 268272343Sngie{ 269272343Sngie const float x = -1.0L / 0.0L; 270272343Sngie size_t i; 271272343Sngie 272272343Sngie for (i = 0; i < __arraycount(exps); i++) 273272343Sngie ATF_CHECK(scalbnf(x, exps[i]) == x); 274272343Sngie} 275272343Sngie 276272343SngieATF_TC(scalbnf_inf_pos); 277272343SngieATF_TC_HEAD(scalbnf_inf_pos, tc) 278272343Sngie{ 279272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(+Inf, n) == +Inf"); 280272343Sngie} 281272343Sngie 282272343SngieATF_TC_BODY(scalbnf_inf_pos, tc) 283272343Sngie{ 284272343Sngie const float x = 1.0L / 0.0L; 285272343Sngie size_t i; 286272343Sngie 287272343Sngie for (i = 0; i < __arraycount(exps); i++) 288272343Sngie ATF_CHECK(scalbnf(x, exps[i]) == x); 289272343Sngie} 290272343Sngie 291272343SngieATF_TC(scalbnf_ldexpf); 292272343SngieATF_TC_HEAD(scalbnf_ldexpf, tc) 293272343Sngie{ 294272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(x, n) == ldexpf(x, n)"); 295272343Sngie} 296272343Sngie 297272343SngieATF_TC_BODY(scalbnf_ldexpf, tc) 298272343Sngie{ 299272343Sngie#if FLT_RADIX == 2 300272343Sngie const float x = 2.91288191221812821; 301272343Sngie float y; 302272343Sngie size_t i; 303272343Sngie 304272343Sngie for (i = 0; i < __arraycount(exps); i++) { 305272343Sngie y = scalbnf(x, exps[i]); 306272343Sngie ATF_CHECK_MSG(y == ldexpf(x, exps[i]), 307272343Sngie "test %zu: exponent=%d, y=%g ldexpf returns %g (diff: %g)", 308272343Sngie i, exps[i], y, ldexpf(x, exps[i]), y-ldexpf(x, exps[i])); 309272343Sngie } 310272343Sngie#endif 311272343Sngie} 312272343Sngie 313272343SngieATF_TC(scalbnf_zero_neg); 314272343SngieATF_TC_HEAD(scalbnf_zero_neg, tc) 315272343Sngie{ 316272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(-0.0, n) == -0.0"); 317272343Sngie} 318272343Sngie 319272343SngieATF_TC_BODY(scalbnf_zero_neg, tc) 320272343Sngie{ 321272343Sngie const float x = -0.0L; 322272343Sngie float y; 323272343Sngie size_t i; 324272343Sngie 325272343Sngie ATF_REQUIRE(signbit(x) != 0); 326272343Sngie 327272343Sngie for (i = 0; i < __arraycount(exps); i++) { 328272343Sngie y = scalbnf(x, exps[i]); 329272343Sngie ATF_CHECK(x == y); 330272343Sngie ATF_CHECK(signbit(y) != 0); 331272343Sngie } 332272343Sngie} 333272343Sngie 334272343SngieATF_TC(scalbnf_zero_pos); 335272343SngieATF_TC_HEAD(scalbnf_zero_pos, tc) 336272343Sngie{ 337272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(+0.0, n) == +0.0"); 338272343Sngie} 339272343Sngie 340272343SngieATF_TC_BODY(scalbnf_zero_pos, tc) 341272343Sngie{ 342272343Sngie const float x = 0.0L; 343272343Sngie float y; 344272343Sngie size_t i; 345272343Sngie 346272343Sngie ATF_REQUIRE(signbit(x) == 0); 347272343Sngie 348272343Sngie for (i = 0; i < __arraycount(exps); i++) { 349272343Sngie y = scalbnf(x, exps[i]); 350272343Sngie ATF_CHECK(x == y); 351272343Sngie ATF_CHECK(signbit(y) == 0); 352272343Sngie } 353272343Sngie} 354272343Sngie 355272343Sngie/* 356272343Sngie * scalbnl(3) 357272343Sngie */ 358272343SngieATF_TC(scalbnl_val); 359272343SngieATF_TC_HEAD(scalbnl_val, tc) 360272343Sngie{ 361272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl() for a few values"); 362272343Sngie} 363272343Sngie 364272343SngieATF_TC_BODY(scalbnl_val, tc) 365272343Sngie{ 366272343Sngie#ifndef __HAVE_LONG_DOUBLE 367272343Sngie atf_tc_skip("Requires long double support"); 368272343Sngie#else 369272343Sngie const struct testcase *tests = test_vals; 370272343Sngie const size_t tcnt = __arraycount(test_vals); 371272343Sngie size_t i; 372272343Sngie long double rv; 373272343Sngie 374272343Sngie for (i = 0; i < tcnt; i++) { 375276521Sngie#ifdef __FreeBSD__ 376276521Sngie errno = 0; 377276521Sngie#endif 378272343Sngie rv = scalbnl(tests[i].inval, tests[i].exp); 379272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 380272343Sngie "test %zu: errno %d instead of %d", i, errno, 381272343Sngie tests[i].error); 382272343Sngie ATF_CHECK_MSG(fabsl(rv-(long double)tests[i].result)<2.0*LDBL_EPSILON, 383272343Sngie "test %zu: return value %Lg instead of %Lg (difference %Lg)", 384272343Sngie i, rv, (long double)tests[i].result, (long double)tests[i].result-rv); 385272343Sngie } 386272343Sngie#endif 387272343Sngie} 388272343Sngie 389272343SngieATF_TC(scalbnl_nan); 390272343SngieATF_TC_HEAD(scalbnl_nan, tc) 391272343Sngie{ 392272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(NaN, n) == NaN"); 393272343Sngie} 394272343Sngie 395272343SngieATF_TC_BODY(scalbnl_nan, tc) 396272343Sngie{ 397272343Sngie#ifndef __HAVE_LONG_DOUBLE 398272343Sngie atf_tc_skip("Requires long double support"); 399272343Sngie#else 400272343Sngie const long double x = 0.0L / 0.0L; 401272343Sngie long double y; 402272343Sngie size_t i; 403272343Sngie 404272343Sngie if (isnan(x) == 0) { 405272343Sngie atf_tc_expect_fail("PR lib/45362"); 406272343Sngie atf_tc_fail("(0.0L / 0.0L) != NaN"); 407272343Sngie } 408272343Sngie 409272343Sngie for (i = 0; i < __arraycount(exps); i++) { 410272343Sngie y = scalbnl(x, exps[i]); 411272343Sngie ATF_CHECK(isnan(y) != 0); 412272343Sngie } 413272343Sngie#endif 414272343Sngie} 415272343Sngie 416272343SngieATF_TC(scalbnl_inf_neg); 417272343SngieATF_TC_HEAD(scalbnl_inf_neg, tc) 418272343Sngie{ 419272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(-Inf, n) == -Inf"); 420272343Sngie} 421272343Sngie 422272343SngieATF_TC_BODY(scalbnl_inf_neg, tc) 423272343Sngie{ 424272343Sngie#ifndef __HAVE_LONG_DOUBLE 425272343Sngie atf_tc_skip("Requires long double support"); 426272343Sngie#else 427272343Sngie const long double x = -1.0L / 0.0L; 428272343Sngie size_t i; 429272343Sngie 430272343Sngie for (i = 0; i < __arraycount(exps); i++) 431272343Sngie ATF_CHECK(scalbnl(x, exps[i]) == x); 432272343Sngie#endif 433272343Sngie} 434272343Sngie 435272343SngieATF_TC(scalbnl_inf_pos); 436272343SngieATF_TC_HEAD(scalbnl_inf_pos, tc) 437272343Sngie{ 438272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(+Inf, n) == +Inf"); 439272343Sngie} 440272343Sngie 441272343SngieATF_TC_BODY(scalbnl_inf_pos, tc) 442272343Sngie{ 443272343Sngie#ifndef __HAVE_LONG_DOUBLE 444272343Sngie atf_tc_skip("Requires long double support"); 445272343Sngie#else 446272343Sngie const long double x = 1.0L / 0.0L; 447272343Sngie size_t i; 448272343Sngie 449272343Sngie for (i = 0; i < __arraycount(exps); i++) 450272343Sngie ATF_CHECK(scalbnl(x, exps[i]) == x); 451272343Sngie#endif 452272343Sngie} 453272343Sngie 454272343SngieATF_TC(scalbnl_zero_neg); 455272343SngieATF_TC_HEAD(scalbnl_zero_neg, tc) 456272343Sngie{ 457272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(-0.0, n) == -0.0"); 458272343Sngie} 459272343Sngie 460272343SngieATF_TC_BODY(scalbnl_zero_neg, tc) 461272343Sngie{ 462272343Sngie#ifndef __HAVE_LONG_DOUBLE 463272343Sngie atf_tc_skip("Requires long double support"); 464272343Sngie#else 465272343Sngie const long double x = -0.0L; 466272343Sngie long double y; 467272343Sngie size_t i; 468272343Sngie 469272343Sngie ATF_REQUIRE(signbit(x) != 0); 470272343Sngie 471272343Sngie for (i = 0; i < __arraycount(exps); i++) { 472272343Sngie y = scalbnl(x, exps[i]); 473272343Sngie ATF_CHECK(x == y); 474272343Sngie ATF_CHECK(signbit(y) != 0); 475272343Sngie } 476272343Sngie#endif 477272343Sngie} 478272343Sngie 479272343SngieATF_TC(scalbnl_zero_pos); 480272343SngieATF_TC_HEAD(scalbnl_zero_pos, tc) 481272343Sngie{ 482272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(+0.0, n) == +0.0"); 483272343Sngie} 484272343Sngie 485272343SngieATF_TC_BODY(scalbnl_zero_pos, tc) 486272343Sngie{ 487272343Sngie#ifndef __HAVE_LONG_DOUBLE 488272343Sngie atf_tc_skip("Requires long double support"); 489272343Sngie#else 490272343Sngie const long double x = 0.0L; 491272343Sngie long double y; 492272343Sngie size_t i; 493272343Sngie 494272343Sngie ATF_REQUIRE(signbit(x) == 0); 495272343Sngie 496272343Sngie for (i = 0; i < __arraycount(exps); i++) { 497272343Sngie y = scalbnl(x, exps[i]); 498272343Sngie ATF_CHECK(x == y); 499272343Sngie ATF_CHECK(signbit(y) == 0); 500272343Sngie } 501272343Sngie#endif 502272343Sngie} 503272343Sngie 504272343SngieATF_TP_ADD_TCS(tp) 505272343Sngie{ 506272343Sngie 507272343Sngie ATF_TP_ADD_TC(tp, scalbn_val); 508272343Sngie ATF_TP_ADD_TC(tp, scalbn_nan); 509272343Sngie ATF_TP_ADD_TC(tp, scalbn_inf_neg); 510272343Sngie ATF_TP_ADD_TC(tp, scalbn_inf_pos); 511272343Sngie ATF_TP_ADD_TC(tp, scalbn_ldexp); 512272343Sngie ATF_TP_ADD_TC(tp, scalbn_zero_neg); 513272343Sngie ATF_TP_ADD_TC(tp, scalbn_zero_pos); 514272343Sngie 515272343Sngie ATF_TP_ADD_TC(tp, scalbnf_val); 516272343Sngie ATF_TP_ADD_TC(tp, scalbnf_nan); 517272343Sngie ATF_TP_ADD_TC(tp, scalbnf_inf_neg); 518272343Sngie ATF_TP_ADD_TC(tp, scalbnf_inf_pos); 519272343Sngie ATF_TP_ADD_TC(tp, scalbnf_ldexpf); 520272343Sngie ATF_TP_ADD_TC(tp, scalbnf_zero_neg); 521272343Sngie ATF_TP_ADD_TC(tp, scalbnf_zero_pos); 522272343Sngie 523272343Sngie ATF_TP_ADD_TC(tp, scalbnl_val); 524272343Sngie ATF_TP_ADD_TC(tp, scalbnl_nan); 525272343Sngie ATF_TP_ADD_TC(tp, scalbnl_inf_neg); 526272343Sngie ATF_TP_ADD_TC(tp, scalbnl_inf_pos); 527272343Sngie/* ATF_TP_ADD_TC(tp, scalbnl_ldexp); */ 528272343Sngie ATF_TP_ADD_TC(tp, scalbnl_zero_neg); 529272343Sngie ATF_TP_ADD_TC(tp, scalbnl_zero_pos); 530272343Sngie 531272343Sngie return atf_no_error(); 532272343Sngie} 533