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.
18 #include "apr_general.h"
19 #include "apr_pools.h"
20 #include "apr_errno.h"
21 #include "apr_file_io.h"
24 #define TEST "Testing\n"
25 #define TEST2 "Testing again\n"
26 #define FILEPATH "data/"
28 static void test_file_dup(CuTest *tc)
30 apr_file_t *file1 = NULL;
31 apr_file_t *file3 = NULL;
35 /* First, create a new file, empty... */
36 rv = apr_file_open(&file1, FILEPATH "testdup.file",
37 APR_READ | APR_WRITE | APR_CREATE |
38 APR_DELONCLOSE, APR_OS_DEFAULT, p);
39 CuAssertIntEquals(tc, APR_SUCCESS, rv);
40 CuAssertPtrNotNull(tc, file1);
42 rv = apr_file_dup(&file3, file1, p);
43 CuAssertIntEquals(tc, APR_SUCCESS, rv);
44 CuAssertPtrNotNull(tc, file3);
46 rv = apr_file_close(file1);
47 CuAssertIntEquals(tc, APR_SUCCESS, rv);
49 /* cleanup after ourselves */
50 rv = apr_file_close(file3);
51 CuAssertIntEquals(tc, APR_SUCCESS, rv);
52 rv = apr_stat(&finfo, FILEPATH "testdup.file", APR_FINFO_NORM, p);
53 CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
56 static void test_file_readwrite(CuTest *tc)
58 apr_file_t *file1 = NULL;
59 apr_file_t *file3 = NULL;
62 apr_size_t txtlen = sizeof(TEST);
66 /* First, create a new file, empty... */
67 rv = apr_file_open(&file1, FILEPATH "testdup.readwrite.file",
68 APR_READ | APR_WRITE | APR_CREATE |
69 APR_DELONCLOSE, APR_OS_DEFAULT, p);
70 CuAssertIntEquals(tc, APR_SUCCESS, rv);
71 CuAssertPtrNotNull(tc, file1);
73 rv = apr_file_dup(&file3, file1, p);
74 CuAssertIntEquals(tc, APR_SUCCESS, rv);
75 CuAssertPtrNotNull(tc, file3);
77 rv = apr_file_write(file3, TEST, &txtlen);
78 CuAssertIntEquals(tc, APR_SUCCESS, rv);
79 CuAssertIntEquals(tc, sizeof(TEST), txtlen);
82 rv = apr_file_seek(file1, APR_SET, &fpos);
83 CuAssertIntEquals(tc, APR_SUCCESS, rv);
84 CuAssert(tc, "File position mismatch, expected 0", fpos == 0);
87 rv = apr_file_read(file1, buff, &txtlen);
88 CuAssertIntEquals(tc, APR_SUCCESS, rv);
89 CuAssertStrEquals(tc, TEST, buff);
91 /* cleanup after ourselves */
92 rv = apr_file_close(file1);
93 CuAssertIntEquals(tc, APR_SUCCESS, rv);
95 rv = apr_file_close(file3);
96 CuAssertIntEquals(tc, APR_SUCCESS, rv);
97 rv = apr_stat(&finfo, FILEPATH "testdup.readwrite.file", APR_FINFO_NORM, p);
98 CuAssertIntEquals(tc, 1, APR_STATUS_IS_ENOENT(rv));
101 static void test_dup2(CuTest *tc)
103 apr_file_t *testfile = NULL;
104 apr_file_t *errfile = NULL;
105 apr_file_t *saveerr = NULL;
108 rv = apr_file_open(&testfile, FILEPATH "testdup2.file",
109 APR_READ | APR_WRITE | APR_CREATE |
110 APR_DELONCLOSE, APR_OS_DEFAULT, p);
111 CuAssertIntEquals(tc, APR_SUCCESS, rv);
112 CuAssertPtrNotNull(tc, testfile);
114 rv = apr_file_open_stderr(&errfile, p);
115 CuAssertIntEquals(tc, APR_SUCCESS, rv);
117 /* Set aside the real errfile */
118 rv = apr_file_dup(&saveerr, errfile, p);
119 CuAssertIntEquals(tc, APR_SUCCESS, rv);
120 CuAssertPtrNotNull(tc, saveerr);
122 rv = apr_file_dup2(errfile, testfile, p);
123 CuAssertIntEquals(tc, APR_SUCCESS, rv);
124 CuAssertPtrNotNull(tc, errfile);
126 apr_file_close(testfile);
128 rv = apr_file_dup2(errfile, saveerr, p);
129 CuAssertIntEquals(tc, APR_SUCCESS, rv);
130 CuAssertPtrNotNull(tc, errfile);
133 static void test_dup2_readwrite(CuTest *tc)
135 apr_file_t *errfile = NULL;
136 apr_file_t *testfile = NULL;
137 apr_file_t *saveerr = NULL;
139 apr_size_t txtlen = sizeof(TEST);
143 rv = apr_file_open(&testfile, FILEPATH "testdup2.readwrite.file",
144 APR_READ | APR_WRITE | APR_CREATE |
145 APR_DELONCLOSE, APR_OS_DEFAULT, p);
146 CuAssertIntEquals(tc, APR_SUCCESS, rv);
147 CuAssertPtrNotNull(tc, testfile);
149 rv = apr_file_open_stderr(&errfile, p);
150 CuAssertIntEquals(tc, APR_SUCCESS, rv);
152 /* Set aside the real errfile */
153 rv = apr_file_dup(&saveerr, errfile, p);
154 CuAssertIntEquals(tc, APR_SUCCESS, rv);
155 CuAssertPtrNotNull(tc, saveerr);
157 rv = apr_file_dup2(errfile, testfile, p);
158 CuAssertIntEquals(tc, APR_SUCCESS, rv);
159 CuAssertPtrNotNull(tc, errfile);
161 txtlen = sizeof(TEST2);
162 rv = apr_file_write(errfile, TEST2, &txtlen);
163 CuAssertIntEquals(tc, APR_SUCCESS, rv);
164 CuAssertIntEquals(tc, sizeof(TEST2), txtlen);
167 rv = apr_file_seek(testfile, APR_SET, &fpos);
168 CuAssertIntEquals(tc, APR_SUCCESS, rv);
169 CuAssert(tc, "File position mismatch, expected 0", fpos == 0);
172 rv = apr_file_read(testfile, buff, &txtlen);
173 CuAssertIntEquals(tc, APR_SUCCESS, rv);
174 CuAssertStrEquals(tc, TEST2, buff);
176 apr_file_close(testfile);
178 rv = apr_file_dup2(errfile, saveerr, p);
179 CuAssertIntEquals(tc, APR_SUCCESS, rv);
180 CuAssertPtrNotNull(tc, errfile);
183 CuSuite *testdup(void)
185 CuSuite *suite = CuSuiteNew("File duplication");
187 SUITE_ADD_TEST(suite, test_file_dup);
188 SUITE_ADD_TEST(suite, test_file_readwrite);
189 SUITE_ADD_TEST(suite, test_dup2);
190 SUITE_ADD_TEST(suite, test_dup2_readwrite);