1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include "apr_file_io.h"
18 #include "apr_file_info.h"
19 #include "apr_network_io.h"
20 #include "apr_errno.h"
21 #include "apr_general.h"
26 #define DIRNAME "data"
27 #define FILENAME DIRNAME "/file_datafile.txt"
28 #define TESTSTR "This is the file data file."
30 #define TESTREAD_BLKSIZE 1024
31 #define APR_BUFFERSIZE 4096 /* This should match APR's buffer size. */
35 static void test_open_noreadwrite(CuTest *tc)
38 apr_file_t *thefile = NULL;
40 rv = apr_file_open(&thefile, FILENAME,
41 APR_CREATE | APR_EXCL,
42 APR_UREAD | APR_UWRITE | APR_GREAD, p);
43 CuAssertTrue(tc, rv != APR_SUCCESS);
44 CuAssertIntEquals(tc, 1, APR_STATUS_IS_EACCES(rv));
45 CuAssertPtrEquals(tc, NULL, thefile);
48 static void test_open_excl(CuTest *tc)
51 apr_file_t *thefile = NULL;
53 rv = apr_file_open(&thefile, FILENAME,
54 APR_CREATE | APR_EXCL | APR_WRITE,
55 APR_UREAD | APR_UWRITE | APR_GREAD, p);
56 CuAssertTrue(tc, rv != APR_SUCCESS);
57 CuAssertIntEquals(tc, 1, APR_STATUS_IS_EEXIST(rv));
58 CuAssertPtrEquals(tc, NULL, thefile);
61 static void test_open_read(CuTest *tc)
64 apr_file_t *filetest = NULL;
66 rv = apr_file_open(&filetest, FILENAME,
68 APR_UREAD | APR_UWRITE | APR_GREAD, p);
69 CuAssertIntEquals(tc, APR_SUCCESS, rv);
70 CuAssertPtrNotNull(tc, filetest);
71 apr_file_close(filetest);
74 static void test_read(CuTest *tc)
77 apr_size_t nbytes = 256;
78 char *str = apr_pcalloc(p, nbytes + 1);
79 apr_file_t *filetest = NULL;
81 rv = apr_file_open(&filetest, FILENAME,
83 APR_UREAD | APR_UWRITE | APR_GREAD, p);
85 apr_assert_success(tc, "Opening test file " FILENAME, rv);
86 rv = apr_file_read(filetest, str, &nbytes);
87 CuAssertIntEquals(tc, APR_SUCCESS, rv);
88 CuAssertIntEquals(tc, strlen(TESTSTR), nbytes);
89 CuAssertStrEquals(tc, TESTSTR, str);
91 apr_file_close(filetest);
94 static void test_filename(CuTest *tc)
98 apr_file_t *filetest = NULL;
100 rv = apr_file_open(&filetest, FILENAME,
102 APR_UREAD | APR_UWRITE | APR_GREAD, p);
103 apr_assert_success(tc, "Opening test file " FILENAME, rv);
105 rv = apr_file_name_get(&str, filetest);
106 CuAssertIntEquals(tc, APR_SUCCESS, rv);
107 CuAssertStrEquals(tc, FILENAME, str);
109 apr_file_close(filetest);
112 static void test_fileclose(CuTest *tc)
117 apr_file_t *filetest = NULL;
119 rv = apr_file_open(&filetest, FILENAME,
121 APR_UREAD | APR_UWRITE | APR_GREAD, p);
122 apr_assert_success(tc, "Opening test file " FILENAME, rv);
124 rv = apr_file_close(filetest);
125 CuAssertIntEquals(tc, APR_SUCCESS, rv);
126 /* We just closed the file, so this should fail */
127 rv = apr_file_read(filetest, &str, &one);
128 CuAssertIntEquals(tc, 1, APR_STATUS_IS_EBADF(rv));
131 static void test_file_remove(CuTest *tc)
134 apr_file_t *filetest = NULL;
136 rv = apr_file_remove(FILENAME, p);
137 CuAssertIntEquals(tc, APR_SUCCESS, rv);
139 rv = apr_file_open(&filetest, FILENAME, APR_READ,
140 APR_UREAD | APR_UWRITE | APR_GREAD, p);
141 CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
144 static void test_open_write(CuTest *tc)
147 apr_file_t *filetest = NULL;
150 rv = apr_file_open(&filetest, FILENAME,
152 APR_UREAD | APR_UWRITE | APR_GREAD, p);
153 CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
154 CuAssertPtrEquals(tc, NULL, filetest);
157 static void test_open_writecreate(CuTest *tc)
160 apr_file_t *filetest = NULL;
163 rv = apr_file_open(&filetest, FILENAME,
164 APR_WRITE | APR_CREATE,
165 APR_UREAD | APR_UWRITE | APR_GREAD, p);
166 CuAssertIntEquals(tc, APR_SUCCESS, rv);
168 apr_file_close(filetest);
171 static void test_write(CuTest *tc)
174 apr_size_t bytes = strlen(TESTSTR);
175 apr_file_t *filetest = NULL;
177 rv = apr_file_open(&filetest, FILENAME,
178 APR_WRITE | APR_CREATE,
179 APR_UREAD | APR_UWRITE | APR_GREAD, p);
180 CuAssertIntEquals(tc, APR_SUCCESS, rv);
182 rv = apr_file_write(filetest, TESTSTR, &bytes);
183 CuAssertIntEquals(tc, APR_SUCCESS, rv);
185 apr_file_close(filetest);
188 static void test_open_readwrite(CuTest *tc)
191 apr_file_t *filetest = NULL;
194 rv = apr_file_open(&filetest, FILENAME,
195 APR_READ | APR_WRITE,
196 APR_UREAD | APR_UWRITE | APR_GREAD, p);
197 CuAssertIntEquals(tc, APR_SUCCESS, rv);
198 CuAssertPtrNotNull(tc, filetest);
200 apr_file_close(filetest);
203 static void test_seek(CuTest *tc)
206 apr_off_t offset = 5;
207 apr_size_t nbytes = 256;
208 char *str = apr_pcalloc(p, nbytes + 1);
209 apr_file_t *filetest = NULL;
211 rv = apr_file_open(&filetest, FILENAME,
213 APR_UREAD | APR_UWRITE | APR_GREAD, p);
214 apr_assert_success(tc, "Open test file " FILENAME, rv);
216 rv = apr_file_read(filetest, str, &nbytes);
217 CuAssertIntEquals(tc, APR_SUCCESS, rv);
218 CuAssertIntEquals(tc, strlen(TESTSTR), nbytes);
219 CuAssertStrEquals(tc, TESTSTR, str);
221 memset(str, 0, nbytes + 1);
223 rv = apr_file_seek(filetest, SEEK_SET, &offset);
224 CuAssertIntEquals(tc, APR_SUCCESS, rv);
226 rv = apr_file_read(filetest, str, &nbytes);
227 CuAssertIntEquals(tc, APR_SUCCESS, rv);
228 CuAssertIntEquals(tc, strlen(TESTSTR) - 5, nbytes);
229 CuAssertStrEquals(tc, TESTSTR + 5, str);
231 apr_file_close(filetest);
233 /* Test for regression of sign error bug with SEEK_END and
235 rv = apr_file_open(&filetest, FILENAME,
236 APR_READ | APR_BUFFERED,
237 APR_UREAD | APR_UWRITE | APR_GREAD, p);
238 apr_assert_success(tc, "Open test file " FILENAME, rv);
241 rv = apr_file_seek(filetest, SEEK_END, &offset);
242 CuAssertIntEquals(tc, APR_SUCCESS, rv);
243 CuAssertIntEquals(tc, strlen(TESTSTR) - 5, offset);
245 memset(str, 0, nbytes + 1);
247 rv = apr_file_read(filetest, str, &nbytes);
248 CuAssertIntEquals(tc, APR_SUCCESS, rv);
249 CuAssertIntEquals(tc, 5, nbytes);
250 CuAssertStrEquals(tc, TESTSTR + strlen(TESTSTR) - 5, str);
252 apr_file_close(filetest);
255 static void test_userdata_set(CuTest *tc)
258 apr_file_t *filetest = NULL;
260 rv = apr_file_open(&filetest, FILENAME,
262 APR_UREAD | APR_UWRITE | APR_GREAD, p);
263 CuAssertIntEquals(tc, APR_SUCCESS, rv);
265 rv = apr_file_data_set(filetest, "This is a test",
266 "test", apr_pool_cleanup_null);
267 CuAssertIntEquals(tc, APR_SUCCESS, rv);
268 apr_file_close(filetest);
271 static void test_userdata_get(CuTest *tc)
275 apr_file_t *filetest = NULL;
277 rv = apr_file_open(&filetest, FILENAME,
279 APR_UREAD | APR_UWRITE | APR_GREAD, p);
280 CuAssertIntEquals(tc, APR_SUCCESS, rv);
282 rv = apr_file_data_set(filetest, "This is a test",
283 "test", apr_pool_cleanup_null);
284 CuAssertIntEquals(tc, APR_SUCCESS, rv);
286 rv = apr_file_data_get((void **)&teststr, "test", filetest);
287 CuAssertIntEquals(tc, APR_SUCCESS, rv);
288 CuAssertStrEquals(tc, "This is a test", teststr);
290 apr_file_close(filetest);
293 static void test_userdata_getnokey(CuTest *tc)
297 apr_file_t *filetest = NULL;
299 rv = apr_file_open(&filetest, FILENAME,
301 APR_UREAD | APR_UWRITE | APR_GREAD, p);
302 CuAssertIntEquals(tc, APR_SUCCESS, rv);
304 rv = apr_file_data_get((void **)&teststr, "nokey", filetest);
305 CuAssertIntEquals(tc, APR_SUCCESS, rv);
306 CuAssertPtrEquals(tc, NULL, teststr);
307 apr_file_close(filetest);
310 static void test_getc(CuTest *tc)
312 apr_file_t *f = NULL;
316 rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
317 CuAssertIntEquals(tc, APR_SUCCESS, rv);
319 apr_file_getc(&ch, f);
320 CuAssertIntEquals(tc, APR_SUCCESS, rv);
321 CuAssertIntEquals(tc, (int)TESTSTR[0], (int)ch);
325 static void test_ungetc(CuTest *tc)
327 apr_file_t *f = NULL;
331 rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
332 CuAssertIntEquals(tc, APR_SUCCESS, rv);
334 apr_file_getc(&ch, f);
335 CuAssertIntEquals(tc, APR_SUCCESS, rv);
336 CuAssertIntEquals(tc, (int)TESTSTR[0], (int)ch);
338 apr_file_ungetc('X', f);
339 CuAssertIntEquals(tc, APR_SUCCESS, rv);
341 apr_file_getc(&ch, f);
342 CuAssertIntEquals(tc, APR_SUCCESS, rv);
343 CuAssertIntEquals(tc, 'X', (int)ch);
348 static void test_gets(CuTest *tc)
350 apr_file_t *f = NULL;
352 char *str = apr_palloc(p, 256);
354 rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
355 CuAssertIntEquals(tc, APR_SUCCESS, rv);
357 rv = apr_file_gets(str, 256, f);
358 /* Only one line in the test file, so APR will encounter EOF on the first
359 * call to gets, but we should get APR_SUCCESS on this call and
360 * APR_EOF on the next.
362 CuAssertIntEquals(tc, APR_SUCCESS, rv);
363 CuAssertStrEquals(tc, TESTSTR, str);
364 rv = apr_file_gets(str, 256, f);
365 CuAssertIntEquals(tc, APR_EOF, rv);
366 CuAssertStrEquals(tc, "", str);
370 static void test_bigread(CuTest *tc)
372 apr_file_t *f = NULL;
374 char buf[APR_BUFFERSIZE * 2];
377 /* Create a test file with known content.
379 rv = apr_file_open(&f, "data/created_file",
380 APR_CREATE | APR_WRITE | APR_TRUNCATE,
381 APR_UREAD | APR_UWRITE, p);
382 CuAssertIntEquals(tc, APR_SUCCESS, rv);
384 nbytes = APR_BUFFERSIZE;
385 memset(buf, 0xFE, nbytes);
387 rv = apr_file_write(f, buf, &nbytes);
388 CuAssertIntEquals(tc, APR_SUCCESS, rv);
389 CuAssertIntEquals(tc, APR_BUFFERSIZE, nbytes);
391 rv = apr_file_close(f);
392 CuAssertIntEquals(tc, APR_SUCCESS, rv);
395 rv = apr_file_open(&f, "data/created_file", APR_READ, 0, p);
396 CuAssertIntEquals(tc, APR_SUCCESS, rv);
399 rv = apr_file_read(f, buf, &nbytes);
400 CuAssertIntEquals(tc, APR_SUCCESS, rv);
401 CuAssertIntEquals(tc, APR_BUFFERSIZE, nbytes);
403 rv = apr_file_close(f);
404 CuAssertIntEquals(tc, APR_SUCCESS, rv);
406 rv = apr_file_remove("data/created_file", p);
407 CuAssertIntEquals(tc, APR_SUCCESS, rv);
410 /* Test that the contents of file FNAME are equal to data EXPECT of
411 * length EXPECTLEN. */
412 static void file_contents_equal(CuTest *tc,
415 apr_size_t expectlen)
417 void *actual = apr_palloc(p, expectlen);
422 rv = apr_file_open(&f, fname, APR_READ|APR_BUFFERED, 0, p);
423 CuAssertIntEquals(tc, APR_SUCCESS, rv);
425 rv = apr_file_read_full(f, actual, expectlen, NULL);
426 CuAssertIntEquals(tc, APR_SUCCESS, rv);
428 rc = memcmp(expect, actual, expectlen);
429 CuAssertIntEquals(tc, 0, rc);
431 rv = apr_file_close(f);
432 CuAssertIntEquals(tc, APR_SUCCESS, rv);
435 #define LINE1 "this is a line of text\n"
436 #define LINE2 "this is a second line of text\n"
438 static void test_writev_buffered(CuTest *tc)
444 const char *fname = "data/testwritev_buffered.dat";
446 rv = apr_file_open(&f, fname,
447 APR_WRITE | APR_CREATE | APR_TRUNCATE |
448 APR_BUFFERED, APR_OS_DEFAULT, p);
449 CuAssertIntEquals(tc, APR_SUCCESS, rv);
451 nbytes = strlen(TESTSTR);
452 rv = apr_file_write(f, TESTSTR, &nbytes);
453 CuAssertIntEquals(tc, APR_SUCCESS, rv);
455 vec[0].iov_base = LINE1;
456 vec[0].iov_len = strlen(LINE1);
457 vec[1].iov_base = LINE2;
458 vec[1].iov_len = strlen(LINE2);
460 rv = apr_file_writev(f, vec, 2, &nbytes);
461 CuAssertIntEquals(tc, APR_SUCCESS, rv);
463 rv = apr_file_close(f);
464 CuAssertIntEquals(tc, APR_SUCCESS, rv);
466 file_contents_equal(tc, fname, TESTSTR LINE1 LINE2,
467 strlen(TESTSTR) + strlen(LINE1) + strlen(LINE2));
470 static void test_writev_buffered_seek(CuTest *tc)
476 apr_size_t nbytes = strlen(TESTSTR);
477 char *str = apr_pcalloc(p, nbytes+1);
478 const char *fname = "data/testwritev_buffered.dat";
480 rv = apr_file_open(&f, fname,
481 APR_WRITE | APR_READ | APR_BUFFERED,
484 rv = apr_file_read(f, str, &nbytes);
485 CuAssertIntEquals(tc, APR_SUCCESS, rv);
486 CuAssertStrEquals(tc, TESTSTR, str);
488 rv = apr_file_seek(f, APR_SET, &off);
489 CuAssertIntEquals(tc, APR_SUCCESS, rv);
491 vec[0].iov_base = LINE1;
492 vec[0].iov_len = strlen(LINE1);
493 vec[1].iov_base = LINE2;
494 vec[1].iov_len = strlen(LINE2);
495 vec[2].iov_base = TESTSTR;
496 vec[2].iov_len = strlen(TESTSTR);
498 rv = apr_file_writev(f, vec, 3, &nbytes);
499 CuAssertIntEquals(tc, APR_SUCCESS, rv);
501 rv = apr_file_close(f);
502 CuAssertIntEquals(tc, APR_SUCCESS, rv);
504 file_contents_equal(tc, fname, LINE1 LINE2 TESTSTR,
505 strlen(LINE1) + strlen(LINE2) + strlen(TESTSTR));
507 rv = apr_file_remove(fname, p);
508 CuAssertIntEquals(tc, APR_SUCCESS, rv);
511 /* This is a horrible name for this function. We are testing APR, not how
512 * Apache uses APR. And, this function tests _way_ too much stuff.
514 static void test_mod_neg(CuTest *tc)
523 const char *fname = "data/modneg.dat";
525 rv = apr_file_open(&f, fname,
526 APR_CREATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
527 CuAssertIntEquals(tc, APR_SUCCESS, rv);
531 rv = apr_file_write(f, s, &nbytes);
532 CuAssertIntEquals(tc, APR_SUCCESS, rv);
533 CuAssertIntEquals(tc, strlen(s), nbytes);
535 for (i = 0; i < 7980; i++) {
538 rv = apr_file_write(f, s, &nbytes);
539 CuAssertIntEquals(tc, APR_SUCCESS, rv);
540 CuAssertIntEquals(tc, strlen(s), nbytes);
545 rv = apr_file_write(f, s, &nbytes);
546 CuAssertIntEquals(tc, APR_SUCCESS, rv);
547 CuAssertIntEquals(tc, strlen(s), nbytes);
549 for (i = 0; i < 10000; i++) {
552 rv = apr_file_write(f, s, &nbytes);
553 CuAssertIntEquals(tc, APR_SUCCESS, rv);
554 CuAssertIntEquals(tc, strlen(s), nbytes);
557 rv = apr_file_close(f);
558 CuAssertIntEquals(tc, APR_SUCCESS, rv);
560 rv = apr_file_open(&f, fname, APR_READ, 0, p);
561 CuAssertIntEquals(tc, APR_SUCCESS, rv);
563 rv = apr_file_gets(buf, 11, f);
564 CuAssertIntEquals(tc, APR_SUCCESS, rv);
565 CuAssertStrEquals(tc, "body56789\n", buf);
568 rv = apr_file_seek(f, APR_CUR, &cur);
569 CuAssertIntEquals(tc, APR_SUCCESS, rv);
570 CuAssert(tc, "File Pointer Mismatch, expected 10", cur == 10);
572 nbytes = sizeof(buf);
573 rv = apr_file_read(f, buf, &nbytes);
574 CuAssertIntEquals(tc, APR_SUCCESS, rv);
575 CuAssertIntEquals(tc, nbytes, sizeof(buf));
577 cur = -((apr_off_t)nbytes - 7980);
578 rv = apr_file_seek(f, APR_CUR, &cur);
579 CuAssertIntEquals(tc, APR_SUCCESS, rv);
580 CuAssert(tc, "File Pointer Mismatch, expected 7990", cur == 7990);
582 rv = apr_file_gets(buf, 11, f);
583 CuAssertIntEquals(tc, APR_SUCCESS, rv);
584 CuAssertStrEquals(tc, "end456789\n", buf);
586 rv = apr_file_close(f);
587 CuAssertIntEquals(tc, APR_SUCCESS, rv);
589 rv = apr_file_remove(fname, p);
590 CuAssertIntEquals(tc, APR_SUCCESS, rv);
593 static void test_truncate(CuTest *tc)
597 const char *fname = "data/testtruncate.dat";
602 apr_file_remove(fname, p);
604 rv = apr_file_open(&f, fname,
605 APR_CREATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
606 CuAssertIntEquals(tc, APR_SUCCESS, rv);
610 rv = apr_file_write(f, s, &nbytes);
611 CuAssertIntEquals(tc, APR_SUCCESS, rv);
612 CuAssertIntEquals(tc, strlen(s), nbytes);
614 rv = apr_file_close(f);
615 CuAssertIntEquals(tc, APR_SUCCESS, rv);
617 rv = apr_file_open(&f, fname,
618 APR_TRUNCATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
619 CuAssertIntEquals(tc, APR_SUCCESS, rv);
621 rv = apr_file_close(f);
622 CuAssertIntEquals(tc, APR_SUCCESS, rv);
624 rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, p);
625 CuAssertIntEquals(tc, APR_SUCCESS, rv);
626 CuAssert(tc, "File size mismatch, expected 0 (empty)", finfo.size == 0);
628 rv = apr_file_remove(fname, p);
629 CuAssertIntEquals(tc, APR_SUCCESS, rv);
632 static void test_fail_write_flush(CuTest *tc)
635 const char *fname = "data/testflush.dat";
637 char buf[APR_BUFFERSIZE];
640 apr_file_remove(fname, p);
642 apr_assert_success(tc, "open test file",
643 apr_file_open(&f, fname,
644 APR_CREATE|APR_READ|APR_BUFFERED,
645 APR_UREAD|APR_UWRITE, p));
647 memset(buf, 'A', sizeof buf);
649 /* Try three writes. One of these should fail when it exceeds the
650 * internal buffer and actually tries to write to the file, which
651 * was opened read-only and hence should be unwritable. */
652 for (n = 0, rv = APR_SUCCESS; n < 4 && rv == APR_SUCCESS; n++) {
653 apr_size_t bytes = sizeof buf;
654 rv = apr_file_write(f, buf, &bytes);
657 CuAssert(tc, "failed to write to read-only buffered fd",
661 apr_file_remove(fname, p);
664 static void test_fail_read_flush(CuTest *tc)
667 const char *fname = "data/testflush.dat";
671 apr_file_remove(fname, p);
673 apr_assert_success(tc, "open test file",
674 apr_file_open(&f, fname,
675 APR_CREATE|APR_READ|APR_BUFFERED,
676 APR_UREAD|APR_UWRITE, p));
678 /* this write should be buffered. */
679 apr_assert_success(tc, "buffered write should succeed",
680 apr_file_puts("hello", f));
682 /* Now, trying a read should fail since the write must be flushed,
683 * and should fail with something other than EOF since the file is
684 * opened read-only. */
685 rv = apr_file_read_full(f, buf, 2, NULL);
687 CuAssert(tc, "read should flush buffered write and fail",
688 rv != APR_SUCCESS && rv != APR_EOF);
690 /* Likewise for gets */
691 rv = apr_file_gets(buf, 2, f);
693 CuAssert(tc, "gets should flush buffered write and fail",
694 rv != APR_SUCCESS && rv != APR_EOF);
697 apr_file_remove(fname, p);
700 static void test_xthread(CuTest *tc)
703 const char *fname = "data/testxthread.dat";
705 apr_int32_t flags = APR_CREATE|APR_READ|APR_WRITE|APR_APPEND|APR_XTHREAD;
706 char buf[128] = { 0 };
708 /* Test for bug 38438, opening file with append + xthread and seeking to
709 the end of the file resulted in writes going to the beginning not the
712 apr_file_remove(fname, p);
714 rv = apr_file_open(&f, fname, flags, APR_UREAD|APR_UWRITE, p);
715 CuAssert(tc, "open test file", rv == APR_SUCCESS);
717 rv = apr_file_puts("hello", f);
718 CuAssert(tc, "write should succeed", rv == APR_SUCCESS);
722 rv = apr_file_open(&f, fname, flags, APR_UREAD|APR_UWRITE, p);
723 CuAssert(tc, "open test file", rv == APR_SUCCESS);
725 /* Seek to the end. */
727 apr_off_t offset = 0;
729 rv = apr_file_seek(f, APR_END, &offset);
732 rv = apr_file_puts("world", f);
733 CuAssert(tc, "more writes should succeed", rv == APR_SUCCESS);
735 /* Back to the beginning. */
737 apr_off_t offset = 0;
739 rv = apr_file_seek(f, APR_SET, &offset);
742 apr_file_read_full(f, buf, sizeof(buf), NULL);
744 CuAssertStrEquals(tc, "helloworld", buf);
749 CuSuite *testfile(void)
751 CuSuite *suite = CuSuiteNew("File I/O");
753 SUITE_ADD_TEST(suite, test_open_noreadwrite);
754 SUITE_ADD_TEST(suite, test_open_excl);
755 SUITE_ADD_TEST(suite, test_open_read);
756 SUITE_ADD_TEST(suite, test_open_readwrite);
757 SUITE_ADD_TEST(suite, test_read);
758 SUITE_ADD_TEST(suite, test_seek);
759 SUITE_ADD_TEST(suite, test_filename);
760 SUITE_ADD_TEST(suite, test_fileclose);
761 SUITE_ADD_TEST(suite, test_file_remove);
762 SUITE_ADD_TEST(suite, test_open_write);
763 SUITE_ADD_TEST(suite, test_open_writecreate);
764 SUITE_ADD_TEST(suite, test_write);
765 SUITE_ADD_TEST(suite, test_userdata_set);
766 SUITE_ADD_TEST(suite, test_userdata_get);
767 SUITE_ADD_TEST(suite, test_userdata_getnokey);
768 SUITE_ADD_TEST(suite, test_getc);
769 SUITE_ADD_TEST(suite, test_ungetc);
770 SUITE_ADD_TEST(suite, test_gets);
771 SUITE_ADD_TEST(suite, test_bigread);
772 SUITE_ADD_TEST(suite, test_writev_buffered);
773 SUITE_ADD_TEST(suite, test_writev_buffered_seek);
774 SUITE_ADD_TEST(suite, test_mod_neg);
775 SUITE_ADD_TEST(suite, test_truncate);
776 SUITE_ADD_TEST(suite, test_fail_write_flush);
777 SUITE_ADD_TEST(suite, test_fail_read_flush);
778 SUITE_ADD_TEST(suite, test_xthread);