// EntryTest.cpp

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <list>
using std::list;
#include <map>
using std::map;
#include <set>
using std::set;

#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>

#include <Entry.h>
#include <Directory.h>
#include <Path.h>

#include "EntryTest.h"

enum test_entry_kind {
        DIR_ENTRY,
        FILE_ENTRY,
        LINK_ENTRY,
        ABSTRACT_ENTRY,
        BAD_ENTRY,
};

struct TestEntry {
        TestEntry();

        void init(TestEntry &super, string name, test_entry_kind kind,
                          bool relative = false);
        void initDir(TestEntry &super, string name);
        void initFile(TestEntry &super, string name);
        void initRLink(TestEntry &super, string name, TestEntry &target);
        void initALink(TestEntry &super, string name, TestEntry &target);
        void initPath(const char *pathName = NULL);
        void completeInit();
        bool isConcrete() const { return !(isAbstract() || isBad()); }
        bool isAbstract() const { return kind == ABSTRACT_ENTRY; }
        bool isBad() const { return kind == BAD_ENTRY; }
        const entry_ref &get_ref();

        TestEntry *             super;
        string                  name;
        test_entry_kind kind;
        string                  path;
        TestEntry *             target;
        string                  link;
        entry_ref               ref;
        bool                    relative;
        // C strings
        const char *    cname;
        const char *    cpath;
        const char *    clink;
};

static list<TestEntry*> allTestEntries;

static TestEntry badTestEntry;
static TestEntry testDir;
static TestEntry dir1;
static TestEntry dir2;
static TestEntry file1;
static TestEntry file2;
static TestEntry file3;
static TestEntry file4;
static TestEntry subDir1;
static TestEntry abstractEntry1;
static TestEntry badEntry1;
static TestEntry absDirLink1;
static TestEntry absDirLink2;
static TestEntry absDirLink3;
static TestEntry absDirLink4;
static TestEntry relDirLink1;
static TestEntry relDirLink2;
static TestEntry relDirLink3;
static TestEntry relDirLink4;
static TestEntry absFileLink1;
static TestEntry absFileLink2;
static TestEntry absFileLink3;
static TestEntry absFileLink4;
static TestEntry relFileLink1;
static TestEntry relFileLink2;
static TestEntry relFileLink3;
static TestEntry relFileLink4;
static TestEntry absCyclicLink1;
static TestEntry absCyclicLink2;
static TestEntry relCyclicLink1;
static TestEntry relCyclicLink2;
static TestEntry absBadLink1;
static TestEntry absBadLink2;
static TestEntry absBadLink3;
static TestEntry absBadLink4;
static TestEntry relBadLink1;
static TestEntry relBadLink2;
static TestEntry relBadLink3;
static TestEntry relBadLink4;
static TestEntry absVeryBadLink1;
static TestEntry absVeryBadLink2;
static TestEntry absVeryBadLink3;
static TestEntry absVeryBadLink4;
static TestEntry relVeryBadLink1;
static TestEntry relVeryBadLink2;
static TestEntry relVeryBadLink3;
static TestEntry relVeryBadLink4;
static TestEntry tooLongEntry1;
static TestEntry tooLongDir1;
static TestEntry tooLongDir2;
static TestEntry tooLongDir3;
static TestEntry tooLongDir4;
static TestEntry tooLongDir5;
static TestEntry tooLongDir6;
static TestEntry tooLongDir7;
static TestEntry tooLongDir8;
static TestEntry tooLongDir9;
static TestEntry tooLongDir10;
static TestEntry tooLongDir11;
static TestEntry tooLongDir12;
static TestEntry tooLongDir13;
static TestEntry tooLongDir14;
static TestEntry tooLongDir15;
static TestEntry tooLongDir16;

static string setUpCommandLine;
static string tearDownCommandLine;

// forward declarations
static TestEntry *resolve_link(TestEntry *entry);
static string get_shortest_relative_path(TestEntry *dir, TestEntry *entry);

static const status_t kErrors[] = {
        B_BAD_ADDRESS,
        B_BAD_VALUE,
        B_CROSS_DEVICE_LINK,
        B_DEVICE_FULL,
        B_DIRECTORY_NOT_EMPTY,
        B_ENTRY_NOT_FOUND,
        B_ERROR,
        B_FILE_ERROR,
        B_FILE_EXISTS,
        B_IS_A_DIRECTORY,
        B_LINK_LIMIT,
        B_NAME_TOO_LONG,
        B_NO_MORE_FDS,
        B_NOT_A_DIRECTORY,
        B_OK,
        B_PARTITION_TOO_SMALL,
        B_READ_ONLY_DEVICE,
        B_UNSUPPORTED,
        E2BIG
};
static const int32 kErrorCount = sizeof(kErrors) / sizeof(status_t);

// get_error_index
static
int32
get_error_index(status_t error)
{
        int32 result = -1;
        for (int32 i = 0; result == -1 && i < kErrorCount; i++) {
                if (kErrors[i] == error)
                        result = i;
        }
        if (result == -1)
                printf("WARNING: error %lx is not in the list of errors\n", error);
        return result;
}

// fuzzy_error
static
status_t
fuzzy_error(status_t error1, status_t error2)
{
        status_t result = error1;
        // encode the two errors in one value
        int32 index1 = get_error_index(error1);
        int32 index2 = get_error_index(error2);
        if (index1 >= 0 && index2 >= 0)
                result = index1 * kErrorCount + index2 + 1;
        return result;
}

// fuzzy_equals
static
bool
fuzzy_equals(status_t error, status_t fuzzyError)
{
        bool result = false;
        if (fuzzyError <= 0)
                result = (error == fuzzyError);
        else {
                // decode the error
                int32 index1 = (fuzzyError - 1) / kErrorCount;
                int32 index2 = (fuzzyError - 1) % kErrorCount;
                if (index1 >= kErrorCount)
                        printf("WARNING: bad fuzzy error: %lx\n", fuzzyError);
                else {
                        status_t error1 = kErrors[index1];
                        status_t error2 = kErrors[index2];
                        result = (error == error1 || error == error2);
                }
        }
        return result;
}


// Suite
CppUnit::Test*
EntryTest::Suite()
{
        CppUnit::TestSuite *suite = new CppUnit::TestSuite();
        typedef CppUnit::TestCaller<EntryTest> TC;

        StatableTest::AddBaseClassTests<EntryTest>("BEntry::", suite);

//      suite->addTest( new TC("BEntry::Init Test1", &EntryTest::InitTest1) );
//      suite->addTest( new TC("BEntry::Init Test2", &EntryTest::InitTest2) );
        suite->addTest( new TC("BEntry::Special cases for Exists(), GetPath(),...",
                                                   &EntryTest::SpecialGetCasesTest) );
//      suite->addTest( new TC("BEntry::Rename Test", &EntryTest::RenameTest) );
//      suite->addTest( new TC("BEntry::MoveTo Test", &EntryTest::MoveToTest) );
        suite->addTest( new TC("BEntry::Remove Test", &EntryTest::RemoveTest) );
        suite->addTest( new TC("BEntry::Comparison Test",
                                                   &EntryTest::ComparisonTest) );
        suite->addTest( new TC("BEntry::Assignment Test",
                                                   &EntryTest::AssignmentTest) );
        suite->addTest( new TC("BEntry::C Functions Test",
                                                   &EntryTest::CFunctionsTest) );
//      suite->addTest( new TC("BEntry::Miscellaneous Test", &EntryTest::MiscTest) );

        return suite;
}               

// CreateROStatables
void
EntryTest::CreateROStatables(TestStatables& testEntries)
{
        CreateRWStatables(testEntries);
}

// CreateRWStatables
void
EntryTest::CreateRWStatables(TestStatables& testStatables)
{
        TestEntry *testEntries[] = {
                &dir1, &dir2, &file1, &subDir1,
                &absDirLink1, &absDirLink2, &absDirLink3, &absDirLink4,
                &relDirLink1, &relDirLink2, &relDirLink3, &relDirLink4,
                &absFileLink1, &absFileLink2, &absFileLink3, &absFileLink4,
                &relFileLink1, &relFileLink2, &relFileLink3, &relFileLink4,
                &absBadLink1, &absBadLink2, &absBadLink3, &absBadLink4,
                &relBadLink1, &relBadLink2, &relBadLink3, &relBadLink4,
                &absVeryBadLink1, &absVeryBadLink2, &absVeryBadLink3, &absVeryBadLink4,
                &relVeryBadLink1, &relVeryBadLink2, &relVeryBadLink3, &relVeryBadLink4
        };
        int32 testEntryCount = sizeof(testEntries) / sizeof(TestEntry*);
        for (int32 i = 0; i < testEntryCount; i++) {
                TestEntry *testEntry = testEntries[i];
                const char *filename = testEntry->cpath;
                testStatables.add(new BEntry(filename), filename);
        }
}

// CreateUninitializedStatables
void
EntryTest::CreateUninitializedStatables(TestStatables& testEntries)
{
        testEntries.add(new BEntry, "");
}

// setUp
void
EntryTest::setUp()
{
        StatableTest::setUp();
        execCommand(setUpCommandLine);
}
        
// tearDown
void
EntryTest::tearDown()
{
        StatableTest::tearDown();
        execCommand(tearDownCommandLine);
}

// examine_entry
static
void
examine_entry(BEntry &entry, TestEntry *testEntry, bool traverse)
{
        if (traverse)
                testEntry = resolve_link(testEntry);
        // Exists()
        CPPUNIT_ASSERT( entry.Exists() == testEntry->isConcrete() );
        // GetPath()
        BPath path;
        CPPUNIT_ASSERT( entry.GetPath(&path) == B_OK );
        CPPUNIT_ASSERT( path == testEntry->cpath );
        // GetName()
        char name[B_FILE_NAME_LENGTH + 1];
        CPPUNIT_ASSERT( entry.GetName(name) == B_OK );
        CPPUNIT_ASSERT( testEntry->name == name );
        // GetParent(BEntry *)
        BEntry parentEntry;
        CPPUNIT_ASSERT( entry.GetParent(&parentEntry) == B_OK );
        CPPUNIT_ASSERT( parentEntry.InitCheck() == B_OK );
        CPPUNIT_ASSERT( parentEntry.GetPath(&path) == B_OK );
        CPPUNIT_ASSERT( path == testEntry->super->cpath );
        parentEntry.Unset();
        path.Unset();
        // GetParent(BDirectory *)
        BDirectory parentDir;
        CPPUNIT_ASSERT( entry.GetParent(&parentDir) == B_OK );
        CPPUNIT_ASSERT( parentDir.GetEntry(&parentEntry) == B_OK );
        CPPUNIT_ASSERT( parentEntry.InitCheck() == B_OK );
        CPPUNIT_ASSERT( parentEntry.GetPath(&path) == B_OK );
        CPPUNIT_ASSERT( path == testEntry->super->cpath );
        // GetRef()
        entry_ref ref;
        CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
        // We can't get a ref of an entry with a too long path name yet.
        if (testEntry->path.length() < B_PATH_NAME_LENGTH)
                CPPUNIT_ASSERT( ref == testEntry->get_ref() );
}

// InitTest1Paths
void
EntryTest::InitTest1Paths(TestEntry &_testEntry, status_t error, bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        // absolute path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                BEntry entry(testEntry->cpath, traverse);
                status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                if (result == B_OK)
                        examine_entry(entry, testEntry, traverse);
        }
        // relative path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                if (chdir(testEntry->super->cpath) == 0) {
                        BEntry entry(testEntry->cname, traverse);
                        status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        if (error == B_OK)
                                examine_entry(entry, testEntry, traverse);
                        RestoreCWD();
                }
        }
}

// InitTest1Refs
void
EntryTest::InitTest1Refs(TestEntry &_testEntry, status_t error, bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        // absolute path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                BEntry entry(&testEntry->get_ref(), traverse);
                status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                if (error == B_OK)
                        examine_entry(entry, testEntry, traverse);
        }
}

