Riferimenti per il file rw_suite.c

#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)

Descrizione dettagliata

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.


Documentazione delle funzioni

int rw_init ( void   ) 

Funzione di inizializzazione della suite

Definizione alla linea 27 del file rw_suite.c.

00027 { return 0; }

int rw_clean ( void   ) 

Funzione di inizializzazione della suite

Definizione alla linea 30 del file rw_suite.c.

00030 { return 0; }

void basic_rw ( char *  fname,
int  block_size,
unsigned int  num_block 
)
Test:

Questa funzione effettua un test basico della scrittura e lettura di un file. In particolare la funzione effettua le seguenti operazioni:

  • Crea il file rw_char nella root directory.
  • Effettua la scrittura di N caratteri (da a in poi) un carattere per volta.
  • Controlla che la lunghezza del file sia cambiata da 0 a N.
  • Controlla che il listing della root directory sia corretto.
  • Richiede la lettura di ciascun carattere con operazioni di read separate e controlla che il risultato sia corretto.
  • Richiede la lettura dei N caratteri in un'unica sequenza di byte e controlla che il risultato sia corretto.

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 
)
Test:

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:

  • Vengono effettuate una serie di scritture in modo da riempire un blocco. Vengono poi effettuate una serie di letture per assicurarsi che le scritture siano avvenute correttamente alla fine del file.
  • Viene effettuata una nuova scrittura che richiede l'allocazione di un nuovo blocco. Viene eseguita una lettura per verificare la correttezza della precedente scrittura.
  • Viene effettuata una lettura della dimensione di due blocchi in modo da verificare che venga rilevata correttamente la fine di un file.
  • Viene effettuata una serie di scritture in modo da utilizzare tutti i blocchi disponibili all'interno del filesystem (num_block).
  • Vengono effettuate delle letture random che accedono a varie parti del file. Lo scopo e' quello di verificare che la lettura di porzioni del file avvenga correttamente.

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 }

Generato il Fri Jan 28 22:16:31 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3