bertos/fs/battfs_test.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2007, 2008 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  * \brief BattFS Test.
  33  *
  34  * \author Francesco Sacchi <batt@develer.com>
  35  */
  36
  37 #include <fs/battfs.h>
  38 #include <io/kblock_file.h>
  39
  40 #include <cfg/debug.h>
  41 #include <cfg/test.h>
  42
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46
  47 #define FILE_SIZE 32768
  48 #define PAGE_SIZE 128
  49
  50 #define DATA_SIZE (PAGE_SIZE - BATTFS_HEADER_LEN)
  51 #define PAGE_COUNT (FILE_SIZE / PAGE_SIZE)
  52
  53 #if UNIT_TEST
  54
  55 const char test_filename[]="battfs_disk.bin";
  56
  57 static uint8_t page_buffer[PAGE_SIZE];
  58 static pgcnt_t page_array[PAGE_COUNT];
  59
  60 static void testCheck(BattFsSuper *disk, pgcnt_t *reference)
  61 {
  62         ASSERT(battfs_fsck(disk));
  63
  64         for (unsigned i = 0; i < disk->dev->blk_cnt; i++)
  65         {
  66                 if (disk->page_array[i] != reference[i])
  67                 {
  68                         kprintf("Error at addr %d: page_array read", i);
  69                         for (pgcnt_t i = 0; i < disk->dev->blk_cnt; i++)
  70                         {
  71                                 if (!(i % 16))
  72                                         kputchar('\n');
  73                                 kprintf("%04d ", disk->page_array[i]);
  74                         }
  75                         kputchar('\n');
  76                         kprintf("Expected:");
  77                         for (pgcnt_t i = 0; i < disk->dev->blk_cnt; i++)
  78                         {
  79                                 if (!(i % 16))
  80                                         kputchar('\n');
  81                                 kprintf("%04d ", reference[i]);
  82                         }
  83                         kputchar('\n');
  84                         battfs_umount(disk);
  85                         exit(2);
  86                 }
  87         }
  88
  89         ASSERT(battfs_fsck(disk));
  90         ASSERT(battfs_umount(disk));
  91 }
  92
  93 static void diskNew(BattFsSuper *disk)
  94 {
  95         pgcnt_t ref[PAGE_COUNT];
  96
  97         TRACEMSG("1: disk new\n");
  98
  99         FILE *fpt = fopen(test_filename, "w+");
 100
 101         for (int i = 0; i < FILE_SIZE; i++)
 102                 fputc(0xff, fpt);
 103
 104         for (int i = 0; i < PAGE_COUNT; i++)
 105                 ref[i] = i;
 106
 107         KBlockFile f;
 108         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 109         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 110
 111         testCheck(disk, ref);
 112         TRACEMSG("1: passed\n");
 113 }
 114
 115 static void disk1File(BattFsSuper *disk)
 116 {
 117         pgcnt_t ref[PAGE_COUNT];
 118         TRACEMSG("2: disk full with 1 contiguos file\n");
 119
 120         FILE *fp = fopen(test_filename, "w+");
 121         for (int i = 0; i < FILE_SIZE; i++)
 122                 fputc(0xff, fp);
 123
 124         KBlockFile f;
 125         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, PAGE_COUNT);
 126
 127         for (int i = 0; i < PAGE_COUNT; i++)
 128         {
 129                 battfs_writeTestBlock(&f.b, i, 0, 0, DATA_SIZE, i);
 130                 ref[i] = i;
 131         }
 132
 133         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 134
 135         testCheck(disk, ref);
 136         TRACEMSG("2: passed\n");
 137 }
 138
 139
 140 static void diskHalfFile(BattFsSuper *disk)
 141 {
 142         pgcnt_t ref[PAGE_COUNT];
 143         TRACEMSG("3: disk half full with 1 contiguos file, rest unformatted\n");
 144
 145
 146         FILE *fp = fopen(test_filename, "w+");
 147         for (int i = 0; i < FILE_SIZE; i++)
 148                 fputc(0xff, fp);
 149
 150         KBlockFile f;
 151         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, PAGE_COUNT);
 152
 153         for (int i = 0; i < PAGE_COUNT / 2; i++)
 154         {
 155                 battfs_writeTestBlock(&f.b, i, 0, 0, DATA_SIZE, i);
 156                 ref[i] = i;
 157         }
 158         fseek(fp, FILE_SIZE / 2, SEEK_SET);
 159         for (int i = FILE_SIZE / 2; i < FILE_SIZE; i++)
 160                 fputc(0xff, fp);
 161
 162         for (int i = PAGE_COUNT / 2; i < PAGE_COUNT; i++)
 163         {
 164                 ref[i] = i;
 165         }
 166
 167         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 168
 169         testCheck(disk, ref);
 170         TRACEMSG("3: passed\n");
 171 }
 172
 173
 174 static void oldSeq1(BattFsSuper *disk)
 175 {
 176         pgcnt_t ref[4];
 177         TRACEMSG("6: 1 file with 1 old seq num, 1 free block\n");
 178
 179         FILE *fp = fopen(test_filename, "w+");
 180         for (int i = 0; i < PAGE_SIZE * 4; i++)
 181                 fputc(0xff, fp);
 182         KBlockFile f;
 183         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 4);
 184
 185         // page, inode, seq, fill, pgoff
 186         battfs_writeTestBlock(&f.b, 0, 0, 0, DATA_SIZE, 0);
 187         battfs_writeTestBlock(&f.b, 1, 0, 0, DATA_SIZE, 1);
 188         battfs_writeTestBlock(&f.b, 2, 0, 1, DATA_SIZE, 1);
 189         battfs_eraseBlock(&f.b, 3);
 190
 191         ref[0] = 0;
 192         ref[1] = 2;
 193         ref[2] = 1;
 194         ref[3] = 3;
 195
 196         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 197
 198         testCheck(disk, ref);
 199         TRACEMSG("6: passed\n");
 200 }
 201
 202 static void oldSeq2(BattFsSuper *disk)
 203 {
 204         pgcnt_t ref[4];
 205         TRACEMSG("7: 1 file with 1 old seq num, 1 free block\n");
 206
 207         FILE *fp = fopen(test_filename, "w+");
 208         for (int i = 0; i < PAGE_SIZE * 4; i++)
 209                 fputc(0xff, fp);
 210         KBlockFile f;
 211         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 4);
 212
 213         // page, inode, seq, fill, pgoff
 214         battfs_writeTestBlock(&f.b, 0, 0, 0, DATA_SIZE, 0);
 215         battfs_writeTestBlock(&f.b, 1, 0, 1, DATA_SIZE, 1);
 216         battfs_writeTestBlock(&f.b, 2, 0, 0, DATA_SIZE, 1);
 217         battfs_eraseBlock(&f.b, 3);
 218
 219         ref[0] = 0;
 220         ref[1] = 1;
 221         ref[2] = 2;
 222         ref[3] = 3;
 223
 224         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 225         testCheck(disk, ref);
 226         TRACEMSG("7: passed\n");
 227 }
 228
 229 static void oldSeq3(BattFsSuper *disk)
 230 {
 231         pgcnt_t ref[4];
 232         TRACEMSG("8: 1 file with 1 old seq num, 1 free block\n");
 233
 234
 235         FILE *fp = fopen(test_filename, "w+");
 236         for (int i = 0; i < PAGE_SIZE * 4; i++)
 237                 fputc(0xff, fp);
 238         KBlockFile f;
 239         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 4);
 240
 241         // page, inode, seq, fill, pgoff
 242         battfs_eraseBlock(&f.b, 0);
 243         battfs_writeTestBlock(&f.b, 1, 0, 0, DATA_SIZE, 0);
 244         battfs_writeTestBlock(&f.b, 2, 0, 1, DATA_SIZE, 1);
 245         battfs_writeTestBlock(&f.b, 3, 0, 0, DATA_SIZE, 1);
 246
 247         ref[0] = 1;
 248         ref[1] = 2;
 249         ref[2] = 0;
 250         ref[3] = 3;
 251
 252         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 253         testCheck(disk, ref);
 254         TRACEMSG("8: passed\n");
 255 }
 256
 257 static void oldSeq2File(BattFsSuper *disk)
 258 {
 259         pgcnt_t ref[8];
 260         TRACEMSG("9: 2 file with old seq num, 2 free block\n");
 261
 262
 263         FILE *fp = fopen(test_filename, "w+");
 264         for (int i = 0; i < PAGE_SIZE * 8; i++)
 265                 fputc(0xff, fp);
 266         KBlockFile f;
 267         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 268
 269         // page, inode, seq, fill, pgoff
 270         battfs_eraseBlock(&f.b, 0);
 271         battfs_writeTestBlock(&f.b, 1, 0, 0, DATA_SIZE, 0);
 272         battfs_writeTestBlock(&f.b, 2, 0, 3, DATA_SIZE, 1);
 273         battfs_writeTestBlock(&f.b, 3, 0, 0, DATA_SIZE, 1);
 274         battfs_eraseBlock(&f.b, 4);
 275         battfs_writeTestBlock(&f.b, 5, 4, 0, DATA_SIZE, 0);
 276         battfs_writeTestBlock(&f.b, 6, 4, 1, DATA_SIZE, 1);
 277         battfs_writeTestBlock(&f.b, 7, 4, 0, DATA_SIZE, 1);
 278
 279
 280         ref[0] = 1;
 281         ref[1] = 2;
 282         ref[2] = 5;
 283         ref[3] = 6;
 284         ref[4] = 0;
 285         ref[5] = 3;
 286         ref[6] = 4;
 287         ref[7] = 7;
 288
 289         battfs_mount(disk, &f.b, page_array, sizeof(page_array));
 290         testCheck(disk, ref);
 291         TRACEMSG("9: passed\n");
 292 }
 293
 294 static void openFile(BattFsSuper *disk)
 295 {
 296         BattFs fd1;
 297         BattFs fd2;
 298         TRACEMSG("10: open file test, inode 0 and inode 4\n");
 299
 300         FILE *fp = fopen(test_filename, "w+");
 301         for (int i = 0; i < PAGE_SIZE * 8; i++)
 302                 fputc(0xff, fp);
 303         KBlockFile f;
 304         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 305
 306
 307         int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 308         inode_t INODE = 0;
 309         inode_t INODE2 = 4;
 310         inode_t INEXISTENT_INODE = 123;
 311         unsigned int MODE = 0;
 312
 313         // page, inode, seq, fill, pgoff
 314         battfs_eraseBlock(&f.b, 0);
 315         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 316         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 317         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 318         battfs_eraseBlock(&f.b, 4);
 319         battfs_writeTestBlock(&f.b, 5, INODE2, 0, PAGE_FILL, 0);
 320         battfs_writeTestBlock(&f.b, 6, INODE2, 1, PAGE_FILL, 1);
 321         battfs_writeTestBlock(&f.b, 7, INODE2, 0, PAGE_FILL, 1);
 322
 323         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 324         ASSERT(battfs_fsck(disk));
 325         ASSERT(!battfs_fileExists(disk, INEXISTENT_INODE));
 326
 327         ASSERT(battfs_fileExists(disk, INODE));
 328         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 329         ASSERT(fd1.fd.size == PAGE_FILL * 2);
 330         ASSERT(fd1.fd.seek_pos == 0);
 331         ASSERT(fd1.mode == MODE);
 332         ASSERT(fd1.inode == INODE);
 333         ASSERT(fd1.start == &disk->page_array[0]);
 334         ASSERT(fd1.disk == disk);
 335         ASSERT(LIST_HEAD(&disk->file_opened_list) == &fd1.link);
 336
 337         ASSERT(kfile_reopen(&fd1.fd) == &fd1.fd);
 338         ASSERT(fd1.fd.size == PAGE_FILL * 2);
 339         ASSERT(fd1.fd.seek_pos == 0);
 340         ASSERT(fd1.mode == MODE);
 341         ASSERT(fd1.inode == INODE);
 342         ASSERT(fd1.start == &disk->page_array[0]);
 343         ASSERT(fd1.disk == disk);
 344         ASSERT(LIST_HEAD(&disk->file_opened_list) == &fd1.link);
 345
 346         ASSERT(battfs_fileExists(disk, INODE2));
 347         ASSERT(battfs_fileopen(disk, &fd2, INODE2, MODE));
 348         ASSERT(fd2.fd.size == PAGE_FILL * 2);
 349         ASSERT(fd2.fd.seek_pos == 0);
 350         ASSERT(fd2.mode == MODE);
 351         ASSERT(fd2.inode == INODE2);
 352         ASSERT(fd2.start == &disk->page_array[2]);
 353         ASSERT(fd2.disk == disk);
 354         ASSERT(LIST_HEAD(&disk->file_opened_list)->succ == &fd2.link);
 355
 356         ASSERT(kfile_close(&fd1.fd) == 0);
 357         ASSERT(kfile_error(&fd1.fd) == 0);
 358         ASSERT(kfile_close(&fd2.fd) == 0);
 359         ASSERT(kfile_error(&fd2.fd) == 0);
 360         ASSERT(LIST_EMPTY(&disk->file_opened_list));
 361         ASSERT(battfs_fsck(disk));
 362         ASSERT(battfs_umount(disk));
 363
 364         TRACEMSG("10: passed\n");
 365 }
 366
 367 static void readFile(BattFsSuper *disk)
 368 {
 369         BattFs fd1;
 370         uint8_t buf[16];
 371
 372         TRACEMSG("11: read file test\n");
 373
 374         FILE *fp = fopen(test_filename, "w+");
 375         for (int i = 0; i < PAGE_SIZE * 8; i++)
 376                 fputc(0xff, fp);
 377         KBlockFile f;
 378         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 379
 380
 381         unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 382         inode_t INODE = 0;
 383         inode_t INODE2 = 4;
 384         unsigned int MODE = 0;
 385
 386         battfs_eraseBlock(&f.b, 0);
 387         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 388         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 389         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 390         battfs_eraseBlock(&f.b, 4);
 391         battfs_writeTestBlock(&f.b, 5, INODE2, 0, PAGE_FILL, 0);
 392         battfs_writeTestBlock(&f.b, 6, INODE2, 1, PAGE_FILL, 1);
 393         battfs_writeTestBlock(&f.b, 7, INODE2, 0, PAGE_FILL, 1);
 394
 395         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 396         ASSERT(battfs_fsck(disk));
 397         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 398         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 399         ASSERT(fd1.fd.seek_pos == sizeof(buf));
 400         for (size_t i = 0; i < sizeof(buf); i++)
 401                 ASSERT(buf[i] == 0xff);
 402
 403         ASSERT(kfile_close(&fd1.fd) == 0);
 404         ASSERT(kfile_error(&fd1.fd) == 0);
 405         ASSERT(battfs_fsck(disk));
 406         ASSERT(battfs_umount(disk));
 407
 408         TRACEMSG("11: passed\n");
 409 }
 410
 411 static void readAcross(BattFsSuper *disk)
 412 {
 413         BattFs fd1;
 414
 415         TRACEMSG("12: read file test across page boundary and seek test\n");
 416
 417         FILE *fp = fopen(test_filename, "w+");
 418         for (int i = 0; i < PAGE_SIZE * 8; i++)
 419                 fputc(0xff, fp);
 420         KBlockFile f;
 421         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 422
 423         const unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 424         inode_t INODE = 0;
 425         unsigned int MODE = 0;
 426         uint8_t buf[PAGE_FILL + BATTFS_HEADER_LEN / 2];
 427
 428         battfs_eraseBlock(&f.b, 0);
 429         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 430         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 431         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 432         battfs_eraseBlock(&f.b, 4);
 433         battfs_writeTestBlock(&f.b, 5, INODE, 0, PAGE_FILL, 2);
 434         battfs_writeTestBlock(&f.b, 6, INODE, 1, PAGE_FILL, 3);
 435         battfs_writeTestBlock(&f.b, 7, INODE, 0, PAGE_FILL, 3);
 436
 437         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 438         ASSERT(battfs_fsck(disk));
 439         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 440
 441         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 442         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf));
 443         for (size_t i = 0; i < sizeof(buf); i++)
 444                 ASSERT(buf[i] == 0xff);
 445
 446         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 447         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf) * 2);
 448         for (size_t i = 0; i < sizeof(buf); i++)
 449                 ASSERT(buf[i] == 0xff);
 450
 451         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 452         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf) * 3);
 453         for (size_t i = 0; i < sizeof(buf); i++)
 454                 ASSERT(buf[i] == 0xff);
 455
 456         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == PAGE_FILL * 4 - sizeof(buf) * 3);
 457         ASSERT(fd1.fd.seek_pos == (kfile_off_t)fd1.fd.size);
 458         for (size_t i = 0; i < PAGE_FILL * 4 - sizeof(buf) * 3; i++)
 459                 ASSERT(buf[i] == 0xff);
 460
 461         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 462         ASSERT(fd1.fd.seek_pos == 0);
 463
 464         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_END) == (kfile_off_t)fd1.fd.size);
 465         ASSERT(fd1.fd.seek_pos = (kfile_off_t)fd1.fd.size);
 466
 467         ASSERT(kfile_close(&fd1.fd) == 0);
 468         ASSERT(kfile_error(&fd1.fd) == 0);
 469         ASSERT(battfs_fsck(disk));
 470         ASSERT(battfs_umount(disk));
 471
 472         TRACEMSG("12: passed\n");
 473 }
 474
 475
 476 static void writeFile(BattFsSuper *disk)
 477 {
 478         BattFs fd1;
 479         uint8_t buf[PAGE_SIZE - BATTFS_HEADER_LEN];
 480
 481         TRACEMSG("13: write file test\n");
 482
 483         FILE *fp = fopen(test_filename, "w+");
 484         for (int i = 0; i < PAGE_SIZE * 8; i++)
 485                 fputc(0xff, fp);
 486         KBlockFile f;
 487         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 488
 489
 490         unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 491         inode_t INODE = 0;
 492         inode_t INODE2 = 4;
 493         unsigned int MODE = 0;
 494
 495         battfs_eraseBlock(&f.b, 0);
 496         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 497         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 498         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 499         battfs_eraseBlock(&f.b, 4);
 500         battfs_writeTestBlock(&f.b, 5, INODE2, 0, PAGE_FILL, 0);
 501         battfs_writeTestBlock(&f.b, 6, INODE2, 1, PAGE_FILL, 1);
 502         battfs_writeTestBlock(&f.b, 7, INODE2, 0, PAGE_FILL, 1);
 503
 504         for (size_t i = 0; i < sizeof(buf); i++)
 505                 buf[i] = i;
 506
 507         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 508         ASSERT(battfs_fsck(disk));
 509         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 510         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 511         ASSERT(fd1.fd.seek_pos == sizeof(buf));
 512         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 513         ASSERT(fd1.fd.seek_pos == 0);
 514
 515         memset(buf, 0, sizeof(buf));
 516         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 517         for (size_t i = 0; i < sizeof(buf); i++)
 518                 ASSERT(buf[i] == i);
 519
 520         ASSERT(kfile_close(&fd1.fd) == 0);
 521         ASSERT(kfile_error(&fd1.fd) == 0);
 522         ASSERT(battfs_fsck(disk));
 523         ASSERT(battfs_umount(disk));
 524
 525         TRACEMSG("13: passed\n");
 526 }
 527
 528 static void writeAcross(BattFsSuper *disk)
 529 {
 530         BattFs fd1;
 531
 532         TRACEMSG("14: write file test across page boundary and seek test\n");
 533
 534         FILE *fp = fopen(test_filename, "w+");
 535         for (int i = 0; i < PAGE_SIZE * 8; i++)
 536                 fputc(0xff, fp);
 537         KBlockFile f;
 538         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 539
 540         const unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 541         inode_t INODE = 0;
 542         unsigned int MODE = 0;
 543         uint8_t buf[PAGE_FILL + BATTFS_HEADER_LEN / 2];
 544
 545         battfs_eraseBlock(&f.b, 0);
 546         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 547         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 548         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 549         battfs_eraseBlock(&f.b, 4);
 550         battfs_writeTestBlock(&f.b, 5, INODE, 0, PAGE_FILL, 2);
 551         battfs_writeTestBlock(&f.b, 6, INODE, 1, PAGE_FILL, 3);
 552         battfs_writeTestBlock(&f.b, 7, INODE, 0, PAGE_FILL, 3);
 553
 554         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 555         ASSERT(battfs_fsck(disk));
 556         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 557
 558         uint8_t val = 0;
 559         for (size_t i = 0; i < sizeof(buf); i++)
 560                 buf[i] = val++;
 561         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 562         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf));
 563
 564         for (size_t i = 0; i < sizeof(buf); i++)
 565                 buf[i] = val++;
 566         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 567         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf) * 2);
 568
 569         for (size_t i = 0; i < sizeof(buf); i++)
 570                 buf[i] = val++;
 571         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 572         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf) * 3);
 573
 574         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 575         ASSERT(fd1.fd.seek_pos == 0);
 576         val = 0;
 577
 578         memset(buf, 0, sizeof(buf));
 579         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 580         for (size_t i = 0; i < sizeof(buf); i++)
 581                 ASSERT(buf[i] == val++);
 582
 583         memset(buf, 0, sizeof(buf));
 584         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 585         for (size_t i = 0; i < sizeof(buf); i++)
 586                 ASSERT(buf[i] == val++);
 587
 588         memset(buf, 0, sizeof(buf));
 589         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 590         for (size_t i = 0; i < sizeof(buf); i++)
 591                 ASSERT(buf[i] == val++);
 592
 593         ASSERT(fd1.fd.seek_pos == (kfile_off_t)sizeof(buf) * 3);
 594
 595         ASSERT(kfile_close(&fd1.fd) == 0);
 596         ASSERT(kfile_error(&fd1.fd) == 0);
 597         ASSERT(battfs_fsck(disk));
 598         ASSERT(battfs_umount(disk));
 599
 600         TRACEMSG("14: passed\n");
 601 }
 602
 603 static void createFile(BattFsSuper *disk)
 604 {
 605         TRACEMSG("15: file creation on new disk\n");
 606
 607         FILE *fpt = fopen(test_filename, "w+");
 608         for (int i = 0; i < FILE_SIZE; i++)
 609                 fputc(0xff, fpt);
 610         KBlockFile f;
 611         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 612
 613         BattFs fd1;
 614         inode_t INODE = 0;
 615         unsigned int MODE = BATTFS_CREATE;
 616
 617         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 618         ASSERT(battfs_fsck(disk));
 619         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 620         for (int i = 0; i < FILE_SIZE / 2; i++)
 621                 ASSERT(kfile_putc(i, &fd1.fd) != EOF);
 622
 623         ASSERT(fd1.fd.seek_pos == FILE_SIZE / 2);
 624         ASSERT(fd1.fd.size == FILE_SIZE / 2);
 625         ASSERT(kfile_close(&fd1.fd) == 0);
 626         ASSERT(kfile_error(&fd1.fd) == 0);
 627         ASSERT(battfs_fsck(disk));
 628         ASSERT(battfs_umount(disk));
 629
 630         fpt = fopen(test_filename, "r+");
 631         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 632
 633         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 634         ASSERT(battfs_fsck(disk));
 635         ASSERT(battfs_fileopen(disk, &fd1, INODE, 0));
 636         ASSERT(fd1.fd.size == FILE_SIZE / 2);
 637         ASSERT(fd1.fd.seek_pos == 0);
 638
 639         uint8_t buf[FILE_SIZE / 2];
 640         memset(buf, 0, sizeof(buf));
 641         ASSERT(kfile_read(&fd1.fd, buf, FILE_SIZE / 2) == FILE_SIZE / 2);
 642
 643         for (int i = 0; i < FILE_SIZE / 2; i++)
 644                 ASSERT(buf[i] == (i & 0xff));
 645
 646         ASSERT(fd1.fd.seek_pos == FILE_SIZE / 2);
 647         ASSERT(kfile_close(&fd1.fd) == 0);
 648         ASSERT(kfile_error(&fd1.fd) == 0);
 649         ASSERT(battfs_fsck(disk));
 650         ASSERT(battfs_umount(disk));
 651
 652
 653         TRACEMSG("15: passed\n");
 654 }
 655
 656 static void multipleWrite(BattFsSuper *disk)
 657 {
 658         TRACEMSG("16: multiple write on file\n");
 659
 660         FILE *fpt = fopen(test_filename, "w+");
 661         for (int i = 0; i < FILE_SIZE; i++)
 662                 fputc(0xff, fpt);
 663         KBlockFile f;
 664         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 665
 666
 667         BattFs fd1;
 668         inode_t INODE = 0;
 669         unsigned int MODE = BATTFS_CREATE;
 670         uint8_t buf[1000];
 671
 672         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 673         ASSERT(battfs_fsck(disk));
 674         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 675
 676         int j;
 677         for (j = 1; j < 1013; j++)
 678         {
 679                 for (unsigned i = 0; i < sizeof(buf); i++)
 680                         buf[i] = j+i;
 681
 682                 ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 683                 ASSERT(fd1.fd.seek_pos == sizeof(buf));
 684                 ASSERT(fd1.fd.size == sizeof(buf));
 685                 ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 686                 memset(buf, 0, sizeof(buf));
 687                 ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 688                 ASSERT(fd1.fd.seek_pos == sizeof(buf));
 689                 for (unsigned i = 0; i < sizeof(buf); i++)
 690                         ASSERT(buf[i] == ((j+i) & 0xff));
 691                 ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 692                 ASSERT(disk->free_bytes == disk->disk_size - sizeof(buf));
 693         }
 694         ASSERT(kfile_close(&fd1.fd) == 0);
 695         ASSERT(kfile_error(&fd1.fd) == 0);
 696         ASSERT(battfs_fsck(disk));
 697         ASSERT(battfs_umount(disk));
 698
 699         fpt = fopen(test_filename, "r+");
 700         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 701
 702         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 703         ASSERT(battfs_fsck(disk));
 704         ASSERT(disk->free_bytes == disk->disk_size - sizeof(buf));
 705         ASSERT(battfs_fileopen(disk, &fd1, INODE, 0));
 706         ASSERT(fd1.fd.size == sizeof(buf));
 707         memset(buf, 0, sizeof(buf));
 708         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 709         for (unsigned i = 0; i < sizeof(buf); i++)
 710                         ASSERT(buf[i] == ((j-1+i) & 0xff));
 711         ASSERT(kfile_close(&fd1.fd) == 0);
 712         ASSERT(kfile_error(&fd1.fd) == 0);
 713         ASSERT(battfs_fsck(disk));
 714         ASSERT(battfs_umount(disk));
 715
 716
 717         TRACEMSG("16: passed\n");
 718 }
 719
 720 static void increaseFile(BattFsSuper *disk)
 721 {
 722         TRACEMSG("17: increasing dimension of a file with multiple open files.\n");
 723
 724         FILE *fpt = fopen(test_filename, "w+");
 725         for (int i = 0; i < FILE_SIZE / 10; i++)
 726                 fputc(0xff, fpt);
 727
 728         KBlockFile f;
 729         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT / 10);
 730
 731
 732         BattFs fd1,fd2;
 733         inode_t INODE1 = 1, INODE2 = 2;
 734         unsigned int MODE = BATTFS_CREATE;
 735         uint8_t buf[1000];
 736
 737         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 738         ASSERT(battfs_fsck(disk));
 739         ASSERT(battfs_fileopen(disk, &fd1, INODE1, MODE));
 740         ASSERT(battfs_fileopen(disk, &fd2, INODE2, MODE));
 741         for (unsigned i = 0; i < sizeof(buf); i++)
 742                 ASSERT(kfile_putc(i, &fd2.fd) != EOF);
 743         ASSERT(kfile_seek(&fd2.fd, 0, KSM_SEEK_SET) == 0);
 744         memset(buf, 0, sizeof(buf));
 745         ASSERT(kfile_read(&fd2.fd, buf, sizeof(buf)) == sizeof(buf));
 746
 747         for (unsigned i = 0; i < sizeof(buf); i++)
 748                 ASSERT(buf[i] == (i & 0xff));
 749         ASSERT(kfile_seek(&fd2.fd, 0, KSM_SEEK_SET) == 0);
 750
 751         for (unsigned i = 0; i < sizeof(buf); i++)
 752                 ASSERT(kfile_putc(i, &fd1.fd) != EOF);
 753
 754         memset(buf, 0, sizeof(buf));
 755         ASSERT(kfile_read(&fd2.fd, buf, sizeof(buf)) == sizeof(buf));
 756
 757         for (unsigned i = 0; i < sizeof(buf); i++)
 758                 ASSERT(buf[i] == (i & 0xff));
 759
 760         ASSERT(kfile_close(&fd1.fd) == 0);
 761         ASSERT(kfile_error(&fd1.fd) == 0);
 762         ASSERT(kfile_close(&fd2.fd) == 0);
 763         ASSERT(kfile_error(&fd2.fd) == 0);
 764         ASSERT(battfs_fsck(disk));
 765         ASSERT(battfs_umount(disk));
 766
 767         TRACEMSG("17: passed\n");
 768 }
 769
 770 static void readEOF(BattFsSuper *disk)
 771 {
 772         BattFs fd1;
 773         uint8_t buf[16];
 774
 775         TRACEMSG("18: reading over EOF test\n");
 776
 777         FILE *fp = fopen(test_filename, "w+");
 778         for (int i = 0; i < PAGE_SIZE * 8; i++)
 779                 fputc(0xff, fp);
 780         KBlockFile f;
 781         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 8);
 782
 783
 784         unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 785         inode_t INODE = 0;
 786         inode_t INODE2 = 4;
 787         unsigned int MODE = 0;
 788
 789         battfs_eraseBlock(&f.b, 0);
 790         battfs_writeTestBlock(&f.b, 1, INODE, 0, PAGE_FILL, 0);
 791         battfs_writeTestBlock(&f.b, 2, INODE, 3, PAGE_FILL, 1);
 792         battfs_writeTestBlock(&f.b, 3, INODE, 0, PAGE_FILL, 1);
 793         battfs_eraseBlock(&f.b, 4);
 794         battfs_writeTestBlock(&f.b, 5, INODE2, 0, PAGE_FILL, 0);
 795         battfs_writeTestBlock(&f.b, 6, INODE2, 1, PAGE_FILL, 1);
 796         battfs_writeTestBlock(&f.b, 7, INODE2, 0, PAGE_FILL, 1);
 797
 798         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 799         ASSERT(battfs_fsck(disk));
 800         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 801         ASSERT(kfile_seek(&fd1.fd, fd1.fd.size + 10, SEEK_SET) == fd1.fd.size + 10);
 802         ASSERT(fd1.fd.seek_pos == fd1.fd.size + 10);
 803         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == 0);
 804
 805         ASSERT(kfile_close(&fd1.fd) == 0);
 806         ASSERT(kfile_error(&fd1.fd) == 0);
 807         ASSERT(battfs_fsck(disk));
 808         ASSERT(battfs_umount(disk));
 809
 810         TRACEMSG("18: passed\n");
 811 }
 812
 813 static void writeEOF(BattFsSuper *disk)
 814 {
 815         TRACEMSG("19: writing over EOF test\n");
 816
 817         FILE *fpt = fopen(test_filename, "w+");
 818         for (int i = 0; i < FILE_SIZE / 5; i++)
 819                 fputc(0xff, fpt);
 820         KBlockFile f;
 821         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT / 5);
 822
 823         BattFs fd1;
 824         inode_t INODE = 0;
 825         unsigned int MODE = BATTFS_CREATE;
 826         uint8_t buf[FILE_SIZE / 13];
 827
 828         for (int i = 0; i < 2; i++)
 829                 buf[i] = i;
 830
 831         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 832         ASSERT(battfs_fsck(disk));
 833         disk_size_t prev_free = disk->free_bytes;
 834         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 835         ASSERT(fd1.fd.size == 0);
 836
 837         ASSERT(kfile_seek(&fd1.fd, 2, KSM_SEEK_END) == 2);
 838         ASSERT(kfile_write(&fd1.fd, buf, 2));
 839         ASSERT(fd1.fd.seek_pos == 4);
 840         ASSERT(fd1.fd.size == 4);
 841         ASSERT(disk->free_bytes == prev_free - 4);
 842         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 843         memset(buf, 0, 2);
 844         ASSERT(kfile_read(&fd1.fd, buf, 2) == 2);
 845         for (int i = 0; i < 2; i++)
 846                 ASSERT(buf[i] == 0);
 847
 848         memset(buf, 0, 2);
 849         ASSERT(kfile_read(&fd1.fd, buf, 2) == 2);
 850         for (int i = 0; i < 2; i++)
 851                 ASSERT(buf[i] == (i & 0xff));
 852
 853         ASSERT(kfile_seek(&fd1.fd, sizeof(buf), KSM_SEEK_END) == sizeof(buf) + 4);
 854         for (unsigned i = 0; i < sizeof(buf); i++)
 855                 buf[i] = i;
 856         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)));
 857         ASSERT(fd1.fd.seek_pos == sizeof(buf) * 2 + 4);
 858         ASSERT(fd1.fd.size == sizeof(buf) * 2 + 4);
 859         ASSERT(disk->free_bytes == prev_free - sizeof(buf) * 2 - 4);
 860
 861         ASSERT(kfile_seek(&fd1.fd, 0, KSM_SEEK_SET) == 0);
 862
 863         memset(buf, 0, 2);
 864         ASSERT(kfile_read(&fd1.fd, buf, 2) == 2);
 865         ASSERT(fd1.fd.seek_pos == 2);
 866         for (int i = 0; i < 2; i++)
 867                 ASSERT(buf[i] == 0);
 868
 869         memset(buf, 0, 2);
 870         ASSERT(kfile_read(&fd1.fd, buf, 2) == 2);
 871         ASSERT(fd1.fd.seek_pos == 4);
 872         for (int i = 0; i < 2; i++)
 873                 ASSERT(buf[i] == (i & 0xff));
 874
 875         memset(buf, 0, 4);
 876         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 877         ASSERT(fd1.fd.seek_pos == sizeof(buf) + 4);
 878         for (unsigned i = 0; i < sizeof(buf); i++)
 879                 ASSERT(buf[i] == 0);
 880
 881         memset(buf, 0, sizeof(buf));
 882         ASSERT(kfile_read(&fd1.fd, buf, sizeof(buf)) == sizeof(buf));
 883         for (unsigned i = 0; i < sizeof(buf); i++)
 884                 ASSERT(buf[i] == (i & 0xff));
 885
 886         ASSERT(kfile_close(&fd1.fd) == 0);
 887         ASSERT(kfile_error(&fd1.fd) == 0);
 888         ASSERT(battfs_fsck(disk));
 889         ASSERT(battfs_umount(disk));
 890
 891         TRACEMSG("19: passed\n");
 892
 893 }
 894
 895 static void endOfSpace(BattFsSuper *disk)
 896 {
 897         TRACEMSG("20: what happens when disk space is over?\n");
 898         BattFs fd1;
 899         uint8_t buf[(PAGE_SIZE - BATTFS_HEADER_LEN) * 5];
 900
 901         FILE *fp = fopen(test_filename, "w+");
 902         for (int i = 0; i < PAGE_SIZE * 4; i++)
 903                 fputc(0xff, fp);
 904         KBlockFile f;
 905         kblockfile_init(&f, fp, page_buffer, PAGE_SIZE, 4);
 906
 907         unsigned int PAGE_FILL = PAGE_SIZE - BATTFS_HEADER_LEN;
 908         inode_t INODE = 0;
 909         unsigned int MODE = BATTFS_CREATE;
 910
 911         battfs_eraseBlock(&f.b, 0);
 912         battfs_eraseBlock(&f.b, 1);
 913         battfs_eraseBlock(&f.b, 2);
 914         battfs_eraseBlock(&f.b, 3);
 915
 916         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 917         ASSERT(battfs_fsck(disk));
 918         ASSERT(battfs_fileopen(disk, &fd1, INODE, MODE));
 919         ASSERT(kfile_write(&fd1.fd, buf, sizeof(buf)) == PAGE_FILL * 4);
 920         ASSERT(fd1.fd.size == (kfile_off_t)(PAGE_FILL * 4));
 921         ASSERT(fd1.fd.seek_pos == (kfile_off_t)(PAGE_FILL * 4));
 922         ASSERT(disk->free_bytes == 0);
 923
 924         ASSERT(kfile_close(&fd1.fd) == 0);
 925         ASSERT(kfile_error(&fd1.fd) == BATTFS_DISK_SPACEOVER_ERR);
 926         ASSERT(battfs_fsck(disk));
 927         ASSERT(battfs_umount(disk));
 928
 929         TRACEMSG("20: passed\n");
 930 }
 931
 932
 933 static void multipleFilesRW(BattFsSuper *disk)
 934 {
 935         TRACEMSG("21: multiple files read/write test\n");
 936
 937         FILE *fpt = fopen(test_filename, "w+");
 938         for (int i = 0; i < FILE_SIZE; i++)
 939                 fputc(0xff, fpt);
 940         KBlockFile f;
 941         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 942
 943         #define N_FILES 10
 944         BattFs fd[N_FILES];
 945         unsigned int MODE = BATTFS_CREATE;
 946         uint32_t buf[FILE_SIZE / (4 * N_FILES * sizeof(uint32_t))];
 947
 948         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 949         ASSERT(battfs_fsck(disk));
 950         for (inode_t i = 0; i < N_FILES; i++)
 951                 ASSERT(battfs_fileopen(disk, &fd[i], i, MODE));
 952
 953         for (int i = N_FILES - 1; i >= 0; i--)
 954         {
 955                 for (uint32_t j = 0; j < countof(buf); j++)
 956                         buf[j] = j+i;
 957
 958                 ASSERT(kfile_write(&fd[i].fd, buf, sizeof(buf)) == sizeof(buf));
 959                 ASSERT(fd[i].fd.size == sizeof(buf));
 960                 ASSERT(fd[i].fd.seek_pos == sizeof(buf));
 961                 ASSERT(kfile_seek(&fd[i].fd, 0, SEEK_SET) == 0);
 962         }
 963
 964         for (inode_t i = 0; i < N_FILES; i++)
 965         {
 966                 memset(buf, 0, sizeof(buf));
 967                 ASSERT(kfile_read(&fd[i].fd, buf, sizeof(buf)) == sizeof(buf));
 968
 969                 for (uint32_t j = 0; j < countof(buf); j++)
 970                         ASSERT(buf[j] == j+i);
 971
 972                 ASSERT(fd[i].fd.size == sizeof(buf));
 973                 ASSERT(fd[i].fd.seek_pos == sizeof(buf));
 974                 ASSERT(kfile_seek(&fd[i].fd, 0, SEEK_SET) == 0);
 975         }
 976
 977         for (inode_t i = 0; i < N_FILES; i++)
 978         {
 979                 ASSERT(kfile_close(&fd[i].fd) == 0);
 980                 ASSERT(kfile_error(&fd[i].fd) == 0);
 981         }
 982
 983         ASSERT(battfs_fsck(disk));
 984         ASSERT(battfs_umount(disk));
 985
 986         fpt = fopen(test_filename, "r+");
 987         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
 988
 989         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
 990         ASSERT(battfs_fsck(disk));
 991
 992         for (inode_t i = 0; i < N_FILES; i++)
 993                 ASSERT(battfs_fileopen(disk, &fd[i], i, 0));
 994
 995         for (inode_t i = 0; i < N_FILES; i++)
 996         {
 997                 memset(buf, 0, sizeof(buf));
 998                 ASSERT(kfile_read(&fd[i].fd, buf, sizeof(buf)) == sizeof(buf));
 999
1000                 for (uint32_t j = 0; j < countof(buf); j++)
1001                         ASSERT(buf[j] == j+i);
1002
1003                 ASSERT(fd[i].fd.size == sizeof(buf));
1004                 ASSERT(fd[i].fd.seek_pos == sizeof(buf));
1005                 ASSERT(kfile_seek(&fd[i].fd, 0, SEEK_SET) == 0);
1006         }
1007
1008         for (inode_t i = 0; i < N_FILES; i++)
1009         {
1010                 ASSERT(kfile_close(&fd[i].fd) == 0);
1011                 ASSERT(kfile_error(&fd[i].fd) == 0);
1012         }
1013
1014         ASSERT(battfs_umount(disk));
1015         TRACEMSG("21: passed\n");
1016 }
1017
1018
1019 static void openAllFiles(BattFsSuper *disk)
1020 {
1021         TRACEMSG("22: try to open a lot of files\n");
1022
1023         FILE *fpt = fopen(test_filename, "w+");
1024         for (int i = 0; i < FILE_SIZE; i++)
1025                 fputc(0xff, fpt);
1026         KBlockFile f;
1027         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
1028
1029         BattFs fd[BATTFS_MAX_FILES];
1030         unsigned int MODE = BATTFS_CREATE;
1031
1032         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
1033         ASSERT(battfs_fsck(disk));
1034         for (unsigned i = 0; i < countof(fd); i++)
1035                 ASSERT(battfs_fileopen(disk, &fd[i], i, MODE));
1036
1037         ASSERT(battfs_fsck(disk));
1038
1039         for (unsigned i = 0; i < countof(fd); i++)
1040         {
1041                 ASSERT(kfile_close(&fd[i].fd) == 0);
1042                 ASSERT(kfile_error(&fd[i].fd) == 0);
1043         }
1044
1045         ASSERT(battfs_fsck(disk));
1046         ASSERT(battfs_umount(disk));
1047
1048
1049         fpt = fopen(test_filename, "r+");
1050         kblockfile_init(&f, fpt, page_buffer, PAGE_SIZE, PAGE_COUNT);
1051
1052         ASSERT(battfs_mount(disk, &f.b, page_array, sizeof(page_array)));
1053         ASSERT(battfs_fsck(disk));
1054
1055
1056         for (unsigned i = 0; i < countof(fd); i++)
1057                 ASSERT(battfs_fileopen(disk, &fd[i], i, MODE));
1058
1059         ASSERT(battfs_fsck(disk));
1060
1061         for (unsigned i = 0; i < countof(fd); i++)
1062         {
1063                 ASSERT(kfile_close(&fd[i].fd) == 0);
1064                 ASSERT(kfile_error(&fd[i].fd) == 0);
1065         }
1066
1067         ASSERT(battfs_fsck(disk));
1068         ASSERT(battfs_umount(disk));
1069         TRACEMSG("22: passed\n");
1070 }
1071
1072
1073 int battfs_testRun(void)
1074 {
1075         BattFsSuper disk;
1076
1077         diskNew(&disk);
1078         disk1File(&disk);
1079         diskHalfFile(&disk);
1080         oldSeq1(&disk);
1081         oldSeq2(&disk);
1082         oldSeq3(&disk);
1083         oldSeq2File(&disk);
1084         openFile(&disk);
1085         readFile(&disk);
1086         readAcross(&disk);
1087         writeFile(&disk);
1088         writeAcross(&disk);
1089         createFile(&disk);
1090         multipleWrite(&disk);
1091         increaseFile(&disk);
1092         readEOF(&disk);
1093         writeEOF(&disk);
1094         endOfSpace(&disk);
1095         multipleFilesRW(&disk);
1096         openAllFiles(&disk);
1097
1098         kprintf("All tests passed!\n");
1099
1100         return 0;
1101 }
1102
1103 int battfs_testSetup(void)
1104 {
1105         return 0;
1106 }
1107
1108 int battfs_testTearDown(void)
1109 {
1110         return 0;
1111 }
1112
1113 TEST_MAIN(battfs);
1114
1115 #endif // _TEST