haiku.git

// PathTest.cpp
#include "PathTest.h"

#include <cppunit/Test.h>
#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>
#include <Directory.h>
#include <Entry.h>
#include <Path.h>
#include <TypeConstants.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <string>
using std::string;


// Suite
CppUnit::Test*
PathTest::Suite() {
	CppUnit::TestSuite *suite = new CppUnit::TestSuite();
	typedef CppUnit::TestCaller<PathTest> TC;
		
	suite->addTest( new TC("BPath::Init Test1", &PathTest::InitTest1) );
	suite->addTest( new TC("BPath::Init Test2", &PathTest::InitTest2) );
	suite->addTest( new TC("BPath::Append Test", &PathTest::AppendTest) );
	suite->addTest( new TC("BPath::Leaf Test", &PathTest::LeafTest) );
	suite->addTest( new TC("BPath::Parent Test", &PathTest::ParentTest) );
	suite->addTest( new TC("BPath::Comparison Test",
						   &PathTest::ComparisonTest) );
	suite->addTest( new TC("BPath::Assignment Test",
						   &PathTest::AssignmentTest) );
	suite->addTest( new TC("BPath::Flattenable Test",
						   &PathTest::FlattenableTest) );
		
	return suite;
}		

// setUp
void
PathTest::setUp()
{
	BasicTest::setUp();
}
	
// tearDown
void
PathTest::tearDown()
{
	BasicTest::tearDown();
}

