Riferimenti per il file open_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 "open_suite.h"

Vai al codice sorgente di questo file.

Funzioni

int open_init (void)
int open_clean (void)
void simple_open (char *fname, int block_size, unsigned int num_block)
void simple_open_128 (void)
void simple_open_1K (void)
void simple_open_2K (void)
void simple_open_4K (void)
void add_suite_open (void)

Descrizione dettagliata

Questo file definisce la test suite per la funzione di creazione di un file fat_open.

Definizione nel file open_suite.c.


Documentazione delle funzioni

int open_init ( void   ) 

Funzione di inizializzazione della suite

Definizione alla linea 25 del file open_suite.c.

00025 {  return 0; }

int open_clean ( void   ) 

Funzione di inizializzazione della suite

Definizione alla linea 28 del file open_suite.c.

00028 {    return 0; }

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

Esegue il test di creazione di un file all'interno della root directory. In particolare si controlla che:

  • La root directory contenga tre entry, due relative a "." e ".." ed una relativa al nuovo file.
  • La lunghezza del file che contiene il filesystem SFAT sia corretta.
  • Che il listing della root directory contenga le corrette informazioni.

Definizione alla linea 42 del file open_suite.c.

00043 {
00044     FILE *fs;
00045     struct fat_ctrl f_ctrl;
00046     struct dir_entry root_info;
00047     unsigned int len;
00048     int  ret;
00049     struct stat st;
00050     char *list;
00051     char ex_list[ ] = ".\t..\tfile1";
00052 
00053     /*
00054      * Formattazione file
00055      */
00056     if ( ( fs = fopen(fname, "w") ) == NULL ) {
00057         perror("simpleopen");
00058         exit (EXIT_FAILURE);
00059     }
00060     fat_format(fs, block_size, num_block);
00061     fclose(fs);
00062     /* caricamento  */
00063     if ( ( fs = fopen(fname, "r+") ) == NULL) {
00064         perror("simpleopen");
00065         exit (EXIT_FAILURE);
00066     }
00067     ret = mount_fat(fs, &f_ctrl);
00068     CU_ASSERT_EQUAL_FATAL(ret, 0);
00069 
00070     /*
00071      * Cerca di creare il file "file1" e chiude il file
00072      */
00073     ret = fat_open(fs, &f_ctrl, "/file1");
00074     CU_ASSERT_EQUAL_FATAL(ret, 0);
00075     fclose(fs);
00076     /* cerca di fare il mount del filesystem .*/
00077     if ( ( fs = fopen(fname, "r+") ) == NULL) {
00078         perror("simpleopen");
00079         exit (EXIT_FAILURE);
00080     }
00081     ret = mount_fat(fs, &f_ctrl);
00082     CU_ASSERT_EQUAL_FATAL(ret, 0);
00083 
00084     /* 
00085      * La root directory table deve contenere tre entry
00086      * per ".", ".." e "dir1" rispettivamente.
00087      */
00088     fseek(fs, f_ctrl.blk_base + (ROOT_IDX)*f_ctrl.b_sector.block_size, SEEK_SET);
00089     /* Legge  "." entry */
00090     ret = fread(&root_info, sizeof(struct dir_entry), 1, fs); 
00091     CU_ASSERT_EQUAL_FATAL(ret, 1);
00092     CU_ASSERT_EQUAL_FATAL(root_info.used, DIR_ENTRY_BUSY);
00093     CU_ASSERT_STRING_EQUAL_FATAL(root_info.name, ".");
00094     CU_ASSERT_EQUAL_FATAL(root_info.attr, SUB_ENTRY);
00095     /* Legge  ".." entry */
00096     ret = fread(&root_info, sizeof(struct dir_entry), 1, fs);
00097     CU_ASSERT_EQUAL_FATAL(ret, 1);
00098     CU_ASSERT_EQUAL_FATAL(root_info.used, DIR_ENTRY_BUSY);
00099     CU_ASSERT_STRING_EQUAL_FATAL(root_info.name, "..");
00100     CU_ASSERT_EQUAL_FATAL(root_info.attr, SUB_ENTRY);
00101     /* Legge "file1" entry */
00102     ret = fread(&root_info, sizeof(struct dir_entry), 1, fs); 
00103     CU_ASSERT_EQUAL_FATAL(ret, 1);
00104     CU_ASSERT_EQUAL_FATAL(root_info.used, DIR_ENTRY_BUSY);
00105     CU_ASSERT_STRING_EQUAL_FATAL(root_info.name, "file1");
00106     CU_ASSERT_EQUAL_FATAL(root_info.attr, FILE_ENTRY);
00107 
00108 
00109     /*
00110      * Controlla la lunghezza del file
00111      */
00112     len = sizeof(struct boot_sector);
00113     len = len + sizeof(unsigned int) * f_ctrl.b_sector.num_block;
00114     len = len + f_ctrl.b_sector.block_size * f_ctrl.b_sector.num_block;
00115     stat(fname, &st);
00116     CU_TEST_FATAL(len == st.st_size);
00117 
00118     /*
00119      * Proviamo a listare il nuovo file.
00120      */
00121     ret = fat_ls(fs, &f_ctrl, "/", &list);
00122     CU_ASSERT_EQUAL_FATAL(ret, 0);
00123     CU_ASSERT_STRING_EQUAL_FATAL(list, ex_list);
00124 
00125     /*
00126      * Cleanup
00127      */
00128     fclose(fs);
00129     unlink(fname); 
00130 }

void simple_open_128 ( void   ) 

Test di base per la creazione di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 128 Byte ciascuno.

Definizione alla linea 136 del file open_suite.c.

00137 {
00138     simple_open("DataFile/fat_128", 128, 10);
00139 }

void simple_open_1K ( void   ) 

Test di base per la creazione di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 1KB ciascuno.

Definizione alla linea 145 del file open_suite.c.

00146 {
00147     simple_open("DataFile/fat_1K", 1024, 10);
00148 }

void simple_open_2K ( void   ) 

Test di base per la creazione di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 2KB ciascuno.

Definizione alla linea 154 del file open_suite.c.

00155 {
00156     simple_open("DataFile/fat_2K", 1024*2, 10);
00157 }

void simple_open_4K ( void   ) 

Test di base per la creazione di un file per un filsystem formattato utilizzando 10 blocchi di dimensione 4KB ciascuno.

Definizione alla linea 163 del file open_suite.c.

00164 {
00165     simple_open("DataFile/fat_4K", 1024*4, 10);
00166 }

void add_suite_open ( void   ) 

Test suite per la funzione fat_open

Definizione alla linea 171 del file open_suite.c.

00172 {
00173     CU_pSuite open_suite = NULL;
00174 
00175     open_suite = CU_add_suite("File creation", open_init, open_clean);
00176 
00177     /* Test creazione file. */ 
00178     CU_add_test(open_suite, "Create a file with block size 128 bytes", simple_open_128); 
00179     CU_add_test(open_suite, "Create a file with block size 1KB", simple_open_1K); 
00180     CU_add_test(open_suite, "Create a file with block size 2KB", simple_open_2K);
00181     CU_add_test(open_suite, "Create a file with block size 4KB", simple_open_4K);  
00182 }

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