1109905Smarkm/* $NetBSD: t_exp.c,v 1.9 2018/11/07 03:59:36 riastradh Exp $ */ 270657Sobrien 370657Sobrien/*- 470657Sobrien * Copyright (c) 2011 The NetBSD Foundation, Inc. 570657Sobrien * All rights reserved. 670657Sobrien * 770657Sobrien * This code is derived from software contributed to The NetBSD Foundation 870657Sobrien * by Jukka Ruohonen. 970657Sobrien * 1070657Sobrien * Redistribution and use in source and binary forms, with or without 1170657Sobrien * modification, are permitted provided that the following conditions 1270657Sobrien * are met: 1370657Sobrien * 1. Redistributions of source code must retain the above copyright 1470657Sobrien * notice, this list of conditions and the following disclaimer. 1570657Sobrien * 2. Redistributions in binary form must reproduce the above copyright 1670657Sobrien * notice, this list of conditions and the following disclaimer in the 1770657Sobrien * documentation and/or other materials provided with the distribution. 1870657Sobrien * 1970657Sobrien * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 2070657Sobrien * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 2170657Sobrien * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 2270657Sobrien * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 2370657Sobrien * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2470657Sobrien * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2570657Sobrien * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2670657Sobrien * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2770657Sobrien * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2870657Sobrien * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 2970657Sobrien * POSSIBILITY OF SUCH DAMAGE. 3070657Sobrien */ 3170657Sobrien 3270657Sobrien#include <atf-c.h> 3370657Sobrien#include <float.h> 3470657Sobrien#include <math.h> 3570657Sobrien#include "t_libm.h" 3670657Sobrien 3770657Sobrien/* y = exp(x) */ 3870657Sobrienstatic const struct { 3970657Sobrien double x; 4070657Sobrien double y; 4170657Sobrien} exp_values[] = { 42216338Sdim { -10, 0.4539992976248485e-4, }, 43216338Sdim { -5, 0.6737946999085467e-2, }, 44216338Sdim { -1, 0.3678794411714423, }, 4570657Sobrien { -0.1, 0.9048374180359595, }, 46100167Smarkm { 0, 1.0000000000000000, }, 4793399Smarkm { 0.1, 1.1051709180756477, }, 4870657Sobrien { 1, 2.7182818284590452, }, 49232832Skib { 5, 148.41315910257660, }, 5070657Sobrien { 10, 22026.465794806718, }, 5180740Smp}; 5280740Smp 5380740Smp/* 54209869Snwhitehorn * exp2/exp2f(3) 55209869Snwhitehorn */ 5670657SobrienATF_LIBM_TEST(exp2_is_nan, "Test exp2(x) == NaN") 5770657Sobrien{ 5870657Sobrien#ifdef T_LIBM_NAN 5970657Sobrien T_LIBM_CHECK_NAN(0, exp2, T_LIBM_NAN); 6070657Sobrien T_LIBM_CHECK_NAN(0, exp2f, T_LIBM_NAN); 6170657Sobrien#else 6270657Sobrien atf_tc_skip("no NaN on this machine"); 6370657Sobrien#endif 6480740Smp} 6570657Sobrien 66100167SmarkmATF_LIBM_TEST(exp2_is_plus_zero, "Test exp2(x) == +0.0") 67100167Smarkm{ 6893036Sobrien#ifdef T_LIBM_MINUS_INF 6993036Sobrien T_LIBM_CHECK_PLUS_ZERO(0, exp2, T_LIBM_MINUS_INF); 7093036Sobrien T_LIBM_CHECK_PLUS_ZERO(0, exp2f, T_LIBM_MINUS_INF); 71100167Smarkm#else 7270657Sobrien atf_tc_skip("no +/-Inf on this machine"); 73100167Smarkm#endif 74100167Smarkm} 75100167Smarkm 7670657SobrienATF_LIBM_TEST(exp2_powers, "Test exp2(x) is correct for some integer x") 7770657Sobrien{ 78245133Skib static const struct { 7970657Sobrien double x; 8070657Sobrien double d_y; 8170657Sobrien double f_y; 8270657Sobrien } v[] = { 8370657Sobrien { +0.0, 1.0, 1.0 }, 8470657Sobrien { -0.0, 1.0, 1.0 }, 85133754Sdfr { 1, 0x1p1, 0x1p1 }, 86133754Sdfr { 2, 0x1p2, 0x1p2 }, 8770657Sobrien { 100, 0x1p100, 0x1p100 }, 8870657Sobrien { 125, 0x1p125, 0x1p125 }, 8970657Sobrien { 126, 0x1p126, 0x1p126 }, 9070657Sobrien#if __DBL_MAX_EXP__ > 129 9170657Sobrien { 127, 0x1p127, 0x1p127 }, 92232832Skib#endif 93232832Skib#ifdef T_LIBM_PLUS_INF 94232832Skib { 128, 0x1p128, T_LIBM_PLUS_INF }, 9570657Sobrien { 129, 0x1p129, T_LIBM_PLUS_INF }, 9670657Sobrien { 1000, 0x1p1000, T_LIBM_PLUS_INF }, 9770657Sobrien { 1020, 0x1p1020, T_LIBM_PLUS_INF }, 9870657Sobrien { 1023, 0x1p1023, T_LIBM_PLUS_INF }, 9970657Sobrien { 1024, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 10070657Sobrien { 1030, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 10170657Sobrien { 1050, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 102 { 2000, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 103 { 16383, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 104 { 16384, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 105 { 16385, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF }, 106#endif 107 { -1, 0x1p-1, 0x1p-1 }, 108 { -2, 0x1p-2, 0x1p-2 }, 109 { -100, 0x1p-100, 0x1p-100 }, 110 { -127, 0x1p-127, 0x1p-127 }, 111 { -128, 0x1p-128, 0x1p-128 }, 112#if __LDBL_MIN_EXP__ < -129 113 { -300, 0x1p-300, 0.0}, 114 { -400, 0x1p-400, 0.0}, 115 {-1000, 0x1p-1000, 0.0}, 116 {-1022, 0x1p-1022, 0.0}, 117 /* These should be denormal numbers */ 118 {-1023, 0x1p-1023, 0.0}, 119 {-1024, 0x1p-1024, 0.0}, 120 {-1040, 0x1p-1040, 0.0}, 121 {-1060, 0x1p-1060, 0.0}, 122 /* This is the smallest result gcc will allow */ 123 {-1074, 0x1p-1074, 0.0}, 124#endif 125 {-1075, 0x0, 0.0}, 126 {-1080, 0x0, 0.0}, 127 {-2000, 0x0, 0.0}, 128 {-16382, 0x0, 0.0}, 129 {-16383, 0x0, 0.0}, 130 {-16384, 0x0, 0.0}, 131 }; 132 unsigned int i; 133 134#if defined(__FreeBSD__) && defined(__i386__) 135 atf_tc_expect_fail("a number of the assertions fail on i386"); 136#endif 137 138 for (i = 0; i < __arraycount(v); i++) { 139 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, 0.0); 140 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, 0.0); 141 } 142} 143 144ATF_LIBM_TEST(exp2_values, "Test exp2(x) is correct for some x") 145{ 146 static const struct { 147 double x; 148 double d_y; 149 float f_y; 150 double d_eps; 151 double f_eps; 152 } v[] = { 153#if __DBL_MAX_EXP__ > 128 154 /* The largest double constant */ 155 { 0x1.fffffffffffffp9, 0x1.ffffffffffd3ap1023, 0.00, 156 0x1p969, 0.0 }, 157 /* The largest float constant */ 158 { 0x1.fffffep6, 0x1.ffff4ep+127, 0x1.ffff4ep+127, 6e30, 0.0 }, 159#endif 160#ifdef T_LIBM_PLUS_INF 161 { T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, 0.0, 0.0 }, 162#endif 163 164 /* The few values from the old tests */ 165 /* Results from i386/amd64, d_eps needed on i386 */ 166 /* f_y values calculated using py-mpmath */ 167 { 1.1, 0x1.125fbee250664p+1, 0x1.125fc0p+1, 0x1p-52, 0x1.8p-22 }, 168 { 2.2, 0x1.2611186bae675p+2, 0x1.26111ap+2, 0x1p-51, 0x1.8p-21 }, 169 { 3.3, 0x1.3b2c47bff8328p+3, 0x1.3b2c48p+3, 0x1p-50, 0x1.8p-20 }, 170 { 4.4, 0x1.51cb453b9536ep+4, 0x1.51cb46p+4, 0x1p-49, 0x1.8p-19 }, 171 { 5.5, 0x1.6a09e667f3bcdp+5, 0x1.6a09e6p+5, 0x1p-48, 0x1.8p-18 }, 172 { 6.6, 0x1.8406003b2ae5bp+6, 0x1.8405fep+6, 0x1p-47, 0x1.8p-17 }, 173 { 7.7, 0x1.9fdf8bcce533ep+7, 0x1.9fdf88p+7, 0x1p-46, 0x1.8p-16 }, 174 { 8.8, 0x1.bdb8cdadbe124p+8, 0x1.bdb8d2p+8, 0x1p-45, 0x1.8p-15 }, 175 }; 176 unsigned int i; 177 178 for (i = 0; i < __arraycount(v); i++) { 179 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, v[i].d_eps); 180 if (i > 1) 181 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, v[i].f_eps); 182 } 183} 184 185 186/* 187 * exp(3) 188 */ 189ATF_TC(exp_nan); 190ATF_TC_HEAD(exp_nan, tc) 191{ 192 atf_tc_set_md_var(tc, "descr", "Test exp(NaN) == NaN"); 193} 194 195ATF_TC_BODY(exp_nan, tc) 196{ 197 const double x = 0.0L / 0.0L; 198 199 if (isnan(exp(x)) == 0) 200 atf_tc_fail_nonfatal("exp(NaN) != NaN"); 201} 202 203ATF_TC(exp_inf_neg); 204ATF_TC_HEAD(exp_inf_neg, tc) 205{ 206 atf_tc_set_md_var(tc, "descr", "Test exp(-Inf) == +0.0"); 207} 208 209ATF_TC_BODY(exp_inf_neg, tc) 210{ 211 const double x = -1.0L / 0.0L; 212 double y = exp(x); 213 214 if (fabs(y) > 0.0 || signbit(y) != 0) 215 atf_tc_fail_nonfatal("exp(-Inf) != +0.0"); 216} 217 218ATF_TC(exp_inf_pos); 219ATF_TC_HEAD(exp_inf_pos, tc) 220{ 221 atf_tc_set_md_var(tc, "descr", "Test exp(+Inf) == +Inf"); 222} 223 224ATF_TC_BODY(exp_inf_pos, tc) 225{ 226 const double x = 1.0L / 0.0L; 227 double y = exp(x); 228 229 if (isinf(y) == 0 || signbit(y) != 0) 230 atf_tc_fail_nonfatal("exp(+Inf) != +Inf"); 231} 232 233ATF_TC(exp_product); 234ATF_TC_HEAD(exp_product, tc) 235{ 236 atf_tc_set_md_var(tc, "descr", "Test some selected exp(x)"); 237} 238 239ATF_TC_BODY(exp_product, tc) 240{ 241 const double eps = DBL_EPSILON; 242 size_t i; 243 244 for (i = 0; i < __arraycount(exp_values); i++) { 245 double x = exp_values[i].x; 246 double e_x = exp_values[i].y; 247 248 if (!(fabs((exp(x) - e_x)/e_x) <= eps)) { 249 atf_tc_fail_nonfatal("exp(%.17g) = %.17g != %.17g", 250 x, exp(x), e_x); 251 } 252 } 253} 254 255ATF_TC(exp_zero_neg); 256ATF_TC_HEAD(exp_zero_neg, tc) 257{ 258 atf_tc_set_md_var(tc, "descr", "Test exp(-0.0) == 1.0"); 259} 260 261ATF_TC_BODY(exp_zero_neg, tc) 262{ 263 const double x = -0.0L; 264 265 if (fabs(exp(x) - 1.0) > 0.0) 266 atf_tc_fail_nonfatal("exp(-0.0) != 1.0"); 267} 268 269ATF_TC(exp_zero_pos); 270ATF_TC_HEAD(exp_zero_pos, tc) 271{ 272 atf_tc_set_md_var(tc, "descr", "Test exp(+0.0) == 1.0"); 273} 274 275ATF_TC_BODY(exp_zero_pos, tc) 276{ 277 const double x = 0.0L; 278 279 if (fabs(exp(x) - 1.0) > 0.0) 280 atf_tc_fail_nonfatal("exp(+0.0) != 1.0"); 281} 282 283/* 284 * expf(3) 285 */ 286ATF_TC(expf_nan); 287ATF_TC_HEAD(expf_nan, tc) 288{ 289 atf_tc_set_md_var(tc, "descr", "Test expf(NaN) == NaN"); 290} 291 292ATF_TC_BODY(expf_nan, tc) 293{ 294 const float x = 0.0L / 0.0L; 295 296 if (isnan(expf(x)) == 0) 297 atf_tc_fail_nonfatal("expf(NaN) != NaN"); 298} 299 300ATF_TC(expf_inf_neg); 301ATF_TC_HEAD(expf_inf_neg, tc) 302{ 303 atf_tc_set_md_var(tc, "descr", "Test expf(-Inf) == +0.0"); 304} 305 306ATF_TC_BODY(expf_inf_neg, tc) 307{ 308 const float x = -1.0L / 0.0L; 309 float y = expf(x); 310 311 if (fabsf(y) > 0.0 || signbit(y) != 0) 312 atf_tc_fail_nonfatal("expf(-Inf) != +0.0"); 313} 314 315ATF_TC(expf_inf_pos); 316ATF_TC_HEAD(expf_inf_pos, tc) 317{ 318 atf_tc_set_md_var(tc, "descr", "Test expf(+Inf) == +Inf"); 319} 320 321ATF_TC_BODY(expf_inf_pos, tc) 322{ 323 const float x = 1.0L / 0.0L; 324 float y = expf(x); 325 326 if (isinf(y) == 0 || signbit(y) != 0) 327 atf_tc_fail_nonfatal("expf(+Inf) != +Inf"); 328} 329 330ATF_TC(expf_product); 331ATF_TC_HEAD(expf_product, tc) 332{ 333 atf_tc_set_md_var(tc, "descr", "Test some selected expf(x)"); 334} 335 336ATF_TC_BODY(expf_product, tc) 337{ 338 const float eps = FLT_EPSILON; 339 size_t i; 340 341 for (i = 0; i < __arraycount(exp_values); i++) { 342 float x = exp_values[i].x; 343 float e_x = exp_values[i].y; 344 345 if (!(fabsf((expf(x) - e_x)/e_x) <= eps)) { 346 atf_tc_fail_nonfatal("expf(%.8g) = %.8g != %.8g", 347 x, exp(x), e_x); 348 } 349 } 350} 351 352ATF_TC(expf_zero_neg); 353ATF_TC_HEAD(expf_zero_neg, tc) 354{ 355 atf_tc_set_md_var(tc, "descr", "Test expf(-0.0) == 1.0"); 356} 357 358ATF_TC_BODY(expf_zero_neg, tc) 359{ 360 const float x = -0.0L; 361 362 if (fabsf(expf(x) - 1.0f) > 0.0) 363 atf_tc_fail_nonfatal("expf(-0.0) != 1.0"); 364} 365 366ATF_TC(expf_zero_pos); 367ATF_TC_HEAD(expf_zero_pos, tc) 368{ 369 atf_tc_set_md_var(tc, "descr", "Test expf(+0.0) == 1.0"); 370} 371 372ATF_TC_BODY(expf_zero_pos, tc) 373{ 374 const float x = 0.0L; 375 376 if (fabsf(expf(x) - 1.0f) > 0.0) 377 atf_tc_fail_nonfatal("expf(+0.0) != 1.0"); 378} 379 380/* 381 * expm1(3) 382 */ 383ATF_TC(expm1_nan); 384ATF_TC_HEAD(expm1_nan, tc) 385{ 386 atf_tc_set_md_var(tc, "descr", "Test expm1(NaN) == NaN"); 387} 388 389ATF_TC_BODY(expm1_nan, tc) 390{ 391 const double x = 0.0L / 0.0L; 392 393 if (isnan(expm1(x)) == 0) 394 atf_tc_fail_nonfatal("expm1(NaN) != NaN"); 395} 396 397ATF_TC(expm1_inf_neg); 398ATF_TC_HEAD(expm1_inf_neg, tc) 399{ 400 atf_tc_set_md_var(tc, "descr", "Test expm1(-Inf) == -1"); 401} 402 403ATF_TC_BODY(expm1_inf_neg, tc) 404{ 405 const double x = -1.0L / 0.0L; 406 407 if (expm1(x) != -1.0) 408 atf_tc_fail_nonfatal("expm1(-Inf) != -1.0"); 409} 410 411ATF_TC(expm1_inf_pos); 412ATF_TC_HEAD(expm1_inf_pos, tc) 413{ 414 atf_tc_set_md_var(tc, "descr", "Test expm1(+Inf) == +Inf"); 415} 416 417ATF_TC_BODY(expm1_inf_pos, tc) 418{ 419 const double x = 1.0L / 0.0L; 420 double y = expm1(x); 421 422 if (isinf(y) == 0 || signbit(y) != 0) 423 atf_tc_fail_nonfatal("expm1(+Inf) != +Inf"); 424} 425 426ATF_TC(expm1_zero_neg); 427ATF_TC_HEAD(expm1_zero_neg, tc) 428{ 429 atf_tc_set_md_var(tc, "descr", "Test expm1(-0.0) == -0.0"); 430} 431 432ATF_TC_BODY(expm1_zero_neg, tc) 433{ 434 const double x = -0.0L; 435 double y = expm1(x); 436 437 if (fabs(y) > 0.0 || signbit(y) == 0) 438 atf_tc_fail_nonfatal("expm1(-0.0) != -0.0"); 439} 440 441ATF_TC(expm1_zero_pos); 442ATF_TC_HEAD(expm1_zero_pos, tc) 443{ 444 atf_tc_set_md_var(tc, "descr", "Test expm1(+0.0) == 1.0"); 445} 446 447ATF_TC_BODY(expm1_zero_pos, tc) 448{ 449 const double x = 0.0L; 450 double y = expm1(x); 451 452 if (fabs(y) > 0.0 || signbit(y) != 0) 453 atf_tc_fail_nonfatal("expm1(+0.0) != +0.0"); 454} 455 456/* 457 * expm1f(3) 458 */ 459ATF_TC(expm1f_nan); 460ATF_TC_HEAD(expm1f_nan, tc) 461{ 462 atf_tc_set_md_var(tc, "descr", "Test expm1f(NaN) == NaN"); 463} 464 465ATF_TC_BODY(expm1f_nan, tc) 466{ 467 const float x = 0.0L / 0.0L; 468 469 if (isnan(expm1f(x)) == 0) 470 atf_tc_fail_nonfatal("expm1f(NaN) != NaN"); 471} 472 473ATF_TC(expm1f_inf_neg); 474ATF_TC_HEAD(expm1f_inf_neg, tc) 475{ 476 atf_tc_set_md_var(tc, "descr", "Test expm1f(-Inf) == -1"); 477} 478 479ATF_TC_BODY(expm1f_inf_neg, tc) 480{ 481 const float x = -1.0L / 0.0L; 482 483 if (expm1f(x) != -1.0) 484 atf_tc_fail_nonfatal("expm1f(-Inf) != -1.0"); 485} 486 487ATF_TC(expm1f_inf_pos); 488ATF_TC_HEAD(expm1f_inf_pos, tc) 489{ 490 atf_tc_set_md_var(tc, "descr", "Test expm1f(+Inf) == +Inf"); 491} 492 493ATF_TC_BODY(expm1f_inf_pos, tc) 494{ 495 const float x = 1.0L / 0.0L; 496 float y = expm1f(x); 497 498 if (isinf(y) == 0 || signbit(y) != 0) 499 atf_tc_fail_nonfatal("expm1f(+Inf) != +Inf"); 500} 501 502ATF_TC(expm1f_zero_neg); 503ATF_TC_HEAD(expm1f_zero_neg, tc) 504{ 505 atf_tc_set_md_var(tc, "descr", "Test expm1f(-0.0) == -0.0"); 506} 507 508ATF_TC_BODY(expm1f_zero_neg, tc) 509{ 510 const float x = -0.0L; 511 float y = expm1f(x); 512 513 if (fabsf(y) > 0.0 || signbit(y) == 0) 514 atf_tc_fail_nonfatal("expm1f(-0.0) != -0.0"); 515} 516 517ATF_TC(expm1f_zero_pos); 518ATF_TC_HEAD(expm1f_zero_pos, tc) 519{ 520 atf_tc_set_md_var(tc, "descr", "Test expm1f(+0.0) == 1.0"); 521} 522 523ATF_TC_BODY(expm1f_zero_pos, tc) 524{ 525 const float x = 0.0L; 526 float y = expm1f(x); 527 528 if (fabsf(y) > 0.0 || signbit(y) != 0) 529 atf_tc_fail_nonfatal("expm1f(+0.0) != +0.0"); 530} 531 532ATF_TP_ADD_TCS(tp) 533{ 534 535 ATF_TP_ADD_TC(tp, exp2_is_nan); 536 ATF_TP_ADD_TC(tp, exp2_is_plus_zero); 537 ATF_TP_ADD_TC(tp, exp2_values); 538 ATF_TP_ADD_TC(tp, exp2_powers); 539 540 ATF_TP_ADD_TC(tp, exp_nan); 541 ATF_TP_ADD_TC(tp, exp_inf_neg); 542 ATF_TP_ADD_TC(tp, exp_inf_pos); 543 ATF_TP_ADD_TC(tp, exp_product); 544 ATF_TP_ADD_TC(tp, exp_zero_neg); 545 ATF_TP_ADD_TC(tp, exp_zero_pos); 546 547 ATF_TP_ADD_TC(tp, expf_nan); 548 ATF_TP_ADD_TC(tp, expf_inf_neg); 549 ATF_TP_ADD_TC(tp, expf_inf_pos); 550 ATF_TP_ADD_TC(tp, expf_product); 551 ATF_TP_ADD_TC(tp, expf_zero_neg); 552 ATF_TP_ADD_TC(tp, expf_zero_pos); 553 554 ATF_TP_ADD_TC(tp, expm1_nan); 555 ATF_TP_ADD_TC(tp, expm1_inf_neg); 556 ATF_TP_ADD_TC(tp, expm1_inf_pos); 557 ATF_TP_ADD_TC(tp, expm1_zero_neg); 558 ATF_TP_ADD_TC(tp, expm1_zero_pos); 559 560 ATF_TP_ADD_TC(tp, expm1f_nan); 561 ATF_TP_ADD_TC(tp, expm1f_inf_neg); 562 ATF_TP_ADD_TC(tp, expm1f_inf_pos); 563 ATF_TP_ADD_TC(tp, expm1f_zero_neg); 564 ATF_TP_ADD_TC(tp, expm1f_zero_pos); 565 566 return atf_no_error(); 567} 568