1314817Sngie/* $NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc 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> 32314817Sngie__RCSID("$NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc 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++) { 84276478Sngie errno = 0; 85272343Sngie rv = scalbn(tests[i].inval, tests[i].exp); 86272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 87272343Sngie "test %zu: errno %d instead of %d", i, errno, 88272343Sngie tests[i].error); 89272343Sngie ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*DBL_EPSILON, 90272343Sngie "test %zu: return value %g instead of %g (difference %g)", 91272343Sngie i, rv, tests[i].result, tests[i].result-rv); 92272343Sngie } 93272343Sngie} 94272343Sngie 95272343SngieATF_TC(scalbn_nan); 96272343SngieATF_TC_HEAD(scalbn_nan, tc) 97272343Sngie{ 98272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(NaN, n) == NaN"); 99272343Sngie} 100272343Sngie 101272343SngieATF_TC_BODY(scalbn_nan, tc) 102272343Sngie{ 103272343Sngie const double x = 0.0L / 0.0L; 104272343Sngie double y; 105272343Sngie size_t i; 106272343Sngie 107272343Sngie ATF_REQUIRE(isnan(x) != 0); 108272343Sngie 109272343Sngie for (i = 0; i < __arraycount(exps); i++) { 110272343Sngie y = scalbn(x, exps[i]); 111272343Sngie ATF_CHECK(isnan(y) != 0); 112272343Sngie } 113272343Sngie} 114272343Sngie 115272343SngieATF_TC(scalbn_inf_neg); 116272343SngieATF_TC_HEAD(scalbn_inf_neg, tc) 117272343Sngie{ 118272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(-Inf, n) == -Inf"); 119272343Sngie} 120272343Sngie 121272343SngieATF_TC_BODY(scalbn_inf_neg, tc) 122272343Sngie{ 123272343Sngie const double x = -1.0L / 0.0L; 124272343Sngie size_t i; 125272343Sngie 126272343Sngie for (i = 0; i < __arraycount(exps); i++) 127272343Sngie ATF_CHECK(scalbn(x, exps[i]) == x); 128272343Sngie} 129272343Sngie 130272343SngieATF_TC(scalbn_inf_pos); 131272343SngieATF_TC_HEAD(scalbn_inf_pos, tc) 132272343Sngie{ 133272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(+Inf, n) == +Inf"); 134272343Sngie} 135272343Sngie 136272343SngieATF_TC_BODY(scalbn_inf_pos, tc) 137272343Sngie{ 138272343Sngie const double x = 1.0L / 0.0L; 139272343Sngie size_t i; 140272343Sngie 141272343Sngie for (i = 0; i < __arraycount(exps); i++) 142272343Sngie ATF_CHECK(scalbn(x, exps[i]) == x); 143272343Sngie} 144272343Sngie 145272343SngieATF_TC(scalbn_ldexp); 146272343SngieATF_TC_HEAD(scalbn_ldexp, tc) 147272343Sngie{ 148272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(x, n) == ldexp(x, n)"); 149272343Sngie} 150272343Sngie 151272343SngieATF_TC_BODY(scalbn_ldexp, tc) 152272343Sngie{ 153272343Sngie#if FLT_RADIX == 2 154272343Sngie const double x = 2.91288191221812821; 155272343Sngie double y; 156272343Sngie size_t i; 157272343Sngie 158272343Sngie for (i = 0; i < __arraycount(exps); i++) { 159272343Sngie y = scalbn(x, exps[i]); 160272343Sngie ATF_CHECK_MSG(y == ldexp(x, exps[i]), "test %zu: exponent=%d, " 161272343Sngie "y=%g, expected %g (diff: %g)", i, exps[i], y, 162272343Sngie ldexp(x, exps[i]), y - ldexp(x, exps[i])); 163272343Sngie } 164272343Sngie#endif 165272343Sngie} 166272343Sngie 167272343SngieATF_TC(scalbn_zero_neg); 168272343SngieATF_TC_HEAD(scalbn_zero_neg, tc) 169272343Sngie{ 170272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(-0.0, n) == -0.0"); 171272343Sngie} 172272343Sngie 173272343SngieATF_TC_BODY(scalbn_zero_neg, tc) 174272343Sngie{ 175272343Sngie const double x = -0.0L; 176272343Sngie double y; 177272343Sngie size_t i; 178272343Sngie 179272343Sngie ATF_REQUIRE(signbit(x) != 0); 180272343Sngie 181272343Sngie for (i = 0; i < __arraycount(exps); i++) { 182272343Sngie y = scalbn(x, exps[i]); 183272343Sngie ATF_CHECK(x == y); 184272343Sngie ATF_CHECK(signbit(y) != 0); 185272343Sngie } 186272343Sngie} 187272343Sngie 188272343SngieATF_TC(scalbn_zero_pos); 189272343SngieATF_TC_HEAD(scalbn_zero_pos, tc) 190272343Sngie{ 191272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbn(+0.0, n) == +0.0"); 192272343Sngie} 193272343Sngie 194272343SngieATF_TC_BODY(scalbn_zero_pos, tc) 195272343Sngie{ 196272343Sngie const double x = 0.0L; 197272343Sngie double y; 198272343Sngie size_t i; 199272343Sngie 200272343Sngie ATF_REQUIRE(signbit(x) == 0); 201272343Sngie 202272343Sngie for (i = 0; i < __arraycount(exps); i++) { 203272343Sngie y = scalbn(x, exps[i]); 204272343Sngie ATF_CHECK(x == y); 205272343Sngie ATF_CHECK(signbit(y) == 0); 206272343Sngie } 207272343Sngie} 208272343Sngie 209272343Sngie/* 210272343Sngie * scalbnf(3) 211272343Sngie */ 212272343SngieATF_TC(scalbnf_val); 213272343SngieATF_TC_HEAD(scalbnf_val, tc) 214272343Sngie{ 215272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf() for a few values"); 216272343Sngie} 217272343Sngie 218272343SngieATF_TC_BODY(scalbnf_val, tc) 219272343Sngie{ 220272343Sngie const struct testcase *tests = test_vals; 221272343Sngie const size_t tcnt = __arraycount(test_vals); 222272343Sngie size_t i; 223272343Sngie double rv; 224272343Sngie 225272343Sngie for (i = 0; i < tcnt; i++) { 226276672Sngie errno = 0; 227272343Sngie rv = scalbnf(tests[i].inval, tests[i].exp); 228272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 229272343Sngie "test %zu: errno %d instead of %d", i, errno, 230272343Sngie tests[i].error); 231272343Sngie ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*FLT_EPSILON, 232272343Sngie "test %zu: return value %g instead of %g (difference %g)", 233272343Sngie i, rv, tests[i].result, tests[i].result-rv); 234272343Sngie } 235272343Sngie} 236272343Sngie 237272343SngieATF_TC(scalbnf_nan); 238272343SngieATF_TC_HEAD(scalbnf_nan, tc) 239272343Sngie{ 240272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(NaN, n) == NaN"); 241272343Sngie} 242272343Sngie 243272343SngieATF_TC_BODY(scalbnf_nan, tc) 244272343Sngie{ 245272343Sngie const float x = 0.0L / 0.0L; 246272343Sngie float y; 247272343Sngie size_t i; 248272343Sngie 249272343Sngie ATF_REQUIRE(isnan(x) != 0); 250272343Sngie 251272343Sngie for (i = 0; i < __arraycount(exps); i++) { 252272343Sngie y = scalbnf(x, exps[i]); 253272343Sngie ATF_CHECK(isnan(y) != 0); 254272343Sngie } 255272343Sngie} 256272343Sngie 257272343SngieATF_TC(scalbnf_inf_neg); 258272343SngieATF_TC_HEAD(scalbnf_inf_neg, tc) 259272343Sngie{ 260272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(-Inf, n) == -Inf"); 261272343Sngie} 262272343Sngie 263272343SngieATF_TC_BODY(scalbnf_inf_neg, tc) 264272343Sngie{ 265272343Sngie const float x = -1.0L / 0.0L; 266272343Sngie size_t i; 267272343Sngie 268272343Sngie for (i = 0; i < __arraycount(exps); i++) 269272343Sngie ATF_CHECK(scalbnf(x, exps[i]) == x); 270272343Sngie} 271272343Sngie 272272343SngieATF_TC(scalbnf_inf_pos); 273272343SngieATF_TC_HEAD(scalbnf_inf_pos, tc) 274272343Sngie{ 275272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(+Inf, n) == +Inf"); 276272343Sngie} 277272343Sngie 278272343SngieATF_TC_BODY(scalbnf_inf_pos, tc) 279272343Sngie{ 280272343Sngie const float x = 1.0L / 0.0L; 281272343Sngie size_t i; 282272343Sngie 283272343Sngie for (i = 0; i < __arraycount(exps); i++) 284272343Sngie ATF_CHECK(scalbnf(x, exps[i]) == x); 285272343Sngie} 286272343Sngie 287272343SngieATF_TC(scalbnf_ldexpf); 288272343SngieATF_TC_HEAD(scalbnf_ldexpf, tc) 289272343Sngie{ 290272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(x, n) == ldexpf(x, n)"); 291272343Sngie} 292272343Sngie 293272343SngieATF_TC_BODY(scalbnf_ldexpf, tc) 294272343Sngie{ 295272343Sngie#if FLT_RADIX == 2 296272343Sngie const float x = 2.91288191221812821; 297272343Sngie float y; 298272343Sngie size_t i; 299272343Sngie 300272343Sngie for (i = 0; i < __arraycount(exps); i++) { 301272343Sngie y = scalbnf(x, exps[i]); 302272343Sngie ATF_CHECK_MSG(y == ldexpf(x, exps[i]), 303272343Sngie "test %zu: exponent=%d, y=%g ldexpf returns %g (diff: %g)", 304272343Sngie i, exps[i], y, ldexpf(x, exps[i]), y-ldexpf(x, exps[i])); 305272343Sngie } 306272343Sngie#endif 307272343Sngie} 308272343Sngie 309272343SngieATF_TC(scalbnf_zero_neg); 310272343SngieATF_TC_HEAD(scalbnf_zero_neg, tc) 311272343Sngie{ 312272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(-0.0, n) == -0.0"); 313272343Sngie} 314272343Sngie 315272343SngieATF_TC_BODY(scalbnf_zero_neg, tc) 316272343Sngie{ 317272343Sngie const float x = -0.0L; 318272343Sngie float y; 319272343Sngie size_t i; 320272343Sngie 321272343Sngie ATF_REQUIRE(signbit(x) != 0); 322272343Sngie 323272343Sngie for (i = 0; i < __arraycount(exps); i++) { 324272343Sngie y = scalbnf(x, exps[i]); 325272343Sngie ATF_CHECK(x == y); 326272343Sngie ATF_CHECK(signbit(y) != 0); 327272343Sngie } 328272343Sngie} 329272343Sngie 330272343SngieATF_TC(scalbnf_zero_pos); 331272343SngieATF_TC_HEAD(scalbnf_zero_pos, tc) 332272343Sngie{ 333272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnf(+0.0, n) == +0.0"); 334272343Sngie} 335272343Sngie 336272343SngieATF_TC_BODY(scalbnf_zero_pos, tc) 337272343Sngie{ 338272343Sngie const float x = 0.0L; 339272343Sngie float y; 340272343Sngie size_t i; 341272343Sngie 342272343Sngie ATF_REQUIRE(signbit(x) == 0); 343272343Sngie 344272343Sngie for (i = 0; i < __arraycount(exps); i++) { 345272343Sngie y = scalbnf(x, exps[i]); 346272343Sngie ATF_CHECK(x == y); 347272343Sngie ATF_CHECK(signbit(y) == 0); 348272343Sngie } 349272343Sngie} 350272343Sngie 351272343Sngie/* 352272343Sngie * scalbnl(3) 353272343Sngie */ 354272343SngieATF_TC(scalbnl_val); 355272343SngieATF_TC_HEAD(scalbnl_val, tc) 356272343Sngie{ 357272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl() for a few values"); 358272343Sngie} 359272343Sngie 360272343SngieATF_TC_BODY(scalbnl_val, tc) 361272343Sngie{ 362272343Sngie#ifndef __HAVE_LONG_DOUBLE 363272343Sngie atf_tc_skip("Requires long double support"); 364272343Sngie#else 365272343Sngie const struct testcase *tests = test_vals; 366272343Sngie const size_t tcnt = __arraycount(test_vals); 367272343Sngie size_t i; 368272343Sngie long double rv; 369272343Sngie 370272343Sngie for (i = 0; i < tcnt; i++) { 371276672Sngie errno = 0; 372272343Sngie rv = scalbnl(tests[i].inval, tests[i].exp); 373272343Sngie ATF_CHECK_EQ_MSG(errno, tests[i].error, 374272343Sngie "test %zu: errno %d instead of %d", i, errno, 375272343Sngie tests[i].error); 376272343Sngie ATF_CHECK_MSG(fabsl(rv-(long double)tests[i].result)<2.0*LDBL_EPSILON, 377272343Sngie "test %zu: return value %Lg instead of %Lg (difference %Lg)", 378272343Sngie i, rv, (long double)tests[i].result, (long double)tests[i].result-rv); 379272343Sngie } 380272343Sngie#endif 381272343Sngie} 382272343Sngie 383272343SngieATF_TC(scalbnl_nan); 384272343SngieATF_TC_HEAD(scalbnl_nan, tc) 385272343Sngie{ 386272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(NaN, n) == NaN"); 387272343Sngie} 388272343Sngie 389272343SngieATF_TC_BODY(scalbnl_nan, tc) 390272343Sngie{ 391272343Sngie#ifndef __HAVE_LONG_DOUBLE 392272343Sngie atf_tc_skip("Requires long double support"); 393272343Sngie#else 394272343Sngie const long double x = 0.0L / 0.0L; 395272343Sngie long double y; 396272343Sngie size_t i; 397272343Sngie 398272343Sngie if (isnan(x) == 0) { 399272343Sngie atf_tc_expect_fail("PR lib/45362"); 400272343Sngie atf_tc_fail("(0.0L / 0.0L) != NaN"); 401272343Sngie } 402272343Sngie 403272343Sngie for (i = 0; i < __arraycount(exps); i++) { 404272343Sngie y = scalbnl(x, exps[i]); 405272343Sngie ATF_CHECK(isnan(y) != 0); 406272343Sngie } 407272343Sngie#endif 408272343Sngie} 409272343Sngie 410272343SngieATF_TC(scalbnl_inf_neg); 411272343SngieATF_TC_HEAD(scalbnl_inf_neg, tc) 412272343Sngie{ 413272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(-Inf, n) == -Inf"); 414272343Sngie} 415272343Sngie 416272343SngieATF_TC_BODY(scalbnl_inf_neg, tc) 417272343Sngie{ 418272343Sngie#ifndef __HAVE_LONG_DOUBLE 419272343Sngie atf_tc_skip("Requires long double support"); 420272343Sngie#else 421272343Sngie const long double x = -1.0L / 0.0L; 422272343Sngie size_t i; 423272343Sngie 424272343Sngie for (i = 0; i < __arraycount(exps); i++) 425272343Sngie ATF_CHECK(scalbnl(x, exps[i]) == x); 426272343Sngie#endif 427272343Sngie} 428272343Sngie 429272343SngieATF_TC(scalbnl_inf_pos); 430272343SngieATF_TC_HEAD(scalbnl_inf_pos, tc) 431272343Sngie{ 432272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(+Inf, n) == +Inf"); 433272343Sngie} 434272343Sngie 435272343SngieATF_TC_BODY(scalbnl_inf_pos, tc) 436272343Sngie{ 437272343Sngie#ifndef __HAVE_LONG_DOUBLE 438272343Sngie atf_tc_skip("Requires long double support"); 439272343Sngie#else 440272343Sngie const long double x = 1.0L / 0.0L; 441272343Sngie size_t i; 442272343Sngie 443272343Sngie for (i = 0; i < __arraycount(exps); i++) 444272343Sngie ATF_CHECK(scalbnl(x, exps[i]) == x); 445272343Sngie#endif 446272343Sngie} 447272343Sngie 448272343SngieATF_TC(scalbnl_zero_neg); 449272343SngieATF_TC_HEAD(scalbnl_zero_neg, tc) 450272343Sngie{ 451272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(-0.0, n) == -0.0"); 452272343Sngie} 453272343Sngie 454272343SngieATF_TC_BODY(scalbnl_zero_neg, tc) 455272343Sngie{ 456272343Sngie#ifndef __HAVE_LONG_DOUBLE 457272343Sngie atf_tc_skip("Requires long double support"); 458272343Sngie#else 459272343Sngie const long double x = -0.0L; 460272343Sngie long double y; 461272343Sngie size_t i; 462272343Sngie 463272343Sngie ATF_REQUIRE(signbit(x) != 0); 464272343Sngie 465272343Sngie for (i = 0; i < __arraycount(exps); i++) { 466272343Sngie y = scalbnl(x, exps[i]); 467272343Sngie ATF_CHECK(x == y); 468272343Sngie ATF_CHECK(signbit(y) != 0); 469272343Sngie } 470272343Sngie#endif 471272343Sngie} 472272343Sngie 473272343SngieATF_TC(scalbnl_zero_pos); 474272343SngieATF_TC_HEAD(scalbnl_zero_pos, tc) 475272343Sngie{ 476272343Sngie atf_tc_set_md_var(tc, "descr", "Test scalbnl(+0.0, n) == +0.0"); 477272343Sngie} 478272343Sngie 479272343SngieATF_TC_BODY(scalbnl_zero_pos, tc) 480272343Sngie{ 481272343Sngie#ifndef __HAVE_LONG_DOUBLE 482272343Sngie atf_tc_skip("Requires long double support"); 483272343Sngie#else 484272343Sngie const long double x = 0.0L; 485272343Sngie long double y; 486272343Sngie size_t i; 487272343Sngie 488272343Sngie ATF_REQUIRE(signbit(x) == 0); 489272343Sngie 490272343Sngie for (i = 0; i < __arraycount(exps); i++) { 491272343Sngie y = scalbnl(x, exps[i]); 492272343Sngie ATF_CHECK(x == y); 493272343Sngie ATF_CHECK(signbit(y) == 0); 494272343Sngie } 495272343Sngie#endif 496272343Sngie} 497272343Sngie 498272343SngieATF_TP_ADD_TCS(tp) 499272343Sngie{ 500272343Sngie 501272343Sngie ATF_TP_ADD_TC(tp, scalbn_val); 502272343Sngie ATF_TP_ADD_TC(tp, scalbn_nan); 503272343Sngie ATF_TP_ADD_TC(tp, scalbn_inf_neg); 504272343Sngie ATF_TP_ADD_TC(tp, scalbn_inf_pos); 505272343Sngie ATF_TP_ADD_TC(tp, scalbn_ldexp); 506272343Sngie ATF_TP_ADD_TC(tp, scalbn_zero_neg); 507272343Sngie ATF_TP_ADD_TC(tp, scalbn_zero_pos); 508272343Sngie 509272343Sngie ATF_TP_ADD_TC(tp, scalbnf_val); 510272343Sngie ATF_TP_ADD_TC(tp, scalbnf_nan); 511272343Sngie ATF_TP_ADD_TC(tp, scalbnf_inf_neg); 512272343Sngie ATF_TP_ADD_TC(tp, scalbnf_inf_pos); 513272343Sngie ATF_TP_ADD_TC(tp, scalbnf_ldexpf); 514272343Sngie ATF_TP_ADD_TC(tp, scalbnf_zero_neg); 515272343Sngie ATF_TP_ADD_TC(tp, scalbnf_zero_pos); 516272343Sngie 517272343Sngie ATF_TP_ADD_TC(tp, scalbnl_val); 518272343Sngie ATF_TP_ADD_TC(tp, scalbnl_nan); 519272343Sngie ATF_TP_ADD_TC(tp, scalbnl_inf_neg); 520272343Sngie ATF_TP_ADD_TC(tp, scalbnl_inf_pos); 521272343Sngie/* ATF_TP_ADD_TC(tp, scalbnl_ldexp); */ 522272343Sngie ATF_TP_ADD_TC(tp, scalbnl_zero_neg); 523272343Sngie ATF_TP_ADD_TC(tp, scalbnl_zero_pos); 524272343Sngie 525272343Sngie return atf_no_error(); 526272343Sngie} 527