// InitTest1DirPaths
void
EntryTest::InitTest1DirPaths(TestEntry &_testEntry, status_t error,
                                                         bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        // absolute path
        NextSubTest();
        {
                if (!testEntry->isBad()
                        && testEntry->path.length() < B_PATH_NAME_LENGTH) {
//printf("%s\n", testEntry->cpath);
                        BDirectory dir("/boot/home/Desktop");
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        BEntry entry(&dir, testEntry->cpath, traverse);
                status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        if (error == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
        // relative path (one level)
        NextSubTest();
        {
                if (!testEntry->isBad()
                        && testEntry->super->path.length() < B_PATH_NAME_LENGTH) {
//printf("%s + %s\n", testEntry->super->cpath, testEntry->cname);
                        BDirectory dir(testEntry->super->cpath);
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        BEntry entry(&dir, testEntry->cname, traverse);
                        status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        if (error == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
        // relative path (two levels)
        NextSubTest();
        {
                if (!testEntry->super->isBad() && !testEntry->super->super->isBad()) {
                        string entryName  = testEntry->super->name + "/" + testEntry->name;
//printf("%s + %s\n", testEntry->super->super->cpath, entryName.c_str());
                        BDirectory dir(testEntry->super->super->cpath);
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        BEntry entry(&dir, entryName.c_str(), traverse);
                        status_t result = entry.InitCheck();
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        if (error == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
}

// InitTest1
void
EntryTest::InitTest1()
{
        // 1. default constructor
        NextSubTest();
        {
                BEntry entry;
                CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        }

        // 2. BEntry(const char *, bool)
        // don't traverse
        InitTest1Paths(dir1, B_OK);
        InitTest1Paths(dir2, B_OK);
        InitTest1Paths(file1, B_OK);
        InitTest1Paths(subDir1, B_OK);
        InitTest1Paths(abstractEntry1, B_OK);
        InitTest1Paths(badEntry1, B_ENTRY_NOT_FOUND);
        InitTest1Paths(absDirLink1, B_OK);
        InitTest1Paths(absDirLink2, B_OK);
        InitTest1Paths(absDirLink3, B_OK);
        InitTest1Paths(absDirLink4, B_OK);
        InitTest1Paths(relDirLink1, B_OK);
        InitTest1Paths(relDirLink2, B_OK);
        InitTest1Paths(relDirLink3, B_OK);
        InitTest1Paths(relDirLink4, B_OK);
        InitTest1Paths(absFileLink1, B_OK);
        InitTest1Paths(absFileLink2, B_OK);
        InitTest1Paths(absFileLink3, B_OK);
        InitTest1Paths(absFileLink4, B_OK);
        InitTest1Paths(relFileLink1, B_OK);
        InitTest1Paths(relFileLink2, B_OK);
        InitTest1Paths(relFileLink3, B_OK);
        InitTest1Paths(relFileLink4, B_OK);
        InitTest1Paths(absCyclicLink1, B_OK);
        InitTest1Paths(relCyclicLink1, B_OK);
        InitTest1Paths(absBadLink1, B_OK);
        InitTest1Paths(absBadLink2, B_OK);
        InitTest1Paths(absBadLink3, B_OK);
        InitTest1Paths(absBadLink4, B_OK);
        InitTest1Paths(relBadLink1, B_OK);
        InitTest1Paths(relBadLink2, B_OK);
        InitTest1Paths(relBadLink3, B_OK);
        InitTest1Paths(relBadLink4, B_OK);
        InitTest1Paths(absVeryBadLink1, B_OK);
        InitTest1Paths(absVeryBadLink2, B_OK);
        InitTest1Paths(absVeryBadLink3, B_OK);
        InitTest1Paths(absVeryBadLink4, B_OK);
        InitTest1Paths(relVeryBadLink1, B_OK);
        InitTest1Paths(relVeryBadLink2, B_OK);
        InitTest1Paths(relVeryBadLink3, B_OK);
        InitTest1Paths(relVeryBadLink4, B_OK);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest1Paths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG));
// R5: returns B_ERROR instead of B_NAME_TOO_LONG
        InitTest1Paths(tooLongDir16, fuzzy_error(B_ERROR, B_NAME_TOO_LONG));
        // traverse
        InitTest1Paths(dir1, B_OK, true);
        InitTest1Paths(dir2, B_OK, true);
        InitTest1Paths(file1, B_OK, true);
        InitTest1Paths(subDir1, B_OK, true);
        InitTest1Paths(abstractEntry1, B_OK, true);
        InitTest1Paths(badEntry1, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absDirLink1, B_OK, true);
        InitTest1Paths(absDirLink2, B_OK, true);
        InitTest1Paths(absDirLink3, B_OK, true);
        InitTest1Paths(absDirLink4, B_OK, true);
        InitTest1Paths(relDirLink1, B_OK, true);
        InitTest1Paths(relDirLink2, B_OK, true);
        InitTest1Paths(relDirLink3, B_OK, true);
        InitTest1Paths(relDirLink4, B_OK, true);
        InitTest1Paths(absFileLink1, B_OK, true);
        InitTest1Paths(absFileLink2, B_OK, true);
        InitTest1Paths(absFileLink3, B_OK, true);
        InitTest1Paths(absFileLink4, B_OK, true);
        InitTest1Paths(relFileLink1, B_OK, true);
        InitTest1Paths(relFileLink2, B_OK, true);
        InitTest1Paths(relFileLink3, B_OK, true);
        InitTest1Paths(relFileLink4, B_OK, true);
        InitTest1Paths(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest1Paths(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest1Paths(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Paths(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest1Paths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG), true);
// R5: returns B_ERROR instead of B_NAME_TOO_LONG
        InitTest1Paths(tooLongDir16, fuzzy_error(B_ERROR, B_NAME_TOO_LONG), true);

        // special cases (root dir)
        NextSubTest();
        {
                BEntry entry("/");
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // special cases (fs root dir)
        NextSubTest();
        {
                BEntry entry("/boot");
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // bad args
        NextSubTest();
        {
                BEntry entry((const char*)NULL);
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        }

        // 3. BEntry(const entry_ref *, bool)
        // don't traverse
        InitTest1Refs(dir1, B_OK);
        InitTest1Refs(dir2, B_OK);
        InitTest1Refs(file1, B_OK);
        InitTest1Refs(subDir1, B_OK);
        InitTest1Refs(abstractEntry1, B_OK);
        InitTest1Refs(absDirLink1, B_OK);
        InitTest1Refs(absDirLink2, B_OK);
        InitTest1Refs(absDirLink3, B_OK);
        InitTest1Refs(absDirLink4, B_OK);
        InitTest1Refs(relDirLink1, B_OK);
        InitTest1Refs(relDirLink2, B_OK);
        InitTest1Refs(relDirLink3, B_OK);
        InitTest1Refs(relDirLink4, B_OK);
        InitTest1Refs(absFileLink1, B_OK);
        InitTest1Refs(absFileLink2, B_OK);
        InitTest1Refs(absFileLink3, B_OK);
        InitTest1Refs(absFileLink4, B_OK);
        InitTest1Refs(relFileLink1, B_OK);
        InitTest1Refs(relFileLink2, B_OK);
        InitTest1Refs(relFileLink3, B_OK);
        InitTest1Refs(relFileLink4, B_OK);
        InitTest1Refs(absCyclicLink1, B_OK);
        InitTest1Refs(relCyclicLink1, B_OK);
        InitTest1Refs(absBadLink1, B_OK);
        InitTest1Refs(absBadLink2, B_OK);
        InitTest1Refs(absBadLink3, B_OK);
        InitTest1Refs(absBadLink4, B_OK);
        InitTest1Refs(relBadLink1, B_OK);
        InitTest1Refs(relBadLink2, B_OK);
        InitTest1Refs(relBadLink3, B_OK);
        InitTest1Refs(relBadLink4, B_OK);
        InitTest1Refs(absVeryBadLink1, B_OK);
        InitTest1Refs(absVeryBadLink2, B_OK);
        InitTest1Refs(absVeryBadLink3, B_OK);
        InitTest1Refs(absVeryBadLink4, B_OK);
        InitTest1Refs(relVeryBadLink1, B_OK);
        InitTest1Refs(relVeryBadLink2, B_OK);
        InitTest1Refs(relVeryBadLink3, B_OK);
        InitTest1Refs(relVeryBadLink4, B_OK);
        // traverse
        InitTest1Refs(dir1, B_OK, true);
        InitTest1Refs(dir2, B_OK, true);
        InitTest1Refs(file1, B_OK, true);
        InitTest1Refs(subDir1, B_OK, true);
        InitTest1Refs(abstractEntry1, B_OK, true);
        InitTest1Refs(absDirLink1, B_OK, true);
        InitTest1Refs(absDirLink2, B_OK, true);
        InitTest1Refs(absDirLink3, B_OK, true);
        InitTest1Refs(absDirLink4, B_OK, true);
        InitTest1Refs(relDirLink1, B_OK, true);
        InitTest1Refs(relDirLink2, B_OK, true);
        InitTest1Refs(relDirLink3, B_OK, true);
        InitTest1Refs(relDirLink4, B_OK, true);
        InitTest1Refs(absFileLink1, B_OK, true);
        InitTest1Refs(absFileLink2, B_OK, true);
        InitTest1Refs(absFileLink3, B_OK, true);
        InitTest1Refs(absFileLink4, B_OK, true);
        InitTest1Refs(relFileLink1, B_OK, true);
        InitTest1Refs(relFileLink2, B_OK, true);
        InitTest1Refs(relFileLink3, B_OK, true);
        InitTest1Refs(relFileLink4, B_OK, true);
        InitTest1Refs(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest1Refs(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest1Refs(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1Refs(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        // bad args
        NextSubTest();
        {
                BEntry entry((const entry_ref*)NULL);
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        }

        // 4. BEntry(const BDirectory *, const char *, bool)
        // don't traverse
        InitTest1DirPaths(dir1, B_OK);
        InitTest1DirPaths(dir2, B_OK);
        InitTest1DirPaths(file1, B_OK);
        InitTest1DirPaths(subDir1, B_OK);
        InitTest1DirPaths(abstractEntry1, B_OK);
        InitTest1DirPaths(badEntry1, B_ENTRY_NOT_FOUND);
        InitTest1DirPaths(absDirLink1, B_OK);
        InitTest1DirPaths(absDirLink2, B_OK);
        InitTest1DirPaths(absDirLink3, B_OK);
        InitTest1DirPaths(absDirLink4, B_OK);
        InitTest1DirPaths(relDirLink1, B_OK);
        InitTest1DirPaths(relDirLink2, B_OK);
        InitTest1DirPaths(relDirLink3, B_OK);
        InitTest1DirPaths(relDirLink4, B_OK);
        InitTest1DirPaths(absFileLink1, B_OK);
        InitTest1DirPaths(absFileLink2, B_OK);
        InitTest1DirPaths(absFileLink3, B_OK);
        InitTest1DirPaths(absFileLink4, B_OK);
        InitTest1DirPaths(relFileLink1, B_OK);
        InitTest1DirPaths(relFileLink2, B_OK);
        InitTest1DirPaths(relFileLink3, B_OK);
        InitTest1DirPaths(relFileLink4, B_OK);
        InitTest1DirPaths(absCyclicLink1, B_OK);
        InitTest1DirPaths(relCyclicLink1, B_OK);
        InitTest1DirPaths(absBadLink1, B_OK);
        InitTest1DirPaths(absBadLink2, B_OK);
        InitTest1DirPaths(absBadLink3, B_OK);
        InitTest1DirPaths(absBadLink4, B_OK);
        InitTest1DirPaths(relBadLink1, B_OK);
        InitTest1DirPaths(relBadLink2, B_OK);
        InitTest1DirPaths(relBadLink3, B_OK);
        InitTest1DirPaths(relBadLink4, B_OK);
        InitTest1DirPaths(absVeryBadLink1, B_OK);
        InitTest1DirPaths(absVeryBadLink2, B_OK);
        InitTest1DirPaths(absVeryBadLink3, B_OK);
        InitTest1DirPaths(absVeryBadLink4, B_OK);
        InitTest1DirPaths(relVeryBadLink1, B_OK);
        InitTest1DirPaths(relVeryBadLink2, B_OK);
        InitTest1DirPaths(relVeryBadLink3, B_OK);
        InitTest1DirPaths(relVeryBadLink4, B_OK);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest1DirPaths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG));
// Haiku: Fails, because the implementation concatenates the dir and leaf
//               name.
#if !TEST_OBOS /* !!!POSIX ONLY!!! */
        InitTest1DirPaths(tooLongDir16, B_OK, true);
#endif
        // traverse
        InitTest1DirPaths(dir1, B_OK, true);
        InitTest1DirPaths(dir2, B_OK, true);
        InitTest1DirPaths(file1, B_OK, true);
        InitTest1DirPaths(subDir1, B_OK, true);
        InitTest1DirPaths(abstractEntry1, B_OK, true);
        InitTest1DirPaths(badEntry1, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absDirLink1, B_OK, true);
        InitTest1DirPaths(absDirLink2, B_OK, true);
        InitTest1DirPaths(absDirLink3, B_OK, true);
        InitTest1DirPaths(absDirLink4, B_OK, true);
        InitTest1DirPaths(relDirLink1, B_OK, true);
        InitTest1DirPaths(relDirLink2, B_OK, true);
        InitTest1DirPaths(relDirLink3, B_OK, true);
        InitTest1DirPaths(relDirLink4, B_OK, true);
        InitTest1DirPaths(absFileLink1, B_OK, true);
        InitTest1DirPaths(absFileLink2, B_OK, true);
        InitTest1DirPaths(absFileLink3, B_OK, true);
        InitTest1DirPaths(absFileLink4, B_OK, true);
        InitTest1DirPaths(relFileLink1, B_OK, true);
        InitTest1DirPaths(relFileLink2, B_OK, true);
        InitTest1DirPaths(relFileLink3, B_OK, true);
        InitTest1DirPaths(relFileLink4, B_OK, true);
        InitTest1DirPaths(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest1DirPaths(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest1DirPaths(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest1DirPaths(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest1DirPaths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG), true);
// Haiku: Fails, because the implementation concatenates the dir and leaf
//               name.
#if !TEST_OBOS /* !!!POSIX ONLY!!! */
        InitTest1DirPaths(tooLongDir16, B_OK, true);
#endif

        // special cases (root dir)
        NextSubTest();
        {
                BDirectory dir("/");
                BEntry entry(&dir, ".");
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // special cases (fs root dir)
        NextSubTest();
        {
                BDirectory dir("/");
                BEntry entry(&dir, "boot");
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // NULL path
        NextSubTest();
        {
                BDirectory dir("/");
                BEntry entry(&dir, (const char*)NULL);
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // bad args (NULL dir)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                chdir("/");
                BEntry entry((const BDirectory*)NULL, "tmp");
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
                RestoreCWD();
        }
#endif
        // strange args (badly initialized dir, absolute path)
        NextSubTest();
        {
                BDirectory dir(badEntry1.cpath);
                CPPUNIT_ASSERT( dir.InitCheck() == B_ENTRY_NOT_FOUND );
                BEntry entry(&dir, "/tmp");
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // bad args (NULL dir and path)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                BEntry entry((const BDirectory*)NULL, (const char*)NULL);
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        }
#endif
        // bad args(NULL dir, absolute path)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                BEntry entry((const BDirectory*)NULL, "/tmp");
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        }
#endif
}

// InitTest2Paths
void
EntryTest::InitTest2Paths(TestEntry &_testEntry, status_t error, bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        BEntry entry;
        // absolute path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                status_t result = entry.SetTo(testEntry->cpath, traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                if (result == B_OK)
                        examine_entry(entry, testEntry, traverse);
        }
        // relative path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                if (chdir(testEntry->super->cpath) == 0) {
                        status_t result = entry.SetTo(testEntry->cname, traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                        if (result == B_OK)
                                examine_entry(entry, testEntry, traverse);
                        RestoreCWD();
                }
        }
}

// InitTest2Refs
void
EntryTest::InitTest2Refs(TestEntry &_testEntry, status_t error, bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        BEntry entry;
        // absolute path
        NextSubTest();
        {
//printf("%s\n", testEntry->cpath);
                status_t result = entry.SetTo(&testEntry->get_ref(), traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                if (result == B_OK)
                        examine_entry(entry, testEntry, traverse);
        }
}

// InitTest2DirPaths
void
EntryTest::InitTest2DirPaths(TestEntry &_testEntry, status_t error,
                                                         bool traverse)
{
        TestEntry *testEntry = &_testEntry;
        BEntry entry;
        // absolute path
        NextSubTest();
        {
                if (!testEntry->isBad()
                        && testEntry->path.length() < B_PATH_NAME_LENGTH) {
//printf("%s\n", testEntry->cpath);
                        BDirectory dir("/boot/home/Desktop");
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        status_t result = entry.SetTo(&dir, testEntry->cpath, traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                        if (result == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
        // relative path (one level)
        NextSubTest();
        {
                if (!testEntry->isBad()
                        && testEntry->super->path.length() < B_PATH_NAME_LENGTH) {
//printf("%s + %s\n", testEntry->super->cpath, testEntry->cname);
                        BDirectory dir(testEntry->super->cpath);
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        status_t result = entry.SetTo(&dir, testEntry->cname, traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                        if (result == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
        // relative path (two levels)
        NextSubTest();
        {
                if (!testEntry->super->isBad() && !testEntry->super->super->isBad()) {
                        string entryName  = testEntry->super->name + "/" + testEntry->name;
//printf("%s + %s\n", testEntry->super->super->cpath, entryName.c_str());
                        BDirectory dir(testEntry->super->super->cpath);
                        CPPUNIT_ASSERT( dir.InitCheck() == B_OK );
                        status_t result = entry.SetTo(&dir, entryName.c_str(), traverse);
if (!fuzzy_equals(result, error))
printf("error: %lx (%lx)\n", result, error);
                        CPPUNIT_ASSERT( fuzzy_equals(result, error) );
                        CPPUNIT_ASSERT( fuzzy_equals(entry.InitCheck(), error) );
                        if (result == B_OK)
                                examine_entry(entry, testEntry, traverse);
                }
        }
}

// InitTest2
void
EntryTest::InitTest2()
{
        BEntry entry;
        // 2. SetTo(const char *, bool)
        // don't traverse
        InitTest2Paths(dir1, B_OK);
        InitTest2Paths(dir2, B_OK);
        InitTest2Paths(file1, B_OK);
        InitTest2Paths(subDir1, B_OK);
        InitTest2Paths(abstractEntry1, B_OK);
        InitTest2Paths(badEntry1, B_ENTRY_NOT_FOUND);
        InitTest2Paths(absDirLink1, B_OK);
        InitTest2Paths(absDirLink2, B_OK);
        InitTest2Paths(absDirLink3, B_OK);
        InitTest2Paths(absDirLink4, B_OK);
        InitTest2Paths(relDirLink1, B_OK);
        InitTest2Paths(relDirLink2, B_OK);
        InitTest2Paths(relDirLink3, B_OK);
        InitTest2Paths(relDirLink4, B_OK);
        InitTest2Paths(absFileLink1, B_OK);
        InitTest2Paths(absFileLink2, B_OK);
        InitTest2Paths(absFileLink3, B_OK);
        InitTest2Paths(absFileLink4, B_OK);
        InitTest2Paths(relFileLink1, B_OK);
        InitTest2Paths(relFileLink2, B_OK);
        InitTest2Paths(relFileLink3, B_OK);
        InitTest2Paths(relFileLink4, B_OK);
        InitTest2Paths(absCyclicLink1, B_OK);
        InitTest2Paths(relCyclicLink1, B_OK);
        InitTest2Paths(absBadLink1, B_OK);
        InitTest2Paths(absBadLink2, B_OK);
        InitTest2Paths(absBadLink3, B_OK);
        InitTest2Paths(absBadLink4, B_OK);
        InitTest2Paths(relBadLink1, B_OK);
        InitTest2Paths(relBadLink2, B_OK);
        InitTest2Paths(relBadLink3, B_OK);
        InitTest2Paths(relBadLink4, B_OK);
        InitTest2Paths(absVeryBadLink1, B_OK);
        InitTest2Paths(absVeryBadLink2, B_OK);
        InitTest2Paths(absVeryBadLink3, B_OK);
        InitTest2Paths(absVeryBadLink4, B_OK);
        InitTest2Paths(relVeryBadLink1, B_OK);
        InitTest2Paths(relVeryBadLink2, B_OK);
        InitTest2Paths(relVeryBadLink3, B_OK);
        InitTest2Paths(relVeryBadLink4, B_OK);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest2Paths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG));
// R5: returns B_ERROR instead of B_NAME_TOO_LONG
        InitTest2Paths(tooLongDir16, fuzzy_error(B_ERROR, B_NAME_TOO_LONG));
        // traverse
        InitTest2Paths(dir1, B_OK, true);
        InitTest2Paths(dir2, B_OK, true);
        InitTest2Paths(file1, B_OK, true);
        InitTest2Paths(subDir1, B_OK, true);
        InitTest2Paths(abstractEntry1, B_OK, true);
        InitTest2Paths(badEntry1, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absDirLink1, B_OK, true);
        InitTest2Paths(absDirLink2, B_OK, true);
        InitTest2Paths(absDirLink3, B_OK, true);
        InitTest2Paths(absDirLink4, B_OK, true);
        InitTest2Paths(relDirLink1, B_OK, true);
        InitTest2Paths(relDirLink2, B_OK, true);
        InitTest2Paths(relDirLink3, B_OK, true);
        InitTest2Paths(relDirLink4, B_OK, true);
        InitTest2Paths(absFileLink1, B_OK, true);
        InitTest2Paths(absFileLink2, B_OK, true);
        InitTest2Paths(absFileLink3, B_OK, true);
        InitTest2Paths(absFileLink4, B_OK, true);
        InitTest2Paths(relFileLink1, B_OK, true);
        InitTest2Paths(relFileLink2, B_OK, true);
        InitTest2Paths(relFileLink3, B_OK, true);
        InitTest2Paths(relFileLink4, B_OK, true);
        InitTest2Paths(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest2Paths(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest2Paths(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Paths(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest2Paths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG), true);
// R5: returns B_ERROR instead of B_NAME_TOO_LONG
        InitTest2Paths(tooLongDir16, fuzzy_error(B_ERROR, B_NAME_TOO_LONG), true);
        // special cases (root dir)
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/") == B_OK );
        CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        entry.Unset();
        // special cases (fs root dir)
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/boot") == B_OK );
        CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        entry.Unset();
        // bad args
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo((const char*)NULL) == B_BAD_VALUE );
        CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        entry.Unset();

        // 3. BEntry(const entry_ref *, bool)
        // don't traverse
        InitTest2Refs(dir1, B_OK);
        InitTest2Refs(dir2, B_OK);
        InitTest2Refs(file1, B_OK);
        InitTest2Refs(subDir1, B_OK);
        InitTest2Refs(abstractEntry1, B_OK);
        InitTest2Refs(absDirLink1, B_OK);
        InitTest2Refs(absDirLink2, B_OK);
        InitTest2Refs(absDirLink3, B_OK);
        InitTest2Refs(absDirLink4, B_OK);
        InitTest2Refs(relDirLink1, B_OK);
        InitTest2Refs(relDirLink2, B_OK);
        InitTest2Refs(relDirLink3, B_OK);
        InitTest2Refs(relDirLink4, B_OK);
        InitTest2Refs(absFileLink1, B_OK);
        InitTest2Refs(absFileLink2, B_OK);
        InitTest2Refs(absFileLink3, B_OK);
        InitTest2Refs(absFileLink4, B_OK);
        InitTest2Refs(relFileLink1, B_OK);
        InitTest2Refs(relFileLink2, B_OK);
        InitTest2Refs(relFileLink3, B_OK);
        InitTest2Refs(relFileLink4, B_OK);
        InitTest2Refs(absCyclicLink1, B_OK);
        InitTest2Refs(relCyclicLink1, B_OK);
        InitTest2Refs(absBadLink1, B_OK);
        InitTest2Refs(absBadLink2, B_OK);
        InitTest2Refs(absBadLink3, B_OK);
        InitTest2Refs(absBadLink4, B_OK);
        InitTest2Refs(relBadLink1, B_OK);
        InitTest2Refs(relBadLink2, B_OK);
        InitTest2Refs(relBadLink3, B_OK);
        InitTest2Refs(relBadLink4, B_OK);
        InitTest2Refs(absVeryBadLink1, B_OK);
        InitTest2Refs(absVeryBadLink2, B_OK);
        InitTest2Refs(absVeryBadLink3, B_OK);
        InitTest2Refs(absVeryBadLink4, B_OK);
        InitTest2Refs(relVeryBadLink1, B_OK);
        InitTest2Refs(relVeryBadLink2, B_OK);
        InitTest2Refs(relVeryBadLink3, B_OK);
        InitTest2Refs(relVeryBadLink4, B_OK);
        // traverse
        InitTest2Refs(dir1, B_OK, true);
        InitTest2Refs(dir2, B_OK, true);
        InitTest2Refs(file1, B_OK, true);
        InitTest2Refs(subDir1, B_OK, true);
        InitTest2Refs(abstractEntry1, B_OK, true);
        InitTest2Refs(absDirLink1, B_OK, true);
        InitTest2Refs(absDirLink2, B_OK, true);
        InitTest2Refs(absDirLink3, B_OK, true);
        InitTest2Refs(absDirLink4, B_OK, true);
        InitTest2Refs(relDirLink1, B_OK, true);
        InitTest2Refs(relDirLink2, B_OK, true);
        InitTest2Refs(relDirLink3, B_OK, true);
        InitTest2Refs(relDirLink4, B_OK, true);
        InitTest2Refs(absFileLink1, B_OK, true);
        InitTest2Refs(absFileLink2, B_OK, true);
        InitTest2Refs(absFileLink3, B_OK, true);
        InitTest2Refs(absFileLink4, B_OK, true);
        InitTest2Refs(relFileLink1, B_OK, true);
        InitTest2Refs(relFileLink2, B_OK, true);
        InitTest2Refs(relFileLink3, B_OK, true);
        InitTest2Refs(relFileLink4, B_OK, true);
        InitTest2Refs(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest2Refs(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest2Refs(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2Refs(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        // bad args
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo((const entry_ref*)NULL) == B_BAD_VALUE );
        CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
        entry.Unset();

        // 4. BEntry(const BDirectory *, const char *, bool)
        // don't traverse
        InitTest2DirPaths(dir1, B_OK);
        InitTest2DirPaths(dir2, B_OK);
        InitTest2DirPaths(file1, B_OK);
        InitTest2DirPaths(subDir1, B_OK);
        InitTest2DirPaths(abstractEntry1, B_OK);
        InitTest2DirPaths(badEntry1, B_ENTRY_NOT_FOUND);
        InitTest2DirPaths(absDirLink1, B_OK);
        InitTest2DirPaths(absDirLink2, B_OK);
        InitTest2DirPaths(absDirLink3, B_OK);
        InitTest2DirPaths(absDirLink4, B_OK);
        InitTest2DirPaths(relDirLink1, B_OK);
        InitTest2DirPaths(relDirLink2, B_OK);
        InitTest2DirPaths(relDirLink3, B_OK);
        InitTest2DirPaths(relDirLink4, B_OK);
        InitTest2DirPaths(absFileLink1, B_OK);
        InitTest2DirPaths(absFileLink2, B_OK);
        InitTest2DirPaths(absFileLink3, B_OK);
        InitTest2DirPaths(absFileLink4, B_OK);
        InitTest2DirPaths(relFileLink1, B_OK);
        InitTest2DirPaths(relFileLink2, B_OK);
        InitTest2DirPaths(relFileLink3, B_OK);
        InitTest2DirPaths(relFileLink4, B_OK);
        InitTest2DirPaths(absCyclicLink1, B_OK);
        InitTest2DirPaths(relCyclicLink1, B_OK);
        InitTest2DirPaths(absBadLink1, B_OK);
        InitTest2DirPaths(absBadLink2, B_OK);
        InitTest2DirPaths(absBadLink3, B_OK);
        InitTest2DirPaths(absBadLink4, B_OK);
        InitTest2DirPaths(relBadLink1, B_OK);
        InitTest2DirPaths(relBadLink2, B_OK);
        InitTest2DirPaths(relBadLink3, B_OK);
        InitTest2DirPaths(relBadLink4, B_OK);
        InitTest2DirPaths(absVeryBadLink1, B_OK);
        InitTest2DirPaths(absVeryBadLink2, B_OK);
        InitTest2DirPaths(absVeryBadLink3, B_OK);
        InitTest2DirPaths(absVeryBadLink4, B_OK);
        InitTest2DirPaths(relVeryBadLink1, B_OK);
        InitTest2DirPaths(relVeryBadLink2, B_OK);
        InitTest2DirPaths(relVeryBadLink3, B_OK);
        InitTest2DirPaths(relVeryBadLink4, B_OK);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest2DirPaths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG));
// Haiku: Fails, because the implementation concatenates the dir and leaf
//               name.
#if !TEST_OBOS /* !!!POSIX ONLY!!! */
        InitTest2DirPaths(tooLongDir16, B_OK, true);
#endif
        // traverse
        InitTest2DirPaths(dir1, B_OK, true);
        InitTest2DirPaths(dir2, B_OK, true);
        InitTest2DirPaths(file1, B_OK, true);
        InitTest2DirPaths(subDir1, B_OK, true);
        InitTest2DirPaths(abstractEntry1, B_OK, true);
        InitTest2DirPaths(badEntry1, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absDirLink1, B_OK, true);
        InitTest2DirPaths(absDirLink2, B_OK, true);
        InitTest2DirPaths(absDirLink3, B_OK, true);
        InitTest2DirPaths(absDirLink4, B_OK, true);
        InitTest2DirPaths(relDirLink1, B_OK, true);
        InitTest2DirPaths(relDirLink2, B_OK, true);
        InitTest2DirPaths(relDirLink3, B_OK, true);
        InitTest2DirPaths(relDirLink4, B_OK, true);
        InitTest2DirPaths(absFileLink1, B_OK, true);
        InitTest2DirPaths(absFileLink2, B_OK, true);
        InitTest2DirPaths(absFileLink3, B_OK, true);
        InitTest2DirPaths(absFileLink4, B_OK, true);
        InitTest2DirPaths(relFileLink1, B_OK, true);
        InitTest2DirPaths(relFileLink2, B_OK, true);
        InitTest2DirPaths(relFileLink3, B_OK, true);
        InitTest2DirPaths(relFileLink4, B_OK, true);
        InitTest2DirPaths(absCyclicLink1, B_LINK_LIMIT, true);
        InitTest2DirPaths(relCyclicLink1, B_LINK_LIMIT, true);
        InitTest2DirPaths(absBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(absVeryBadLink4, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relVeryBadLink1, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relVeryBadLink2, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relVeryBadLink3, B_ENTRY_NOT_FOUND, true);
        InitTest2DirPaths(relVeryBadLink4, B_ENTRY_NOT_FOUND, true);
// R5: returns E2BIG instead of B_NAME_TOO_LONG
        InitTest2DirPaths(tooLongEntry1, fuzzy_error(E2BIG, B_NAME_TOO_LONG), true);
// Haiku: Fails, because the implementation concatenates the dir and leaf
//               name.
#if !TEST_OBOS /* !!!POSIX ONLY!!! */
        InitTest2DirPaths(tooLongDir16, B_OK, true);
#endif
        // special cases (root dir)
        NextSubTest();
        {
                BDirectory dir("/");
                CPPUNIT_ASSERT( entry.SetTo(&dir, ".") == B_OK );
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
                entry.Unset();
        }
        // special cases (fs root dir)
        NextSubTest();
        {
                BDirectory dir("/");
                CPPUNIT_ASSERT( entry.SetTo(&dir, "boot") == B_OK );
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
                entry.Unset();
        }
        // NULL path
        NextSubTest();
        {
                BDirectory dir("/");
                CPPUNIT_ASSERT( entry.SetTo(&dir, (const char*)NULL) == B_OK );
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
                entry.Unset();
        }
        // bad args (NULL dir)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                chdir("/");
                CPPUNIT_ASSERT( entry.SetTo((const BDirectory*)NULL, "tmp")
                                                == B_BAD_VALUE );
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
                RestoreCWD();
                entry.Unset();
        }
#endif
        // strange args (badly initialized dir, absolute path)
        NextSubTest();
        {
                BDirectory dir(badEntry1.cpath);
                CPPUNIT_ASSERT( dir.InitCheck() == B_ENTRY_NOT_FOUND );
                CPPUNIT_ASSERT( entry.SetTo(&dir, "/tmp") == B_OK );
                CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
        }
        // bad args (NULL dir and path)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                CPPUNIT_ASSERT( entry.SetTo((const BDirectory*)NULL, (const char*)NULL)
                                                == B_BAD_VALUE );
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
                entry.Unset();
        }
#endif
        // bad args(NULL dir, absolute path)
// R5: crashs
#if !TEST_R5
        NextSubTest();
        {
                CPPUNIT_ASSERT( entry.SetTo((const BDirectory*)NULL, "/tmp")
                                                == B_BAD_VALUE );
                CPPUNIT_ASSERT( entry.InitCheck() == B_BAD_VALUE );
                entry.Unset();
        }
#endif
}

// SpecialGetCasesTest
//
// Tests special (mostly error) cases for Exists(), GetPath(), GetName(),
// GetParent() and GetRef(). The other cases have already been tested in
// InitTest1/2().
void
EntryTest::SpecialGetCasesTest()
{
        BEntry entry;
        // 1. Exists()
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.Exists() == false );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.Exists() == false );
        entry.Unset();  
        // root
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/") == B_OK );
        CPPUNIT_ASSERT( entry.Exists() == true );
        entry.Unset();  

        // 2. GetPath()
        BPath path;
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.GetPath(&path) == B_NO_INIT );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.GetPath(&path) == B_NO_INIT );
        entry.Unset();  
        // too long pathname
// Haiku: Fails, because the implementation concatenates the dir and leaf
//               name.
#if !TEST_OBOS /* !!!POSIX ONLY!!! */
        NextSubTest();
        BDirectory dir(tooLongDir16.super->super->cpath);
        string entryName = tooLongDir16.super->name + "/" + tooLongDir16.name;
        CPPUNIT_ASSERT( entry.SetTo(&dir, entryName.c_str()) == B_OK );
        CPPUNIT_ASSERT( entry.GetPath(&path) == B_OK );
        CPPUNIT_ASSERT( path == tooLongDir16.cpath );
        entry.Unset();  
#endif

        // 3. GetName()
        char name[B_FILE_NAME_LENGTH + 1];
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.GetName(name) == B_NO_INIT );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.GetName(name) == B_NO_INIT );
        entry.Unset();  

        // 4. GetParent(BEntry *)
        BEntry parentEntry;
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.GetParent(&parentEntry) == B_NO_INIT );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.GetParent(&parentEntry) == B_NO_INIT );
        entry.Unset();  
        // parent of root dir
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/") == B_OK );
        CPPUNIT_ASSERT( entry.GetParent(&parentEntry) == B_ENTRY_NOT_FOUND );
        entry.Unset();  

        // 5. GetParent(BDirectory *)
        BDirectory parentDir;
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.GetParent(&parentDir) == B_NO_INIT );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.GetParent(&parentDir) == B_NO_INIT );
        entry.Unset();  
        // parent of root dir
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/") == B_OK );
        CPPUNIT_ASSERT( entry.GetParent(&parentDir) == B_ENTRY_NOT_FOUND );
        entry.Unset();  

        // 6. GetRef()
        entry_ref ref, ref2;
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.GetRef(&ref) == B_NO_INIT );
        entry.Unset();  
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.GetRef(&ref) == B_NO_INIT );
        entry.Unset();  
        // ref for root dir
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo("/") == B_OK );
        CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
        entry.Unset();  
}

// RenameTestEntry
void
EntryTest::RenameTestEntry(TestEntry *testEntry, TestEntry *newTestEntry,
                                                   string newName, bool existing, bool clobber,
                                                   status_t error, uint32 kind)
{
        NextSubTest();
        BEntry entry;
        BDirectory dir;
        // get all the names
        string pathname = testEntry->path; 
        string dirname = testEntry->super->path;
        string newPathname = newTestEntry->path;
//printf("path: `%s', dir: `%s', new name: `%s'\n", pathname.c_str(),
//dirname.c_str(), newPathname.c_str());
        // create the entries
        switch (kind) {
                case B_FILE_NODE:
                        CreateFile(pathname.c_str());
                        break;
                case B_DIRECTORY_NODE:
                        CreateDir(pathname.c_str());
                        break;
                case B_SYMLINK_NODE:
                        CreateLink(pathname.c_str(), file1.cpath);
                        break;
        }
        if (existing)
                CreateFile(newPathname.c_str());
        // rename the file
        CPPUNIT_ASSERT( entry.SetTo(pathname.c_str()) == B_OK );
        CPPUNIT_ASSERT( dir.SetTo(dirname.c_str()) == B_OK );
        status_t result = entry.Rename(newName.c_str(), clobber);
if (result != error) {
printf("`%s'.Rename(`%s', %d): ", pathname.c_str(), newName.c_str(), clobber);
printf("error: %lx (%lx)\n", result, error);
}
        CPPUNIT_ASSERT( result == error );
        // check and cleanup
        if (error == B_OK) {
                switch (kind) {
                        case B_FILE_NODE:
                                CPPUNIT_ASSERT( !PingFile(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingFile(newPathname.c_str()) );
                                break;
                        case B_DIRECTORY_NODE:
                                CPPUNIT_ASSERT( !PingDir(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingDir(newPathname.c_str()) );
                                break;
                        case B_SYMLINK_NODE:
                                CPPUNIT_ASSERT( !PingLink(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingLink(newPathname.c_str(), file1.cpath) );
                                break;
                }
                RemoveFile(newPathname.c_str());
        } else {
                switch (kind) {
                        case B_FILE_NODE:
                                CPPUNIT_ASSERT( PingFile(pathname.c_str()) );
                                break;
                        case B_DIRECTORY_NODE:
                                CPPUNIT_ASSERT( PingDir(pathname.c_str()) );
                                break;
                        case B_SYMLINK_NODE:
                                CPPUNIT_ASSERT( PingLink(pathname.c_str(), file1.cpath) );
                                break;
                }
                if (existing) {
                        CPPUNIT_ASSERT( PingFile(newPathname.c_str()) );
                        RemoveFile(newPathname.c_str());
                }
                RemoveFile(pathname.c_str());
        }
}

// RenameTestEntry
void
EntryTest::RenameTestEntry(TestEntry *testEntry, TestEntry *newTestEntry,
                                                   bool existing, bool clobber, status_t error,
                                                   uint32 kind)
{
        // relative path
        string relPath = get_shortest_relative_path(testEntry->super,
                                                                                                newTestEntry);
        if (relPath.length() > 0) {
                RenameTestEntry(testEntry, newTestEntry, relPath, existing,
                                                clobber, error, B_FILE_NODE);
        }
        // absolute path
        RenameTestEntry(testEntry, newTestEntry, newTestEntry->path, existing,
                                        clobber, error, B_FILE_NODE);
}

// RenameTestFile
void
EntryTest::RenameTestFile(TestEntry *testEntry, TestEntry *newTestEntry,
                                                  bool existing, bool clobber, status_t error)
{
        RenameTestEntry(testEntry, newTestEntry, existing, clobber, error,
                                        B_FILE_NODE);
}

// RenameTestDir
void
EntryTest::RenameTestDir(TestEntry *testEntry, TestEntry *newTestEntry,
                                                 bool existing, bool clobber, status_t error)
{
        RenameTestEntry(testEntry, newTestEntry, existing, clobber, error,
                                        B_DIRECTORY_NODE);
}

// RenameTestLink
void
EntryTest::RenameTestLink(TestEntry *testEntry, TestEntry *newTestEntry,
                                                  bool existing, bool clobber, status_t error)
{
        RenameTestEntry(testEntry, newTestEntry, existing, clobber, error,
                                        B_SYMLINK_NODE);
}

// RenameTest
void
EntryTest::RenameTest()
{
        BDirectory dir;
        BEntry entry;
        // file
        // same dir
        RenameTestFile(&file2, &file2, false, false, B_FILE_EXISTS);
        RenameTestFile(&file2, &file2, false, true, B_NOT_ALLOWED);
        RenameTestFile(&file2, &file4, false, false, B_OK);
        // different dir
        RenameTestFile(&file2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        RenameTestFile(&file2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        RenameTestFile(&file2, &file3, true, false, B_FILE_EXISTS);
        // dir
        // same dir
        RenameTestDir(&file2, &file2, false, false, B_FILE_EXISTS);
        RenameTestDir(&file2, &file2, false, true, B_NOT_ALLOWED);
        RenameTestDir(&file2, &file4, false, false, B_OK);
        // different dir
        RenameTestDir(&file2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        RenameTestDir(&file2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        RenameTestDir(&file2, &file3, true, false, B_FILE_EXISTS);
        // link
        // same dir
        RenameTestLink(&file2, &file2, false, false, B_FILE_EXISTS);
        RenameTestLink(&file2, &file2, false, true, B_NOT_ALLOWED);
        RenameTestLink(&file2, &file4, false, false, B_OK);
        // different dir
        RenameTestLink(&file2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        RenameTestLink(&file2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        RenameTestLink(&file2, &file3, true, false, B_FILE_EXISTS);

        // try to clobber a non-empty directory
        NextSubTest();
        CreateFile(file3.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file3.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Rename(dir1.cpath, true) == B_DIRECTORY_NOT_EMPTY );
        CPPUNIT_ASSERT( PingDir(dir1.cpath) );
        CPPUNIT_ASSERT( PingFile(file3.cpath, &entry) );
        RemoveFile(file3.cpath);
        entry.Unset();
        dir.Unset();
        // clobber an empty directory
        NextSubTest();
        CreateFile(file3.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file3.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Rename(subDir1.cpath, true) == B_OK );
        CPPUNIT_ASSERT( PingFile(subDir1.cpath, &entry) );
        CPPUNIT_ASSERT( !PingFile(file3.cpath) );
        RemoveFile(subDir1.cpath);
        entry.Unset();
        dir.Unset();
        // abstract entry
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(file2.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Rename(file4.cname) == B_ENTRY_NOT_FOUND );
        entry.Unset();
        dir.Unset();
        // uninitialized entry
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.Rename(file4.cpath) == B_NO_INIT );
        entry.Unset();
        dir.Unset();
        // badly initialized entry
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.Rename(file4.cpath) == B_NO_INIT );
        entry.Unset();
        dir.Unset();
        // Verify attempts to rename root
        NextSubTest();
        BEntry root("/");
        CPPUNIT_ASSERT( root.Rename("/", false) == B_FILE_EXISTS );
        CPPUNIT_ASSERT( root.Rename("/", true) == B_NOT_ALLOWED );
        // Verify abstract entries
        NextSubTest();
        BEntry abstract(abstractEntry1.cpath);
        CPPUNIT_ASSERT( abstract.InitCheck() == B_OK );
        CPPUNIT_ASSERT( !abstract.Exists() );
        CPPUNIT_ASSERT( abstract.Rename("/boot/DoesntMatter") == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( abstract.Rename("/boot/DontMatter", true) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( abstract.Rename("/DoesntMatter") == B_CROSS_DEVICE_LINK );
        CPPUNIT_ASSERT( abstract.Rename("/DontMatter", true) == B_CROSS_DEVICE_LINK );
        // bad args
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(file1.cpath) == B_OK );
        CPPUNIT_ASSERT( equals(entry.Rename(NULL, false), B_FILE_EXISTS,
                                                   B_BAD_VALUE) );
        CPPUNIT_ASSERT( equals(entry.Rename(NULL, true), B_NOT_ALLOWED,
                                                   B_BAD_VALUE) );
}

// MoveToTestEntry
void
EntryTest::MoveToTestEntry(TestEntry *testEntry, TestEntry *testDir,
                                                   string newName, bool existing, bool clobber,
                                                   status_t error, uint32 kind)
{
        NextSubTest();
        BEntry entry;
        BDirectory dir;
        // get all the names
        string pathname = testEntry->path; 
        string dirname = testDir->path;
        string newPathname = dirname + "/";
        if (newName.length() == 0)
                newPathname += testEntry->name;
        else {
                // check, if the new path is absolute
                if (newName.find("/") == 0)
                        newPathname = newName;
                else
                        newPathname += newName;
        }
//printf("path: `%s', dir: `%s', new name: `%s'\n", pathname.c_str(),
//dirname.c_str(), newPathname.c_str());
        // create the entries
        switch (kind) {
                case B_FILE_NODE:
                        CreateFile(pathname.c_str());
                        break;
                case B_DIRECTORY_NODE:
                        CreateDir(pathname.c_str());
                        break;
                case B_SYMLINK_NODE:
                        CreateLink(pathname.c_str(), file1.cpath);
                        break;
        }
        if (existing)
                CreateFile(newPathname.c_str());
        // move the file
        CPPUNIT_ASSERT( entry.SetTo(pathname.c_str()) == B_OK );
        CPPUNIT_ASSERT( dir.SetTo(dirname.c_str()) == B_OK );
        if (newName.length() == 0) {
                status_t result = entry.MoveTo(&dir, NULL, clobber);
if (result != error) {
printf("`%s'.MoveTo(`%s', NULL, %d): ", pathname.c_str(), dirname.c_str(), clobber);
printf("error: %lx (%lx)\n", result, error);
}
                CPPUNIT_ASSERT( result == error );
        } else {
                status_t result = entry.MoveTo(&dir, newName.c_str(), clobber);
if (result != error) {
printf("`%s'.MoveTo(`%s', `%s', %d): ", pathname.c_str(), newName.c_str(), dirname.c_str(), clobber);
printf("error: %lx (%lx)\n", result, error);
}
                CPPUNIT_ASSERT( result == error );
        }
        // check and cleanup
        if (error == B_OK) {
                switch (kind) {
                        case B_FILE_NODE:
                                CPPUNIT_ASSERT( !PingFile(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingFile(newPathname.c_str()) );
                                break;
                        case B_DIRECTORY_NODE:
                                CPPUNIT_ASSERT( !PingDir(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingDir(newPathname.c_str()) );
                                break;
                        case B_SYMLINK_NODE:
                                CPPUNIT_ASSERT( !PingLink(pathname.c_str()) );
                                CPPUNIT_ASSERT( PingLink(newPathname.c_str(), file1.cpath) );
                                break;
                }
                RemoveFile(newPathname.c_str());
        } else {
                switch (kind) {
                        case B_FILE_NODE:
                                CPPUNIT_ASSERT( PingFile(pathname.c_str()) );
                                break;
                        case B_DIRECTORY_NODE:
                                CPPUNIT_ASSERT( PingDir(pathname.c_str()) );
                                break;
                        case B_SYMLINK_NODE:
                                CPPUNIT_ASSERT( PingLink(pathname.c_str(), file1.cpath) );
                                break;
                }
                if (existing) {
                        CPPUNIT_ASSERT( PingFile(newPathname.c_str()) );
                        RemoveFile(newPathname.c_str());
                }
                RemoveFile(pathname.c_str());
        }
}

// MoveToTestEntry
void
EntryTest::MoveToTestEntry(TestEntry *testEntry, TestEntry *testDir,
                                                   TestEntry *newTestEntry, bool existing,
                                                   bool clobber, status_t error, uint32 kind)
{
        if (newTestEntry) {
                // Here is the right place to play a little bit with the dir and path
                // arguments. At this time we only pass the leaf name and the
                // absolute path name.
                MoveToTestEntry(testEntry, testDir, newTestEntry->name, existing,
                                                clobber, error, B_FILE_NODE);
                MoveToTestEntry(testEntry, &subDir1, newTestEntry->path, existing,
                                                clobber, error, B_FILE_NODE);
        } else {
                MoveToTestEntry(testEntry, testDir, "", existing, clobber, error,
                                                B_FILE_NODE);
        }
}

// MoveToTestFile
void
EntryTest::MoveToTestFile(TestEntry *testEntry, TestEntry *testDir,
                                                  TestEntry *newTestEntry, bool existing, bool clobber,
                                                  status_t error)
{
        MoveToTestEntry(testEntry, testDir, newTestEntry, existing, clobber, error,
                                        B_FILE_NODE);
}

// MoveToTestDir
void
EntryTest::MoveToTestDir(TestEntry *testEntry, TestEntry *testDir,
                                                 TestEntry *newTestEntry, bool existing, bool clobber,
                                                 status_t error)
{
        MoveToTestEntry(testEntry, testDir, newTestEntry, existing, clobber, error,
                                        B_DIRECTORY_NODE);
}

// MoveToTestLink
void
EntryTest::MoveToTestLink(TestEntry *testEntry, TestEntry *testDir,
                                                  TestEntry *newTestEntry, bool existing, bool clobber,
                                                  status_t error)
{
        MoveToTestEntry(testEntry, testDir, newTestEntry, existing, clobber, error,
                                        B_SYMLINK_NODE);
}

// MoveToTest
void
EntryTest::MoveToTest()
{
        BDirectory dir;
        BEntry entry;
        // 1. NULL path
        // file
        // same dir
        MoveToTestFile(&file2, file2.super, NULL, false, false, B_FILE_EXISTS);
        MoveToTestFile(&file2, file2.super, NULL, false, true, B_NOT_ALLOWED);
        // different dir
        MoveToTestFile(&file2, &dir2, NULL, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestFile(&file2, &dir2, NULL, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestFile(&file2, &dir2, NULL, true, false, B_FILE_EXISTS);
        // dir
        // same dir
        MoveToTestDir(&file2, file2.super, NULL, false, false, B_FILE_EXISTS);
        MoveToTestDir(&file2, file2.super, NULL, false, true, B_NOT_ALLOWED);
        // different dir
        MoveToTestDir(&file2, &dir2, NULL, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestDir(&file2, &dir2, NULL, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestDir(&file2, &dir2, NULL, true, false, B_FILE_EXISTS);
        // link
        // same dir
        MoveToTestLink(&file2, file2.super, NULL, false, false, B_FILE_EXISTS);
        MoveToTestLink(&file2, file2.super, NULL, false, true, B_NOT_ALLOWED);
        // different dir
        MoveToTestLink(&file2, &dir2, NULL, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestLink(&file2, &dir2, NULL, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestLink(&file2, &dir2, NULL, true, false, B_FILE_EXISTS);

        // 2. non NULL path
        // file
        // same dir
        MoveToTestFile(&file2, file2.super, &file2, false, false,
                                   B_FILE_EXISTS);
        MoveToTestFile(&file2, file2.super, &file2, false, true,
                                   B_NOT_ALLOWED);
        MoveToTestFile(&file2, file2.super, &file3, false, false, B_OK);
        // different dir
        MoveToTestFile(&file2, &dir2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestFile(&file2, &dir2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestFile(&file2, &dir2, &file3, true, false, B_FILE_EXISTS);
        // dir
        // same dir
        MoveToTestDir(&file2, file2.super, &file2, false, false,
                                  B_FILE_EXISTS);
        MoveToTestDir(&file2, file2.super, &file2, false, true,
                                  B_NOT_ALLOWED);
        MoveToTestDir(&file2, file2.super, &file3, false, false, B_OK);
        // different dir
        MoveToTestDir(&file2, &dir2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestDir(&file2, &dir2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestDir(&file2, &dir2, &file3, true, false, B_FILE_EXISTS);
        // link
        // same dir
        MoveToTestLink(&file2, file2.super, &file2, false, false,
                                   B_FILE_EXISTS);
        MoveToTestLink(&file2, file2.super, &file2, false, true,
                                   B_NOT_ALLOWED);
        MoveToTestLink(&file2, file2.super, &file3, false, false, B_OK);
        // different dir
        MoveToTestLink(&file2, &dir2, &file3, false, false, B_OK);
        // different dir, existing file, clobber
        MoveToTestLink(&file2, &dir2, &file3, true, true, B_OK);
        // different dir, existing file, no clobber
        MoveToTestLink(&file2, &dir2, &file3, true, false, B_FILE_EXISTS);

        // try to clobber a non-empty directory
        CreateFile(file3.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file3.cpath) == B_OK );
        CPPUNIT_ASSERT( dir.SetTo(dir1.super->cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(&dir, dir1.cname, true)
                                        == B_DIRECTORY_NOT_EMPTY );
        CPPUNIT_ASSERT( PingDir(dir1.cpath) );
        CPPUNIT_ASSERT( PingFile(file3.cpath, &entry) );
        RemoveFile(file3.cpath);
        entry.Unset();
        dir.Unset();
        // clobber an empty directory
        CreateFile(file3.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file3.cpath) == B_OK );
        CPPUNIT_ASSERT( dir.SetTo(subDir1.super->cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(&dir, subDir1.cname, true) == B_OK );
        CPPUNIT_ASSERT( PingFile(subDir1.cpath, &entry) );
        CPPUNIT_ASSERT( !PingFile(file3.cpath) );
        RemoveFile(subDir1.cpath);
        entry.Unset();
        dir.Unset();
        // abstract entry
        CPPUNIT_ASSERT( entry.SetTo(file2.cpath) == B_OK );
        CPPUNIT_ASSERT( dir.SetTo(dir2.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(&dir) == B_ENTRY_NOT_FOUND );
        entry.Unset();
        dir.Unset();
        // uninitialized entry
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( dir.SetTo(dir2.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(&dir) == B_NO_INIT );
        entry.Unset();
        dir.Unset();
        // badly initialized entry
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( dir.SetTo(dir2.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(&dir) == B_NO_INIT );
        entry.Unset();
        dir.Unset();
        // bad args (NULL dir)
// R5: crashs
#if !TEST_R5
        CreateFile(file2.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file2.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.MoveTo(NULL, file3.cpath) == B_BAD_VALUE );
        RemoveFile(file3.cpath);
        entry.Unset();
        dir.Unset();
#endif
        // uninitialized dir, absolute path
        CreateFile(file2.cpath);
        CPPUNIT_ASSERT( entry.SetTo(file2.cpath) == B_OK );
        CPPUNIT_ASSERT( dir.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.MoveTo(&dir, file3.cpath) == B_BAD_VALUE );
        RemoveFile(file3.cpath);
        entry.Unset();
        dir.Unset();
}

// RemoveTest
void
EntryTest::RemoveTest()
{
        BEntry entry;
        // file
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(file1.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Remove() == B_OK );
        CPPUNIT_ASSERT( !PingFile(file1.cpath) );
        entry.Unset();
        // symlink
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(absFileLink1.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Remove() == B_OK );
        CPPUNIT_ASSERT( !PingLink(absFileLink1.cpath) );
        entry.Unset();
        // empty dir
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(subDir1.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Remove() == B_OK );
        CPPUNIT_ASSERT( !PingDir(subDir1.cpath) );
        entry.Unset();
        // non-empty dir
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(dir1.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Remove() == B_DIRECTORY_NOT_EMPTY );
        CPPUNIT_ASSERT( PingDir(dir1.cpath) );
        entry.Unset();
        // abstract entry
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(abstractEntry1.cpath) == B_OK );
        CPPUNIT_ASSERT( entry.Remove() == B_ENTRY_NOT_FOUND );
        entry.Unset();
        // uninitialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
        CPPUNIT_ASSERT( entry.Remove() == B_NO_INIT );
        entry.Unset();
        // badly initialized
        NextSubTest();
        CPPUNIT_ASSERT( entry.SetTo(badEntry1.cpath) == B_ENTRY_NOT_FOUND );
        CPPUNIT_ASSERT( entry.Remove() == B_NO_INIT );
        entry.Unset();
}

// compareEntries
static
void
compareEntries(const BEntry &entry, const BEntry &entry2,
                           const TestEntry *testEntry, const TestEntry *testEntry2,
                           bool traversed, bool traversed2)
{
        if (!testEntry->isBad() && !testEntry2->isBad()
                && (!traversed && testEntry->isConcrete())
                && (!traversed2 && testEntry2->isConcrete())) {
//printf("compare: `%s', `%s'\n", testEntry->cpath, testEntry2->cpath);
//printf("InitCheck(): %x, %x\n", entry.InitCheck(), entry2.InitCheck());
                CPPUNIT_ASSERT( (entry == entry2) == (testEntry == testEntry2) );
                CPPUNIT_ASSERT( (entry == entry2) == (testEntry2 == testEntry) );
                CPPUNIT_ASSERT( (entry != entry2) == (testEntry != testEntry2) );
                CPPUNIT_ASSERT( (entry != entry2) == (testEntry2 != testEntry) );
        }
}

// ComparisonTest
void
EntryTest::ComparisonTest()
{
        // uninitialized
        NextSubTest();
        {
                BEntry entry;
                BEntry entry2;
                CPPUNIT_ASSERT( entry == entry2 );
                CPPUNIT_ASSERT( entry2 == entry );
                CPPUNIT_ASSERT( !(entry != entry2) );
                CPPUNIT_ASSERT( !(entry2 != entry) );
        }
        // initialized + uninitialized
        NextSubTest();
        {
                BEntry entry(file1.cpath);
                BEntry entry2;
                CPPUNIT_ASSERT( !(entry == entry2) );
                CPPUNIT_ASSERT( !(entry2 == entry) );
                CPPUNIT_ASSERT( entry != entry2 );
                CPPUNIT_ASSERT( entry2 != entry );
        }
        {
                BEntry entry;
                BEntry entry2(file1.cpath);
                CPPUNIT_ASSERT( !(entry == entry2) );
                CPPUNIT_ASSERT( !(entry2 == entry) );
                CPPUNIT_ASSERT( entry != entry2 );
                CPPUNIT_ASSERT( entry2 != entry );
        }
        // initialized
        TestEntry *testEntries[] = {
                &dir1, &dir2, &file1, &subDir1, &abstractEntry1, &badEntry1,
                &absDirLink1, &absDirLink2, &absDirLink3, &absDirLink4,
                &relDirLink1, &relDirLink2, &relDirLink3, &relDirLink4,
                &absFileLink1, &absFileLink2, &absFileLink3, &absFileLink4,
                &relFileLink1, &relFileLink2, &relFileLink3, &relFileLink4,
                &absBadLink1, &absBadLink2, &absBadLink3, &absBadLink4,
                &relBadLink1, &relBadLink2, &relBadLink3, &relBadLink4,
                &absVeryBadLink1, &absVeryBadLink2, &absVeryBadLink3, &absVeryBadLink4,
                &relVeryBadLink1, &relVeryBadLink2, &relVeryBadLink3, &relVeryBadLink4
        };
        int32 testEntryCount = sizeof(testEntries) / sizeof(TestEntry*);
        for (int32 i = 0; i < testEntryCount; i++) {
                NextSubTest();
                TestEntry *testEntry = testEntries[i];
                TestEntry *traversedTestEntry = resolve_link(testEntry);
                BEntry entry(testEntry->cpath);
                BEntry traversedEntry(testEntry->cpath, true);
                for (int32 k = 0; k < testEntryCount; k++) {
                        TestEntry *testEntry2 = testEntries[k];
                        TestEntry *traversedTestEntry2 = resolve_link(testEntry2);
                        BEntry entry2(testEntry2->cpath);
                        BEntry traversedEntry2(testEntry2->cpath, true);
                        compareEntries(entry, entry2, testEntry, testEntry2, false, false);
                        compareEntries(traversedEntry, entry2,
                                                   traversedTestEntry, testEntry2, true, false);
                        compareEntries(entry, traversedEntry2,
                                                   testEntry, traversedTestEntry2, false, true);
                        compareEntries(traversedEntry, traversedEntry2,
                                                   traversedTestEntry, traversedTestEntry2,
                                                   true, true);
                }
        }
}

// AssignmentTest
void
EntryTest::AssignmentTest()
{
        // 1. copy constructor
        // uninitialized
        NextSubTest();
        {
                BEntry entry;
                CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
                BEntry entry2(entry);
// R5: returns B_BAD_VALUE instead of B_NO_INIT
                CPPUNIT_ASSERT( equals(entry2.InitCheck(), B_BAD_VALUE, B_NO_INIT) );
                CPPUNIT_ASSERT( entry == entry2 );
        }
        // initialized
        TestEntry *testEntries[] = {
                &dir1, &dir2, &file1, &subDir1, &abstractEntry1, &badEntry1,
                &absDirLink1, &absDirLink2, &absDirLink3, &absDirLink4,
                &relDirLink1, &relDirLink2, &relDirLink3, &relDirLink4,
                &absFileLink1, &absFileLink2, &absFileLink3, &absFileLink4,
                &relFileLink1, &relFileLink2, &relFileLink3, &relFileLink4,
                &absBadLink1, &absBadLink2, &absBadLink3, &absBadLink4,
                &relBadLink1, &relBadLink2, &relBadLink3, &relBadLink4,
                &absVeryBadLink1, &absVeryBadLink2, &absVeryBadLink3, &absVeryBadLink4,
                &relVeryBadLink1, &relVeryBadLink2, &relVeryBadLink3, &relVeryBadLink4
        };
        int32 testEntryCount = sizeof(testEntries) / sizeof(TestEntry*);
        for (int32 i = 0; i < testEntryCount; i++) {
                NextSubTest();
                TestEntry *testEntry = testEntries[i];
                BEntry entry(testEntry->cpath);
                BEntry entry2(entry);
                CPPUNIT_ASSERT( entry == entry2 );
                CPPUNIT_ASSERT( entry2 == entry );
                CPPUNIT_ASSERT( !(entry != entry2) );
                CPPUNIT_ASSERT( !(entry2 != entry) );
        }

        // 2. assignment operator
        // uninitialized
        NextSubTest();
        {
                BEntry entry;
                CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
                BEntry entry2;
                entry2 = entry;
// R5: returns B_BAD_VALUE instead of B_NO_INIT
                CPPUNIT_ASSERT( equals(entry2.InitCheck(), B_BAD_VALUE, B_NO_INIT) );
                CPPUNIT_ASSERT( entry == entry2 );
        }
        NextSubTest();
        {
                BEntry entry;
                CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
                BEntry entry2(file1.cpath);
                entry2 = entry;
// R5: returns B_BAD_VALUE instead of B_NO_INIT
                CPPUNIT_ASSERT( equals(entry2.InitCheck(), B_BAD_VALUE, B_NO_INIT) );
                CPPUNIT_ASSERT( entry == entry2 );
        }
        // initialized
        for (int32 i = 0; i < testEntryCount; i++) {
                NextSubTest();
                TestEntry *testEntry = testEntries[i];
                BEntry entry(testEntry->cpath);
                BEntry entry2;
                BEntry entry3(file1.cpath);
                entry2 = entry;
                entry3 = entry;
                CPPUNIT_ASSERT( entry == entry2 );
                CPPUNIT_ASSERT( entry2 == entry );
                CPPUNIT_ASSERT( !(entry != entry2) );
                CPPUNIT_ASSERT( !(entry2 != entry) );
                CPPUNIT_ASSERT( entry == entry3 );
                CPPUNIT_ASSERT( entry3 == entry );
                CPPUNIT_ASSERT( !(entry != entry3) );
                CPPUNIT_ASSERT( !(entry3 != entry) );
        }
}

// get_entry_ref_for_entry
static
status_t
get_entry_ref_for_entry(const char *dir, const char *leaf, entry_ref *ref)
{
        status_t error = (dir && leaf ? B_OK : B_BAD_VALUE);
        struct stat dirStat;
        if (lstat(dir, &dirStat) == 0) {
                ref->device = dirStat.st_dev;
                ref->directory = dirStat.st_ino;
                ref->set_name(leaf);
        } else
                error = errno;
        return error;
}

// entry_ref >
bool
operator>(const entry_ref & a, const entry_ref & b)
{
        return (a.device > b.device
                || (a.device == b.device
                        && (a.directory > b.directory
                        || (a.directory == b.directory
                                && (a.name != NULL && b.name == NULL
                                || (a.name != NULL && b.name != NULL
                                        && strcmp(a.name, b.name) > 0))))));
}

// CFunctionsTest
void
EntryTest::CFunctionsTest()
{
        // get_ref_for_path(), <
        TestEntry *testEntries[] = {
                &dir1, &dir2, &file1, &subDir1, &abstractEntry1, &badEntry1,
                &absDirLink1, &absDirLink2, &absDirLink3, &absDirLink4,
                &relDirLink1, &relDirLink2, &relDirLink3, &relDirLink4,
                &absFileLink1, &absFileLink2, &absFileLink3, &absFileLink4,
                &relFileLink1, &relFileLink2, &relFileLink3, &relFileLink4,
                &absBadLink1, &absBadLink2, &absBadLink3, &absBadLink4,
                &relBadLink1, &relBadLink2, &relBadLink3, &relBadLink4,
                &absVeryBadLink1, &absVeryBadLink2, &absVeryBadLink3, &absVeryBadLink4,
                &relVeryBadLink1, &relVeryBadLink2, &relVeryBadLink3, &relVeryBadLink4
        };
        int32 testEntryCount = sizeof(testEntries) / sizeof(TestEntry*);
        for (int32 i = 0; i < testEntryCount; i++) {
                NextSubTest();
                TestEntry *testEntry = testEntries[i];
                const char *path = testEntry->cpath;
                entry_ref ref;
                if (testEntry->isBad())
                        CPPUNIT_ASSERT( get_ref_for_path(path, &ref) == B_ENTRY_NOT_FOUND );
                else {
                        CPPUNIT_ASSERT( get_ref_for_path(path, &ref) == B_OK );
                        const entry_ref &testEntryRef = testEntry->get_ref();
                        CPPUNIT_ASSERT( testEntryRef.device == ref.device );
                        CPPUNIT_ASSERT( testEntryRef.directory == ref.directory );
                        CPPUNIT_ASSERT( strcmp(testEntryRef.name, ref.name) == 0 );
                        CPPUNIT_ASSERT( testEntryRef == ref );
                        CPPUNIT_ASSERT( !(testEntryRef != ref) );
                        CPPUNIT_ASSERT(  ref == testEntryRef );
                        CPPUNIT_ASSERT(  !(ref != testEntryRef) );
                        for (int32 k = 0; k < testEntryCount; k++) {
                                TestEntry *testEntry2 = testEntries[k];
                                const char *path2 = testEntry2->cpath;
                                entry_ref ref2;
                                if (!testEntry2->isBad()) {
                                        CPPUNIT_ASSERT( get_ref_for_path(path2, &ref2) == B_OK );
                                        int cmp = 0;
                                        if (ref > ref2)
                                                cmp = 1;
                                        else if (ref2 > ref)
                                                cmp = -1;
                                        CPPUNIT_ASSERT(  (ref == ref2) == (cmp == 0) );
                                        CPPUNIT_ASSERT(  (ref2 == ref) == (cmp == 0) );
                                        CPPUNIT_ASSERT(  (ref != ref2) == (cmp != 0) );
                                        CPPUNIT_ASSERT(  (ref2 != ref) == (cmp != 0) );
                                        CPPUNIT_ASSERT(  (ref < ref2) == (cmp < 0) );
                                        CPPUNIT_ASSERT(  (ref2 < ref) == (cmp > 0) );
                                }
                        }
                }
        }
        // root dir
        NextSubTest();
        entry_ref ref, ref2;
        CPPUNIT_ASSERT( get_ref_for_path("/", &ref) == B_OK );
        CPPUNIT_ASSERT( get_entry_ref_for_entry("/", ".", &ref2) == B_OK );
        CPPUNIT_ASSERT( ref.device == ref2.device );
        CPPUNIT_ASSERT( ref.directory == ref2.directory );
        CPPUNIT_ASSERT( strcmp(ref.name, ref2.name) == 0 );
        CPPUNIT_ASSERT(  ref == ref2 );
        // fs root dir
        NextSubTest();
        CPPUNIT_ASSERT( get_ref_for_path("/boot", &ref) == B_OK );
        CPPUNIT_ASSERT( get_entry_ref_for_entry("/", "boot", &ref2) == B_OK );
        CPPUNIT_ASSERT( ref.device == ref2.device );
        CPPUNIT_ASSERT( ref.directory == ref2.directory );
        CPPUNIT_ASSERT( strcmp(ref.name, ref2.name) == 0 );
        CPPUNIT_ASSERT(  ref == ref2 );
        // uninitialized
        NextSubTest();
        ref = entry_ref();
        ref2 = entry_ref();
        CPPUNIT_ASSERT(  ref == ref2 );
        CPPUNIT_ASSERT(  !(ref != ref2) );
        CPPUNIT_ASSERT(  !(ref < ref2) );
        CPPUNIT_ASSERT(  !(ref2 < ref) );
        CPPUNIT_ASSERT( get_entry_ref_for_entry("/", ".", &ref2) == B_OK );
        CPPUNIT_ASSERT(  !(ref == ref2) );
        CPPUNIT_ASSERT(  ref != ref2 );
        CPPUNIT_ASSERT(  ref < ref2 );
        CPPUNIT_ASSERT(  !(ref2 < ref) );
}


// isHarmlessPathname
bool
isHarmlessPathname(const char *path)
{
        bool result = false;
        if (path) {
                const char *harmlessDir = "/tmp/";
                result = (string(path).find(harmlessDir) == 0);
        }
if (!result)
printf("WARNING: `%s' is not a harmless pathname.\n", path);
        return result;
}

// CreateLink
void
EntryTest::CreateLink(const char *link, const char *target)
{
        if (link && target && isHarmlessPathname(link)) {
                execCommand(string("rm -rf ") + link
                                        + " ; ln -s " + target + " " + link);
        }
}
        
// CreateFile
void
EntryTest::CreateFile(const char *file)
{
        if (file && isHarmlessPathname(file))
                execCommand(string("rm -rf ") + file + " ; touch " + file);
}
                        
// CreateDir
void
EntryTest::CreateDir(const char *dir)
{
        if (dir  && isHarmlessPathname(dir))
                execCommand(string("rm -rf ") + dir + " ; mkdir " + dir);
}
                        
// RemoveFile
void
EntryTest::RemoveFile(const char *file)
{
        if (file && isHarmlessPathname(file))
                execCommand(string("rm -rf ") + file);
}

// PingFile
bool
EntryTest::PingFile(const char *path, BEntry *entry)
{
        bool result = false;
        // check existence and type
        struct stat st;
        if (lstat(path, &st) == 0)
                result = (S_ISREG(st.st_mode));
        // check entry
        if (result && entry) {
                BPath entryPath;
                result = (entry->GetPath(&entryPath) == B_OK && entryPath == path);
        }
        return result;
}

// PingDir
bool
EntryTest::PingDir(const char *path, BEntry *entry)
{
        bool result = false;
        // check existence and type
        struct stat st;
        if (lstat(path, &st) == 0)
                result = (S_ISDIR(st.st_mode));
        // check entry
        if (result && entry) {
                BPath entryPath;
                result = (entry->GetPath(&entryPath) == B_OK && entryPath == path);
        }
        return result;
}

// PingLink
bool
EntryTest::PingLink(const char *path, const char *target, BEntry *entry)
{
        bool result = false;
        // check existence and type
        struct stat st;
        if (lstat(path, &st) == 0)
                result = (S_ISLNK(st.st_mode));
        // check target
        if (result && target) {
                char linkTarget[B_PATH_NAME_LENGTH + 1];
                ssize_t size = readlink(path, linkTarget, B_PATH_NAME_LENGTH);
                result = (size >= 0);
                if (result) {
                        linkTarget[size] = 0;
                        result = (string(linkTarget) == target);
                }
        }
        // check entry
        if (result && entry) {
                BPath entryPath;
                result = (entry->GetPath(&entryPath) == B_OK && entryPath == path);
        }
        return result;
}

// MiscTest
void
EntryTest::MiscTest()
{
        BNode node(file1.cpath);
        BEntry entry(file1.cpath);
                
        CPPUNIT_ASSERT(node.Lock() == B_OK);
        CPPUNIT_ASSERT( entry.Exists() );
}
        


// directory name for too long path name (70 characters)
static const char *tooLongDirname =
        "1234567890123456789012345678901234567890123456789012345678901234567890";

// too long entry name (257 characters)
static const char *tooLongEntryname = 
        "1234567890123456789012345678901234567890123456789012345678901234567890"
        "1234567890123456789012345678901234567890123456789012345678901234567890"
        "1234567890123456789012345678901234567890123456789012345678901234567890"
        "12345678901234567890123456789012345678901234567";


static void
init_entry_test()
{
        // root dir for testing
        testDir.initDir(badTestEntry, "testDir");
        testDir.initPath((string("/tmp/") + testDir.name).c_str());
        allTestEntries.pop_back();
        // other entries
        dir1.initDir(testDir, "dir1");
        dir2.initDir(testDir, "dir2");
        file1.initFile(dir1, "file1");
        file2.init(dir1, "file2", ABSTRACT_ENTRY);
        file3.init(dir2, "file3", ABSTRACT_ENTRY);
        file4.init(dir1, "file4", ABSTRACT_ENTRY);
        subDir1.initDir(dir1, "subDir1");
        abstractEntry1.init(dir1, "abstractEntry1", ABSTRACT_ENTRY);
        badEntry1.init(abstractEntry1, "badEntry1", BAD_ENTRY);
        absDirLink1.initALink(dir1, "absDirLink1", subDir1);
        absDirLink2.initALink(dir1, "absDirLink2", absDirLink1);
        absDirLink3.initALink(dir2, "absDirLink3", absDirLink2);
        absDirLink4.initALink(testDir, "absDirLink4", absDirLink3);
        relDirLink1.initRLink(dir1, "relDirLink1", subDir1);
        relDirLink2.initRLink(dir1, "relDirLink2", relDirLink1);
        relDirLink3.initRLink(dir2, "relDirLink3", relDirLink2);
        relDirLink4.initRLink(testDir, "relDirLink4", relDirLink3);
        absFileLink1.initALink(dir1, "absFileLink1", file1);
        absFileLink2.initALink(dir1, "absFileLink2", absFileLink1);
        absFileLink3.initALink(dir2, "absFileLink3", absFileLink2);
        absFileLink4.initALink(testDir, "absFileLink4", absFileLink3);
        relFileLink1.initRLink(dir1, "relFileLink1", file1);
        relFileLink2.initRLink(dir1, "relFileLink2", relFileLink1);
        relFileLink3.initRLink(dir2, "relFileLink3", relFileLink2);
        relFileLink4.initRLink(testDir, "relFileLink4", relFileLink3);
        absCyclicLink1.initALink(dir1, "absCyclicLink1", absCyclicLink2);
        absCyclicLink2.initALink(dir1, "absCyclicLink2", absCyclicLink1);
        relCyclicLink1.initRLink(dir1, "relCyclicLink1", relCyclicLink2);
        relCyclicLink2.initRLink(dir1, "relCyclicLink2", relCyclicLink1);
        absBadLink1.initALink(dir1, "absBadLink1", abstractEntry1);
        absBadLink2.initALink(dir1, "absBadLink2", absBadLink1);
        absBadLink3.initALink(dir2, "absBadLink3", absBadLink2);
        absBadLink4.initALink(testDir, "absBadLink4", absBadLink3);
        relBadLink1.initRLink(dir1, "relBadLink1", abstractEntry1);
        relBadLink2.initRLink(dir1, "relBadLink2", relBadLink1);
        relBadLink3.initRLink(dir2, "relBadLink3", relBadLink2);
        relBadLink4.initRLink(testDir, "relBadLink4", relBadLink3);
        absVeryBadLink1.initALink(dir1, "absVeryBadLink1", badEntry1);
        absVeryBadLink2.initALink(dir1, "absVeryBadLink2", absVeryBadLink1);
        absVeryBadLink3.initALink(dir2, "absVeryBadLink3", absVeryBadLink2);
        absVeryBadLink4.initALink(testDir, "absVeryBadLink4", absVeryBadLink3);
        relVeryBadLink1.initRLink(dir1, "relVeryBadLink1", badEntry1);
        relVeryBadLink2.initRLink(dir1, "relVeryBadLink2", relVeryBadLink1);
        relVeryBadLink3.initRLink(dir2, "relVeryBadLink3", relVeryBadLink2);
        relVeryBadLink4.initRLink(testDir, "relVeryBadLink4", relVeryBadLink3);
        tooLongEntry1.init(testDir, tooLongEntryname, ABSTRACT_ENTRY);
        tooLongDir1.initDir(testDir, tooLongDirname);
        tooLongDir2.initDir(tooLongDir1, tooLongDirname);
        tooLongDir3.initDir(tooLongDir2, tooLongDirname);
        tooLongDir4.initDir(tooLongDir3, tooLongDirname);
        tooLongDir5.initDir(tooLongDir4, tooLongDirname);
        tooLongDir6.initDir(tooLongDir5, tooLongDirname);
        tooLongDir7.initDir(tooLongDir6, tooLongDirname);
        tooLongDir8.initDir(tooLongDir7, tooLongDirname);
        tooLongDir9.initDir(tooLongDir8, tooLongDirname);
        tooLongDir10.initDir(tooLongDir9, tooLongDirname);
        tooLongDir11.initDir(tooLongDir10, tooLongDirname);
        tooLongDir12.initDir(tooLongDir11, tooLongDirname);
        tooLongDir13.initDir(tooLongDir12, tooLongDirname);
        tooLongDir14.initDir(tooLongDir13, tooLongDirname);
        tooLongDir15.initDir(tooLongDir14, tooLongDirname);
        tooLongDir16.initDir(tooLongDir15, tooLongDirname);

        // init paths
        for (list<TestEntry*>::iterator it = allTestEntries.begin();
                 it != allTestEntries.end(); it++) {
                (*it)->initPath();
        }
        // complete initialization
        testDir.completeInit();
        for (list<TestEntry*>::iterator it = allTestEntries.begin();
                 it != allTestEntries.end(); it++) {
                (*it)->completeInit();
        }
        // create the set up command line
        setUpCommandLine = string("mkdir ") + testDir.path;
        for (list<TestEntry*>::iterator it = allTestEntries.begin();
                 it != allTestEntries.end(); it++) {
                TestEntry *entry = *it;
                string command;
                switch (entry->kind) {
                        case ABSTRACT_ENTRY:
                                break;
                        case DIR_ENTRY:
                        {
                                if (entry->path.length() < B_PATH_NAME_LENGTH) {
                                        command = string("mkdir ") + entry->path;
                                } else {
                                        command = string("( ")
                                                + "cd " + entry->super->super->path + " ; "
                                                + " mkdir " + entry->super->name + "/" + entry->name
                                                + " )";
                                }
                                break;
                        }
                        case FILE_ENTRY:
                        {
                                command = string("touch ") + entry->path;
                                break;
                        }
                        case LINK_ENTRY:
                        {
                                command = string("ln -s ") + entry->link + " " + entry->path;
                                break;
                        }
                        default:
                                break;
                }
                if (command.length() > 0) {
                        if (setUpCommandLine.length() == 0)
                                setUpCommandLine = command;
                        else
                                setUpCommandLine += string(" ; ") + command;
                }
        }
        // create the tear down command line
        tearDownCommandLine = string("rm -rf ") + testDir.path;
}

struct InitEntryTest {
        InitEntryTest()
        {
                init_entry_test();
        }
} _InitEntryTest;


// TestEntry

// constructor
TestEntry::TestEntry()
                 : super(&badTestEntry),
                   name("badTestEntry"),
                   kind(BAD_ENTRY),
                   path("/tmp/badTestEntry"),
                   target(&badTestEntry),
                   link(),
                   ref(),
                   relative(true),
                   cname(""),
                   cpath(""),
                   clink("")
{
}

// init
void
TestEntry::init(TestEntry &super, string name, test_entry_kind kind,
                                bool relative)
{
        this->super             = &super;
        this->name              = name;
        this->kind              = kind;
        this->relative  = relative;
        allTestEntries.push_back(this);
}

// initDir
void
TestEntry::initDir(TestEntry &super, string name)
{
        init(super, name, DIR_ENTRY);
}

// initFile
void
TestEntry::initFile(TestEntry &super, string name)
{
        init(super, name, FILE_ENTRY);
}

// initRLink
void
TestEntry::initRLink(TestEntry &super, string name, TestEntry &target)
{
        init(super, name, LINK_ENTRY, true);
        this->target = &target;
}

// initALink
void
TestEntry::initALink(TestEntry &super, string name, TestEntry &target)
{
        init(super, name, LINK_ENTRY, false);
        this->target = &target;
}

// initPath
void
TestEntry::initPath(const char *pathName)
{
        if (pathName)
                path = pathName;
        else
                path = super->path + "/" + name;
}

// completeInit
void
TestEntry::completeInit()
{
        // init link
        if (kind == LINK_ENTRY) {
                if (relative)
                        link = get_shortest_relative_path(super, target);
                else
                        link = target->path;
        }
        // init the C strings
        cname = name.c_str();
        cpath = path.c_str();
        clink = link.c_str();
}

// get_ref
const entry_ref &
TestEntry::get_ref()
{
        if (isConcrete() || isAbstract())
                get_entry_ref_for_entry(super->cpath, cname, &ref);
        return ref;
}

// get_shortest_relative_path
static
string
get_shortest_relative_path(TestEntry *dir, TestEntry *entry)
{
        string relPath;
        // put all super directories (including dir itself) of the dir in a set
        map<TestEntry*, int> superDirs;
        int dirSuperLevel = 0;
        for (TestEntry *superDir = dir;
                 superDir != &badTestEntry;
                 superDir = superDir->super, dirSuperLevel++) {
                superDirs[superDir] = dirSuperLevel;
        }
        // find the first super dir that dir and entry have in common
        TestEntry *commonSuperDir = &badTestEntry;
        int targetSuperLevel = 0;
        for (TestEntry *superDir = entry;
                 commonSuperDir == &badTestEntry
                 && superDir != &badTestEntry;
                 superDir = superDir->super, targetSuperLevel++) {
                if (superDirs.find(superDir) != superDirs.end())
                        commonSuperDir = superDir;
        }
        // construct the relative path
        if (commonSuperDir != &badTestEntry) {
                dirSuperLevel = superDirs[commonSuperDir];
                if (dirSuperLevel == 0 && targetSuperLevel == 0) {
                        // entry == dir
                        relPath == ".";
                } else {
                        // levels down
                        for (TestEntry *superDir = entry;
                                 superDir != commonSuperDir;
                                 superDir = superDir->super) {
                                if (relPath.length() == 0)
                                        relPath = superDir->name;
                                else
                                        relPath = superDir->name + "/" + relPath;
                        }
                        // levels up
                        for (int i = dirSuperLevel; i > 0; i--) {
                                if (relPath.length() == 0)
                                        relPath = "..";
                                else
                                        relPath = string("../") + relPath;
                        }
                }
        }
        return relPath;
}

// resolve_link
static
TestEntry *
resolve_link(TestEntry *entry)
{
        set<TestEntry*> followedLinks;
        while (entry != &badTestEntry && entry->kind == LINK_ENTRY) {
                if (followedLinks.find(entry) == followedLinks.end()) {
                        followedLinks.insert(entry);
                        entry = entry->target;
                } else
                        entry = &badTestEntry;  // cyclic link
        }
        return entry;
}