rw_suite.c

Vai alla documentazione di questo file.
00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <string.h>
00004 #include <sys/types.h>
00005 #include <sys/stat.h>
00006 #include <unistd.h>
00007 #include <mcheck.h>
00008 #include "CUnit.h"
00009 #include "TestDB.h"
00010 #include "Basic.h"
00011 #include "fat.h"
00012 #include "format.h"
00013 #include "load_fat.h"
00014 #include "list.h"
00015 #include "open_fat.h"
00016 #include "write_fat.h"
00017 #include "read_fat.h"
00018 #include "rw_suite.h"
00019 #define N 25
00020 
00027 int rw_init(void) { return 0; }
00028 
00030 int rw_clean(void) { return 0; }
00031 
00051 void basic_rw (char *fname, int block_size, unsigned int num_block)
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 }
00184 
00209 void advanced_rw (char *fname, int block_size, unsigned int num_block)
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 }
00352 
00357 void basic_rw_128 (void)
00358 {
00359     basic_rw("DataFile/fat_128", 128, 10);
00360 }
00361 
00366 void basic_rw_1K (void)
00367 {
00368     basic_rw("DataFile/fat_1K", 1024, 10);
00369 }
00370 
00375 void basic_rw_2K (void)
00376 {
00377     basic_rw("DataFile/fat_2K", 1024*2, 10);
00378 }
00379 
00384 void basic_rw_4K (void)
00385 {
00386     basic_rw("DataFile/fat_4K", 1024*4, 10);
00387 }
00388 
00393 void advanced_rw_128 (void)
00394 {
00395     advanced_rw("DataFile/fat_128", 128, 10);
00396 }
00397 
00402 void advanced_rw_1K (void)
00403 {
00404     advanced_rw("DataFile/fat_1K", 1024, 10);
00405 }
00406 
00411 void advanced_rw_2K (void)
00412 {
00413     advanced_rw("DataFile/fat_2K", 1024*2, 10);
00414 }
00415 
00420 void advanced_rw_4K (void)
00421 {
00422     advanced_rw("DataFile/fat_4K", 1024*4, 10);
00423 }
00424 
00425 
00429 void add_suite_rw(void)
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