1 /* $NetBSD: t_fmemopen.c,v 1.7 2021/09/11 18:18:28 rillig Exp $ */ 2 3 /*- 4 * Copyright (c)2010 Takehiko NOZAKI, 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 #if defined(__NetBSD__) 31 #include <atf-c.h> 32 #else 33 #if defined(__linux__) 34 #define _GNU_SOURCE 35 #include <features.h> 36 #endif 37 #include <assert.h> 38 #include <stdio.h> 39 #define ATF_TC(arg0) static void arg0##_head(void) 40 #define ATF_TC_HEAD(arg0, arg1) static void arg0##_head() 41 #define atf_tc_set_md_var(arg0, arg1, ...) do { \ 42 printf(__VA_ARGS__); \ 43 puts(""); \ 44 } while (/*CONSTCOND*/0) 45 #define ATF_TC_BODY(arg0, arg1) static void arg0##_body() 46 #define ATF_CHECK(arg0) assert(arg0) 47 #define ATF_TP_ADD_TCS(arg0) int main(void) 48 #define ATF_TP_ADD_TC(arg0, arg1) arg1##_head(); arg1##_body() 49 #define atf_no_error() 0 50 #endif 51 52 #include <errno.h> 53 #include <stdint.h> 54 #include <stdio.h> 55 #include <limits.h> 56 #include <stdlib.h> 57 #include <string.h> 58 59 const char *mode_rwa[] = { 60 "r", "rb", "r+", "rb+", "r+b", 61 "w", "wb", "w+", "wb+", "w+b", 62 "a", "ab", "a+", "ab+", "a+b", 63 NULL 64 }; 65 66 const char *mode_r[] = { "r", "rb", "r+", "rb+", "r+b", NULL }; 67 const char *mode_w[] = { "w", "wb", "w+", "wb+", "w+b", NULL }; 68 const char *mode_a[] = { "a", "ab", "a+", "ab+", "a+b", NULL }; 69 70 struct testcase { 71 const char *s; 72 off_t n; 73 } testcases[] = { 74 #define TESTSTR(s) { s, sizeof(s)-1 } 75 TESTSTR("\0he quick brown fox jumps over the lazy dog"), 76 TESTSTR("T\0e quick brown fox jumps over the lazy dog"), 77 TESTSTR("Th\0 quick brown fox jumps over the lazy dog"), 78 TESTSTR("The\0quick brown fox jumps over the lazy dog"), 79 TESTSTR("The \0uick brown fox jumps over the lazy dog"), 80 TESTSTR("The q\0ick brown fox jumps over the lazy dog"), 81 TESTSTR("The qu\0ck brown fox jumps over the lazy dog"), 82 TESTSTR("The qui\0k brown fox jumps over the lazy dog"), 83 TESTSTR("The quic\0 brown fox jumps over the lazy dog"), 84 TESTSTR("The quick\0brown fox jumps over the lazy dog"), 85 TESTSTR("The quick \0rown fox jumps over the lazy dog"), 86 TESTSTR("The quick b\0own fox jumps over the lazy dog"), 87 TESTSTR("The quick br\0wn fox jumps over the lazy dog"), 88 TESTSTR("The quick bro\0n fox jumps over the lazy dog"), 89 TESTSTR("The quick brow\0 fox jumps over the lazy dog"), 90 TESTSTR("The quick brown\0fox jumps over the lazy dog"), 91 TESTSTR("The quick brown \0ox jumps over the lazy dog"), 92 TESTSTR("The quick brown f\0x jumps over the lazy dog"), 93 TESTSTR("The quick brown fo\0 jumps over the lazy dog"), 94 TESTSTR("The quick brown fox\0jumps over the lazy dog"), 95 TESTSTR("The quick brown fox \0umps over the lazy dog"), 96 TESTSTR("The quick brown fox j\0mps over the lazy dog"), 97 TESTSTR("The quick brown fox ju\0ps over the lazy dog"), 98 TESTSTR("The quick brown fox jum\0s over the lazy dog"), 99 TESTSTR("The quick brown fox jump\0 over the lazy dog"), 100 TESTSTR("The quick brown fox jumps\0over the lazy dog"), 101 TESTSTR("The quick brown fox jumps \0ver the lazy dog"), 102 TESTSTR("The quick brown fox jumps o\0er the lazy dog"), 103 TESTSTR("The quick brown fox jumps ov\0r the lazy dog"), 104 TESTSTR("The quick brown fox jumps ove\0 the lazy dog"), 105 TESTSTR("The quick brown fox jumps over\0the lazy dog"), 106 TESTSTR("The quick brown fox jumps over \0he lazy dog"), 107 TESTSTR("The quick brown fox jumps over t\0e lazy dog"), 108 TESTSTR("The quick brown fox jumps over th\0 lazy dog"), 109 TESTSTR("The quick brown fox jumps over the\0lazy dog"), 110 TESTSTR("The quick brown fox jumps over the \0azy dog"), 111 TESTSTR("The quick brown fox jumps over the l\0zy dog"), 112 TESTSTR("The quick brown fox jumps over the la\0y dog"), 113 TESTSTR("The quick brown fox jumps over the laz\0 dog"), 114 TESTSTR("The quick brown fox jumps over the lazy\0dog"), 115 TESTSTR("The quick brown fox jumps over the lazy \0og"), 116 TESTSTR("The quick brown fox jumps over the lazy d\0g"), 117 TESTSTR("The quick brown fox jumps over the lazy do\0"), 118 TESTSTR("The quick brown fox jumps over the lazy dog"), 119 { NULL, 0 }, 120 }; 121 122 ATF_TC(test00); 123 ATF_TC_HEAD(test00, tc) 124 { 125 atf_tc_set_md_var(tc, "descr", "test00"); 126 } 127 ATF_TC_BODY(test00, tc) 128 { 129 const char **p; 130 char buf[BUFSIZ]; 131 FILE *fp; 132 133 for (p = &mode_rwa[0]; *p != NULL; ++p) { 134 fp = fmemopen(&buf[0], sizeof(buf), *p); 135 /* 136 * Upon successful completion, fmemopen() shall return a pointer to the 137 * object controlling the stream. 138 */ 139 ATF_CHECK(fp != NULL); 140 141 ATF_CHECK(fclose(fp) == 0); 142 } 143 } 144 145 ATF_TC(test01); 146 ATF_TC_HEAD(test01, tc) 147 { 148 atf_tc_set_md_var(tc, "descr", "test01"); 149 } 150 ATF_TC_BODY(test01, tc) 151 { 152 const char **p; 153 const char *mode[] = { 154 "r+", "rb+", "r+b", 155 "w+", "wb+", "w+b", 156 "a+", "ab+", "a+b", 157 NULL 158 }; 159 FILE *fp; 160 161 for (p = &mode[0]; *p != NULL; ++p) { 162 /* 163 * If a null pointer is specified as the buf argument, fmemopen() shall 164 * allocate size bytes of memory as if by a call to malloc(). 165 */ 166 fp = fmemopen(NULL, BUFSIZ, *p); 167 ATF_CHECK(fp != NULL); 168 169 /* 170 * If buf is a null pointer, the initial position shall always be set 171 * to the beginning of the buffer. 172 */ 173 ATF_CHECK(ftello(fp) == (off_t)0); 174 175 ATF_CHECK(fclose(fp) == 0); 176 } 177 } 178 179 ATF_TC(test02); 180 ATF_TC_HEAD(test02, tc) 181 { 182 atf_tc_set_md_var(tc, "descr", "test02"); 183 } 184 ATF_TC_BODY(test02, tc) 185 { 186 const char **p; 187 char buf[BUFSIZ]; 188 FILE *fp; 189 190 for (p = &mode_r[0]; *p != NULL; ++p) { 191 192 memset(&buf[0], 0x1, sizeof(buf)); 193 fp = fmemopen(&buf[0], sizeof(buf), *p); 194 ATF_CHECK(fp != NULL); 195 196 /* 197 * This position is initially set to either the beginning of the buffer 198 * (for r and w modes) 199 */ 200 ATF_CHECK((unsigned char)buf[0] == 0x1); 201 ATF_CHECK(ftello(fp) == (off_t)0); 202 203 /* 204 * The stream also maintains the size of the current buffer contents. 205 * For modes r and r+ the size is set to the value given by the size argument. 206 */ 207 #if !defined(__GLIBC__) 208 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_END) == 0); 209 ATF_CHECK(ftello(fp) == (off_t)sizeof(buf)); 210 #endif 211 ATF_CHECK(fclose(fp) == 0); 212 } 213 } 214 215 ATF_TC(test03); 216 ATF_TC_HEAD(test03, tc) 217 { 218 atf_tc_set_md_var(tc, "descr", "test03"); 219 } 220 ATF_TC_BODY(test03, tc) 221 { 222 const char **p; 223 char buf[BUFSIZ]; 224 FILE *fp; 225 226 for (p = &mode_w[0]; *p != NULL; ++p) { 227 228 memset(&buf[0], 0x1, sizeof(buf)); 229 fp = fmemopen(&buf[0], sizeof(buf), *p); 230 ATF_CHECK(fp != NULL); 231 232 /* 233 * This position is initially set to either the beginning of the buffer 234 * (for r and w modes) 235 */ 236 ATF_CHECK(buf[0] == '\0'); 237 ATF_CHECK(ftello(fp) == (off_t)0); 238 239 /* 240 * For modes w and w+ the initial size is zero 241 */ 242 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_END) == 0); 243 ATF_CHECK(ftello(fp) == (off_t)0); 244 245 ATF_CHECK(fclose(fp) == 0); 246 } 247 } 248 249 ATF_TC(test04); 250 ATF_TC_HEAD(test04, tc) 251 { 252 atf_tc_set_md_var(tc, "descr", "test04"); 253 } 254 ATF_TC_BODY(test04, tc) 255 { 256 const char **p; 257 char buf[BUFSIZ]; 258 FILE *fp; 259 260 /* 261 * or to the first null byte in the buffer (for a modes) 262 */ 263 for (p = &mode_a[0]; *p != NULL; ++p) { 264 265 memset(&buf[0], 0x1, sizeof(buf)); 266 fp = fmemopen(&buf[0], sizeof(buf), *p); 267 ATF_CHECK(fp != NULL); 268 269 ATF_CHECK((unsigned char)buf[0] == 0x1); 270 271 /* If no null byte is found in append mode, 272 * the initial position is set to one byte after the end of the buffer. 273 */ 274 #if !defined(__GLIBC__) 275 ATF_CHECK(ftello(fp) == (off_t)sizeof(buf)); 276 #endif 277 278 /* 279 * and for modes a and a+ the initial size is either the position of the 280 * first null byte in the buffer or the value of the size argument 281 * if no null byte is found. 282 */ 283 #if !defined(__GLIBC__) 284 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_END) == 0); 285 ATF_CHECK(ftello(fp) == (off_t)sizeof(buf)); 286 #endif 287 288 ATF_CHECK(fclose(fp) == 0); 289 } 290 } 291 292 ATF_TC(test05); 293 ATF_TC_HEAD(test05, tc) 294 { 295 atf_tc_set_md_var(tc, "descr", "test05"); 296 } 297 ATF_TC_BODY(test05, tc) 298 { 299 const char **p; 300 FILE *fp; 301 char buf[BUFSIZ]; 302 303 for (p = &mode_rwa[0]; *p != NULL; ++p) { 304 /* 305 * Otherwise, a null pointer shall be returned, and errno shall be set 306 * to indicate the error. 307 */ 308 errno = 0; 309 fp = fmemopen(NULL, (size_t)0, *p); 310 ATF_CHECK(fp == NULL); 311 ATF_CHECK(errno == EINVAL); 312 313 errno = 0; 314 fp = fmemopen((void *)&buf[0], 0, *p); 315 ATF_CHECK(fp == NULL); 316 ATF_CHECK(errno == EINVAL); 317 } 318 } 319 320 ATF_TC(test06); 321 ATF_TC_HEAD(test06, tc) 322 { 323 atf_tc_set_md_var(tc, "descr", "test06"); 324 } 325 ATF_TC_BODY(test06, tc) 326 { 327 const char **p; 328 const char *mode[] = { "", " ", "???", NULL }; 329 FILE *fp; 330 331 for (p = &mode[0]; *p != NULL; ++p) { 332 /* 333 * The value of the mode argument is not valid. 334 */ 335 fp = fmemopen(NULL, 1, *p); 336 ATF_CHECK(fp == NULL); 337 ATF_CHECK(errno == EINVAL); 338 } 339 } 340 341 ATF_TC(test07); 342 ATF_TC_HEAD(test07, tc) 343 { 344 atf_tc_set_md_var(tc, "descr", "test07"); 345 } 346 ATF_TC_BODY(test07, tc) 347 { 348 #if !defined(__GLIBC__) 349 const char **p; 350 const char *mode[] = { 351 "r", "rb", 352 "w", "wb", 353 "a", "ab", 354 NULL 355 }; 356 FILE *fp; 357 358 for (p = &mode[0]; *p != NULL; ++p) { 359 /* 360 * Because this feature is only useful when the stream is opened for updating 361 * (because there is no way to get a pointer to the buffer) the fmemopen() 362 * call may fail if the mode argument does not include a '+'. 363 */ 364 errno = 0; 365 fp = fmemopen(NULL, 1, *p); 366 ATF_CHECK(fp == NULL); 367 ATF_CHECK(errno == EINVAL); 368 } 369 #endif 370 } 371 372 ATF_TC(test08); 373 ATF_TC_HEAD(test08, tc) 374 { 375 atf_tc_set_md_var(tc, "descr", "test08"); 376 } 377 ATF_TC_BODY(test08, tc) 378 { 379 #if !defined(__GLIBC__) 380 const char **p; 381 const char *mode[] = { 382 "r+", "rb+", "r+b", 383 "w+", "wb+", "w+b", 384 "a+", "ab+", "a+b", 385 NULL 386 }; 387 FILE *fp; 388 389 for (p = &mode[0]; *p != NULL; ++p) { 390 /* 391 * The buf argument is a null pointer and the allocation of a buffer of 392 * length size has failed. 393 */ 394 fp = fmemopen(NULL, SIZE_MAX, *p); 395 ATF_CHECK(fp == NULL); 396 ATF_CHECK(errno == ENOMEM); 397 } 398 #endif 399 } 400 401 /* 402 * test09 - test14: 403 * An attempt to seek a memory buffer stream to a negative position or to a 404 * position larger than the buffer size given in the size argument shall fail. 405 */ 406 407 ATF_TC(test09); 408 ATF_TC_HEAD(test09, tc) 409 { 410 atf_tc_set_md_var(tc, "descr", "test09"); 411 } 412 ATF_TC_BODY(test09, tc) 413 { 414 struct testcase *t; 415 const char **p; 416 char buf[BUFSIZ]; 417 FILE *fp; 418 off_t i; 419 420 for (t = &testcases[0]; t->s != NULL; ++t) { 421 for (p = &mode_rwa[0]; *p != NULL; ++p) { 422 423 memcpy(&buf[0], t->s, t->n); 424 fp = fmemopen(&buf[0], t->n, *p); 425 ATF_CHECK(fp != NULL); 426 427 /* 428 * test fmemopen_seek(SEEK_SET) 429 */ 430 /* zero */ 431 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_SET) == 0); 432 ATF_CHECK(ftello(fp) == (off_t)0); 433 434 /* positive */ 435 for (i = (off_t)1; i <= (off_t)t->n; ++i) { 436 ATF_CHECK(fseeko(fp, i, SEEK_SET) == 0); 437 ATF_CHECK(ftello(fp) == i); 438 } 439 /* positive + OOB */ 440 ATF_CHECK(fseeko(fp, t->n + 1, SEEK_SET) == -1); 441 ATF_CHECK(ftello(fp) == t->n); 442 443 /* negative + OOB */ 444 ATF_CHECK(fseeko(fp, (off_t)-1, SEEK_SET) == -1); 445 ATF_CHECK(ftello(fp) == t->n); 446 447 ATF_CHECK(fclose(fp) == 0); 448 } 449 } 450 } 451 452 const char *mode_rw[] = { 453 "r", "rb", "r+", "rb+", "r+b", 454 "w", "wb", "w+", "wb+", "w+b", 455 NULL 456 }; 457 458 ATF_TC(test10); 459 ATF_TC_HEAD(test10, tc) 460 { 461 atf_tc_set_md_var(tc, "descr", "test10"); 462 } 463 ATF_TC_BODY(test10, tc) 464 { 465 struct testcase *t; 466 off_t i; 467 const char **p; 468 char buf[BUFSIZ]; 469 FILE *fp; 470 471 for (t = &testcases[0]; t->s != NULL; ++t) { 472 for (p = &mode_rw[0]; *p != NULL; ++p) { 473 474 memcpy(&buf[0], t->s, t->n); 475 fp = fmemopen(&buf[0], t->n, *p); 476 ATF_CHECK(fp != NULL); 477 478 /* 479 * test fmemopen_seek(SEEK_CUR) 480 */ 481 ATF_CHECK(ftello(fp) == (off_t)0); 482 483 /* zero */ 484 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_CUR) == 0); 485 ATF_CHECK(ftello(fp) == (off_t)0); 486 487 /* negative & OOB */ 488 ATF_CHECK(fseeko(fp, (off_t)-1, SEEK_CUR) == -1); 489 ATF_CHECK(ftello(fp) == (off_t)0); 490 491 /* positive */ 492 for (i = 0; i < (off_t)t->n; ++i) { 493 ATF_CHECK(fseeko(fp, (off_t)1, SEEK_CUR) == 0); 494 ATF_CHECK(ftello(fp) == i + 1); 495 } 496 497 /* positive & OOB */ 498 ATF_CHECK(fseeko(fp, (off_t)1, SEEK_CUR) == -1); 499 ATF_CHECK(ftello(fp) == (off_t)t->n); 500 501 ATF_CHECK(fclose(fp) == 0); 502 } 503 } 504 } 505 506 ATF_TC(test11); 507 ATF_TC_HEAD(test11, tc) 508 { 509 atf_tc_set_md_var(tc, "descr", "test11"); 510 } 511 ATF_TC_BODY(test11, tc) 512 { 513 struct testcase *t; 514 off_t len, rest, i; 515 const char **p; 516 char buf[BUFSIZ]; 517 FILE *fp; 518 519 /* test fmemopen_seek(SEEK_CUR) */ 520 for (t = &testcases[0]; t->s != NULL; ++t) { 521 len = (off_t)strnlen(t->s, t->n); 522 rest = (off_t)t->n - len; 523 for (p = &mode_a[0]; *p != NULL; ++p) { 524 525 memcpy(&buf[0], t->s, t->n); 526 fp = fmemopen(&buf[0], t->n, *p); 527 ATF_CHECK(fp != NULL); 528 /* 529 * test fmemopen_seek(SEEK_CUR) 530 */ 531 #if defined(__GLIBC__) 532 if (i < (off_t)t->n) { 533 #endif 534 /* zero */ 535 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_CUR) == 0); 536 ATF_CHECK(ftello(fp) == len); 537 538 /* posive */ 539 for (i = (off_t)1; i <= rest; ++i) { 540 ATF_CHECK(fseeko(fp, (off_t)1, SEEK_CUR) == 0); 541 ATF_CHECK(ftello(fp) == len + i); 542 } 543 544 /* positive + OOB */ 545 ATF_CHECK(fseeko(fp, (off_t)1, SEEK_CUR) == -1); 546 ATF_CHECK(ftello(fp) == (off_t)t->n); 547 548 /* negative */ 549 for (i = (off_t)1; i <= (off_t)t->n; ++i) { 550 ATF_CHECK(fseeko(fp, (off_t)-1, SEEK_CUR) == 0); 551 ATF_CHECK(ftello(fp) == (off_t)t->n - i); 552 } 553 554 /* negative + OOB */ 555 ATF_CHECK(fseeko(fp, (off_t)-1, SEEK_CUR) == -1); 556 ATF_CHECK(ftello(fp) == (off_t)0); 557 558 #if defined(__GLIBC__) 559 } 560 #endif 561 ATF_CHECK(fclose(fp) == 0); 562 } 563 } 564 } 565 566 ATF_TC(test12); 567 ATF_TC_HEAD(test12, tc) 568 { 569 atf_tc_set_md_var(tc, "descr", "test12"); 570 } 571 ATF_TC_BODY(test12, tc) 572 { 573 struct testcase *t; 574 off_t len, rest, i; 575 const char **p; 576 char buf[BUFSIZ]; 577 FILE *fp; 578 579 /* test fmemopen_seek(SEEK_END) */ 580 for (t = &testcases[0]; t->s != NULL; ++t) { 581 len = (off_t)strnlen(t->s, t->n); 582 rest = t->n - len; 583 for (p = &mode_r[0]; *p != NULL; ++p) { 584 585 memcpy(buf, t->s, t->n); 586 fp = fmemopen(&buf[0], t->n, *p); 587 ATF_CHECK(fp != NULL); 588 589 /* 590 * test fmemopen_seek(SEEK_END) 591 */ 592 #if !defined(__GLIBC__) 593 ATF_CHECK(ftello(fp) == (off_t)0); 594 595 /* zero */ 596 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_END) == 0); 597 ATF_CHECK(ftello(fp) == len); 598 599 /* positive + OOB */ 600 ATF_CHECK(fseeko(fp, rest + 1, SEEK_END) == -1); 601 ATF_CHECK(ftello(fp) == len); 602 603 /* negative + OOB */ 604 ATF_CHECK(fseeko(fp, -(len + 1), SEEK_END) == -1); 605 ATF_CHECK(ftello(fp) == len); 606 607 /* positive */ 608 for (i = 1; i <= rest; ++i) { 609 ATF_CHECK(fseeko(fp, i, SEEK_END) == 0); 610 ATF_CHECK(ftello(fp) == len + i); 611 } 612 613 /* negative */ 614 for (i = 1; i < len; ++i) { 615 ATF_CHECK(fseeko(fp, -i, SEEK_END) == 0); 616 ATF_CHECK(ftello(fp) == len - i); 617 } 618 #endif 619 ATF_CHECK(fclose(fp) == 0); 620 } 621 } 622 } 623 624 ATF_TC(test13); 625 ATF_TC_HEAD(test13, tc) 626 { 627 atf_tc_set_md_var(tc, "descr", "test13"); 628 } 629 ATF_TC_BODY(test13, tc) 630 { 631 struct testcase *t; 632 off_t i; 633 const char **p; 634 char buf[BUFSIZ]; 635 FILE *fp; 636 637 /* test fmemopen_seek(SEEK_END) */ 638 for (t = &testcases[0]; t->s != NULL; ++t) { 639 for (p = &mode_w[0]; *p != NULL; ++p) { 640 641 memcpy(buf, t->s, t->n); 642 fp = fmemopen(&buf[0], t->n, *p); 643 ATF_CHECK(fp != NULL); 644 /* 645 * test fmemopen_seek(SEEK_END) 646 */ 647 #if !defined(__GLIBC__) 648 ATF_CHECK(ftello(fp) == (off_t)0); 649 ATF_CHECK(buf[0] == '\0'); 650 651 /* zero */ 652 ATF_CHECK(fseeko(fp, (off_t)0, SEEK_END) == 0); 653 ATF_CHECK(ftello(fp) == (off_t)0); 654 655 /* positive + OOB */ 656 ATF_CHECK(fseeko(fp, (off_t)t->n + 1, SEEK_END) == -1); 657 ATF_CHECK(ftello(fp) == (off_t)0); 658 659 /* negative + OOB */ 660 ATF_CHECK(fseeko(fp, -1, SEEK_END) == -1); 661 ATF_CHECK(ftello(fp) == (off_t)0); 662 663 /* positive */ 664 for (i = 1; i <= t->n; ++i) { 665 ATF_CHECK(fseeko(fp, i, SEEK_END) == 0); 666 ATF_CHECK(ftello(fp) == i); 667 } 668 #endif 669 ATF_CHECK(fclose(fp) == 0); 670 } 671 } 672 } 673 674 ATF_TC(test14); 675 ATF_TC_HEAD(test14, tc) 676 { 677 atf_tc_set_md_var(tc, "descr", "test14"); 678 } 679 ATF_TC_BODY(test14, tc) 680 { 681 struct testcase *t; 682 off_t len, rest, i; 683 const char **p; 684 char buf[BUFSIZ]; 685 FILE *fp; 686 687 /* test fmemopen_seek(SEEK_END) */ 688 for (t = &testcases[0]; t->s != NULL; ++t) { 689 len = (off_t)strnlen(t->s, t->n); 690 rest = (off_t)t->n - len; 691 for (p = &mode_a[0]; *p != NULL; ++p) { 692 693 memcpy(buf, t->s, t->n); 694 fp = fmemopen(&buf[0], t->n, *p); 695 ATF_CHECK(fp != NULL); 696 /* 697 * test fmemopen_seek(SEEK_END) 698 */ 699 #if !defined(__GLIBC__) 700 ATF_CHECK(ftello(fp) == len); 701 702 /* zero */ 703 ATF_CHECK(fseeko(fp, 0, SEEK_END) == 0); 704 ATF_CHECK(ftello(fp) == len); 705 706 /* positive + OOB */ 707 ATF_CHECK(fseeko(fp, rest + 1, SEEK_END) == -1); 708 ATF_CHECK(ftello(fp) == len); 709 710 /* negative + OOB */ 711 ATF_CHECK(fseeko(fp, -(len + 1), SEEK_END) == -1); 712 ATF_CHECK(ftello(fp) == len); 713 714 /* positive */ 715 for (i = 1; i <= rest; ++i) { 716 ATF_CHECK(fseeko(fp, i, SEEK_END) == 0); 717 ATF_CHECK(ftello(fp) == len + i); 718 } 719 720 /* negative */ 721 for (i = 1; i < len; ++i) { 722 ATF_CHECK(fseeko(fp, -i, SEEK_END) == 0); 723 ATF_CHECK(ftello(fp) == len - i); 724 } 725 #endif 726 ATF_CHECK(fclose(fp) == 0); 727 } 728 } 729 } 730 731 const char *mode_rw1[] = { 732 "r", "rb", "r+", "rb+", "r+b", 733 "w+", "wb+", 734 NULL 735 }; 736 737 /* test15 - 18: 738 * When a stream open for writing is flushed or closed, a null byte is written 739 * at the current position or at the end of the buffer, depending on the size 740 * of the contents. 741 */ 742 743 ATF_TC(test15); 744 ATF_TC_HEAD(test15, tc) 745 { 746 atf_tc_set_md_var(tc, "descr", "test15"); 747 } 748 ATF_TC_BODY(test15, tc) 749 { 750 struct testcase *t; 751 const char **p; 752 char buf0[BUFSIZ]; 753 FILE *fp; 754 int i; 755 756 for (t = &testcases[0]; t->s != NULL; ++t) { 757 for (p = &mode_rw1[0]; *p != NULL; ++p) { 758 759 memcpy(&buf0[0], t->s, t->n); 760 fp = fmemopen(&buf0[0], t->n, *p); 761 ATF_CHECK(fp != NULL); 762 /* 763 * test fmemopen_read + fgetc(3) 764 */ 765 for (i = 0; i < t->n; ++i) { 766 ATF_CHECK(ftello(fp) == (off_t)i); 767 ATF_CHECK(fgetc(fp) == buf0[i]); 768 ATF_CHECK(feof(fp) == 0); 769 ATF_CHECK(ftello(fp) == (off_t)i + 1); 770 } 771 ATF_CHECK(fgetc(fp) == EOF); 772 ATF_CHECK(feof(fp) != 0); 773 ATF_CHECK(ftello(fp) == (off_t)t->n); 774 ATF_CHECK(fclose(fp) == 0); 775 } 776 } 777 } 778 779 ATF_TC(test16); 780 ATF_TC_HEAD(test16, tc) 781 { 782 atf_tc_set_md_var(tc, "descr", "test16"); 783 } 784 ATF_TC_BODY(test16, tc) 785 { 786 struct testcase *t; 787 const char **p; 788 char buf0[BUFSIZ], buf1[BUFSIZ]; 789 FILE *fp; 790 791 for (t = &testcases[0]; t->s != NULL; ++t) { 792 for (p = &mode_rw1[0]; *p != NULL; ++p) { 793 794 memcpy(&buf0[0], t->s, t->n); 795 buf1[t->n] = 0x1; 796 fp = fmemopen(&buf0[0], t->n, *p); 797 ATF_CHECK(fp != NULL); 798 /* 799 * test fmemopen_read + fread(4) 800 */ 801 ATF_CHECK(ftello(fp) == (off_t)0); 802 ATF_CHECK(fread(&buf1[0], 1, sizeof(buf1), fp) == (size_t)t->n); 803 ATF_CHECK(feof(fp) != 0); 804 ATF_CHECK(memcmp(&buf0[0], &buf1[0], t->n) == 0); 805 ATF_CHECK((unsigned char)buf1[t->n] == 0x1); 806 807 ATF_CHECK(fclose(fp) == 0); 808 } 809 } 810 } 811 812 const char *mode_a1[] = { "a+", "ab+", NULL }; 813 814 ATF_TC(test17); 815 ATF_TC_HEAD(test17, tc) 816 { 817 atf_tc_set_md_var(tc, "descr", "test17"); 818 } 819 ATF_TC_BODY(test17, tc) 820 { 821 struct testcase *t; 822 size_t len; 823 int i; 824 const char **p; 825 char buf[BUFSIZ]; 826 FILE *fp; 827 828 for (t = &testcases[0]; t->s != NULL; ++t) { 829 len = strnlen(t->s, t->n); 830 for (p = &mode_a1[0]; *p != NULL; ++p) { 831 832 memcpy(&buf[0], t->s, t->n); 833 fp = fmemopen(&buf[0], t->n, *p); 834 ATF_CHECK(fp != NULL); 835 /* 836 * test fmemopen_read + fgetc(3) 837 */ 838 #if defined(__GLIBC__) 839 if (i < t->n) { 840 #endif 841 for (i = len; i < t->n; ++i) { 842 ATF_CHECK(ftello(fp) == (off_t)i); 843 ATF_CHECK(fgetc(fp) == buf[i]); 844 ATF_CHECK(feof(fp) == 0); 845 ATF_CHECK(ftello(fp) == (off_t)i + 1); 846 } 847 ATF_CHECK(fgetc(fp) == EOF); 848 ATF_CHECK(feof(fp) != 0); 849 ATF_CHECK(ftello(fp) == (off_t)t->n); 850 rewind(fp); 851 for (i = 0; i < t->n; ++i) { 852 ATF_CHECK(ftello(fp) == (off_t)i); 853 ATF_CHECK(fgetc(fp) == buf[i]); 854 ATF_CHECK(feof(fp) == 0); 855 ATF_CHECK(ftello(fp) == (off_t)i + 1); 856 } 857 ATF_CHECK(fgetc(fp) == EOF); 858 ATF_CHECK(feof(fp) != 0); 859 ATF_CHECK(ftello(fp) == (off_t)t->n); 860 #if defined(__GLIBC__) 861 } 862 #endif 863 ATF_CHECK(fclose(fp) == 0); 864 } 865 } 866 } 867 868 ATF_TC(test18); 869 ATF_TC_HEAD(test18, tc) 870 { 871 atf_tc_set_md_var(tc, "descr", "test18"); 872 } 873 ATF_TC_BODY(test18, tc) 874 { 875 struct testcase *t; 876 size_t len; 877 const char **p; 878 char buf0[BUFSIZ], buf1[BUFSIZ]; 879 FILE *fp; 880 881 for (t = &testcases[0]; t->s != NULL; ++t) { 882 len = strnlen(t->s, t->n); 883 for (p = &mode_a1[0]; *p != NULL; ++p) { 884 885 memcpy(&buf0[0], t->s, t->n); 886 buf1[t->n - len] = 0x1; 887 fp = fmemopen(&buf0[0], t->n, *p); 888 ATF_CHECK(fp != NULL); 889 /* 890 * test fmemopen_read + fread(3) 891 */ 892 #if defined(__GLIBC__) 893 if (i < t->n) { 894 #endif 895 ATF_CHECK(ftello(fp) == (off_t)len); 896 ATF_CHECK(fread(&buf1[0], 1, sizeof(buf1), fp) 897 == t->n - len); 898 ATF_CHECK(feof(fp) != 0); 899 ATF_CHECK(!memcmp(&buf0[len], &buf1[0], t->n - len)); 900 ATF_CHECK((unsigned char)buf1[t->n - len] == 0x1); 901 rewind(fp); 902 buf1[t->n] = 0x1; 903 ATF_CHECK(ftello(fp) == (off_t)0); 904 ATF_CHECK(fread(&buf1[0], 1, sizeof(buf1), fp) 905 == (size_t)t->n); 906 ATF_CHECK(feof(fp) != 0); 907 ATF_CHECK(!memcmp(&buf0[0], &buf1[0], t->n)); 908 ATF_CHECK((unsigned char)buf1[t->n] == 0x1); 909 #if defined(__GLIBC__) 910 } 911 #endif 912 ATF_CHECK(fclose(fp) == 0); 913 } 914 } 915 } 916 917 /* 918 * test19 - test22: 919 * If a stream open for update is flushed or closed and the last write has 920 * advanced the current buffer size, a null byte is written at the end of the 921 * buffer if it fits. 922 */ 923 924 const char *mode_rw2[] = { 925 "r+", "rb+", "r+b", 926 "w", "wb", "w+", "wb+", "w+b", 927 NULL 928 }; 929 930 ATF_TC(test19); 931 ATF_TC_HEAD(test19, tc) 932 { 933 atf_tc_set_md_var(tc, "descr", "test19"); 934 } 935 ATF_TC_BODY(test19, tc) 936 { 937 struct testcase *t; 938 int i; 939 const char **p; 940 char buf[BUFSIZ]; 941 FILE *fp; 942 943 for (t = &testcases[0]; t->s != NULL; ++t) { 944 for (p = &mode_rw2[0]; *p != NULL; ++p) { 945 946 memcpy(&buf[0], t->s, t->n); 947 buf[t->n] = 0x1; 948 fp = fmemopen(&buf[0], t->n + 1, *p); 949 ATF_CHECK(fp != NULL); 950 setbuf(fp, NULL); 951 /* 952 * test fmemopen_write + fputc(3) 953 */ 954 for (i = 0; i < t->n; ++i) { 955 ATF_CHECK(ftello(fp) == (off_t)i); 956 ATF_CHECK(fputc(t->s[i], fp) == t->s[i]); 957 ATF_CHECK(buf[i] == t->s[i]); 958 ATF_CHECK(ftello(fp) == (off_t)i + 1); 959 ATF_CHECK(buf[i] == t->s[i]); 960 #if !defined(__GLIBC__) 961 ATF_CHECK(buf[i + 1] == '\0'); 962 #endif 963 } 964 965 /* don't accept non nul character at end of buffer */ 966 ATF_CHECK(fputc(0x1, fp) == EOF); 967 ATF_CHECK_MSG(ftello(fp) == (off_t)t->n, 968 "%jd != %jd", (intmax_t)ftello(fp), 969 (intmax_t)t->n); 970 ATF_CHECK(feof(fp) == 0); 971 972 /* accept nul character at end of buffer */ 973 ATF_CHECK(fputc('\0', fp) == '\0'); 974 ATF_CHECK(ftello(fp) == (off_t)t->n + 1); 975 ATF_CHECK(feof(fp) == 0); 976 977 /* reach EOF */ 978 ATF_CHECK(fputc('\0', fp) == EOF); 979 ATF_CHECK(ftello(fp) == (off_t)t->n + 1); 980 981 /* compare */ 982 ATF_CHECK(memcmp(&buf[0], t->s, t->n) == 0); 983 ATF_CHECK(buf[t->n] == '\0'); 984 985 ATF_CHECK(fclose(fp) == 0); 986 } 987 } 988 } 989 990 ATF_TC(test20); 991 ATF_TC_HEAD(test20, tc) 992 { 993 atf_tc_set_md_var(tc, "descr", "test20"); 994 } 995 ATF_TC_BODY(test20, tc) 996 { 997 struct testcase *t; 998 const char **p; 999 char buf[BUFSIZ]; 1000 FILE *fp; 1001 1002 for (t = &testcases[0]; t->s != NULL; ++t) { 1003 for (p = &mode_rw2[0]; *p != NULL; ++p) { 1004 1005 memcpy(&buf[0], t->s, t->n); 1006 buf[t->n] = 0x1; 1007 fp = fmemopen(&buf[0], t->n + 1, *p); 1008 ATF_CHECK(fp != NULL); 1009 setbuf(fp, NULL); 1010 ATF_CHECK(fwrite(t->s, 1, t->n, fp) == (size_t)t->n); 1011 /* 1012 * test fmemopen_write + fwrite(3) 1013 */ 1014 #if !defined(__GLIBC__) 1015 ATF_CHECK(buf[t->n] == '\0'); 1016 1017 /* don't accept non nul character at end of buffer */ 1018 ATF_CHECK(fwrite("\x1", 1, 1, fp) == 0); 1019 ATF_CHECK(ftello(fp) == (off_t)t->n); 1020 ATF_CHECK(feof(fp) == 0); 1021 #endif 1022 1023 /* accept nul character at end of buffer */ 1024 ATF_CHECK(fwrite("\x0", 1, 1, fp) == 1); 1025 ATF_CHECK(ftello(fp) == (off_t)t->n + 1); 1026 ATF_CHECK(feof(fp) == 0); 1027 1028 /* reach EOF */ 1029 ATF_CHECK(fputc('\0', fp) == EOF); 1030 ATF_CHECK(ftello(fp) == (off_t)t->n + 1); 1031 1032 /* compare */ 1033 ATF_CHECK(memcmp(&buf[0], t->s, t->n) == 0); 1034 ATF_CHECK(buf[t->n] == '\0'); 1035 1036 ATF_CHECK(fclose(fp) == 0); 1037 } 1038 } 1039 } 1040 1041 ATF_TC(test21); 1042 ATF_TC_HEAD(test21, tc) 1043 { 1044 atf_tc_set_md_var(tc, "descr", "test21"); 1045 } 1046 ATF_TC_BODY(test21, tc) 1047 { 1048 struct testcase *t; 1049 int len, i; 1050 const char **p; 1051 char buf[BUFSIZ]; 1052 FILE *fp; 1053 1054 for (t = &testcases[0]; t->s != NULL; ++t) { 1055 len = strnlen(t->s, t->n); 1056 for (p = &mode_a[0]; *p != NULL; ++p) { 1057 memcpy(&buf[0], t->s, t->n); 1058 fp = fmemopen(&buf[0], t->n, *p); 1059 ATF_CHECK(fp != NULL); 1060 setbuf(fp, NULL); 1061 /* 1062 * test fmemopen_write + fputc(3) 1063 */ 1064 if (len < t->n) { 1065 for (i = len; i < t->n - 1; ++i) { 1066 ATF_CHECK(ftello(fp) == (off_t)i); 1067 ATF_CHECK(fputc(t->s[i - len], fp) 1068 == t->s[i - len]); 1069 ATF_CHECK(buf[i] == t->s[i - len]); 1070 ATF_CHECK(ftello(fp) == (off_t)i + 1); 1071 #if !defined(__GLIBC__) 1072 ATF_CHECK(buf[i + 1] == '\0'); 1073 #endif 1074 } 1075 1076 /* don't accept non nul character at end of buffer */ 1077 ATF_CHECK(ftello(fp) == (off_t)t->n - 1); 1078 ATF_CHECK(fputc(0x1, fp) == EOF); 1079 ATF_CHECK(ftello(fp) == (off_t)t->n - 1); 1080 1081 /* accept nul character at end of buffer */ 1082 ATF_CHECK(ftello(fp) == (off_t)t->n - 1); 1083 ATF_CHECK(fputc('\0', fp) == '\0'); 1084 ATF_CHECK(ftello(fp) == (off_t)t->n); 1085 } 1086 1087 /* reach EOF */ 1088 ATF_CHECK(ftello(fp) == (off_t)t->n); 1089 ATF_CHECK(fputc('\0', fp) == EOF); 1090 ATF_CHECK(ftello(fp) == (off_t)t->n); 1091 1092 ATF_CHECK(fclose(fp) == 0); 1093 } 1094 } 1095 } 1096 1097 ATF_TC(test22); 1098 ATF_TC_HEAD(test22, tc) 1099 { 1100 atf_tc_set_md_var(tc, "descr", "test22"); 1101 } 1102 ATF_TC_BODY(test22, tc) 1103 { 1104 struct testcase *t0, *t1; 1105 size_t len0, len1, nleft; 1106 const char **p; 1107 char buf[BUFSIZ]; 1108 FILE *fp; 1109 1110 for (t0 = &testcases[0]; t0->s != NULL; ++t0) { 1111 len0 = strnlen(t0->s, t0->n); 1112 for (t1 = &testcases[0]; t1->s != NULL; ++t1) { 1113 len1 = strnlen(t1->s, t1->n); 1114 for (p = &mode_a[0]; *p != NULL; ++p) { 1115 1116 memcpy(&buf[0], t0->s, t0->n); 1117 fp = fmemopen(&buf[0], t0->n, *p); 1118 ATF_CHECK(fp != NULL); 1119 setbuf(fp, NULL); 1120 /* 1121 * test fmemopen_write + fwrite(3) 1122 */ 1123 nleft = t0->n - len0; 1124 #if !defined(__GLIBC__) 1125 if (nleft == 0 || len1 == nleft - 1) { 1126 ATF_CHECK(fwrite(t1->s, 1, t1->n, fp) 1127 == nleft); 1128 ATF_CHECK(ftell(fp) == t1->n); 1129 } else { 1130 ATF_CHECK(fwrite(t1->s, 1, t1->n, fp) 1131 == nleft - 1); 1132 ATF_CHECK(ftell(fp) == t1->n - 1); 1133 } 1134 #endif 1135 ATF_CHECK(fclose(fp) == 0); 1136 } 1137 } 1138 } 1139 } 1140 1141 ATF_TP_ADD_TCS(tp) 1142 { 1143 ATF_TP_ADD_TC(tp, test00); 1144 ATF_TP_ADD_TC(tp, test01); 1145 ATF_TP_ADD_TC(tp, test02); 1146 ATF_TP_ADD_TC(tp, test03); 1147 ATF_TP_ADD_TC(tp, test04); 1148 ATF_TP_ADD_TC(tp, test05); 1149 ATF_TP_ADD_TC(tp, test06); 1150 ATF_TP_ADD_TC(tp, test07); 1151 ATF_TP_ADD_TC(tp, test08); 1152 ATF_TP_ADD_TC(tp, test09); 1153 ATF_TP_ADD_TC(tp, test10); 1154 ATF_TP_ADD_TC(tp, test11); 1155 ATF_TP_ADD_TC(tp, test12); 1156 ATF_TP_ADD_TC(tp, test13); 1157 ATF_TP_ADD_TC(tp, test14); 1158 ATF_TP_ADD_TC(tp, test15); 1159 ATF_TP_ADD_TC(tp, test16); 1160 ATF_TP_ADD_TC(tp, test17); 1161 ATF_TP_ADD_TC(tp, test18); 1162 ATF_TP_ADD_TC(tp, test19); 1163 ATF_TP_ADD_TC(tp, test20); 1164 ATF_TP_ADD_TC(tp, test21); 1165 ATF_TP_ADD_TC(tp, test22); 1166 1167 return atf_no_error(); 1168 } 1169
Indexes created Sat Sep 20 22:09:52 GMT 2025