// InitTest1
void
PathTest::InitTest1()
{
	// 1. default constructor
	NextSubTest();
	{
		BPath path;
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}

	// 2. BPath(const char*, const char*, bool)
	// absolute existing path (root dir), no leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// absolute existing path, no leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// absolute non-existing path, no leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist/but/who/cares";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// absolute existing path (root dir), no leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/.///.";
		const char *normalizedPathName = "/";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	}
	// absolute existing path, no leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/boot/";
		const char *normalizedPathName = "/boot";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	}
	// absolute non-existing path, no leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist/but///who/cares";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// absolute existing path (root dir), no leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/";
		BPath path(pathName, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// absolute existing path, no leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/boot";
		BPath path(pathName, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// absolute non-existing path, no leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist/but/who/cares";
		BPath path(pathName, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// relative existing path, no leaf, no normalization needed, but done
	chdir("/");
	NextSubTest();
	{
		const char *pathName = "boot";
		const char *absolutePathName = "/boot";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// relative non-existing path, no leaf, no normalization needed, but done
	chdir("/boot");
	NextSubTest();
	{
		const char *pathName = "doesn't/exist/but/who/cares";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// relative existing path, no leaf, auto normalization
	chdir("/");
	NextSubTest();
	{
		const char *pathName = "boot/";
		const char *normalizedPathName = "/boot";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	}
	// relative non-existing path, no leaf, auto normalization
	chdir("/boot");
	NextSubTest();
	{
		const char *pathName = "doesn't/exist/but///who/cares";
		BPath path(pathName);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// relative existing path, no leaf, normalization forced
	chdir("/");
	NextSubTest();
	{
		const char *pathName = "boot";
		const char *absolutePathName = "/boot";
		BPath path(pathName, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// relative non-existing path, no leaf, normalization forced
	chdir("/boot");
	NextSubTest();
	{
		const char *pathName = "doesn't/exist/but/who/cares";
		BPath path(pathName, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// absolute existing path (root dir), leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/";
		const char *leafName = "boot";
		const char *absolutePathName = "/boot";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// absolute existing path, leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		const char *leafName = "home/Desktop";
		const char *absolutePathName = "/boot/home/Desktop";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// absolute non-existing path, leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist";
		const char *leafName = "but/who/cares";
		const char *absolutePathName = "/doesn't/exist/but/who/cares";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// absolute existing path (root dir), leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/.///";
		const char *leafName = ".";
		const char *absolutePathName = "/";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// absolute existing path, leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		const char *leafName = "home/..";
		const char *absolutePathName = "/boot";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// absolute non-existing path, leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist";
		const char *leafName = "but//who/cares";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// absolute non-existing path, leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/doesn't/exist";
		const char *leafName = "but/who/cares";
		BPath path(pathName, leafName, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// relative existing path, leaf, no normalization needed, but done
	chdir("/");
	NextSubTest();
	{
		const char *pathName = "boot";
		const char *leafName = "home";
		const char *absolutePathName = "/boot/home";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// relative non-existing path, leaf, no normalization needed, but done
	chdir("/boot");
	NextSubTest();
	{
		const char *pathName = "doesn't/exist";
		const char *leafName = "but/who/cares";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// relative existing path, leaf, auto normalization
	chdir("/boot");
	NextSubTest();
	{
		const char *pathName = "home";
		const char *leafName = "Desktop//";
		const char *normalizedPathName = "/boot/home/Desktop";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	}
	// bad args (absolute lead)
	NextSubTest();
	{
		const char *pathName = "/";
		const char *leafName = "/boot";
		BPath path(pathName, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args
	NextSubTest();
	{
		BPath path((const char*)NULL, "test");
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args
	NextSubTest();
	{
		BPath path((const char*)NULL);
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}

	// 3. BPath(const BDirectory*, const char*, bool)
	// existing dir (root dir), no leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/";
		BDirectory dir(pathName);
		BPath path(&dir, NULL);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing dir, no leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		BDirectory dir(pathName);
		BPath path(&dir, NULL);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing dir (root dir), no leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/";
		BDirectory dir(pathName);
		BPath path(&dir, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing dir, no leaf, normalization forced
	NextSubTest();
	{
		const char *pathName = "/boot";
		BDirectory dir(pathName);
		BPath path(&dir, NULL, true);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing dir (root dir), leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/";
		const char *leafName = "boot";
		const char *absolutePathName = "/boot";
		BDirectory dir(pathName);
		BPath path(&dir, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// existing dir, leaf, no normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		const char *leafName = "home/Desktop";
		const char *absolutePathName = "/boot/home/Desktop";
		BDirectory dir(pathName);
		BPath path(&dir, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// existing dir, leaf, auto normalization
	NextSubTest();
	{
		const char *pathName = "/boot";
		const char *leafName = "home/..";
		const char *absolutePathName = "/boot";
		BDirectory dir(pathName);
		BPath path(&dir, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	}
	// bad args (absolute leaf)
	NextSubTest();
	{
		const char *pathName = "/";
		const char *leafName = "/boot";
		BDirectory dir(pathName);
		BPath path(&dir, leafName);
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (uninitialized dir)
	NextSubTest();
	{
		BDirectory dir;
		BPath path(&dir, "test");
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (badly initialized dir)
	NextSubTest();
	{
		BDirectory dir("/this/dir/doesn't/exists");
		BPath path(&dir, "test");
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (NULL dir)
// R5: crashs, when passing a NULL BDirectory
#if !TEST_R5
	NextSubTest();
	{
		BPath path((const BDirectory*)NULL, "test");
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (NULL dir)
	NextSubTest();
	{
		BPath path((const BDirectory*)NULL, NULL);
		CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
#endif

	// 4. BPath(const BEntry*)
	// existing entry (root dir)
	NextSubTest();
	{
		const char *pathName = "/";
		BEntry entry(pathName);
		BPath path(&entry);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing entry
	NextSubTest();
	{
		const char *pathName = "/boot";
		BEntry entry(pathName);
		BPath path(&entry);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// abstract entry
	NextSubTest();
	{
		const char *pathName = "/boot/shouldn't exist";
		BEntry entry(pathName);
		BPath path(&entry);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// bad args (uninitialized BEntry)
	NextSubTest();
	{
		BEntry entry;
		BPath path(&entry);
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (badly initialized BEntry)
	NextSubTest();
	{
		BEntry entry("/this/doesn't/exist");
		BPath path(&entry);
		CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_ENTRY_NOT_FOUND) );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
	// bad args (NULL BEntry)
	NextSubTest();
	{
		BPath path((const BEntry*)NULL);
		CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_BAD_VALUE) );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}

	// 5. BPath(const entry_ref*)
	// existing entry (root dir)
	NextSubTest();
	{
		const char *pathName = "/";
		BEntry entry(pathName);
		entry_ref ref;
		CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
		BPath path(&ref);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// existing entry
	NextSubTest();
	{
		const char *pathName = "/boot";
		BEntry entry(pathName);
		entry_ref ref;
		CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
		BPath path(&ref);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// abstract entry
	NextSubTest();
	{
		const char *pathName = "/boot/shouldn't exist";
		BEntry entry(pathName);
		entry_ref ref;
		CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
		BPath path(&ref);
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		CPPUNIT_ASSERT( string(pathName) == path.Path() );
	}
	// bad args (NULL entry_ref)
	NextSubTest();
	{
		BPath path((const entry_ref*)NULL);
		CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_BAD_VALUE) );
		CPPUNIT_ASSERT( path.Path() == NULL );
	}
}

// InitTest2
void
PathTest::InitTest2()
{
	BPath path;
	const char *pathName;
	const char *leafName;
	const char *absolutePathName;
	const char *normalizedPathName;
	BDirectory dir;
	BEntry entry;
	entry_ref ref;

	// 2. SetTo(const char*, const char*, bool)
	// absolute existing path (root dir), no leaf, no normalization
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	// absolute existing path, no leaf, no normalization
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	// absolute non-existing path, no leaf, no normalization
	NextSubTest();
	pathName = "/doesn't/exist/but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	// absolute existing path (root dir), no leaf, auto normalization
	NextSubTest();
	pathName = "/.///.";
	normalizedPathName = "/";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	path.Unset();
	// absolute existing path, no leaf, auto normalization
	NextSubTest();
	pathName = "/boot/";
	normalizedPathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	path.Unset();
	// absolute non-existing path, no leaf, auto normalization
	NextSubTest();
	pathName = "/doesn't/exist/but///who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// absolute existing path (root dir), no leaf, normalization forced
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( path.SetTo(pathName, NULL, true) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	// absolute existing path, no leaf, normalization forced
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName, NULL, true) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	// absolute non-existing path, no leaf, normalization forced
	NextSubTest();
	pathName = "/doesn't/exist/but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, NULL, true) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// relative existing path, no leaf, no normalization needed, but done
	chdir("/");
	NextSubTest();
	pathName = "boot";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// relative non-existing path, no leaf, no normalization needed, but done
	chdir("/boot");
	NextSubTest();
	pathName = "doesn't/exist/but/who/cares";
	absolutePathName = "/boot/doesn't/exist/but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// relative existing path, no leaf, auto normalization
	chdir("/");
	NextSubTest();
	pathName = "boot/";
	normalizedPathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	path.Unset();
	// relative non-existing path, no leaf, auto normalization
	chdir("/boot");
	NextSubTest();
	pathName = "doesn't/exist/but///who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// relative existing path, no leaf, normalization forced
	chdir("/");
	NextSubTest();
	pathName = "boot";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName, NULL, true) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// relative non-existing path, no leaf, normalization forced
	chdir("/boot");
	NextSubTest();
	pathName = "doesn't/exist/but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, NULL, true) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// absolute existing path (root dir), leaf, no normalization
	NextSubTest();
	pathName = "/";
	leafName = "boot";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute existing path, leaf, no normalization
	NextSubTest();
	pathName = "/boot";
	leafName = "home/Desktop";
	absolutePathName = "/boot/home/Desktop";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute non-existing path, leaf, no normalization
	NextSubTest();
	pathName = "/doesn't/exist";
	leafName = "but/who/cares";
	absolutePathName = "/doesn't/exist/but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute existing path (root dir), leaf, auto normalization
	NextSubTest();
	pathName = "/.///";
	leafName = ".";
	absolutePathName = "/";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute existing path, leaf, auto normalization
	NextSubTest();
	pathName = "/boot";
	leafName = "home/..";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute existing path, leaf, self assignment
	NextSubTest();
	pathName = "/boot/home";
	leafName = "home/Desktop";
	absolutePathName = "/boot/home/Desktop";
	CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(path.Path(), ".///./") == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	CPPUNIT_ASSERT( path.SetTo(path.Path(), "..") == B_OK );
	CPPUNIT_ASSERT( string("/boot") == path.Path() );
	CPPUNIT_ASSERT( path.SetTo(path.Path(), leafName) == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// absolute non-existing path, leaf, auto normalization
	NextSubTest();
	pathName = "/doesn't/exist";
	leafName = "but//who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// absolute non-existing path, leaf, normalization forced
	NextSubTest();
	pathName = "/doesn't/exist";
	leafName = "but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName, true) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// relative existing path, leaf, no normalization needed, but done
	chdir("/");
	NextSubTest();
	pathName = "boot";
	leafName = "home";
	absolutePathName = "/boot/home";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	// relative non-existing path, leaf, no normalization needed, but done
	chdir("/boot");
	NextSubTest();
	pathName = "doesn't/exist";
	leafName = "but/who/cares";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// relative existing path, leaf, auto normalization
	chdir("/boot");
	NextSubTest();
	pathName = "home";
	leafName = "Desktop//";
	normalizedPathName = "/boot/home/Desktop";
	CPPUNIT_ASSERT( path.SetTo(pathName, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(normalizedPathName) == path.Path() );
	path.Unset();
	// bad args (absolute leaf)
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/", "/boot") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// bad args
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo((const char*)NULL, "test") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// bad args
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo((const char*)NULL) == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();

	// 3. SetTo(const BDirectory*, const char*, bool)
	// existing dir (root dir), no leaf, no normalization
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, NULL) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir, no leaf, no normalization
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, NULL) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir (root dir), no leaf, normalization forced
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, NULL, true) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir, no leaf, normalization forced
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, NULL, true) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir (root dir), leaf, no normalization
	NextSubTest();
	pathName = "/";
	leafName = "boot";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir, leaf, no normalization
	NextSubTest();
	pathName = "/boot";
	leafName = "home/Desktop";
	absolutePathName = "/boot/home/Desktop";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// existing dir, leaf, auto normalization
	NextSubTest();
	pathName = "/boot";
	leafName = "home/..";
	absolutePathName = "/boot";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, leafName) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(absolutePathName) == path.Path() );
	path.Unset();
	dir.Unset();
	// bad args (absolute leaf)
	NextSubTest();
	pathName = "/";
	leafName = "/boot";
	CPPUNIT_ASSERT( dir.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&dir, leafName) == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	dir.Unset();
	// bad args (uninitialized dir)
	NextSubTest();
	CPPUNIT_ASSERT( dir.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.SetTo(&dir, "test") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	dir.Unset();
	// bad args (badly initialized dir)
	NextSubTest();
	CPPUNIT_ASSERT( dir.SetTo("/this/dir/doesn't/exists") == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.SetTo(&dir, "test") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	dir.Unset();
// R5: crashs, when passing a NULL BDirectory
#if !TEST_R5
	// bad args (NULL dir)
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo((const BDirectory*)NULL, "test") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	dir.Unset();
	// bad args (NULL dir)
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo((const BDirectory*)NULL, NULL) == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	dir.Unset();
#endif

	// 4. SetTo(const BEntry*)
	// existing entry (root dir)
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&entry) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// existing entry
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&entry) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// abstract entry
	NextSubTest();
	pathName = "/boot/shouldn't exist";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&entry) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// bad args (uninitialized BEntry)
	NextSubTest();
	CPPUNIT_ASSERT( entry.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.SetTo(&entry) == B_NO_INIT );
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	entry.Unset();
	// bad args (badly initialized BEntry)
	NextSubTest();
	CPPUNIT_ASSERT( entry.SetTo("/this/doesn't/exist") == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( equals(path.SetTo(&entry), B_NO_INIT, B_ENTRY_NOT_FOUND) );
	CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_ENTRY_NOT_FOUND) );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	entry.Unset();
	// bad args (NULL BEntry)
	NextSubTest();
	CPPUNIT_ASSERT( equals(path.SetTo((const BEntry*)NULL), B_NO_INIT,
									  B_BAD_VALUE) );
	CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_BAD_VALUE) );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	entry.Unset();

	// 5. SetTo(const entry_ref*)
	// existing entry (root dir)
	NextSubTest();
	pathName = "/";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&ref) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// existing entry
	NextSubTest();
	pathName = "/boot";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&ref) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// abstract entry
	NextSubTest();
	pathName = "/boot/shouldn't exist";
	CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
	CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
	CPPUNIT_ASSERT( path.SetTo(&ref) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_OK );
	CPPUNIT_ASSERT( string(pathName) == path.Path() );
	path.Unset();
	entry.Unset();
	// bad args (NULL entry_ref)
	NextSubTest();
	CPPUNIT_ASSERT( equals(path.SetTo((const entry_ref*)NULL), B_NO_INIT,
						   B_BAD_VALUE) );
	CPPUNIT_ASSERT( equals(path.InitCheck(), B_NO_INIT, B_BAD_VALUE) );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	entry.Unset();
}

// AppendTest
void
PathTest::AppendTest()
{
	BPath path;
	// uninitialized BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.Append("test") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// dir hierarchy, from existing to non-existing
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/") == B_OK );
	CPPUNIT_ASSERT( string("/") == path.Path() );
	CPPUNIT_ASSERT( path.Append("boot") == B_OK );
	CPPUNIT_ASSERT( string("/boot") == path.Path() );
	CPPUNIT_ASSERT( path.Append("home/Desktop") == B_OK );
	CPPUNIT_ASSERT( string("/boot/home/Desktop") == path.Path() );
	CPPUNIT_ASSERT( path.Append("non/existing") == B_OK );
	CPPUNIT_ASSERT( string("/boot/home/Desktop/non/existing") == path.Path() );
	// trigger normalization
	CPPUNIT_ASSERT( path.Append("at/least/not//now") == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// force normalization
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( string("/boot") == path.Path() );
	CPPUNIT_ASSERT( path.Append("home/non-existing", true) == B_OK );
	CPPUNIT_ASSERT( string("/boot/home/non-existing") == path.Path() );
	CPPUNIT_ASSERT( path.Append("not/now", true) == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.InitCheck() == B_ENTRY_NOT_FOUND );
	CPPUNIT_ASSERT( path.Path() == NULL );
	path.Unset();
	// bad/strange args
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( path.Append(NULL) == B_OK );
	CPPUNIT_ASSERT( string("/boot") == path.Path() );
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( path.Append("/tmp") == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.InitCheck() == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( path.Append("") == B_OK );
	CPPUNIT_ASSERT( string("/boot") == path.Path() );
	path.Unset();
}

// LeafTest
void
PathTest::LeafTest()
{
	BPath path;
	// uninitialized BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.Leaf() == NULL );
	path.Unset();
	// root dir
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/") == B_OK );
	CPPUNIT_ASSERT( string("") == path.Leaf() );
	path.Unset();
	// existing dirs
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( string("boot") == path.Leaf() );
	CPPUNIT_ASSERT( path.SetTo("/boot/home") == B_OK );
	CPPUNIT_ASSERT( string("home") == path.Leaf() );
	CPPUNIT_ASSERT( path.SetTo("/boot/home/Desktop") == B_OK );
	CPPUNIT_ASSERT( string("Desktop") == path.Leaf() );
	path.Unset();
	// non-existing dirs
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/non-existing") == B_OK );
	CPPUNIT_ASSERT( string("non-existing") == path.Leaf() );
	CPPUNIT_ASSERT( path.SetTo("/non/existing/dir") == B_OK );
	CPPUNIT_ASSERT( string("dir") == path.Leaf() );
	path.Unset();
}

// ParentTest
void
PathTest::ParentTest()
{
	BPath path;
	BPath parent;
// R5: crashs, when GetParent() is called on uninitialized BPath
#if !TEST_R5
	// uninitialized BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_NO_INIT );
	path.Unset();
	parent.Unset();
#endif
	// root dir
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_ENTRY_NOT_FOUND );
	path.Unset();
	parent.Unset();
	// existing dirs
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/boot") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_OK );
	CPPUNIT_ASSERT( string("/") == parent.Path() );
	CPPUNIT_ASSERT( path.SetTo("/boot/home") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_OK );
	CPPUNIT_ASSERT( string("/boot") == parent.Path() );
	CPPUNIT_ASSERT( path.SetTo("/boot/home/Desktop") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_OK );
	CPPUNIT_ASSERT( string("/boot/home") == parent.Path() );
	path.Unset();
	parent.Unset();
	// non-existing dirs
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/non-existing") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_OK );
	CPPUNIT_ASSERT( string("/") == parent.Path() );
	CPPUNIT_ASSERT( path.SetTo("/non/existing/dir") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&parent) == B_OK );
	CPPUNIT_ASSERT( string("/non/existing") == parent.Path() );
	path.Unset();
	parent.Unset();
	// destructive parenting
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/non/existing/dir") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(&path) == B_OK );
	CPPUNIT_ASSERT( string("/non/existing") == path.Path() );
	CPPUNIT_ASSERT( path.GetParent(&path) == B_OK );
	CPPUNIT_ASSERT( string("/non") == path.Path() );
	CPPUNIT_ASSERT( path.GetParent(&path) == B_OK );
	CPPUNIT_ASSERT( string("/") == path.Path() );
	CPPUNIT_ASSERT( path.GetParent(&path) == B_ENTRY_NOT_FOUND );
	path.Unset();
	parent.Unset();
// R5: crashs, when passing a NULL BPath
#if !TEST_R5
	// bad args
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/non/existing/dir") == B_OK );
	CPPUNIT_ASSERT( path.GetParent(NULL) == B_BAD_VALUE );
	path.Unset();
	parent.Unset();
#endif
}

// ComparisonTest
void
PathTest::ComparisonTest()
{
	BPath path;
	// 1. ==/!= const BPath &
	BPath path2;
	// uninitialized BPaths
// R5: uninitialized paths are unequal
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
#if !TEST_R5
	CPPUNIT_ASSERT( (path == path2) == true );
	CPPUNIT_ASSERT( (path != path2) == false );
#endif
	path.Unset();
	path2.Unset();
	// uninitialized argument BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/") == B_OK );
	CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( (path == path2) == false );
	CPPUNIT_ASSERT( (path != path2) == true );
	path.Unset();
	path2.Unset();
	// uninitialized this BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path2.SetTo("/") == B_OK );
	CPPUNIT_ASSERT( (path == path2) == false );
	CPPUNIT_ASSERT( (path != path2) == true );
	path.Unset();
	path2.Unset();
	// various paths
	NextSubTest();
	const char *paths[] = { "/", "/boot", "/boot/home", "/boot/home/Desktop" };
	int32 pathCount = sizeof(paths) / sizeof(const char*);
	for (int32 i = 0; i < pathCount; i++) {
		for (int32 k = 0; k < pathCount; k++) {
			CPPUNIT_ASSERT( path.SetTo(paths[i]) == B_OK );
			CPPUNIT_ASSERT( path2.SetTo(paths[k]) == B_OK );
			CPPUNIT_ASSERT( (path == path2) == (i == k) );
			CPPUNIT_ASSERT( (path != path2) == (i != k) );
		}
	}
	path.Unset();
	path2.Unset();

	// 2. ==/!= const char *
	const char *pathName;
	// uninitialized BPath
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	pathName = "/";
	CPPUNIT_ASSERT( (path == pathName) == false );
	CPPUNIT_ASSERT( (path != pathName) == true );
	path.Unset();
	// various paths
	NextSubTest();
	for (int32 i = 0; i < pathCount; i++) {
		for (int32 k = 0; k < pathCount; k++) {
			CPPUNIT_ASSERT( path.SetTo(paths[i]) == B_OK );
			pathName = paths[k];
			CPPUNIT_ASSERT( (path == pathName) == (i == k) );
			CPPUNIT_ASSERT( (path != pathName) == (i != k) );
		}
	}
	path.Unset();
	// bad args (NULL const char*)
// R5: initialized path equals NULL argument!
// R5: uninitialized path does not equal NULL argument!
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/") == B_OK );
	pathName = NULL;
#if !TEST_R5
	CPPUNIT_ASSERT( (path == pathName) == false );
	CPPUNIT_ASSERT( (path != pathName) == true );
#endif
	path.Unset();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
#if !TEST_R5
	CPPUNIT_ASSERT( (path == pathName) == true );
	CPPUNIT_ASSERT( (path != pathName) == false );
#endif
	path.Unset();
}

// AssignmentTest
void
PathTest::AssignmentTest()
{
	// 1. copy constructor
	// uninitialized
	NextSubTest();
	{
		BPath path;
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		BPath path2(path);
		CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
	}
	// initialized
	NextSubTest();
	{
		BPath path("/boot/home/Desktop");
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		BPath path2(path);
		CPPUNIT_ASSERT( path2.InitCheck() == B_OK );
		CPPUNIT_ASSERT( path == path2 );
	}

	// 2. assignment operator, const BPath &
	// uninitialized
	NextSubTest();
	{
		BPath path;
		BPath path2;
		path2 = path;
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
	}
	NextSubTest();
	{
		BPath path;
		BPath path2("/");
		CPPUNIT_ASSERT( path2.InitCheck() == B_OK );
		path2 = path;
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
	}
	// initialized
	NextSubTest();
	{
		BPath path("/boot/home");
		CPPUNIT_ASSERT( path.InitCheck() == B_OK );
		BPath path2;
		path2 = path;
		CPPUNIT_ASSERT( path2.InitCheck() == B_OK );
		CPPUNIT_ASSERT( path == path2 );
	}

	// 2. assignment operator, const char *
	// initialized
	NextSubTest();
	{
		const char *pathName = "/boot/home";
		BPath path2;
		path2 = pathName;
		CPPUNIT_ASSERT( path2.InitCheck() == B_OK );
		CPPUNIT_ASSERT( path2 == pathName );
	}
	// bad args
	NextSubTest();
	{
		const char *pathName = NULL;
		BPath path2;
		path2 = pathName;
		CPPUNIT_ASSERT( path2.InitCheck() == B_NO_INIT );
	}
}

// FlattenableTest
void
PathTest::FlattenableTest()
{
	BPath path;
	// 1. trivial methods (IsFixedSize(), TypeCode(), AllowsTypeCode)
	// uninitialized
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	CPPUNIT_ASSERT( path.IsFixedSize() == false );
	CPPUNIT_ASSERT( path.TypeCode() == B_REF_TYPE );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_REF_TYPE) == true );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_STRING_TYPE) == false );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_FLOAT_TYPE) == false );
	path.Unset();	
	// initialized
	NextSubTest();
	CPPUNIT_ASSERT( path.SetTo("/boot/home") == B_OK );
	CPPUNIT_ASSERT( path.IsFixedSize() == false );
	CPPUNIT_ASSERT( path.TypeCode() == B_REF_TYPE );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_REF_TYPE) == true );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_STRING_TYPE) == false );
	CPPUNIT_ASSERT( path.AllowsTypeCode(B_FLOAT_TYPE) == false );
	path.Unset();	

	// 2. non-trivial methods
	char buffer[1024];
	// uninitialized
	NextSubTest();
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	ssize_t size = path.FlattenedSize();
	CPPUNIT_ASSERT( size == sizeof(dev_t) + sizeof(ino_t) );
	CPPUNIT_ASSERT( path.Flatten(buffer, sizeof(buffer)) == B_OK );
	CPPUNIT_ASSERT( path.Unflatten(B_REF_TYPE, buffer, size) == B_OK );
	CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
	path.Unset();
	// some flatten/unflatten tests
	NextSubTest();
	const char *paths[] = { "/", "/boot", "/boot/home", "/boot/home/Desktop",
							"/boot/home/non-existing" };
	int32 pathCount = sizeof(paths) / sizeof(const char*);
	for (int32 i = 0; i < pathCount; i++) {
		const char *pathName = paths[i];
		// init the path and get an equivalent entry ref
		CPPUNIT_ASSERT( path.SetTo(pathName) == B_OK );
		BEntry entry;
		CPPUNIT_ASSERT( entry.SetTo(pathName) == B_OK );
		entry_ref ref;
		CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
		// flatten the path
		struct flattened_ref { dev_t device; ino_t directory; char name[1]; };
		size = path.FlattenedSize();
		ssize_t expectedSize
			= sizeof(dev_t) + sizeof(ino_t) + strlen(ref.name) + 1;
		CPPUNIT_ASSERT( size ==  expectedSize);
		CPPUNIT_ASSERT( path.Flatten(buffer, sizeof(buffer)) == B_OK );
		// check the flattened data
		const flattened_ref &fref = *(flattened_ref*)buffer;
		CPPUNIT_ASSERT( ref.device == fref.device );
		CPPUNIT_ASSERT( ref.directory == fref.directory );
		CPPUNIT_ASSERT( strcmp(ref.name, fref.name) == 0 );
		// unflatten the path 
		path.Unset();
		CPPUNIT_ASSERT( path.InitCheck() == B_NO_INIT );
		CPPUNIT_ASSERT( path.Unflatten(B_REF_TYPE, buffer, size) == B_OK );
		CPPUNIT_ASSERT( path == pathName );
		path.Unset();
	}
	// bad args
	NextSubTest();
// R5: crashs, when passing a NULL buffer
// R5: doesn't check the buffer size
	CPPUNIT_ASSERT( path.SetTo("/boot/home") == B_OK );
#if !TEST_R5
	CPPUNIT_ASSERT( path.Flatten(NULL, sizeof(buffer)) == B_BAD_VALUE );
	CPPUNIT_ASSERT( path.Flatten(buffer, path.FlattenedSize() - 2)
					== B_BAD_VALUE );
#endif
	path.Unset();
}