Riferimenti per il file format_suite.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "CUnit.h"
#include "TestDB.h"
#include "Basic.h"
#include "fat.h"
#include "format.h"
#include "load_fat.h"

Vai al codice sorgente di questo file.

Funzioni

int success_init (void)
int success_clean (void)
void run_formatter (char *fname, int bsize, int nblock)
void format_128 (void)
void format_1K (void)
void format_2K (void)
void format_4K (void)
void add_suite_format (void)

Descrizione dettagliata

Questo file definisce la test suite per la funzione di formattazione del filesystem SFAT.

Definizione nel file format_suite.c.


Documentazione delle funzioni

int success_init ( void   ) 

Funzione di inizializzazione della suite

Definizione alla linea 21 del file format_suite.c.

00021 { return 0; }

int success_clean ( void   ) 

Funzione di clean up della suite

Definizione alla linea 23 del file format_suite.c.

00023 { return 0; }

void run_formatter ( char *  fname,
int  bsize,
int  nblock 
)

Questa funzione crea e formatta un filesystem utilizzando i parametri specificati in ingresso. Il test effettua i controlli necessari a verificare che il file sia stato formattato correttamente.

Parametri:
fname nome del file da formattare.
bsize dimensione dei blocchi del filesystem
nblock numero di blocchi disponibili.

Definizione alla linea 34 del file format_suite.c.

00034                                                         {
00035     int ret, len, i, nbytes;
00036     struct stat st;
00037     FILE *fs;
00038     struct fat_ctrl f_ctrl;
00039     struct boot_sector b_sec;
00040     struct dir_entry d_entry;
00041     unsigned int *fat_check;
00042     char blk_elem;
00043 
00044     /*
00045      * Creazione del file device che conterra' il file system. 
00046      * Se il file esiste viene troncato 
00047      * Se fopen ritorna NULL il test viene abortito 
00048      */
00049     fs = fopen(fname, "w");
00050     CU_ASSERT_PTR_NOT_NULL_FATAL(fs); 
00051 
00052     /*
00053      * Formattazione con nblock blocchi di 
00054      * size bsize
00055      */
00056     ret = fat_format(fs, bsize, nblock);
00057     CU_ASSERT_EQUAL(0, ret);
00058     fclose(fs);
00059 
00060     /*
00061      * La lunghezza in byte e' giusta?
00062      */
00063     len = sizeof(struct boot_sector);
00064     len = len + sizeof(unsigned int) * nblock;
00065     len = len + bsize * nblock;
00066     stat(fname, &st);
00067     CU_TEST_FATAL(len == st.st_size);
00068 
00069     /*
00070      * Effettua il mounting del file system e 
00071      * controlla che la format abbia scritto i valori giusti
00072      */
00073     fs = fopen(fname, "r+");
00074     ret = mount_fat(fs, &f_ctrl);
00075     CU_ASSERT_EQUAL_FATAL(0, ret);
00076 
00077     /*
00078      * Controlla i valori del boot sector
00079      */
00080     b_sec = f_ctrl.b_sector;
00081     CU_TEST_FATAL(b_sec.fs_type == FAT_TYPE);
00082     CU_TEST_FATAL(b_sec.block_size  == bsize);
00083     CU_TEST_FATAL(b_sec.num_block  == nblock);
00084 
00085     /*
00086      * Controlla il valore di blk_base
00087      */
00088     CU_ASSERT_EQUAL_FATAL(f_ctrl.blk_base, sizeof(struct boot_sector) + (sizeof(unsigned int) * b_sec.num_block));
00089 
00090     /*
00091      * Controlla i valori nella File Allocation Table.
00092      * L'array deve contenere BLOCK_FREE in tutte le posizioni 
00093      * eccetto la prima, che deve contenere LAST_BLOCK.
00094      */
00095     fat_check = f_ctrl.fat_ptr;
00096     for (i=0; i<b_sec.num_block; i++)
00097       CU_ASSERT_EQUAL_FATAL(fat_check[i], i==ROOT_IDX ? LAST_BLOCK : BLOCK_FREE);
00098 
00099     /*
00100      * Controllo intermedio.
00101      * Tutti i blocchi prima di ROOT_IDX devono essere
00102      * inizializzati a INIT_BLOCK.
00103      */
00104     fseek(fs, f_ctrl.blk_base, SEEK_SET);
00105     nbytes = ROOT_IDX*b_sec.block_size;
00106     for (i=0; i<nbytes; i++) {
00107         ret = fread(&blk_elem, sizeof(char), 1, fs);
00108         CU_ASSERT_EQUAL_FATAL(1, ret);
00109         CU_ASSERT_EQUAL_FATAL(blk_elem, INIT_BLOCK);
00110     }
00111 
00112     /*
00113      * Controlla che la directory root contenga i valori giusti per 
00114      * "." e ".."
00115      */
00116     ret = fread(&d_entry, sizeof(d_entry), 1, fs);
00117     CU_ASSERT_EQUAL_FATAL(1, ret);
00118     CU_ASSERT_EQUAL_FATAL(d_entry.used, DIR_ENTRY_BUSY);
00119     CU_ASSERT_STRING_EQUAL_FATAL(d_entry.name, ".");
00120     CU_ASSERT_EQUAL_FATAL(d_entry.attr, SUB_ENTRY);
00121     CU_ASSERT_EQUAL_FATAL(d_entry.index, 0);
00122     CU_ASSERT_EQUAL_FATAL(d_entry.len, 2 * sizeof(d_entry));
00123 
00124     ret = fread(&d_entry, sizeof(d_entry), 1, fs);
00125     CU_ASSERT_EQUAL_FATAL(1, ret);
00126     CU_ASSERT_EQUAL_FATAL(d_entry.used, DIR_ENTRY_BUSY);
00127     CU_ASSERT_STRING_EQUAL_FATAL(d_entry.name, "..");
00128     CU_ASSERT_EQUAL_FATAL(d_entry.attr, SUB_ENTRY);
00129     CU_ASSERT_EQUAL_FATAL(d_entry.index, 0);
00130     CU_ASSERT_EQUAL_FATAL(d_entry.len, 2 * sizeof(d_entry));
00131 
00132     /*
00133      * Controllo finale.
00134      * Tutti i blocchi rimanenti devono essere inizializzati a 
00135      * INIT_BLOCK.
00136      */
00137     len = 2 * sizeof(d_entry) + nbytes;
00138     nbytes = b_sec.num_block*b_sec.block_size;
00139     for (i=len; i<nbytes; i++) {
00140         ret = fread(&blk_elem, sizeof(char), 1, fs);
00141         CU_ASSERT_EQUAL_FATAL(1, ret);
00142         CU_ASSERT_EQUAL_FATAL(blk_elem, INIT_BLOCK);
00143     }  
00144 }

