VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstFile.cpp@ 13068

Last change on this file since 13068 was 8245, checked in by vboxsync, 17 years ago

rebranding: IPRT files again.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.2 KB
Line 
1/* $Id: tstFile.cpp 8245 2008-04-21 17:24:28Z vboxsync $ */
2/** @file
3 * IPRT Testcase - File I/O.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 *
26 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31
32/*******************************************************************************
33* Header Files *
34*******************************************************************************/
35#include <iprt/file.h>
36#include <iprt/err.h>
37#include <iprt/string.h>
38#include <iprt/stream.h>
39#include <iprt/runtime.h>
40
41
42int main()
43{
44 int cErrors = 0;
45 RTPrintf("tstFile: TESTING\n");
46 RTR3Init();
47
48 RTFILE File;
49 int rc = RTFileOpen(&File, "tstFile#1.tst", RTFILE_O_READWRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE);
50 if (RT_FAILURE(rc))
51 {
52 RTPrintf("tstFile: FATAL ERROR - Failed to open file #1. rc=%Rrc\n", rc);
53 return 1;
54 }
55
56 RTFOFF cbMax = -2;
57 rc = RTFileGetMaxSizeEx(File, &cbMax);
58 if (RT_FAILURE(rc))
59 {
60 RTPrintf("tstFile: RTFileGetMaxSizeEx failed: %Rrc\n", rc);
61 cErrors++;
62 }
63 else if (cbMax <= 0)
64 {
65 RTPrintf("tstFile: RTFileGetMaxSizeEx failed: cbMax=%RTfoff\n", cbMax);
66 cErrors++;
67 }
68 else if (RTFileGetMaxSize(File) != cbMax)
69 {
70 RTPrintf("tstFile: RTFileGetMaxSize failed; returns %RTfoff instead of %RTfoff\n", RTFileGetMaxSize(File), cbMax);
71 cErrors++;
72 }
73 else
74 RTPrintf("Maximum file size is %RTfoff bytes.\n", cbMax);
75
76 /* grow file beyond 2G */
77 rc = RTFileSetSize(File, _2G + _1M);
78 if (RT_FAILURE(rc))
79 {
80 RTPrintf("Failed to grow file #1 to 2.001GB. rc=%Rrc\n", rc);
81 cErrors++;
82 }
83 else
84 {
85 uint64_t cb;
86 rc = RTFileGetSize(File, &cb);
87 if (RT_FAILURE(rc))
88 {
89 RTPrintf("Failed to get file size of #1. rc=%Rrc\n", rc);
90 cErrors++;
91 }
92 else if (cb != _2G + _1M)
93 {
94 RTPrintf("RTFileGetSize return %RX64 bytes, expected %RX64.\n", cb, _2G + _1M);
95 cErrors++;
96 }
97 else
98 RTPrintf("tstFile: cb=%RX64\n", cb);
99
100 /*
101 * Try some writes at the beginning of the file.
102 */
103 uint64_t offFile = RTFileTell(File);
104 if (offFile != 0)
105 {
106 RTPrintf("RTFileTell -> %#RX64, expected 0 (#1)\n", offFile);
107 cErrors++;
108 }
109 static const char szTestBuf[] = "Sausages and bacon for breakfast again!";
110 size_t cbWritten = 0;
111 while (cbWritten < sizeof(szTestBuf))
112 {
113 size_t cbWrittenPart;
114 rc = RTFileWrite(File, &szTestBuf[cbWritten], sizeof(szTestBuf) - cbWritten, &cbWrittenPart);
115 if (RT_FAILURE(rc))
116 break;
117 cbWritten += cbWrittenPart;
118 }
119 if (RT_FAILURE(rc))
120 {
121 RTPrintf("Failed to write to file #1 at offset 0. rc=%Rrc\n", rc);
122 cErrors++;
123 }
124 else
125 {
126 /* check that it was written correctly. */
127 rc = RTFileSeek(File, 0, RTFILE_SEEK_BEGIN, NULL);
128 if (RT_FAILURE(rc))
129 {
130 RTPrintf("Failed to seek offset 0 in file #1. rc=%Rrc\n", rc);
131 cErrors++;
132 }
133 else
134 {
135 char szReadBuf[sizeof(szTestBuf)];
136 size_t cbRead = 0;
137 while (cbRead < sizeof(szTestBuf))
138 {
139 size_t cbReadPart;
140 rc = RTFileRead(File, &szReadBuf[cbRead], sizeof(szTestBuf) - cbRead, &cbReadPart);
141 if (RT_FAILURE(rc))
142 break;
143 cbRead += cbReadPart;
144 }
145 if (RT_FAILURE(rc))
146 {
147 RTPrintf("Failed to read from file #1 at offset 0. rc=%Rrc\n", rc);
148 cErrors++;
149 }
150 else
151 {
152 if (!memcmp(szReadBuf, szTestBuf, sizeof(szTestBuf)))
153 RTPrintf("tstFile: head write ok\n");
154 else
155 {
156 RTPrintf("Data read from file #1 at offset 0 differs from what we wrote there.\n");
157 cErrors++;
158 }
159 }
160 }
161 }
162
163 /*
164 * Try some writes at the end of the file.
165 */
166 rc = RTFileSeek(File, _2G + _1M, RTFILE_SEEK_BEGIN, NULL);
167 if (RT_FAILURE(rc))
168 {
169 RTPrintf("Failed to seek to _2G + _1M in file #1. rc=%Rrc\n", rc);
170 cErrors++;
171 }
172 else
173 {
174 offFile = RTFileTell(File);
175 if (offFile != _2G + _1M)
176 {
177 RTPrintf("RTFileTell -> %#llx, expected %#llx (#2)\n", offFile, _2G + _1M);
178 cErrors++;
179 }
180 else
181 {
182 size_t cbWritten = 0;
183 while (cbWritten < sizeof(szTestBuf))
184 {
185 size_t cbWrittenPart;
186 rc = RTFileWrite(File, &szTestBuf[cbWritten], sizeof(szTestBuf) - cbWritten, &cbWrittenPart);
187 if (RT_FAILURE(rc))
188 break;
189 cbWritten += cbWrittenPart;
190 }
191 if (RT_FAILURE(rc))
192 {
193 RTPrintf("Failed to write to file #1 at offset 2G + 1M. rc=%Rrc\n", rc);
194 cErrors++;
195 }
196 else
197 {
198 rc = RTFileSeek(File, offFile, RTFILE_SEEK_BEGIN, NULL);
199 if (RT_FAILURE(rc))
200 {
201 RTPrintf("Failed to seek offset %RX64 in file #1. rc=%Rrc\n", offFile, rc);
202 cErrors++;
203 }
204 else
205 {
206 char szReadBuf[sizeof(szTestBuf)];
207 size_t cbRead = 0;
208 while (cbRead < sizeof(szTestBuf))
209 {
210 size_t cbReadPart;
211 rc = RTFileRead(File, &szReadBuf[cbRead], sizeof(szTestBuf) - cbRead, &cbReadPart);
212 if (RT_FAILURE(rc))
213 break;
214 cbRead += cbReadPart;
215 }
216 if (RT_FAILURE(rc))
217 {
218 RTPrintf("Failed to read from file #1 at offset 2G + 1M. rc=%Rrc\n", rc);
219 cErrors++;
220 }
221 else
222 {
223 if (!memcmp(szReadBuf, szTestBuf, sizeof(szTestBuf)))
224 RTPrintf("tstFile: tail write ok\n");
225 else
226 {
227 RTPrintf("Data read from file #1 at offset 2G + 1M differs from what we wrote there.\n");
228 cErrors++;
229 }
230 }
231 }
232 }
233 }
234 }
235
236 /*
237 * Some general seeking around.
238 */
239 rc = RTFileSeek(File, _2G + 1, RTFILE_SEEK_BEGIN, NULL);
240 if (RT_FAILURE(rc))
241 {
242 RTPrintf("Failed to seek to _2G + 1 in file #1. rc=%Rrc\n", rc);
243 cErrors++;
244 }
245 else
246 {
247 offFile = RTFileTell(File);
248 if (offFile != _2G + 1)
249 {
250 RTPrintf("RTFileTell -> %#llx, expected %#llx (#3)\n", offFile, _2G + 1);
251 cErrors++;
252 }
253 }
254
255 /* seek end */
256 rc = RTFileSeek(File, 0, RTFILE_SEEK_END, NULL);
257 if (RT_FAILURE(rc))
258 {
259 RTPrintf("Failed to seek to end of file #1. rc=%Rrc\n", rc);
260 cErrors++;
261 }
262 else
263 {
264 offFile = RTFileTell(File);
265 if (offFile != _2G + _1M + sizeof(szTestBuf)) /* assuming tail write was ok. */
266 {
267 RTPrintf("RTFileTell -> %#RX64, expected %#RX64 (#4)\n", offFile, _2G + _1M + sizeof(szTestBuf));
268 cErrors++;
269 }
270 }
271
272 /* seek start */
273 rc = RTFileSeek(File, 0, RTFILE_SEEK_BEGIN, NULL);
274 if (RT_FAILURE(rc))
275 {
276 RTPrintf("Failed to seek to end of file #1. rc=%Rrc\n", rc);
277 cErrors++;
278 }
279 else
280 {
281 offFile = RTFileTell(File);
282 if (offFile != 0)
283 {
284 RTPrintf("RTFileTell -> %#llx, expected 0 (#5)\n", offFile);
285 cErrors++;
286 }
287 }
288 }
289
290
291 /*
292 * Cleanup.
293 */
294 rc = RTFileClose(File);
295 if (RT_FAILURE(rc))
296 {
297 RTPrintf("Failed to close file #1. rc=%Rrc\n", rc);
298 cErrors++;
299 }
300 rc = RTFileDelete("tstFile#1.tst");
301 if (RT_FAILURE(rc))
302 {
303 RTPrintf("Failed to delete file #1. rc=%Rrc\n", rc);
304 cErrors++;
305 }
306
307 /*
308 * Summary
309 */
310 if (cErrors == 0)
311 RTPrintf("tstFile: SUCCESS\n");
312 else
313 RTPrintf("tstFile: FAILURE - %d errors\n", cErrors);
314 return !!cErrors;
315}
316
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette