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
00063
00064 fs = fopen(fname, "w");
00065 fat_format(fs, block_size, num_block);
00066 fclose(fs);
00067
00068 fs = fopen(fname, "r+");
00069 ret = mount_fat(fs, &f_ctrl);
00070 CU_ASSERT_EQUAL_FATAL(ret, 0);
00071
00072
00073
00074
00075 ret = fat_open(fs, &f_ctrl, "/rw_char");
00076 CU_ASSERT_EQUAL_FATAL(ret, 0);
00077 fclose(fs);
00078
00079 fs = fopen(fname, "r+");
00080 ret = mount_fat(fs, &f_ctrl);
00081 CU_ASSERT_EQUAL_FATAL(ret, 0);
00082
00083
00084
00085
00086
00087 c = 'a';
00088 for (i=0; i<N; i++)
00089 buff_in[i] = c + i;
00090
00091
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
00098
00099 fs = fopen(fname, "r+");
00100 ret = mount_fat(fs, &f_ctrl);
00101 CU_ASSERT_EQUAL_FATAL(ret, 0);
00102
00103
00104
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
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
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
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
00143
00144 ret = fat_open(fs, &f_ctrl, "/rw_int");
00145
00146
00147 for (i=0; i<N; i++)
00148 int_buff_in[i] = i;
00149
00150
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
00156 fs = fopen(fname, "r+");
00157 ret = mount_fat(fs, &f_ctrl);
00158 CU_ASSERT_EQUAL_FATAL(ret, 0);
00159
00160
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
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
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
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
00224
00225 fs = fopen(fname, "w");
00226 fat_format(fs, block_size, num_block);
00227 fclose(fs);
00228
00229 fs = fopen(fname, "r+");
00230 ret = mount_fat(fs, &f_ctrl);
00231 CU_ASSERT_EQUAL_FATAL(ret, 0);
00232
00233
00234
00235
00236 ret = fat_open(fs, &f_ctrl, "/rw_st");
00237 CU_ASSERT_EQUAL_FATAL(ret, 0);
00238 fclose(fs);
00239
00240 fs = fopen(fname, "r+");
00241 ret = mount_fat(fs, &f_ctrl);
00242 CU_ASSERT_EQUAL_FATAL(ret, 0);
00243
00244
00245
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;
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
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
00272
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
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
00290
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
00305
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
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
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
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
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
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
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 }