#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) |
Questo file definisce la test suite per la funzione di formattazione del filesystem SFAT.
Definizione nel file format_suite.c.
int success_init | ( | void | ) |
Funzione di inizializzazione della suite
Definizione alla linea 21 del file format_suite.c.
int success_clean | ( | void | ) |
Funzione di clean up della suite
Definizione alla linea 23 del file format_suite.c.
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.
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 | ) |
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 | ) |
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 | ) |
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 | ) |
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 }