void format_128 ( void   ) 
Test:

Testa la formattazione di un filesystem che utilizza 100 blocchi ciascuno di dimensione 128 bytes.

Definizione alla linea 152 del file format_suite.c.

00153 {
00154     run_formatter("./DataFile/FAT_128", 128, 100);
00155 }

void format_1K ( void   ) 
Test:

Testa la formattazione di un filesystem che utilizza 10 blocchi ciascuno di dimensione 1KB.

Definizione alla linea 163 del file format_suite.c.

00164 {
00165     run_formatter("./DataFile/FAT_1K", 1024, 10);
00166 }

void format_2K ( void   ) 
Test:

Testa la formattazione di un filesystem che utilizza 10 blocchi ciascuno di dimensione 2KB bytes.

Definizione alla linea 174 del file format_suite.c.

00175 {
00176     run_formatter("./DataFile/FAT_2K", 1024*2, 10);
00177 }

void format_4K ( void   ) 
Test:

Testa la formattazione di un filesystem che utilizza 10 blocchi ciascuno di dimensione 4KB.

Definizione alla linea 185 del file format_suite.c.

00186 {
00187     run_formatter("./DataFile/FAT_4K", 1024*4, 10);
00188 }

void add_suite_format ( void   ) 

Definizione della suite.

Definizione alla linea 191 del file format_suite.c.

00192 {
00193     CU_pSuite format_suite = NULL;
00194 
00195     format_suite = CU_add_suite("Format Operation", success_init, success_clean);
00196     CU_add_test(format_suite, "FAT format/mount Test (128 Bytes)", format_128);
00197     CU_add_test(format_suite, "FAT format/mount Test (1K Bytes)", format_1K);
00198     CU_add_test(format_suite, "FAT format/mount Test (2K Bytes)", format_2K);
00199     CU_add_test(format_suite, "FAT format/mount Test (4K Bytes)", format_4K);
00200 }

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