#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <mcheck.h>
#include "CUnit.h"
#include "TestDB.h"
#include "Basic.h"
#include "fat.h"
#include "format.h"
#include "load_fat.h"
#include "list.h"
#include "open_fat.h"
#include "write_fat.h"
#include "read_fat.h"
#include "rw_suite.h"
Vai al codice sorgente di questo file.
Definizioni | |
#define | N 25 |
Funzioni | |
int | rw_init (void) |
int | rw_clean (void) |
void | basic_rw (char *fname, int block_size, unsigned int num_block) |
void | advanced_rw (char *fname, int block_size, unsigned int num_block) |
void | basic_rw_128 (void) |
void | basic_rw_1K (void) |
void | basic_rw_2K (void) |
void | basic_rw_4K (void) |
void | advanced_rw_128 (void) |
void | advanced_rw_1K (void) |
void | advanced_rw_2K (void) |
void | advanced_rw_4K (void) |
void | add_suite_rw (void) |
Questo file definisce la test suite per le funzioni di scrittura e lettura di un file all'interno di un filesystem SFAT.
Definizione nel file rw_suite.c.
int rw_init | ( | void | ) |
Funzione di inizializzazione della suite
Definizione alla linea 27 del file rw_suite.c.
int rw_clean | ( | void | ) |
Funzione di inizializzazione della suite
Definizione alla linea 30 del file rw_suite.c.
void basic_rw | ( | char * | fname, | |
int | block_size, | |||
unsigned int | num_block | |||
) |
Questa funzione effettua un test basico della scrittura e lettura di un file. In particolare la funzione effettua le seguenti operazioni:
rw_char
nella root directory.Inoltre la funzione crea un secondo file rw_int
ed effettua la scrittura di N interi (da 0 a N-1). Su tale file vengono effettuati gli stessi tipi di controlli previsti per il file rw_char
.
Definizione alla linea 51 del file rw_suite.c.
00052 { 00053 FILE *fs; 00054 struct fat_ctrl f_ctrl; 00055 struct dir_entry root_info; 00056 unsigned int len; 00057 int ret, i, int_buff_in[N], int_buff_out[N]; 00058 char *list, buff_in[N], buff_out[N], c; 00059 char ex_list1[ ] = ".\t..\trw_char"; 00060 00061 /* 00062 * Formatta il filesystem e ... 00063 */ 00064 fs = fopen(fname, "w"); 00065 fat_format(fs, block_size, num_block); 00066 fclose(fs); 00067 /* ... lo carica */ 00068 fs = fopen(fname, "r+"); 00069 ret = mount_fat(fs, &f_ctrl); 00070 CU_ASSERT_EQUAL_FATAL(ret, 0); 00071 00072 /* 00073 * Crea il file rw_char e chiude il fs ... 00074 */ 00075 ret = fat_open(fs, &f_ctrl, "/rw_char"); 00076 CU_ASSERT_EQUAL_FATAL(ret, 0); 00077 fclose(fs); 00078 /* ... cerca di montare il fs */ 00079 fs = fopen(fname, "r+"); 00080 ret = mount_fat(fs, &f_ctrl); 00081 CU_ASSERT_EQUAL_FATAL(ret, 0); 00082 00083 /* 00084 * Prepara il buffer ... 00085 */ 00086 00087 c = 'a'; /* inizia dal carattere 'a' */ 00088 for (i=0; i<N; i++) 00089 buff_in[i] = c + i; 00090 00091 /* ... scrive il buffer su file e chiude il file system. */ 00092 ret = fat_write(fs, &f_ctrl, "/rw_char", buff_in, N*sizeof(char)); 00093 CU_ASSERT_EQUAL_FATAL(ret, 0); 00094 fclose(fs); 00095 00096 /* 00097 * Effettua di nuovo il mounting del file system 00098 */ 00099 fs = fopen(fname, "r+"); 00100 ret = mount_fat(fs, &f_ctrl); 00101 CU_ASSERT_EQUAL_FATAL(ret, 0); 00102 00103 /* 00104 * Controlla la lunghezza del file 00105 */ 00106 len = sizeof(struct dir_entry)*2; 00107 len = f_ctrl.blk_base + (ROOT_IDX)*f_ctrl.b_sector.block_size+len; 00108 fseek(fs, len ,SEEK_SET); 00109 ret = fread(&root_info, sizeof(struct dir_entry), 1, fs); 00110 CU_ASSERT_EQUAL_FATAL(ret, 1); 00111 CU_ASSERT_EQUAL_FATAL(root_info.len, N*sizeof(char)); 00112 00113 /* 00114 * Controlla il listing di "/" 00115 */ 00116 ret = fat_ls(fs, &f_ctrl, "/", &list); 00117 CU_ASSERT_EQUAL_FATAL(ret, 0); 00118 CU_ASSERT_STRING_EQUAL_FATAL(list, ex_list1); 00119 00120 /* 00121 * Effettua la lettura di controllo 00122 */ 00123 c = 'a'; 00124 00125 for (i=0; i<N; i++) { 00126 ret = fat_read(fs, &f_ctrl, "/rw_char", i, sizeof(char), buff_out); 00127 CU_ASSERT_EQUAL_FATAL(ret, sizeof(char)); 00128 CU_ASSERT_FATAL(buff_out[0] == c); 00129 c = c + 1; 00130 } 00131 00132 /* 00133 * Legge N byte dal file e controlla il risultato 00134 */ 00135 ret = fat_read(fs, &f_ctrl, "/rw_char", 0, sizeof(char)*N, buff_out); 00136 CU_ASSERT_EQUAL_FATAL(ret, sizeof(char)*N); 00137 for (i=0; i<N; i++) 00138 CU_ASSERT_FATAL(buff_out[i] == buff_in[i]); 00139 00140 00141 /* 00142 * Stesso test su N interi (da 0 a N-1) 00143 */ 00144 ret = fat_open(fs, &f_ctrl, "/rw_int"); 00145 00146 /* Inizializza il buffer*/ 00147 for (i=0; i<N; i++) 00148 int_buff_in[i] = i; 00149 00150 /* Scrive il buffer sul file rw_int */ 00151 ret = fat_write(fs, &f_ctrl, "/rw_int", (char *)int_buff_in, N*sizeof(int)); 00152 CU_ASSERT_EQUAL_FATAL(ret, 0); 00153 fclose(fs); 00154 00155 /* Mounting del filesystem */ 00156 fs = fopen(fname, "r+"); 00157 ret = mount_fat(fs, &f_ctrl); 00158 CU_ASSERT_EQUAL_FATAL(ret, 0); 00159 00160 /* Check della lunghezza del file */ 00161 len = sizeof(struct dir_entry)*3; 00162 len = f_ctrl.blk_base + ROOT_IDX*f_ctrl.b_sector.block_size + len; 00163 fseek(fs, len ,SEEK_SET); 00164 ret = fread(&root_info, sizeof(struct dir_entry), 1, fs); 00165 CU_ASSERT_EQUAL_FATAL(ret, 1); 00166 CU_ASSERT_EQUAL_FATAL(root_info.len, N*sizeof(int)); 00167 00168 /* Controlla la lettura di un intero alla volta */ 00169 for (i=0; i<N; i++) { 00170 ret = fat_read(fs, &f_ctrl, "/rw_int", i*sizeof(int), sizeof(int), (char *)int_buff_out); 00171 CU_ASSERT_EQUAL_FATAL(ret, sizeof(int)); 00172 CU_ASSERT_FATAL((int)int_buff_out[0] == i); 00173 } 00174 00175 /* Legge tutti gli interi dal file. */ 00176 ret = fat_read(fs, &f_ctrl, "/rw_int", 0, sizeof(int)*N, (char *)int_buff_out); 00177 CU_ASSERT_EQUAL_FATAL(ret, sizeof(int)*N); 00178 for (i=0; i<N; i++) 00179 CU_ASSERT_FATAL(int_buff_out[i] == int_buff_in[i]); 00180 00181 fclose(fs); 00182 00183 }
void advanced_rw | ( | char * | fname, | |
int | block_size, | |||
unsigned int | num_block | |||
) |
Questa funzione effettua dei test di alcune delle condizioni limite delle funzione di scrittura e lettura di un file all'interno di un filesystem SFAT. Per questo test verra' utilizzata una struttura che contiene un intero ed un carattere. I test che vengono realizzati da questa funzione sono i seguenti:
num_block
).Definizione alla linea 209 del file rw_suite.c.
00210 { 00211 /* struttura da scrivere nel file */ 00212 struct test_data { 00213 char c_data; 00214 int i_data; 00215 }; 00216 FILE *fs; 00217 struct fat_ctrl f_ctrl; 00218 int n_blk, r_bytes, ret, i, num_elem, begin; 00219 char c; 00220 struct test_data *buff_in, *buff_out; 00221 00222 /* 00223 * Formattazione del fs e ... 00224 */ 00225 fs = fopen(fname, "w"); 00226 fat_format(fs, block_size, num_block); 00227 fclose(fs); 00228 /* ... caricamento */ 00229 fs = fopen(fname, "r+"); 00230 ret = mount_fat(fs, &f_ctrl); 00231 CU_ASSERT_EQUAL_FATAL(ret, 0); 00232 00233 /* 00234 * Crate the file rw_struct and ... 00235 */ 00236 ret = fat_open(fs, &f_ctrl, "/rw_st"); 00237 CU_ASSERT_EQUAL_FATAL(ret, 0); 00238 fclose(fs); 00239 /* ... try to mount the filsystem */ 00240 fs = fopen(fname, "r+"); 00241 ret = mount_fat(fs, &f_ctrl); 00242 CU_ASSERT_EQUAL_FATAL(ret, 0); 00243 00244 /* 00245 * Numero di scritture necessarie e riempire il blocco 00246 * 00247 */ 00248 num_elem = block_size / sizeof(struct test_data); 00249 buff_in = (struct test_data *)malloc(sizeof(struct test_data)*num_elem); 00250 00251 c = 0x00; /* Starts from '\0' */ 00252 for (i=0; i<num_elem; i++) { 00253 buff_in[i].c_data = (c + i) % 128; 00254 buff_in[i].i_data = i; 00255 ret = fat_write(fs, &f_ctrl, "/rw_st", (char *)(buff_in + i), sizeof(struct test_data)); 00256 CU_ASSERT_EQUAL_FATAL(ret, 0); 00257 } 00258 00259 /* 00260 * Lettura e controllo delle strutture scritte 00261 */ 00262 buff_out = (struct test_data *)malloc(sizeof(struct test_data)*num_elem ); 00263 ret = fat_read(fs, &f_ctrl, "/rw_st", 0, sizeof(struct test_data)*num_elem, (char *)buff_out); 00264 CU_ASSERT_EQUAL_FATAL(ret, sizeof(struct test_data)*num_elem); 00265 for (i=0; i<num_elem; i++) { 00266 CU_ASSERT_FATAL(buff_out[i].c_data == buff_in[i].c_data); 00267 CU_ASSERT_FATAL(buff_out[i].i_data == buff_in[i].i_data); 00268 } 00269 00270 /* 00271 * Scriviamo una nuova struttua, 00272 * questo richiede l'allocazione di un nuovo blocco .. 00273 */ 00274 buff_in[0].c_data = num_elem % 128; 00275 buff_in[0].i_data = num_elem; 00276 ret = fat_write(fs, &f_ctrl, "/rw_st", (char *)(buff_in), sizeof(struct test_data)); 00277 CU_ASSERT_EQUAL_FATAL(ret, 0); 00278 00279 /*... rilettura .... */ 00280 ret = fat_read(fs, &f_ctrl, "/rw_st", num_elem*sizeof(struct test_data), 00281 sizeof(struct test_data), (char *)buff_out); 00282 CU_ASSERT_EQUAL_FATAL(ret, sizeof(struct test_data)); 00283 CU_ASSERT_FATAL(buff_out[0].c_data == buff_in[0].c_data); 00284 CU_ASSERT_FATAL(buff_out[0].i_data == buff_in[0].i_data); 00285 00286 free(buff_in); 00287 free(buff_out); 00288 /* 00289 * Leggiamo 2*num_elem strutture da file. Solo num_elem + 1 devono essere 00290 * ritornate nel buffer 00291 */ 00292 r_bytes = sizeof(struct test_data)*2*num_elem; 00293 buff_out = (struct test_data *)malloc(r_bytes); 00294 CU_ASSERT_FATAL(buff_out!=NULL); 00295 00296 ret = fat_read(fs, &f_ctrl, "/rw_st", 0, r_bytes, (char *)buff_out); 00297 CU_ASSERT_EQUAL_FATAL(ret, sizeof(struct test_data)*(num_elem + 1)); 00298 for (i=0; i<num_elem + 1; i++) { 00299 CU_ASSERT_FATAL(buff_out[i].i_data == i); 00300 CU_ASSERT_FATAL(buff_out[i].c_data == i%128); 00301 } 00302 00303 /* 00304 * Riempiamo i blocchi disponibili. 00305 * Nota: un blocco e' usato dalla root e due dal file rw_st. 00306 */ 00307 n_blk = num_block - 2; 00308 for (i=0; i<(n_blk*num_elem)-1; i++) { 00309 buff_in[0].c_data = (num_elem + 1 + i) % 128; 00310 buff_in[0].i_data = num_elem + 1 + i; 00311 ret = fat_write(fs, &f_ctrl, "/rw_st", (char *)(buff_in), sizeof(struct test_data)); 00312 CU_ASSERT_EQUAL_FATAL(ret, 0); 00313 } 00314 00315 /* Reads all data */ 00316 free(buff_out); 00317 r_bytes = sizeof(struct test_data)*num_elem*(num_block-1); 00318 buff_out = (struct test_data *)malloc(r_bytes); 00319 ret = fat_read(fs, &f_ctrl, "/rw_st", 0, r_bytes, (char *)buff_out); 00320 CU_ASSERT_EQUAL_FATAL(ret, r_bytes); 00321 for (i=0; i<num_elem*(num_block-1); i++) { 00322 CU_ASSERT_FATAL(buff_out[i].c_data == i%128); 00323 CU_ASSERT_FATAL(buff_out[i].i_data == i); 00324 } 00325 00326 /* Legge dalla struttura 4 nel blocco 2 alla 3 nel blocco 4 . */ 00327 begin = (num_elem*2 + 4)*sizeof(struct test_data); 00328 r_bytes = ((sizeof(struct test_data)*num_elem*3) + 3*sizeof(struct test_data) - begin); 00329 ret = fat_read(fs, &f_ctrl, "/rw_st", begin, r_bytes, (char *)buff_out); 00330 CU_ASSERT_EQUAL_FATAL(ret, r_bytes); 00331 for (i=num_elem*2 + 4; i<num_elem*3 + 3; i++) { 00332 CU_ASSERT_FATAL(buff_out[i].c_data == i%128); 00333 CU_ASSERT_FATAL(buff_out[i].i_data == i); 00334 } 00335 00336 /* Legge i dati dell'ultimo blocco*/ 00337 begin = (num_elem*(num_block - 2)) * sizeof(struct test_data); 00338 r_bytes = sizeof(struct test_data)*num_elem; 00339 ret = fat_read(fs, &f_ctrl, "/rw_st", begin, r_bytes, (char *)buff_out); 00340 CU_ASSERT_EQUAL_FATAL(ret, r_bytes); 00341 for (i=num_elem*(num_block - 2); i<num_elem*(num_block - 1); i++) { 00342 CU_ASSERT_FATAL(buff_out[i].c_data == i%128); 00343 CU_ASSERT_FATAL(buff_out[i].i_data == i); 00344 } 00345 00346 /* 00347 * Check file system full. 00348 */ 00349 ret = fat_write(fs, &f_ctrl, "/rw_st", (char *)(buff_in), sizeof(struct test_data)); 00350 CU_ASSERT_EQUAL_FATAL(ret, ENMSD); 00351 }
void basic_rw_128 | ( | void | ) |
Test di base per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 128 Bytes ciascuno.
Definizione alla linea 357 del file rw_suite.c.
00358 { 00359 basic_rw("DataFile/fat_128", 128, 10); 00360 }
void basic_rw_1K | ( | void | ) |
Test di base per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 1KB ciascuno.
Definizione alla linea 366 del file rw_suite.c.
00367 { 00368 basic_rw("DataFile/fat_1K", 1024, 10); 00369 }
void basic_rw_2K | ( | void | ) |
Test di base per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 2KB ciascuno.
Definizione alla linea 375 del file rw_suite.c.
00376 { 00377 basic_rw("DataFile/fat_2K", 1024*2, 10); 00378 }
void basic_rw_4K | ( | void | ) |
Test di base per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 4KB ciascuno.
Definizione alla linea 384 del file rw_suite.c.
00385 { 00386 basic_rw("DataFile/fat_4K", 1024*4, 10); 00387 }
void advanced_rw_128 | ( | void | ) |
Test avanzato per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 128 Bytes ciascuno.
Definizione alla linea 393 del file rw_suite.c.
00394 { 00395 advanced_rw("DataFile/fat_128", 128, 10); 00396 }
void advanced_rw_1K | ( | void | ) |
Test avanzato per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 1KB ciascuno.
Definizione alla linea 402 del file rw_suite.c.
00403 { 00404 advanced_rw("DataFile/fat_1K", 1024, 10); 00405 }
void advanced_rw_2K | ( | void | ) |
Test avanzato per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 2KB ciascuno.
Definizione alla linea 411 del file rw_suite.c.
00412 { 00413 advanced_rw("DataFile/fat_2K", 1024*2, 10); 00414 }
void advanced_rw_4K | ( | void | ) |
Test avanzato per la lettura e scrittura di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 4KB ciascuno.
Definizione alla linea 420 del file rw_suite.c.
00421 { 00422 advanced_rw("DataFile/fat_4K", 1024*4, 10); 00423 }
void add_suite_rw | ( | void | ) |
Test suite per le funzioni fat_read
e fat_write
Definizione alla linea 429 del file rw_suite.c.
00430 { 00431 CU_pSuite rw_suite = NULL; 00432 00433 rw_suite = CU_add_suite("File R/W operations", rw_init, rw_clean); 00434 00435 /* Basic R/W operations test */ 00436 CU_add_test(rw_suite, "Basic R/W operations with block size 128 bytes", basic_rw_128); 00437 CU_add_test(rw_suite, "Basic R/W operations with block size 1K bytes", basic_rw_1K); 00438 CU_add_test(rw_suite, "Basic R/W operations with block size 2K bytes", basic_rw_2K); 00439 CU_add_test(rw_suite, "Basic R/W operations with block size 4K bytes", basic_rw_4K); 00440 00441 /* Advanced R/W operations test */ 00442 CU_add_test(rw_suite, "Advanced R/W operations with block size 128 bytes", advanced_rw_128); 00443 CU_add_test(rw_suite, "Advanced R/W operations with block size 1K bytes", advanced_rw_1K); 00444 CU_add_test(rw_suite, "Advanced R/W operations with block size 2K bytes", advanced_rw_2K); 00445 CU_add_test(rw_suite, "Advanced R/W operations with block size 4K bytes", advanced_rw_4K); 00446 }