fc-tourmaline: src/cs/drivers/drv_app/ffs/board/tcases.c comparison

comparison src/cs/drivers/drv_app/ffs/board/tcases.c @ 0:4e78acac3d88

src/{condat,cs,gpf,nucleus}: import from Selenite

author	Mychaela Falconia <falcon@freecalypso.org>
date	Fri, 16 Oct 2020 06:23:26 +0000
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:4e78acac3d88
+/******************************************************************************
+* Flash File System (ffs)
+* Idea, design and coding by Mads Meisner-Jensen, mmj@ti.com
+*
+* ffs test cases
+*
+* $Id: tcases.c 1.13.1.1.1.66 Thu, 08 Jan 2004 15:05:23 +0100 tsj $
+*
+******************************************************************************/
+#ifndef TARGET
+#include "ffs.cfg"
+#endif
+#include "ffs/ffs_api.h"  // Temp
+#include "ffs/ffs.h"
+#include "ffs/board/tffs.h"
+#include "ffs/board/core.h" // only for block/object recovery test flags
+#include "ffs/board/tdata.h"
+#include "ffs/board/ffstrace.h"
+#include "ffs/board/drv.h"
+#include "ffs/pcm.h"
+#if((TARGET == 1) || (RIV_ENV==1))
+#include "rvf/rvf_api.h"  // this include rv_general.h and rvf_target.h
+#include "rvm/rvm_use_id_list.h"
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <assert.h>
+#define LUDIR  "/europe/sweden"
+#define MFDIR "/pcm"
+// TODO: reimplement test case bfull (not valid any more).
+// TODO: Cleanup in beginning of each test case for as many cases as
+// possible, so they can be re-run.
+// TODO: Make as many cases as possible fully independent of number of
+// blocks and size of blocks in ffs.
+// TODO: Every testcase should test if it is applicable to the current
+// environment, e.g. some tests are impossible if e have a 2 or 3 block
+// file system.
+// TODO: test case for testing age functionality
+// TODO: Implement case_ren
+// TODO: Implement case_rm
+// NOTEME: DO something with test case flags (PC, IT, RND)?
+// Should we make a test case where we use case_lsr to make map of objects (
+// ensuring mapsize is prime). In a loop, we select a random object (object
+// index[rnd%size]) and perform a random operation on that object?
+// Should test data (tdata[]) be of sizes 2^n+n or Xn+n where n = 0..15
+// Should all test files have suffix ".<tdata-index>"? This would make very
+// easy data checking!
+// Add compiler define: WITH_PCM
+//unsigned char ffs_image[4*4*1024];
+//int ffs_ram_image_address = (int) &ffs_image;
+/******************************************************************************
+* Prototypes and Globals
+******************************************************************************/
+// Helper functions
+int case_cleanup(int min_space);
+int case_mk_rand_file(char *dirname, int max_size, int min_size);
+int ignore_file(char *pathname);
+int case_trace_mask(int p0, int p1);
+int case_reinit(int p0, int p1);
+int case_debug_help(int p0, int p1);
+struct object_s {
+char *name;
+struct xstat_s stat;
+};
+const struct testcase_s testcase[];
+// Benchmark (not in use yet)
+struct results_s {
+int w16B;
+int w256B;
+int w4096B;
+int rew4096B;
+int r16B;
+int r256B;
+int r4096B;
+int lfile;
+int ldir;
+int lonef;
+};
+/******************************************************************************
+* Collective Test Cases
+******************************************************************************/
+// test cases: all, alot, most, much + specific ones
+int case_all(int p0, int p1)
+{
+#if (TARGET == 1)
+UINT32 time_begin, elapsed;
+time_begin = tffs_timer_begin();
+#endif
+// We have to run test case 'init' after test case 'format'. This is
+// because 'init' test case calls test_ffs_params_get() which
+// initializes variables used in many of the testcases.
+error = test_run("ninit;format;i;world;eu;pcm;apiexc;"
+"bigf;open;rw;seek;append;ren;mopen;"
+"jnl;irec;drec;trunc;brec;stat;"
+"lu;fc;root;dirs;frd;bfull;dsync;"
+"ssym;find;ri;x;fwflags;query;octrl");
+#if (TARGET == 1)
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrAll, "Time elapsed %ds" NL, elapsed / 1000));
+#endif
+test_statistics_print();
+return error;
+// Not implemented test cases...
+return test_run("rm;pcm;");
+}
+int case_alot(int p0, int p1)
+{
+return test_run("ninit;format;ri;i;ri;world;ri;eu;ri;fwflags;ri;"
+"bigf;ri;open;ri;rw;ri;seek;ri;append;ri;ren;ri;"
+"jnl;ri;irec;ri;brec;ri;stat;ri;trunc;ri;mopen;ri;"
+"lu;ri;fc;ri;root;ri;dirs;ri;frd;ri;bfull;ri;"
+"ssym;ri;find;ri;x;ri;dsync;ri;pcm;ri;query;ri;octrl");
+}
+int case_tall(int p0, int p1)
+{
+return test_run("ninit;format;i;world;eu;fwflags;"
+"bigf;jnl;irec;drec;ren;apiexc;"
+"stat;open;rw;seek;trunc;append;octrl;"
+"lu;fc;root;dirs;frd;bfull;pcm;query;"
+"ssym;find;x;ex;bf;nb;mopen;dsync;brec");
+}
+// Ad hoc test case
+int case_test(int p0, int p1)
+{
+return test_run("format;i;world;eu;ri;mopen1;ri;fwflags;ri;"
+"bigf;ri;jnl;ri;irec;ri;drec;ri;brec;ri;pcm;ri;"
+"trunc1;ri;stat;open1;ri;rw1;ri;seek1;ri;ren;ri;"
+"lu;ri;fc;ri;root;ri;dirs;ri;frd;ri;bfull;ri;"
+"ssym;ri;find;ri;x;ri;append;ri;dsync;ri;");
+}
+extern struct dev_s dev;
+// Agressive all. Run case 'all' for dev.numblocks in the range dev.numblocks..4
+int case_aall(int p0, int p1)
+{
+char myname[20];
+int i, failed = 0;
+if (dev.numblocks * dev.blocksize > 1024*1024)
+strcpy(myname, "/ffs/b999");
+else
+strcpy(myname, "/ffs/b99");
+/** There's no need to test for i=127,126,125,124..3,2,1. So for i
+* >= 20 we progress a little faster. */
+for (i = dev.numblocks; i >= 3; i -= (i >= 20 ? i/4 : 1))
+{
+tw(tr(TR_FUNC, TrTest, "TEST aall. %d\n", i));
+ttw(ttr(TTrTest, "TEST aall. %d" NL, i));
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+sprintf(myname, "/ffs/b%d", i);
+tffs_format(myname, 0x2BAD);
+expect(error, EFFS_OK);
+failed += test_run("i;world;eu;bigf;bfull;"
+"jnl;irec;drec;brec;stat;dsync;"
+"open;rw;seek;trunc;ren;mopen;"
+"lu;fc;root;dirs;frd;append;"
+"ssym;find;ri;x");
+}
+return failed;
+}
+// This is a collection of all failing testcases to be investigated.
+int case_fail(int p0, int p1)
+{
+int result;
+const char imeifile[] = "/europe/norway/IMEI";
+switch (p0) {
+case 1:
+tw(tr(TR_FUNC, TrTestHigh,
+"remember to run case_fcontrol before this one\n"));
+// Make symlink to imeifile and try to update it
+error = tffs_symlink("/europe/imie", imeifile);
+expect(error, EFFS_ACCESS);
+error = tffs_fwrite("/europe/imie", TDATA(1));
+expect(error, EFFS_ACCESS);
+break;
+case 2:
+if (1) {
+const char bigfile[] = "/iceberg";
+int bytes_max, file_size;
+char myname[] = "/ffs/b7";
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format(myname, 0x2BAD);
+expect(error, EFFS_OK);
+ffs_query(Q_BYTES_FREE, (uint32 *) &bytes_max);
+// File the system with this huge file
+file_size = bytes_max;
+ttw(ttr(TTrTest, "Bigfile of size %d" NL, file_size));
+tw(tr(TR_FUNC, TrTestHigh, "Bigfile of size %d\n", file_size));
+error = tffs_fcreate(bigfile, (char *) tdata[TDATA_HUGE], file_size);
+expect(error, EFFS_OK);
+}
+break;
+default:
+result = 1;
+}
+return result;
+}
+// zzz to easy search ;-)
+// NOTE: Move the below tests
+extern char *tdata_huge;
+// Test that a FFS API blocking call that not is able to send a mail to FFS fails as expected and don't lock the system (it must unlock and delete the mutex).
+int case_okay(int p0, int p1)
+{
+error = tffs_fwrite("/test", tdata[TDATA_HUGE], 20);
+expect_ok(error);
+error = tffs_fread("/test", bigbuf, 20);
+expect_ok(error);
+bigbuf[20] = 0;
+tw(tr(TR_FUNC, TrTestHigh, "String '%s'\n", bigbuf));
+return EFFS_OK;
+}
+// Run testcases in a random order. Only the test cases in the test case
+// table that are marked as re-runnable, are run.
+int case_rand(int p0, int p1)
+{
+int i, n, seed, max = 0, error = 0;
+const struct testcase_s *p;
+// This is a way to activate trace at a defined test number. If rand
+// test number 134 fail it is possible to activate trace at test number
+// 133 etc. Note we have to change activate_trace_nr manual before compile.
+int activate_trace_nr = 0;
+int trace_mask = 0xFFDFF;
+// NOTE: use p1 as active_trace_nr? or make it
+p0 = (p0 == 0 ? 117 : p0); // Number of test cases to run
+p1 = (p1 == 0 ? 567 : p1); // Initial seed
+seed = p1;
+if (seed == 1) {
+; // TODO: Set seed as a variable of current time
+}
+// TODO: Initialize seed from p1.
+// First count total number of test cases
+for (p = testcase; p->name; p++)
+max++;
+tw(tr(TR_FUNC, TrTestHigh,
+"Number of available random test cases = %d\n", max));
+for (i = 0; i < p0; i++)
+{
+do {
+n = rand() % max;
+} while ((testcase[n].flags & RND) == 0);
+if ((i + 1) == activate_trace_nr) {
+#if (TARGET == 0)
+tr_init(trace_mask, 2, 0 );
+#else
+ttr_init(trace_mask);
+#endif
+tw(tr_bstat());
+}
+tw(tr(TR_FUNC, TrTest, "Nr: %d", i + 1));
+ttw(ttr(TTrTest, "Nr: %d" NL, i + 1));
+if ((error = test_run(testcase[n].name)))
+break;
+}
+if (p1 == 1)
+tw(tr(TR_FUNC, TrTestHigh, "Initial seed = %d\n", seed));
+test_statistics_print();
+return error;
+}
+/******************************************************************************
+* Population Tests
+******************************************************************************/
+int case_world(int p0, int p1)
+{
+int i;
+const char *dirs[] = { "/antarctica",    "/africa",
+"/asia",          "/europe",
+"/north-america", "/south-america",
+"/australia" };
+// Cleanup
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+tffs_remove(dirs[i]);
+}
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+error = tffs_mkdir(dirs[i]);
+expect(error, EFFS_OK);
+}
+return 0;
+}
+int case_europe(int p0, int p1)
+{
+int i;
+const char *dirs[] = { "/europe/denmark", "/europe/sweden",
+"/europe/norway",  "/europe/finland" };
+// Cleanup
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+error = tffs_remove(dirs[i]);
+}
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+error = tffs_mkdir(dirs[i]);
+expect(error, EFFS_OK);
+}
+return 0;
+}
+int case_denmark(int p0, int p1)
+{
+// Cleanup
+tffs_remove("/europe/denmark/jutland");
+tffs_remove("/europe/denmark/sealand");
+error = tffs_mkdir("/europe/denmark/jutland");
+expect(error, EFFS_OK);
+error = tffs_mkdir("/europe/denmark/sealand");
+expect(error, EFFS_OK);
+return 0;
+}
+/******************************************************************************
+* Atomic Tests
+******************************************************************************/
+int case_init(int p0, int p1)
+{
+error = tffs_initialize();
+// ignore error
+error = test_ffs_params_get();
+expect(error, EFFS_OK);
+return 0;
+}
+int case_exit(int p0, int p1)
+{
+error = tffs_exit();
+expect(error, EFFS_OK);
+return 0;
+}
+int case_only_preformat(int p0, int p1)
+{
+tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+return 0;
+}
+int case_only_format(int p0, int p1)
+{
+tffs_format("/ffs", 0x2BAD);
+expect(error, EFFS_OK);
+return 0;
+}
+int case_reset(int p0, int p1)
+{
+error = tffs_initialize();
+// ignore result
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs", 0x2BAD);
+expect(error, EFFS_OK);
+error = tffs_exit();
+expect(error, EFFS_OK);
+return 0;
+}
+int case_status(int p0, int p1)
+{
+error = test_run("lsr");
+return error;
+}
+/******************************************************************************
+* Special Tests
+******************************************************************************/
+// Test FFS with only 2 blocks in device
+int case_twob(int p0, int p1)
+{
+int space_left;
+int size, i;
+char myname[] = "/two_block99";
+// Format ffs to use only 2 block no journal file and no reserved space.
+// Make some directoryes.
+// Fill ffs allmost to the edge and try to write over the edge.
+// Read back all the files.
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs/b2j0m0", 0x2BAD);
+expect(error, EFFS_OK);
+error = test_run("i;world;eu;x");
+if(error) return 1;
+// Calculate the amount of space that is left to user data because some space
+// is used to directoryes
+space_left = dev.blocksize - (13 * 20);
+tw(tr(TR_FUNC, TrTestHigh, "Space left: %d\n", space_left));
+size = space_left;
+for(i = 0; i < 6; i++) {
+size = size/2;
+sprintf(myname, "/two_block%d", i);
+error = tffs_fwrite(myname, (char*)tdata[TDATA_HUGE],
+size >= 20 ? size - 20 : 0);
+expect(error, EFFS_OK);
+}
+error = tffs_fwrite(myname, (char*)tdata[TDATA_HUGE], space_left/5);
+expect(error, EFFS_NOSPACE);
+// 20 is the average space used to the file name + word align.
+size = space_left;
+for(i = 0; i < 6; i++) {
+size = size/2;
+sprintf(myname, "/two_block%d", i);
+error = tffs_fread(myname, bigbuf, bigbuf_size);
+expect(error, size >= 20 ? size - 20 : 0);
+}
+//error = ffs_object_control(0, OC_DEV_DEVICE, 0x080D);
+//if (error < 0) return error;
+return 0;
+}
+// Test FFS with only 3 blocks in device
+int case_threeb(int p0, int p1)
+{
+char mytest[20];
+// Format ffs to use only 3 blocks, make directoryes and run test case
+// rand <p0> number of times.
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs/b3r24", 0x2BAD);
+expect(error, EFFS_OK);
+error = test_run("i;world;eu;x");
+if (error) return 1;
+if(p0 == 0) p0 = 233;
+sprintf(mytest, "rand%d", p0);
+return test_run(mytest);
+}
+// Simulate a typical usage of ffs. We expect one part of the data will be
+// what we call 'static' data (calibration files etc) the other part is the
+// 'dynamic' data (wap, sms etc) we do also expect that they don't fill FFS
+// completely thus we have a 'free' part.
+int case_customer(int nblocks, int nloops)
+{
+int free_part = 5, static_part = 47, dynamic_part = 47;
+int free_size, static_size, dynamic_size;
+int bytes_free, bytes_max, bytes_used;
+int file_size_max, file_size_min, file_size_avg;
+int i, j, max_obj_block, num_static_files;
+char myname[] = "/ffs/bxxx/";
+char file_name[FFS_FILENAME_MAX + 1];
+char path[FFS_FILENAME_MAX * 2];
+char static_dir[] ="/READONLY";
+char dynamic_dir[] = "/rand";
+struct dir_s dir;
+if (nblocks == 0)
+nblocks = 7;
+if (nloops == 0)
+nloops = 300;
+error = tffs_preformat(0xDEAD);      expect(error, EFFS_OK);
+sprintf(myname, "/ffs/b%d", nblocks);
+error = tffs_format(myname, 0x2BAD); expect(error, EFFS_OK);
+tffs_mkdir(dynamic_dir); expect(error, EFFS_OK);
+tffs_mkdir(static_dir);  expect(error, EFFS_OK);
+ffs_query(Q_BYTES_FREE, &bytes_max);
+free_size = bytes_max * free_part / 100;
+static_size = bytes_max * static_part / 100;
+dynamic_size = bytes_max * dynamic_part / 100;
+tw(tr(TR_FUNC, TrTest, "Free:%d,%dkB. Static:%d,%dkB, Dynamic:%d,%dkB\n",
+free_part, free_size/1024, static_part, static_size/1024,
+dynamic_part, dynamic_size/1024));
+// Find max average objects per block
+max_obj_block = fs.block_files_max;
+if (max_obj_block > fs.objects_max / (dev.numblocks -1 - fs.blocks_free_min))
+max_obj_block = fs.objects_max / (dev.numblocks -1 - fs.blocks_free_min);
+tw(tr(TR_FUNC, TrTest, "Max average objects per block %d\n", max_obj_block));
+ttw(ttr(TTrTest, "Max avg obj per block %d" NL, max_obj_block));
+// Average (minimum) file size (avoid to reach block_files_max and
+// objects_max)
+file_size_avg = dev.blocksize / max_obj_block;
+ffs_query(Q_BYTES_USED, &bytes_used);
+tw(tr(TR_FUNC, TrTest, "Write static files (avg size %d)\n", file_size_avg));
+ttw(ttr(TTrTest, "avg size %d" NL, file_size_avg));
+do {
+i++;
+file_size_min = 5;
+// For each 5 file we make one huge.
+file_size_max = i % 5 ? file_size_avg * 2 : file_size_avg * 15;
+// For each 6 file we make one small.
+file_size_max = i % 6 ? file_size_max : 5;
+// Saturate, avoid to make one file that parses the total static_size
+if (file_size_max > static_size - bytes_used)
+file_size_max = file_size_min = static_size - bytes_used;
+// For each 7 file we create one dynamic (If the block is full with only
+// valid objects do we risk that this block never will be reclaimed!).
+if (i % 7)
+error = case_mk_rand_file(dynamic_dir, file_size_max, file_size_min);
+else
+error = case_mk_rand_file(static_dir, file_size_max, file_size_min);
+expect_ok(error);
+ffs_query(Q_BYTES_USED, &bytes_used);
+} while (bytes_used < static_size);
+num_static_files = tffs_opendir(static_dir, &dir);
+expect_ok(num_static_files);
+tw(tr(TR_FUNC, TrTest, "Written %d files\n", num_static_files));
+ttw(ttr(TTrTest, "Written %d files" NL, num_static_files));
+// In a loop we continue to write data until only the wanted free_part is
+// left, after that we remove half of the just created files and then write
+// again and again...
+j = 0;
+tw(tr(TR_FUNC, TrTest, "Write and remove dynamic files\n"));
+ttw(ttr(TTrTest, "Write and remove dynamic files" NL));
+for (i = 0; i < nloops; i++) {
+if (i % 10 == 0) {
+tw(tr(TR_FUNC, TrTest, "loop %d\n", i));
+ttw(ttr(TTrTest, "loop %d" NL, i));
+}
+ffs_query(Q_BYTES_FREE, &bytes_free);
+do {
+j++;
+file_size_min = 5;
+file_size_max = j % 5 ? file_size_avg * 2 : file_size_avg * 15;
+file_size_max = j % 6 ? file_size_max : 5;
+// Saturate, avoid using the free space.
+if (file_size_max > bytes_free - free_size)
+file_size_max = file_size_min = bytes_free - free_size;
+if (file_size_max < 0)
+break;
+error = case_mk_rand_file(dynamic_dir, file_size_max, file_size_min);
+// NOTE it is very difficult to avoid EFFS_FSFULL because cleanup will
+// sometimes only remove the big files thus there will exist a lot of small
+// that use all the inodes.
+if (error == EFFS_FSFULL) {
+tw(tr(TR_FUNC, TrTest, "Warning no free inodes\n"));
+ttw(ttr(TTrTest, "Warning no free inodes" NL));
+error = case_cleanup(free_size + dynamic_size);
+}
+else
+expect_ok(error);
+ffs_query(Q_BYTES_FREE, &bytes_free);
+} while (bytes_free > free_size);
+error = case_cleanup(free_size + dynamic_size / 2);
+expect_ok(error);
+}
+error = case_reinit(0, 0);
+expect(EFFS_OK, error);
+tw(tr(TR_FUNC, TrTest, "Verify all files\n"));
+ttw(ttr(TTrTest, "Verify all files" NL));
+for (i = 0; i < 2; i++) {
+if (i == 0) {
+error = tffs_opendir(static_dir, &dir);
+expect_eq(error, num_static_files);
+}
+else {
+error = tffs_opendir(dynamic_dir, &dir);
+expect_ok(error);
+}
+while ((error = tffs_readdir(&dir, file_name, sizeof(file_name))) > 0) {
+if (i == 0)
+strcpy(path, static_dir);
+else
+strcpy(path, dynamic_dir);
+strcat(path, "/");
+strcat(path, file_name);
+error = tffs_stat(path, &stat);
+expect_ok(error);
+error = test_expect_file(path, tdata[TDATA_HUGE], stat.size);
+if (error) return 1;
+}
+}
+test_statistics_print();
+return 0;
+}
+// TODO cleanup this test. Use stat and verify some of the files etc.
+// Used to test ConQuest issue FFS_FIX-11368 We fill FFS with a lot of small
+// files. Then by turn remove some files and write new files, always very
+// close to max avaible bytes.
+// Note the below test is not able to run in big configuration because it
+// creates a lot of small files thus we reach EFFS_FSFULL 'out of inodes'
+int case_ffull(int p0, int p1)
+{
+int error, i, bytes_free, file_size, max_write_size = 1000;
+char myname[] = "/ffs/bxxx/";
+if (p0 == 0)
+p0 = 100; // Default 100 loops
+if (p1 == 0 || p1 > 999)
+p1 = 3;   // Default run in 3 blocks
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+sprintf(myname, "/ffs/b%d", p1);
+error = tffs_format(myname, 0x2BAD);
+expect(error, EFFS_OK);
+tffs_mkdir("/rand");
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTest, "Fill it with files until it fails\n"));
+ttw(ttr(TTrTest, "Fill it with files until it fails" NL));
+// We have to avoid too many small files or else do we reach objects_max
+ffs_query(Q_BYTES_FREE, &bytes_free);
+max_write_size = bytes_free / fs.objects_max * 2.5;
+do {
+error = case_mk_rand_file("/rand", max_write_size, 0);
+} while (error >= 0 );
+tw(tr(TR_FUNC, TrTest, "Fill done (%d)\n" ,error));
+ttw(ttr(TTrTest, "Fill done (%d)" NL, error));
+expect(error, EFFS_NOSPACE);  // Now are we sure that it is full
+tw(tr(TR_FUNC, TrTest, "Cleanup and fill again \n"));
+for (i = 0; i < (1 + p0); i++) {
+tw(tr(TR_FUNC, TrTestHigh, "Loop %d \n", i + 1));
+ttw(ttr(TTrTest, "Loop %d" NL, i + 1));
+tw(tr_bstat());
+error = case_cleanup(max_write_size * 3);
+tw(tr_bstat());
+do {
+ffs_query(Q_BYTES_FREE, &bytes_free);
+// Saturate size
+file_size = bytes_free > max_write_size ? max_write_size :bytes_free;
+// Query BYTES_FREE don't count the below data use.
+//file_size -= (FFS_FILENAME_MAX + 1 + dev.atomsize);
+if (file_size < 0)
+break;
+error = case_mk_rand_file("/rand", file_size - (FFS_FILENAME_MAX+1), 0);
+if (error == EFFS_FSFULL) { // Out of inodes
+error = case_cleanup(max_write_size * 6);
+// Create bigger files to avoid '-11', auto fit :-)
+max_write_size *= 1.1;  // Add 10%
+tw(tr(TR_FUNC, TrTestHigh, "Out of inodes, write size: %d \n",
+max_write_size));
+continue;
+}
+expect_ok(error);
+} while (file_size != bytes_free);
+}
+tw(tr(TR_FUNC, TrTest, "Test finish (%d) \n", error));
+ttw(ttr(TTrTest, "Test finish (%d)" NL, error));
+if (error >= 0)
+return EFFS_OK;
+return error;
+}
+int case_rivtype(int p0, int p1)
+{
+// Use the compiler to test if the types are correctly defined. We don't
+// need to run this test just make a compilation.
+T_FFS_OPEN_FLAGS flags = FFS_O_RDONLY;
+T_FFS_SIZE size = 20;
+T_FFS_RET error = -10;
+T_FFS_WHENCE whence = FFS_SEEK_SET;
+T_FFS_STAT stat;
+T_FFS_DIR dir;
+T_FFS_FD fd = FFS_FD_OFFSET;
+T_RV_RETURN callback;
+T_FFS_FILE_CNF confirm;
+T_FFS_OBJECT_TYPE objt = OT_FILE;
+// Use the defined variables to avoid the boring warning: unused
+// variable 'xx'
+if (flags != FFS_O_RDONLY)  return 1;
+if (size != 20)             return 1;
+if (error != -10)           return 1;
+if (whence != FFS_SEEK_SET) return 1;
+if (fd != FFS_FD_OFFSET)    return 1;
+if (objt != OT_FILE)        return 1;
+stat.type = 1;
+if (stat.type != 1) return 1;
+dir.this = 5;
+if (dir.this != 5) return 1;
+callback.addr_id = 3;
+if (callback.addr_id != 3) return 1;
+confirm.error = -1;
+if (confirm.error != -1) return 1;
+return 0;
+}
+/******************************************************************************
+* Pseudo Tests
+******************************************************************************/
+// Recursively read objects in directory. Does NOT check for buffer
+// overflow!
+int case_dir_list(char *dirname, struct object_s **pplist, char **ppnames)
+{
+struct object_s *plist, *plist_start, *plist_end;
+char pathname[6 * 20];
+struct dir_s dir;
+char *pnames, *pn;
+int i, pathlen;
+//tw(tr(TR_BEGIN, TrTestHigh, "dir_list('%s', %d, 0x%x)\n",
+//      dirname, (int)*pplist/sizeof(struct object_s), *ppnames));
+plist_start = plist = *pplist;
+pnames = *ppnames;
+strcpy(pathname, dirname);
+pathlen = strlen(pathname);
+// remove trailing slash. It is tiring to handle the root directory
+// differently from other directories. In a future ffs revision, this
+// trailing slash should be allowed!
+if (pathname[pathlen - 1] == '/') {
+pathname[pathlen - 1] = 0;
+pathlen--;
+}
+if (strlen(pathname) == 0)
+error = tffs_opendir("/", &dir);
+else
+error = tffs_opendir(pathname, &dir);
+expect_ok(error);
+pn = pathname + strlen(pathname);
+*pn++ = '/';
+*pn = 0;
+error = 1;
+for (i = 0; (error = tffs_readdir(&dir, pn, 21)) > 0; i++)
+{
+error = tffs_xlstat(pathname, &plist->stat);
+expect(error, EFFS_OK);
+// Copy full object pathname to buffer, working downwards.
+pnames -= strlen(pathname) + 1;
+// Check for buffer overflow (if pnames <= plist)
+expect_gt((int) pnames, (int) plist);
+strcpy(pnames, pathname);
+plist->name = pnames;
+plist++;
+}
+*pplist = plist;
+*ppnames = pnames;
+// For each directory in the retrieved list, recurse.
+plist_end = plist;
+for (plist = plist_start; plist < plist_end; plist++) {
+if (plist->stat.type == OT_DIR)
+i += case_dir_list(plist->name, pplist, ppnames);
+}
+// tw(tr(TR_END, TrTestHigh, "} %d\n", i));
+return i;
+}
+int case_find(int p0, int p1)
+{
+struct object_s *plist, *plist_start;
+char *pnames, *pnames_start;
+int n, names_used, list_used;
+plist  = plist_start  = (struct object_s *) bigbuf;
+pnames = pnames_start = bigbuf + bigbuf_size;
+n = case_dir_list("/", &plist, &pnames);
+list_used = n * sizeof(struct object_s);
+names_used = pnames_start - pnames;
+tw(tr(TR_FUNC, TrTestHigh, "Buffer space used: %d + %d = %d\n",
+list_used, names_used, list_used + names_used));
+ttw(ttr(TTrTest, "Buffer space used: %d + %d = %d" NL,
+list_used, names_used, list_used + names_used));
+return 0;
+}
+// TODO: We should accumulate all stat.space and check it vs. the number of
+// bytes used!
+int case_lsr(int p0, int p1)
+{
+struct object_s *plist, *plist_start;
+char *pnames, *pnames_start;
+char of[3];
+int i, n;
+plist  = plist_start  = (struct object_s *) bigbuf;
+pnames = pnames_start = bigbuf + bigbuf_size;
+n = case_dir_list("/", &plist, &pnames);
+tw(tr(TR_FUNC, TrTestHigh, "Total %d objects.\n", n));
+ttw(ttr(TTrTest, "Total %d objects" NL, n));
+plist = plist_start;
+for (i = 0; i < n; i++, plist++) {
+strcpy(of, "  ");
+switch (plist->stat.type) {
+case OT_FILE: of[0] = ' '; break;
+case OT_DIR:  of[0] = 'd'; break;
+case OT_LINK: of[0] = 'l'; break;
+}
+if (plist->stat.flags & OF_READONLY)
+of[1] = 'r';
+#if (TARGET == 0)
+printf("%3d: %s %3d %2d/%04X (%4d,%4d) %5d %s\n",
+i, of,
+plist->stat.inode, plist->stat.block,
+plist->stat.location, plist->stat.sequence, plist->stat.updates,
+plist->stat.size, &plist->name[1]);
+#else
+ttw(ttr(TTrTest, "%3d: %s %3d %2d/%04X (%4d,%4d) %5d %s" NL,
+i, of,
+plist->stat.inode, plist->stat.block,
+plist->stat.location, plist->stat.sequence, plist->stat.updates,
+plist->stat.size, &plist->name[1]));
+#endif
+}
+return 0;
+}
+/******************************************************************************
+* Normal Tests
+******************************************************************************/
+int case_format(int p0, int p1)
+{
+error = tffs_preformat(0xD00D);
+expect(error, EFFS_INVALID);
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs/", 0xDEAD);
+expect(error, EFFS_INVALID);
+error = tffs_format("ffs", 0x2BAD);
+expect(error, EFFS_BADNAME);
+error = tffs_format("", 0x2BAD);
+expect(error, EFFS_BADNAME);
+error = tffs_format("/", 0x2BAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs", 0x2BAD);
+expect(error, EFFS_NOPREFORMAT);
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format(0, 0x2BAD);
+//error = tffs_format("/ffs/i256o128", 0x2BAD);
+expect(error, EFFS_OK);
+return 0;
+}
+// Test that it is illegal to modify root inode as if it was a normal file
+// or directory
+int case_root(int p0, int p1)
+{
+error = tffs_opendir("/", &dir);
+expect_ok(error);
+error = tffs_fcreate("/", "foo", 3);
+expect(error, EFFS_EXISTS);
+error = tffs_fupdate("/", "bar", 3);
+expect(error, EFFS_NOTAFILE);
+error = tffs_fwrite("/", "foo", 3);
+expect(error, EFFS_NOTAFILE);
+error = tffs_remove("/");
+expect(error, EFFS_ACCESS);
+return 0;
+}
+// Test object lookup, object names etc.
+int case_lookup(int p0, int p1)
+{
+// Swedish Provinces: Blekinge, Smaaland, Halland, Vaermland, Dalarna,
+// Dalsland, Gotland, Gaestrikland, Haelsingland, Bohuslaen,
+// Haerjedalen, Jaemtland, Lappland, Medelpad, Norrbotten, Naerke,
+// Soedermanland, Uppland, Vaesterbotten
+// Smaaland Cities: Vetlanda, Bodafors, Rottne, Ljungby, Nybro,
+// Hultsfred, Oskarshamn, Vimmerby, Hyltebruk, Joenkoeping, Vaexjoe
+tffs_mkdir("/europe");
+tffs_mkdir("/europe/sweden");
+// test init
+error = tffs_mkdir(LUDIR "/Smaaland");
+expect(error, EFFS_OK);
+// test BAD_FILENAME
+error = tffs_fcreate("", TDATA(0));
+expect(error, EFFS_BADNAME);
+// test EFFS_EXISTS
+error = tffs_fcreate(LUDIR "/Smaaland/vetlanda", TDATA(0));
+expect(error, EFFS_OK);
+error = tffs_fcreate(LUDIR "/Smaaland/vetlanda", TDATA(0));
+expect(error, EFFS_EXISTS);
+error = tffs_mkdir(LUDIR "/Smaaland");
+expect(error, EFFS_EXISTS);
+error = tffs_fwrite(LUDIR "/Smaaland/vetlanda", TDATA(1));
+expect(error, EFFS_OK);
+// test EFFS_BADNAME
+error = tffs_fcreate(LUDIR "/Smaaland/A_Zaz.0+9-7!", TDATA(2));
+expect(error, EFFS_BADNAME);
+error = tffs_fcreate(LUDIR "/Smaaland/A_Zaz.0+9-7#%$", TDATA(2));
+expect(error, EFFS_OK);
+// test ending slash
+error = tffs_mkdir(LUDIR "/Smaaland/Vaexjoe/");
+expect(error, EFFS_NOTADIR);
+error = tffs_fcreate(LUDIR "/Smaaland/Vaexjoe/", TDATA(3));
+expect(error, EFFS_NOTADIR);
+// test EFFS_NAMETOOLONG
+error = tffs_fcreate(LUDIR "/Smaaland/Hultsfred-is-21-chars", TDATA(4));
+expect(error, EFFS_NAMETOOLONG);
+error = tffs_fcreate(LUDIR "/Smaaland/Bodafors-is-20-chars", TDATA(4));
+expect(error, EFFS_OK);
+error = tffs_mkdir(LUDIR "/Vaermland-is-21-chars");
+expect(error, EFFS_NAMETOOLONG);
+error = tffs_mkdir(LUDIR "/Dalsland-is-20-chars");
+expect(error, EFFS_OK);
+// test EFFS_NOTADIR
+error = tffs_mkdir(LUDIR "/DontMakeSeveral/DirsAt/TheSameTime");
+expect(error, EFFS_NOTADIR);
+error = tffs_fread(LUDIR "/Lappland/Bodafors-is-20-chars", bigbuf, 1024);
+tw(tr(TR_END, TrApi, "} %d\n", error)); // Avoid wrong indent
+expect(error, EFFS_NOTADIR);
+error = tffs_fread(LUDIR "/Lappland/", bigbuf, 1024);
+tw(tr(TR_END, TrApi, "} %d\n", error)); // Avoid wrong indent
+expect(error, EFFS_NOTADIR);
+error = tffs_fread(LUDIR "/Smaaland/Bodafors", TDATA(4));
+tw(tr(TR_END, TrApi, "} %d\n", error)); // Avoid wrong indent
+expect(error, EFFS_NOTFOUND);
+// test EFFS_PATHTOODEEP
+error = tffs_mkdir(LUDIR "/Gotland"); // 3. level
+expect(error, EFFS_OK);
+error = tffs_mkdir(LUDIR "/Gotland/Visby"); // 4. level
+expect(error, EFFS_OK);
+error = tffs_mkdir(LUDIR "/Gotland/Visby/level5"); // 5. level
+expect(error, EFFS_OK);
+error = tffs_mkdir(LUDIR "/Gotland/Visby/level5/level6"); // 6. level
+expect(error, EFFS_OK);
+error = tffs_mkdir(LUDIR "/Gotland/Visby/level5/level6/level7"); // 7. level
+expect(error, EFFS_PATHTOODEEP);
+error = tffs_fcreate(LUDIR "/Gotland/Visby/level5/level6/level7",
+TDATA(5)); // 7. level
+expect(error, EFFS_PATHTOODEEP);
+// final checks
+error = test_expect_file(LUDIR "/Smaaland/vetlanda", TDATA(1));
+if (error) return 1;
+error = test_expect_file(LUDIR "/Smaaland/Bodafors-is-20-chars", TDATA(4));
+if (error) return 1;
+error = tffs_opendir(LUDIR "/Dalsland-is-20-chars", &dir);
+expect_ok(error);
+error = tffs_opendir(LUDIR "/Gotland/Visby/level5/level6", &dir);
+expect_ok(error);
+// cleanup
+error = tffs_remove(LUDIR "/Smaaland/A_Zaz.0+9-7");
+return 0;
+}
+// Test fcontrol and read-only semantics. TODO: We still need to perform
+// same tests on a dir and a symlink and thru a symlink.
+int case_fcontrol(int p0, int p1)
+{
+struct ffs_state_s old, new;
+const char rofile[]   = "/europe/norway/rofile";
+const char imeifile[] = "/europe/norway/IMEI";
+fd_t fdi;
+// Cleanup
+tffs_remove(rofile);
+tffs_remove("/europe/norway");
+tffs_remove("/europe");
+// Initialize
+error = tffs_mkdir("/europe");
+error = tffs_mkdir("/europe/norway");
+error = tffs_fcreate(rofile, TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_stat(rofile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, 0);
+test_ffs_state_get(&old);
+// set read-only flag
+error = tffs_fcontrol(rofile, OC_FLAGS, OF_READONLY);
+expect(error, EFFS_OK);
+error = tffs_stat(rofile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, OF_READONLY);
+test_ffs_state_get(&new);
+expect_eq(new.objects_total, old.objects_total);
+expect_ne(new.inodes_used,  old.inodes_used);
+test_ffs_state_copy(&old, &new);
+// Set illegal flags. Try to fupdate file. Then try to set read-only
+// flag again.
+error = tffs_fcontrol(rofile, OC_FLAGS, 1<<0);
+expect(error, EFFS_INVALID);
+error = tffs_fcontrol(rofile, OC_FLAGS, 1<<3);
+expect(error, EFFS_INVALID);
+error = tffs_fcontrol(rofile, OC_FLAGS, 1<<5);
+expect(error, EFFS_INVALID);
+error = tffs_fcontrol(rofile, OC_FLAGS, 1<<6);
+expect(error, EFFS_INVALID);
+error = tffs_fupdate(rofile, TDATA(3));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/europe/norway/tease", TDATA(2));
+expect(error, EFFS_OK);
+tffs_remove("/europe/norway/tease");
+error = tffs_fcontrol(rofile, OC_FLAGS, OF_READONLY);
+expect(error, EFFS_OK);
+error = tffs_stat(rofile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, OF_READONLY);
+test_ffs_state_get(&new);
+expect_eq(new.objects_total, old.objects_total);
+expect_ne(new.inodes_used,  old.inodes_used);
+test_ffs_state_copy(&old, &new);
+// clear read-only flag (this works because ffs_is_modifiable() by
+// default returns true for all objects except for object names ending
+// in "IMEI".
+error = tffs_fcontrol(rofile, OC_FLAGS, 0);
+expect(error, EFFS_OK);
+error = tffs_stat(rofile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, 0);
+test_ffs_state_get(&new);
+expect_eq(new.objects_total, old.objects_total);
+expect_ne(new.inodes_used,  old.inodes_used);
+test_ffs_state_copy(&old, &new);
+// Set read-only flag (again)
+error = tffs_fcontrol(rofile, OC_FLAGS, OF_READONLY);
+expect(error, EFFS_OK);
+error = tffs_stat(rofile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, OF_READONLY);
+test_ffs_state_get(&new);
+expect_eq(new.objects_total, old.objects_total);
+expect_ne(new.inodes_used,  old.inodes_used);
+test_ffs_state_copy(&old, &new);
+// Set read-only flag of IMEI file
+error = tffs_fcreate(imeifile, TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_stat(imeifile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, 0);
+error = tffs_fcontrol(imeifile, OC_FLAGS, OF_READONLY);
+expect(error, EFFS_OK);
+error = tffs_stat(imeifile, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.flags, OF_READONLY);
+test_ffs_state_get(&new);
+expect_eq(new.objects_total, old.objects_total + 1);
+expect_ne(new.inodes_used,  old.inodes_used);
+test_ffs_state_copy(&old, &new);
+// Try to remove, fupdate, fwrite and fcontrol IMEI file.
+error = tffs_remove(imeifile);
+expect(error, EFFS_ACCESS);
+error = tffs_fupdate(imeifile, TDATA(0));
+expect(error, EFFS_ACCESS);
+error = tffs_fwrite(imeifile, TDATA(0));
+expect(error, EFFS_ACCESS);
+error = tffs_fcontrol(imeifile, OC_FLAGS, 0);
+expect(error, EFFS_ACCESS);
+// Try to open IMEI file in write-only and read-only
+fdi = tffs_open(imeifile, FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, EFFS_ACCESS);
+fdi = tffs_open(imeifile, FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+return 0;
+}
+// Test symlink functionality of simple symlink implementation.
+// Fixme: add remove file through symlink, stat a dir through a symlink.
+int case_ssym(int p0, int p1)
+{
+int size;
+fd_t fdi;
+// two links, read files thru links
+// link to link to file, open file
+// link to non-valid object
+//
+// make three test files, a link to each of these, one link to dir, one
+// link to non-existing object, one link to link to file
+tffs_mkdir("/europe");
+tffs_mkdir("/europe/denmark");
+error = tffs_fwrite("/europe/denmark/aalborg", TDATA(1));
+expect(error, EFFS_OK);
+error = tffs_symlink("/europe/aal", "/europe/denmark/aalborg");
+expect(error, EFFS_OK);
+error = tffs_symlink("/dk", "/europe/denmark");
+expect(error, EFFS_OK);
+error = tffs_fwrite("/europe/denmark/aarhus", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_symlink("/europe/aar", "/europe/denmark/aarhus");
+expect(error, EFFS_OK);
+error = tffs_symlink("/europe/se", "/europe/non-existing");
+expect(error, EFFS_OK);
+error = tffs_fwrite("/europe/denmark/billund", TDATA(3));
+expect(error, EFFS_OK);
+error = tffs_symlink("/europe/bil", "/europe/denmark/billund");
+expect(error, EFFS_OK);
+error = tffs_symlink("/lego", "/europe/bil");
+expect(error, EFFS_OK);
+error = tffs_fwrite("/europe/denmark/norresundby", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_symlink("/europe/nor", "/europe/denmark/norresundby");
+expect(error, EFFS_OK);
+// Test link to dir
+error = tffs_opendir("/dk", &dir);
+expect(error, EFFS_NOTAFILE); // TODO: strange error!
+error = tffs_stat("/dk", &stat);
+expect(error, EFFS_NOTAFILE); // TODO: strange error!
+error = tffs_linkstat("/dk", &stat);
+expect(error, EFFS_OK);
+// Test link to link to file
+error = tffs_stat("/lego", &stat);
+expect(error, EFFS_NOTAFILE); // TODO: strange error?!
+error = tffs_linkstat("/lego", &stat);
+expect(error, EFFS_OK);
+error = tffs_fread("/lego", bigbuf, bigbuf_size);
+tw(tr(TR_END, TrApi, "} %d\n", error));  // Avoid wrong indent
+expect(error, EFFS_NOTAFILE);
+// Test link to non-existing object
+error = tffs_opendir("/europe/se", &dir);
+expect(error, EFFS_NOTFOUND);
+error = tffs_stat("/europe/se", &stat);
+expect(error, EFFS_NOTFOUND);
+error = tffs_linkstat("/europe/se", &stat);
+expect(error, EFFS_OK);
+// Read files through links
+error = test_expect_file("/europe/aal", TDATA(1));
+if (error) return 1;
+error = test_expect_file("/europe/aar", TDATA(2));
+if (error) return 1;
+error = test_expect_file("/europe/bil", TDATA(3));
+if (error) return 1;
+// Write files through links
+error = tffs_fwrite("/europe/aal", TDATA(3));
+expect(error, EFFS_OK);
+error = tffs_fupdate("/europe/aar", TDATA(4));
+expect(error, EFFS_OK);
+error = tffs_fupdate("/europe/bil", TDATA(5));
+expect(error, EFFS_OK);
+// Open file and write and read files through links
+fdi = tffs_open("/europe/nor", FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 50);
+expect(size, 50);
+error = tffs_close(fdi);
+expect(error, 0);
+fdi = tffs_open("/europe/nor", FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_read(fdi, bigbuf, 62);
+expect(size, 50);
+error = test_expect_data((char*)tdata[TDATA_HUGE], bigbuf, 50);
+if (error) return 1;
+error = tffs_close(fdi);
+expect(error, 0);
+// remove "lego" link, recreate it to link to "billund", read file data
+// through link, re-write file data through link
+error = tffs_symlink("/lego", "/europe/denmark/billund");
+expect(error, EFFS_NOTAFILE); // TODO: strange error?!
+error = tffs_fupdate("/lego", "/europe/denmark/billund",
+strlen("/europe/denmark/billund"));
+expect(error, EFFS_NOTAFILE);
+error = tffs_remove("/lego");
+expect(error, EFFS_OK);
+error = tffs_symlink("/lego", "/europe/denmark/billund");
+expect(error, EFFS_OK);
+error = test_expect_file("/lego", TDATA(5));
+if (error) return 1;
+error = tffs_fupdate("/lego", TDATA(2));
+expect(error, EFFS_OK);
+// Re-Read files through links
+error = test_expect_file("/europe/aal", TDATA(3));
+if (error) return 1;
+error = test_expect_file("/europe/aar", TDATA(4));
+if (error) return 1;
+error = test_expect_file("/europe/bil", TDATA(2));
+if (error) return 1;
+// Clean up
+error = tffs_remove("/europe/aal");
+expect(error, EFFS_OK);
+error = tffs_remove("/dk");
+expect(error, EFFS_OK);
+error = tffs_remove("/europe/aar");
+expect(error, EFFS_OK);
+error = tffs_remove("/europe/se");
+expect(error, EFFS_OK);
+error = tffs_remove("/europe/bil");
+expect(error, EFFS_OK);
+error = tffs_remove("/lego");
+expect(error, EFFS_OK);
+error = tffs_remove("/europe/nor");
+expect(error, EFFS_OK);
+return 0;
+}
+// Test symlink functionality of full symlink implementation
+int case_fsym(int p0, int p1)
+{
+fd_t fdi;
+// make relative link to directory, stat link and directory
+error = tffs_symlink("/sa", "/south-america"); // relative link
+expect(error, EFFS_OK);
+error = tffs_linkstat("/sa", &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.type, OT_LINK);
+error = tffs_stat("/sa", &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.type, OT_DIR);
+// create directory thru a symlink
+error = tffs_mkdir("/sa/brazil");
+expect(error, EFFS_OK);
+error = tffs_symlink("/br.ba", "/brazil/buenos-aires"); // relative link
+expect(error, EFFS_OK);
+// create file via symlink, stat the new file
+error = tffs_fcreate("/sa/brazil/buenos-aires", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_stat("/sa/br.ba", &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.type, OT_FILE);
+fdi = tffs_open("/sa/peru", FFS_O_WRONLY | FFS_O_TRUNC |
+FFS_O_APPEND | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_close(fdi);
+expect(error, 0);
+// create file thru a symlink, stat the new file. Will this work?
+error = tffs_symlink("/br.br", "/brazil/brasilia"); // relative link
+expect(error, EFFS_OK);
+error = tffs_fcreate("/sa/br.br", TDATA(3)); // ???
+expect(error, EFFS_OK);
+error = tffs_stat("/sa/br.br", &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.type, OT_FILE);
+// Create symlink that is a link to absolute link path
+error = tffs_symlink("/south-america/cape-horn", "/sa/ar"); // absolute link
+expect(error, EFFS_OK);
+error = tffs_fcreate("/south-america/argentina", TDATA(0));
+expect(error, EFFS_OK);
+error = tffs_symlink("/sa/ar", "/south-america/argentina");
+expect(error, EFFS_OK);
+// TODO: Test very deep path
+// TODO: Test circular link
+// TODO: Test if ending slash is allowed on dirs and symlinks
+tw(tr(TR_FUNC, TrTest, "WARNING: Test case not implemented!\n"));
+ttw(str(TTrTest, "Test case not implemented!" NL));
+return 0;
+}
+// Check every combination of name length and data size within the device
+// atomsize,
+int case_fread(int p0, int p1)
+{
+const char fullname[] = "123456789ABCDEF0123456789ABCDEF";
+int i, j, dirlen, mysize;
+char *mydata;
+char myname[20+20+32] = "/australia/f";
+case_cleanup(0x11 * param.atomsize * param.atomsize);
+tffs_mkdir("/australia");
+mydata = (char *) tdata[TDATA_HUGE];
+dirlen = strlen(myname);
+for (j = 0; j < param.atomsize; j++) {
+mysize = j * 0x11 /* + 0x100 */;
+ttw(ttr(TTrTest, "frd: size = %x" NL, mysize));
+tw(tr(TR_FUNC, TrTestHigh, "frd: size = %x\n", mysize));
+// remove files
+for (i = 0; i < param.atomsize; i++) {
+strncpy(&myname[dirlen], fullname, i);
+myname[dirlen + i] = 0;
+error = tffs_remove(myname);
+}
+// fcreate files with varying name lengths but same alignment.
+for (i = 0; i < param.atomsize; i++) {
+strncpy(&myname[dirlen], fullname, i);
+myname[dirlen + i] = 0;
+error = tffs_fwrite(myname, mydata, mysize);
+expect(error, EFFS_OK);
+}
+// Now check all the files written
+for (i = 0; i < param.atomsize; i++) {
+strncpy(&myname[dirlen], fullname, i);
+myname[dirlen + i] = 0;
+//tw(tr(TR_FUNC, TrTestHigh, "frd: txf('f...', %x, %d)\n",
+//      mydata, mysize));
+error = test_expect_file(myname, mydata, mysize);
+if (error) return 1;
+}
+mydata += 0x10;
+}
+for (i = 0; i < param.atomsize; i++) {
+strncpy(&myname[dirlen], fullname, i);
+myname[dirlen + i] = 0;
+error = tffs_remove(myname);
+expect(error, EFFS_OK);
+}
+return 0;
+}
+/******************************************************************************
+* Non-finished
+******************************************************************************/
+// Test Directories
+int case_dirs(int p0, int p1)
+{
+// remove empty dir, non-empty dir
+// open/readdir empty dir, non-empty dir
+char name[21];
+int i, j;
+struct dir_s dir[3];
+const char *names[3][5] = {
+{ "china",    "japan",    "korea", "india", 0 },
+{ "bombay",   "newdelhi", 0,       0,       0 },
+{ "hongkong", "shanghai", "hk",    0,       0 }
+};
+// Cleanup
+tffs_mkdir("/asia");
+tffs_remove("/asia/india/bombay");
+tffs_remove("/asia/india/newdelhi");
+tffs_remove("/asia/india");
+error = tffs_mkdir("/asia/china");
+expect(error, EFFS_OK);
+error = tffs_mkdir("/asia/china/beijing");
+expect(error, EFFS_OK);
+error = tffs_mkdir("/asia/china/hongkong");
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/china/hongkong/hkfile1", TDATA(1));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/china/shanghai", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_symlink("/asia/china/hk", "/asia/china/hongkong");
+expect(error, EFFS_OK);
+error = tffs_mkdir("/asia/japan");
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/thailand", TDATA(0));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/korea", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/japan/tokyo", TDATA(3));
+expect(error, EFFS_OK);
+error = tffs_fupdate("/asia/japan/tokyo", TDATA(4));
+expect(error, EFFS_OK);
+error = tffs_mkdir("/asia/india");
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/india/bombay", TDATA(0));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/india/newdelhi", TDATA(1));
+expect(error, EFFS_OK);
+error = tffs_fcreate("/asia/india/calcutta", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_opendir("/asia", &dir[0]);
+expect(error, 5);
+error = tffs_opendir("/asia/india", &dir[1]);
+expect(error, 3);
+error = tffs_opendir("/asia/china", &dir[2]);
+expect(error, 4);
+// remove first, middle and last entry in a dir
+error = tffs_remove("/asia/china/beijing");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/thailand");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/india/calcutta");
+expect(error, EFFS_OK);
+for (j = 0; j < 5; j++) {
+for (i = 0; i < 3; i++) {
+error = tffs_readdir(&dir[i], name, 21);
+if (names[i][j] == NULL) {
+expect(error, EFFS_OK);
+}
+else {
+expect_gt(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestHigh, "dir[%d]: %10s, expected: %s\n",
+i, name, names[i][j]));
+test_expect_data(name, TDATA_STRING(names[i][j]));
+}
+}
+}
+error = tffs_remove("/asia/china");
+expect(error, EFFS_DIRNOTEMPTY);
+error = tffs_remove("/asia/china/hongkong");
+expect(error, EFFS_DIRNOTEMPTY);
+error = tffs_remove("/asia/china/hongkong/hkfile1");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/china/shanghai");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/china/hk");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/china");
+expect(error, EFFS_DIRNOTEMPTY);
+error = tffs_remove("/asia/china/hongkong");
+expect(error, EFFS_OK);
+error = tffs_opendir("/asia/china", &dir[2]);
+expect(error, 0);
+error = tffs_remove("/asia/china");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/korea");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/japan/tokyo");
+expect(error, EFFS_OK);
+error = tffs_remove("/asia/japan");
+expect(error, EFFS_OK);
+return 0;
+}
+// Check that expected stat data was read
+int case_expect_stat(const char *name, int n)
+{
+error = tffs_stat(name, &stat);
+expect(error, EFFS_OK);
+// test type, size, flags, space?
+// test range of location, inode, block
+return 0;
+}
+// Test stat
+int case_stat(int p0, int p1)
+{
+struct xstat_s xstat;
+struct stat_s stat;
+char myname[] = "/Stat_file";
+char sym_name[] = "/sf";
+char stream_name[] = "/Stat_stream";
+fd_t fdi;
+int size, i, file_size = 0;
+// test stat on dirs, symlinks and files
+// check stat.block (by writing two HUGE files)
+case_cleanup(fs.chunk_size_max / 5 * 20);
+// NOTEME: this is a very limited test
+error = tffs_fwrite(myname, (char *)tdata[TDATA_HUGE], 99);
+expect_ok(error);
+error = tffs_stat(myname, &stat);
+expect(error, EFFS_OK);
+expect(stat.type, OT_FILE);
+expect(stat.flags, 0);
+expect_ok(stat.inode);
+expect(stat.size, 99);
+//    error = tffs_xstat(myname, &xstat);
+//    expect(error, EFFS_OK);
+//    expect(error, EFFS_OK);
+//    expect(xstat.type, OT_FILE);
+//    expect(xstat.flags, 0);
+//    expect_ok(xstat.inode);
+//    expect(xstat.size, 99);
+//    expect(xstat.space, 112);
+//    expect_ok(xstat.location);
+//   expect_ok(xstat.block);
+//    expect_ok(xstat.sequence);
+//    expect_ok(xstat.updates);
+error = tffs_linkstat(myname, &stat);
+expect(error, EFFS_OK);
+expect(error, EFFS_OK);
+expect(stat.type, OT_FILE);
+expect(stat.flags, 0);
+expect_ok(stat.inode);
+expect(stat.size, 99);
+error = tffs_xlstat(myname, &xstat);
+expect(error, EFFS_OK);
+expect(error, EFFS_OK);
+expect(xstat.type, OT_FILE);
+expect(xstat.flags, 0);
+expect_ok(xstat.inode);
+expect(xstat.size, 99);
+expect(xstat.space, 112);
+expect_ok(xstat.location);
+expect_ok(xstat.block);
+expect_ok(xstat.sequence);
+expect_ok(xstat.updates);
+// Symlink
+tffs_symlink(sym_name, myname);
+error = tffs_xlstat(sym_name, &xstat);
+expect(error, EFFS_OK);
+expect(error, EFFS_OK);
+expect(xstat.type, OT_LINK);
+expect(xstat.flags, 0);
+expect_ok(xstat.inode);
+expect(xstat.size, sizeof(myname));
+expect(xstat.space, 16);
+expect_ok(xstat.location);
+expect_ok(xstat.block);
+expect_ok(xstat.sequence);
+expect_ok(xstat.updates);
+// Stream stat test
+// Use xstat to return the size of the file
+fdi = tffs_open(stream_name, FFS_O_WRONLY | FFS_O_CREATE |
+FFS_O_TRUNC  | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+for (i = 0; i < 20; i++) {
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE],
+fs.chunk_size_max / 5);
+expect(size, fs.chunk_size_max / 5);
+file_size +=size;
+error = tffs_xlstat(stream_name, &xstat);
+expect(error, EFFS_OK);
+expect_eq(xstat.size, file_size);
+error = tffs_fstat(fdi, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, file_size);
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Test if the file size is right if opened in read-only
+fdi = tffs_open(stream_name, FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_xlstat(stream_name, &xstat);
+expect(error, EFFS_OK);
+expect_eq(xstat.size, file_size);
+// Test a lot of difference fdi
+for (i = -3; i < FFS_FD_OFFSET + fs.fd_max + 3; i++) {
+error = tffs_fstat(i, &stat);
+if (i == FFS_FD_OFFSET) {
+expect(error, EFFS_OK);
+}
+else expect(error, EFFS_BADFD);
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+return 0;
+}
+int case_remove(int p0, int p1)
+{
+tw(tr(TR_FUNC, TrTest, "WARNING: Test case not implemented!\n"));
+ttw(str(TTrTest, "Test case not implemented!" NL));
+return 0;
+}
+int case_rename(int p0, int p1)
+{
+fd_t fdi;
+int size, i;
+struct dir_s dir;
+// create file A
+// rename A to B
+// check file A is gone
+// check file B is same as file A
+// do all the same for directory
+// do all the same for symlink
+// test and ensure that dir rename "foo" to "foo/bar" is impossible!
+// Cleanup before run
+tffs_remove("/Walt_Disney/RUP");
+tffs_remove("/Uncle_Scrooge");
+tffs_remove("/Walt_Disney/Minnie");
+tffs_remove("/Walt_Disney");
+tffs_remove("/Duck");
+// Init
+tffs_mkdir("/Disney");
+tffs_mkdir("/Hell");
+error = tffs_fwrite("/IMEI", TDATA(2));
+if (error < 0 && error != EFFS_ACCESS) return 1;
+error = tffs_fcontrol("/IMEI", OC_FLAGS, OF_READONLY);
+if (error < 0 && error != EFFS_ACCESS) return 1;
+tw(tr(TR_FUNC, TrTestHigh, "Rename file\n")); /* Rename file */
+error = tffs_fwrite("/Mickey", TDATA(3));
+expect(error, EFFS_OK);
+error = tffs_fwrite("/Pluto", TDATA(2));
+expect(error, EFFS_OK);
+error = tffs_rename("/Pluto", "/Dog");
+expect(error, EFFS_OK);
+error = tffs_fupdate("/Pluto", TDATA(2));
+expect(error, EFFS_NOTFOUND);
+error = test_expect_file("/Dog", TDATA(2));
+if (error) return 1;
+error = tffs_rename("/Dog", "/Hell/RIP");
+expect(error, EFFS_OK);
+error = tffs_rename("/Hell/RIP", "/RAP");
+expect(error, EFFS_OK);
+error = tffs_rename("/RAP", "/Disney/RUP");
+expect(error, EFFS_OK);
+error = test_expect_file("/Disney/RUP", TDATA(2));
+if (error) return 1;
+// Rename a file to an existing file
+error = tffs_rename("/Mickey", "/Disney/RUP");
+expect(error, EFFS_OK);
+// Have the data changed?
+error = test_expect_file("/Disney/RUP", TDATA(3));
+if (error) return 1;
+// Try rename a file to an exisitng read-only file
+error = tffs_rename("/Disney/RUP", "/IMEI");
+expect(error, EFFS_ACCESS);
+// Try rename a file to an existing dir
+error = tffs_rename("/Disney/RUP", "/Hell");
+expect(error, EFFS_NOTAFILE);
+error = tffs_rename("/Disney/RUP", "/BADNAME?");
+expect(error, EFFS_BADNAME);
+error = tffs_remove("/Hell");
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestHigh, "Rename symlink\n")); /* Rename symlink */
+tffs_symlink("/Goose", "/Disney/RUP"); // 5
+error = tffs_rename("/Goose", "/Duck");
+expect(error, EFFS_OK);
+error = tffs_fupdate("/Goose", TDATA(2));
+expect(error, EFFS_NOTFOUND);
+error = test_expect_file("/Duck", TDATA(3));
+if (error) return 1;
+error = test_expect_file("/Disney/RUP", TDATA(3));
+if (error) return 1;
+tw(tr(TR_FUNC, TrTestHigh, "Rename dir\n"));     /* Rename dir */
+// * FIXME BUG * FIXME BUG * FIXME BUG * The below test to not fail instead
+// the directory is removed
+// error = tffs_rename("/Disney", "/Disney/foo");
+// expect(error, EFFS_OK);
+tffs_mkdir("/Disney/Donald_Duck");
+expect(error, EFFS_OK);
+error = ffs_rename("/Disney/Donald_Duck", "/Uncle_Scrooge");
+expect(error, EFFS_OK);
+error = tffs_opendir("/Uncle_Scrooge", &dir);
+expect(error, EFFS_OK);
+error = tffs_opendir("/Disney/Donald_Duck", &dir);
+expect(error, EFFS_NOTFOUND);
+error = tffs_rename("/Disney", "/Walt_Disney");
+expect(error, EFFS_OK);
+tffs_mkdir("/Disney");  // Create 'Disney' dir again
+expect(error, EFFS_OK);
+// Try rename to existing dir
+error = tffs_rename("/Disney", "/Walt_Disney");
+expect(error, EFFS_EXISTS);
+// Try rename to existing file
+error = tffs_rename("/Disney", "/Walt_Disney/RUP");
+expect(error, EFFS_EXISTS);
+tw(tr(TR_FUNC, TrTestHigh, "Rename seghead\n")); /* Rename seghead */
+fdi = tffs_open("/Walt_Disney/Mickey", FFS_O_WRONLY | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], fs.chunk_size_max + 1);
+expect(size, fs.chunk_size_max + 1);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] + size, fs.chunk_size_max);
+expect(size, fs.chunk_size_max);
+error = tffs_rename("/Walt_Disney/Mickey", "/Walt_Disney/Minnie");
+expect(error, EFFS_LOCKED);
+tffs_close(fdi);
+error = tffs_rename("/Walt_Disney/Mickey", "/Walt_Disney/Minnie");
+expect(error, EFFS_OK);
+fdi = tffs_open("/Walt_Disney/Minnie", FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+i = 0;
+do {
+size = tffs_read(fdi, bigbuf, bigbuf_size);
+error = test_expect_data((char*)tdata[TDATA_HUGE] + i, bigbuf, size);
+if (error) return 1;
+i += size;
+} while (size);
+error = tffs_close(fdi);
+expect(error, 0);
+error = test_expect_file("/Walt_Disney/Minnie", (char *)tdata[TDATA_HUGE],
+2 * fs.chunk_size_max + 1);
+if (error) return 1;
+// Rename a big file to an existing big file
+error = tffs_fwrite("/Mickey", (char *)tdata[TDATA_HUGE] + 5,
+2.5 * fs.chunk_size_max);
+expect(error, EFFS_OK);
+error = tffs_rename("/Mickey", "/Walt_Disney/Minnie");
+expect(error, EFFS_OK);
+error = test_expect_file("/Walt_Disney/Minnie", (char *)tdata[TDATA_HUGE] + 5,
+2.5 * fs.chunk_size_max);
+if (error) return 1;
+error = tffs_fread("/Mickey", 0 , 0);
+expect(error, EFFS_NOTFOUND);
+return 0;
+}
+// One of the problems with the rename function is that we need to copy the
+// data part from the old obj to the new obj. When we allocate data for the
+// new obj we risk that the data alloc caused a data reclaim which relocated
+// the old obj thus the source have been moved!
+int case_rename_extended(int p0, int p1)
+{
+int i, old_drec_most_lost, rename_file_relocated = 0;
+int fsize, offset;
+char myname1[] = "/rename1/rename1/foo";
+char myname2[] = "/rename2/rename2/bar";
+if (p0 == 0) p0 = 100;
+if (p1 == 0) p1 = 5;
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs/b3r24", 0x2BAD);
+expect(error, EFFS_OK);
+fsize = 2.5 * fs.chunk_size_max; // Test with more than one chunk
+tffs_mkdir("/rename1");
+tffs_mkdir("/rename1/rename1");
+tffs_mkdir("/rename2");
+tffs_mkdir("/rename2/rename2");
+error = tffs_file_write(myname1, (char*)tdata[TDATA_HUGE], fsize,
+FFS_O_CREATE | FFS_O_TRUNC);
+// Test if rename can handle when the objects are relocaded while the
+// rename is in progress
+for (i = 0; i < p0; i++) {
+tw(tr(TR_FUNC, TrTest, "Rename number %d\n", i));
+offset = i % 2 ? 3 : 9;
+error = tffs_file_write(myname2, (char*)tdata[TDATA_HUGE] + offset, fsize,
+FFS_O_CREATE | FFS_O_TRUNC);
+// Get data reclaim candidate most_lost
+old_drec_most_lost = stats.drec.most_lost;
+error = tffs_rename(myname2, myname1);
+expect(error, EFFS_OK);
+error = test_expect_file(myname1, tdata[TDATA_HUGE] + offset, fsize);
+expect(error, EFFS_OK);
+error = tffs_fread(myname2, 0, 0);
+expect(error, EFFS_NOTFOUND);
+// Has the rename triggered a data_reclaim()?
+if (old_drec_most_lost != stats.drec.most_lost) {
+rename_file_relocated++;
+tw(tr(TR_FUNC, TrTest, "Rename objects relocated %d\n",
+rename_file_relocated));
+if (rename_file_relocated >= p1)
+return EFFS_OK;
+}
+}
+return 1;
+}
+// Test Big files
+int case_bigfile(int p0, int p1)
+{
+struct ffs_state_s old, new;
+const char bigfile[] = "/antarctica/iceberg";
+int bytes_max, file_size;
+#if 1
+ttw(ttr(TTrTest, "WARNING: We need to re-implement this test. Skip test" NL));
+tw(tr(TR_FUNC, TrTest, "WARNING: We need to re-implement this test. Skip test\n"));
+return 0;
+#endif
+if (param.data_blocks <= 1) {
+ttw(ttr(TTrTest, "WARNING: Too few blocks to run. Skip test" NL));
+tw(tr(TR_FUNC, TrTest, "WARNING: Too few blocks to run. Skip test\n"));
+return 0;
+}
+error = case_cleanup(fs.filesize_max);
+expect(error, EFFS_NOSPACE); // We can not cleanup this amount.
+ffs_query(Q_BYTES_FREE, (uint32 *) &bytes_max);
+test_ffs_state_get(&old);
+// We don't have enough space for this amount because the name dos also
+// use some space
+file_size = bytes_max + 1;
+// Try to make a file of a size that is bigger than the total free space
+// in the file system.
+ttw(ttr(TTrTest, "Bigfile of size %d" NL, file_size));
+tw(tr(TR_FUNC, TrTestHigh, "Bigfile of size %d\n", file_size));
+error = tffs_fcreate(bigfile,
+(char *) tdata[TDATA_HUGE], file_size);
+expect(error, EFFS_NOSPACE);
+test_ffs_state_get(&new);
+expect_eq(old.bytes_free, new.bytes_free);
+// File the system with this huge file
+file_size = bytes_max - FFS_FILENAME_MAX - dev.atomsize;
+ttw(ttr(TTrTest, "Bigfile of size %d" NL, file_size));
+tw(tr(TR_FUNC, TrTestHigh, "Bigfile of size %d\n", file_size));
+error = tffs_fcreate(bigfile,
+(char *) tdata[TDATA_HUGE], file_size);
+expect(error, EFFS_OK);
+error = test_expect_file((char *) bigfile,
+(char *) tdata[TDATA_HUGE], file_size);
+if (error) return 1;
+test_ffs_state_get(&new);
+expect_gt(old.bytes_free, new.bytes_free - file_size);
+tffs_remove(bigfile);
+return 0;
+}
+/******************************************************************************
+* Reclaim Test Cases
+******************************************************************************/
+// Test that ffs internal state is same after a re-ffs_init()
+int case_reinit(int p0, int p1)
+{
+struct ffs_state_s old, new;
+test_ffs_state_get(&old);
+error = tffs_initialize();
+expect(error, EFFS_OK);
+test_ffs_state_get(&new);
+error = test_expect_state(&old, &new);
+if (error) return 1;
+return 0;
+}
+// Test inodes reclaim
+int case_irec(int p0, int p1)
+{
+// African states: kenya, egypt, marocco, namibia, nigeria, mozambique,
+// tanzania, ghana, togo, liberia, mali, congo
+struct ffs_state_s old, new;
+int i, j, updates;
+if (p0 == 0)
+p0 = 7;
+tffs_mkdir("/africa");
+// Initialize
+tffs_fwrite("/africa/kenya", TDATA(0)); // 1
+tffs_mkdir("/africa/east"); // 2
+tffs_fwrite("/africa/tanzania", TDATA(1)); // 3
+tffs_fwrite("/africa/east/egypt", TDATA(2)); // 4
+tffs_symlink("/africa/et", "africa/east/egypt"); // 5
+tffs_mkdir("/africa/west"); // 7
+tffs_fupdate("/africa/et", TDATA(3)); // 6
+tffs_fwrite("/africa/west/liberia", TDATA(0)); // 8
+for (j = 0; j < p0; j++) {
+test_ffs_state_get(&old);
+updates = param.inodes_max - old.inodes_used;
+ttw(ttr(TTrTest, "loop %d: updates = %d" NL, j, updates));
+tw(tr(TR_FUNC, TrTestHigh, "loop %d: updates = %d\n", j, updates));
+for (i = 0; i < (updates / 10) + 10; i++) {
+// cleanup...
+error = tffs_remove("/africa/east/egypt");
+expect(error, EFFS_OK);
+error = tffs_remove("/africa/east");
+expect(error, EFFS_OK);
+error = tffs_remove("/africa/et");
+expect(error, EFFS_OK);
+error = tffs_remove("/africa/west/liberia");
+expect(error, EFFS_OK);
+error = tffs_remove("/africa/west");
+expect(error, EFFS_OK);
+// use 10 inodes...
+error = tffs_fwrite("/africa/kenya", TDATA(0)); // 1
+expect(error, EFFS_OK);
+error = tffs_mkdir("/africa/east"); // 2
+expect(error, EFFS_OK);
+error = tffs_fwrite("/africa/tanzania", (char *) tdata[0], 0); // 3
+expect(error, EFFS_OK);
+error = tffs_fcreate("/africa/east/egypt", TDATA(2)); // 4
+expect(error, EFFS_OK);
+error = tffs_symlink("/africa/et", "/africa/east/egypt"); // 5
+expect(error, EFFS_OK);
+error = tffs_mkdir("/africa/west"); // 7
+expect(error, EFFS_OK);
+error = tffs_fupdate("/africa/et", TDATA(3)); // 6
+expect(error, EFFS_OK);
+error = tffs_fcreate("/africa/west/liberia", TDATA(0)); // 8
+expect(error, EFFS_OK);
+error = tffs_fupdate("/africa/west/liberia", TDATA(1)); // 9
+expect(error, EFFS_OK);
+error = tffs_fupdate("/africa/tanzania", TDATA(2)); // 10
+expect(error, EFFS_OK);
+}
+test_ffs_state_get(&new);
+expect_eq(old.objects_total, new.objects_total);
+error = test_expect_file("/africa/tanzania", TDATA(2));
+if (error) return 1;
+error = test_expect_file("/africa/west/liberia", TDATA(1));
+if (error) return 1;
+error = test_expect_file("/africa/east/egypt", TDATA(3));
+if (error) return 1;
+error = test_expect_file("/africa/kenya", TDATA(0));
+if (error) return 1;
+}
+return 0;
+}
+#if 1
+// FIXME: Is this test case still valid after the new ffs_file_write() which
+// makes several chunks instead of on big?
+// Test data reclaim. Use up to maximum half the total space available.
+// drec params: percentage of avail to use, numupdates. We must not have too
+// big files due to fragmentation problems
+#define DREC_DIR "/north-america/usa"
+#define DREC_CHUNKS 6
+int case_drec(int p0, int p1)
+{
+static struct test_file_s files[] =
+{
+{ DREC_DIR "/alaska", 0, 0 },
+{ DREC_DIR "/arkansas", 0, 0 },
+{ DREC_DIR "/california", 0, 0 },
+{ DREC_DIR "/colorado", 0, 0 },
+{ DREC_DIR "/dakota", 0, 0 }, // north, south?
+{ DREC_DIR "/DistrictOfColumbia", 0, 0 }, // state?
+{ DREC_DIR "/florida", 0, 0 },
+{ DREC_DIR "/Georgia", 0, 0 },
+{ DREC_DIR "/hawaii", 0, 0 },
+{ DREC_DIR "/Idaho", 0, 0 },
+{ DREC_DIR "/Illinois", 0, 0 },
+{ DREC_DIR "/Iowa", 0, 0 },
+{ DREC_DIR "/kentucky", 0, 0 },
+{ DREC_DIR "/maine", 0, 0 },
+{ DREC_DIR "/Massachusettes", 0, 0 }, // spelling?
+{ DREC_DIR "/michigan", 0, 0 },
+{ DREC_DIR "/minnesota", 0, 0 },
+{ DREC_DIR "/mississippi", 0, 0 },
+{ DREC_DIR "/missouri", 0, 0 },
+{ DREC_DIR "/Montana", 0, 0 },
+{ DREC_DIR "/Nevada", 0, 0 },
+{ DREC_DIR "/NewHampshire", 0, 0 },
+{ DREC_DIR "/NewJersey", 0, 0 },
+{ DREC_DIR "/NewMexico", 0, 0 },
+{ DREC_DIR "/NewYork", 0, 0 }, // state?
+{ DREC_DIR "/north-carolina", 0, 0 },
+{ DREC_DIR "/ohio", 0, 0 },
+{ DREC_DIR "/oklahoma", 0, 0 },
+{ DREC_DIR "/Oregon", 0, 0 },
+{ DREC_DIR "/Pensylvania", 0, 0 },
+{ DREC_DIR "/RhodeIsland", 0, 0 }, // state?
+{ DREC_DIR "/south-carolina", 0, 0 },
+{ DREC_DIR "/Tennesee", 0, 0 },
+{ DREC_DIR "/texas", 0, 0 },
+{ DREC_DIR "/utah", 0, 0 },
+{ DREC_DIR "/Vermont", 0, 0 },
+{ DREC_DIR "/virginia", 0, 0 },
+{ DREC_DIR "/washington", 0, 0 },
+{ DREC_DIR "/Wyoming", 0, 0 },
+{ DREC_DIR "/40", 0, 0 },
+{ DREC_DIR "/41", 0, 0 },
+{ DREC_DIR "/42", 0, 0 },
+{ DREC_DIR "/43", 0, 0 },
+{ DREC_DIR "/44", 0, 0 },
+{ DREC_DIR "/45", 0, 0 },
+{ DREC_DIR "/46", 0, 0 },
+{ DREC_DIR "/47", 0, 0 },
+{ DREC_DIR "/48", 0, 0 },
+{ DREC_DIR "/49", 0, 0 },
+{ DREC_DIR "/50", 0, 0 },
+{ DREC_DIR "/51", 0, 0 },
+{ DREC_DIR "/52", 0, 0 },
+};
+struct chunk_s {
+int ratio;
+int high;
+int low;
+};
+const struct chunk_s chunk[DREC_CHUNKS] = {
+{ 15, 65536, 32768 },
+{ 15, 32768, 16384 },
+{ 25, 16384,  8192 },
+{ 20,  8192,  4096 },
+{ 15,  4096,  2048 },
+{ 10,  2048,     0 }
+};
+int i, j, n, num_files;
+int num, pct;
+int size_used, size_max, size_chunk;
+int size_chunk_used, size_chunk_low, size_chunk_high;
+num = (p0 == 0 ? 11 : p0);
+pct = (p1 == 0 ? 50 : p1);
+tffs_mkdir("/north-america");
+tffs_mkdir("/north-america/usa");
+size_max   = pct * param.bytes_avail / 100;
+size_used  = 0;
+num_files  = sizeof(files) / sizeof(struct test_file_s);
+n = 0;
+tw(tr(TR_FUNC, TrTestHigh, "pct = %d%% = %dk\n",  pct, size_max/1024));
+for (i = 0; i < DREC_CHUNKS; i++) {
+size_chunk = chunk[i].ratio * size_max / 100;
+size_chunk_low  = chunk[i].low  / 256 * fs.filesize_max / 256;
+size_chunk_high = chunk[i].high / 256 * fs.filesize_max / 256;
+tw(tr(TR_FUNC, TrTestHigh, "%4dk of [%d..%d]: ",
+size_chunk/1024, size_chunk_high, size_chunk_low));
+ttw(ttr(TTrTest, "%4dk of [%d..%d]: ",
+size_chunk/1024, size_chunk_high, size_chunk_low));
+size_chunk_used = 0;
+// If the total chunk size can guaranteeable be contained...
+if (size_chunk >= chunk[i].high) {
+for (j = 0; j < size_chunk / size_chunk_high; j++) {
+if (n >= num_files) {
+tw(tr(TR_FUNC, TrTestHigh, "j too big\n"));
+ttw(str(TTrTest, "j too big" NL));
+break;
+}
+files[n].size = size_chunk_low +
+rand() % (size_chunk_high - size_chunk_low);
+#ifdef WIN32
+/* due to limitation in MS Visual C */
+if( files[n].size  > 65535 )
+files[n].size = 65535;
+#endif //WIN32
+files[n].data = (char *) tdata[TDATA_HUGE] + n;
+tw(tr(TR_NULL, TrTestHigh, "%d:%s ",
+files[n].size, &files[n].name[strlen(DREC_DIR)+1]));
+ttw(ttr(TTrTest, "%d:%s " NL,
+files[n].size, &files[n].name[strlen(DREC_DIR)+1]));
+size_chunk_used += files[n].size;
+n++;
+// FIXME: We should let all the unused bytes from this
+// chunk spill over into the next chunk so we use the
+// full percentage specified by p1.
+}
+size_used += size_chunk_used;
+}
+tw(tr(TR_NULL, TrTestHigh, "(%dk)\n", size_chunk_used/1024));
+ttw(ttr(TTrTest, "(%dk)" NL, size_chunk_used/1024));
+}
+tw(tr(TR_FUNC, TrTestHigh, "pct = %d%% = %dk\n",
+100 * size_used/param.bytes_avail, size_used/1024));
+ttw(ttr(TTrTest, "pct = %d%% = %dk" NL,
+100 * size_used/param.bytes_avail, size_used/1024));
+for (j = 0; j < num; j++) {
+ttw(ttr(TTrTest, "drec: %d. write" NL, j+1));
+tw(tr(TR_FUNC, TrTestHigh, "drec: %d. write\n", j+1));
+for (i = 0; i < n; i++) {
+error = tffs_fwrite(files[i].name, files[i].data, files[i].size);
+expect(error, EFFS_OK);
+}
+}
+for (i = 0; i < n; i++) {
+error = test_expect_file(files[i].name, files[i].data, files[i].size);
+if (error)
+return 1;
+error = tffs_remove(files[i].name);
+expect(error, EFFS_OK);
+}
+tffs_remove("/north-america/usa");
+tffs_remove("/north-america");
+return 0;
+}
+#else
+// Test data reclaim. Use up to maximum half the total space available.
+// drec params: percentage of avail to use, numupdates. We must not have too
+// big files due to fragmentation problems
+int case_drec(int p0, int p1)
+{
+struct blabla_s {
+int ratio;
+int high;
+int low;
+};
+struct blabla_s sizes[4] =
+{
+{  10, 65536, 32768 },
+{  40, 21800, 16384 },
+{  45, 16384,  2048 },
+{   5,  2048,     0 }
+};
+static struct test_file_s files[] =
+{
+{ DRECDIR "/alaska", 0, 0 },
+{ DRECDIR "/arkansas", 0, 0 },
+{ DRECDIR "/california", 0, 0 },
+{ DRECDIR "/colorado", 0, 0 },
+{ DRECDIR "/dakota", 0, 0 }, // north, south?
+{ DRECDIR "/DistrictOfColumbia", 0, 0 }, // state?
+{ DRECDIR "/florida", 0, 0 },
+{ DRECDIR "/Georgia", 0, 0 },
+{ DRECDIR "/hawaii", 0, 0 },
+{ DRECDIR "/Idaho", 0, 0 },
+{ DRECDIR "/Illinois", 0, 0 },
+{ DRECDIR "/Iowa", 0, 0 },
+{ DRECDIR "/kentucky", 0, 0 },
+{ DRECDIR "/maine", 0, 0 },
+{ DRECDIR "/Massachusettes", 0, 0 }, // spelling?
+{ DRECDIR "/michigan", 0, 0 },
+{ DRECDIR "/minnesota", 0, 0 },
+{ DRECDIR "/mississippi", 0, 0 },
+{ DRECDIR "/missouri", 0, 0 },
+{ DRECDIR "/Montana", 0, 0 },
+{ DRECDIR "/Nevada", 0, 0 },
+{ DRECDIR "/NewHampshire", 0, 0 },
+{ DRECDIR "/NewJersey", 0, 0 },
+{ DRECDIR "/NewMexico", 0, 0 },
+{ DRECDIR "/NewYork", 0, 0 }, // state?
+{ DRECDIR "/north-carolina", 0, 0 },
+{ DRECDIR "/ohio", 0, 0 },
+{ DRECDIR "/oklahoma", 0, 0 },
+{ DRECDIR "/Oregon", 0, 0 },
+{ DRECDIR "/Pensylvania", 0, 0 },
+{ DRECDIR "/RhodeIsland", 0, 0 }, // state?
+{ DRECDIR "/south-carolina", 0, 0 },
+{ DRECDIR "/Tennesee", 0, 0 },
+{ DRECDIR "/texas", 0, 0 },
+{ DRECDIR "/utah", 0, 0 },
+{ DRECDIR "/Vermont", 0, 0 },
+{ DRECDIR "/virginia", 0, 0 },
+{ DRECDIR "/washington", 0, 0 },
+{ DRECDIR "/Wyoming", 0, 0 },
+{ DRECDIR "/40", 0, 0 },
+{ DRECDIR "/41", 0, 0 },
+{ DRECDIR "/42", 0, 0 },
+{ DRECDIR "/43", 0, 0 },
+{ DRECDIR "/44", 0, 0 },
+{ DRECDIR "/45", 0, 0 },
+{ DRECDIR "/46", 0, 0 },
+{ DRECDIR "/47", 0, 0 },
+{ DRECDIR "/48", 0, 0 },
+{ DRECDIR "/49", 0, 0 },
+{ DRECDIR "/50", 0, 0 },
+{ DRECDIR "/51", 0, 0 },
+{ DRECDIR "/52", 0, 0 },
+};
+int i, j, n, size, size_target;
+int num, percentage;
+error = tffs_mkdir("/north-america");
+percentage = (p1 == 0 ? 50 : p1);
+n = sizeof(files)/sizeof(struct test_file_s);
+size_target = percentage * param.bytes_avail / 100;
+size = 0;
+for (i = 0; i < 4; i++) {
+sizes[i].ratio = sizes[i].ratio * size_target / 100;
+sizes[i].high  = sizes[i].high / 256 * fs.filesize_max / 256;
+sizes[i].low   = sizes[i].low  / 256 * fs.filesize_max / 256;
+size += sizes[i].ratio;
+}
+ttw(ttr(TTrTest, "%4dk in total" NL, size / 1024));
+tw(tr(TR_FUNC, TrTestHigh, "%4dk in total\n", size / 1024));
+j = 0;
+size = size_target = 0;
+for (i = 0; i < 4; i++) {
+ttw(ttr(TTrTest, "%4dk: %d..%d = ",
+sizes[i].ratio / 1024, sizes[i].high, sizes[i].low));
+tw(tr(TR_FUNC, TrTestHigh, "%4dk: %d..%d = ",
+sizes[i].ratio / 1024, sizes[i].high, sizes[i].low));
+size_target += sizes[i].ratio;
+while (size < size_target) {
+files[j].data = (char *) tdata[TDATA_HUGE] + j;
+files[j].size = rand() % (sizes[i].high - sizes[i].low)
++ sizes[i].low;
+size += files[j].size;
+ttw(ttr(TTrTest, "%d:%s, ",
+files[j].size, &files[j].name[strlen(DRECDIR)+1]));
+tw(tr(TR_NULL, TrTestHigh, "%d:%s, ",
+files[j].size, &files[j].name[strlen(DRECDIR)+1]));
+j++;
+if (j >= n) {
+// TODO: better error handling?
+ttw(str(TTrTest, "j too big" NL));
+tw(tr(TR_FUNC, TrTestHigh, "j too big\n"));
+return -1;
+}
+}
+ttw(str(TTrTest, "" NL));
+tw(tr(TR_NULL, TrTestHigh, "\n"));
+}
+n = j;
+error = tffs_mkdir(DRECDIR);
+num = (p0 == 0 ? 5 : p0);
+for (j = 0; j < num; j++) {
+ttw(ttr(TTrTest, "drec: %d. write" NL, j+1));
+tw(tr(TR_FUNC, TrTestHigh, "drec: %d. write\n", j+1));
+for (i = 0; i < n; i++) {
+error = tffs_fwrite(files[i].name, files[i].data, files[i].size);
+expect(error, EFFS_OK);
+}
+// error = test_run("ri");
+// if (error) return 1;
+}
+for (i = 0; i < n; i++) {
+error = test_expect_file(files[i].name, files[i].data, files[i].size);
+if (error) return 1;
+error = tffs_remove(files[i].name);
+expect(error, EFFS_OK);
+}
+return 0;
+}
+#endif
+void save_block_ages(int *age)
+{
+int i;
+struct block_header_s *bhp;
+for (i = 0; i < dev.numblocks; i++)
+{
+bhp = (struct block_header_s *) offset2addr(dev.binfo[i].offset);
+age[i] = bhp->age;
+tw(tr(TR_FUNC, TrTestHigh, "b,age(%d,%d)\n", i, age[i]));
+}
+}
+// NOTE: This chech includes the inode block thus the inode block also needs
+// to be reclaimed before this functions returns ok
+int has_all_block_ages_changed(int *age)
+{
+int i;
+struct block_header_s *bhp;
+for (i = 0; i < dev.numblocks; i++)
+{
+bhp = (struct block_header_s *) offset2addr(dev.binfo[i].offset);
+if (age[i] == bhp->age)
+return 0; // Age have not changed
+}
+return 1;
+}
+#define chunkalign(size) (((size) + fs.chunk_size_max-1) & ~(fs.chunk_size_max-1))
+// Fill a data blocks with the maximum possible numbers of objects
+int fill_block_with_max_objects(void)
+{
+static int n = 1000; // Avoid white spaces in the filename
+int fsize, i, b, nobjects, bfree_space;
+char myname[] = "Fb_max-xxxx";
+char *mydata = (char *) tdata[TDATA_HUGE];
+// Find an approximate objects size
+fsize = dev.blocksize / fs.block_files_max - sizeof(myname) - 1;
+// Fill approximate 75% of a data block
+for (i = 0; i < fs.block_files_max / 4 * 3; i++, n++) {
+sprintf(myname, "/Fb_max-%4d", n);
+error = tffs_file_write(myname,(char*) mydata, fsize, FFS_O_CREATE);
+expect_ok(error);
+}
+// Find the block we currently are filling with objects.
+error = tffs_xlstat(myname, &xstat);
+expect_ok(error);
+b = xstat.block;
+bfree_space = dev.blocksize - bstat[b].used;
+tw(tr(TR_FUNC, TrTestHigh, "Block: %d, Free space:%dkB\n", b ,bfree_space>>10));
+// Calculate the exact file size to fill a block with max number of files
+nobjects = fs.block_files_max - bstat[b].objects - fs.block_files_reserved;
+fsize = bfree_space / nobjects - sizeof(myname);
+fsize &= ~dev.atomnotmask;     // Avoid padding
+tw(tr(TR_FUNC, TrTestHigh, "Exact file size (%d)\n", fsize));
+// Fill the rest of the block
+for (i = 0; i < nobjects; i++, n++) {
+sprintf(myname, "/Fb_max-%4d", n);
+error = tffs_file_write(myname, (char*) mydata, fsize, FFS_O_CREATE);
+expect_ok(error);
+}
+tw(tr(TR_FUNC, TrTest, "Filled block %d done\n", b));
+return EFFS_OK;
+}
+// Stress test data reclaim and test wearleveling.
+// NOTE: This test can not run in less than 7 blocks
+int case_adrec(int nwrites, int nage_change)
+{
+int i, j, n, inodes_reserved, nobjects, bytes_max;
+int blocks, fsize;
+int dynamic_fsize = 1000;
+char static_name[] = "/Static-xxxx";
+char dynamic_name[] = "/Dynamic";
+int *age = (int*) smallbuf;
+/* Flow:
+Format ffs.
+Fill N number of blocks with the maximum possible numbers of objects.
+Fill the rest of FFS except from a few kbytes. Use almost all the inodes.
+Trigger data reclaim by continue to update a file.
+Test if all flash blocks are used for wearleveling.
+*/
+if (nwrites == 0)  // Number of updates of the dynamic file (timeout)
+nwrites = 1000000;
+if (nage_change == 0) //
+nage_change = 2;
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs", 0x2BAD);
+expect(error, EFFS_OK);
+// Major hack, disable journal and reserved space or else there will be
+// created new journals inside the blocks where we wish to have only
+// static objects
+fs.ijournal = 0;
+fs.reserved_space = 0;
+// Minimum amount of inodes to fill FFS:
+ffs_query(Q_BYTES_FREE, &bytes_max);
+inodes_reserved = bytes_max / fs.chunk_size_max;
+// We need to calculate the amount of inodes we can use and still
+// garanti that we have enough inodes to fill all data blocks with data.
+nobjects  = fs.objects_max - inodes_reserved;
+// How many blocks can we fill?
+blocks = nobjects / fs.block_files_max;
+// Fill N number of data blocks with the maximum possible numbers of objects
+tw(tr(TR_FUNC, TrTest, "Fill %d blocks with max obj \n", blocks));
+n = 1000; // Avoid white spaces in the filename
+for (j = 0; j < blocks; j++) {
+error = fill_block_with_max_objects();
+expect_ok(error);
+}
+// Restore journal and reserved space
+error = tffs_initialize();
+expect_ok(error);
+// Fill the rest of FFS except from 3 times the dynamic size, futhermore
+// keep 4 objects 'free'
+ffs_query(Q_OBJECTS_FREE, &nobjects);
+tw(tr(TR_FUNC, TrTest, "Fill almost the rest of FFS\n"));
+n = 1000;        // Avoid white spaces in the filename
+while (nobjects - 4 > 0) {
+ffs_query(Q_BYTES_FREE, &bytes_max);
+fsize = (bytes_max - dynamic_fsize * 3) / (nobjects - 4);
+tw(tr(TR_FUNC, TrTestHigh, "space,obj,fsize (%dk,%d,%d)\n",
+bytes_max/1024, nobjects, fsize));
+if (fsize > fs.chunk_size_max) {
+// Roundup to the closet complete chunk or else we use to many inodes
+fsize = chunkalign(fsize);
+tw(tr(TR_FUNC, TrTestHigh, "Chunkalign %d\n", fsize));
+}
+sprintf(static_name, "/Static-%4d", n++);
+error = tffs_file_write(static_name, (char*)tdata[TDATA_HUGE], fsize,
+FFS_O_CREATE);
+if (error == EFFS_NOSPACE) {
+tw(tr(TR_FUNC, TrTest, "WARNING: Fill failed with out of data space\n"));
+break;
+}
+else
+expect_ok(error);
+ffs_query(Q_OBJECTS_FREE, &nobjects);
+}
+tw(tr(TR_FUNC, TrTest, "Fill done, all static objects are written\n"));
+case_debug_help(2,0);  // bstat trace
+// Save the age of all blocks
+save_block_ages(age);
+tw(tr(TR_FUNC, TrTest, "Update the dynamic file max %d times\n", nwrites));
+for (i = 0, j = 0; i < nwrites; i++) {
+error = tffs_file_write(dynamic_name, (char*)tdata[TDATA_HUGE],
+dynamic_fsize,
+FFS_O_CREATE | FFS_O_TRUNC);
+expect_ok(error);
+if (i%1000 == 0)
+tw(tr(TR_FUNC, TrTest, "Write number %d\n", i));
+if (has_all_block_ages_changed(age) == 1) {
+tw(tr(TR_FUNC, TrTest,"All block ages have changed %d\n", j));
+j++;
+save_block_ages(age);
+}
+if (j >= nage_change)
+break;
+}
+test_statistics_print();
+case_debug_help(2,0);  // bstat trace
+if (j >= nage_change)
+return 0;
+return 1;  //Error
+}
+/******************************************************************************
+* Journalling and Recover Test Cases
+******************************************************************************/
+// Test journalling. Both for normal objects but also for journal file
+// itself! The following operations are tested for proper recovery: fcreate,
+// fupdate, relocate, delete, clean, fcontrol
+int case_journal(int p0, int p1)
+{
+struct test_file_s tf;
+struct ffs_state_s old, new;
+struct xstat_s stat_old, stat_new;
+int i, myspace = 0, mytmpspace, offset;
+char mytmpname[] = "/test-journal-tmp";
+int testflags[] = {
+JOURNAL_TEST_EMPTY,      // object not committed
+JOURNAL_TEST_WRITING,    // object not committed
+JOURNAL_TEST_READY,      // object ok
+JOURNAL_TEST_COMMITTING, // object ok
+JOURNAL_TEST_COMMITTED,  // object ok
+JOURNAL_TEST_DONE,       // object ok
+};
+tf.name = "/test-journal";
+tf.data = (char *) tdata[2];
+tf.size = sdata[2];
+#if 1
+// NOTEME: Workaround, the below use of state_get can not handle if we
+// create a new journal while we run the test. Instead we create a
+// new journal before the test if we are close to full.
+if (fs.journal_pos >= fs.journal_size - (FFS_JOURNAL_MARGIN + 12) *
+sizeof(struct journal_s)) {
+tw(tr(TR_FUNC, TrTest, "Journal file (near) full!\n"));
+journal_create(fs.ijournal);
+}
+// NOTEME: Workaround, this test is unabel to handle a
+// block_alloc(). The 'extra' amount of lost space caused by a
+// block_alloc() and its block header dos cheat the test to fail.
+offset = data_prealloc(1024);
+expect_gt(offset, 0);
+#endif
+// init
+#if 1
+error = tffs_fwrite(mytmpname, tf.data, tf.size);
+expect(error, EFFS_OK);
+error = tffs_xlstat(mytmpname, &stat_old);
+expect(error, EFFS_OK);
+mytmpspace = stat_old.space;
+ttw(ttr(TTrTest, "file '%s' uses %d bytes" NL, mytmpname, mytmpspace));
+tw(tr(TR_FUNC, TrTestHigh, "file '%s' uses %d bytes\n", mytmpname, mytmpspace));
+#endif
+error = tffs_fcreate(tf.name, tf.data, tf.size);
+expect(error, EFFS_OK);
+error = tffs_xlstat(tf.name, &stat_old);
+expect(error, EFFS_OK);
+myspace = stat_old.space;
+error = tffs_fcreate("/dummy", 0, 0);
+expect(error, EFFS_OK);
+ttw(ttr(TTrTest, "file '%s' uses %d bytes" NL, tf.name, myspace));
+tw(tr(TR_FUNC, TrTestHigh, "file '%s' uses %d bytes\n", tf.name, myspace));
+ttw(str(TTrTest, "fcreate:" NL));
+tw(tr(TR_BEGIN, TrTestHigh, "fcreate:\n"));
+stat_old.inode = 0;
+for (i = 0; i < sizeof(testflags)/sizeof(int); i++)
+{
+// clean up from operation being tested
+tffs_remove(tf.name);
+ttw(ttr(TTrTest, "fs.testflags = 0x%x" NL, testflags[i]));
+tw(tr(TR_FUNC, TrTestHigh, "fs.testflags = 0x%x\n", testflags[i]));
+test_ffs_state_get(&old);
+error = tffs_fcontrol("/dummy", OC_FS_TESTFLAGS, testflags[i]);
+expect(error, EFFS_OK);
+error = tffs_fcreate(tf.name, tf.data, tf.size);
+expect(error, EFFS_OK);
+error = tffs_initialize();
+expect(error, EFFS_OK);
+test_ffs_state_get(&new);
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_used new = %7d, old = %7d, diff = %d\n",
+new.bytes_used, old.bytes_used, new.bytes_used - old.bytes_used));
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_lost new = %7d, old = %7d, diff = %d\n",
+new.bytes_lost, old.bytes_lost,
+new.bytes_lost - old.bytes_lost));
+expect_eq(new.bytes_used, old.bytes_used + myspace);
+error = tffs_xlstat(tf.name, &stat_new);
+if (i < 2) {
+// object was not committed, so object must not exist
+expect(error, EFFS_NOTFOUND);
+expect_eq(new.objects_total, old.objects_total);
+expect_eq(new.bytes_lost,    old.bytes_lost + myspace);
+}
+else {
+// object was committed, so object must exist
+expect(error, EFFS_OK);
+expect_ne(stat_old.inode, stat_new.inode);
+expect_eq(new.objects_total, old.objects_total + 1);
+expect_eq(new.bytes_lost,    old.bytes_lost);
+}
+}
+ttw(str(TTrTest, "" NL));
+tw(tr(TR_END, TrTestHigh, ""));
+ttw(str(TTrTest, "fupdate:" NL));
+tw(tr(TR_BEGIN, TrTestHigh, "fupdate:\n"));
+error = tffs_xlstat(tf.name, &stat_old);
+expect(error, EFFS_OK);
+for (i = 0; i < sizeof(testflags)/sizeof(int); i++)
+{
+ttw(ttr(TTrTest, "fs.testflags = 0x%x" NL, testflags[i]));
+tw(tr(TR_FUNC, TrTestHigh, "fs.testflags = 0x%x\n", testflags[i]));
+test_ffs_state_get(&old);
+error = tffs_fcontrol("/dummy", OC_FS_TESTFLAGS, testflags[i]);
+expect(error, EFFS_OK);
+error = tffs_fupdate(tf.name, tf.data, tf.size);
+error = tffs_initialize();
+expect(error, EFFS_OK);
+error = tffs_xlstat(tf.name, &stat_new);
+expect(error, EFFS_OK);
+if (i < 2) {
+// object was not committed, so stats must be equal
+error = test_expect_data(&stat_new, &stat_old, sizeof(stat));
+if (error) return 1;
+}
+else {
+// object was committed, so inodes must not be equal
+expect_ne(stat_old.inode, stat_new.inode);
+}
+test_ffs_state_get(&new);
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_used new = %7d, old = %7d, diff = %d\n",
+new.bytes_used, old.bytes_used, new.bytes_used - old.bytes_used));
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_lost new = %7d, old = %7d, diff = %d\n",
+new.bytes_lost, old.bytes_lost,
+new.bytes_lost - old.bytes_lost));
+expect_eq(new.objects_total, old.objects_total);
+expect_eq(new.bytes_used,    old.bytes_used + myspace);
+expect_eq(new.bytes_lost,    old.bytes_lost + myspace);
+}
+ttw(str(TTrTest, "" NL));
+tw(tr(TR_END, TrTestHigh, ""));
+ttw(str(TTrTest, "rename:" NL));
+tw(tr(TR_BEGIN, TrTestHigh, "rename:\n"));
+error = tffs_fwrite(tf.name, tf.data, tf.size);
+expect(error, EFFS_OK);
+error = tffs_xlstat(tf.name, &stat_old);
+expect(error, EFFS_OK);
+for (i = 0; i < sizeof(testflags)/sizeof(int); i++)
+{
+ttw(ttr(TTrTest, "fs.testflags = 0x%x" NL, testflags[i]));
+tw(tr(TR_FUNC, TrTestHigh, "fs.testflags = 0x%x\n", testflags[i]));
+error = tffs_fwrite(mytmpname, tf.data, tf.size);
+expect_ok(error);
+error = tffs_fcontrol("/dummy", OC_FS_TESTFLAGS, testflags[i]);
+expect(error, EFFS_OK);
+test_ffs_state_get(&old);
+error = tffs_rename(mytmpname, tf.name);
+expect_ok(error);
+error = tffs_initialize();
+expect(error, EFFS_OK);
+test_ffs_state_get(&new);
+// tf.name MUST always exist
+error = tffs_xlstat(tf.name, &stat_new);
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_used new = %7d, old = %7d, diff = %d\n",
+new.bytes_used, old.bytes_used, new.bytes_used - old.bytes_used));
+tw(tr(TR_FUNC, TrTestHigh,
+"bytes_lost new = %7d, old = %7d, diff = %d\n",
+new.bytes_lost, old.bytes_lost,
+new.bytes_lost - old.bytes_lost));
+error = tffs_xlstat(mytmpname, &stat_new);
+if (i < 2) {
+// Journal not READY, so test-journal-tmp must exist
+expect(error, EFFS_OK);
+expect_eq(new.objects_total, old.objects_total);
+expect_eq(new.bytes_used,    old.bytes_used + myspace);
+expect_eq(new.bytes_lost,    old.bytes_lost + myspace);
+}
+else {
+// Journal ready, so test-journal-tmp must not exist
+expect(error, EFFS_NOTFOUND);
+expect_eq(new.objects_total, old.objects_total - 1);
+expect_eq(new.bytes_used,    old.bytes_used + myspace);
+expect_eq(new.bytes_lost,    old.bytes_lost + myspace + mytmpspace);
+expect_ne(stat_old.inode, stat_new.inode);
+}
+}
+ttw(str(TTrTest, "" NL));
+tw(tr(TR_END, TrTestHigh, ""));
+// cleanup
+tffs_remove(tf.name);
+tffs_remove("/dummy");
+return 0;
+}
+// Test block recovery
+int case_brecover(int p0, int p1)
+{
+struct test_file_s tf;
+struct ffs_state_s old, new;
+int j, inodes_block_old = 0, inodes_block_new = 0;
+int i, error;
+uint16 free_blocks;
+int testflags[] = {
+BLOCK_COMMIT_BEFORE,
+BLOCK_COMMIT_NO_VALID,
+BLOCK_COMMIT_OLD_FREE,
+BLOCK_COMMIT_AFTER
+};
+int testflags_2[] = {
+BLOCK_RECLAIM_ALLOC,
+BLOCK_RECLAIM_CLEANING,
+BLOCK_RECLAIM_NO_CLEAN,
+};
+tf.name = "/dummy4fctrl";
+tf.data = (char *) tdata[0];
+tf.size = sdata[0];
+error = tffs_fwrite(tf.name, tf.data, tf.size);
+expect(error, EFFS_OK);
+for (j = 0; j < 3; j++)
+{
+test_ffs_state_get(&old);
+//case_lsr(0, 0);  // temp
+error = ffs_query(Q_FS_INODES, (uint16 *) &inodes_block_old);
+expect(error, EFFS_OK);
+// Trigger block_commit() to fail
+error = tffs_fcontrol(tf.name, OC_FS_TESTFLAGS, testflags[j]);
+expect(error, EFFS_OK);
+inodes_reclaim();
+error = tffs_initialize();
+expect(error, EFFS_OK);
+error = ffs_query(Q_FS_INODES, (uint16 *) &inodes_block_new);
+expect(error, EFFS_OK);
+ttw(ttr(TTrTest, "inodes block %d -> %d" NL,
+inodes_block_old, inodes_block_new));
+tw(tr(TR_FUNC, TrTestHigh, "inodes block %d -> %d\n",
+inodes_block_old, inodes_block_new));
+switch (j) {
+case 0: expect(inodes_block_old, inodes_block_new); break;
+case 1: expect_ne(inodes_block_old, inodes_block_new); break;
+case 2: expect_ne(inodes_block_old, inodes_block_new); break;
+case 3: expect_ne(inodes_block_old, inodes_block_new); break;
+}
+test_ffs_state_get(&new);
+if (test_expect_objects(&old, &new))
+return 1;
+}
+// FIXME: The below test often fails (recalaim data block and create new
+// jouranl file makes it to fail)
+if (p0 == 9) {
+// Test BLOCK_RECLAIM Fill up all data blocks until only one is
+// free.
+tw(tr(TR_FUNC, TrTest, "Test Block reclaim\n"));
+ttw(ttr(TTrTest, "Test Block reclaim..." ));
+tffs_mkdir("/rand");
+ffs_query(Q_BLOCKS_FREE, (uint16 *) &free_blocks);
+while (free_blocks > 1) {
+error = case_mk_rand_file("/rand", 10000, 0);
+if (error < 0) {
+tw(tr(TR_FUNC, TrTest, "ERROR: case_mk_rand_file failed\n"));
+return 1;
+}
+ffs_query(Q_BLOCKS_FREE, (uint16 *) &free_blocks);
+}
+// case_mk_rand_file() will trigger a block_reclaim which will be
+// interruptet by the activated testflags. This will cause the FFS to
+// use the last free block! After a new init of ffs must it have
+// recovered.
+ttw(ttr(TTrTest, "use last block..."));
+for (i = 0; i < sizeof(testflags_2)/sizeof(int); i++)
+{
+error = tffs_fcontrol(tf.name, OC_FS_TESTFLAGS, testflags_2[i]);
+expect(error, EFFS_OK);
+do {
+case_cleanup(20000);
+error = case_mk_rand_file("/rand", 7000, 0);
+} while (error >= 0);
+expect(error, EFFS_NOSPACE);
+ffs_query(Q_BLOCKS_FREE, (uint16 *) &free_blocks);
+if (free_blocks != 0) {
+tw(tr(TR_FUNC, TrTestHigh, "ERROR: We still have free blocks!\n"));
+return 1;
+}
+error = tffs_initialize();// NOTE: error "WARNING: block_alloc failed" is okay.
+expect_ok(error);
+ffs_query(Q_BLOCKS_FREE, (uint16 *) &free_blocks);
+if (free_blocks != 1) {
+tw(tr(TR_FUNC, TrTestHigh,
+"ERROR: Wrong number of blocks free: %d\n", free_blocks));
+return 1;
+}
+}
+// NOTE: We have to make this clenaup because we can not run if FFS is
+// near full
+case_cleanup(dev.blocksize);
+// This test will make data_block_reclaim() to fail before it has
+// relocated all objects
+ttw(ttr(TTrTest, "interrupt block_reclaim()..."));
+for (i = 0; i < 4; i++)
+{
+error = tffs_fcontrol(tf.name, OC_FS_TESTFLAGS, BLOCK_RECOVER_OBJECTS);
+expect(error, EFFS_OK);
+do {
+case_cleanup(20000);
+error = case_mk_rand_file("/rand", 7000, 0);
+} while (error >= 0);
+expect(error, EFFS_NOSPACE);
+// NOTE: error "WARNING: block_alloc failed" is okay.
+error = tffs_initialize();
+expect_ok(error);
+}
+// Free up some space to the next test case.
+case_cleanup(dev.blocksize * 4);
+ttw(ttr(TTrTest, "Done" NL));
+}
+return 0;
+}
+/******************************************************************************
+* Specific/Special Test Cases
+******************************************************************************/
+// FIXME: Is this test case still valid after the new ffs_file_write() which
+// makes seveal chunks instead of on big?
+// Test filling a block to the full block size. We write N files of
+// decreasing powers of two, starting at half the block size. At the end we
+// are guaranteed to have at least one completelt full block. Also, we know
+// we have used at least <block_size> bytes of storage.
+int case_bfull(int p0, int p1)
+{
+struct ffs_state_s old, new;
+char myname[40] = "/antarctica/ice-";
+int i, size, mysize, dirlen, space;
+if (param.data_blocks <= 1) {
+ttw(ttr(TTrTest, "WARNING: Too few blocks to run. Skip test" NL));
+tw(tr(TR_FUNC, TrTest, "WARNING: Too few blocks to run. Skip test\n"));
+return 0;
+}
+error = tffs_mkdir("/antarctica");
+error = case_cleanup(param.block_size + 10000);
+expect_ok(error);
+test_ffs_state_get(&old);
+dirlen = strlen(myname);
+space = 0;
+size = param.block_size/2;
+for (i = 0; size > 0; i++) {
+mysize = size - param.atomsize;
+if (mysize < 0)
+mysize = size;
+sprintf(&myname[dirlen], "%d", size);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], mysize);
+expect(error, EFFS_OK);
+error = tffs_xlstat(myname, &xstat);
+expect(error, EFFS_OK);
+ttw(ttr(TTrTest, "%6d: %s" NL, xstat.space, myname));
+tw(tr(TR_FUNC, TrTestHigh, "%6d: %s\n", xstat.space, myname));
+space += xstat.space;
+size >>= 1;
+}
+test_ffs_state_get(&new);
+// Check space used. We have used a little more than <space> because we
+// have probably allocated one or two new blocks, and that is
+// dev.atomsize more bytes per block.
+tw(tr(TR_FUNC, TrTestHigh,
+"old.free = %d, new.free = %d, space used in test = %d\n",
+old.bytes_free, new.bytes_free, space));
+expect_gt(old.bytes_free, new.bytes_free + space - 1);
+// remove half of the files
+size = param.block_size/2;
+for (i = 0; size > 0; i++) {
+if (i & 1) {
+sprintf(&myname[dirlen], "%d", size);
+error = tffs_remove(myname);
+expect(error, EFFS_OK);
+}
+size >>= 1;
+}
+return 0;
+}
+int case_list(int p0, int p1)
+{
+const struct testcase_s *p;
+tw(tr(TR_FUNC, TrTestHigh, "bigbuf   = 0x%X, %d\n", bigbuf,   bigbuf_size));
+tw(tr(TR_FUNC, TrTestHigh, "smallbuf = 0x%X, %d\n", smallbuf, smallbuf_size));
+ttw(ttr(TTrTest, "bigbuf   = 0x%X, %d" NL, bigbuf,   bigbuf_size));
+ttw(ttr(TTrTest, "smallbuf = 0x%X, %d" NL, smallbuf, smallbuf_size));
+ttw(str(TTrTest, "Test Cases:" NL));
+for (p = testcase; p->name != 0; p++) {
+tw(tr(TR_FUNC, TrTest, "%8s: %s\n", p->name, p->comment));
+ttw(ttr(TTrTest, "%8s: %s" NL, p->name, p->comment));
+}
+return 0;
+}
+// Stress test the target.
+// p0 is number of times to run. Default is 10.
+// p1 is number of milli-seconds to wait between each file update.
+int case_stress(int p0, int p1)
+{
+char myname[20];
+int i, mysize;
+char *mydata;
+mydata = (char *) tdata[TDATA_HUGE];
+mysize = 9 * param.block_size / 16;
+if (p0 == 0) p0 = 10;
+if (p1 == 0) p1 = 1000;
+for (i = 0; i < p0; i++) {
+sprintf(myname, "/stress-%d", i);
+ttw(ttr(TTrTest, "/stress %d" NL, i));
+error = tffs_fcreate(myname, (char *)mydata, mysize);
+expect(error, EFFS_OK);
+tffs_delay(p1);
+error = tffs_remove(myname);
+expect(error, EFFS_OK);
+}
+return 0;
+}
+// Test ffs with many (small) files. p0 is number of times to write all the
+// files. Default is two e.g. one create and one update
+int case_mfiles(int p0, int p1)
+{
+char myname[40];
+int i, j;
+static struct test_file_s tf[] =
+{
+{ MFDIR "/MSCAP",   0,    6 },
+{ MFDIR "/IMEI",    0,    8 },
+{ MFDIR "/CLASS2",  0,    3 },
+{ MFDIR "/CLASS3",  0,    2 },
+{ MFDIR "/MSSUP",   0,    5 },
+{ MFDIR "/MSSET",   0,   83 },
+{ MFDIR "/UPN",     0,  165 },
+{ MFDIR "/CTIM",    0,   92 },
+{ MFDIR "/CCNT",    0,   52 },
+{ MFDIR "/ECC",     0,   15 },
+{ MFDIR "/ORG",     0, 2650 },
+{ MFDIR "/BCCHINF", 0,   54 },
+{ MFDIR "/CCP",     0,    7 },
+{ MFDIR "/EXT1",    0,   13 },
+{ MFDIR "/SIMLCK",  0,   62 },
+{ MFDIR "/SIMLCKEXT",0, 172 },
+{ MFDIR "/SECURITY", 0,   8 },
+{ MFDIR "/MAIN",    0,    8 },
+{ MFDIR "/SFK",     0,    8 },
+{ MFDIR "/FAULT",   0,    8 },
+{ MFDIR "/DEBUG",   0,    8 },
+{ MFDIR "/POWER",   0,    8 },
+{ MFDIR "/KEYB",    0,   64 },
+{ MFDIR "/RADIO",   0,    8 },
+{ MFDIR "/CGMI",    0,   20 },
+{ MFDIR "/CGMM",    0,   20 },
+{ MFDIR "/CGMR",    0,   20 },
+{ MFDIR "/CGSN",    0,   20 },
+{ MFDIR "/SMSPRFL", 0,  206 },
+{ MFDIR "/PLMN",    0,   68 },
+{ MFDIR "/ATRADIO", 0, 2700 },
+{ MFDIR "/GROUP",   0, 1122 }
+};
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/ffs/i2048o1024", 0x2BAD);
+expect(error, EFFS_OK);
+error = tffs_mkdir(MFDIR);
+expect(error, EFFS_OK);
+if (p0 == 0) p0 = 2;
+for (j = 0; j < p0; j++) {
+tw(tr(TR_FUNC, TrTestHigh, "mf: Writing many files, loop %d\n", j));
+tw(tr(TR_FUNC, TrTestHigh, "SMS000..SMS099\n"));
+for (i = 0; i < 100; i++) {
+sprintf(myname, MFDIR "/SMS%03d", i);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], 176);
+expect(error, EFFS_OK);
+}
+tw(tr(TR_FUNC, TrTestHigh, "LDN/LRN/LMN000..LDN/LRN/LMN009\n"));
+for (i = 0; i < 10; i++) {
+sprintf(myname, MFDIR "/LDN%03d", i);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], 31);
+expect(error, EFFS_OK);
+sprintf(myname, MFDIR "/LRN%03d", i);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], 32);
+expect(error, EFFS_OK);
+sprintf(myname, MFDIR "/LMN%03d", i);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], 30);
+expect(error, EFFS_OK);
+}
+tw(tr(TR_FUNC, TrTestHigh, "ADN000..ADN149\n"));
+for (i = 0; i < 150; i++) {
+sprintf(myname, MFDIR "/ADN%03d", i);
+error = tffs_fwrite(myname, (char *) tdata[TDATA_HUGE], 43);
+expect(error, EFFS_OK);
+}
+tw(tr(TR_FUNC, TrTestHigh, "PCM Files...\n"));
+for (i = 0; i < sizeof(tf)/sizeof(struct test_file_s); i++) {
+error = tffs_fwrite(tf[i].name,
+(char *) tdata[TDATA_HUGE], tf[i].size);
+expect(error, EFFS_OK);
+}
+}
+error = tffs_exit();
+expect(error, EFFS_OK);
+return 0;
+}
+int case_open(int p0, int p1)
+{
+fd_t fdi;
+char myname[20];
+int i, size;
+#define RDONLY FFS_O_RDONLY
+#define WRONLY FFS_O_WRONLY
+#define APPEND FFS_O_APPEND
+#define CREATE FFS_O_CREATE
+#define EXCL   FFS_O_EXCL
+#define TRUNC  FFS_O_TRUNC
+ffs_options_t non_exist_invalid[] = {
+( 0 ),
+( RDONLY |                   CREATE                ),
+( RDONLY |                   CREATE | EXCL         ),
+( RDONLY |                   CREATE |        TRUNC ),
+( RDONLY |                   CREATE | EXCL | TRUNC ),
+( RDONLY |                            EXCL         ),
+( RDONLY |                            EXCL | TRUNC ),
+( RDONLY |                                   TRUNC ),
+(                                     EXCL         ),
+(                                     EXCL | TRUNC ),
+(                                            TRUNC ),
+(                            CREATE |        TRUNC ),
+(                            CREATE | EXCL | TRUNC ),
+(                            CREATE | EXCL         ),
+(                            CREATE                ),
+(                   APPEND                         ),
+(                   APPEND |          EXCL         ),
+(                   APPEND |          EXCL | TRUNC ),
+(                   APPEND |                 TRUNC ),
+(                   APPEND | CREATE |        TRUNC ),
+(                   APPEND | CREATE | EXCL         ),
+(                   APPEND | CREATE | EXCL         ),
+(                   APPEND | CREATE                ),
+( RDONLY |          APPEND                         ),
+( RDONLY |          APPEND |          EXCL         ),
+( RDONLY |          APPEND |          EXCL | TRUNC ),
+( RDONLY |          APPEND |                 TRUNC ),
+( RDONLY |          APPEND | CREATE |        TRUNC ),
+( RDONLY |          APPEND | CREATE | EXCL | TRUNC ),
+( RDONLY |          APPEND | CREATE | EXCL         ),
+( RDONLY |          APPEND | CREATE                )
+};
+ffs_options_t non_exist_notfound[] = {
+(          WRONLY | APPEND                         ),
+(          WRONLY | APPEND |          EXCL         ),
+(          WRONLY | APPEND |          EXCL | TRUNC ),
+(          WRONLY | APPEND |                 TRUNC ),
+(          WRONLY                                  ),
+(          WRONLY |                   EXCL         ),
+(          WRONLY |                   EXCL | TRUNC ),
+(          WRONLY |                          TRUNC ),
+( RDONLY | WRONLY                                  ),
+( RDONLY | WRONLY |                   EXCL         ),
+( RDONLY | WRONLY |                   EXCL | TRUNC ),
+( RDONLY | WRONLY |                          TRUNC ),
+( RDONLY | WRONLY | APPEND                         ),
+( RDONLY | WRONLY | APPEND |          EXCL         ),
+( RDONLY | WRONLY | APPEND |          EXCL | TRUNC ),
+( RDONLY | WRONLY | APPEND |                 TRUNC ),
+( RDONLY                                           )
+};
+ffs_options_t non_exist_fd_offset[] = {
+(          WRONLY | APPEND | CREATE |        TRUNC ),
+(          WRONLY | APPEND | CREATE | EXCL | TRUNC ),
+(          WRONLY | APPEND | CREATE | EXCL         ),
+(          WRONLY | APPEND | CREATE                ),
+(          WRONLY |          CREATE |        TRUNC ),
+(          WRONLY |          CREATE | EXCL | TRUNC ),
+(          WRONLY |          CREATE | EXCL         ),
+(          WRONLY |          CREATE                ),
+( RDONLY | WRONLY |          CREATE |        TRUNC ),
+( RDONLY | WRONLY |          CREATE | EXCL | TRUNC ),
+( RDONLY | WRONLY |          CREATE | EXCL         ),
+( RDONLY | WRONLY |          CREATE                ),
+( RDONLY | WRONLY | APPEND | CREATE |        TRUNC ),
+( RDONLY | WRONLY | APPEND | CREATE | EXCL | TRUNC ),
+( RDONLY | WRONLY | APPEND | CREATE | EXCL         ),
+( RDONLY | WRONLY | APPEND | CREATE                )
+};
+ffs_options_t exist_invalid[] = {
+(                                     EXCL         ),
+(                                     EXCL | TRUNC ),
+(                                            TRUNC ),
+(                            CREATE |        TRUNC ),
+(                            CREATE | EXCL | TRUNC ),
+(                            CREATE | EXCL         ),
+(                            CREATE                ),
+(                   APPEND                         ),
+(                   APPEND |          EXCL         ),
+(                   APPEND |          EXCL | TRUNC ),
+(                   APPEND |                 TRUNC ),
+(                   APPEND | CREATE |        TRUNC ),
+(                   APPEND | CREATE | EXCL | TRUNC ),
+(                   APPEND | CREATE | EXCL         ),
+(                   APPEND | CREATE                ),
+( RDONLY |          APPEND                         ),
+( RDONLY |          APPEND |          EXCL         ),
+( RDONLY |          APPEND |          EXCL | TRUNC ),
+( RDONLY |          APPEND |                 TRUNC ),
+( RDONLY |          APPEND | CREATE |        TRUNC ),
+( RDONLY |          APPEND | CREATE | EXCL | TRUNC ),
+( RDONLY |          APPEND | CREATE | EXCL         ),
+( RDONLY |          APPEND | CREATE                ),
+( RDONLY |                            EXCL         ),
+( RDONLY |                            EXCL | TRUNC ),
+( RDONLY |                                   TRUNC ),
+( RDONLY |                   CREATE |        TRUNC ),
+( RDONLY |                   CREATE | EXCL | TRUNC ),
+( RDONLY |                   CREATE | EXCL         ),
+( RDONLY |                   CREATE                )
+};
+ffs_options_t exist_exist[] = {
+(          WRONLY | APPEND | CREATE | EXCL | TRUNC ),
+(          WRONLY | APPEND | CREATE | EXCL         ),
+(          WRONLY |          CREATE | EXCL | TRUNC ),
+(          WRONLY |          CREATE | EXCL         ),
+( RDONLY | WRONLY |          CREATE | EXCL | TRUNC ),
+( RDONLY | WRONLY |          CREATE | EXCL         ),
+( RDONLY | WRONLY | APPEND | CREATE | EXCL | TRUNC ),
+( RDONLY | WRONLY | APPEND | CREATE | EXCL         )
+};
+ffs_options_t exist_fd_offset[] = {
+(          WRONLY | APPEND                         ),
+(          WRONLY | APPEND |          EXCL         ),
+(          WRONLY | APPEND |          EXCL | TRUNC ),
+(          WRONLY | APPEND |                 TRUNC ),
+(          WRONLY | APPEND | CREATE |        TRUNC ),
+(          WRONLY | APPEND | CREATE                ),
+( RDONLY                                           ),
+( RDONLY | WRONLY                                  ),
+( RDONLY | WRONLY |                   EXCL         ),
+( RDONLY | WRONLY |                   EXCL | TRUNC ),
+( RDONLY | WRONLY |                          TRUNC ),
+( RDONLY | WRONLY |          CREATE |        TRUNC ),
+( RDONLY | WRONLY |          CREATE                ),
+( RDONLY | WRONLY | APPEND                         ),
+( RDONLY | WRONLY | APPEND |          EXCL         ),
+( RDONLY | WRONLY | APPEND |          EXCL | TRUNC ),
+( RDONLY | WRONLY | APPEND |                 TRUNC ),
+( RDONLY | WRONLY | APPEND | CREATE |        TRUNC ),
+( RDONLY | WRONLY | APPEND | CREATE                ),
+(          WRONLY                                  ),
+(          WRONLY |                   EXCL         ),
+(          WRONLY |                   EXCL | TRUNC ),
+(          WRONLY |                          TRUNC ),
+( WRONLY |                   CREATE |        TRUNC ),
+( WRONLY |                   CREATE                )
+};
+// Cleanup
+for (i = 0; i < 20; i++) {
+sprintf(myname, "/stream%d", i);
+tffs_remove(myname);
+}
+tw(tr(TR_FUNC, TrTestHigh, "Various open options, file non-existing\n"));
+ttw(str(TTrTest, "Various open options, file non-existing" NL));
+for (i = 0; i < sizeof(non_exist_invalid)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/20 * 20);
+fdi = tffs_open(myname, non_exist_invalid[i]);
+expect(fdi, EFFS_INVALID);
+}
+for (i = 0; i < sizeof(non_exist_notfound)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/20 * 20);
+fdi = tffs_open(myname, non_exist_notfound[i]);
+expect(fdi, EFFS_NOTFOUND);
+}
+for (i = 0; i < sizeof(non_exist_fd_offset)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/20 * 20);
+fdi = tffs_open(myname, non_exist_fd_offset[i]);
+expect(fdi, FFS_FD_OFFSET);
+tffs_close(fdi);
+}
+// Make FFS_FD_MAX number of files and write some data for later use
+tw(tr(TR_FUNC, TrTestHigh, "Create %d files with data \n", fs.fd_max));
+for (i = 0; i < fs.fd_max; i++) {
+sprintf(myname, "/stream%d", i);
+fdi = tffs_open(myname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC);
+expect(fdi, i + FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 31);
+expect(size, 31);
+}
+// Try to open one more file, this will make a error!
+sprintf(myname, "/stream%d", i++);
+fdi = tffs_open(myname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC);
+expect(fdi, EFFS_NUMFD);
+for (i = 0; i < fs.fd_max; i++) {
+error = tffs_close(i + FFS_FD_OFFSET);
+expect(error, EFFS_OK);
+}
+tw(tr(TR_FUNC, TrTestHigh,
+"Open same file multiple times in RDONLY mode\n"));
+for (i = 0; i < fs.fd_max; i++) {
+fdi = tffs_open("/stream2", FFS_O_RDONLY);
+expect(fdi, i + FFS_FD_OFFSET);
+}
+for (i = 0; i < fs.fd_max; i++) {
+error = tffs_close(i + FFS_FD_OFFSET);
+expect(error, 0);
+}
+tw(tr(TR_FUNC, TrTestHigh,
+"Open in WRONLY and try to open same file in WR or RD\n"));
+fdi = tffs_open("/stream1", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+fdi = tffs_open("/stream1", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, EFFS_LOCKED);
+fdi = tffs_open("/stream1", FFS_O_RDONLY );
+expect(fdi, EFFS_LOCKED);
+error = tffs_close(FFS_FD_OFFSET);
+expect(error, 0);
+tw(tr(TR_FUNC, TrTestHigh,
+"Open in READONLY and try to open same file WRONLY\n"));
+fdi = tffs_open("/stream1", FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+fdi = tffs_open("/stream1", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, EFFS_LOCKED);
+error = tffs_close(FFS_FD_OFFSET);
+expect(error, 0);
+tw(tr(TR_FUNC, TrTestHigh, "Various open options, file exists\n"));
+ttw(str(TTrTest, "Various open options, file exists" NL));
+for (i = 0; i < sizeof(exist_invalid)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/20 * 20);
+fdi = tffs_open(myname, exist_invalid[i]);
+expect(fdi, EFFS_INVALID);
+}
+for (i = 0; i < sizeof(exist_exist)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/20 * 20);
+fdi = tffs_open(myname, exist_exist[i]);
+expect(fdi, EFFS_EXISTS);
+tffs_close(fdi);
+}
+for (i = 0; i < sizeof(exist_fd_offset)/sizeof(ffs_options_t); i++) {
+sprintf(myname, "/stream%d", i - i/10 * 10);
+fdi = tffs_open(myname, exist_fd_offset[i]);
+expect(fdi, FFS_FD_OFFSET);
+tffs_close(fdi);
+}
+tw(tr(TR_FUNC, TrTestHigh, "Try to create a file with a dir name\n"));
+error = tffs_mkdir("/streams");
+fdi = tffs_open("/streams", FFS_O_WRONLY | FFS_O_APPEND | FFS_O_CREATE);
+expect(fdi, EFFS_NOTAFILE);
+tw(tr(TR_FUNC, TrTestHigh,
+"Try to use fwrite, fcreate, fread and remove on a open file\n"));
+fdi = tffs_open("/stream1", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_fcreate("/stream1", TDATA(2));
+expect(error, EFFS_EXISTS);
+error = tffs_file_write("/stream1", (char *) tdata[TDATA_HUGE], 31,
+FFS_O_CREATE | FFS_O_TRUNC);
+expect(error, EFFS_LOCKED);
+error = tffs_file_read("/stream1", bigbuf, 31);
+expect(error, EFFS_LOCKED);
+error = tffs_remove("/stream1");
+expect(error, EFFS_LOCKED);
+error = tffs_close(fdi);
+expect(error, 0);
+#undef RDONLY
+#undef WRONLY
+#undef APPEND
+#undef CREATE
+#undef EXCL
+#undef TRUNC
+return 0;
+}
+int twrite_seek(fd_t fdi, offset_t offset, int whence)
+{
+int size;
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE] + 10, 100);
+if (test_expect(size, 100) < 0) return -1;
+offset = tffs_seek(fdi, offset, whence);
+if (test_expect_ok(offset)) return -1;
+return offset;
+}
+int tseek_read(fd_t fdi, offset_t offset, int whence, offset_t src_offset)
+{
+int size;
+offset = tffs_seek(fdi, offset, whence);
+if (test_expect_ok(offset)) return -1;
+size = tffs_read(fdi, bigbuf, 100);
+if (test_expect(size, 100) < 0) return -1;
+error = test_expect_data((char*)tdata[TDATA_HUGE] + src_offset, bigbuf, size);
+if (error) return error;
+return offset;
+}
+int tseek_write(fd_t fdi, offset_t offset, int whence, offset_t src_offset)
+{
+int size;
+offset = tffs_seek(fdi, offset, whence);
+if (test_expect_ok(offset)) return -1;
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE] + src_offset + offset,
+fs.chunk_size_max / 2);
+if (test_expect(size, fs.chunk_size_max / 2) < 0) return -1;
+return offset;
+}
+int case_rw(int p0, int p1)
+{
+int i, size, offset;
+fd_t fdi;
+const char *dirs[] = { "/streams", "/streams/rw", "/streams/rw/multi",
+"/streams/rw/multi/write" };
+error = case_cleanup(5 * fs.chunk_size_max);
+expect_ok(error);
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+error = tffs_mkdir(dirs[i]);
+}
+tw(tr(TR_FUNC, TrTestHigh,
+"Test create and append of file, small and huge\n"));
+ttw(str(TTrTest, "Test create and append of file, small and huge" NL));
+fdi = tffs_open("/streams/rw_test",
+FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 31);
+expect(size, 31);
+error = tffs_close(fdi); expect(error, EFFS_OK);
+fdi = tffs_open("/streams/rw_test", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE] + 31, 2 * fs.chunk_size_max);
+expect(size, 2 * fs.chunk_size_max);
+error = tffs_close(fdi); expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+ttw(ttr(TTrTest, "Validate data" NL));
+size = tffs_fread("/streams/rw_test", bigbuf, bigbuf_size);
+expect(size, 31 + 2 * fs.chunk_size_max);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+// Provoke EFFS_FILETOOBIG
+error = tffs_fread("/streams/rw_test", bigbuf, size - 1);
+expect(error, EFFS_FILETOOBIG);
+error = tffs_fread("/streams/rw_test", bigbuf, size + 1);
+expect_ok(error);
+error = tffs_fread("/streams/rw_test", bigbuf, size);
+expect_ok(error);
+// Update file from zero, middle (between to chunks) and end. File with
+// and without data in seghead. Update the first 100 bytes (new data
+// have a offset of 10 so the data not is identical with the existing
+// ones).
+fdi = tffs_open("/streams/rw_test", FFS_O_RDWR);
+expect(fdi, FFS_FD_OFFSET);
+// write 100 bytes and seek to 50 bytes before end of the first chunk
+expect_ok(twrite_seek(fdi, fs.chunk_size_max - 50, FFS_SEEK_SET));
+// write 100 bytes, seek to 50 bytes from the end of the file
+expect_ok(twrite_seek(fdi, -50, FFS_SEEK_END));
+// Write 100 bytes. This will update the last 19 bytes of second chunk,
+// update and append data to the last chunk.  Read the last data but
+// only 80 bytes because they are in the buffer
+expect_ok(twrite_seek(fdi, -80, FFS_SEEK_CUR));
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+ttw(ttr(TTrTest, "Validate data" NL));
+size = tffs_read(fdi, bigbuf, 100);
+expect(size, 80);
+error = test_expect_data((char *)tdata[TDATA_HUGE] + 10 + 20, bigbuf, size);
+if (error) return 1;
+// Seek to start of file and read the first 100 bytes that was updated
+offset = tseek_read(fdi, 0, FFS_SEEK_SET, 10);
+expect_ok(offset);
+// Read 100 bytes more to make sure that the old data still is valid
+offset = tseek_read(fdi, 0, FFS_SEEK_CUR, 100);
+expect_ok(offset);
+// Seek to 50 bytes before end of the first chunk and read 100 bytes
+offset = tseek_read(fdi, fs.chunk_size_max - 50, FFS_SEEK_SET, 10);
+expect_ok(offset);
+// Read 100 bytes more to make sure that the old data still is valid
+offset = tseek_read(fdi, 0, FFS_SEEK_CUR, offset + 100);
+expect_ok(offset);
+// Read the last 100 bytes (updated data from 2 chunks)
+offset = tseek_read(fdi, -100, FFS_SEEK_END, 10);
+expect_ok(offset);
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Test where there is data in the seghead
+size = tffs_file_write("/streams/rw_test", (char*) tdata[TDATA_HUGE],
+2 * fs.chunk_size_max, FFS_O_CREATE | FFS_O_TRUNC);
+fdi = tffs_open("/streams/rw_test", FFS_O_RDWR);
+expect(fdi, FFS_FD_OFFSET);
+// Update the last half of the last chunk
+expect_ok(tseek_write(fdi, -fs.chunk_size_max / 2, FFS_SEEK_END, 10));
+// Update the first half of the last chunk
+expect_ok(tseek_write(fdi, fs.chunk_size_max, FFS_SEEK_SET, 10));
+// Update the first half of the seghead
+expect_ok(tseek_write(fdi, 0, FFS_SEEK_SET, 10));
+// Update the last half of the seghead, but flush the buffer so it have
+// to write and read the previous updated data
+error = tffs_fdatasync(fdi);
+expect(error, EFFS_OK);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE] + 10 + fs.chunk_size_max/2,
+fs.chunk_size_max/2);
+expect(size, fs.chunk_size_max/2);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+ttw(ttr(TTrTest, "Validate data" NL));
+// Read the complete file, all the data should have a offset of 10 bytes now!
+offset = tffs_seek(fdi, 0, FFS_SEEK_SET);
+expect_ok(offset);
+size = tffs_read(fdi, bigbuf, bigbuf_size);
+expect(size, 2 * fs.chunk_size_max);
+error = test_expect_data((char *)tdata[TDATA_HUGE] + 10, bigbuf, size);
+if (error) return 1;
+error = tffs_close(fdi); expect(error, 0);
+// Test bad fdi, write in RDONLY and read from WRONLY
+fdi = tffs_open("/streams/rw_test", FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_read(fdi + 1, bigbuf, 31);
+expect(size, EFFS_BADFD);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 31);
+tw(tr(TR_END, TrApi, "} %d\n", size)); // Avoid wrong indent
+expect(size, EFFS_INVALID);
+error = tffs_close(fdi);  expect(error, 0);
+fdi = tffs_open("/streams/rw_test", FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_read(fdi, bigbuf, 31);
+expect(size, EFFS_INVALID);
+error = tffs_close(fdi); expect(error, 0);
+// Test for bad file name
+fdi = tffs_open("/stream&!'*", FFS_O_WRONLY | FFS_O_CREATE);
+expect(fdi, EFFS_BADNAME);
+// Test for bad file name
+fdi = tffs_open("/%$#.+-_,Z19", FFS_O_WRONLY | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+tffs_close(fdi);
+return 0;
+}
+int case_multi_open(int p0, int p1)
+{
+int i, j, size;
+fd_t fdi;
+const char *dirs[] = { "/streams", "/streams/rw", "/streams/rw/multi",
+"/streams/rw/multi/write" };
+const char *file[] = { "/x-rw", "/streams/rw/x-rw",
+"/streams/rw/multi/x-rw",
+"/streams/rw/multi/write/x-rw" };
+error = case_cleanup(fs.fd_max * 50 * 10 + 5000);
+expect_ok(error);
+for (i = 0; i < sizeof(dirs)/sizeof(char *); i++) {
+error = tffs_mkdir(dirs[i]);
+}
+// Open multiply files from difference subdirectorys
+// and write/read X times to/from file (this also test truncate option)
+for (i = 0; i < fs.fd_max; i++) {
+fdi = tffs_open( file[i], FFS_O_WRONLY | FFS_O_APPEND |
+FFS_O_CREATE | FFS_O_TRUNC);
+expect(fdi, i + FFS_FD_OFFSET);
+}
+for (i = 0; i < fs.fd_max; i++) {
+for (j = 0; j < 10; j++) {
+size = tffs_write(i + FFS_FD_OFFSET, (char *) tdata[TDATA_HUGE], 50);
+expect(size, 50);
+}
+}
+// Run test with p0 != 0 to stress the test
+if (p0) { error = test_run("irec;drec;"); if (error > 0) return 1; }
+for (i = 0; i < fs.fd_max; i++) {
+error = tffs_close(i + FFS_FD_OFFSET);
+expect(error, 0);
+}
+for (i = 0; i < fs.fd_max; i++) {
+fdi = tffs_open( file[i], FFS_O_RDONLY);
+expect(fdi, i + FFS_FD_OFFSET);
+}
+if(p0) { error = test_run("irec;drec;"); if (error > 0) return 1; }
+for (i = 0; i < fs.fd_max; i++) {
+for (j = 0; j < 10; j++) {
+size = tffs_read(i + FFS_FD_OFFSET, bigbuf, 50);
+expect(size, 50);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+}
+}
+for (i = 0; i < fs.fd_max; i++) {
+error = tffs_close(i + FFS_FD_OFFSET);
+expect(error, 0);
+}
+return 0;
+}
+int case_seek(int p0, int p1)
+{
+fd_t fdi;
+int size, offset;
+error = case_cleanup(3 * fs.chunk_size_max);
+expect_ok(error);
+// The seek function itself don't care if the file is open in read or
+// write mode.
+error = tffs_mkdir("/streams");
+offset = tffs_seek(FFS_FD_OFFSET, 0, FFS_SEEK_SET);
+expect(offset, EFFS_BADFD);
+/* Make file to seek on */
+fdi = tffs_open("/streams/seek", FFS_O_RDWR | FFS_O_CREATE | FFS_O_TRUNC);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 3 * fs.chunk_size_max);
+expect(size, 3 * fs.chunk_size_max);
+/*  Simple test in RDWR without any writes. Test good and bad offset */
+tw(tr(TR_FUNC, TrTestHigh, "seek and RDWR \n"));
+ttw(str(TTrTest, "seek and RDWR" NL));
+offset = ffs_seek(fdi, 0, 5);
+expect(offset, EFFS_INVALID );
+tw(tr(TR_FUNC, TrTestHigh, "ffs_seek(FFS_SEEK_SET)\n"));
+ttw(str(TTrTest, "ffs_seek(FFS_SEEK_SET)" NL));
+offset = tffs_seek(fdi, -1, FFS_SEEK_SET);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 3 * fs.chunk_size_max + 1, FFS_SEEK_SET);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 15, FFS_SEEK_SET);
+expect(offset, 15);
+size = tffs_read(fdi, bigbuf, fs.chunk_size_max/10);
+expect(size, fs.chunk_size_max/10);
+error = test_expect_data((char *)tdata[TDATA_HUGE] + 15,
+bigbuf, fs.chunk_size_max/10);
+if (error) return 1;
+offset = tffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(offset, 0);
+size = tffs_read(fdi, bigbuf, bigbuf_size);
+error = test_expect_data((char*)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+tw(tr(TR_FUNC, TrTestHigh, "ffs_seek(FFS_SEEK_CUR)\n"));
+ttw(str(TTrTest, "ffs_seek(FFS_SEEK_CUR)" NL));
+offset = tffs_seek(fdi, -(3 * fs.chunk_size_max + 1), FFS_SEEK_CUR);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 1, FFS_SEEK_CUR);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 0, FFS_SEEK_CUR);
+expect(offset, 3 * fs.chunk_size_max);
+offset = tffs_seek(fdi, -30, FFS_SEEK_CUR);
+expect(offset, 3 * fs.chunk_size_max - 30);
+offset = tffs_seek(fdi, 20, FFS_SEEK_CUR);
+expect(offset, 3 * fs.chunk_size_max - 30 + 20);
+size = tffs_read(fdi, bigbuf, 3 * fs.chunk_size_max);
+expect(size, 10);
+error = test_expect_data((char *)tdata[TDATA_HUGE] +
+(3 * fs.chunk_size_max - 10), bigbuf, 10);
+if (error) return 1;
+tw(tr(TR_FUNC, TrTestHigh, "ffs_seek(FFS_SEEK_END)\n"));
+ttw(str(TTrTest, "ffs_seek(FFS_SEEK_END)" NL));
+offset = tffs_seek(fdi, -(3 * fs.chunk_size_max + 1), FFS_SEEK_END);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 1, FFS_SEEK_END);
+expect(offset, EFFS_INVALID);
+offset = tffs_seek(fdi, 0, FFS_SEEK_END);
+expect(offset, 3 * fs.chunk_size_max);
+offset = tffs_seek(fdi, -15, FFS_SEEK_END);
+expect(offset, 3 * fs.chunk_size_max - 15);
+size = tffs_read(fdi, bigbuf, 20);
+expect(size, 15);
+error = test_expect_data((char *)tdata[TDATA_HUGE] +
+(3 * fs.chunk_size_max - 15), bigbuf, size);
+if (error) return 1;
+error = tffs_close(fdi);
+expect(error, 0);
+// Seek in write-mode with write in different places of the file. Test
+// on the dirty flag to se if the buffer is flushed ad the rigth time
+tw(tr(TR_FUNC, TrTestHigh, "seek and WRONLY \n"));
+ttw(str(TTrTest, "seek and WRONLY" NL));
+fdi = tffs_open("/streams/seek", FFS_O_WRONLY);
+// Write and seek in the last chunk, buffer must be dirty so long the fp
+// not have been moved away from that chunk!
+offset = tffs_seek(fdi, -20, FFS_SEEK_END); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 0);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 10); expect(size, 10);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, -100, FFS_SEEK_CUR); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 10); expect(size, 10);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, -fs.chunk_size_max/4, FFS_SEEK_CUR); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 10); expect(size, 10);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, offset + 10, FFS_SEEK_SET); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 10); expect(size, 10);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+// Write and seek across several chunks, the buffer must be flushed after
+// leaving a 'dirty' chunk.
+offset = tffs_seek(fdi, 10, FFS_SEEK_SET); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 0);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 10); expect(size, 10);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, -50, FFS_SEEK_END); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 0);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 100); expect(size, 100);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, -fs.chunk_size_max, FFS_SEEK_CUR); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 0);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], fs.chunk_size_max / 2);
+expect(size, fs.chunk_size_max / 2);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+offset = tffs_seek(fdi, fs.chunk_size_max, FFS_SEEK_SET); expect_ok(offset);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 0);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 50); expect(size, 50);
+expect(fs.fd[fdi - FFS_FD_OFFSET].dirty, 1);
+error = tffs_close(fdi);
+expect(error, 0);
+return 0;
+}
+// NOTEME: move to other place later
+int case_trunc(int p0, int p1)
+{
+fd_t fdi;
+int size, f_size, trunc_size, i;
+T_FFS_STAT stat;
+char fname[] = "/truncate/normal_file";
+char sname[] = "/truncate/stream_file";
+char imeifile[] = "/truncate/IMEI";
+tffs_remove(fname);
+tffs_remove(sname);
+error = case_cleanup(5 * fs.chunk_size_max);
+expect_ok(error);
+tffs_mkdir("/truncate");
+// Try to truncate a non existing file
+error = tffs_truncate(fname, 0);
+expect(error, EFFS_NOTFOUND);
+// Try to truncate a directory
+error = tffs_truncate("/truncate", 0);
+expect(error, EFFS_NOTAFILE);
+f_size = fs.chunk_size_max + 100;
+error = tffs_file_write(fname, (char *)tdata[TDATA_HUGE], f_size,
+FFS_O_TRUNC | FFS_O_WRONLY | FFS_O_CREATE);
+expect(error, EFFS_OK);
+/* Test truncate from file size + 3 to file size - 3 */
+for (i = 0; i < 6; i++) {
+trunc_size = f_size + 3 - i;
+tw(tr(TR_FUNC, TrTestLow, "TRUNC file to size %d \n", trunc_size));
+error = tffs_truncate(fname, trunc_size);
+expect(error, EFFS_OK);
+error = tffs_lstat(fname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, (f_size < trunc_size ? f_size : trunc_size));
+}
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(fname, bigbuf, f_size);
+expect(size, trunc_size);  // ++ because of the last -- in for()
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+tw(tr(TR_FUNC, TrTestLow, "Truncate file while it is open \n"));
+fdi = tffs_open(fname, FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) &tdata[TDATA_HUGE][trunc_size], 31);
+expect(size, 31);
+f_size = trunc_size + 31;
+// Truncate to a size less than fp, this will fail
+error = tffs_ftruncate(fdi, f_size - 1);
+expect(error, EFFS_INVALID);
+// Move fp otherwise it will not be possible to truncate
+error = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(error, 0);
+// Test truncate from file size + 3 to file size - 3
+for (i = 0; i < 6; i++) {
+trunc_size = f_size + 3 - i;
+tw(tr(TR_FUNC, TrTestLow, "TRUNC file to size %d \n", trunc_size));
+error = tffs_ftruncate(fdi, trunc_size);
+expect(error, EFFS_OK);
+error = tffs_lstat(fname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, (f_size < trunc_size ? f_size : trunc_size));
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(fname, bigbuf, f_size);
+expect(size, trunc_size);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+// We need to test ftruncate with a size less than the first chunk
+fdi = tffs_open(fname, FFS_O_WRONLY);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_ftruncate(fdi, 10);
+expect(error, EFFS_OK);
+error = tffs_ftruncate(fdi, 10);  // same size twice to complicate it
+expect(error, EFFS_OK);
+error = tffs_lstat(fname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, 10);
+error = tffs_ftruncate(fdi, 0);
+expect(error, EFFS_OK);
+error = tffs_ftruncate(fdi, 0);
+expect(error, EFFS_OK);
+error = tffs_lstat(fname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, 0);
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Stream file test, make 2 segments and test around the end of segment
+// 1 (file closed)
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC
+| FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], fs.chunk_size_max + 1);
+expect(size, fs.chunk_size_max + 1);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 31);
+expect(size, 31);
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+f_size = fs.chunk_size_max + 1 + 31;
+for (i = 0; i < 6; i++) {
+trunc_size = fs.chunk_size_max + 1 + 3 - i;
+tw(tr(TR_FUNC, TrTestLow, "TRUNC stream to size %d \n", trunc_size));
+error = tffs_truncate(sname, trunc_size);
+expect(error, EFFS_OK);
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, trunc_size);
+}
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(sname, bigbuf, f_size);
+expect(size, trunc_size);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+// Try to enlarge the file.
+tw(tr(TR_FUNC, TrTestLow, "Try to enlarge the file \n"));
+error = tffs_truncate(sname, trunc_size + 1);
+expect(error, EFFS_OK);
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, trunc_size);
+fdi = tffs_open(sname, FFS_O_WRONLY);
+expect(fdi, FFS_FD_OFFSET);
+error = tffs_ftruncate(fdi, trunc_size + 1);
+expect(error, EFFS_OK);
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, trunc_size);
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Make a file with 2 segments + some data in the buffer, test around
+// end of segment 2 and the begining of segment 1 (file open).
+tw(tr(TR_FUNC, TrTestLow, "Truncate stream while it is open \n"));
+// Make segment 1
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_APPEND | FFS_O_TRUNC);
+expect(fdi, FFS_FD_OFFSET);
+f_size = tffs_write(fdi, (char *) tdata[TDATA_HUGE],
+2 * fs.chunk_size_max + 1);
+expect(f_size, 2 * fs.chunk_size_max + 1);
+// Move fp otherwise it will not be possible to truncate
+error = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(error, 0);
+// Test around end of segment 2
+for (i = 0; i < 16; i++) {
+trunc_size = f_size + 3 - i;
+tw(tr(TR_FUNC, TrTestLow, "TRUNC stream to size %d \n",
+trunc_size));
+error = tffs_ftruncate(fdi, trunc_size);
+expect(error, EFFS_OK);
+error = tffs_lstat(sname, &stat); expect(error, EFFS_OK);
+expect_eq(stat.size, (f_size < trunc_size ? f_size : trunc_size));
+}
+// Test around begining of segment 1
+for (i = 0; i < 6; i++) {
+trunc_size = 3 - i;
+tw(tr(TR_FUNC, TrTestLow, "TRUNC stream to size %d \n",
+trunc_size));
+error = tffs_ftruncate(fdi, trunc_size);
+if (trunc_size >= 0) {
+expect(error, EFFS_OK);
+}
+else {
+expect(error, EFFS_INVALID);
+break;
+}
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, (trunc_size));
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Make, truncate and append to a file (use ffs_ftruncate())
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC
+| FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+f_size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], fs.chunk_size_max);
+expect(f_size, fs.chunk_size_max );
+tw(tr(TR_FUNC, TrTestLow, "write 1/2 buf size, trunc 1/4 buf size\n"));
+// write 1/2 buf size and truncate 1/4 buf size x times
+for (i = 0; i < 8; i++) {
+size = tffs_write(fdi, (char *) &tdata[TDATA_HUGE][f_size],
+fs.chunk_size_max / 2);
+if (size < 0) return size;
+f_size += size;
+size = tffs_seek(fdi, - fs.chunk_size_max / 4, FFS_SEEK_CUR);
+expect(size, f_size - fs.chunk_size_max / 4);
+error = tffs_ftruncate(fdi, f_size - fs.chunk_size_max / 4);
+expect(error, EFFS_OK);
+f_size -= fs.chunk_size_max / 4;
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, f_size);
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(sname, bigbuf, bigbuf_size);
+expect(size, f_size);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, f_size);
+if (error) return 1;
+// backwards trunc 1/2 write 1/4 x times
+tw(tr(TR_FUNC, TrTestLow, "trunc 1/2 buf size, write 1/4 buf size\n"));
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+for (i = 0; i < 8; i++) {
+size = tffs_seek(fdi, - fs.chunk_size_max / 2, FFS_SEEK_CUR);
+expect(size, f_size - fs.chunk_size_max / 2);
+error = tffs_ftruncate(fdi, f_size - fs.chunk_size_max / 2);
+expect(error, EFFS_OK);
+f_size -= fs.chunk_size_max / 2;
+f_size += tffs_write(fdi, (char *) &tdata[TDATA_HUGE][f_size],
+fs.chunk_size_max / 4);
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, f_size);
+}
+if (p0) { error = test_run("irec"); if (error > 0) return 1; }
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(sname, bigbuf, bigbuf_size);
+expect(size, f_size);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, f_size);
+if (error) return 1;
+tw(tr(TR_FUNC, TrTestLow, "Make 2 segments, truncate to zero and append\n"));
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC
+| FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+size = tffs_write(fdi, (char*) tdata[TDATA_HUGE], 2 * fs.chunk_size_max + 10);
+expect(size, 2 * fs.chunk_size_max + 10);
+// Move fp otherwise it will not be possible to truncate
+error = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(error, 0);
+error = tffs_ftruncate(fdi, 0);
+expect(error, EFFS_OK);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 150);
+expect(size, 150 );
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+if (p0) { error = test_run("irec;brec"); if (error > 0) return 1; }
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+f_size = tffs_fread(sname, bigbuf, bigbuf_size);
+expect(f_size, size);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, f_size);
+if (error) return 1;
+// Truncate through a symlink
+error = tffs_symlink("/str", sname);
+expect(error, EFFS_OK);
+error = tffs_truncate("/str", 100);
+expect(error, EFFS_OK);
+f_size = tffs_fread(sname, bigbuf, bigbuf_size);
+expect(f_size, 100);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, f_size);
+if (error) return 1;
+tffs_remove("/str");
+// truncate a file which only have data in the stream buffer
+fdi = tffs_open(sname, FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC
+| FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+f_size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], 3);
+expect(f_size, 3);
+// Move fp otherwise it will not be possible to truncate
+error = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(error, 0);
+tw(tr(TR_FUNC, TrTestLow, "Truncate in buffer\n"));
+for (i = 0; i < 4; i++) {
+error = tffs_ftruncate(fdi, --f_size);
+if (f_size >= 0) {
+expect(error, EFFS_OK);
+error = tffs_lstat(sname, &stat);
+expect(error, EFFS_OK);
+expect_eq(stat.size, f_size);
+}
+else {
+expect(error, EFFS_INVALID);
+}
+}
+error = tffs_close(fdi);
+expect(error, EFFS_OK);
+// Try to truncate a read-only file
+error = tffs_fwrite(imeifile, TDATA(0));
+// The file is maybe already created!
+error = tffs_fcontrol(imeifile, OC_FLAGS, OF_READONLY);
+error = tffs_truncate(imeifile, 0);
+expect(error, EFFS_ACCESS);
+// Use ffs_truncate() on a file open in read mode
+fdi = tffs_open(fname, FFS_O_RDONLY);
+error = tffs_truncate(fname, 0);
+expect(error, EFFS_LOCKED);
+error = tffs_ftruncate(fdi, 0);
+expect(error, EFFS_INVALID);
+error = tffs_close(fdi);
+expect_ok(error);
+return 0;
+}
+int case_append(int p0, int p1)
+{
+fd_t fdi;
+int size, fsize;
+char sname[] = "/stream/append1";
+char fname[] = "/stream/append2";
+int offset = 0;
+if (param.data_blocks <= 1) {
+ttw(ttr(TTrTest, "WARNING: Too few blocks to run. Skip test" NL));
+tw(tr(TR_FUNC, TrTest, "WARNING: Too few blocks to run. Skip test\n"));
+return 0;
+}
+case_cleanup(fs.chunk_size_max * 5);
+tffs_mkdir("/stream");
+fdi = tffs_open(sname, FFS_O_RDWR | FFS_O_APPEND | FFS_O_TRUNC |
+FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+// Write data in buf and seek in the buf
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE], fs.chunk_size_max / 2);
+expect_gt(size, 0);
+offset = ffs_seek(fdi, -fs.chunk_size_max / 4, FFS_SEEK_CUR);
+expect_gt(offset, 0);
+expect(1, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+// Append data and seek in the buffer ad the end of the last chunk
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] +
+fs.fd[fdi - FFS_FD_OFFSET].size, fs.chunk_size_max);
+expect_gt(size, 0);
+offset = ffs_seek(fdi, -fs.chunk_size_max / 4, FFS_SEEK_END);
+expect_gt(offset, 0);
+size = tffs_read(fdi, bigbuf, fs.chunk_size_max / 4);
+expect(size, fs.chunk_size_max / 4);
+expect(1, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+// Append data and seek away from buf
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] +
+fs.fd[fdi - FFS_FD_OFFSET].size, fs.chunk_size_max * 1.5);
+expect_gt(size, 0);
+offset = ffs_seek(fdi, -fs.chunk_size_max * 2, FFS_SEEK_END);
+expect_gt(offset, 0);
+size = tffs_read(fdi, bigbuf, fs.chunk_size_max / 4);
+expect(size, fs.chunk_size_max / 4);
+// Append again and validate the data
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] +
+fs.fd[fdi - FFS_FD_OFFSET].size, fs.chunk_size_max / 2);
+expect_gt(size, 0);
+offset = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(0, offset);
+size = tffs_read(fdi, bigbuf, fs.fd[fdi - FFS_FD_OFFSET].size);
+expect_gt(size, 0);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+error = tffs_close(fdi);
+expect_ok(error);
+// Append on a file with data in the seghead
+fsize = fs.chunk_size_max / 4;
+error = tffs_file_write(fname, (char *)tdata[TDATA_HUGE], fsize,
+FFS_O_TRUNC | FFS_O_WRONLY | FFS_O_CREATE);
+expect(error, EFFS_OK);
+fdi = tffs_open(fname, FFS_O_RDWR | FFS_O_APPEND);
+expect(fdi, FFS_FD_OFFSET);
+// Write data in buf and seek in the buf
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] + fsize,
+fs.chunk_size_max / 2);
+expect_gt(size, 0);
+fsize += size;
+offset = ffs_seek(fdi, 0, FFS_SEEK_SET);
+expect(offset, 0);
+expect(1, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] + fsize,
+fs.chunk_size_max / 2);
+expect_gt(size, 0);
+fsize += size;
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, fsize);
+if (error) return 1;
+error = tffs_close(fdi);
+expect_ok(error);
+return 0;
+}
+int case_datasync(int p0, int p1)
+{
+fd_t fdi;
+int size, fsize, offset, i;
+char myname[] = "/datasync";
+error = case_cleanup(4 * fs.chunk_size_max);
+expect_ok(error);
+fdi = tffs_open(myname, FFS_O_RDWR | FFS_O_TRUNC | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+fsize = 0;
+for (i = 0; i < 10; i++) {
+// Write data in buf and use datasync
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] + fsize,
+fs.chunk_size_max / 3);
+expect_gt(size, 0);
+fsize += size;
+error = tffs_fdatasync(fdi);
+expect(error, EFFS_OK);
+expect(0, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+}
+error = tffs_fdatasync(fdi + 1);
+expect(error, EFFS_BADFD);
+// Seek to chunk 2, write data, seek, use fdatasync
+offset = tffs_seek(fdi, fs.chunk_size_max * 2.5, FFS_SEEK_SET);
+expect_gt(offset, 0);
+size = tffs_write(fdi, (char *) tdata[TDATA_HUGE] + offset,
+fs.chunk_size_max / 4);
+expect_gt(size, 0);
+offset = tffs_seek(fdi, -fs.chunk_size_max / 2, FFS_SEEK_CUR);
+expect_gt(offset, 0);
+error = tffs_fdatasync(fdi);
+expect(error, EFFS_OK);
+expect(0, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+error = tffs_close(fdi);
+expect_ok(error);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread(myname, bigbuf, fsize);
+tw(tr(TR_FUNC, TrTestLow, "size: %d fsize: %d \n", size, fsize));
+expect(size, fsize);
+error = test_expect_data((char *)tdata[TDATA_HUGE], bigbuf, size);
+if (error) return 1;
+return 0;
+}
+int case_fw_flags(int p0, int p1)
+{
+int i;
+char myname[] = "/file_write";
+tffs_remove(myname);
+tw(tr(TR_FUNC, TrTestHigh, "Test ffs_file_write() flags, file non-exist\n"));
+for (i = 0; i < 0xFE; i++) {
+error = tffs_file_write(myname, 0,0, i);
+if (is_open_option(i, FFS_O_CREATE)) {
+expect_ok(error);
+error = tffs_remove(myname);
+expect_ok(error);
+}
+else
+expect(EFFS_NOTFOUND, error);
+}
+tw(tr(TR_FUNC, TrTestHigh, "Test ffs_file_write() flags, file exist\n"));
+error = tffs_file_write(myname, 0,0, FFS_O_CREATE);
+expect_ok(error);
+for (i = 0; i < 0xFF; i++) {
+error = tffs_file_write(myname, 0,0, i);
+if (is_open_option(i, FFS_O_EXCL) && is_open_option(i, FFS_O_CREATE)) {
+expect(error, EFFS_EXISTS);
+}
+else
+expect_ok(error);
+}
+return 0;
+}
+drv_Return_Type pcm_init(void);
+int case_pcm(int p0, int p1)
+{
+UBYTE version;
+UBYTE imei[] = "12345678";
+int size;
+ffs_mkdir("/pcm");
+// Write imei file to ffs. Run init (this reads the imei file), remove
+// the file from flash, write the imei to flash from pcm and validate
+// data.
+error = ffs_file_write("/pcm/IMEI", &imei, sizeof(imei), FFS_O_CREATE);
+expect_ok(error);
+error = pcm_init();
+expect(PCM_INITIALIZED, error);
+error = pcm_ReadFile((UBYTE *) EF_IMEI_ID, SIZE_EF_IMEI, imei, &version);
+expect(PCM_OK, error);
+error = ffs_remove("/pcm/IMEI");
+expect_ok(error);
+error =  pcm_WriteFile((UBYTE *) EF_IMEI_ID, SIZE_EF_IMEI, imei);
+expect(PCM_OK, error);
+tw(tr(TR_FUNC, TrTestLow, "Validate data \n"));
+size = tffs_fread("/pcm/IMEI", bigbuf, bigbuf_size);
+expect(size, SIZE_EF_IMEI);
+error = test_expect_data(imei, bigbuf, size);
+if (error) return 1;
+// TODO: test pcm_WriteRecord and pcm_ReadRecord.
+return 0;
+}
+int case_api_exceptions(int p0, int p1)
+{
+int i;
+T_FFS_DIR dir;
+T_FFS_FD myfdi;
+char myname[] = "/BAD";
+char mydir[] = "/tdir";
+char mylink[] = "/tlink";
+char mytfile[] = "/tfile";
+char buf[] = "foobar";
+// Create test file and dir
+error = tffs_file_write(mytfile, buf, sizeof(buf), FFS_O_CREATE);
+expect_ok(error);
+error = tffs_mkdir(mydir);
+if (error < 0 && error != EFFS_EXISTS) return 1;
+error = tffs_symlink(mytfile, mylink);
+if (error < 0 && error != EFFS_EXISTS) return 1;
+error = tffs_opendir(mydir, &dir);
+expect_ok(error);
+myfdi = tffs_open("/tsream", FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC);
+expect(myfdi, FFS_FD_OFFSET);
+expect(tffs_write(myfdi, buf, sizeof(buf)), sizeof(buf));
+// Test all API functions for pathname with null pointers.
+for (i = 0; i < 17; i++) {
+switch (i) {
+case 0: error = tffs_open(0, FFS_O_WRONLY | FFS_O_CREATE); break;
+case 1: error = tffs_truncate(0, 1);    break;
+case 2: error = tffs_file_write(0, buf, sizeof(buf), FFS_O_CREATE); break;
+case 3: error = tffs_stat(0, &stat);    break;
+case 4: error = tffs_lstat(0, &stat);   break;
+case 5: error = tffs_xlstat(0, &xstat); break;
+case 6: error = tffs_remove(0);         break;
+case 7: error = tffs_mkdir(0);          break;
+case 8: error = tffs_opendir(0, &dir);  break;
+case 9: error = tffs_symlink(0, myname); break;
+case 10: error = tffs_symlink("/link", 0); break;
+case 11: error = tffs_readlink(0, buf, sizeof(buf)); break;
+case 12: error = tffs_rename(0, "/test"); break;
+case 13: error = tffs_rename(mytfile, 0); break;
+case 14: error = tffs_file_write(0, buf, sizeof(buf), FFS_O_CREATE); break;
+case 15: error = tffs_file_read(0, buf, sizeof(buf)); break;
+case 16: error = tffs_fcontrol(0, OC_FLAGS, OF_READONLY); break;
+default: error = EFFS_INVALID;
+}
+expect(error, EFFS_BADNAME);
+}
+// Test all API functions with buffer null pointers.
+for (i = 0; i < 13; i++) {
+switch (i) {
+case 0: error = tffs_file_write(myname, 0, 100, FFS_O_CREATE); break;
+case 1: error = tffs_file_read(mytfile, 0, 40); break;
+case 2: error = tffs_opendir(mydir, 0); break;
+case 3: error = ffs_readdir (0, buf, sizeof(buf)); break;
+case 4: error = ffs_readdir (&dir, 0, 100); break;
+case 5: error = tffs_readlink(mylink, 0, 1); break;
+case 6: error = tffs_stat(mytfile, 0); break;
+case 7: error = tffs_lstat(mylink, 0); break;
+case 8: error = tffs_xlstat(mylink, 0); break;
+case 9: error = tffs_query(Q_BYTES_FREE, 0); break;
+case 10: error = tffs_fstat(myfdi, 0); break;
+case 11: error = tffs_write(myfdi, 0, 10); break;
+case 12: error = tffs_read(myfdi, 0, 40); break;
+default: error = 0;
+}
+expect(error, EFFS_INVALID);
+}
+expect_ok(tffs_close(myfdi));
+// Make sure we still can create empty files!
+error = tffs_file_write("/empty_file", 0, 0, FFS_O_CREATE);
+expect_ok(error);
+// Open file for test of negative size
+myfdi = tffs_open(myname, FFS_O_RDWR | FFS_O_CREATE |
+FFS_O_TRUNC | FFS_O_APPEND);
+expect(myfdi, FFS_FD_OFFSET);
+// Test all API 'size' parameters with a negative size
+for (i = 0; i < 11; i++) {
+switch (i) {
+// Try modify
+case 0: error = tffs_write(myfdi, buf, -1); break;
+case 1: error = tffs_truncate(myname, -1); break;
+case 2: error = tffs_fwrite(myname, buf, -2); break;
+case 3: error = tffs_fcreate(myname, buf, -3); break;
+case 4: error = tffs_fupdate(myname, buf, -56); break;
+case 5: error = tffs_file_write(myname, buf, -100, FFS_O_CREATE); break;
+// Try read
+case 6: error = tffs_fread(mytfile, bigbuf, -1); break;
+case 7: error = tffs_file_read(mytfile, bigbuf, -2); break;
+case 8: error = tffs_readdir(&dir, bigbuf, -3); break;
+case 9: error = tffs_readlink(mytfile, bigbuf, -4); break;
+case 10: error = tffs_read(myfdi, bigbuf, -5); break;
+default: error = 0;
+}
+expect(error, EFFS_INVALID);
+}
+error = tffs_close(myfdi);
+expect_ok(error);
+return EFFS_OK;
+}
+int case_api_notformated(int p0, int p1)
+{
+int i;
+struct dir_s dir;
+fd_t fdi;
+char buf[20];
+uint16 q_out;
+struct xstat_s xstat;
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+for(i=1; i<24; i++)
+{
+switch(i)
+{
+case 1:  error = tffs_open("apinf", FFS_O_WRONLY);          break;
+case 2:  error = tffs_close(fdi);                         break;
+case 3:  error = tffs_write(fdi, "abcdefghij", 10);       break;
+case 4:  error = tffs_read(fdi, buf, 2);                  break;
+case 5:  error = tffs_seek(fdi, 0, FFS_SEEK_SET);         break;
+case 6:  error = tffs_truncate("apinf", 0);                 break;
+case 7:  error = tffs_fdatasync(fdi);                     break;
+case 8:  error = tffs_stat("apinf", &stat);                 break;
+case 9:  error = tffs_fstat(fdi, &stat);                  break;
+case 10: error = tffs_lstat("apinf", &stat);                break;
+case 11: error = tffs_xlstat("apinf", &xstat);              break;
+case 12: error = ffs_remove("/apinf");                      break;
+case 13: error = ffs_mkdir("/apinf");                       break;
+case 14: error = ffs_opendir("/apinf", &dir);               break;
+case 15: error = tffs_readdir(&dir, "/ffs", 21);          break;
+case 16: error = tffs_symlink("/europe/imie", "imei");    break;
+case 17: error = ffs_rename("/Pluto", "/Dog");            break;
+case 18: error = ffs_file_write("/non-exist", "1234567890", 10, FFS_O_TRUNC);          break;
+case 19: error = tffs_file_read("/stream1", buf, 10);     break;
+case 20: error = tffs_fcreate("/", "apinf", 3);             break;
+case 21: error = tffs_fupdate("/", "bar", 3);             break;
+case 22: error = tffs_fwrite("/europe/imie","0123456789", 10);          break;
+case 23: error = tffs_fcontrol("/apinf", OC_FLAGS, OF_READONLY);          break;
+}
+expect(error, EFFS_NOFORMAT);
+}
+/* query must return information even if the device isnt formated */
+error = tffs_query(Q_FS_INODES, (uint16 *) &q_out);
+expect(error, EFFS_OK);
+return 0;
+}
+int case_query(int p0, int p1)
+{
+int i;
+uint32 ret_val32;
+uint16 ret_val16;
+for(i=1; i<27; i++)
+{
+switch(i)
+{
+case 1:  error = ffs_query(Q_TM_BUFADDR, (uint32 *)&ret_val32); break;
+case 2:  error = ffs_query(Q_TM_BUFSIZE, (uint32 *)&ret_val32); break;
+case 3:  error = ffs_query(Q_DEV_BASE, (uint32 *)&ret_val32); break;
+case 4:  error = ffs_query(Q_FFS_API_VERSION, (uint16 *)&ret_val16); break;
+case 5:  error = ffs_query(Q_FFS_DRV_VERSION, (uint16 *)&ret_val16); break;
+case 6:  error = ffs_query(Q_FFS_REVISION, (uint16 *)&ret_val16); break;
+case 7:  error = ffs_query(Q_FFS_FORMAT_WRITE, (uint16 *)&ret_val16); break;
+case 8:  error = ffs_query(Q_FFS_FORMAT_READ, (uint16 *)&ret_val16); break;
+case 9:  error = ffs_query(Q_FFS_LASTERROR, (uint16 *)&ret_val16); break;
+case 10:  error = ffs_query(Q_FFS_TM_VERSION, (uint16 *)&ret_val16); break;
+case 11:  error = ffs_query(Q_OBJECTS_MAX, (uint16 *)&ret_val16); break;
+case 12:  error = ffs_query(Q_CHUNK_SIZE_MAX, (uint16 *)&ret_val16); break;
+case 13:  error = ffs_query(Q_FD_BUF_SIZE, (uint32 *)&ret_val32); break;
+case 14:  error = ffs_query(Q_FD_MAX, (uint16 *)&ret_val16); break;
+case 15:  error = ffs_query(Q_DEV_MANUFACTURER, (uint16 *)&ret_val16); break;
+case 16:  error = ffs_query(Q_DEV_DEVICE, (uint16 *)&ret_val16); break;
+case 17:  error = ffs_query(Q_DEV_DRIVER, (uint16 *)&ret_val16); break;
+case 18:  error = ffs_query(Q_LOST_HIGH, (uint16 *)&ret_val16); break;
+case 19:  error = ffs_query(Q_FS_FLAGS, (uint16 *)&ret_val16); break;
+case 20:  error = ffs_query(Q_FS_ROOT, (uint16 *)&ret_val16); break;
+case 21:  error = ffs_query(Q_STATS_DRECLAIMS, (uint32 *)&ret_val32); break;
+case 22:  error = ffs_query(Q_STATS_IRECLAIMS, (uint32 *)&ret_val32); break;
+case 23:  error = ffs_query(Q_STATS_DATA_RECLAIMED, (uint32 *)&ret_val32); break;
+case 24:  error = ffs_query(Q_STATS_INODES_RECLAIMED, (uint32 *)&ret_val32); break;
+case 25:  error = ffs_query(Q_STATS_DATA_ALLOCATED, (uint32 *)&ret_val32); break;
+case 26:  error = ffs_query(Q_REQUEST_ID_LAST, (uint32 *)&ret_val32); break;
+}
+expect(error, EFFS_OK);
+}
+return 0;
+}
+extern uint16 ffs_flash_device;
+extern uint16 ffs_flash_manufact;
+int case_octrl(int p0, int p1)
+{
+int org_fsflags = fs.flags, org_manufact = ffs_flash_manufact;
+int org_device = ffs_flash_device, org_testf = fs.testflags;
+error = object_control(0, OC_FS_FLAGS, 0x02);
+expect(error, EFFS_OK);
+error = object_control(0, OC_DEV_MANUFACT, 'T');
+expect(error, EFFS_OK);
+error = object_control(0, OC_DEV_DEVICE, 0x0F12);
+expect(error, EFFS_OK);
+error = object_control(0, OC_DEBUG_0, 0xAFFE);
+expect(error, EFFS_OK);
+error = object_control(0, OC_DEBUG_LAST+1, 0);
+expect(error, EFFS_INVALID);
+// Restore the values or else it mess up the other tests
+fs.flags = org_fsflags;
+fs.testflags = org_testf;
+ffs_flash_manufact = org_manufact;
+ffs_flash_device = org_device;
+return 0;
+}
+/***************************************************************************/
+/*          Examples from RIV111                                           */
+/***************************************************************************/
+#if (TARGET == 0)
+int case_examples(int p0, int p1)
+{
+return 0;
+}
+#else
+static req_id_t my_request_id;
+static int removed_greeting;
+static void my_callback(T_FFS_FILE_CNF *confirm)
+{
+ttw(ttr(TTrTest, "my_callback(%d, %s, %d)" NL,
+confirm->error, confirm->path, confirm->request_id));
+if (my_request_id !=  confirm->request_id) {
+ttw(ttr(TTrFatal, "error (%d, %d)" NL, confirm->request_id, my_request_id));
+return;
+}
+if (confirm->error < 0) {
+ttw(ttr(TTrTest, "FATAL: my_callback error: %d" NL, confirm->error));
+}
+else {
+ttw(ttr(TTrTest, "Remove 'greeting'" NL));
+ffs_remove_nb("/greeting", 0);
+removed_greeting = 1;
+}
+error = rvf_free_buf(confirm);
+if (error < 0)
+ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error);
+}
+// Using Function Callback
+T_RV_RETURN my_fc_cnfpath = {0, (CALLBACK_FUNC)my_callback};
+// Using Mail Callback
+#define MY_TASK_ID (MAX_RVF_TASKS - 1 - 1)  // same as FFS_TEST_TASK_ID
+T_RV_RETURN my_mail_cnfpath = {MY_TASK_ID, 0};
+int case_examples(int p0, int p1)
+{
+if(1) {
+// MMI Configuration scenario
+struct {
+int volume;
+uint32 ringtype;
+} mmi;
+int temp;
+ttw(ttr(TTrTest, "Run MMI conf." NL));
+mmi.volume = temp = 3;
+mmi.ringtype = 1111;
+ffs_mkdir("/mmi");
+ffs_fwrite("/mmi/volume", &mmi.volume, sizeof(mmi.volume));
+error = ffs_file_read("/mmi/volume", &mmi.volume, sizeof(mmi.volume));
+if (error < 0)
+return 1;
+error = test_expect_data(&temp, &mmi.volume, sizeof(mmi.volume));
+if (error < 0)
+return 1;
+}
+if(1) {
+// Using Mail Callback
+T_FFS_FILE_CNF *confirm_file;
+T_FFS_STREAM_CNF *confirm_stream;
+T_FFS_RET error;
+T_FFS_FD fdi;
+char hello[] = "Hello, world";
+T_FFS_SIZE size;
+ttw(ttr(TTrTest, "Use Mail Callback" NL));
+if ((my_request_id = ffs_open_nb("/mmi/sound",
+FFS_O_WRONLY | FFS_O_CREATE |
+FFS_O_APPEND | FFS_O_TRUNC,
+&my_mail_cnfpath)) < 0)
+return my_request_id;
+ttw(ttr(TTrTest, "Wait..." NL));
+rvf_wait(RVF_TASK_MBOX_0_EVT_MASK, 0);
+ttw(ttr(TTrTest, "Get mail" NL));
+confirm_file = (T_FFS_FILE_CNF *) rvf_read_mbox(RVF_TASK_MBOX_0);
+fdi = confirm_file->error;
+expect(FFS_FD_OFFSET, fdi);
+expect(my_request_id, confirm_file->request_id);
+expect(FFS_MESSAGE_OFFSET, confirm_file->header.msg_id);
+ttw(ttr(TTrTest, "Path '%s'" NL, confirm_file->path));
+error = rvf_free_buf(confirm_file);
+if (error < 0)
+ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error);
+if ((my_request_id = ffs_write_nb(fdi, hello, strlen(hello) ,
+&my_mail_cnfpath)) < 0)
+return my_request_id;
+ttw(ttr(TTrTest, "Wait..." NL));
+rvf_wait(RVF_TASK_MBOX_0_EVT_MASK, 0);
+ttw(ttr(TTrTest, "Get mail" NL));
+confirm_stream = (T_FFS_STREAM_CNF *) rvf_read_mbox(RVF_TASK_MBOX_0);
+size = confirm_stream->error;
+expect(strlen(hello), size);
+expect(my_request_id, confirm_stream->request_id);
+ttw(ttr(TTrTest, "fdi: %d" NL, confirm_stream->fdi));
+error = rvf_free_buf(confirm_stream);
+if (error < 0)
+ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error);
+ttw(ttr(TTrTest, "Close file" NL));
+if ((error = ffs_close(fdi)) < 0)
+return error;
+}
+if(1) {
+// Using Function Callback
+char hello[] = "Hello, world";
+T_FFS_STAT stat;
+ttw(ttr(TTrTest, "Use Function Callback" NL));
+if ((my_request_id = ffs_fcreate_nb("/greeting", hello, strlen(hello),
+&my_fc_cnfpath)) < 0)
+return my_request_id;
+// Wait until my_callback() has removed the file "greeting"
+removed_greeting = 0;
+while (removed_greeting == 0)
+tffs_delay(10);
+// NOTE: This is importent because if the test brec runs immediately
+// after his one will the brec test fail because the "greeting" file
+// is removed inside the brec test which don't expect that files is
+// removed.
+}
+return 0;
+}
+#endif
+/******************************************************************************
+* Non blocking test ffs_xx_nb()
+******************************************************************************/
+#if (TARGET == 0)
+int case_nonblock(int p0, int p1)
+{
+tw(tr(TR_FUNC, TrTest,
+"WARNING: This test can only run in target. Skip test\n"));
+return 0;
+}
+#else
+extern int request_id_last;  // from task.c
+#define WAIT_GET_TEST      ttw(ttr(TTrTest, "Wait..." NL)); rvf_wait(RVF_TASK_MBOX_0_EVT_MASK, 0); ttw(ttr(TTrTest, "Get mail" NL)); confirm_file = (T_FFS_FILE_CNF *) rvf_read_mbox(RVF_TASK_MBOX_0); ttw(ttr(TTrTest, "Path '%s'" NL, confirm_file->path)); expect(FFS_MESSAGE_OFFSET, confirm_file->header.msg_id); expect(my_id, confirm_file->request_id);
+#define WAIT_GET_TEST_FDI  ttw(ttr(TTrTest, "Wait..." NL)); rvf_wait(RVF_TASK_MBOX_0_EVT_MASK, 0); confirm_stream = (T_FFS_STREAM_CNF *) rvf_read_mbox(RVF_TASK_MBOX_0); ttw(ttr(TTrTest, "Get mail" NL)); ttw(ttr(TTrTest, "fdi: %d" NL, confirm_stream->fdi)); expect(FFS_MESSAGE_OFFSET, confirm_stream->header.msg_id); expect(FFS_FD_OFFSET, confirm_stream->fdi); expect(my_id, confirm_stream->request_id);
+#define FREE error = rvf_free_buf(confirm_file); if (error < 0) { ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error); return 1;}
+#define FREE_FDI error = rvf_free_buf(confirm_stream); if (error < 0) { ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error); return 1;}
+int case_nonblock(int p0, int p1)
+{
+T_FFS_FILE_CNF *confirm_file;
+T_FFS_STREAM_CNF *confirm_stream;
+T_FFS_RET error;
+T_FFS_FD fdi;
+char hello[] = "Hello, world";
+char myfname[] = "/non_block/file";
+char mysname[] = "/non_block/stream";
+T_FFS_SIZE size;
+int i;
+T_FFS_REQ_ID my_id;
+// mail confirm
+T_RV_RETURN cnfpath = {MY_TASK_ID, 0};
+// Test wrap arround in request_id_get(). Set id to 5 from max, the following
+// function calls will trigger the wrap arround
+request_id_last = 0x7FFFFFFF - 5;
+ttw(ttr(TTrTest, "request :%d" NL, request_id_last));
+// preformat, format, mkdir
+// open, write, ftruncate, close, remove,
+// file_write, symlink, rename, truncate, fcontrol
+my_id = ffs_preformat_nb(0xDEAD, &cnfpath);
+expect_gt(my_id, -1);
+WAIT_GET_TEST; FREE;
+my_id = ffs_format_nb("/ffs", 0x2BAD, &cnfpath);
+expect_gt(my_id, -1);
+WAIT_GET_TEST; FREE;
+my_id = ffs_mkdir_nb("/non_block", &cnfpath);
+expect_gt(my_id, -1);
+WAIT_GET_TEST; FREE;
+if ((my_id = ffs_open_nb(mysname, FFS_O_WRONLY | FFS_O_CREATE,
+&cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+fdi = confirm_file->error;
+expect(FFS_FD_OFFSET, fdi);
+FREE;
+if ((my_id = ffs_write_nb(fdi, hello, strlen(hello), &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST_FDI; FREE_FDI;
+expect(1, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+if ((my_id = ffs_fdatasync_nb(fdi, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST_FDI; FREE_FDI;
+expect(0, fs.fd[fdi - FFS_FD_OFFSET].dirty);
+if ((my_id = ffs_seek_nb(fdi, 2, FFS_SEEK_SET, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST_FDI; FREE_FDI;
+expect(2, fs.fd[fdi - FFS_FD_OFFSET].fp);
+if ((my_id = ffs_ftruncate_nb(fdi, 3, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST_FDI;
+expect(EFFS_OK, confirm_stream->error);
+FREE_FDI;
+if ((my_id = ffs_close_nb(fdi, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST_FDI;
+expect(EFFS_OK, confirm_stream->error);
+FREE_FDI;
+if ((my_id = ffs_remove_nb(mysname, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+if ((my_id = ffs_file_write_nb(myfname, hello, strlen(hello),
+FFS_O_WRONLY | FFS_O_CREATE, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+if ((my_id = ffs_symlink_nb("/nb_file", myfname, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+if ((my_id = ffs_rename_nb("/nb_file", "/nbf", &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+if ((my_id = ffs_truncate_nb(myfname, 0, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+if ((my_id = ffs_fcontrol_nb(myfname, OC_FLAGS, OF_READONLY, &cnfpath)) < 0)
+return my_id;
+WAIT_GET_TEST;
+expect(EFFS_OK, confirm_file->error);
+FREE;
+ttw(ttr(TTrTest, "request :%d" NL, request_id_last));
+// This should make a EFFS_MEMORY fail
+for(i = 0; i < 10000; i++) {
+my_id = ffs_fwrite_nb("/mem_test", TDATA(0), 0);
+if (my_id < 0)
+break;
+}
+ttw(ttr(TTrTest, "write nr: %d my_id: %d" NL, i, my_id));
+expect(my_id, EFFS_MEMORY);
+// All memory has been used so wait a while (let some of the writes finish)
+tffs_delay(50);
+// Make a call to a blocking function will make it possible for ffs to
+// finish all the non blocking writes.
+error = ffs_fwrite("/mem_test", TDATA(0));
+expect_ok(error);
+return 0;
+}
+#endif
+/******************************************************************************
+* Blocking test
+******************************************************************************/
+#if (TARGET == 0)
+int case_blocking(int p0, int p1)
+{
+tw(tr(TR_FUNC, TrTest,
+"WARNING: This test can only run in target. Skip test\n"));
+return 0;
+}
+#else
+#include "ffs/board/task.h"
+void my_mb_callback(T_RVF_MB_ID id)
+{ // Dummy callback function
+}
+// Test that a FFS API blocking call that not is able to send a mail to FFS fails as expected and don't lock the system (it must unlock and delete the mutex).
+int case_blocking(int p0, int p1)
+{
+UINT32 mem_unused;
+T_RVF_MB_STATUS status;
+char *buf;
+extern T_OS_MB_ID ffs_mb_id;
+// Later when all the memory is used the memory bank will be marked as
+// RED by Riviera. The RED flag is erased when the buffer is freed but
+// only if a callback function is applied.
+rvf_set_callback_func(ffs_mb_id, my_mb_callback);  // Ignore error
+mem_unused = rvf_get_mb_unused_mem(ffs_mb_id);
+ttw(ttr(TTrTest,"Unused memory: %d" NL, mem_unused));
+// When all the memory is used the blocking functions will not be able
+// to allocate memory to the FFS mail thus it must fail. After the
+// buffer has been freed the block call must again be fully functional.
+if ((buf = (char *) target_malloc(mem_unused)) == 0)
+return EFFS_MEMORY;
+error = tffs_fwrite("/blocking_test", (char*)tdata[TDATA_HUGE], 20);
+target_free(buf);
+expect(error, EFFS_MEMORY);
+error = tffs_fwrite("/blocking_test", (char*)tdata[TDATA_HUGE], 20);
+expect_ok(error);
+return EFFS_OK;
+}
+#endif
+/******************************************************************************
+* Test erase_suspend and erase_resume
+******************************************************************************
+* Test erase suspend and resume by making a call to ffs_begin() followed by
+* an ffs_read() while we are erasing. We trigger the erase by sending
+* several write mails to FFS. We let FFS get the CPU for less time than an
+* erase, which will guarantee that we interrupt the erase when we call
+* ffs_begin().
+******************************************************************************/
+#if (TARGET == 1)
+static int write_mails_left;
+static void driver_callback(T_FFS_FILE_CNF *confirm)
+{
+if (confirm->error < 0) {
+ttw(ttr(TTrTest, "FATAL: driver_callback error: %d" NL, confirm->error));
+}
+error = rvf_free_buf(confirm);
+if (error < 0)
+ttr(TTrFatal, "FFS FATAL: os_free() %d" NL, error);
+write_mails_left--;
+}
+#endif
+#if (TARGET == 0)
+int case_erase_suspend(int p0, int p1)
+{
+tw(tr(TR_FUNC, TrTestHigh, "Erase_suspend test not supported on PC sim\n"));
+return 1;
+}
+#else
+// TEST erase_suspend and erase_resume
+int case_erase_suspend(int p0, int p1)
+{
+int i, j, error, nsuspend;
+char myname[] = "/ffs/b4";      // Run test with only 4 block.
+char myfname[] = "/driver_test";
+int file_size = 1024;
+T_RV_RETURN cnfpath = {0, (CALLBACK_FUNC)driver_callback};
+ttw(ttr(TTrTest, "Erase suspend-resume test" NL));
+// To minimize the numbers of required writes before we are guarantied an
+// erase we run this test in only 4 blocks
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format(myname, 0x2BAD);
+expect(error, EFFS_OK);
+if (p0 == 0) p0 = 1;
+for (j = 0; j < p0; j++) {
+write_mails_left = 0;
+// Write 2 blocks of data (must trigger an erase)
+for (i = 0; i < 2 * (dev.blocksize/file_size); i++)
+{
+// Non blockin write
+if ((error = ffs_file_write_nb(myfname, (char *) tdata[TDATA_HUGE],
+file_size,
+FFS_O_WRONLY | FFS_O_CREATE | FFS_O_TRUNC,
+&cnfpath)) < 0)
+return error;
+write_mails_left++;
+}
+ttw(ttr(TTrTest, "Finish write calls(%d)" NL, i));
+// NOTE only tested with AMD MB driver
+switch (dev.driver) {
+case FFS_DRIVER_AMD:
+case FFS_DRIVER_SST:
+case FFS_DRIVER_INTEL:
+case FFS_DRIVER_AMD_SB:
+ttw(ttr(TTrTest, "Start read test" NL));
+nsuspend = 0;
+do {
+// NOTEME: We can also test if we get the CPU and not is delay
+// by the erase
+// This will change state to ERASE_SUSPEND if we are in
+// ERASE mode (only valid for MB driver)
+error = ffs_begin();
+expect(error, EFFS_OK);
+if (dev.state == DEV_ERASE_SUSPEND) {
+nsuspend++;
+// Read... Note it will also resume the erase (MB driver).
+error = tffs_file_read(myfname, bigbuf, file_size/4);
+expect(error, EFFS_FILETOOBIG);
+}
+rvf_delay(5);  // Let FFS get the CPU for some time
+} while (write_mails_left > 0);
+if (nsuspend <= 0) {
+ttw(ttr(TTrTest, "Arg no erase suspend" NL));
+return 1;
+}
+ttw(ttr(TTrTest, "Erase suspended %d times" NL, nsuspend));
+break;
+case FFS_DRIVER_SST_SB:
+case FFS_DRIVER_INTEL_SB:
+default:
+ttw(ttr(TTrTest, "Driver not supported by this test" NL));
+// Do not return before the cnfpath resource not is used anymore
+while (write_mails_left > 0) rvf_delay(100);
+return 1;
+}
+}
+return 0;
+}
+#endif // TARGET == 0
+/******************************************************************************
+* The 3 below testh_.. function is helper function used for the low level
+* driver tests.
+******************************************************************************/
+#if (TARGET == 1)
+uint32 int_disable(void);
+void int_enable(uint32 tmp);
+// Only start an erase, don't wait until it is finish
+// Note to use this function with SB drivers require a multi bank flash device
+int testh_nb_erase(uint8 block)
+{
+volatile char *flash = dev.base;
+volatile char *addr;
+uint32 cpsr;
+ttw(ttr(TTrTest, "e(%d)" NL, block));
+addr = block2addr(block);
+cpsr = int_disable();
+switch (dev.driver) {
+case FFS_DRIVER_AMD:
+case FFS_DRIVER_AMD_SB:
+case FFS_DRIVER_AMD_PSEUDO_SB:
+flash[0xAAAA] = 0xAA; // AMD unlock cycle 1
+flash[0x5555] = 0x55; // AMD unlock cycle 2
+flash[0xAAAA] = 0x80;
+flash[0xAAAA] = 0xAA; // AMD unlock cycle 1
+flash[0x5555] = 0x55; // AMD unlock cycle 2
+*addr         = 0x30; // AMD erase sector command
+int_enable(cpsr);
+break;
+default:
+return -1; // Not yet supported
+}
+return 0;
+}
+// Note to use this function with SB drivers require a multi bank flash device
+int testh_erase_suspend(uint8 block)
+{
+volatile char *flash = dev.base;
+volatile char *addr;
+ttw(ttr(TTrTest, "esusp(%d)" NL, block));
+addr = block2addr(block);
+switch (dev.driver) {
+case FFS_DRIVER_AMD:
+case FFS_DRIVER_AMD_SB:
+case FFS_DRIVER_AMD_PSEUDO_SB:
+*addr         = 0xB0; // AMD erase suspend command
+break;
+default:
+return -1; // Not yet supported
+}
+return 0;
+}
+int testh_get_free_block(void)
+{
+uint8 b;
+for (b = 0; b < dev.numblocks; b++)
+{
+if (is_block(b, BF_IS_FREE) || is_block(b, BF_IS_EMPTY))
+return b;
+}
+return -1;
+}
+#endif // TARGET == 1
+// NOTEME: The below test have not been used in this FFS version
+// NOTEME: We don't have an AMD init function
+/******************************************************************************
+* Test drv.init (low level driver test)
+******************************************************************************
+* Test drv.init by start an erase, call drv.init and make sure that the
+* erase is finish after we return from drv.init.
+*
+* Test drv.init by start erase, suspend the erase and make sure that the
+* erase is resumed and finish before we return from drv.init. The test is
+* valid for both AMD SB and MB driver
+******************************************************************************/
+#if (TARGET == 0)
+int case_drv_init(int p0, int p1)
+{
+tw(tr(TR_FUNC, TrTestHigh, "drv_init test not supported on PC sim\n"));
+return 1;
+}
+#else
+int case_drv_init(int p0, int p1)
+{
+volatile char *flash = dev.base;
+volatile char *addr;
+char myname[] = "/drv_init";
+uint32 cpsr;
+uint8 block;
+int free_b, i, j, command;
+enum command { ERASE, WRITE, READ };
+char action[6][3] =
+{
+{ WRITE, READ, ERASE },
+{ WRITE, ERASE, READ },
+{ READ, WRITE, ERASE },
+{ READ, ERASE, WRITE },
+{ ERASE, READ, WRITE },
+{ ERASE, WRITE, READ }
+};
+ttw(ttr(TTrTest, "Test ffsdrv.init()" NL));
+// Test drv.init 6 times there the flash is in erase mode and 6 times
+// there the flash is in erase suspend mode.
+for (i = 0; i < 12; i++)
+{
+free_b = testh_get_free_block();
+expect_ok(free_b);
+fs.debug[0] = 0;
+fs.debug[1] = 0;
+// Start erase, run driver init.
+error = testh_nb_erase(free_b);
+expect_ok(error);
+rvf_delay(20); // Make sure that the erase has started
+if (i > 6) {
+error = testh_erase_suspend(free_b);
+expect_ok(error);
+rvf_delay(20); // Make sure that the erase is suspended
+}
+error = ffsdrv.init();  // Call ffsdrv_init() instead? (inc. autodetect)
+expect_ok(error);
+if (i > 6) {
+expect(fs.debug[0], 1);    // Test that the erase was resumed
+expect_gt(fs.debug[1], 0); // Test what we did wait for erase to finish
+}
+else {
+expect(fs.debug[0], 0);    // Erase not resumed
+expect_gt(fs.debug[1], 0); // We did wait for an erase to finish
+}
+// To test that any combination of erase, read or write can be
+// performed after drv.init do we make the test below. The first
+// complete drv.init test will be like this: Start an erase, call
+// drv.init(), write a file, read the file and erase a free block.
+for (j = 0; j < 3; j++) {
+if (i < 6)
+command = action[i][j];
+else
+command =  action[i-6][j];
+switch (command) {
+case ERASE:
+free_b = testh_get_free_block();
+expect_ok(free_b);
+ffsdrv.erase(free_b);
+break;
+case READ:
+error = test_expect_file(myname, TDATA(2));
+if (error) return 1;
+break;
+case WRITE:
+error = tffs_fwrite(myname, TDATA(2));
+expect(error, EFFS_OK);
+break;
+default:
+return 1;
+}
+}
+}
+return 0;
+}
+#endif
+uint32 get_cpsr(void);
+// Test disable and enable of interrupt (Note only valid for MB drivers)
+int case_interrupt(int p0, int p1)
+{
+extern void int_enable(uint32 tmp);
+extern uint32 int_disable(void);
+uint32 cpsr;
+int i;
+uint32 xcpsr;
+switch (dev.driver) {
+case FFS_DRIVER_AMD:
+case FFS_DRIVER_INTEL:
+		break;
+	default:
+		return 1; // Not supported
+	}
+p0 *= 100;
+ttw(ttr(TTrTest, "Test interrupt code" NL));
+for (i = 0; i < p0; i++) {
+cpsr = int_disable();
+xcpsr = get_cpsr();
+if ((xcpsr & 0xC0) != 0xC0) {
+ttw(ttr(TTrTest, "FATAL int not disablet!" NL));
+return 1;
+}
+int_enable(cpsr);
+xcpsr = get_cpsr();
+if ((xcpsr & 0xC0) != 0) {
+ttw(ttr(TTrTest, "FATAL int not enablet!" NL));
+return 1;
+}
+if ((i % 1000) == 0)
+ttw(ttr(TTrTest, "loop (%d)" NL, i));
+}
+return 0;
+}
+/******************************************************************************
+* Benchmarking
+******************************************************************************/
+// Below define only for PC compile
+#if (TARGET == 0)
+#define UINT32   int
+#define tffs_timer_begin() 0
+#define tffs_timer_end(time) 5000 - time
+#endif
+const struct results_s old_results[] =
+{
+{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+// NOTEME: Bencmark_results() not finished.
+int bencmark_results(int manufact, int driver, int sample,
+struct results_s *meas_res)
+{
+switch(manufact) {
+case MANUFACT_AMD:
+switch(driver) {
+//        case FFS_DRIVER_AMD:
+case FFS_DRIVER_AMD_SB:
+default: return 0;
+}
+case MANUFACT_FUJITSU:
+switch(driver) {
+//        case FFS_DRIVER_AMD:
+case FFS_DRIVER_AMD_SB:
+default: return 0;
+}
+default: return 0;
+}
+}
+// Benchmark write and read operation. Measure write throughput as kBps in
+// idle and loopback mode. Both for an empty ffs where we don't have to
+// reclaim blocks and for a full ffs where block reclaims/erasures affect
+// the overall throughput. For SB flash driver as well as for DB driver. For
+// files of size:16, 256, 4096, bytes.
+int case_bm_stream_rw(int p0, int p1)
+{
+#if (TARGET == 1)
+UINT32 time_begin, elapsed, bytes_max;
+char myname[] = "/Benchmark0";
+int i, j, k, nm_files, file_size;
+int size, write_size[] = {16, 256, 4096};
+fd_t fdi;
+//ttw(ttr(TTrTest, "RVF_POOL_0_SIZE: %d" NL, RVF_POOL_0_SIZE));
+// 1 block is used for inodes, 1 have to be free, 1/4 is used for
+// journal and 1/2 is used as a margin
+// FIXME: changed to 4.75 because the SW TCS2.1 dos make some files and
+// because of this is there not enough data space left to this test.
+// NOTEME: Instead of hardwire this value then query it
+bytes_max = (dev.numblocks - 4.75) * dev.blocksize;
+file_size = bytes_max / dev.numblocks;
+ttw(ttr(TTrTest, "bytes_max: %d(- 2.75 block)" NL, bytes_max));
+// Format, measure write of 16B.
+// Format, measure write of 256B.
+// Format, measure write of 4096B.
+for (j = 0; j < 3; j++) {
+ttw(ttr(TTrTest, "Format, measure write of %dB" NL, write_size[j]));
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+time_begin = tffs_timer_begin();
+for (i = 0; i < dev.numblocks; i++) {
+myname[10] = i + (i <= 9 ? '0': 'A' -10);
+fdi = tffs_open(myname, FFS_O_WRONLY | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+size = 0;
+do {
+size += error = tffs_write(fdi, (char*)tdata[TDATA_HUGE],
+write_size[j]);
+if (error < 0) {
+if (error == EFFS_NOSPACE) {
+ttw(ttr(TTrTest, "Aarg out of space" NL));
+bytes_max = size;
+break;
+}
+else
+expect_ok(error);
+}
+} while (size < file_size);
+error = tffs_close(fdi);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+// FFS has used the CPU for a long time so let the trace task get
+// the CPU for a while
+tffs_delay(50);
+ttw(ttr(TTrTest, "Write %dBytes %d times in %dms, %dkBps" NL NL,
+write_size[j], file_size/write_size[j], elapsed,
+(bytes_max * 1000) / (elapsed * 1024)));
+}
+ttw(ttr(TTrTest, "Rm all files, measure write of 4kB" NL));
+for (i = 0; i < dev.numblocks; i++) {
+myname[10] = i + (i <= 9 ? '0': 'A' -10);
+error = tffs_remove(myname);
+expect_ok(error);
+}
+time_begin = tffs_timer_begin();
+for (i = 0; i < dev.numblocks; i++) {
+myname[10] = i + (i <= 9 ? '0': 'A' -10);
+fdi = tffs_open(myname, FFS_O_WRONLY | FFS_O_CREATE);
+expect(fdi, FFS_FD_OFFSET);
+size = 0;
+do {
+size += tffs_write(fdi, (char*)tdata[TDATA_HUGE], write_size[2]);
+} while (size < file_size);
+error = tffs_close(fdi);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+tffs_delay(50);
+ttw(ttr(TTrTest, "Write %dBytes %d times in %dms, %dkBps" NL NL,
+write_size[2], file_size/write_size[2], elapsed,
+(bytes_max * 1000) / (elapsed * 1024)));
+// Read all files with 16B at a time
+for (j = 0; j < 3; j++) {
+ttw(ttr(TTrTest, "Read all files with %dB at a time" NL, write_size[j]));
+time_begin = tffs_timer_begin();
+for (i = 0; i < dev.numblocks; i++) {
+myname[10] = i + (i <= 9 ? '0': 'A' -10);
+fdi = tffs_open(myname, FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+size = 0;
+do {
+size += tffs_read(fdi, bigbuf, write_size[j]);
+} while (size < file_size);
+error = tffs_close(fdi);
+expect(error, 0);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Read %d files of %dkB in %dms, %dkBps," NL NL,
+dev.numblocks, size/1024, elapsed,
+(dev.numblocks * size * 1000) / (elapsed * 1024)));
+}
+// Measure write and read of one big file
+ttw(ttr(TTrTest, "Format, Write and read one big file" NL));
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+time_begin = tffs_timer_begin();
+fdi = tffs_open(myname, FFS_O_WRONLY | FFS_O_CREATE);
+size = 0;
+do {
+size += tffs_write(fdi, bigbuf, write_size[2]);
+} while (size < bytes_max);
+error = tffs_close(fdi);
+expect(error, 0);
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Write %dkB in %dms, %dkBps" NL,
+size/1024 , elapsed, (size * 1000) / (elapsed * 1024)));
+time_begin = tffs_timer_begin();
+// read one big file (reading one big file take more time than reading
+// many files of the same total size because there is a lot more inode
+// to look through)
+fdi = tffs_open(myname, FFS_O_RDONLY);
+expect(fdi, FFS_FD_OFFSET);
+size = 0;
+do {
+size += tffs_read(fdi, bigbuf, write_size[2]);
+} while (size < bytes_max);
+error = tffs_close(fdi);
+expect(error, 0);
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Read %dkB in %dms, %dkBps," NL,
+size/1024, elapsed, (size * 1000) / (elapsed * 1024)));
+// Make a data base of old measurements her? compare with old data and
+// make a warning if the performance has decreased?
+return 0;
+#else
+return 1;
+#endif
+}
+// Benchmark ffs_file_write() and ffs_file_read()
+int case_bm_file_rw(int p0, int p1)
+{
+UINT32 time_begin, elapsed;
+char myname[] = "/Benchmark";
+int i, j;
+struct test_info_s {
+int fsize;
+int fnumber;
+};
+struct test_info_s tinfo[] = {
+{   16, 500  },
+{  256, 200  },
+{ 4096, 200  },
+{32768, 10   }
+};
+for (j = 0; j < 4; j++) {
+ttw(ttr(TTrTest, "Format, measure write of %dB" NL, tinfo[j].fsize));
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+time_begin = tffs_timer_begin();
+for (i = 0; i < tinfo[j].fnumber; i++) {
+error = tffs_file_write(myname, (char*)tdata[TDATA_HUGE],
+tinfo[j].fsize, FFS_O_CREATE);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+// FFS has used the CPU for a long time so let the trace task get
+// the CPU for a while
+tffs_delay(50);
+ttw(ttr(TTrTest, "Write %dBytes %d times in %dms, %dkBps" NL NL,
+tinfo[j].fsize, i, elapsed,
+(i * tinfo[j].fsize * 1000) / (elapsed * 1024)));
+time_begin = tffs_timer_begin();
+for (i = 0; i < tinfo[j].fnumber; i++) {
+error = tffs_file_read(myname, bigbuf, tinfo[j].fsize);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Read %dBytes %d times in %dms, %dkBps" NL NL,
+tinfo[j].fsize, i, elapsed,
+(i * tinfo[j].fsize * 1000) / (elapsed * 1024)));
+}
+tffs_delay(3000);
+return 0;
+}
+// We banchmark lookups by using ffs_stat()
+int case_bm_lookup(int p0, int p1)
+{
+//format, update file x times, measure lookup with ffs_stat()
+//format, make x difference files, measure lookup with ffs_stat()
+//format, make a file in max directory depth, measure lookup with ffs_stat()
+//format, make one file, measure lookup with ffs_stat() (no traverse)
+//format, make x dirs with x files, measure lookup of last file in last dir
+#if (TARGET == 1)
+UINT32 time_begin, elapsed;
+int i, j;
+char myname[] = "/benchmark";
+char mydir[100] = "";
+char depth[] = "/depth99";
+char mypath[100] = "";
+//format, update file 100 times, measure lookup with ffs_stat()
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+for (i = 0; i < 100; i++) {
+error = tffs_file_write(myname, 0,0, FFS_O_CREATE);
+expect_ok(error);
+}
+time_begin = tffs_timer_begin();
+for (i = 0; i < 100; i++) {
+error = tffs_stat(myname, &stat);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Lookup through 100 deleted objects 100 times in %dms(%d obj/s)" NL, elapsed, 100 * 1000 / elapsed));
+//format, make 100 difference files, measure lookup with ffs_stat()
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+for (i = 0; i < 100; i++) {
+sprintf(myname, "/benchm%d", i);
+error = tffs_file_write(myname, 0,0, FFS_O_CREATE);
+expect_ok(error);
+}
+time_begin = tffs_timer_begin();
+for (i = 0; i < 100; i++) {
+error = tffs_stat(myname, &stat);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Lookup through 100 difference objects 100 times in %dms(%d obj/s)"
+NL, elapsed, 100 * 1000 / elapsed));
+//format, make a file in max directory depth, measure lookup with ffs_stat()
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+for (i = 0; i < fs.path_depth_max - 1; i++) {
+sprintf(depth, "/depth%d", i + 1);
+strcat(mydir, depth);
+error = tffs_mkdir(mydir);
+expect_ok(error);
+}
+strcat(mydir, myname);
+error = tffs_file_write(mydir, 0,0, FFS_O_CREATE);
+expect_ok(error);
+time_begin = tffs_timer_begin();
+for (i = 0; i < 1000; i++) {
+error = tffs_stat(mydir, &stat);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Lookup througt %d directorys 1000 times in %dms(%d obj/s)"
+NL, fs.path_depth_max, elapsed, 1000 * 1000 / elapsed));
+//format, make x files in each directory, measure lookup with ffs_stat()
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+mydir[0] = 0;  // Reset/empty buffer
+for (i = 0; i < fs.path_depth_max - 1; i++) {
+sprintf(depth, "/depth%d", i + 1);
+strcat(mydir, depth);
+error = tffs_mkdir(mydir);
+expect_ok(error);
+for (j = 0; j < 5; j++){
+sprintf(myname, "/benchm%d", j);
+strcpy(mypath, mydir);
+strcat(mypath, myname);
+error = tffs_file_write(mypath, 0,0, FFS_O_CREATE);
+expect_ok(error);
+}
+}
+time_begin = tffs_timer_begin();
+for (i = 0; i < 100; i++) {
+error = tffs_stat(mypath, &stat);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Lookup througt %d directorys with %d files in each times in %dms(%d obj/s)"
+NL, fs.path_depth_max, j, elapsed, 100 * 1000 / elapsed));
+//format, make one file, measure lookup with ffs_stat() (no traverse)
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+error = tffs_file_write(myname, 0,0, FFS_O_CREATE);
+expect_ok(error);
+time_begin = tffs_timer_begin();
+for (i = 0; i < 10000; i++) {
+error = tffs_stat(myname, &stat);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Lookup one file 10000 times in %dms(%d obj/s)"
+NL, elapsed, 1000 * 10000 / elapsed));
+//format, make x dirs with x files, measure lookup of last file in last dir
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+return 0;
+#else
+return 1;
+#endif
+}
+int case_bm_seek(int p0, int p1)
+{
+UINT32 time_begin, elapsed;
+int i, pos, fsize = 20000;
+char myname[] = "/benchmark";
+fd_t fdi;
+//format, update file 100 times, measure lookup with ffs_stat()
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+error = tffs_format("/foo", 0x2BAD);
+expect(error, EFFS_OK);
+// Create test file
+error = tffs_file_write(myname, (char*)tdata[TDATA_HUGE], fsize, FFS_O_CREATE);
+expect_ok(error);
+fdi = tffs_open(myname, FFS_O_RDWR);
+expect(fdi, FFS_FD_OFFSET);
+tw(tr(TR_FUNC, TrTest, "Run read reference\n"));
+ttw(ttr(TTrTest, "Run read reference" NL));
+// Reference
+time_begin = tffs_timer_begin();
+for (i = 0; i < fsize/4; i++) {
+error = tffs_read(fdi, bigbuf, 4);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+tw(tr(TR_FUNC, TrTest, "Read %d entries of 4 bytes (bytes/s %d)\n",
+fsize/4, (fsize * 1000 / elapsed)));
+ttw(ttr(TTrTest, "Read %d entries of 4 bytes in %dms (bytes/s %d)" NL,
+fsize/4, elapsed, (fsize * 1000 / elapsed)));
+tw(tr(TR_FUNC, TrTest, "Benchmark seek\n"));
+ttw(ttr(TTrTest, "Benchmark seek" NL));
+error = tffs_seek(fdi, 0, FFS_SEEK_SET);
+expect_ok(error);
+pos = 0;
+// Benchmark seek
+time_begin = tffs_timer_begin();
+for (i = 0; i < fsize/4; i++) {
+error = tffs_seek(fdi, pos, FFS_SEEK_SET);
+expect_ok(error);
+pos += 4;
+error = tffs_read(fdi, bigbuf, 4);
+expect_ok(error);
+}
+elapsed = tffs_timer_end(time_begin);
+tw(tr(TR_FUNC, TrTest, "Seek and Read %d entries of 4 bytes (bytes/s %d)\n",
+fsize/4, (fsize * 1000 / elapsed)));
+ttw(ttr(TTrTest, "Seek and Read %d entries of 4 bytes in %dms (bytes/s %d)" NL,
+fsize/4, elapsed, (fsize * 1000 / elapsed)));
+error = tffs_close(fdi);
+expect_ok(error);
+return EFFS_OK;
+}
+// Benchmark the blocking 'system'. Make n number of calls to ffs_format()
+// with bad magic.
+int case_bm_blocking(int p0, int p1)
+{
+int i;
+int time_begin, elapsed;
+time_begin = tffs_timer_begin();
+for (i = 0; i < 10000; i++)
+tffs_format("/ffs", 0);
+elapsed = tffs_timer_end(time_begin);
+ttw(ttr(TTrTest, "Made %d blocking calls in %dms (ms/call %d)" NL,
+i, elapsed, elapsed / i));
+// Make sure that it did fail as we expected
+error = tffs_format("/ffs", 0);
+expect(error, EFFS_INVALID);
+return EFFS_OK;
+}
+/******************************************************************************
+* Core test case
+******************************************************************************/
+int case_seekfile(int p0, int p1)
+{
+// NOTEME: this is only a visual test add some expect() to finish it.
+char *name;
+iref_t i, dir, i_out;
+int length, flength;
+int segment_offset;
+fd_t fdi;
+error = tffs_fwrite("/File_seg", (char*)tdata[TDATA_HUGE], 50);
+expect(error, EFFS_OK);
+if ((i = object_lookup("/File_seg", &name, &dir)) < 0)
+return i;
+for (length = 52; length > 48; length--) {
+flength = segfile_seek(i, length, &i_out, &segment_offset);
+tw(tr(TR_FUNC, TrTest,
+"*** Length %d, Flength %d, Seg_offset %2d, i %d ***\n",
+length, flength, segment_offset, i_out));
+}
+fdi = tffs_open("/Stream_seg", FFS_O_WRONLY | FFS_O_CREATE);
+tffs_write(fdi, (char*)tdata[TDATA_HUGE], 55);
+tffs_close(fdi);
+fdi = tffs_open("/Stream_seg", FFS_O_WRONLY | FFS_O_APPEND);
+tffs_write(fdi, (char*)tdata[TDATA_HUGE], 50);
+tffs_close(fdi);
+fdi = tffs_open("/Stream_seg", FFS_O_WRONLY | FFS_O_APPEND);
+tffs_write(fdi, (char*)tdata[TDATA_HUGE], 45);
+tffs_close(fdi);
+if ((i = object_lookup("/Stream_seg", &name, &dir)) < 0)
+return i;
+for (length = 153; length > 148; length--) {
+flength = segfile_seek(i, length, &i_out, &segment_offset);
+tw(tr(TR_FUNC, TrTest,
+"*** Length %d, Flength %d, Seg_offset %2d, i %d ***\n",
+length, flength, segment_offset, i_out));
+}
+for (length = 107; length > 103; length--) {
+flength = segfile_seek(i, length, &i_out, &segment_offset);
+tw(tr(TR_FUNC, TrTest,
+"*** Length %d, Flength %d, Seg_offset %2d, i %d ***\n",
+length, flength, segment_offset, i_out));
+}
+for (length = 58; length > 53; length--) {
+flength = segfile_seek(i, length, &i_out, &segment_offset);
+tw(tr(TR_FUNC, TrTest,
+"*** Length %d, Flength %d, Seg_offset %2d, i %d ***\n",
+length, flength, segment_offset, i_out));
+}
+return 0;
+}
+void display_fs_params(void)
+{
+int numdatablocks;
+numdatablocks = dev.numblocks - fs.blocks_free_min - 1;
+// Note expect only one free block!
+tw(tr(TR_FUNC, TrTest, "Data blocks %d, size %dkB\n",
+numdatablocks, dev.blocksize / 1024));
+tw(tr(TR_FUNC, TrTest, "    User data:       %dkB\n",
+(numdatablocks * dev.blocksize - fs.reserved_space) / 1024));
+tw(tr(TR_FUNC, TrTest, "    reserved_space:  %dkB\n", fs.reserved_space/ 1024));
+tw(tr(TR_FUNC, TrTest, "    inodes_max:      %d\n", fs.inodes_max));
+tw(tr(TR_FUNC, TrTest, "    journal_size:    %d\n", fs.journal_size));
+tw(tr(TR_FUNC, TrTest, "    objects_max:     %d\n", fs.objects_max));
+tw(tr(TR_FUNC, TrTest, "    block_files_max: %d\n", fs.block_files_max));
+tw(tr(TR_FUNC, TrTest, "    chunk_size:      %d\n\n", fs.chunk_size_max));
+}
+// NOTE only visual test
+int case_param_init(int p0, int p1)
+{
+char myname[] = "/ffs/xx/xx/xx";
+int numblocks[] = { 8, 3, 7, 15, 31, 63, 96, 127, 61, 127};
+int i;
+for (i = 0; i < sizeof(numblocks) / sizeof(int); i++)
+{
+dev.numblocks = numblocks[i];
+if (i == 0)
+dev.blocksize = 1024 * 8;
+else if (i > 0 && i < 8)
+dev.blocksize = 1024 * 64;
+else
+dev.blocksize = 1024 * 128;
+fs_params_init(myname);
+display_fs_params();
+// TODO add some checks, test format("/ffs/bx/ox") etc.
+}
+error = tffs_initialize(); // Use the 'real' blocksize
+expect(error, EFFS_OK);
+// Test param input from the format string
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+tffs_format("/ffs/i4000/o3000", 0x2BAD);
+expect(error, EFFS_OK);
+display_fs_params();
+// Test small conf.
+tw(tr(TR_FUNC, TrTest, "Test small conf\n"));
+error = tffs_preformat(0xDEAD);
+expect(error, EFFS_OK);
+tffs_format("/ffs/b3/j8/r24/f100/o100", 0x2BAD);
+expect(error, EFFS_OK);
+display_fs_params();
+return 0;
+}
+/******************************************************************************
+* Trace mask
+******************************************************************************/
+// This is not a test case but a way to change the trace mask on the fly
+int case_trace_mask(int p0, int p1)
+{
+unsigned int temp;
+// Because p0 and p1 only is of the type int and trace_mask is a
+// unsigned int is p0 bit 1-28 and p1 is bit 29-32
+temp = p1 << 28;
+temp |= p0;
+#if (TARGET == 0)
+tr_init(temp, 2, NULL );
+tw(tr(TR_FUNC, TrAll, "trace mask = %x\n", temp));
+#else
+ttr_init(temp);
+ttw(ttr(TTrTest, "trase mask = %x" NL, temp));
+#endif
+return 0;
+}
+/******************************************************************************
+* Helper function
+******************************************************************************/
+#define CLEANUP_MIN_SIZE 1
+int ignore_file(char *pathname)
+{
+int i;
+const char *ignore[] = {
+"/.journal", "/.ffs-stats", "/.ffs-bstat.old","/dummy4fctrl" ,
+"/truncate/IMEI", "/truncate/stream_file", "/gsm/com/rfcap",
+"/var/dbg/dar" };
+const char readonly[] = "/READONLY";
+for (i = 0; i < sizeof(ignore)/sizeof(char *); i++) {
+if (ffs_strcmp(pathname, ignore[i]) == 0) {
+return 0;
+}
+}
+// Special case, we have one directory where we don't delete any objects
+if (memcmp(pathname, readonly, sizeof(readonly) - 1) == 0)
+return 0;
+return 1;
+}
+// Remove files in FFS until there is min_space left. Ignore all files that
+// are listed in the ignore string above.
+int case_cleanup(int min_space)
+{
+int free, i, n, error;
+struct object_s *plist, *plist_start;
+char *pnames, *pnames_start;
+tw(tr(TR_FUNC, TrTestLow, "case_cleanup(%d)?\n", min_space));
+ffs_query(Q_BYTES_FREE, (uint32 *) &free);
+if (free > min_space) {
+tw(tr(TR_FUNC, TrTestLow, "Total data free: %d\n", free));
+return free;    // Nothing to do
+}
+plist  = plist_start  = (struct object_s *) bigbuf;
+pnames = pnames_start = bigbuf + bigbuf_size;
+n = case_dir_list("/", &plist, &pnames);
+plist = plist_start;
+for (i = 0; i < n; i++, plist++)
+{
+ffs_query(Q_BYTES_FREE, (uint32 *) &free);
+if (free > min_space) {
+tw(tr(TR_FUNC, TrTestLow, "Total data free: %d\n", free));
+return free;
+}
+if (plist->stat.size > CLEANUP_MIN_SIZE && ignore_file(plist->name)) {
+if ((error = ffs_remove(plist->name)) < 0)
+return error;
+}
+}
+return EFFS_NOSPACE;
+}
+// Make a random file. Random filename length, random filename, random filesize.
+// Note it is up to the caller that the directory exists.
+int case_mk_rand_file(char *dirname, int max_size, int min_size)
+{
+int size, diff, filenamelen, pathlen = 0, i, error;
+char pathname[(FFS_FILENAME_MAX + 1) * FFS_PATH_DEPTH_MAX];
+// All valid filename chars
+char tabel[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+"abcdefghijklmnopqrtsuvwyz_-.,+%$#";
+diff = max_size - min_size;
+if (diff < 0)
+return EFFS_INVALID;
+else if (diff == 0)
+size = max_size;
+else
+size = (rand() % diff) + min_size;
+filenamelen = (rand() % (FFS_FILENAME_MAX - 1)) + 1;  // We need min one char
+tw(tr(TR_FUNC, TrTestLow, "size:%5d, filenamelen:%3d,",size, filenamelen));
+if (dirname != 0) {
+strcpy(pathname, dirname);
+pathlen = strlen(pathname);
+}
+pathname[pathlen++] = '/';
+for (i = 0; i < filenamelen; pathlen++, i++) {
+pathname[pathlen] = tabel[rand() % strlen(tabel)];
+}
+pathname[pathlen] = 0;  // Zero terminate
+tw(tr(TR_FUNC, TrTestLow, "pathname:'%s'\n", pathname, size));
+error = tffs_file_write(pathname, (char *) tdata[TDATA_HUGE], size,
+FFS_O_CREATE | FFS_O_TRUNC);
+return error;
+}
+// Various helper functions for debug
+int case_debug_help(int p0, int p1)
+{
+int tr_mask;
+switch(p0) {
+case 1:
+{
+// Write rfcap file
+char rfcap_data[] = { 0, 0xf, 0x41, 0x10, 0, 0, 0, 0, 0x50, 0,
+0, 0xa5, 0x5, 0, 0xc0, 0 };
+ttw(ttr(TTrTest, "Write rfcap file..."));
+tffs_mkdir("/gsm");  // ignore error
+tffs_mkdir("/gsm/com");
+error = tffs_file_write("/gsm/com/rfcap", rfcap_data,
+sizeof(rfcap_data), FFS_O_CREATE | FFS_O_TRUNC);
+expect_ok(error);
+ttw(ttr(TTrTest, "done" NL));
+}
+break;
+case 2:
+tr_mask = tr_query(INT_MAX);
+#if (TARGET == 0)
+tr_init(TrBstat, 2, NULL );
+tr_bstat();
+tr_init(tr_mask, 2, NULL );
+#else
+ttr_init(TTrBstat);
+tr_bstat();
+ttr_init(tr_mask);
+#endif
+break;
+case 3:
+// Make mem dump to screen
+#if (TARGET == 1)
+rvf_dump_mem();
+break;
+#else
+tw(tr(TR_FUNC, TrTestLow, "Not supported on PC\n"));
+return 1;
+#endif
+case 4:
+#if (TARGET == 1)
+rvf_dump_tasks(); break;
+#else
+tw(tr(TR_FUNC, TrTestLow, "Not supported on PC\n"));
+return 1;
+#endif
+case 5:
+#if (TARGET == 1)
+rvf_dump_pool(); break;
+#else
+tw(tr(TR_FUNC, TrTestLow, "Not supported on PC\n"));
+return 1;
+#endif
+default:
+tw(tr(TR_FUNC, TrTest, "Available helper functions:\n"));
+tw(tr(TR_FUNC, TrTest, "    1: Write rfcap file\n"));
+tw(tr(TR_FUNC, TrTest, "    2: Display bstat trace\n"));
+ttw(ttr(TTrTest, "Available helper functions:" NL));
+ttw(ttr(TTrTest, "    1: Write rfcap file" NL));
+ttw(ttr(TTrTest, "    2: Display bstat trace" NL));
+ttw(ttr(TTrTest, "    3: Memory dump to screen" NL));
+ttw(ttr(TTrTest, "    4: Tasks dump to screen" NL));
+ttw(ttr(TTrTest, "    5: Pool dump to screen" NL));
+return 0;
+}
+return 0;
+}
+/******************************************************************************
+* Hexdumping
+******************************************************************************/
+#if 0
+void hexdump(const char *buf, int size, unsigned int address, int unitsize)
+{
+char string[(8+1+1) + (1+16+1+1) + (3*16) + 1];
+int n, i;
+char *s;
+while (size > 0)
+{
+s = string;
+s += sprintf(s, "%8x: ", address); // print offset
+n = (size > 16 ? 16 : size);
+// print the textual representation
+for (i = 0; i < n; i++) {
+if (buf[i] >= ' ' && buf[i] < 127)
+*s++ = buf[i];
+else
+*s++ = '.';
+}
+// pad textual representation with spaces
+for (i = 0; i < 16 - n; i++) {
+*s++ = ' ';
+}
+*s++ = ' ';
+// print hexedecimal representation
+for (i = 0; i < n; i += unitsize) {
+switch (unitsize) {
+case 1: s += sprintf(s, "%02x ", *(unsigned char  *) (buf+i)); break;
+case 2: s += sprintf(s, "%04x ", *(unsigned short *) (buf+i)); break;
+case 4: s += sprintf(s, "%08x ", *(unsigned int *) (buf+i)); break;
+}
+}
+buf += 16;
+address += 16;
+size -= 16;
+puts(string);
+}
+}
+#endif
+/******************************************************************************
+* Test Cases
+******************************************************************************/
+const struct testcase_s testcase[] =
+{
+// Collective test cases
+{ "all",    PC       , case_all,      "All" },
+{ "alot",   PC       , case_alot,     "Almost all" },
+{ "tall",      IT    , case_tall,     "Target all" },
+{ "aall",   PC       , case_aall,     "Agressive all" },
+{ "list",   PC|IT    , case_list,     "List all testcases" },
+{ "lsr",    PC|IT    , case_lsr,      "Recursively list all objects" },
+{ "test",   PC|IT    , case_test,     "Ad hoc test" },
+{ "rand",   PC|IT    , case_rand,     "Random tests (NOT FINISHED)" },
+{ "fail",   PC|IT    , case_fail,     "Fail (just fail)" },
+{ "okay",   PC|IT    , case_okay,     "Okay (just succeed)" },
+// Atomic/small test cases
+{ "s",      PC|IT    , case_status,   "Status: ffs_init(), lsr" },
+{ "r",      PC|IT    , case_reset,    "preformat(), format(), init(), exit()" },
+{ "i",      PC|IT    , case_init,           "ffs_init()" },
+{ "x",      PC|IT    , case_exit,           "ffs_exit()" },
+{ "p",      PC|IT    , case_only_preformat, "ffs_preformat()" },
+{ "f",      PC|IT    , case_only_format,    "ffs_format()" },
+// Populate test cases
+{ "world",  PC|IT    , case_world,    "Make world" },
+{ "eu",     PC|IT    , case_europe,   "Make europe" },
+{ "dk",     PC|IT    , case_denmark,  "Make denmark" },
+// Special test cases
+{ "mf",     PC|IT    , case_mfiles,   "Test FFS with many (small) files" },
+{ "threeb", PC|IT    , case_threeb,   "Test ffs in only three blocks" },
+{ "twob",   PC|IT    , case_twob,     "Test ffs in only two blocks" },
+{ "pcm",    PC|IT    , case_pcm,      "Test PCM interface" },
+{ "stress",    IT    , case_stress,   "Stress test erase/write" },
+{ "find",   PC|IT|RND, case_find,     "Recursively traverse all objects" },
+{ "nb",     IT       , case_nonblock, "Test non block functions" },
+{ "bf",     IT|RND   , case_blocking, "Test blocking function" },
+{ "cust",   PC       , case_customer, "Test customer typical use"},
+{ "esus",   IT       , case_erase_suspend, "Test erase suspend and resume" },
+// Driver test cases
+{ "int",    IT       , case_interrupt,     "Test INT disable and enable" },
+// Benchmark test cases
+{ "bmsrw",     IT    , case_bm_stream_rw, "Benchmark stream read and writes" },
+{ "bmfrw",     IT    , case_bm_file_rw,   "Benchmark file read and writes" },
+{ "bmlu",      IT    , case_bm_lookup,    "Benchmark lookups" },
+{ "bmsk",    PC|IT   , case_bm_seek,      "Benchmark ffs_seek()" },
+{ "bmbl",    PC|IT   , case_bm_blocking,  "Benchmark blocking 'system'" },
+// Normal test cases
+{ "format", PC       , case_format,   "Test ffs_pre/format()" },
+{ "lu",     PC|IT    , case_lookup,   "Test object_lookup()" },
+{ "fc",     PC|IT    , case_fcontrol, "Test fcontrol() and read-only" },
+{ "root",   PC|IT|RND, case_root,     "Test root inode is non-modifiable" },
+{ "dirs",   PC|IT|RND, case_dirs,     "Test Directories" },
+{ "frd",    PC|IT|RND, case_fread,    "Test fread() with varying sizes/names" },
+{ "bfull",  PC|IT    , case_bfull,    "Test filling a block completely" },
+{ "ffull",  PC|IT    , case_ffull,    "Test filling ffs completely" },
+{ "bigf",   PC       , case_bigfile,  "Test big files" },
+{ "stat",   PC|IT|RND, case_stat,     "Test ffs_stat()" },
+{ "rm",     PC|IT    , case_remove,   "Test ffs_remove()" },
+{ "ren",    PC|IT|RND, case_rename,   "Test ffs_rename()" },
+{ "renext", PC|IT    , case_rename_extended, "Extended test of ffs_rename()" },
+{ "irec",   PC|IT    , case_irec,     "Test inodes reclaim" },
+{ "drec",   PC       , case_drec,     "Test data reclaim" },
+{ "adrec",  PC       , case_adrec,    "Test xxxx reclaim" },
+{ "jnl",    PC|IT    , case_journal,  "Test journalling" },
+{ "brec",   PC|IT|RND, case_brecover, "Test block recovery" },
+{ "ssym",   PC|IT|RND, case_ssym,     "Test Simple Symlinks" },
+{ "fsym",   PC|IT    , case_fsym,     "Test Full Symlinks (NOT IMPLEMENTED)" },
+{ "ri",     PC|IT|RND, case_reinit,   "Test re-ffs_init()" },
+{ "open",   PC|IT|RND, case_open,     "Test open flags" },
+{ "rw",     PC|IT|RND, case_rw,       "Test read and write files" },
+{ "mopen",  PC|IT|RND, case_multi_open, "Test open of multiply files" },
+{ "seek",   PC|IT|RND, case_seek,     "Test seek on files " },
+{ "trunc",  PC|IT|RND, case_trunc,    "Test ffs_truncate() " },
+{ "append", PC|IT|RND, case_append,   "Test append on a open file" },
+{ "dsync",  PC|IT|RND, case_datasync, "Test ffs_fdatasync" },
+{ "ex",     IT|RND,    case_examples, "Test examples from RIV111 " },
+{ "fwflags",PC|IT|RND, case_fw_flags, "Test ffs_file_write() flags" },
+{ "pcm"    ,PC|IT|RND, case_pcm,      "Test pcm interface" },
+{ "apiexc" ,PC|IT,     case_api_exceptions, "Test API exceptions" },
+{ "ninit"  ,PC|IT,     case_api_notformated, "Test API on a nformated flash"},
+{ "query"  ,PC|IT|RND, case_query,    "Test query function" },
+{ "octrl"  ,PC|IT,     case_octrl,    "Test of object control" },
+// Core test cases
+{ "seekf",  PC,        case_seekfile,  "Test core segfile_seek" },
+{ "param",  PC,        case_param_init,"Test core param_init" },
+// Helper test case
+{ "tr",     PC|IT    , case_trace_mask, "Change trace mask on the fly " },
+{ "dh",     PC|IT    , case_debug_help, "Difference help functions " },
+{ 0,        0,         0,             0 }
+};
+#if (TARGET == 1)
+// Note like the interrupt functions in drv.c this asm needs to be places ad
+// the buttom of the file or else it crach!
+uint32 get_cpsr(void)
+{
+asm("        .state16");
+asm("        adr       A2, get_cpsr32");
+asm("        bx        A2");
+asm("        .state32");
+asm("get_cpsr32");
+asm("        mrs       A1,cpsr      ; get current CPSR");
+}
+#else
+uint32 get_cpsr(void){return 0;}
+#endif

FreeCalypso > hg > fc-tourmaline

comparison src/cs/drivers/drv_app/ffs/board/tcases.c @ 0:4e78acac3d88