tcases.c

MMI层OBJ不能完全编译

    error = tffs_fcontrol(imeifile, OC_FLAGS, OF_READONLY);
    expect(error, EFFS_OK);
    error = tffs_stat(imeifile, &tstat);
    expect(error, EFFS_OK);
    expect_eq(tstat.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_file_write(imeifile, TDATA(0), FFS_O_TRUNC);
    expect(error, EFFS_ACCESS);
    error = tffs_file_write(imeifile, TDATA(0), FFS_O_CREATE | FFS_O_TRUNC);
    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_file_write("/europe/denmark/aalborg", TDATA(1), FFS_O_CREATE | FFS_O_TRUNC);
    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_file_write("/europe/denmark/aarhus", TDATA(2), FFS_O_CREATE | FFS_O_TRUNC);
    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_file_write("/europe/denmark/billund", TDATA(3), FFS_O_CREATE | FFS_O_TRUNC);
    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_file_write("/europe/denmark/norresundby", TDATA(2), FFS_O_CREATE | FFS_O_TRUNC);
    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", &tstat);
    expect(error, EFFS_NOTAFILE); // TODO: strange error!
    error = tffs_linkstat("/dk", &tstat);
    expect(error, EFFS_OK);

    // Test link to link to file
    error = tffs_stat("/lego", &tstat);
    expect(error, EFFS_NOTAFILE); // TODO: strange error?!
    error = tffs_linkstat("/lego", &tstat);
    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", &tstat);
    expect(error, EFFS_NOTFOUND);
    error = tffs_linkstat("/europe/se", &tstat);
    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_file_write("/europe/aal", TDATA(3), FFS_O_CREATE | FFS_O_TRUNC);
    expect(error, EFFS_OK);
    error = tffs_file_write("/europe/aar", TDATA(4), FFS_O_TRUNC);
    expect(error, EFFS_OK);
    error = tffs_file_write("/europe/bil", TDATA(5), FFS_O_TRUNC);
    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_file_write("/lego", "/europe/denmark/billund",
                         strlen("/europe/denmark/billund"), FFS_O_TRUNC);
    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_file_write("/lego", TDATA(2), FFS_O_TRUNC);
    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", &tstat);
    expect(error, EFFS_OK);
    expect_eq(tstat.type, OT_LINK);

    error = tffs_stat("/sa", &tstat);
    expect(error, EFFS_OK);
    expect_eq(tstat.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_file_write("/sa/brazil/buenos-aires", TDATA(2), 
                            FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_stat("/sa/br.ba", &tstat);
    expect(error, EFFS_OK);
    expect_eq(tstat.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_file_write("/sa/br.br", TDATA(3), FFS_O_CREATE | FFS_O_EXCL);//???
    expect(error, EFFS_OK);
    error = tffs_stat("/sa/br.br", &tstat);
    expect(error, EFFS_OK);
    expect_eq(tstat.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_file_write("/south-america/argentina", TDATA(0), 
                            FFS_O_CREATE | FFS_O_EXCL);

    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";

    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_file_write(myname, mydata, mysize, FFS_O_CREATE | FFS_O_TRUNC);
            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_file_write("/asia/china/hongkong/hkfile1", TDATA(1), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/china/shanghai", TDATA(2), FFS_O_CREATE | FFS_O_EXCL);
    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_file_write("/asia/thailand", TDATA(0), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/korea", TDATA(2), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/japan/tokyo", TDATA(3), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/japan/tokyo", TDATA(4), FFS_O_TRUNC);
    expect(error, EFFS_OK);
    error = tffs_mkdir("/asia/india");
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/india/bombay", TDATA(0), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/india/newdelhi", TDATA(1), FFS_O_CREATE | FFS_O_EXCL);
    expect(error, EFFS_OK);
    error = tffs_file_write("/asia/india/calcutta", TDATA(2), FFS_O_CREATE | FFS_O_EXCL);
    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");