tcases.c

MMI层OBJ不能完全编译

    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, &tstat);
    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)
{
    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)

    cleanup(fs.chunk_size_max / 5 * 20);
    
    // NOTEME: this is a very limited test
    error = tffs_file_write(myname, (char *)tdata[TDATA_HUGE], 99, 
                            FFS_O_CREATE | FFS_O_TRUNC); 
    expect_ok(error);

    error = tffs_stat(myname, &tstat);
    expect(error, EFFS_OK);
    expect(tstat.type, OT_FILE);
    expect(tstat.flags, 0);
    expect_ok(tstat.inode);
    expect(tstat.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, &tstat);
    expect(error, EFFS_OK);
    
    expect(error, EFFS_OK);
    expect(tstat.type, OT_FILE);
    expect(tstat.flags, 0);
    expect_ok(tstat.inode);
    expect(tstat.size, 99);
    
    error = tffs_xlstat(myname, &txstat);
    expect(error, EFFS_OK);

    expect(error, EFFS_OK);
    expect(txstat.type, OT_FILE);
    expect(txstat.flags, 0);
    expect_ok(txstat.inode);
    expect(txstat.size, 99);

    expect(txstat.space, 112);
    expect_ok(txstat.location);
    expect_ok(txstat.block);
    expect_ok(txstat.sequence);
    expect_ok(txstat.updates);

    // Symlink
    tffs_symlink(sym_name, myname);  
        
    error = tffs_xlstat(sym_name, &txstat);
    expect(error, EFFS_OK);

    expect(error, EFFS_OK);
    expect(txstat.type, OT_LINK);
    expect(txstat.flags, 0);
    expect_ok(txstat.inode);
    expect(txstat.size, sizeof(myname));

    expect(txstat.space, 16);
    expect_ok(txstat.location);
    expect_ok(txstat.block);
    expect_ok(txstat.sequence);
    expect_ok(txstat.updates);

    // Stream stat test
    // Use txstat 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, &txstat);
        expect(error, EFFS_OK);
        expect_eq(txstat.size, file_size);

        error = tffs_fstat(fdi, &tstat);
        expect(error, EFFS_OK);
        expect_eq(tstat.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, &txstat);
    expect(error, EFFS_OK);
    expect_eq(txstat.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, &tstat);
        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(5 * fs.chunk_size_max);
    
    // 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_file_write("/IMEI", TDATA(2), FFS_O_CREATE | FFS_O_TRUNC);
    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_file_write("/Mickey", TDATA(3), FFS_O_CREATE | FFS_O_TRUNC);
    expect(error, EFFS_OK);

    error = tffs_file_write("/Pluto", TDATA(2), FFS_O_CREATE | FFS_O_TRUNC);
    expect(error, EFFS_OK);

    error = tffs_rename("/Pluto", "/Dog");
    expect(error, EFFS_OK);

    error = tffs_file_write("/Pluto", TDATA(2), FFS_O_TRUNC);
    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_file_write("/Goose", TDATA(2), FFS_O_TRUNC);
    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 does 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 = tffs_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_file_write("/Mickey", (char *)tdata[TDATA_HUGE] + 5, 
                        2.5 * fs.chunk_size_max, FFS_O_CREATE | FFS_O_TRUNC);
    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