Toyomasa Watarai
Mbed Cloud example program for workshop in W27 2018.
Embed:
(wiki syntax)
Show/hide line numbers
pal_fileSystem_test.c
00001 /* 00002 * Copyright (c) 2016 ARM Limited. All rights reserved. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * Licensed under the Apache License, Version 2.0 (the License); you may 00005 * 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, WITHOUT 00012 * 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 "pal.h" 00018 #include "unity.h" 00019 #include "unity_fixture.h" 00020 00021 00022 #define TEST_DIR "dir1" 00023 #define TEST_DIR2 "dir2" 00024 #define TEST_WORKING_DIR "work1" 00025 #define TEST_DIR_FILE "dir1/test.txt" 00026 #define TEST_NUMBER_OF_FILE_TO_CREATE 20 00027 #define TEST_BUFFER_SIZE 100 00028 #define TEST_BUFFER_SMALL_SIZE 17 00029 //#define TEST_BYTES_TO_WRITE 300*4 00030 #define TEST_BYTES_TO_WRITE 100 00031 #define TEST_FILE_NAME "%s/test_f%d" 00032 #define BUFFER_TEST_SIZE 1123 00033 00034 #if (false == PAL_PRIMARY_PARTITION_PRIVATE) 00035 #define PAL_TEST_PRIMARY_PATH "/pri" 00036 #else 00037 #define PAL_TEST_PRIMARY_PATH "" 00038 #endif 00039 00040 #if (false == PAL_SECONDARY_PARTITION_PRIVATE) 00041 #define PAL_TEST_SECONDARY_PATH "/sec" 00042 #else 00043 #define PAL_TEST_SECONDARY_PATH "" 00044 #endif 00045 00046 //out should in length be PAL_MAX_FILE_AND_FOLDER_LENGTH 00047 static char* addRootToPath(const char* in, char* out,pal_fsStorageID_t id) 00048 { 00049 char root[PAL_MAX_FILE_AND_FOLDER_LENGTH] = { 0 }; 00050 size_t len = 0; 00051 palStatus_t status; 00052 00053 memset(out,0,PAL_MAX_FILE_AND_FOLDER_LENGTH); 00054 status = pal_fsGetMountPoint(id, PAL_MAX_FILE_AND_FOLDER_LENGTH, root); 00055 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00056 00057 strncat(out, root, PAL_MAX_FILE_AND_FOLDER_LENGTH-1); //-1 for null terminator space 00058 len = strlen(out); 00059 if (PAL_FS_PARTITION_PRIMARY == id) 00060 { 00061 strncat(out, PAL_TEST_PRIMARY_PATH, PAL_MAX_FILE_AND_FOLDER_LENGTH - len); 00062 } 00063 else 00064 { 00065 strncat(out, PAL_TEST_SECONDARY_PATH, PAL_MAX_FILE_AND_FOLDER_LENGTH - len); 00066 } 00067 len = strlen(out); 00068 if (*in != '\0') 00069 { 00070 strncat(out,"/",PAL_MAX_FILE_AND_FOLDER_LENGTH - len); 00071 strncat(out,in,PAL_MAX_FILE_AND_FOLDER_LENGTH -len -1); 00072 } 00073 return(out); 00074 } 00075 00076 00077 00078 PAL_PRIVATE uint8_t *bufferTest = NULL; 00079 PAL_PRIVATE uint8_t *bufferTest2 = NULL; 00080 00081 PAL_PRIVATE palFileDescriptor_t g_fd1 = 0; 00082 PAL_PRIVATE palFileDescriptor_t g_fd2 = 0; 00083 00084 PAL_PRIVATE palStatus_t pal_fsClearAndInitialyze(pal_fsStorageID_t id) 00085 { 00086 palStatus_t status = PAL_SUCCESS; 00087 00088 if (pal_fsIsPrivatePartition(id)) 00089 { 00090 status = pal_fsFormat(id); 00091 } 00092 else 00093 { 00094 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00095 status = pal_fsRmFiles(addRootToPath("",buffer,id)); 00096 } 00097 return(status); 00098 } 00099 00100 /*! \brief This function compare two files 00101 * 00102 * @param[in] *pathCmp1 - pointer to the null-terminated string that specifies the first filename to be compare 00103 * @param[in] *pathCmp2 - pointer to the null-terminated string that specifies the second filename to be compare 00104 * 00105 * \return PAL_SUCCESS upon successful operation.\n 00106 * 00107 */ 00108 PAL_PRIVATE palStatus_t fileSystemCompareUtil(const char * pathCmp1, const char * pathCmp2) 00109 { 00110 palStatus_t status = PAL_SUCCESS; 00111 00112 char bufferCmp1[TEST_BUFFER_SIZE]; 00113 char bufferCmp2[TEST_BUFFER_SIZE]; 00114 size_t numOfBytesCmp1 = 0; 00115 size_t numOfBytesCmp2 = 0; 00116 palFileDescriptor_t fdCmp1 = 0; 00117 palFileDescriptor_t fdCmp2 = 0; 00118 00119 status = pal_fsFopen(pathCmp1, PAL_FS_FLAG_READONLY, &fdCmp1); 00120 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00121 00122 status = pal_fsFopen(pathCmp2, PAL_FS_FLAG_READONLY, &fdCmp2); 00123 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00124 00125 while(true) 00126 { 00127 00128 status = pal_fsFread(&fdCmp1, bufferCmp1, TEST_BUFFER_SIZE, &numOfBytesCmp1); 00129 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00130 00131 status = pal_fsFread(&fdCmp2, bufferCmp2, TEST_BUFFER_SIZE, &numOfBytesCmp2); 00132 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00133 00134 if ((numOfBytesCmp2 == 0) && (numOfBytesCmp1 == 0)) 00135 {//End of file reached 00136 break; 00137 } 00138 00139 TEST_ASSERT_EQUAL(numOfBytesCmp1, numOfBytesCmp2); 00140 TEST_ASSERT_EQUAL_MEMORY(bufferCmp1, bufferCmp2, numOfBytesCmp1); 00141 } 00142 00143 status = pal_fsFclose(&fdCmp1); 00144 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00145 00146 status = pal_fsFclose(&fdCmp2); 00147 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00148 00149 return status; 00150 } 00151 00152 TEST_GROUP(pal_fileSystem); 00153 00154 TEST_SETUP(pal_fileSystem) 00155 { 00156 00157 pal_init(); 00158 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00159 00160 pal_fsRmFiles(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY));//Remove all files in the testing DIRECTORY 00161 pal_fsRmDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Delete Directory if exist 00162 pal_fsRmFiles(addRootToPath(TEST_WORKING_DIR,buffer,PAL_FS_PARTITION_PRIMARY));//Remove all files in the testing DIRECTORY 00163 pal_fsRmDir(addRootToPath(TEST_WORKING_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Delete Directory if exist 00164 pal_fsRmFiles(addRootToPath(TEST_DIR2,buffer,PAL_FS_PARTITION_PRIMARY));//Remove all files in the testing DIRECTORY 00165 pal_fsRmDir(addRootToPath(TEST_DIR2,buffer,PAL_FS_PARTITION_PRIMARY)); //Delete Directory if exist 00166 00167 00168 pal_fsRmFiles(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_SECONDARY));//Remove all files in the testing DIRECTORY 00169 pal_fsRmDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_SECONDARY)); //Delete Directory if exist 00170 pal_fsRmFiles(addRootToPath(TEST_WORKING_DIR,buffer,PAL_FS_PARTITION_SECONDARY));//Remove all files in the testing DIRECTORY 00171 pal_fsRmDir(addRootToPath(TEST_WORKING_DIR,buffer,PAL_FS_PARTITION_SECONDARY)); //Delete Directory if exist 00172 pal_fsRmFiles(addRootToPath(TEST_DIR2,buffer,PAL_FS_PARTITION_SECONDARY));//Remove all files in the testing DIRECTORY 00173 pal_fsRmDir(addRootToPath(TEST_DIR2,buffer,PAL_FS_PARTITION_SECONDARY)); //Delete Directory if exist 00174 00175 g_fd1 = 0; 00176 g_fd2 = 0; 00177 bufferTest = NULL; 00178 bufferTest2 = NULL; 00179 if(!pal_fsIsPrivatePartition(PAL_FS_PARTITION_PRIMARY)) 00180 { 00181 00182 addRootToPath("",buffer,PAL_FS_PARTITION_PRIMARY); 00183 pal_fsMkDir(buffer); 00184 } 00185 if(!pal_fsIsPrivatePartition(PAL_FS_PARTITION_SECONDARY)) 00186 { 00187 addRootToPath("",buffer,PAL_FS_PARTITION_SECONDARY); 00188 pal_fsMkDir(buffer); 00189 } 00190 } 00191 00192 TEST_TEAR_DOWN(pal_fileSystem) 00193 { 00194 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00195 pal_fsFclose(&g_fd1); 00196 pal_fsFclose(&g_fd2); 00197 g_fd1 = 0; 00198 g_fd2 = 0; 00199 00200 if (bufferTest != NULL) 00201 { 00202 free(bufferTest); 00203 bufferTest = NULL; 00204 } 00205 if (bufferTest2 != NULL) 00206 { 00207 free(bufferTest2); 00208 bufferTest2 = NULL; 00209 } 00210 00211 pal_fsClearAndInitialyze(PAL_FS_PARTITION_PRIMARY); 00212 pal_fsClearAndInitialyze(PAL_FS_PARTITION_SECONDARY); 00213 00214 if(!pal_fsIsPrivatePartition(PAL_FS_PARTITION_PRIMARY)) 00215 { 00216 00217 addRootToPath("",buffer,PAL_FS_PARTITION_PRIMARY); 00218 pal_fsRmDir(buffer); 00219 } 00220 if(!pal_fsIsPrivatePartition(PAL_FS_PARTITION_SECONDARY)) 00221 { 00222 addRootToPath("",buffer,PAL_FS_PARTITION_SECONDARY); 00223 pal_fsRmDir(buffer); 00224 } 00225 pal_destroy(); 00226 00227 } 00228 00229 /*! \brief /b SDFormat function tests formatting an SD card. 00230 * 00231 ** \test 00232 * | # | Step | Expected | 00233 * |---|--------------------------------|-------------| 00234 * | 1 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00235 * | 2 | create TEST_DIR_FILE file with pal_fsOpen | PAL_SUCCESS | 00236 * | 3 | close file TEST_DIR_FILE with pal_fsClose | PAL_SUCCESS | 00237 * | 4 | Format SD card with pal_FormatSDPartition | PAL_SUCCESS | 00238 * | 5 | TEST_DIR_FILE should not exist after format | PAL_ERR_FS_NO_FILE | 00239 * | 6 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00240 */ 00241 void SDFormat_1Partition() 00242 { 00243 palStatus_t status = PAL_SUCCESS; 00244 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00245 00246 /*#1*/ 00247 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Create Directory 00248 if (PAL_SUCCESS == status) 00249 { 00250 /*#2*/ 00251 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_PRIMARY), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00252 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00253 /*#3*/ 00254 status = pal_fsFclose(&g_fd1); 00255 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00256 } 00257 00258 00259 /*#4*/ 00260 status = pal_fsClearAndInitialyze(PAL_FS_PARTITION_PRIMARY); //Format SD 00261 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00262 00263 /*#5*/ 00264 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_PRIMARY), PAL_FS_FLAG_READONLY, &g_fd1); 00265 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00266 00267 status = pal_fsClearAndInitialyze(PAL_FS_PARTITION_SECONDARY); //Format SD 00268 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00269 00270 00271 /*#6*/ 00272 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Create Directory 00273 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00274 00275 } 00276 00277 /*! \brief /b SDFormat function tests formatting an SD card. 00278 * 00279 ** \test 00280 * | # | Step | Expected | 00281 * |---|--------------------------------|-------------| 00282 * | 1 | create TEST_DIR with pal_fsMkDir primary partition | PAL_SUCCESS | 00283 * | 2 | create TEST_DIR_FILE file with pal_fsOpen primary partition | PAL_SUCCESS | 00284 * | 3 | close file TEST_DIR_FILE with pal_fsClose | PAL_SUCCESS | 00285 * | 4 | create TEST_DIR with pal_fsMkDir secondary partition | PAL_SUCCESS | 00286 * | 5 | create TEST_DIR_FILE file with pal_fsOpen secondary partition | PAL_SUCCESS | 00287 * | 6 | close file TEST_DIR_FILE with pal_fsClose | PAL_SUCCESS | 00288 * | 7 | Format SD card primary partition with pal_FormatSDPartition | PAL_SUCCESS | 00289 * | 8 | TEST_DIR_FILE in primary should not exist after format | PAL_ERR_FS_NO_FILE | 00290 * | 9 | TEST_DIR_FILE in secondary should exist after format | PAL_SUCCESS | 00291 * | 10| Format SD card secondary partition with pal_FormatSDPartition | PAL_SUCCESS | 00292 * | 11| TEST_DIR_FILE in secondary should not exist after format | PAL_ERR_FS_NO_FILE | 00293 * | 12| create TEST_DIR with pal_fsMkDir in primary partition | PAL_SUCCESS | 00294 * | 13| create TEST_DIR with pal_fsMkDir in secondary partition | PAL_SUCCESS | 00295 */ 00296 void SDFormat_2Partition() 00297 { 00298 palStatus_t status = PAL_SUCCESS; 00299 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00300 00301 /*#1*/ 00302 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Create Directory 00303 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00304 /*#2*/ 00305 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_PRIMARY), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00306 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00307 /*#3*/ 00308 status = pal_fsFclose(&g_fd1); 00309 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00310 00311 /*#4*/ 00312 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_SECONDARY)); //Create Directory 00313 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00314 00315 /*#5*/ 00316 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_SECONDARY), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00317 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00318 /*#6*/ 00319 status = pal_fsFclose(&g_fd1); 00320 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00321 00322 00323 /*#7*/ 00324 status = pal_fsClearAndInitialyze(PAL_FS_PARTITION_PRIMARY); //Format SD 00325 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00326 00327 /*#8*/ 00328 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_PRIMARY), PAL_FS_FLAG_READONLY, &g_fd1); 00329 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00330 00331 /*#9*/ 00332 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_SECONDARY), PAL_FS_FLAG_READONLY, &g_fd1); 00333 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); //the file still exists in secondary 00334 00335 status = pal_fsFclose(&g_fd1); 00336 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00337 00338 /*#10*/ 00339 status = pal_fsClearAndInitialyze(PAL_FS_PARTITION_SECONDARY); //Format SD 00340 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00341 /*#11*/ 00342 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,PAL_FS_PARTITION_SECONDARY), PAL_FS_FLAG_READONLY, &g_fd1); 00343 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00344 00345 /*#12*/ 00346 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_PRIMARY)); //Create Directory 00347 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00348 /*#13*/ 00349 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,PAL_FS_PARTITION_SECONDARY)); //Create Directory 00350 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00351 } 00352 00353 00354 00355 TEST(pal_fileSystem, SDFormat) 00356 { 00357 SDFormat_2Partition(); 00358 SDFormat_1Partition(); 00359 } 00360 00361 00362 /*! \brief /b directoryTests function Tests root Directory commands 00363 * 00364 ** \test 00365 * | # | Step | Expected | 00366 * |---|--------------------------------|-------------| 00367 * | 1 | get root directory with pal_fsGetMountPoint | PAL_SUCCESS | 00368 * | 2 | create TEST_WORKING_DIR with pal_fsMkDir | PAL_SUCCESS | 00369 * | 3 | Change Root Directory to TEST_WORKING_DIR with pal_fsSetMountPoint | PAL_SUCCESS | 00370 * | 4 | create TEST_WORKING_DIR with pal_fsMkDir | PAL_ERR_FS_NAME_ALREADY_EXIST | 00371 * | 5 | get root directory with pal_fsGetMountPoint | PAL_SUCCESS | 00372 */ 00373 void rootDirectoryTests(pal_fsStorageID_t storageId) 00374 { 00375 palStatus_t status = PAL_SUCCESS; 00376 char getRootPath[TEST_BUFFER_SIZE] = { 0 }; 00377 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00378 /*#1*/ 00379 status = pal_fsGetMountPoint(storageId, TEST_BUFFER_SIZE, getRootPath); //Setting New working Directory 00380 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00381 00382 /*#2*/ 00383 status = pal_fsMkDir(addRootToPath(TEST_WORKING_DIR,buffer,storageId)); //Create Directory 00384 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00385 00386 /*#3*/ 00387 status = pal_fsSetMountPoint(storageId, addRootToPath(TEST_WORKING_DIR,buffer,storageId)); //Setting New working Directory 00388 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00389 00390 /*#4*/ 00391 status = pal_fsMkDir(getRootPath); //should fail because already exits and path is absolute 00392 TEST_ASSERT_EQUAL(PAL_ERR_FS_NAME_ALREADY_EXIST, status); 00393 00394 /*#5*/ 00395 status = pal_fsGetMountPoint(storageId, TEST_BUFFER_SIZE, getRootPath); //Setting New working Directory 00396 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00397 00398 } 00399 00400 00401 TEST(pal_fileSystem, rootDirectoryTests) 00402 { 00403 00404 rootDirectoryTests(PAL_FS_PARTITION_PRIMARY); 00405 00406 } 00407 00408 00409 /*! \brief /b directoryTests function Tests Directory commands 00410 * 00411 ** \test 00412 * | # | Step | Expected | 00413 * |---|--------------------------------|-------------| 00414 * | 1 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00415 * | 2 | create TEST_DIR with pal_fsMkDir | PAL_ERR_FS_NAME_ALREADY_EXIST | 00416 * | 3 | Create File TEST_DIR_FILE With PAL_ERR_FS_READWRITEEXCLUSIVE with pal_fsFopen | PAL_SUCCESS | 00417 * | 4 | Create File TEST_DIR_FILE With PAL_ERR_FS_READWRITEEXCLUSIVE with pal_fsFopen | PAL_ERR_FS_NAME_ALREADY_EXIST | 00418 * | 5 | Close file with uninitialized file descriptor | PAL_ERR_FS_BAD_FD | 00419 * | 6 | Close file with initialized file descriptor | PAL_SUCCESS | 00420 * | 7 | Delete directory with pal_fsRmDir (directory not empty) | PAL_ERR_FS_ERROR | 00421 * | 8 | Delete file TEST_DIR_FILE with pal_fsUnlink | PAL_SUCCESS | 00422 * | 9 | Delete file TEST_DIR_FILE with pal_fsUnlink | PAL_SUCCESS | 00423 * | 10 | Delete a folder which not exists with pal_fsUnlink | PAL_ERR_FS_NO_PATH | 00424 * 00425 */ 00426 void directoryTests(pal_fsStorageID_t storageId) 00427 { 00428 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00429 char *pathToFile = NULL; 00430 palStatus_t status = PAL_SUCCESS; 00431 00432 /*#1*/ 00433 pathToFile = addRootToPath(TEST_DIR,buffer,storageId); 00434 status = pal_fsMkDir(pathToFile); //Create Directory 00435 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00436 00437 /*#2*/ 00438 pathToFile = addRootToPath(TEST_DIR,buffer,storageId); 00439 status = pal_fsMkDir(pathToFile); //Create same Directory Shall failed 00440 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_NAME_ALREADY_EXIST, status); 00441 00442 /*#3*/ 00443 pathToFile = addRootToPath(TEST_DIR_FILE,buffer,storageId); 00444 status = pal_fsFopen(pathToFile, PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00445 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00446 00447 /*#4*/ 00448 pathToFile = addRootToPath(TEST_DIR_FILE,buffer,storageId); 00449 status = pal_fsFopen(pathToFile, PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd2); // Failed open Exclusively and file already created 00450 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_NAME_ALREADY_EXIST, status); 00451 00452 /*#5*/ 00453 pal_fsFclose(&g_fd2);//Failed fd1 was not a valid File descriptor 00454 //TEST_ASSERT_EQUAL(PAL_ERR_FS_BAD_FD, status); //TODO Pass on mbedOS 00455 00456 /*#6*/ 00457 status = pal_fsFclose(&g_fd1); 00458 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00459 00460 /*#7*/ 00461 pathToFile = addRootToPath(TEST_DIR,buffer,storageId); 00462 status = pal_fsRmDir(pathToFile); //Delete Directory Failed Directory not empty 00463 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_DIR_NOT_EMPTY, status); 00464 00465 /*#8*/ 00466 pathToFile = addRootToPath(TEST_DIR_FILE,buffer,storageId); 00467 status = pal_fsUnlink(pathToFile); //Delete the file in a directory 00468 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00469 00470 /*#9*/ 00471 pathToFile = addRootToPath(TEST_DIR,buffer,storageId); 00472 status = pal_fsRmDir(pathToFile); //Delete Directory success 00473 TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status); 00474 00475 /*#10*/ 00476 pathToFile = addRootToPath(TEST_DIR,buffer,storageId); 00477 status = pal_fsRmDir(pathToFile); //Delete not existing Directory 00478 TEST_ASSERT_EQUAL_HEX(PAL_ERR_FS_NO_PATH, status); 00479 } 00480 00481 TEST(pal_fileSystem, directoryTests) 00482 { 00483 directoryTests(PAL_FS_PARTITION_PRIMARY); 00484 directoryTests(PAL_FS_PARTITION_SECONDARY); 00485 } 00486 00487 /*! \brief /b FilesTests function Tests files commands 00488 * 00489 ** \test 00490 * | # | Step | Expected | 00491 * |---|--------------------------------|-------------| 00492 * | 1 | Init Test | | 00493 * | 2 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00494 * | 3 | create TEST_DIR2 with pal_fsMkDir | PAL_SUCCESS | 00495 * | 4 | Start Loop i from [0 - TEST_NUMBER_OF_FILE_TO_CREATE] | | 00496 * | 5 | Create File in DIR_FILE named f_i (i - index of loop)with PAL_ERR_FS_READWRITEEXCLUSIVE mode using pal_fsFopen | PAL_SUCCESS | 00497 * | 6 | Write random buffer[TEST_BYTES_TO_WRITE] to file with pal_fsFwrite | PAL_SUCCESS | 00498 * | 7 | close file handler with pal_fsFclose | PAL_SUCCESS | 00499 * | 8 | End Loop | | 00500 * | 9 | Copy TEST_DIR folder to TEST_DIR2 with pal_fsCpFolder | PAL_SUCCESS | 00501 * | 10 | Compare Folders | | 00502 * | 11 | remove all files from TEST_DIR2 | PAL_SUCCESS | 00503 * | 12 | remove all files from TEST_DIR | PAL_SUCCESS | 00504 * | 13 | Start Loop i from [0 - TEST_NUMBER_OF_FILE_TO_CREATE] | | 00505 * | 14 | open Files in DIR_FILE named f_i (i - index of loop) with PAL_ERR_FS_READONLY mode using pal_fsFopen | PAL_ERR_FS_NO_FILE | 00506 * | 15 | open Files in DIR_FILE named f_i (i - index of loop) with PAL_ERR_FS_READWRITE mode using pal_fsFopen | PAL_ERR_FS_NO_FILE | 00507 * | 16 | open Files in DIR_FILE2 named f_i (i - index of loop) with PAL_ERR_FS_READONLY mode using pal_fsFopen | PAL_ERR_FS_NO_FILE | 00508 * | 17 | open Files in DIR_FILE2 named f_i (i - index of loop) with PAL_ERR_FS_READWRITE mode using pal_fsFopen | PAL_ERR_FS_NO_FILE | 00509 * | 18 | remove TEST_DIR with pal_fsRmDir | PAL_SUCCESS | 00510 * | 19 | remove TEST_DIR2 with pal_fsRmDir | PAL_SUCCESS | 00511 * | 20 | try to remove a file that does not exist | PAL_ERR_FS_NO_FILE | 00512 * | 21 | try to remove a a variety of files that does not exist | PAL_ERR_FS_NO_PATH | 00513 * | 22 | try to copy a non existing folder | PAL_ERR_FS_NO_PATH | 00514 * 00515 */ 00516 void FilesTests(pal_fsStorageID_t storageId) 00517 { 00518 palStatus_t status = PAL_SUCCESS; 00519 char rootPathBuffer1[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00520 char rootPathBuffer2[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00521 char buffer1[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00522 char buffer2[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00523 int i = 0; 00524 size_t numOfBytes; 00525 /*#1*/ 00526 //---------------- INIT TESTS----------------------------// 00527 memset(rootPathBuffer1, '1', PAL_MAX_FILE_AND_FOLDER_LENGTH); 00528 memset(rootPathBuffer2, '1', PAL_MAX_FILE_AND_FOLDER_LENGTH); 00529 //----------------END INIT TESTS-------------------------// 00530 00531 /*#2*/ 00532 status = pal_fsMkDir(addRootToPath(TEST_DIR,rootPathBuffer1,storageId)); //Create Directory 00533 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00534 00535 /*#3*/ 00536 status = pal_fsMkDir(addRootToPath(TEST_DIR2,rootPathBuffer2,storageId)); //Create Directory 00537 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00538 00539 /*#4*/ 00540 for(i = 0; i < TEST_NUMBER_OF_FILE_TO_CREATE; i++) 00541 { 00542 /*#5*/ 00543 snprintf(rootPathBuffer1, PAL_MAX_FILE_AND_FOLDER_LENGTH, TEST_FILE_NAME, TEST_DIR, i); 00544 status = pal_fsFopen(addRootToPath(rootPathBuffer1,buffer1,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00545 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00546 00547 /*#6*/ 00548 status = pal_fsFwrite(&g_fd1, (void *)rootPathBuffer1, TEST_BYTES_TO_WRITE, &numOfBytes); 00549 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00550 00551 /*#7*/ 00552 status = pal_fsFclose(&g_fd1); 00553 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00554 /*#8*/ 00555 } 00556 00557 /*#9*/ 00558 status = pal_fsCpFolder(addRootToPath(TEST_DIR,rootPathBuffer1,storageId), addRootToPath(TEST_DIR2,rootPathBuffer2,storageId));//Copy all files from TEST_DIR to TEST_DIR2 00559 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00560 /*#10*/ 00561 for(i = 0; i < TEST_NUMBER_OF_FILE_TO_CREATE; i++) 00562 { 00563 snprintf(rootPathBuffer1, PAL_MAX_FILE_AND_FOLDER_LENGTH, TEST_FILE_NAME, TEST_DIR, i); 00564 snprintf(rootPathBuffer2, PAL_MAX_FILE_AND_FOLDER_LENGTH, TEST_FILE_NAME, TEST_DIR2, i); 00565 00566 fileSystemCompareUtil(addRootToPath(rootPathBuffer1,buffer1,storageId), addRootToPath(rootPathBuffer2,buffer2,storageId)); 00567 } 00568 00569 /*#11*/ 00570 status = pal_fsRmFiles(addRootToPath(TEST_DIR2,rootPathBuffer2,storageId));//Remove all files in the testing DIRECTORY 00571 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00572 00573 /*#12*/ 00574 status = pal_fsRmFiles(addRootToPath(TEST_DIR,rootPathBuffer1,storageId));//Remove all files in the testing DIRECTORY 00575 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00576 00577 /*#13*/ 00578 for(i = 0; i < TEST_NUMBER_OF_FILE_TO_CREATE; i++) 00579 { 00580 /*#14*/ 00581 snprintf(buffer1, PAL_MAX_FILE_AND_FOLDER_LENGTH, TEST_FILE_NAME, TEST_DIR, i); 00582 status = pal_fsFopen(addRootToPath(buffer1,rootPathBuffer1,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 00583 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00584 00585 /*#15*/ 00586 status = pal_fsFopen(addRootToPath(buffer1,rootPathBuffer1,storageId), PAL_FS_FLAG_READWRITE, &g_fd1); 00587 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00588 00589 /*#16*/ 00590 snprintf(buffer2, PAL_MAX_FILE_AND_FOLDER_LENGTH, TEST_FILE_NAME, TEST_DIR2, i); 00591 status = pal_fsFopen(addRootToPath(buffer2,rootPathBuffer2,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 00592 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00593 00594 /*#17*/ 00595 status = pal_fsFopen(addRootToPath(buffer1,rootPathBuffer1,storageId), PAL_FS_FLAG_READWRITE, &g_fd1); 00596 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); //Failed all files where deleted in previous step 00597 00598 } 00599 00600 /*#18*/ 00601 status = pal_fsRmDir(addRootToPath(TEST_DIR,buffer1,storageId)); 00602 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00603 00604 /*#19*/ 00605 status = pal_fsRmDir(addRootToPath(TEST_DIR2,buffer2,storageId)); 00606 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00607 00608 /*#20*/ 00609 status = pal_fsUnlink(addRootToPath("aaaa.t",rootPathBuffer1, storageId));//not existing file 00610 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_FILE, status); 00611 00612 /*#21*/ 00613 status = pal_fsRmFiles(addRootToPath("aaaaa",rootPathBuffer1, storageId));//Remove all file in not existing directory 00614 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_PATH, status); 00615 00616 /*#22*/ 00617 00618 status = pal_fsCpFolder(addRootToPath("aaaaa", rootPathBuffer1, storageId), addRootToPath("bbbb" ,rootPathBuffer2,storageId)); //copy from not existing dir 00619 TEST_ASSERT_EQUAL(PAL_ERR_FS_NO_PATH, status); 00620 } 00621 00622 TEST(pal_fileSystem, FilesTests) 00623 { 00624 FilesTests(PAL_FS_PARTITION_PRIMARY); 00625 FilesTests(PAL_FS_PARTITION_SECONDARY); 00626 } 00627 00628 /*! \brief /b FilesTestsSeek function Tests \b fseek() , \b fteel() & \b fread() function 00629 * 00630 ** \test 00631 * | # | Step | Expected | 00632 * |---|--------------------------------|-------------| 00633 * | 1 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00634 * | 2 | Create File TEST_DIR_FILE With PAL_ERR_FS_READWRITETRUNC with pal_fsFopen | PAL_SUCCESS | 00635 * | 3 | Create buffer[TEST_BUFFER_SIZE] with incremental data, Buffer size TEST_BUFFER_SIZE | PAL_SUCCESS | 00636 * | 4 | Write buffer to file with pal_fsFwrite | PAL_SUCCESS | 00637 * | 5 | Start Loop i from [0 - TEST_BUFFER_SIZE] | | 00638 * | 6 | run pal_fsFseek with PAL_FS_OFFSET_SEEKSET option and incremental offset i | PAL_SUCCESS | 00639 * | 7 | run pal_fsFtell and compare offset to i | PAL_SUCCESS | 00640 * | 8 | run pal_fsFread, read one byte and compare it to the buffer[i] | PAL_SUCCESS | 00641 * | 9 | End Loop | | 00642 * | 10 | Start Loop i from [0 - TEST_BUFFER_SIZE] | | 00643 * | 11 | run pal_fsFseek with PAL_FS_OFFSET_SEEKEND option and incremental offset (-1)*i | PAL_SUCCESS | 00644 * | 12 | run pal_fsFtell and compare offset to TEST_BUFFER_SIZE - i | PAL_SUCCESS | 00645 * | 13 | End Loop | | 00646 * | 14 | run pal_fsFseek with PAL_FS_OFFSET_SEEKSET option offset TEST_BUFFER_SIZE/2 | PAL_SUCCESS | 00647 * | 15 | Start Loop i from [0 - TEST_BUFFER_SIZE/10] | | 00648 * | 16 | run pal_fsFseek with PAL_FS_OFFSET_SEEKEND option and incremental offset i | PAL_SUCCESS | 00649 * | 17 | run pal_fsFtell and compare offset to i | PAL_SUCCESS | 00650 * | 18 | End Loop | | 00651 * | 19 | Cleanup | PAL_SUCCESS | 00652 * 00653 */ 00654 void FilesTestsSeek(pal_fsStorageID_t storageId) 00655 { 00656 palStatus_t status = PAL_SUCCESS; 00657 char buffer[TEST_BUFFER_SIZE]; 00658 int i = 0; 00659 size_t numOfBytes; 00660 int32_t pos = 0; 00661 char read_buf = 1; 00662 size_t prePos = 0; 00663 /*#1*/ 00664 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,storageId)); //Create Directory 00665 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00666 00667 /*#2*/ 00668 status = pal_fsFopen(addRootToPath(TEST_DIR_FILE,buffer,storageId), PAL_FS_FLAG_READWRITETRUNC, &g_fd1); 00669 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00670 00671 /*#3*/ 00672 for(i = 0; i < TEST_BUFFER_SIZE; i++) 00673 { 00674 buffer[i] = i; 00675 } 00676 00677 /*#4*/ 00678 status = pal_fsFwrite(&g_fd1, (void *)buffer, TEST_BUFFER_SIZE, &numOfBytes); //Write incremental buffer for seek testing 00679 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00680 TEST_ASSERT_EQUAL(TEST_BUFFER_SIZE, numOfBytes); 00681 00682 /*#5*/ 00683 //Test Seek "PAL_FS_OFFSET_SEEKSET" 00684 for(i = 0; i < TEST_BUFFER_SIZE; i++) 00685 { 00686 00687 /*#6*/ 00688 status = pal_fsFseek(&g_fd1, i, PAL_FS_OFFSET_SEEKSET); //Set position to start of the stream 00689 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00690 00691 /*#7*/ 00692 status = pal_fsFtell(&g_fd1, &pos); //Check if position is in the start of the stream 00693 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00694 TEST_ASSERT_EQUAL(i, pos); 00695 00696 /*#8*/ 00697 status = pal_fsFread(&g_fd1, &read_buf, 1, &numOfBytes); 00698 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00699 TEST_ASSERT_EQUAL(1, numOfBytes); 00700 TEST_ASSERT_EQUAL(buffer[i], read_buf); 00701 00702 /*#9*/ 00703 } 00704 00705 /*#10*/ 00706 //Test Seek "PAL_FS_OFFSET_SEEKEND" 00707 for(i = 0; i < TEST_BUFFER_SIZE; i++) 00708 { 00709 /*#11*/ 00710 status = pal_fsFseek(&g_fd1, (-1)*i, PAL_FS_OFFSET_SEEKEND); //Set position to end of the stream 00711 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00712 00713 /*#12*/ 00714 status = pal_fsFtell(&g_fd1, &pos); //Get position 00715 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00716 TEST_ASSERT_EQUAL(TEST_BUFFER_SIZE - i, pos); 00717 00718 /*#13*/ 00719 } 00720 00721 /*#14*/ 00722 //Test Seek "PAL_ERR_FS_SEEKCUR" 00723 status = pal_fsFseek(&g_fd1, TEST_BUFFER_SIZE/2, PAL_FS_OFFSET_SEEKSET); //Set position to middle of the stream 00724 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00725 prePos = TEST_BUFFER_SIZE/2; 00726 00727 /*#15*/ 00728 for(i = 0; i < TEST_BUFFER_SIZE/10 ; i++) 00729 { 00730 00731 /*#16*/ 00732 status = pal_fsFseek(&g_fd1, i, PAL_FS_OFFSET_SEEKCUR); //Set position to start of the stream 00733 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00734 00735 /*17*/ 00736 status = pal_fsFtell(&g_fd1, &pos); //Get position 00737 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00738 TEST_ASSERT_EQUAL(prePos + i, pos); 00739 prePos = pos; 00740 00741 /*#18*/ 00742 } 00743 00744 /*#19*/ 00745 status = pal_fsFclose(&g_fd1); 00746 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00747 } 00748 00749 00750 TEST(pal_fileSystem, FilesTestsSeek) 00751 { 00752 FilesTestsSeek(PAL_FS_PARTITION_PRIMARY); 00753 #if (PAL_NUMBER_OF_PARTITIONS == 2) 00754 FilesTestsSeek(PAL_FS_PARTITION_SECONDARY); 00755 #endif 00756 } 00757 00758 /*! \brief /b FilesPermission function Tests \b fopen() with r 00759 * 00760 ** \test 00761 * | # | Step | Expected | 00762 * |---|--------------------------------|-------------| 00763 * | 1 | Init Test | Success | 00764 * | 2 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00765 * | 3 | create new file using fopen with PAL_FS_FLAG_READWRITEEXCLUSIVE | PAL_SUCCESS | 00766 * | 4 | write buffer to file | PAL_SUCCESS | 00767 * | 5 | close file | PAL_SUCCESS | 00768 * | 6 | open file using fopen() with PAL_FS_FLAG_READONLY | PAL_SUCCESS | 00769 * | 7 | write buffer to file with fwrite() | failed | 00770 * | 8 | read buffer from file with fread() | PAL_SUCCESS | 00771 * | 9 | close file | PAL_SUCCESS | 00772 * | 10 | remove all files in folder | PAL_SUCCESS | 00773 * | 11 | remove folder | PAL_SUCCESS | 00774 */ 00775 void FilesPermission_read_only(pal_fsStorageID_t storageId) 00776 { 00777 palStatus_t status = PAL_SUCCESS; 00778 char readBuffer[TEST_BUFFER_SIZE]; 00779 char readBuffer2[TEST_BUFFER_SIZE]; 00780 char filename[TEST_BUFFER_SIZE]; 00781 size_t numOfBytes = 0; 00782 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00783 00784 /*#1*/ 00785 //---------------- INIT TESTS----------------------------// 00786 memset(readBuffer, '1', TEST_BUFFER_SIZE); 00787 //----------------END INIT TESTS-------------------------// 00788 00789 /*#2*/ 00790 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,storageId)); //Create Directory 00791 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00792 00793 snprintf(filename, TEST_BUFFER_SIZE, TEST_FILE_NAME, TEST_DIR, 1); 00794 /*#3*/ 00795 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00796 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00797 00798 /*#4*/ 00799 status = pal_fsFwrite(&g_fd1, (void *)readBuffer, TEST_BYTES_TO_WRITE, &numOfBytes); 00800 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00801 TEST_ASSERT_EQUAL(TEST_BYTES_TO_WRITE, numOfBytes); 00802 00803 /*#5*/ 00804 status = pal_fsFclose(&g_fd1); 00805 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00806 00807 /*#6*/ 00808 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 00809 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00810 00811 /*#7*/ 00812 pal_fsFwrite(&g_fd1, (void *)readBuffer, TEST_BYTES_TO_WRITE, &numOfBytes); 00813 TEST_ASSERT_EQUAL(0, numOfBytes); 00814 00815 /*#8*/ 00816 status = pal_fsFread(&g_fd1, readBuffer2, TEST_BUFFER_SIZE, &numOfBytes); 00817 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00818 TEST_ASSERT_EQUAL(TEST_BUFFER_SIZE, numOfBytes); 00819 TEST_ASSERT_EQUAL_MEMORY(readBuffer, readBuffer2, TEST_BUFFER_SIZE); 00820 00821 /*#9*/ 00822 status = pal_fsFclose(&g_fd1); 00823 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00824 00825 /*#10*/ 00826 status = pal_fsRmFiles(addRootToPath(TEST_DIR,buffer,storageId));//Remove all files in the testing DIRECTORY 00827 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00828 00829 /*#11*/ 00830 status = pal_fsRmDir(addRootToPath(TEST_DIR,buffer,storageId)); //Delete Directory if exist 00831 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00832 } 00833 00834 TEST(pal_fileSystem, FilesPermission_read_only) 00835 { 00836 FilesPermission_read_only(PAL_FS_PARTITION_PRIMARY); 00837 FilesPermission_read_only(PAL_FS_PARTITION_SECONDARY); 00838 } 00839 00840 00841 /*! \brief /b FilesPermission function Tests \b fopen() with r+ 00842 * 00843 ** \test 00844 * | # | Step | Expected | 00845 * |---|--------------------------------|-------------| 00846 * | 1 | Init Test | Success | 00847 * | 2 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00848 * | 3 | create new file using fopen with PAL_FS_FLAG_READWRITEEXCLUSIVE | PAL_SUCCESS | 00849 * | 4 | write buffer to file | PAL_SUCCESS | 00850 * | 5 | close file | PAL_SUCCESS | 00851 * | 6 | open file using fopen() with PAL_FS_FLAG_READONLY | PAL_SUCCESS | 00852 * | 7 | write buffer to file with fwrite() | PAL_SUCCESS | 00853 * | 8 | seek to the begining of the file | PAL_SUCCESS | 00854 * | 9 | read buffer from file with fread() | PAL_SUCCESS | 00855 * | 10 | close file | PAL_SUCCESS | 00856 * | 11 | remove all files in folder | PAL_SUCCESS | 00857 * | 12 | remove folder | PAL_SUCCESS | 00858 */ 00859 void FilesPermission_read_write(pal_fsStorageID_t storageId) 00860 { 00861 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00862 palStatus_t status = PAL_SUCCESS; 00863 char readBuffer[TEST_BUFFER_SIZE]; 00864 char readBuffer2[TEST_BUFFER_SIZE]; 00865 char filename[TEST_BUFFER_SIZE]; 00866 size_t numOfBytes = 0; 00867 00868 /*#1*/ 00869 //---------------- INIT TESTS----------------------------// 00870 memset(readBuffer, '1', TEST_BUFFER_SIZE); 00871 //----------------END INIT TESTS-------------------------// 00872 00873 /*#2*/ 00874 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,storageId)); //Create Directory 00875 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00876 00877 snprintf(filename, TEST_BUFFER_SIZE, TEST_FILE_NAME, TEST_DIR, 1); 00878 /*#3*/ 00879 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00880 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00881 00882 /*#4*/ 00883 status = pal_fsFwrite(&g_fd1, (void *)readBuffer, TEST_BYTES_TO_WRITE, &numOfBytes); 00884 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00885 TEST_ASSERT_EQUAL(TEST_BYTES_TO_WRITE, numOfBytes); 00886 00887 /*#5*/ 00888 status = pal_fsFclose(&g_fd1); 00889 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00890 00891 /*#6*/ 00892 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READWRITE, &g_fd1); 00893 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00894 00895 /*#7*/ 00896 status = pal_fsFwrite(&g_fd1, (void *)readBuffer, TEST_BYTES_TO_WRITE, &numOfBytes); 00897 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00898 TEST_ASSERT_EQUAL(TEST_BYTES_TO_WRITE, numOfBytes); 00899 00900 /*#8*/ 00901 status = pal_fsFseek(&g_fd1, 0, PAL_FS_OFFSET_SEEKSET); //Set position to start of the stream 00902 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00903 00904 /*#9*/ 00905 status = pal_fsFread(&g_fd1, readBuffer2, TEST_BUFFER_SIZE, &numOfBytes); 00906 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00907 TEST_ASSERT_EQUAL(TEST_BYTES_TO_WRITE, numOfBytes); 00908 TEST_ASSERT_EQUAL_MEMORY(readBuffer, readBuffer2, TEST_BUFFER_SIZE); 00909 00910 /*#10*/ 00911 status = pal_fsFclose(&g_fd1); 00912 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00913 00914 /*#11*/ 00915 status = pal_fsRmFiles(addRootToPath(TEST_DIR,buffer,storageId));//Remove all files in the testing DIRECTORY 00916 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00917 00918 /*#12*/ 00919 status = pal_fsRmDir(addRootToPath(TEST_DIR,buffer,storageId)); //Delete Directory if exist 00920 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00921 } 00922 00923 00924 TEST(pal_fileSystem, FilesPermission_read_write) 00925 { 00926 FilesPermission_read_write(PAL_FS_PARTITION_PRIMARY); 00927 FilesPermission_read_write(PAL_FS_PARTITION_SECONDARY); 00928 } 00929 00930 00931 /*! \brief /b FilesPermission function Tests \b fopen() with w+x 00932 * 00933 ** \test 00934 * | # | Step | Expected | 00935 * |---|--------------------------------|-------------| 00936 * | 1 | Init Test | Success | 00937 * | 2 | create TEST_DIR with pal_fsMkDir | PAL_SUCCESS | 00938 * | 3 | create new file using fopen with PAL_FS_FLAG_READWRITEEXCLUSIVE | PAL_SUCCESS | 00939 * | 4 | write buffer to file | PAL_SUCCESS | 00940 * | 5 | close file | PAL_SUCCESS | 00941 * | 6 | open file using fopen() withPAL_FS_FLAG_READWRITETRUNC | PAL_SUCCESS | 00942 * | 7 | read buffer from file with fread() | PAL_SUCCESS with read length 0 | 00943 * | 8 | close file | PAL_SUCCESS | 00944 * | 9 | remove all files in folder | PAL_SUCCESS | 00945 * | 10 | remove folder | PAL_SUCCESS | 00946 */ 00947 void FilesPermission_read_write_trunc(pal_fsStorageID_t storageId) 00948 { 00949 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 00950 palStatus_t status = PAL_SUCCESS; 00951 char readBuffer[TEST_BUFFER_SIZE]; 00952 char filename[TEST_BUFFER_SIZE]; 00953 size_t numOfBytes = 0; 00954 00955 /*#1*/ 00956 //---------------- INIT TESTS----------------------------// 00957 memset(readBuffer, '1', TEST_BUFFER_SIZE); 00958 //----------------END INIT TESTS-------------------------// 00959 00960 /*#2*/ 00961 status = pal_fsMkDir(addRootToPath(TEST_DIR,buffer,storageId)); //Create Directory 00962 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00963 00964 snprintf(filename, TEST_BUFFER_SIZE, TEST_FILE_NAME, TEST_DIR, 1); 00965 /*#3*/ 00966 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 00967 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00968 00969 /*#4*/ 00970 status = pal_fsFwrite(&g_fd1, (void *)readBuffer, TEST_BYTES_TO_WRITE, &numOfBytes); 00971 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00972 TEST_ASSERT_EQUAL(TEST_BYTES_TO_WRITE, numOfBytes); 00973 00974 /*#5*/ 00975 status = pal_fsFclose(&g_fd1); 00976 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00977 00978 /*#6*/ 00979 status = pal_fsFopen(addRootToPath(filename,buffer,storageId), PAL_FS_FLAG_READWRITETRUNC, &g_fd1); 00980 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00981 00982 /*#7*/ 00983 status = pal_fsFread(&g_fd1, readBuffer, TEST_BUFFER_SIZE, &numOfBytes); 00984 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00985 TEST_ASSERT_EQUAL(0, numOfBytes); //nothing to read empty file 00986 00987 /*#8*/ 00988 status = pal_fsFclose(&g_fd1); 00989 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00990 00991 /*#9*/ 00992 status = pal_fsRmFiles(addRootToPath(TEST_DIR,buffer,storageId));//Remove all files in the testing DIRECTORY 00993 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00994 00995 /*#10*/ 00996 status = pal_fsRmDir(addRootToPath(TEST_DIR,buffer,storageId)); //Delete Directory if exist 00997 TEST_ASSERT_EQUAL(PAL_SUCCESS, status); 00998 } 00999 01000 01001 TEST(pal_fileSystem, FilesPermission_read_write_trunc) 01002 { 01003 FilesPermission_read_write_trunc(PAL_FS_PARTITION_PRIMARY); 01004 FilesPermission_read_write_trunc(PAL_FS_PARTITION_SECONDARY); 01005 } 01006 01007 01008 void create_write_and_read_pal_file(pal_fsStorageID_t storageId) 01009 { 01010 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 01011 char fileName[] = "fileName"; 01012 palStatus_t res = PAL_SUCCESS; 01013 size_t num_bytes_write = 0; 01014 size_t num_bytes_read = 0; 01015 01016 uint32_t i = 0; 01017 01018 bufferTest = malloc(BUFFER_TEST_SIZE); 01019 TEST_ASSERT_NOT_EQUAL(bufferTest, NULL); 01020 bufferTest2 = malloc(BUFFER_TEST_SIZE); 01021 TEST_ASSERT_NOT_EQUAL(bufferTest2, NULL); 01022 memset(bufferTest, 0, BUFFER_TEST_SIZE); 01023 memset(bufferTest2, 0, BUFFER_TEST_SIZE); 01024 01025 for (i = 0; i < BUFFER_TEST_SIZE; i++){ 01026 bufferTest[i] = (uint8_t)(i % 256); 01027 } 01028 01029 pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01030 01031 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &(g_fd1)); 01032 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01033 01034 res = pal_fsFwrite(&(g_fd1), bufferTest, BUFFER_TEST_SIZE, &num_bytes_write); 01035 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01036 TEST_ASSERT_EQUAL(BUFFER_TEST_SIZE, num_bytes_write); 01037 01038 res = pal_fsFclose(&(g_fd1)); 01039 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01040 01041 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READONLY, &(g_fd1)); 01042 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01043 01044 res = pal_fsFread(&(g_fd1), bufferTest2, 223, &num_bytes_read); 01045 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01046 TEST_ASSERT_EQUAL(223, num_bytes_read); 01047 01048 // split the reads 01049 res = pal_fsFread(&(g_fd1), bufferTest2, 900, &num_bytes_read); 01050 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01051 TEST_ASSERT_EQUAL(900, num_bytes_read); 01052 01053 01054 // Compare the buffers � here we have a mismatch in location buffer2[288] 01055 TEST_ASSERT_EQUAL_INT8_ARRAY(&(bufferTest[223]), bufferTest2, 900); 01056 01057 res = pal_fsFclose(&(g_fd1)); 01058 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01059 01060 res = pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01061 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01062 01063 free(bufferTest); 01064 bufferTest = NULL; 01065 free(bufferTest2); 01066 bufferTest2 = NULL; 01067 01068 } 01069 01070 01071 TEST(pal_fileSystem, create_write_and_read_pal_file) 01072 { 01073 create_write_and_read_pal_file(PAL_FS_PARTITION_PRIMARY); 01074 create_write_and_read_pal_file(PAL_FS_PARTITION_SECONDARY); 01075 } 01076 01077 void WriteInTheMiddle(pal_fsStorageID_t storageId) 01078 { 01079 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 01080 char fileName[] = "fileName"; 01081 const uint32_t inputSizeSmall = (TEST_BUFFER_SIZE * 6) + 1; 01082 const uint32_t inputSizeBig = BUFFER_TEST_SIZE; 01083 palStatus_t res = PAL_SUCCESS; 01084 size_t num_bytes_write = 0; 01085 size_t num_bytes_read = 0; 01086 unsigned char *smallBuffer = NULL; 01087 const size_t offset = 200; 01088 uint32_t residue = inputSizeBig - (offset + inputSizeSmall); 01089 01090 bufferTest = malloc(inputSizeBig); 01091 TEST_ASSERT_NOT_EQUAL(bufferTest, NULL); 01092 bufferTest2 = malloc(inputSizeBig); 01093 TEST_ASSERT_NOT_EQUAL(bufferTest2, NULL); 01094 smallBuffer = malloc(inputSizeSmall); 01095 TEST_ASSERT_NOT_EQUAL(smallBuffer, NULL); 01096 memset(bufferTest, 0, inputSizeBig); 01097 memset(bufferTest2, 0, inputSizeBig); 01098 memset(smallBuffer, 0, inputSizeSmall); 01099 01100 // create 1123 bytes buffer filled with the numbers 0..255 01101 for (uint32_t i = 0; i < inputSizeBig; i++) 01102 { 01103 bufferTest[i] = (uint8_t)(i % 256); 01104 } 01105 01106 // create 601 bytes buffer filled with only 0xCC 01107 for (uint32_t i = 0; i < inputSizeSmall; i++) 01108 { 01109 smallBuffer[i] = 0xCC; 01110 } 01111 01112 pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01113 TEST_ASSERT((PAL_SUCCESS == res) || (PAL_ERR_FS_NO_FILE == res)); 01114 01115 /* 1. Write bufferTest data to file, read it and compare read content to bufferTest */ 01116 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 01117 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01118 01119 res = pal_fsFwrite(&g_fd1, bufferTest, inputSizeBig, &num_bytes_write); 01120 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01121 TEST_ASSERT_EQUAL(inputSizeBig, num_bytes_write); 01122 01123 res = pal_fsFclose(&g_fd1); 01124 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01125 01126 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 01127 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01128 01129 res = pal_fsFread(&g_fd1, bufferTest2, inputSizeBig, &num_bytes_read); 01130 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01131 TEST_ASSERT_EQUAL(inputSizeBig, num_bytes_read); 01132 TEST_ASSERT_EQUAL_HEX8_ARRAY(bufferTest, bufferTest2, inputSizeBig); 01133 01134 res = pal_fsFclose(&g_fd1); 01135 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01136 01137 /* 01138 2. Write smallBuffer data to offset 201 of the file and then compare each fragment: 01139 - offset 0..200 equal to bufferTest[0..200] 01140 - offset 201..801 equal to smallBuffer 01141 - offset 802..1122 equal to bufferTest[802..1122] 01142 */ 01143 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READWRITE, &g_fd1); 01144 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01145 01146 res = pal_fsFseek(&g_fd1, offset, PAL_FS_OFFSET_SEEKSET); 01147 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01148 01149 res = pal_fsFwrite(&g_fd1, smallBuffer, inputSizeSmall, &num_bytes_write); 01150 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01151 TEST_ASSERT_EQUAL(inputSizeSmall, num_bytes_write); 01152 01153 res = pal_fsFclose(&g_fd1); 01154 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01155 01156 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 01157 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01158 01159 // offset 0..200 equal to bufferTest[0..200] 01160 res = pal_fsFread(&g_fd1, bufferTest2, offset, &num_bytes_read); 01161 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01162 TEST_ASSERT_EQUAL(offset, num_bytes_read); 01163 TEST_ASSERT_EQUAL_HEX8_ARRAY(bufferTest, bufferTest2, offset); 01164 01165 // offset 201..801 equal to smallBuffer 01166 res = pal_fsFread(&g_fd1, bufferTest2, inputSizeSmall, &num_bytes_read); 01167 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01168 TEST_ASSERT_EQUAL(inputSizeSmall, num_bytes_read); 01169 TEST_ASSERT_EQUAL_HEX8_ARRAY(smallBuffer, bufferTest2, inputSizeSmall); 01170 01171 // offset 802..1122 equal to bufferTest[802..1122] 01172 res = pal_fsFread(&g_fd1, bufferTest2, residue, &num_bytes_read); 01173 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01174 TEST_ASSERT_EQUAL(residue, num_bytes_read); 01175 TEST_ASSERT_EQUAL_HEX8_ARRAY(bufferTest + offset + inputSizeSmall, bufferTest2, residue); 01176 01177 res = pal_fsFclose(&g_fd1); 01178 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01179 01180 res = pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01181 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01182 01183 free(bufferTest); 01184 bufferTest = NULL; 01185 free(bufferTest2); 01186 bufferTest2 = NULL; 01187 free(smallBuffer); 01188 smallBuffer = NULL; 01189 } 01190 01191 TEST(pal_fileSystem, WriteInTheMiddle) 01192 { 01193 WriteInTheMiddle(PAL_FS_PARTITION_PRIMARY); 01194 WriteInTheMiddle(PAL_FS_PARTITION_SECONDARY); 01195 } 01196 01197 01198 01199 01200 void SequentialWriteAndRead(pal_fsStorageID_t storageId) 01201 { 01202 char buffer[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0}; 01203 char fileName[] = "fileName"; 01204 palStatus_t res = PAL_SUCCESS; 01205 size_t num_bytes_write = 0; 01206 size_t num_bytes_read = 0; 01207 unsigned char small_write_buffer[TEST_BUFFER_SMALL_SIZE] = { 01208 0x2D, 0x6B, 0xAC, 0xCC, 0x08, 0x6B, 0x14, 0x82, 01209 0xF3, 0x0C, 0xF5, 0x67, 0x17, 0x23, 0x50, 0xB4, 01210 0xFF 01211 }; 01212 unsigned char small_read_buffer[TEST_BUFFER_SMALL_SIZE] = { 0 }; 01213 bufferTest = malloc(BUFFER_TEST_SIZE); 01214 TEST_ASSERT_NOT_EQUAL(bufferTest, NULL); 01215 bufferTest2 = malloc(BUFFER_TEST_SIZE); 01216 TEST_ASSERT_NOT_EQUAL(bufferTest2, NULL); 01217 memset(bufferTest, 0, BUFFER_TEST_SIZE); 01218 memset(bufferTest2, 0, BUFFER_TEST_SIZE); 01219 01220 // create 1123 bytes buffer filled with the numbers 0..255 01221 for (uint32_t i = 0; i < BUFFER_TEST_SIZE; i++) 01222 { 01223 bufferTest[i] = (uint8_t)(i % 256); 01224 } 01225 res = pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01226 TEST_ASSERT((PAL_SUCCESS == res) || (PAL_ERR_FS_NO_FILE == res)); 01227 01228 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READWRITEEXCLUSIVE, &g_fd1); 01229 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01230 01231 // split the writes 01232 res = pal_fsFwrite(&g_fd1, small_write_buffer, TEST_BUFFER_SMALL_SIZE, &num_bytes_write); 01233 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01234 TEST_ASSERT_EQUAL(TEST_BUFFER_SMALL_SIZE, num_bytes_write); 01235 01236 res = pal_fsFwrite(&g_fd1, bufferTest, BUFFER_TEST_SIZE, &num_bytes_write); 01237 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01238 TEST_ASSERT_EQUAL(BUFFER_TEST_SIZE, num_bytes_write); 01239 01240 res = pal_fsFclose(&g_fd1); 01241 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01242 01243 res = pal_fsFopen(addRootToPath(fileName,buffer,storageId), PAL_FS_FLAG_READONLY, &g_fd1); 01244 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01245 01246 // split the reads 01247 res = pal_fsFread(&g_fd1, small_read_buffer, TEST_BUFFER_SMALL_SIZE, &num_bytes_read); 01248 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01249 TEST_ASSERT_EQUAL(TEST_BUFFER_SMALL_SIZE, num_bytes_read); 01250 01251 res = pal_fsFread(&g_fd1, bufferTest2, BUFFER_TEST_SIZE, &num_bytes_read); 01252 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01253 TEST_ASSERT_EQUAL(BUFFER_TEST_SIZE, num_bytes_read); 01254 01255 TEST_ASSERT_EQUAL_INT8_ARRAY(bufferTest, bufferTest2, BUFFER_TEST_SIZE); 01256 01257 res = pal_fsFclose(&g_fd1); 01258 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01259 01260 res = pal_fsUnlink(addRootToPath(fileName,buffer,storageId)); 01261 TEST_ASSERT_EQUAL(PAL_SUCCESS, res); 01262 01263 free(bufferTest); 01264 bufferTest = NULL; 01265 free(bufferTest2); 01266 bufferTest2 = NULL; 01267 } 01268 01269 TEST(pal_fileSystem, SequentialWriteAndRead) 01270 { 01271 SequentialWriteAndRead(PAL_FS_PARTITION_PRIMARY); 01272 SequentialWriteAndRead(PAL_FS_PARTITION_SECONDARY); 01273 }
Generated on Tue Jul 12 2022 16:22:09 by
1.7.2