Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
main.cpp
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2016 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #include "mbed.h" 00018 #include "greentea-client/test_env.h" 00019 #include "unity.h" 00020 #include "utest.h" 00021 #include <stdlib.h> 00022 #include <errno.h> 00023 00024 using namespace utest::v1; 00025 00026 // test configuration 00027 #ifndef MBED_TEST_FILESYSTEM 00028 #define MBED_TEST_FILESYSTEM FATFileSystem 00029 #endif 00030 00031 #ifndef MBED_TEST_FILESYSTEM_DECL 00032 #define MBED_TEST_FILESYSTEM_DECL MBED_TEST_FILESYSTEM fs("fs") 00033 #endif 00034 00035 #ifndef MBED_TEST_BLOCKDEVICE 00036 #define MBED_TEST_BLOCKDEVICE RZ_SDHIBlockDevice 00037 #define MBED_TEST_BLOCKDEVICE_DECL SDHIBlockDevice bd(MBED_CONF_RZ_SDHI_CH); 00038 #endif 00039 00040 #ifndef MBED_TEST_BLOCKDEVICE_DECL 00041 #define MBED_TEST_BLOCKDEVICE_DECL MBED_TEST_BLOCKDEVICE bd 00042 #endif 00043 00044 #ifndef MBED_TEST_FILES 00045 #define MBED_TEST_FILES 4 00046 #endif 00047 00048 #ifndef MBED_TEST_DIRS 00049 #define MBED_TEST_DIRS 4 00050 #endif 00051 00052 #ifndef MBED_TEST_TIMEOUT 00053 #define MBED_TEST_TIMEOUT 120 00054 #endif 00055 00056 00057 // declarations 00058 #define STRINGIZE(x) STRINGIZE2(x) 00059 #define STRINGIZE2(x) #x 00060 #define INCLUDE(x, ext) STRINGIZE(x.ext) 00061 00062 #include INCLUDE(MBED_TEST_FILESYSTEM, h) 00063 #include INCLUDE(MBED_TEST_BLOCKDEVICE, hpp) 00064 00065 MBED_TEST_FILESYSTEM_DECL; 00066 MBED_TEST_BLOCKDEVICE_DECL; 00067 00068 Dir dir[MBED_TEST_DIRS]; 00069 File file[MBED_TEST_FILES]; 00070 DIR *dd[MBED_TEST_DIRS]; 00071 FILE *fd[MBED_TEST_FILES]; 00072 struct dirent ent; 00073 struct dirent *ed; 00074 uint8_t buffer[MBED_CONF_RZ_SDHI_TEST_BUFFER]; 00075 00076 00077 // tests 00078 00079 void test_seek_tests() 00080 { 00081 int res = bd.init(); 00082 TEST_ASSERT_EQUAL(0, res); 00083 00084 { 00085 size_t size; 00086 res = MBED_TEST_FILESYSTEM::format(&bd); 00087 TEST_ASSERT_EQUAL(0, res); 00088 res = fs.mount(&bd); 00089 TEST_ASSERT_EQUAL(0, res); 00090 res = fs.mkdir("hello", 0777); 00091 TEST_ASSERT_EQUAL(0, res); 00092 for (int i = 0; i < 132; i++) { 00093 sprintf((char *)buffer, "hello/kitty%d", i); 00094 res = file[0].open(&fs, (char *)buffer, 00095 O_WRONLY | O_CREAT | O_APPEND); 00096 TEST_ASSERT_EQUAL(0, res); 00097 00098 size = strlen("kittycatcat"); 00099 memcpy(buffer, "kittycatcat", size); 00100 for (int j = 0; j < 132; j++) { 00101 file[0].write(buffer, size); 00102 } 00103 res = file[0].close(); 00104 TEST_ASSERT_EQUAL(0, res); 00105 } 00106 res = fs.unmount(); 00107 TEST_ASSERT_EQUAL(0, res); 00108 } 00109 00110 res = bd.deinit(); 00111 TEST_ASSERT_EQUAL(0, res); 00112 } 00113 00114 void test_simple_dir_seek() 00115 { 00116 int res = bd.init(); 00117 TEST_ASSERT_EQUAL(0, res); 00118 00119 { 00120 res = fs.mount(&bd); 00121 TEST_ASSERT_EQUAL(0, res); 00122 res = dir[0].open(&fs, "hello"); 00123 TEST_ASSERT_EQUAL(0, res); 00124 #if (MBED_TEST_FILESYSTEM != FATFileSystem) 00125 res = dir[0].read(&ent); 00126 TEST_ASSERT_EQUAL(1, res); 00127 res = strcmp(ent.d_name, "."); 00128 TEST_ASSERT_EQUAL(0, res); 00129 res = dir[0].read(&ent); 00130 TEST_ASSERT_EQUAL(1, res); 00131 res = strcmp(ent.d_name, ".."); 00132 TEST_ASSERT_EQUAL(0, res); 00133 #endif 00134 00135 off_t pos; 00136 int i; 00137 for (i = 0; i < 4; i++) { 00138 sprintf((char *)buffer, "kitty%d", i); 00139 res = dir[0].read(&ent); 00140 TEST_ASSERT_EQUAL(1, res); 00141 res = strcmp(ent.d_name, (char *)buffer); 00142 TEST_ASSERT_EQUAL(0, res); 00143 pos = dir[0].tell(); 00144 } 00145 res = pos >= 0; 00146 TEST_ASSERT_EQUAL(1, res); 00147 00148 dir[0].seek(pos); 00149 sprintf((char *)buffer, "kitty%d", i); 00150 res = dir[0].read(&ent); 00151 TEST_ASSERT_EQUAL(1, res); 00152 res = strcmp(ent.d_name, (char *)buffer); 00153 TEST_ASSERT_EQUAL(0, res); 00154 00155 dir[0].rewind(); 00156 sprintf((char *)buffer, "kitty%d", 0); 00157 #if (MBED_TEST_FILESYSTEM != FATFileSystem) 00158 res = dir[0].read(&ent); 00159 TEST_ASSERT_EQUAL(1, res); 00160 res = strcmp(ent.d_name, "."); 00161 TEST_ASSERT_EQUAL(0, res); 00162 res = dir[0].read(&ent); 00163 TEST_ASSERT_EQUAL(1, res); 00164 res = strcmp(ent.d_name, ".."); 00165 TEST_ASSERT_EQUAL(0, res); 00166 #endif 00167 res = dir[0].read(&ent); 00168 TEST_ASSERT_EQUAL(1, res); 00169 res = strcmp(ent.d_name, (char *)buffer); 00170 TEST_ASSERT_EQUAL(0, res); 00171 00172 dir[0].seek(pos); 00173 sprintf((char *)buffer, "kitty%d", i); 00174 res = dir[0].read(&ent); 00175 TEST_ASSERT_EQUAL(1, res); 00176 res = strcmp(ent.d_name, (char *)buffer); 00177 TEST_ASSERT_EQUAL(0, res); 00178 res = dir[0].close(); 00179 TEST_ASSERT_EQUAL(0, res); 00180 res = fs.unmount(); 00181 TEST_ASSERT_EQUAL(0, res); 00182 } 00183 00184 res = bd.deinit(); 00185 TEST_ASSERT_EQUAL(0, res); 00186 } 00187 00188 void test_large_dir_seek() 00189 { 00190 int res = bd.init(); 00191 TEST_ASSERT_EQUAL(0, res); 00192 00193 { 00194 res = fs.mount(&bd); 00195 TEST_ASSERT_EQUAL(0, res); 00196 res = dir[0].open(&fs, "hello"); 00197 TEST_ASSERT_EQUAL(0, res); 00198 #if (MBED_TEST_FILESYSTEM != FATFileSystem) 00199 res = dir[0].read(&ent); 00200 TEST_ASSERT_EQUAL(1, res); 00201 res = strcmp(ent.d_name, "."); 00202 TEST_ASSERT_EQUAL(0, res); 00203 res = dir[0].read(&ent); 00204 TEST_ASSERT_EQUAL(1, res); 00205 res = strcmp(ent.d_name, ".."); 00206 TEST_ASSERT_EQUAL(0, res); 00207 #endif 00208 00209 off_t pos; 00210 int i; 00211 for (i = 0; i < 128; i++) { 00212 sprintf((char *)buffer, "kitty%d", i); 00213 res = dir[0].read(&ent); 00214 TEST_ASSERT_EQUAL(1, res); 00215 res = strcmp(ent.d_name, (char *)buffer); 00216 TEST_ASSERT_EQUAL(0, res); 00217 pos = dir[0].tell(); 00218 } 00219 res = pos >= 0; 00220 TEST_ASSERT_EQUAL(1, res); 00221 00222 dir[0].seek(pos); 00223 sprintf((char *)buffer, "kitty%d", i); 00224 res = dir[0].read(&ent); 00225 TEST_ASSERT_EQUAL(1, res); 00226 res = strcmp(ent.d_name, (char *)buffer); 00227 TEST_ASSERT_EQUAL(0, res); 00228 00229 dir[0].rewind(); 00230 sprintf((char *)buffer, "kitty%d", 0); 00231 #if (MBED_TEST_FILESYSTEM != FATFileSystem) 00232 res = dir[0].read(&ent); 00233 TEST_ASSERT_EQUAL(1, res); 00234 res = strcmp(ent.d_name, "."); 00235 TEST_ASSERT_EQUAL(0, res); 00236 res = dir[0].read(&ent); 00237 TEST_ASSERT_EQUAL(1, res); 00238 res = strcmp(ent.d_name, ".."); 00239 TEST_ASSERT_EQUAL(0, res); 00240 #endif 00241 res = dir[0].read(&ent); 00242 TEST_ASSERT_EQUAL(1, res); 00243 res = strcmp(ent.d_name, (char *)buffer); 00244 TEST_ASSERT_EQUAL(0, res); 00245 00246 dir[0].seek(pos); 00247 sprintf((char *)buffer, "kitty%d", i); 00248 res = dir[0].read(&ent); 00249 TEST_ASSERT_EQUAL(1, res); 00250 res = strcmp(ent.d_name, (char *)buffer); 00251 TEST_ASSERT_EQUAL(0, res); 00252 res = dir[0].close(); 00253 TEST_ASSERT_EQUAL(0, res); 00254 res = fs.unmount(); 00255 TEST_ASSERT_EQUAL(0, res); 00256 } 00257 00258 res = bd.deinit(); 00259 TEST_ASSERT_EQUAL(0, res); 00260 } 00261 00262 void test_simple_file_seek() 00263 { 00264 int res = bd.init(); 00265 TEST_ASSERT_EQUAL(0, res); 00266 00267 { 00268 size_t size; 00269 res = fs.mount(&bd); 00270 TEST_ASSERT_EQUAL(0, res); 00271 res = file[0].open(&fs, "hello/kitty42", O_RDONLY); 00272 TEST_ASSERT_EQUAL(0, res); 00273 00274 off_t pos; 00275 size = strlen("kittycatcat"); 00276 for (int i = 0; i < 4; i++) { 00277 res = file[0].read(buffer, size); 00278 TEST_ASSERT_EQUAL(size, res); 00279 res = memcmp(buffer, "kittycatcat", size); 00280 TEST_ASSERT_EQUAL(0, res); 00281 pos = file[0].tell(); 00282 } 00283 res = pos >= 0; 00284 TEST_ASSERT_EQUAL(1, res); 00285 res = file[0].seek(pos, SEEK_SET); 00286 TEST_ASSERT_EQUAL(pos, res); 00287 res = file[0].read(buffer, size); 00288 TEST_ASSERT_EQUAL(size, res); 00289 res = memcmp(buffer, "kittycatcat", size); 00290 TEST_ASSERT_EQUAL(0, res); 00291 00292 file[0].rewind(); 00293 res = file[0].read(buffer, size); 00294 TEST_ASSERT_EQUAL(size, res); 00295 res = memcmp(buffer, "kittycatcat", size); 00296 TEST_ASSERT_EQUAL(0, res); 00297 res = file[0].seek(pos, SEEK_SET); 00298 TEST_ASSERT_EQUAL(pos, res); 00299 res = file[0].read(buffer, size); 00300 TEST_ASSERT_EQUAL(size, res); 00301 res = memcmp(buffer, "kittycatcat", size); 00302 TEST_ASSERT_EQUAL(0, res); 00303 res = file[0].seek(-size, SEEK_CUR); 00304 TEST_ASSERT_EQUAL(pos, res); 00305 res = file[0].read(buffer, size); 00306 TEST_ASSERT_EQUAL(size, res); 00307 res = memcmp(buffer, "kittycatcat", size); 00308 TEST_ASSERT_EQUAL(0, res); 00309 res = file[0].seek(-size, SEEK_END) >= 0; 00310 TEST_ASSERT_EQUAL(1, res); 00311 res = file[0].read(buffer, size); 00312 TEST_ASSERT_EQUAL(size, res); 00313 res = memcmp(buffer, "kittycatcat", size); 00314 TEST_ASSERT_EQUAL(0, res); 00315 00316 size = file[0].size(); 00317 res = file[0].seek(0, SEEK_CUR); 00318 TEST_ASSERT_EQUAL(size, res); 00319 res = file[0].close(); 00320 TEST_ASSERT_EQUAL(0, res); 00321 res = fs.unmount(); 00322 TEST_ASSERT_EQUAL(0, res); 00323 } 00324 00325 res = bd.deinit(); 00326 TEST_ASSERT_EQUAL(0, res); 00327 } 00328 00329 void test_large_file_seek() 00330 { 00331 int res = bd.init(); 00332 TEST_ASSERT_EQUAL(0, res); 00333 00334 { 00335 size_t size; 00336 res = fs.mount(&bd); 00337 TEST_ASSERT_EQUAL(0, res); 00338 res = file[0].open(&fs, "hello/kitty42", O_RDONLY); 00339 TEST_ASSERT_EQUAL(0, res); 00340 00341 off_t pos; 00342 size = strlen("kittycatcat"); 00343 for (int i = 0; i < 128; i++) { 00344 res = file[0].read(buffer, size); 00345 TEST_ASSERT_EQUAL(size, res); 00346 res = memcmp(buffer, "kittycatcat", size); 00347 TEST_ASSERT_EQUAL(0, res); 00348 pos = file[0].tell(); 00349 } 00350 res = pos >= 0; 00351 TEST_ASSERT_EQUAL(1, res); 00352 res = file[0].seek(pos, SEEK_SET); 00353 TEST_ASSERT_EQUAL(pos, res); 00354 res = file[0].read(buffer, size); 00355 TEST_ASSERT_EQUAL(size, res); 00356 res = memcmp(buffer, "kittycatcat", size); 00357 TEST_ASSERT_EQUAL(0, res); 00358 00359 file[0].rewind(); 00360 res = file[0].read(buffer, size); 00361 TEST_ASSERT_EQUAL(size, res); 00362 res = memcmp(buffer, "kittycatcat", size); 00363 TEST_ASSERT_EQUAL(0, res); 00364 res = file[0].seek(pos, SEEK_SET); 00365 TEST_ASSERT_EQUAL(pos, res); 00366 res = file[0].read(buffer, size); 00367 TEST_ASSERT_EQUAL(size, res); 00368 res = memcmp(buffer, "kittycatcat", size); 00369 TEST_ASSERT_EQUAL(0, res); 00370 res = file[0].seek(-size, SEEK_CUR); 00371 TEST_ASSERT_EQUAL(pos, res); 00372 res = file[0].read(buffer, size); 00373 TEST_ASSERT_EQUAL(size, res); 00374 res = memcmp(buffer, "kittycatcat", size); 00375 TEST_ASSERT_EQUAL(0, res); 00376 res = file[0].seek(-size, SEEK_END) >= 0; 00377 TEST_ASSERT_EQUAL(1, res); 00378 res = file[0].read(buffer, size); 00379 TEST_ASSERT_EQUAL(size, res); 00380 res = memcmp(buffer, "kittycatcat", size); 00381 TEST_ASSERT_EQUAL(0, res); 00382 00383 size = file[0].size(); 00384 res = file[0].seek(0, SEEK_CUR); 00385 TEST_ASSERT_EQUAL(size, res); 00386 res = file[0].close(); 00387 TEST_ASSERT_EQUAL(0, res); 00388 res = fs.unmount(); 00389 TEST_ASSERT_EQUAL(0, res); 00390 } 00391 00392 res = bd.deinit(); 00393 TEST_ASSERT_EQUAL(0, res); 00394 } 00395 00396 void test_simple_file_seek_and_write() 00397 { 00398 int res = bd.init(); 00399 TEST_ASSERT_EQUAL(0, res); 00400 00401 { 00402 size_t size; 00403 res = fs.mount(&bd); 00404 TEST_ASSERT_EQUAL(0, res); 00405 res = file[0].open(&fs, "hello/kitty42", O_RDWR); 00406 TEST_ASSERT_EQUAL(0, res); 00407 00408 off_t pos; 00409 size = strlen("kittycatcat"); 00410 for (int i = 0; i < 4; i++) { 00411 res = file[0].read(buffer, size); 00412 TEST_ASSERT_EQUAL(size, res); 00413 res = memcmp(buffer, "kittycatcat", size); 00414 TEST_ASSERT_EQUAL(0, res); 00415 pos = file[0].tell(); 00416 } 00417 res = pos >= 0; 00418 TEST_ASSERT_EQUAL(1, res); 00419 00420 memcpy(buffer, "doggodogdog", size); 00421 res = file[0].seek(pos, SEEK_SET); 00422 TEST_ASSERT_EQUAL(pos, res); 00423 res = file[0].write(buffer, size); 00424 TEST_ASSERT_EQUAL(size, res); 00425 res = file[0].seek(pos, SEEK_SET); 00426 TEST_ASSERT_EQUAL(pos, res); 00427 res = file[0].read(buffer, size); 00428 TEST_ASSERT_EQUAL(size, res); 00429 res = memcmp(buffer, "doggodogdog", size); 00430 TEST_ASSERT_EQUAL(0, res); 00431 00432 file[0].rewind(); 00433 res = file[0].read(buffer, size); 00434 TEST_ASSERT_EQUAL(size, res); 00435 res = memcmp(buffer, "kittycatcat", size); 00436 TEST_ASSERT_EQUAL(0, res); 00437 res = file[0].seek(pos, SEEK_SET); 00438 TEST_ASSERT_EQUAL(pos, res); 00439 res = file[0].read(buffer, size); 00440 TEST_ASSERT_EQUAL(size, res); 00441 res = memcmp(buffer, "doggodogdog", size); 00442 TEST_ASSERT_EQUAL(0, res); 00443 res = file[0].seek(-size, SEEK_END) >= 0; 00444 TEST_ASSERT_EQUAL(1, res); 00445 res = file[0].read(buffer, size); 00446 TEST_ASSERT_EQUAL(size, res); 00447 res = memcmp(buffer, "kittycatcat", size); 00448 TEST_ASSERT_EQUAL(0, res); 00449 00450 size = file[0].size(); 00451 res = file[0].seek(0, SEEK_CUR); 00452 TEST_ASSERT_EQUAL(size, res); 00453 res = file[0].close(); 00454 TEST_ASSERT_EQUAL(0, res); 00455 res = fs.unmount(); 00456 TEST_ASSERT_EQUAL(0, res); 00457 } 00458 00459 res = bd.deinit(); 00460 TEST_ASSERT_EQUAL(0, res); 00461 } 00462 00463 void test_large_file_seek_and_write() 00464 { 00465 int res = bd.init(); 00466 TEST_ASSERT_EQUAL(0, res); 00467 00468 { 00469 size_t size; 00470 res = fs.mount(&bd); 00471 TEST_ASSERT_EQUAL(0, res); 00472 res = file[0].open(&fs, "hello/kitty42", O_RDWR); 00473 TEST_ASSERT_EQUAL(0, res); 00474 00475 off_t pos; 00476 size = strlen("kittycatcat"); 00477 for (int i = 0; i < 128; i++) { 00478 res = file[0].read(buffer, size); 00479 TEST_ASSERT_EQUAL(size, res); 00480 if (i != 4) { 00481 res = memcmp(buffer, "kittycatcat", size); 00482 TEST_ASSERT_EQUAL(0, res); 00483 } 00484 pos = file[0].tell(); 00485 } 00486 res = pos >= 0; 00487 TEST_ASSERT_EQUAL(1, res); 00488 00489 memcpy(buffer, "doggodogdog", size); 00490 res = file[0].seek(pos, SEEK_SET); 00491 TEST_ASSERT_EQUAL(pos, res); 00492 res = file[0].write(buffer, size); 00493 TEST_ASSERT_EQUAL(size, res); 00494 res = file[0].seek(pos, SEEK_SET); 00495 TEST_ASSERT_EQUAL(pos, res); 00496 res = file[0].read(buffer, size); 00497 TEST_ASSERT_EQUAL(size, res); 00498 res = memcmp(buffer, "doggodogdog", size); 00499 TEST_ASSERT_EQUAL(0, res); 00500 00501 file[0].rewind(); 00502 res = file[0].read(buffer, size); 00503 TEST_ASSERT_EQUAL(size, res); 00504 res = memcmp(buffer, "kittycatcat", size); 00505 TEST_ASSERT_EQUAL(0, res); 00506 res = file[0].seek(pos, SEEK_SET); 00507 TEST_ASSERT_EQUAL(pos, res); 00508 res = file[0].read(buffer, size); 00509 TEST_ASSERT_EQUAL(size, res); 00510 res = memcmp(buffer, "doggodogdog", size); 00511 TEST_ASSERT_EQUAL(0, res); 00512 res = file[0].seek(-size, SEEK_END) >= 0; 00513 TEST_ASSERT_EQUAL(1, res); 00514 res = file[0].read(buffer, size); 00515 TEST_ASSERT_EQUAL(size, res); 00516 res = memcmp(buffer, "kittycatcat", size); 00517 TEST_ASSERT_EQUAL(0, res); 00518 00519 size = file[0].size(); 00520 res = file[0].seek(0, SEEK_CUR); 00521 TEST_ASSERT_EQUAL(size, res); 00522 res = file[0].close(); 00523 TEST_ASSERT_EQUAL(0, res); 00524 res = fs.unmount(); 00525 TEST_ASSERT_EQUAL(0, res); 00526 } 00527 00528 res = bd.deinit(); 00529 TEST_ASSERT_EQUAL(0, res); 00530 } 00531 00532 void test_boundary_seek_and_write() 00533 { 00534 int res = bd.init(); 00535 TEST_ASSERT_EQUAL(0, res); 00536 00537 { 00538 size_t size; 00539 res = fs.mount(&bd); 00540 TEST_ASSERT_EQUAL(0, res); 00541 res = file[0].open(&fs, "hello/kitty42", O_RDWR); 00542 TEST_ASSERT_EQUAL(0, res); 00543 00544 size = strlen("hedgehoghog"); 00545 const off_t offsets[] = {512, 1020, 513, 1021, 511, 1019}; 00546 00547 for (int i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) { 00548 off_t off = offsets[i]; 00549 memcpy(buffer, "hedgehoghog", size); 00550 res = file[0].seek(off, SEEK_SET); 00551 TEST_ASSERT_EQUAL(off, res); 00552 res = file[0].write(buffer, size); 00553 TEST_ASSERT_EQUAL(size, res); 00554 res = file[0].seek(off, SEEK_SET); 00555 TEST_ASSERT_EQUAL(off, res); 00556 res = file[0].read(buffer, size); 00557 TEST_ASSERT_EQUAL(size, res); 00558 res = memcmp(buffer, "hedgehoghog", size); 00559 TEST_ASSERT_EQUAL(0, res); 00560 res = file[0].seek(0, SEEK_SET); 00561 TEST_ASSERT_EQUAL(0, res); 00562 res = file[0].read(buffer, size); 00563 TEST_ASSERT_EQUAL(size, res); 00564 res = memcmp(buffer, "kittycatcat", size); 00565 TEST_ASSERT_EQUAL(0, res); 00566 res = file[0].sync(); 00567 TEST_ASSERT_EQUAL(0, res); 00568 } 00569 res = file[0].close(); 00570 TEST_ASSERT_EQUAL(0, res); 00571 res = fs.unmount(); 00572 TEST_ASSERT_EQUAL(0, res); 00573 } 00574 00575 res = bd.deinit(); 00576 TEST_ASSERT_EQUAL(0, res); 00577 } 00578 00579 void test_out_of_bounds_seek() 00580 { 00581 int res = bd.init(); 00582 TEST_ASSERT_EQUAL(0, res); 00583 00584 { 00585 size_t size; 00586 res = fs.mount(&bd); 00587 TEST_ASSERT_EQUAL(0, res); 00588 res = file[0].open(&fs, "hello/kitty42", O_RDWR); 00589 TEST_ASSERT_EQUAL(0, res); 00590 00591 size = strlen("kittycatcat"); 00592 res = file[0].size(); 00593 TEST_ASSERT_EQUAL(132 * size, res); 00594 res = file[0].seek((132 + 4) * size, 00595 SEEK_SET); 00596 TEST_ASSERT_EQUAL((132 + 4)*size, res); 00597 res = file[0].read(buffer, size); 00598 TEST_ASSERT_EQUAL(0, res); 00599 00600 memcpy(buffer, "porcupineee", size); 00601 res = file[0].write(buffer, size); 00602 TEST_ASSERT_EQUAL(size, res); 00603 res = file[0].seek((132 + 4) * size, 00604 SEEK_SET); 00605 TEST_ASSERT_EQUAL((132 + 4)*size, res); 00606 res = file[0].read(buffer, size); 00607 TEST_ASSERT_EQUAL(size, res); 00608 res = memcmp(buffer, "porcupineee", size); 00609 TEST_ASSERT_EQUAL(0, res); 00610 res = file[0].seek(132 * size, 00611 SEEK_SET); 00612 TEST_ASSERT_EQUAL(132 * size, res); 00613 res = file[0].read(buffer, size); 00614 TEST_ASSERT_EQUAL(size, res); 00615 #if (MBED_TEST_FILESYSTEM != FATFileSystem) 00616 // FatFs does not guarantee empty expanded buffer 00617 res = memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size); 00618 TEST_ASSERT_EQUAL(0, res); 00619 #endif 00620 res = file[0].close(); 00621 TEST_ASSERT_EQUAL(0, res); 00622 res = fs.unmount(); 00623 TEST_ASSERT_EQUAL(0, res); 00624 } 00625 00626 res = bd.deinit(); 00627 TEST_ASSERT_EQUAL(0, res); 00628 } 00629 00630 00631 00632 // test setup 00633 utest::v1::status_t test_setup(const size_t number_of_cases) 00634 { 00635 GREENTEA_SETUP(MBED_TEST_TIMEOUT, "default_auto"); 00636 return verbose_test_setup_handler(number_of_cases); 00637 } 00638 00639 Case cases[] = { 00640 Case("Seek tests", test_seek_tests), 00641 Case("Simple dir seek", test_simple_dir_seek), 00642 Case("Large dir seek", test_large_dir_seek), 00643 Case("Simple file seek", test_simple_file_seek), 00644 Case("Large file seek", test_large_file_seek), 00645 Case("Simple file seek and write", test_simple_file_seek_and_write), 00646 Case("Large file seek and write", test_large_file_seek_and_write), 00647 Case("Boundary seek and write", test_boundary_seek_and_write), 00648 Case("Out-of-bounds seek", test_out_of_bounds_seek), 00649 }; 00650 00651 Specification specification(test_setup, cases); 00652 00653 int main() 00654 { 00655 return !Harness::run(specification); 00656 }
Generated on Sun Jul 17 2022 03:41:56 by
1.7.2