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 }