![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to d410.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / ph|
Return to d410.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / ph |
1.1 ! root 1: /* The Plum Hall Validation Suite for C ! 2: * Unpublished copyright (c) 1986-1991, Chiron Systems Inc and Plum Hall Inc. ! 3: * VERSION: 4 ! 4: * DATE: 1993-01-01 ! 5: * The "ANSI" mode of this suite corresponds to official ANSI C, X3.159-1989. ! 6: * As per your license agreement, your distribution is not to be moved or copied outside the Designated Site ! 7: * without specific permission from Plum Hall Inc. ! 8: */ ! 9: ! 10: ! 11: #include "flags.h" ! 12: #ifndef SKIP410 ! 13: #define LIB_TEST 1 ! 14: #include "defs.h" ! 15: ! 16: /* ! 17: * 4.10 - General Utilities <stdlib.h> ! 18: */ ! 19: ! 20: #if ANSI ! 21: #include <stdlib.h> ! 22: #if ANSI8703 ! 23: #include <errno.h> ! 24: #endif /* ANSI8703 */ ! 25: #else /* if !ANSI */ ! 26: #include <stdio.h> /* for NULL, at least */ ! 27: extern int errno; ! 28: double atof(); ! 29: int atoi(); ! 30: long atol(); ! 31: char *calloc(), *malloc(), *realloc(); ! 32: void free(); ! 33: void abort(); ! 34: void exit(); ! 35: char *getenv(); ! 36: int system(); ! 37: #endif /* ANSI */ ! 38: ! 39: int strcmp(); ! 40: size_t strlen(); ! 41: ! 42: #include <math.h> ! 43: static void d4_10_1(); ! 44: static void d4_10_2(); ! 45: static void d4_10_3(); ! 46: static void d4_10_4(); ! 47: static void d4_10_4x(); ! 48: static void d4_10_5(); ! 49: static void d4_10_6(); ! 50: static void d4_10_7(); ! 51: static void d4_10_8(); ! 52: ! 53: ! 54: #ifndef SKIP4_101 ! 55: static char *string1 = "1.234 2.3e99999999999999999999"; ! 56: static char *string2 = " 123 10"; ! 57: static char *string3 = "999999999999999999999999999999999999999999999999999999"; ! 58: static char *string4 = "-99999999999999999999999999999999999999999999999999999"; ! 59: static char *string5 = " XXX"; ! 60: #endif /* SKIP4_101 */ ! 61: ! 62: void d4_10() ! 63: { ! 64: ! 65: Filename = "d410.c"; ! 66: #if ANSI ! 67: { ! 68: /* check existence of types */ ! 69: div_t dummy1; ! 70: ldiv_t dummy2; ! 71: #if WIDE_CHARS ! 72: wchar_t wc; ! 73: #endif /* WIDE_CHARS */ ! 74: size_t si; ! 75: int i; ! 76: ! 77: /* check definition of required macros */ ! 78: #if !defined(EXIT_FAILURE) ! 79: complain(__LINE__); ! 80: #elif !defined(EXIT_SUCCESS) ! 81: complain(__LINE__); ! 82: #elif !defined(RAND_MAX) ! 83: complain(__LINE__); ! 84: #elif !defined(MB_CUR_MAX) ! 85: complain(__LINE__); ! 86: #endif ! 87: ! 88: checkthat(__LINE__, sizeof(div_t) >= 2*sizeof(int)); ! 89: checkthat(__LINE__, sizeof(ldiv_t) >= 2*sizeof(long)); ! 90: #if WIDE_CHARS ! 91: checkthat(__LINE__, MB_CUR_MAX >= 1); ! 92: #endif /* WIDE_CHARS */ ! 93: ! 94: /* make sure that these expand to integral expressions (compile ! 95: * fails if not). ! 96: */ ! 97: i = ivalue(-99); if (i == EXIT_FAILURE) do_nothing(&si); ! 98: i = ivalue(-99); if (i == EXIT_SUCCESS) do_nothing(&si); ! 99: i = ivalue(-99); switch (i) { case RAND_MAX: do_nothing(&si); } ! 100: } ! 101: #endif /* ANSI */ ! 102: d4_10_1(); ! 103: d4_10_2(); ! 104: d4_10_3(); ! 105: d4_10_4(); ! 106: d4_10_5(); ! 107: d4_10_6(); ! 108: d4_10_7(); ! 109: d4_10_8(); ! 110: } ! 111: ! 112: #if ANSI ! 113: #include <limits.h> ! 114: #include <float.h> ! 115: #endif /* ANSI */ ! 116: /* ! 117: * 4.10.1 String conversion functions ! 118: */ ! 119: static void d4_10_1() ! 120: { ! 121: #ifndef SKIP4_101 ! 122: char *p; ! 123: int i; ! 124: long l; ! 125: double d; ! 126: ! 127: /* atof, atoi, atol do not affect errno */ ! 128: errno = 99; ! 129: ! 130: /* 4.10.1.1 atof ! 131: * text to float ! 132: */ ! 133: dequals(__LINE__, atof("XXX"), 0.0); ! 134: dequals(__LINE__, atof("\f\t\n\r\v1.234"), 1.234); ! 135: dequals(__LINE__, atof("1.234"), 1.234); ! 136: dequals(__LINE__, atof(" +1.234"), 1.234); ! 137: dequals(__LINE__, atof(" +1.234"), 1.234); ! 138: dequals(__LINE__, atof(" -1.234"), -1.234); ! 139: dequals(__LINE__, atof(" +1.234e1"), 1.234e1); ! 140: dequals(__LINE__, atof(" +1.234E1"), 1.234E1); ! 141: dequals(__LINE__, atof(" +1.234E-1"), 1.234E-1); ! 142: dequals(__LINE__, atof(" +1.234XE-1"), 1.234); ! 143: ! 144: /* 4.10.1.2 atoi ! 145: * text to int ! 146: */ ! 147: iequals(__LINE__, atoi("XXX"), 0); ! 148: iequals(__LINE__, atoi("123"), 123); ! 149: iequals(__LINE__, atoi("+123"), 123); ! 150: iequals(__LINE__, atoi("-123"), -123); ! 151: iequals(__LINE__, atoi(" +123"), 123); ! 152: iequals(__LINE__, atoi(" 0123"), 123); ! 153: iequals(__LINE__, atoi(" 0x123"), 0); ! 154: iequals(__LINE__, atoi(" 12a3"), 12); ! 155: ! 156: /* 4.10.1.3 atol ! 157: * text to long ! 158: */ ! 159: lequals(__LINE__, atol("XXX"), 0L); ! 160: lequals(__LINE__, atol("123456"), 123456); ! 161: lequals(__LINE__, atol("+123456"), 123456); ! 162: lequals(__LINE__, atol("-123456"), -123456); ! 163: lequals(__LINE__, atol(" +123456"), 123456); ! 164: lequals(__LINE__, atol(" 0123456"), 123456); /* not octal !! */ ! 165: lequals(__LINE__, atol(" 0x123456"), 0L); ! 166: lequals(__LINE__, atol(" 12a3"), 12L); ! 167: ! 168: errno = 0; ! 169: ! 170: #if ANSI ! 171: /* 4.10.1.4 strtod ! 172: * Same as atof, but gets pointer to end character and error checking ! 173: */ ! 174: dequals(__LINE__, strtod("XXX", &p), 0.0); ! 175: dequals(__LINE__, strtod("\f\t\n\r\v1.1", &p), 1.1); ! 176: dequals(__LINE__, strtod("1.234", &p), 1.234); ! 177: dequals(__LINE__, strtod(" +1.234", &p), 1.234); ! 178: dequals(__LINE__, strtod(" +1.234", &p), 1.234); ! 179: dequals(__LINE__, strtod(" -1.234", &p), -1.234); ! 180: dequals(__LINE__, strtod(" +1.234e1", &p), 1.234e1); ! 181: dequals(__LINE__, strtod(" +1.234E1", &p), 1.234E1); ! 182: dequals(__LINE__, strtod(" +1.234E-1", &p), 1.234E-1); ! 183: dequals(__LINE__, strtod(" +1.234XE-1", &p), 1.234); ! 184: ! 185: /* on no conversion, end pointer doesn't move */ ! 186: d = strtod(string5+3, &p); ! 187: aequals(__LINE__, p, string5+3); ! 188: d = strtod(string5, &p); ! 189: aequals(__LINE__, p, string5); ! 190: ! 191: /* endptr gets pointer to remaining string */ ! 192: dequals(__LINE__, strtod(string1, &p), 1.234); ! 193: aequals(__LINE__, p++, string1+5); ! 194: ! 195: /* overflow returns +/- HUGE_VAL */ ! 196: errno = 0; ! 197: dequals(__LINE__, strtod(p, NULL), HUGE_VAL); ! 198: iequals(__LINE__, errno, ERANGE); ! 199: errno = 0; ! 200: dequals(__LINE__, strtod("-1e99999999999999999999", NULL), -HUGE_VAL); ! 201: iequals(__LINE__, errno, ERANGE); ! 202: ! 203: /* underflow returns 0 */ ! 204: errno = 0; ! 205: dequals(__LINE__, strtod("1e-9999999999999999", NULL), 0.0); ! 206: iequals(__LINE__, errno, ERANGE); ! 207: ! 208: /* 4.10.1.5 strtol ! 209: * same as atol but with pointer, base, and error checking ! 210: */ ! 211: lequals(__LINE__, strtol("XXX", &p, 0), 0L); ! 212: lequals(__LINE__, strtol(string2, &p, 8), 0123L); ! 213: aequals(__LINE__, p++, string2+12); ! 214: ! 215: /* check out bases */ ! 216: for (i = 2; i <= 36; ++i) ! 217: lequals(__LINE__, strtol("11", NULL, i), (long)(i+1)); ! 218: lequals(__LINE__, strtol("zzz", NULL, 36), (((35L*36L)+35L)*36L)+35L); ! 219: ! 220: /* 0 base uses default C parsing rules */ ! 221: lequals(__LINE__, strtol("0x12345", NULL, 0), 0x12345L); ! 222: lequals(__LINE__, strtol("0123", NULL, 0), 0123L); ! 223: lequals(__LINE__, strtol(" -123", NULL, 0), -123L); ! 224: lequals(__LINE__, strtol(" +123", NULL, 0), 123L); ! 225: ! 226: /* otherwise, same as atol */ ! 227: lequals(__LINE__, strtol("\f\t\n\r\v7", &p, 10), 7L); ! 228: lequals(__LINE__, strtol("123456", &p, 10), 123456L); ! 229: lequals(__LINE__, strtol("+123456", &p, 10), 123456L); ! 230: lequals(__LINE__, strtol("-123456", &p, 10), -123456L); ! 231: lequals(__LINE__, strtol(" +123456", &p, 10), 123456L); ! 232: lequals(__LINE__, strtol(" 0123456", &p, 10), 123456L); ! 233: lequals(__LINE__, strtol(" 0x123456", &p, 10), 0L); ! 234: lequals(__LINE__, strtol(" 0x123456", &p, 16), 0x123456L); ! 235: lequals(__LINE__, strtol(" -0X123456", &p, 16), -0x123456L); ! 236: lequals(__LINE__, strtol(" 12a3", &p, 10), 12L); ! 237: ! 238: /* on no conversion, end pointer doesn't move */ ! 239: d = strtol(string5+3, &p, 10); ! 240: aequals(__LINE__, p, string5+3); ! 241: d = strtol(string5, &p, 10); ! 242: aequals(__LINE__, p, string5); ! 243: ! 244: /* error checking */ ! 245: errno = 0; ! 246: lequals(__LINE__, strtol(string3, NULL, 0), LONG_MAX); ! 247: iequals(__LINE__, errno, ERANGE); ! 248: errno = 0; ! 249: lequals(__LINE__, strtol(string4, NULL, 0), LONG_MIN); ! 250: iequals(__LINE__, errno, ERANGE); ! 251: ! 252: ! 253: ! 254: /* 4.10.1.6 strtoul ! 255: * same conversions as strtol, but to unsigned long ! 256: */ ! 257: lequals(__LINE__, strtoul("XXX", &p, 0), 0L); ! 258: lequals(__LINE__, strtoul(string2, &p, 8), 0123L); ! 259: aequals(__LINE__, p++, string2+12); ! 260: ! 261: /* check out bases */ ! 262: for (i = 2; i <= 36; ++i) ! 263: lequals(__LINE__, strtoul("11", NULL, i), (long)(i+1)); ! 264: lequals(__LINE__, strtoul("zzz", NULL, 36), (((35L*36L)+35L)*36L)+35L); ! 265: ! 266: /* 0 base uses default C parsing rules */ ! 267: lequals(__LINE__, strtoul("0x12345", NULL, 0), 0x12345L); ! 268: lequals(__LINE__, strtoul("0123", NULL, 0), 0123L); ! 269: ! 270: lequals(__LINE__, strtoul("\f\t\n\r\v7", &p, 10), 7L); ! 271: lequals(__LINE__, strtoul("123456", &p, 10), 123456L); ! 272: lequals(__LINE__, strtoul(" 0123456", &p, 10), 123456L); ! 273: lequals(__LINE__, strtoul(" 0x123456", &p, 10), 0L); ! 274: lequals(__LINE__, strtoul(" 0x123456", &p, 16), 0x123456L); ! 275: lequals(__LINE__, strtoul(" 0X123456", &p, 16), 0x123456L); ! 276: lequals(__LINE__, strtoul(" 12a3", &p, 10), 12L); ! 277: #if ANSI8712 ! 278: lequals(__LINE__, strtoul(" +12", &p, 10), 12L); ! 279: #endif /* ANSI8712 */ ! 280: ! 281: /* on no conversion, end pointer doesn't move */ ! 282: d = strtoul(string5+3, &p, 10); ! 283: aequals(__LINE__, p, string5+3); ! 284: d = strtoul(string5, &p, 10); ! 285: aequals(__LINE__, p, string5); ! 286: ! 287: /* error checking */ ! 288: errno = 0; ! 289: lequals(__LINE__, strtoul(string3, NULL, 0), ULONG_MAX); ! 290: iequals(__LINE__, errno, ERANGE); ! 291: #endif /* ANSI */ ! 292: #endif /* SKIP4_101 */ ! 293: } ! 294: ! 295: /* ! 296: * 4.10.2 - Random number generation functions. ! 297: */ ! 298: static void d4_10_2() ! 299: { ! 300: #ifndef SKIP4_102 ! 301: int i1, i2, i3, j1, j2, j3; ! 302: ! 303: /* 4.10.2.1 rand ! 304: * before ansi, all we can count on is that the sequence exists ! 305: */ ! 306: i1 = rand(); ! 307: i2 = rand(); ! 308: i3 = rand(); ! 309: ! 310: /* 4.10.2.2 srand ! 311: * that it can be reset to the default ! 312: */ ! 313: srand(1); ! 314: j1 = rand(); ! 315: j2 = rand(); ! 316: j3 = rand(); ! 317: iequals(__LINE__, i1, j1); ! 318: iequals(__LINE__, i2, j2); ! 319: iequals(__LINE__, i3, j3); ! 320: ! 321: /* and reset arbitrarily */ ! 322: srand(11); ! 323: i1 = rand(); ! 324: i2 = rand(); ! 325: i3 = rand(); ! 326: srand(11); ! 327: j1 = rand(); ! 328: j2 = rand(); ! 329: j3 = rand(); ! 330: iequals(__LINE__, i1, j1); ! 331: iequals(__LINE__, i2, j2); ! 332: iequals(__LINE__, i3, j3); ! 333: ! 334: #if ANSI ! 335: /* now the range is specified */ ! 336: for (i1 = 0; i1 < 30; ++i1) ! 337: { ! 338: j1 = rand(); ! 339: checkthat(__LINE__, 0 <= j1 && j1 <= RAND_MAX); ! 340: } ! 341: #endif /* ANSI */ ! 342: #endif /* SKIP4_102 */ ! 343: } ! 344: ! 345: ! 346: ! 347: /* ! 348: * 4.10.3 - Memory management functions ! 349: */ ! 350: static void d4_10_3() ! 351: { ! 352: #ifndef SKIP4_103 ! 353: int i; ! 354: char *pc; ! 355: long *pl; ! 356: double d = 9.87; ! 357: union all ! 358: { ! 359: char c; ! 360: short s; ! 361: int i; ! 362: long l; ! 363: double d; ! 364: #if ANSI ! 365: long double ld; ! 366: #endif /* ANSI */ ! 367: char *pc; ! 368: long *pl; ! 369: double *pd; ! 370: } *pu; ! 371: int is_all_zero; ! 372: ! 373: /* 4.10.3.1 calloc ! 374: * Can't do much more than check for existence and see if ! 375: * using them doesn't crash the program. Calloc zeros out ! 376: * the space. ! 377: */ ! 378: pc = calloc(100, sizeof(long)); ! 379: is_all_zero = 1; /* See update item #534, Review Board 8/92 */ ! 380: for (i = 0; i < 100*sizeof(long); ++i) ! 381: { ! 382: if (pc[i] != 0) ! 383: is_all_zero = 0; ! 384: } ! 385: iequals(__LINE__, is_all_zero, 1); ! 386: ! 387: pl = (long *)pc; ! 388: for (i = 0; i < 100; ++i) ! 389: lequals(__LINE__, pl[i], 0L); ! 390: ! 391: free((char *)pl); ! 392: ! 393: /* Check alignment properties ... presumably the program ! 394: * could crash if there is an alignment error. Here is a case ! 395: * where it is important to try to defeat optimizers, so ivalue, etc. ! 396: * are used for the assignments.. ! 397: */ ! 398: pu = (union all *)calloc(100, sizeof(*pu)); ! 399: pu->c = ivalue('a'); ! 400: iequals(__LINE__, pu->c, 'a'); ! 401: pu->s = ivalue(SHRT_MAX); ! 402: iequals(__LINE__, pu->s, SHRT_MAX); ! 403: pu->i = ivalue(INT_MAX); ! 404: iequals(__LINE__, pu->i, INT_MAX); ! 405: pu->l = lvalue(LONG_MAX); ! 406: lequals(__LINE__, pu->l, LONG_MAX); ! 407: pu->d = dvalue(2.34); ! 408: dequals(__LINE__, pu->d, 2.34); ! 409: #if ANSI ! 410: pu->ld = 3.45L; ! 411: ldequals(__LINE__, pu->ld, 3.45L); ! 412: #endif /* ANSI */ ! 413: /* pointer to integral types already checked */ ! 414: pu->pd = (double *)avalue(&d); ! 415: dequals(__LINE__, *(pu->pd), 9.87); ! 416: ! 417: /* check for 0 as arguments */ ! 418: aequals(- __LINE__, calloc(0, 100), NULL); /* ANSI8612: behavior is implem-def; see 4.10.3 P1s1 */ ! 419: aequals(- __LINE__, calloc(100, 0), NULL); /* ANSI8612: behavior is implem-def; see 4.10.3 P1s1 */ ! 420: ! 421: /* 4.10.3.2 free used throughout. ANSI requires free to accept a NULL argument. */ ! 422: #if ANSI ! 423: free(NULL); ! 424: #endif /* ANSI */ ! 425: ! 426: /* 4.10.3.3 malloc ! 427: */ ! 428: pc = malloc(100 * sizeof(long)); ! 429: for (i = 0; i < 100*sizeof(long); ++i) ! 430: pc[i] = i%128; ! 431: for (i = 0; i < 100*sizeof(long); ++i) ! 432: iequals(__LINE__, pc[i], i%128); ! 433: pl = (long *)pc; ! 434: for (i = 0; i < 100; ++i) ! 435: pl[i] = i; ! 436: for (i = 0; i < 100; ++i) ! 437: lequals(__LINE__, pl[i], (long)i); ! 438: ! 439: ! 440: /* check for 0 as arguments */ ! 441: aequals(- __LINE__, malloc(0), NULL); /* ANSI8612: behavior is implem-def; see 4.10.3 P1s1 */ ! 442: ! 443: /* 4.10.3.4 realloc ! 444: * contents should be the same up to the lesser size ! 445: */ ! 446: pc = realloc((char *)pl, 200*sizeof(long)); ! 447: pl = (long *)pc; ! 448: for (i = 0; i < 100; ++i) ! 449: lequals(__LINE__, pl[i], (long)i); ! 450: pc = realloc((char *)pl, 50*sizeof(long)); ! 451: pl = (long *)pc; ! 452: for (i = 0; i < 50; ++i) ! 453: lequals(__LINE__, pl[i], (long)i); ! 454: free(pc); ! 455: #if ANSI ! 456: /* ANSI requires that NULL and 0 are acceptable as arguments */ ! 457: pc = realloc(NULL, 400); ! 458: for (i = 0; i < 400; ++i) ! 459: pc[i] = i%128; ! 460: for (i = 0; i < 400; ++i) ! 461: iequals(__LINE__, pc[i], i%128); ! 462: aequals(- __LINE__, realloc(pc, 0), NULL); /* ANSI8612: behavior is implem-def; see 4.10.3 P1s1 */ ! 463: #endif /* ANSI */ ! 464: #endif /* SKIP4_103 */ ! 465: } ! 466: ! 467: /* ! 468: * 4.10.4 - Communication with the environment. ! 469: */ ! 470: typedef int (*PIF)(); ! 471: #ifndef SKIP4_104 ! 472: static void d4_10_4y(); ! 473: static void d4_10_4z(); ! 474: #endif /* SKIP4_104 */ ! 475: static void d4_10_4() ! 476: { ! 477: #ifndef SKIP4_104 ! 478: PIF p; ! 479: int i; ! 480: void d4_10_4x(); ! 481: ! 482: /* Existence of these functions has been checked in 4.1. ! 483: * Most of these we can't call without terminating the program, ! 484: * in which case no real testing is done. ! 485: */ ! 486: ! 487: #if ANSI ! 488: /* 4.10.4.1 abort ! 489: * terminates the program, so don't call it. ! 490: */ ! 491: p = (PIF)abort; ! 492: ! 493: /* 4.10.4.2 atexit ! 494: * register functions to be called at exit. At least ! 495: * 32 must be allowed. As of ANSI8712 it is required that ! 496: * they be called in reverse order of registry. ! 497: */ ! 498: #if ANSI8712 ! 499: iequals(__LINE__, atexit(d4_10_4x), 0); ! 500: for (i = 0; i < 30; ++i) ! 501: iequals(__LINE__, atexit(d4_10_4y), 0); ! 502: iequals(__LINE__, atexit(d4_10_4z), 0); ! 503: #else ! 504: for (i = 0; i < 32; ++i) ! 505: iequals(__LINE__, atexit(d4_10_4x), 0); ! 506: #endif /* ANSI8712 */ ! 507: #endif /* ANSI */ ! 508: ! 509: /* 4.10.4.3 exit ! 510: * will be tested at the end of main ! 511: */ ! 512: #if ANSI8612 ! 513: checkthat(__LINE__, EXIT_SUCCESS != EXIT_FAILURE); ! 514: #endif /* ANSI8612 */ ! 515: p = (PIF)exit; ! 516: ! 517: /* 4.10.4.4 getenv ! 518: * returns an implementation dependant pointer ! 519: */ ! 520: aequals(- __LINE__, getenv("this is probably a NULL pointer"), NULL); ! 521: ! 522: /* 4.10.4.4 system ! 523: * is very implementation dependent. Does a command processor ! 524: * exist? Return of 0 says not. ! 525: */ ! 526: checkthat(- __LINE__, system(NULL) != 0); ! 527: #endif /* SKIP4_104 */ ! 528: } ! 529: ! 530: static int i = 0; ! 531: #ifndef SKIP4_104 ! 532: static void d4_10_4z() ! 533: { ! 534: Filename = "d410.c"; ! 535: /* this function was registered last, so it should be called first */ ! 536: if (++i != 1) ! 537: complain(__LINE__); ! 538: } ! 539: static void d4_10_4y() ! 540: { ! 541: Filename = "d410.c"; ! 542: /* there should be exactly 30 invocations of this function */ ! 543: if (i < 1 || i > 30) ! 544: complain(__LINE__); ! 545: ++i; ! 546: } ! 547: #if ANSI8712 ! 548: static void d4_10_4x() ! 549: { ! 550: Filename = "d410.c"; ! 551: /* this function was registered first, so it should be called last */ ! 552: if (++i != 32) ! 553: complain(__LINE__); ! 554: } ! 555: #else /* if !ANSI8712 */ ! 556: static void d4_10_4x() ! 557: { ! 558: if (++i == 32) ! 559: printf("ATEXIT successfully registered 32 functions\n"); ! 560: Filename = "d410.c"; ! 561: checkthat(__LINE__, i <= 32); ! 562: } ! 563: #endif /* ANSI8712 */ ! 564: #endif /* SKIP4_104 */ ! 565: ! 566: /* ! 567: * 4.10.5 - Searching and sorting. ! 568: */ ! 569: ! 570: #if !ANSI ! 571: static void d4_10_5() { } ! 572: #else /* if ANSI */ ! 573: int mycmpfn PARMS((const void *, const void *)); ! 574: int mycmpfn(s1, s2) ! 575: const void *s1, *s2; ! 576: { ! 577: return (strcmp((const char *)s1, (const char *)s2)); ! 578: } ! 579: ! 580: static void d4_10_5() ! 581: { ! 582: #ifndef SKIP4_105 ! 583: /* generic_ptr bsearch(); depend upon declaration in <stdlib.h> */ ! 584: char *p; ! 585: static char names[][4] = {"abc", "jkl", "yzz", "def", "stu", "mno", "vwx", "pqr", "ghi"}; ! 586: /* Since we are in a "C" locale, these strings can be expected */ ! 587: /* to collate as abc, def, ghi, jkl, mno, pqr, stu, vwx, yzz. */ ! 588: /* 4.10.5.1 qsort ! 589: * sort using user comparison routine. ! 590: */ ! 591: qsort(names, 9, 4, mycmpfn); ! 592: stequals(__LINE__, names[0], "abc"); ! 593: stequals(__LINE__, names[1], "def"); ! 594: stequals(__LINE__, names[2], "ghi"); ! 595: stequals(__LINE__, names[3], "jkl"); ! 596: stequals(__LINE__, names[4], "mno"); ! 597: stequals(__LINE__, names[5], "pqr"); ! 598: stequals(__LINE__, names[6], "stu"); ! 599: stequals(__LINE__, names[7], "vwx"); ! 600: stequals(__LINE__, names[8], "yzz"); ! 601: /* 4.10.5.2 bsearch ! 602: * find the entries in the array ! 603: */ ! 604: checkthat(__LINE__, bsearch("abc", names, 9, 4, mycmpfn) == names[0]); ! 605: aequals(__LINE__, bsearch("def", names, 9, 4, mycmpfn), names[1]); ! 606: aequals(__LINE__, bsearch("ghi", names, 9, 4, mycmpfn), names[2]); ! 607: aequals(__LINE__, bsearch("jkl", names, 9, 4, mycmpfn), names[3]); ! 608: aequals(__LINE__, bsearch("mno", names, 9, 4, mycmpfn), names[4]); ! 609: aequals(__LINE__, bsearch("pqr", names, 9, 4, mycmpfn), names[5]); ! 610: aequals(__LINE__, bsearch("stu", names, 9, 4, mycmpfn), names[6]); ! 611: aequals(__LINE__, bsearch("vwx", names, 9, 4, mycmpfn), names[7]); ! 612: /* no match returns NULL */ ! 613: aequals(__LINE__, bsearch("123", (char*)names, 9, 4, mycmpfn), NULL); ! 614: #endif /* SKIP4_105 */ ! 615: } ! 616: #endif /* !ANSI */ ! 617: ! 618: /* ! 619: * 4.10.6 - Integer arithmetic functions. ! 620: */ ! 621: static void d4_10_6() ! 622: { ! 623: #ifndef SKIP4_106 ! 624: /* 4.10.6.1 abs ! 625: * absolute value ! 626: */ ! 627: iequals(__LINE__, abs(10), 10); ! 628: iequals(__LINE__, abs(-10), 10); ! 629: ! 630: #if ANSI ! 631: { ! 632: div_t d; ! 633: ldiv_t ld; ! 634: ! 635: /* 4.10.6.2 div ! 636: * get dividend and remainder. ! 637: */ ! 638: d = div(-5, 2); ! 639: iequals(__LINE__, d.quot, -2); ! 640: iequals(__LINE__, d.rem, -1); ! 641: d = div(5, 2); ! 642: iequals(__LINE__, d.quot, 2); ! 643: iequals(__LINE__, d.rem, 1); ! 644: ! 645: /* 4.10.6.3 labs ! 646: * same as abs, but for longs ! 647: */ ! 648: lequals(__LINE__, labs(2147483647), 2147483647); ! 649: lequals(__LINE__, labs(-2147483647), 2147483647); ! 650: ! 651: /* 4.10.6.4 ldiv ! 652: * get long dividend and remainder. ! 653: */ ! 654: ld = ldiv(-5L, 2L); ! 655: lequals(__LINE__, ld.quot, -2L); ! 656: lequals(__LINE__, ld.rem, -1L); ! 657: ld = ldiv(5L, 2L); ! 658: lequals(__LINE__, ld.quot, 2L); ! 659: lequals(__LINE__, ld.rem, 1L); ! 660: } ! 661: #endif /* ANSI */ ! 662: #endif /* SKIP4_106 */ ! 663: } ! 664: ! 665: /* ! 666: * 4.10.7 - Multibyte character functions ! 667: */ ! 668: #if !ANSI ! 669: static void d4_10_7(){} ! 670: #else /* if ANSI */ ! 671: static void d4_10_7() ! 672: { ! 673: #ifndef SKIP4_107 ! 674: const char *s = "Test string"; ! 675: int len = strlen(s); ! 676: const char *ps = s + len; /* points to 0 */ ! 677: #if WIDE_CHARS ! 678: wchar_t wc; ! 679: #endif /* WIDE_CHARS */ ! 680: char buff[10]; ! 681: ! 682: /* Only the "C" locale can be tested here, which has no ! 683: * specific requirements. Vendor specific tests can be added to ! 684: * test actual multibyte encodings. ! 685: */ ! 686: #if WIDE_CHARS ! 687: /* 4.10.7.1 The mblen function */ ! 688: iequals( - __LINE__, mblen(NULL, 1000), 0); /* no multibytes */ ! 689: iequals( - __LINE__, mblen(NULL, 0), 0); /* no multibytes */ ! 690: iequals(__LINE__, mblen(ps, 1), 0); /* pointer to 0 */ ! 691: iequals(__LINE__, mblen(s, len), 1); /* 1 byte per char */ ! 692: ! 693: /* 4.10.7.2 The mbtowc function */ ! 694: iequals(__LINE__, mbtowc(&wc, NULL, 0), 0); /* no multibytes */ ! 695: iequals(__LINE__, mbtowc(&wc, ps, 1), 0); /* pointer to 0 */ ! 696: lequals(__LINE__, (long)wc, 0L); /* big enough for wchar_t */ ! 697: iequals(__LINE__, mbtowc(&wc, s, len), 1); /* pointer to 0 */ ! 698: lequals(__LINE__, (long)wc, (long)'T'); /* big enough for wchar_t */ ! 699: checkthat(__LINE__, MB_CUR_MAX >= 1); ! 700: ! 701: /* 4.10.7.3 The wctomb function */ ! 702: iequals(__LINE__, wctomb(NULL, wc), 0); /* no multibytes */ ! 703: iequals(__LINE__, wctomb(NULL, 0), 0); /* no multibytes */ ! 704: iequals(__LINE__, wctomb(buff, wc), 1); /* 1 byte per char */ ! 705: iequals(__LINE__, buff[0], 'T'); ! 706: wc = 0; ! 707: iequals(__LINE__, wctomb(buff, wc), 1); ! 708: iequals(__LINE__, buff[0], 0); ! 709: #endif /* WIDE_CHARS */ ! 710: #endif /* SKIP4_107 */ ! 711: } ! 712: #endif /* ANSI */ ! 713: ! 714: /* ! 715: * 4.10.8 - Multibyte string functions ! 716: * The size_t checks are done as long because sizeof(long) >= sizeof(size_t). ! 717: * Also, it is assumed that sizeof(long) >= sizeof(wchar_t); ! 718: */ ! 719: #if !ANSI || !WIDE_CHARS ! 720: static void d4_10_8() ! 721: {} ! 722: #else /* if ANSI && WIDE_CHARS */ ! 723: static void d4_10_8() ! 724: { ! 725: #ifndef SKIP4_108 ! 726: int i; ! 727: const char *s = "A test string"; ! 728: long len = (long)strlen(s); ! 729: #define WLEN 20 ! 730: wchar_t warray[WLEN]; ! 731: char buf[WLEN]; ! 732: ! 733: /* if wchar_t is bigger than a long, these tests will not work */ ! 734: if (sizeof(long) < sizeof(wchar_t)) ! 735: { ! 736: complain(- __LINE__); ! 737: return; ! 738: } ! 739: ! 740: /* initialize warray and buf to all 1 */ ! 741: for (i = 0; i < WLEN; ++i) ! 742: { ! 743: warray[i] = 1; ! 744: buf[i] = 1; ! 745: } ! 746: ! 747: /* in the "C" locale it is assumed that the MB representation ! 748: * is the same as the wchar_t representation for printable ! 749: * characters. ! 750: */ ! 751: ! 752: /* 4.10.8.1 the mbstowcs function */ ! 753: lequals(__LINE__, (long) mbstowcs(warray, s, 1), 1L); ! 754: lequals(__LINE__, (long) warray[0], (long)'A'); ! 755: lequals(__LINE__, (long) warray[1], 1L); /* no terminating 0 */ ! 756: lequals(__LINE__, (long) mbstowcs(warray, s, WLEN), len); ! 757: lequals(__LINE__, (long) warray[len-1], (long)'g'); ! 758: lequals(__LINE__, (long) warray[len], 0L); /* terminating 0 */ ! 759: ! 760: /* 4.10.8.2 the wcstombs function */ ! 761: lequals(__LINE__, (long) wcstombs(buf, warray, 1), 1L); ! 762: lequals(__LINE__, (long) buf[0], (long)'A'); ! 763: lequals(__LINE__, (long) buf[1], 1L); /* no terminating 0 */ ! 764: lequals(__LINE__, (long) wcstombs(buf, warray, WLEN), len); ! 765: lequals(__LINE__, (long) buf[len-1], (long)'g'); ! 766: lequals(__LINE__, (long) buf[len], 0L); /* terminating 0 */ ! 767: #endif /* SKIP4_108 */ ! 768: } ! 769: #endif /* ANSI && WIDE_CHARS */ ! 770: ! 771: #else /* if SKIP410 */ ! 772: void d4_10() { pr_skip("d4_10: SKIPPED ENTIRELY\n"); } ! 773: #endif /* SKIP410 */ ! 774:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.