// MimeTypeTest.cpp

#include <ctype.h>			// For tolower()
#include <fcntl.h>			// open()
#include <map>
#include <queue>
#include <stdio.h>
#include <string.h>			// For memcmp()
#include <string>
#include <unistd.h>
#include <vector>


#include <fs_attr.h>		// For struct attr_info
#include <fs_info.h>
#include <Application.h>
#include <Bitmap.h>
#include <DataIO.h>
#include <Drivers.h>		// B_GET_ICON, device_icon
#include <Message.h>
#include <Mime.h>
#if !TEST_R5
	#include <mime/database_support.h>
#endif
#include <Path.h>			// Only needed for entry_ref dumps
#include <StorageKit.h>
#include <String.h>
#include <storage_support.h>	// for split_path()

#include "TestShell.h"
#include "TestApp.h"
#include "TestUtils.h"

#include "MimeTypeTest.h"

// MIME database directories
static const char *testDir				= "/tmp/mimeTestDir";
static const char *R5DatabaseDir		= "/boot/home/config/settings/beos_mime";
#if TEST_R5
static std::string mimeDatabaseDir		= R5DatabaseDir;
#else
static std::string mimeDatabaseDir		= BPrivate::Storage::Mime::kDatabaseDir;
#endif

// MIME Test Types
// testType and testTypeApp are Delete()d after each test.
static const char *testType				= "text/x-vnd.obos-Storage-Kit-Test";
static const char *testType1			= "text/x-vnd.obos-Storage-Kit-Test1";
static const char *testType2			= "text/x-vnd.obos-Storage-Kit-Test2";
static const char *testType3			= "text/x-vnd.obos-Storage-Kit-Test3";
static const char *testType4			= "text/x-vnd.obos-Storage-Kit-Test4";
static const char *testType5			= "text/x-vnd.obos-Storage-Kit-Test5";
static const char *testTypeApp			= "application/StorageKit-Test";
static const char *testTypeApp1			=  "application/"
										   "x-vnd.obos.mime.test.test1";
static const char *testTypeApp2			=  "application/"
										   "x-vnd.obos.mime.test.test2";
static const char *testTypeApp3			=  "application/"
										   "x-vnd.obos.mime.test.test3";
static const char *testTypeInvalid		= "text/Are spaces valid?";
static const char *testTypeSuperValid	= "valid-but-fake-supertype";
static const char *testTypeSuperInvalid	= "?????";

// Real MIME types
static const char *wildcardType			= "application/octet-stream";
static const char *applicationSupertype	= "application";

// Application Paths
static const char *testApp				= "/boot/beos/apps/SoundRecorder";
static const char *testApp2				= "/boot/beos/apps/CDPlayer";
static const char *fakeTestApp			= "/__this_isn't_likely_to_exist__";

// BMessage field names
static const char *applicationsField		= "applications";
static const char *typeField				= "type";
static const char *typesField				= "types";
static const char *fileExtField				= "extensions";
static const char *attrInfoField_Name		= "attr:name";
static const char *attrInfoField_PublicName	= "attr:public_name";
static const char *attrInfoField_Type		= "attr:type";
static const char *attrInfoField_Viewable	= "attr:viewable";
static const char *attrInfoField_Editable	= "attr:editable";

// Descriptions
static const char *testDescr			= "Just a test, nothing more :-)";
static const char *testDescr2			= "Another amazing test string";
static const char *longDescr			=
"This description is longer than B_MIME_TYPE_LENGTH, which is quite useful for certain things... "
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd";
// Signatures
static const char *testSig				= "application/x-vnd.obos.mime-type-test";
static const char *testSig2				= "application/x-vnd.obos.mime-type-test-2";
static const char *longSig				= "application/x-vnd.obos.mime-type-test-long."
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd";

// Declarations for handy dandy private functions
static bool operator==(BBitmap &bmp1, BBitmap &bmp2);
static bool operator!=(BBitmap &bmp1, BBitmap &bmp2);
static bool operator==(BMessage &msg1, BMessage &msg2);
static bool operator!=(BMessage &msg1, BMessage &msg2);
static void fill_bitmap(BBitmap &bmp, char value);
//static void dump_bitmap(BBitmap &bmp, char *name = "bmp");
#if !TEST_R5
	static status_t reduce_color_depth(BBitmap &src32, BBitmap &dest8);
#endif
//static void dump_ref(entry_ref *ref, char* name = "ref");
static void to_lower(const char *str, std::string &result);
static std::string to_lower(const char *str);
static void remove_type(const char *type, const char *databaseDir = mimeDatabaseDir.c_str());
static bool type_exists(const char *type, const char *databaseDir = mimeDatabaseDir.c_str());
class ContainerAdapter;
class SetAdapter;
class QueueAdapter;
void FillWithMimeTypes(ContainerAdapter &container, BMessage &typeMessage, const char* fieldName);
	// Used to add all the types in a BMessage from GetInstalled*Types() to some
	// sort of container object (via an adapter to support differing interfaces).

// Custom TestSuite class to allow us to make a copy of the MIME database directory
// before running all the BMimeType tests
class MimeTypeTestSuite : public CppUnit::TestSuite {
public:
	MimeTypeTestSuite() : CppUnit::TestSuite(), fMimeDirExisted(false) {}
	virtual void setUp()
	{
		// If we're using a directory other than the R5 MIME database directory, make
		// sure that directory exists. If not, make a complete copy of the R5 database
		// directory.
		if (mimeDatabaseDir != R5DatabaseDir) {
			BEntry dir(mimeDatabaseDir.c_str());
			if (dir.InitCheck() != B_OK || !dir.Exists()) {
				if (BTestShell::GlobalBeVerbose())
					cout << "(Making a copy of your MIME database at '" + mimeDatabaseDir + "')" << endl;
				std::string cmd = std::string("copyattr -d -r -- ") + R5DatabaseDir
					+ " " + mimeDatabaseDir;
				ExecCommand(cmd.c_str());
			} else {
				fMimeDirExisted = true;
				if (BTestShell::GlobalBeVerbose())
					cout << "(Using existing copy of MIME database in '" + mimeDatabaseDir + "')" << endl;
			}
		}
	}

	virtual void tearDown()
	{
		if (mimeDatabaseDir != R5DatabaseDir && !fMimeDirExisted) {
			if (BTestShell::GlobalBeVerbose())
				cout << "(Removing copy of MIME database in '" + mimeDatabaseDir + "')" << endl;
			std::string cmd = std::string("rm -rf ") + mimeDatabaseDir;
			ExecCommand(cmd.c_str());
		}
	}

	virtual void run( CppUnit::TestResult *result )
	{
		setUp();
		CppUnit::TestSuite::run(result);
		tearDown();
	}
private:
	bool fMimeDirExisted;
};

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

	// Tyler
	suite->addTest( new TC("BMimeType::Install/Delete Test",
						   &MimeTypeTest::InstallDeleteTest) );
	suite->addTest( new TC("BMimeType::App Hint Test",
						   &MimeTypeTest::AppHintTest) );
	suite->addTest( new TC("BMimeType::Attribute Info Test",
						   &MimeTypeTest::AttrInfoTest) );
	suite->addTest( new TC("BMimeType::Long Description Test",
						   &MimeTypeTest::LongDescriptionTest) );
	suite->addTest( new TC("BMimeType::Short Description Test",
						   &MimeTypeTest::ShortDescriptionTest) );
	suite->addTest( new TC("BMimeType::File Extensions Test",
						   &MimeTypeTest::FileExtensionsTest) );
	suite->addTest( new TC("BMimeType::Icon Test (Large)",
						   &MimeTypeTest::LargeIconTest) );
	suite->addTest( new TC("BMimeType::Icon Test (Mini)",
						   &MimeTypeTest::MiniIconTest) );
	suite->addTest( new TC("BMimeType::Icon For Type Test (Large)",
						   &MimeTypeTest::LargeIconForTypeTest) );
	suite->addTest( new TC("BMimeType::Icon For Type Test (Mini)",
						   &MimeTypeTest::MiniIconForTypeTest) );
	suite->addTest( new TC("BMimeType::Installed Types Test",
						   &MimeTypeTest::InstalledTypesTest) );
	suite->addTest( new TC("BMimeType::Preferred App Test",
						   &MimeTypeTest::PreferredAppTest) );
	suite->addTest( new TC("BMimeType::Supporting Apps Test",
						   &MimeTypeTest::SupportingAppsTest) );
	suite->addTest( new TC("BMimeType::Supported Types Test",
						   &MimeTypeTest::SupportedTypesTest) );
	suite->addTest( new TC("BMimeType::Wildcard Apps Test",
						   &MimeTypeTest::WildcardAppsTest) );

	// Ingo
	suite->addTest( new TC("BMimeType::Initialization Test",
						   &MimeTypeTest::InitTest) );
	suite->addTest( new TC("BMimeType::MIME String Test",
						   &MimeTypeTest::StringTest) );
	suite->addTest( new TC("BMimeType::MIME Monitoring Test",
						   &MimeTypeTest::MonitoringTest) );
	suite->addTest( new TC("BMimeType::update_mime_info() Test",
						   &MimeTypeTest::UpdateMimeInfoTest) );
	suite->addTest( new TC("BMimeType::create_app_meta_mime() Test",
						   &MimeTypeTest::CreateAppMetaMimeTest) );
	suite->addTest( new TC("BMimeType::get_device_icon() Test",
						   &MimeTypeTest::GetDeviceIconTest) );
	suite->addTest( new TC("BMimeType::Sniffer Rule Test",
						   &MimeTypeTest::SnifferRuleTest) );
	suite->addTest( new TC("BMimeType::Sniffing Test",
						   &MimeTypeTest::SniffingTest) );


	return suite;
}

// Handy comparison operators for BBitmaps. The size and color depth
// are compared first, followed by the bitmap data.
bool
operator==(BBitmap &bmp1, BBitmap &bmp2) {
	if (bmp1.Bounds() == bmp2.Bounds()) {
//		printf("bmp== 1\n");
		if (bmp1.ColorSpace() == bmp2.ColorSpace()) {
//			printf("bmp== 2\n");
			char *data1 = (char*)bmp1.Bits();
			char *data2 = (char*)bmp2.Bits();
			// NOTE! It's possible that padding bits might not get copied verbatim,
			// which could lead to unexpected failures. If things are acting weird,
			// you might try the commented out code below (keeping in mind that it
			// currently only works for 8-bit color depths).
			for (int i = 0; i < bmp1.BitsLength(); data1++, data2++, i++) {
				if (*data1 != *data2) {
//					printf("i == %d\n", i);
					return false;
				}
			}
/*			for (int i = 0; i < bmp1.Bounds().IntegerHeight(); i++) {
				for (int j = 0; j < bmp1.Bounds().IntegerWidth(); j++) {
//					printf("(%d, %d)", data1[(i * bmp1.BytesPerRow()) + j], data2[(i * bmp2.BytesPerRow()) + j]);
					if (data1[(i * bmp1.BytesPerRow()) + j] != data2[(i * bmp2.BytesPerRow()) + j]) {
						printf("fail at (%d, %d)\n", j, i);
						return false;
					}
				}
			}*/
			return true;
		} else
			return false;
	} else
		return false;
}

bool
operator!=(BBitmap &bmp1, BBitmap &bmp2) {
	return !(bmp1 == bmp2);
}

// Handy comparison operators for BMessages. The BMessages are checked field
// by field, each of which is verified to be identical with respect to: type,
// count, and data (all items).
bool
operator==(BMessage &msg1, BMessage &msg2) {
	status_t err = B_OK;

	// For now I'm ignoring the what fields...I shall deal with that later :-)
	if (msg1.what != msg2.what)
		return false;

/*
	printf("----------------------------------------------------------------------\n");
	msg1.PrintToStream();
	msg2.PrintToStream();
	printf("----------------------------------------------------------------------\n");
*/

	// Check the counts of field names
	int count1, count2;
	count1 = msg1.CountNames(B_ANY_TYPE);
	count2 = msg2.CountNames(B_ANY_TYPE);
	if (count1 != count2 && (count1 == 0 || count2 == 0))
		return false;

	// Iterate over all the names in msg1 and check that the field
	// with the same name exists in msg2, is of the same type, and
	// contains identical data.
	for (int i = 0; i < count1 && !err; i++) {
		char *name;
		type_code typeFound1, typeFound2;
		int32 countFound1, countFound2;

		// Check type and count info
		err = msg1.GetInfo(B_ANY_TYPE, i, &name, &typeFound1, &countFound1);
		if (!err)
			err = msg2.GetInfo(name, &typeFound2, &countFound2);
		if (!err)
			err = (typeFound1 == typeFound2 && countFound1 == countFound2 ? B_OK : B_ERROR);
		if (!err) {
			// Check all the data items
			for (int j = 0; j < countFound1; j++) {
				void *data1, *data2;
				ssize_t bytes1, bytes2;

				err = msg1.FindData(name, typeFound1, j, (const void**)&data1, &bytes1);
				if (!err)
					err = msg2.FindData(name, typeFound2, j, (const void**)&data2, &bytes2);
				if (!err)
					err = (bytes1 == bytes2 && memcmp(data1, data2, bytes1) == 0 ? B_OK : B_ERROR);
			}
		}
	}

	return !err;
}

bool
operator!=(BMessage &msg1, BMessage &msg2) {
	return !(msg1 == msg2);
}

// Fills the bitmap data with the given character
void
fill_bitmap(BBitmap &bmp, char value) {
	char *data = (char*)bmp.Bits();
	for (int i = 0; i < bmp.BitsLength(); data++, i++) {
//		printf("(%d -> ", *data);
		*data = value;
//		printf("%d)", *data);
	}
//	printf("\n");
}

// Fills the bitmap data with the given character
void
fill_bitmap32(BBitmap &bmp, char r, char g, char b, char a) {
	if (bmp.ColorSpace() == B_RGB32 || bmp.ColorSpace() == B_RGBA32) {
		char *data = (char*)bmp.Bits();
		for (int i = 0; i+3 < bmp.BitsLength(); data += 4, i+= 4) {
			data[0] = b;
			data[1] = g;
			data[2] = r;
			data[3] = a;
//			printf("(%d,%d,%d,%d)", data[2], data[1], data[0], data[3]);
		}
//		printf("\n");
	}
}

// Dumps the size, colorspace, and first data byte
// of the bitmap to stdout
/*void
dump_bitmap(BBitmap &bmp, char *name = "bmp") {
	printf("%s == (%ldx%ld, ", name, bmp.Bounds().IntegerWidth()+1,
		bmp.Bounds().IntegerHeight()+1);
	switch (bmp.ColorSpace()) {
		case B_CMAP8:
			printf("B_CMAP8");
			break;

		case B_RGB32:
			printf("B_RGB32");
			break;

		case B_RGBA32:
			printf("B_RGBA32");
			break;

		default:
			printf("%x", bmp.ColorSpace());
			break;
	}
	printf(", %d, [", *(char*)bmp.Bits());
	char *data = (char*)bmp.Bits();
	for (int i = 0; i < bmp.BitsLength() && i < 20; data++, i++)
		printf("%d,", *data);
	printf("]\n");
}*/

// Uses BBitmap::SetBits() to convert the B_RGB32 bitmap in src32
// to a B_CMAP8 bitmap in dest8
#if !TEST_R5
status_t
reduce_color_depth(BBitmap &src32, BBitmap &dest8)
{
	status_t err = (src32.ColorSpace() == B_RGB32
				      && dest8.ColorSpace() == B_CMAP8
				        && src32.InitCheck() == B_OK
				          && dest8.InitCheck() == B_OK
					        && src32.Bounds() == dest8.Bounds())
					          ? B_OK
					            : B_BAD_VALUE;
	if (!err) {
		// Set each pixel individually, since SetBits() for B_RGB32 takes
		// 24-bit rgb pixel data...
		char *data = (char*)src32.Bits();
		for (int32 i = 0; i*4+3 < src32.BitsLength(); data += 4, i++) {
			char rgb[3];
			rgb[0] = data[2];	// red
			rgb[1] = data[1];	// green
			rgb[2] = data[0];	// blue
			dest8.SetBits(rgb, 3, i, B_RGB32);
		}
	}
	return err;
}
#endif

// IconHelper and IconForTypeHelper:
// Adapter(?) classes needed to reuse icon tests among {Get,Set}Icon() and {Get,Set}IconForType()
// What originally were meant to encapsulate the variations among calls to the various BMimeType
// icon functions have now exploded into beefy helper classes with a bunch of BBitmap related
// functionality as well. A lot of this stuff doesn't necessarily belong

class IconHelper {
public:
	IconHelper(icon_size which)
		: bmp1(BitmapBounds(which), B_CMAP8),
		  bmp2(BitmapBounds(which), B_CMAP8),
		  bmpTemp(BitmapBounds(which), B_CMAP8),
		  size(which)
	{
		// Initialize our three bitmaps to different "colors"
		fill_bitmap(bmp1, 1);
		fill_bitmap(bmp2, 2);
		fill_bitmap(bmpTemp, 3);
	}

	virtual ~IconHelper() {}

	// Returns the proper bitmap bounds for the given icon size
	BRect BitmapBounds(icon_size isize) {
		return isize == B_LARGE_ICON ? BRect(0,0,31,31) : BRect(0,0,15,15);
	}

	// Returns the proper bitmap bounds for this helper's icon size
	BRect BitmapBounds() {
		return BitmapBounds(size);
	}

	// Used to call the appropriate GetIcon[ForType] function
	virtual status_t GetIcon(BMimeType &mime, BBitmap *icon) {
		return mime.GetIcon(icon, size);
	}

	// Used to call the appropriate SetIcon[ForType] function
	virtual status_t SetIcon(BMimeType &mime, BBitmap *icon) {
		return mime.SetIcon(icon, size);
	}

	// Used to call the appropriate DeleteIcon[ForType] function
	virtual status_t DeleteIcon(BMimeType &mime) {
#if TEST_R5
		return B_BAD_VALUE;
#else
		return mime.DeleteIcon(size);
#endif
	}

	BBitmap* TempBitmap() {
		return &bmpTemp;
	}

	BBitmap* Bitmap1() {
		return &bmp1;
	}

	BBitmap* Bitmap2() {
		return &bmp2;
	}

	icon_size Size() {
		return size;
	}

protected:
	BBitmap bmp1;
	BBitmap bmp2;
	BBitmap bmpTemp;
	icon_size size;
};

class IconForTypeHelper : public IconHelper {
public:
	IconForTypeHelper(const char *fileType, icon_size which)
		: IconHelper(which), fileType(fileType) {}
	virtual ~IconForTypeHelper() {}
	virtual status_t GetIcon(BMimeType &mime, BBitmap *icon) {
		return mime.GetIconForType(fileType.c_str(), icon, size);
	}
	virtual status_t SetIcon(BMimeType &mime, BBitmap *icon) {
		return mime.SetIconForType(fileType.c_str(), icon, size);
	}
	virtual status_t DeleteIcon(BMimeType &mime) {
#if TEST_R5
		return B_BAD_VALUE;
#else
		return mime.DeleteIconForType(fileType.c_str(), size);
#endif
	}
protected:
	std::string fileType;
};

// Adapter classes used by FillWithMimeTypes() to facilitate
// addition of strings to containers with varying interfaces
class ContainerAdapter {
public:
	virtual void Add(std::string value) = 0;
};

class SetAdapter : public ContainerAdapter {
public:
	SetAdapter(std::set<std::string> &set)
		: fSet(set) { }
	virtual void Add(std::string value) {
		fSet.insert(value);
	}
protected:
	std::set<std::string> &fSet;
};

class QueueAdapter : public ContainerAdapter {
public:
	QueueAdapter(std::queue<std::string> &queue)
		: fQueue(queue) { }
	virtual void Add(std::string value) {
		fQueue.push(value);
	}
protected:
	std::queue<std::string> &fQueue;
};


// setUp
void
MimeTypeTest::setUp()
{
	BasicTest::setUp();
	execCommand(string("mkdir ") + testDir);
/*	// Better not to play with fire, so we'll make a copy of the
	// local mime database which we'll use for certain Haiku tests
	execCommand(string("mkdir ") + testDir
				+ " ; copyattr -d -r -- " + mimeDatabaseDir + "/\* " + testDir
				); */
	// Setup our application
	fApplication = new BTestApp(testSig);
	if (fApplication->Init() != B_OK) {
		fprintf(stderr, "Failed to initialize application.\n");
		delete fApplication;
		fApplication = NULL;
	}

}

// tearDown
void
MimeTypeTest::tearDown()
{
	execCommand(string("rm -rf ") + testDir);

	// Uninistall our test type
	//! /todo Uncomment the following uninstall code when all is said and done.
/*	BMimeType mime(testType);
	status_t err = mime.InitCheck();
	if (!err && mime.IsInstalled())
		err = mime.Delete();
	if (err)
		fprintf(stderr, "Failed to unistall test type \"%s\"\n", testType); */
	// Terminate the Application
	if (fApplication) {
		fApplication->Terminate();
		delete fApplication;
		fApplication = NULL;
	}
	// remove the types we've added
	const char * const testTypes[] = {
		testType, testType1, testType2, testType3, testType4, testType5,
		testTypeApp, testTypeApp1, testTypeApp2, testTypeApp3,
	};
	for (uint32 i = 0; i < sizeof(testTypes) / sizeof(const char*); i++) {
		BMimeType type(testTypes[i]);
		type.Delete();
	}
	BasicTest::tearDown();
}

// entry_ref dumping function ; this may be removed at any time

/*void
dump_ref(entry_ref *ref, char* name = "ref") {
	if (ref) {
		BPath path(ref);
		status_t err = path.InitCheck();
		if (!err) {
			printf("%s == '%s'", name, path.Path());
		} else
			printf("%s == ERROR", name);
		printf(" == (%ld, %lld, '%s')\n", ref->device, ref->directory, ref->name);

	} else
		printf("%s == (NULL)\n", name);
}*/

// App Hint

void
MimeTypeTest::AppHintTest() {
	// init a couple of entry_refs to applications
	BEntry entry(testApp);
	entry_ref appRef;
	CHK(entry.InitCheck() == B_OK);
	CHK(entry.GetRef(&appRef) == B_OK);
	BEntry entry2(testApp2);
	entry_ref appRef2;
	CHK(entry2.InitCheck() == B_OK);
	CHK(entry2.GetRef(&appRef2) == B_OK);
	// Uninitialized
	NextSubTest();
	{
		BMimeType mime;
		entry_ref ref;
		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(mime.GetAppHint(&ref) != B_OK);		// R5 == B_BAD_VALUE
		CHK(mime.SetAppHint(&ref) != B_OK);		// R5 == B_BAD_VALUE
	}
	// NULL params
	NextSubTest();
	{
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
#if TEST_R5
		CHK(!mime.IsInstalled());
		CHK(mime.GetAppHint(NULL) != B_OK);		// R5 == B_BAD_VALUE
		CHK(!mime.IsInstalled());
		CHK(mime.SetAppHint(NULL) != B_OK);		// Installs, R5 == B_ENTRY_NOT_FOUND
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(NULL) != B_OK);		// R5 == B_BAD_VALUE
		CHK(mime.SetAppHint(NULL) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
#else
		CHK(!mime.IsInstalled());
		CHK(mime.GetAppHint(NULL) != B_OK);		// B_BAD_VALUE
		CHK(!mime.IsInstalled());
		CHK(mime.SetAppHint(NULL) != B_OK);		// B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == appRef);
		CHK(mime.SetAppHint(NULL) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) != B_OK);		// B_ENTRY_NOT_FOUND
#endif
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeleteAppHint() != B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == appRef);
		CHK(mime.DeleteAppHint() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) != B_OK);
#endif
	}
	// Non-installed type
	NextSubTest();
	{
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == appRef);
	}
	// Installed Type
	NextSubTest();
	{
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Get() with no apphint installed
		CHK(mime.GetAppHint(&ref) == B_ENTRY_NOT_FOUND);
		// Initial Set()/Get()
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == appRef);
		// Followup Set()/Get()
		CHK(mime.SetAppHint(&appRef2) == B_OK);
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == appRef2);
		CHK(ref != appRef);
	}
	// Installed Type, invalid entry_ref
	NextSubTest();
	{
		entry_ref ref(-1, -1, NULL);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.SetAppHint(&ref) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Installed Type, fake/invalid entry_ref
	NextSubTest();
	{
		entry_ref ref(0, 0, "__this_ought_not_exist__");
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.SetAppHint(&ref) != B_OK);	// R5 == B_ENTRY_NOT_FOUND
	}
	// Installed Type, abstract entry_ref
	NextSubTest();
	{
		entry_ref fakeRef;
		entry_ref ref;
		BEntry entry(fakeTestApp);
		CHK(entry.InitCheck() == B_OK);
		CHK(!entry.Exists());
		CHK(entry.GetRef(&fakeRef) == B_OK);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.SetAppHint(&appRef) == B_OK);
		CHK(mime.SetAppHint(&fakeRef) == B_OK);
		CHK(mime.GetAppHint(&ref) == B_OK);
		CHK(ref == fakeRef);
		CHK(ref != appRef);
	}
}

// Attr Info

void
MimeTypeTest::AttrInfoTest() {
	// Create some messages to sling around
	const int32 WHAT = 233;	// This is the what value that GAI() returns...not sure if it has a name yet
	BMessage msg1(WHAT), msg2(WHAT), msg3(WHAT), msgIncomplete1(WHAT), msgIncomplete2(WHAT);

	CHK(msg1.AddString(attrInfoField_Name, "Color") == B_OK);
	CHK(msg1.AddString(attrInfoField_PublicName, "The Color") == B_OK);
	CHK(msg1.AddInt32(attrInfoField_Type, B_STRING_TYPE) == B_OK);
	CHK(msg1.AddBool(attrInfoField_Viewable, true) == B_OK);
	CHK(msg1.AddBool(attrInfoField_Editable, true) == B_OK);

	CHK(msg1.AddString(attrInfoField_Name, "High Score") == B_OK);
	CHK(msg1.AddString(attrInfoField_PublicName, "The Highest Score Ever") == B_OK);
	CHK(msg1.AddInt32(attrInfoField_Type, B_INT32_TYPE) == B_OK);
	CHK(msg1.AddBool(attrInfoField_Viewable, false) == B_OK);
	CHK(msg1.AddBool(attrInfoField_Editable, false) == B_OK);

	CHK(msg2.AddString(attrInfoField_Name, "Volume") == B_OK);
	CHK(msg2.AddString(attrInfoField_PublicName, "Loudness") == B_OK);
	CHK(msg2.AddInt32(attrInfoField_Type, B_DOUBLE_TYPE) == B_OK);
	CHK(msg2.AddBool(attrInfoField_Viewable, true) == B_OK);
	CHK(msg2.AddBool(attrInfoField_Editable, true) == B_OK);

	CHK(msg3.AddString(attrInfoField_Name, "Volume") == B_OK);
	CHK(msg3.AddString(attrInfoField_PublicName, "Loudness") == B_OK);
	CHK(msg3.AddInt32(attrInfoField_Type, B_DOUBLE_TYPE) == B_OK);
	CHK(msg3.AddBool(attrInfoField_Viewable, true) == B_OK);
	CHK(msg3.AddBool(attrInfoField_Editable, true) == B_OK);

	CHK(msgIncomplete1.AddString(attrInfoField_Name, "Color") == B_OK);
	CHK(msgIncomplete1.AddString(attrInfoField_PublicName, "The Color") == B_OK);
	CHK(msgIncomplete1.AddInt32(attrInfoField_Type, B_STRING_TYPE) == B_OK);
	CHK(msgIncomplete1.AddBool(attrInfoField_Viewable, true) == B_OK);
	CHK(msgIncomplete1.AddBool(attrInfoField_Editable, true) == B_OK);

	CHK(msgIncomplete1.AddString(attrInfoField_Name, "High Score") == B_OK);
//	CHK(msgIncomplete1.AddString(attrInfoField_PublicName, "The Highest Score Ever") == B_OK);
	CHK(msgIncomplete1.AddInt32(attrInfoField_Type, B_INT32_TYPE) == B_OK);
//	CHK(msgIncomplete1.AddBool(attrInfoField_Viewable, false) == B_OK);
	CHK(msgIncomplete1.AddBool(attrInfoField_Editable, false) == B_OK);

	CHK(msgIncomplete2.AddString(attrInfoField_Name, "Color") == B_OK);
//	CHK(msgIncomplete2.AddString(attrInfoField_PublicName, "The Color") == B_OK);
//	CHK(msgIncomplete2.AddInt32(attrInfoField_Type, B_STRING_TYPE) == B_OK);
//	CHK(msgIncomplete2.AddBool(attrInfoField_Viewable, true) == B_OK);
	CHK(msgIncomplete2.AddBool(attrInfoField_Editable, true) == B_OK);

	CHK(msg1 == msg1);
	CHK(msg2 == msg2);
	CHK(msg3 == msg3);
	CHK(msg1 != msg2);
	CHK(msg1 != msg3);
	CHK(msg2 == msg3);

	// Uninitialized
	NextSubTest();
	{
		BMimeType mime;
		BMessage msg;

		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(mime.GetAttrInfo(&msg) != B_OK);		// R5 == B_BAD_VALUE
		CHK(mime.SetAttrInfo(&msg) != B_OK);		// R5 == B_BAD_VALUE
	}

	// NULL params
	NextSubTest();
	{
#if !TEST_R5
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeleteAttrInfo() != B_OK);
		CHK(!mime.IsInstalled());
		msg1.RemoveName(typeField);						// Clear "type" field, since SAI() just adds another
		CHK(mime.SetAttrInfo(&msg1) == B_OK);
		CHK(mime.IsInstalled());
		CHK(msg != msg1);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" field as GAI() does
		CHK(msg == msg1);
		CHK(mime.SetAttrInfo(NULL) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAttrInfo(&msg) != B_OK);
#endif
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeleteAttrInfo() != B_OK);
		CHK(!mime.IsInstalled());
		msg1.RemoveName(typeField);						// Clear "type" field, since SAI() just adds another
		CHK(mime.SetAttrInfo(&msg1) == B_OK);
		CHK(mime.IsInstalled());
		CHK(msg != msg1);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" field as GAI() does
		CHK(msg == msg1);
		CHK(mime.DeleteAttrInfo() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAttrInfo(&msg) != B_OK);
#endif
	}

	// Improperly formatted BMessages
	NextSubTest();
	{
		BMessage msg(WHAT);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Initial Set()/Get()
		msgIncomplete1.RemoveName(typeField);		// Clear "type" fields, since SAI() just adds another
		msgIncomplete2.RemoveName(typeField);
		CHK(msg != msgIncomplete1);
		CHK(msg != msgIncomplete2);
		CHK(mime.SetAttrInfo(&msgIncomplete1) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msgIncomplete1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msgIncomplete2.AddString(typeField, testType) == B_OK);
		CHK(msg == msgIncomplete1);
		CHK(msg != msgIncomplete2);
	}

	// Set() with improperly formatted message
	NextSubTest();
	{
		BMessage msg(WHAT);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Initial Set()/Get()
		msgIncomplete1.RemoveName(typeField);		// Clear "type" fields, since SAI() just adds another
		msgIncomplete2.RemoveName(typeField);
		CHK(msg != msgIncomplete1);
		CHK(msg != msgIncomplete2);
		CHK(mime.SetAttrInfo(&msgIncomplete1) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msgIncomplete1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msgIncomplete2.AddString(typeField, testType) == B_OK);
		CHK(msg == msgIncomplete1);
		CHK(msg != msgIncomplete2);
	}

	// Set() with empty message
	NextSubTest();
	{
		BMimeType mime(testType);
		BMessage msgEmpty(WHAT);
		BMessage msg(WHAT);
		CHK(msg.AddInt32("stuff", 1234) == B_OK);	// Add an extra attribute to give us something to compare with

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Set(empty)
		CHK(msg != msgEmpty);
		CHK(mime.SetAttrInfo(&msgEmpty) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msgEmpty.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg == msgEmpty);
	}

	// Set() with extra attributes in message
	NextSubTest();
	{
		BMimeType mime(testType);
		BMessage msg(WHAT);
		BMessage msgExtraSet(msg1);
		CHK(msgExtraSet.AddString("extra", ".extra") == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 123) == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 456) == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 789) == B_OK);
		BMessage msgExtraGet(msgExtraSet);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Set(extra)/Get(empty)
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msgExtraSet);
		CHK(mime.SetAttrInfo(&msgExtraSet) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msgExtraSet.AddString(typeField, testType) == B_OK);
		CHK(msg == msgExtraSet);
		CHK(msg != msg1);

		// Get(extra)
		NextSubTest();
		CHK(mime.GetAttrInfo(&msgExtraGet) == B_OK);
		CHK(msgExtraGet == msgExtraSet);
		CHK(msgExtraGet != msg1);

		// Get(extra and then some)
		NextSubTest();
		CHK(msgExtraGet.AddInt32("more_extras", 101112) == B_OK);
		msgExtraGet.RemoveName(typeField);		// Clear "type" fields to be fair, since SFE() just adds another
		CHK(mime.GetAttrInfo(&msgExtraGet) == B_OK);	// Reinitializes result (clearing extra fields)
		CHK(msgExtraGet == msgExtraSet);
		CHK(msgExtraGet != msg1);

	}
	// Normal Function (Non-installed type)
	NextSubTest();
	{
		BMimeType mime(testType);
		BMessage msg(WHAT);
		BMessage msg2(WHAT);

		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);

		CHK(!mime.IsInstalled());
		CHK(mime.GetAttrInfo(&msg) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetAttrInfo(&msg) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetAttrInfo(&msg2) == B_OK);
		CHK(msg.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GAI() does
		CHK(msg == msg2);
	}

	// Normal Function
	NextSubTest();
	{
		BMessage msg(WHAT);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Initial Set()/Get()
		msg1.RemoveName(typeField);		// Clear "type" fields, since SAI() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
		CHK(mime.SetAttrInfo(&msg1) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg == msg1);
		CHK(msg != msg2);

		// Followup Set()/Get()
		NextSubTest();
		CHK(msg.MakeEmpty() == B_OK);
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
		CHK(mime.SetAttrInfo(&msg2) == B_OK);
		CHK(mime.GetAttrInfo(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg != msg1);
		CHK(msg == msg2);

		// Clear
		NextSubTest();
		CHK(msg.MakeEmpty() == B_OK);
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
#if !TEST_R5
		CHK(mime.SetAttrInfo(NULL) == B_OK);		// R5 == CRASH! despite what one might think should happen
		CHK(mime.GetAttrInfo(&msg) != B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg != msg1);
		CHK(msg != msg2);
#endif
	}
}

// File Extensions

void
MimeTypeTest::FileExtensionsTest() {
	// Create some messages to sling around
	const int32 WHAT = 234;	// This is the what value that GFE returns...not sure if it has a name yet
	BMessage msg1(WHAT), msg2(WHAT), msg3(WHAT);

	CHK(msg1.AddString(fileExtField, ".data") == B_OK);
	CHK(msg1.AddString(fileExtField, ".txt") == B_OK);
	CHK(msg1.AddString(fileExtField, ".png") == B_OK);
	CHK(msg1.AddString(fileExtField, ".html") == B_OK);

	CHK(msg2.AddString(fileExtField, ".data") == B_OK);
	CHK(msg2.AddString(fileExtField, ".txt") == B_OK);

	CHK(msg3.AddString(fileExtField, ".data") == B_OK);
	CHK(msg3.AddString(fileExtField, ".txt") == B_OK);

	CHK(msg1 == msg1);
	CHK(msg2 == msg2);
	CHK(msg3 == msg3);
	CHK(msg1 != msg2);
	CHK(msg1 != msg3);
	CHK(msg2 == msg3);

	// Uninitialized
	NextSubTest();
	{
		BMessage msg(WHAT);
		BMimeType mime;

		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(mime.GetFileExtensions(&msg) != B_OK);	// R5 == B_BAD_VALUE
		CHK(mime.SetFileExtensions(&msg) != B_OK);	// R5 == B_BAD_VALUE
	}
	// NULL params
	NextSubTest();
	{
#if !TEST_R5
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeleteFileExtensions() != B_OK);
		CHK(!mime.IsInstalled());
		msg1.RemoveName(typeField);						// Clear "type" field, since SAI() just adds another
		CHK(mime.SetFileExtensions(&msg1) == B_OK);
		CHK(mime.IsInstalled());
		CHK(msg != msg1);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" field as GAI() does
		CHK(msg == msg1);
		CHK(mime.SetFileExtensions(NULL) == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetFileExtensions(&msg) != B_OK);
#endif
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeleteFileExtensions() != B_OK);
		CHK(!mime.IsInstalled());
		msg1.RemoveName(typeField);						// Clear "type" field, since SAI() just adds another
		CHK(mime.SetFileExtensions(&msg1) == B_OK);
		CHK(mime.IsInstalled());
		CHK(msg != msg1);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" field as GAI() does
		CHK(msg == msg1);
		CHK(mime.DeleteFileExtensions() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetFileExtensions(&msg) != B_OK);
#endif
	}
	// Set() with empty message
	NextSubTest();
	{
		BMimeType mime(testType);
		BMessage msgEmpty(WHAT);
		BMessage msg(WHAT);
		CHK(msg.AddInt32("stuff", 1234) == B_OK);	// Add an extra attribute to give us something to compare with

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Set(empty)
		CHK(msg != msgEmpty);
		CHK(mime.SetFileExtensions(&msgEmpty) == B_OK);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msgEmpty.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg == msgEmpty);
	}
	// Set() with extra attributes in message
	NextSubTest();
	{
		BMimeType mime(testType);
		BMessage msg(WHAT);
		BMessage msgExtraSet(msg1);
		CHK(msgExtraSet.AddString("extra", ".extra") == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 123) == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 456) == B_OK);
		CHK(msgExtraSet.AddInt32("more_extras", 789) == B_OK);
		BMessage msgExtraGet(msgExtraSet);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Set(extra)/Get(empty)
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msgExtraSet);
		CHK(mime.SetFileExtensions(&msgExtraSet) == B_OK);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msgExtraSet.AddString(typeField, testType) == B_OK);
		CHK(msg == msgExtraSet);
		CHK(msg != msg1);

		// Get(extra)
		NextSubTest();
		CHK(mime.GetFileExtensions(&msgExtraGet) == B_OK);
		CHK(msgExtraGet == msgExtraSet);
		CHK(msgExtraGet != msg1);

		// Get(extra and then some)
		NextSubTest();
		CHK(msgExtraGet.AddInt32("more_extras", 101112) == B_OK);
		msgExtraGet.RemoveName(typeField);		// Clear "type" fields to be fair, since SFE() just adds another
		CHK(mime.GetFileExtensions(&msgExtraGet) == B_OK);	// Reinitializes result (clearing extra fields)
		CHK(msgExtraGet == msgExtraSet);
		CHK(msgExtraGet != msg1);

	}
	// Normal function
	NextSubTest();
	{
		BMessage msg(WHAT);
		BMimeType mime(testType);

		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Initial Set()/Get()
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
		CHK(mime.SetFileExtensions(&msg1) == B_OK);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg == msg1);
		CHK(msg != msg2);

		// Followup Set()/Get()
		NextSubTest();
		CHK(msg.MakeEmpty() == B_OK);
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
		CHK(mime.SetFileExtensions(&msg2) == B_OK);
		CHK(mime.GetFileExtensions(&msg) == B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg != msg1);
		CHK(msg == msg2);

		// Clear
		NextSubTest();
		CHK(msg.MakeEmpty() == B_OK);
		msg1.RemoveName(typeField);		// Clear "type" fields, since SFE() just adds another
		msg2.RemoveName(typeField);
		CHK(msg != msg1);
		CHK(msg != msg2);
#if !TEST_R5
		CHK(mime.SetFileExtensions(NULL) == B_OK);		// R5 == CRASH! despite what the BeBook says
		CHK(mime.GetFileExtensions(&msg) != B_OK);
		CHK(msg1.AddString(typeField, testType) == B_OK);	// Add in "type" fields as GFE() does
		CHK(msg2.AddString(typeField, testType) == B_OK);
		CHK(msg != msg1);
		CHK(msg != msg2);
#endif
	}
}


// Icon Test Helper Function

void
MimeTypeTest::IconTest(IconHelper &helper) {
	BBitmap *bmp = helper.TempBitmap();
	// Unitialized
	NextSubTest();
	{
		BMimeType mime;
		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(helper.GetIcon(mime, bmp) != B_OK);	// R5 == B_BAD_VALUE
		CHK(helper.SetIcon(mime, bmp) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Non-installed type
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		// Test
		CHK(helper.GetIcon(mime, bmp) != B_OK);	// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(mime.IsInstalled());
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
	}
	// NULL params
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		// Uninstalled
		CHK(helper.GetIcon(mime, NULL) != B_OK);	// B_BAD_VALUE
		CHK(!mime.IsInstalled());
		CHK(helper.SetIcon(mime, NULL) != B_OK);	// R5 == Installs, B_ENTRY_NOT_FOUND
													// Haiku == Doesn't install, B_ENTRY_NOT_FOUND
#if TEST_R5
		CHK(mime.IsInstalled());
#else
		CHK(!mime.IsInstalled());
		CHK(mime.Install() == B_OK);
#endif
		CHK(helper.GetIcon(mime, bmp) != B_OK);	// B_ENTRY_NOT_FOUND
		// Installed
		CHK(helper.GetIcon(mime, NULL) != B_OK);	// B_BAD_VALUE
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(helper.SetIcon(mime, NULL) == B_OK);
		CHK(helper.GetIcon(mime, bmp) != B_OK);	// B_ENTRY_NOT_FOUND
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(helper.DeleteIcon(mime) != B_OK);
		CHK(!mime.IsInstalled());
		CHK(helper.SetIcon(mime, helper.Bitmap2()) == B_OK);
		CHK(mime.IsInstalled());
		fill_bitmap(*bmp, 100);
		CHK(*bmp != *helper.Bitmap2());
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap2());
		CHK(helper.DeleteIcon(mime) == B_OK);
		CHK(mime.IsInstalled());
		CHK(helper.GetIcon(mime, bmp) != B_OK);
#endif
	}
	// Invalid Bitmap Size (small -- 10x10)
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Init Test Bitmap
		BBitmap testBmp(BRect(0,0,9,9), B_CMAP8);
		fill_bitmap(testBmp, 3);
		// Test Set()
		CHK(testBmp != *helper.Bitmap1());
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(helper.SetIcon(mime, &testBmp) != B_OK);	// R5 == B_BAD_VALUE
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(*bmp != testBmp);
		// Test Get()
		fill_bitmap(testBmp, 3);
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, &testBmp) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Invalid Bitmap Size (large -- 100x100)
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Init Test Bitmap
		BBitmap testBmp(BRect(0,0,99,99), B_CMAP8);
		// Test Set()
		fill_bitmap(testBmp, 3);
		CHK(testBmp != *helper.Bitmap1());
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(helper.SetIcon(mime, &testBmp) != B_OK);	// R5 == B_BAD_VALUE
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(*bmp != testBmp);
		// Test Get()
		fill_bitmap(testBmp, 3);
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, &testBmp) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Non-B_CMAP8 Color Depth (not really supported under R5)
	NextSubTest();
	{
#if !TEST_R5
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Init Test Bitmap
		BBitmap testBmp(helper.BitmapBounds(), B_RGB32);
		// Test Set()
//		fill_bitmap(testBmp, 4);
		fill_bitmap32(testBmp, 10, 20, 30, 40);				// Fill our 32-bit bitmap
		BBitmap testBmp8(helper.BitmapBounds(), B_CMAP8);	// Create an 8-bit bitmap the same size
//		dump_bitmap(testBmp8);
		reduce_color_depth(testBmp, testBmp8);				// Make it an 8-bit version of the 32-bit bitmap
//		dump_bitmap(testBmp8);
		CHK(testBmp != *helper.Bitmap1());
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		CHK(helper.SetIcon(mime, &testBmp) == B_OK);
			// R5 == B_OK, despite being invalid color depth; however, icon is not actually set,
			// and any subsequent call to GetIcon() will cause the application to crash...
		CHK(helper.GetIcon(mime, bmp) == B_OK);	// R5 == CRASH!, Haiku == Damn right I can handle that shit
		CHK(*bmp != *helper.Bitmap1());
		CHK(*bmp != testBmp);				// Shouldn't match, since SetIcon() reduces to B_CMAP8
		CHK(*bmp == testBmp8);				// *Should* match, since it's the result of a similar reduction
#endif
	}
	// Normal Function
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Set() then Get()
		fill_bitmap(*bmp, 3);
		CHK(*bmp != *helper.Bitmap1());
		CHK(helper.SetIcon(mime, helper.Bitmap1()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		// Set() then Get() again
		fill_bitmap(*bmp, 3);
		CHK(helper.SetIcon(mime, helper.Bitmap2()) == B_OK);
		CHK(helper.GetIcon(mime, bmp) == B_OK);
		CHK(*bmp == *helper.Bitmap2());
		CHK(*bmp != *helper.Bitmap1());
	}
}

// Icon For Type Helper Functions

void
MimeTypeTest::IconForTypeTest(IconForTypeHelper &helper) {
	IconTest(helper);	// First run all the icon tests
		// Then do some IconForType() specific tests

	BBitmap *bmp = helper.TempBitmap();

	// Invalid MIME string
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Set() then Get()
		fill_bitmap(*bmp, 3);
		CHK(*bmp != *helper.Bitmap1());
		CHK(mime.SetIconForType(testTypeInvalid, helper.Bitmap1(), helper.Size()) != B_OK);	// R5 == B_BAD_VALUE
		CHK(mime.GetIconForType(testTypeInvalid, bmp, helper.Size()) != B_OK);				// R5 == B_BAD_VALUE
		CHK(*bmp != *helper.Bitmap1());
	}
	// NULL MIME string (just like calling respective {Get,Set}Icon() function)
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		// Set() then Get()
		fill_bitmap(*bmp, 3);
		CHK(*bmp != *helper.Bitmap1());
		CHK(mime.SetIconForType(NULL, helper.Bitmap1(), helper.Size()) == B_OK);
		CHK(mime.GetIconForType(NULL, bmp, helper.Size()) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		// Verify GetIcon() does the same thing
		fill_bitmap(*bmp, 3);
		CHK(*bmp != *helper.Bitmap1());
		CHK(mime.GetIcon(bmp, helper.Size()) == B_OK);
		CHK(*bmp == *helper.Bitmap1());
		// Delete with dual NULL calls
		CHK(mime.SetIconForType(NULL, NULL, helper.Size()) == B_OK);
		CHK(mime.GetIconForType(NULL, bmp, helper.Size()) != B_OK);	// B_ENTRY_NOT_FOUND
		CHK(mime.GetIcon(bmp, helper.Size()) != B_OK);				// B_ENTRY_NOT_FOUND
	}
}

void
MimeTypeTest::LargeIconTest() {
	IconHelper helper(B_LARGE_ICON);
	IconTest(helper);
}

void
MimeTypeTest::MiniIconTest() {
	IconHelper helper(B_MINI_ICON);
	IconTest(helper);
}

void
MimeTypeTest::LargeIconForTypeTest() {
	IconForTypeHelper helper(testType, B_LARGE_ICON);
	IconForTypeTest(helper);
}

void
MimeTypeTest::MiniIconForTypeTest() {
	IconForTypeHelper helper(testType, B_MINI_ICON);
	IconForTypeTest(helper);
}

bool isMIMESupertype(const char *type) {
	BMimeType sub, super;
	status_t err;
	err = !type || !BMimeType::IsValid(type);

	// See if the type is the same as it's supertype
	if (!err)
		err = sub.SetTo(type);
	if (!err)
		return sub.GetSupertype(&super) == B_BAD_VALUE;
			// This is what R5::GetSupertype() returns when called on a supertype;

	return false;
}

void
MimeTypeTest::VerifyInstalledTypes() {
	// Check GetInstalledTypes(1)
	NextSubTest();
	{
		BMessage msg;

		// Get the list of installed types
		CHK(BMimeType::GetInstalledTypes(&msg) == B_OK);

		// Add all the type strings to a std::set
		std::set<std::string> typeSet;
		SetAdapter typeAdapter(typeSet);
		FillWithMimeTypes(typeAdapter, msg, "types");

		// Manually verify that the set of types returned by GetInstalledTypes()
		// and the types present in the database are exactly the same (ignoring
		// any files with names made of invalid characters, in case some bozo
		// manually added such a file :-)
		BDirectory rootDir(mimeDatabaseDir.c_str());
		BEntry superEntry;
		CHK(rootDir.InitCheck() == B_OK);
		rootDir.Rewind();
		while (true) {
			status_t err = rootDir.GetNextEntry(&superEntry);
			if (err == B_ENTRY_NOT_FOUND)
				break;	// End of directory listing

			CHK(!err);	// Any other error is unacceptable :-)

			// Get the leaf name
			char superLeafMixed[B_PATH_NAME_LENGTH+1];
			CHK(superEntry.GetName(superLeafMixed) == B_OK);
			std::string superLeaf;
			to_lower(superLeafMixed, superLeaf);

			// We're only interested in directories, as they map to
			// supertypes (and since they map thusly, they must also
			// be valid MIME strings)
			if (superEntry.IsDirectory() && BMimeType::IsValid(superLeaf.c_str())) {
				// First, find and remove the supertype from our set
				CHK(typeSet.find(superLeaf.c_str()) != typeSet.end());
				typeSet.erase(superLeaf.c_str());

				// Second, iterate through all the entries in the directory.
				// If the entry designates a valid MIME string, find it
				// in the set and remove it.
				BDirectory superDir(&superEntry);
				BEntry subEntry;
				CHK(superDir.InitCheck() == B_OK);
				superDir.Rewind();
				while (true) {
					status_t err = superDir.GetNextEntry(&subEntry);
					if (err == B_ENTRY_NOT_FOUND)
						break;	// End of directory listing

					CHK(!err);	// Any other error is unacceptable :-)

					// Get the leaf name
					char subLeafMixed[B_PATH_NAME_LENGTH+1];
					CHK(subEntry.GetName(subLeafMixed) == B_OK);
					std::string subLeaf;
					to_lower(subLeafMixed, subLeaf);

					// Verify it's a valid mime string. If so, find and remove from our set
					std::string subType = superLeaf + "/" + subLeaf;
					if (BMimeType::IsValid(subType.c_str())) {
						if (typeSet.find(subType.c_str()) == typeSet.end())
							cout << "Fuckup == '" << subType << "'" << endl;
						CHK(typeSet.find(subType.c_str()) != typeSet.end());
						typeSet.erase(subType.c_str());
					}
				}
			}
		}

		// At this point our set should be empty :-) If it's not, you might check
		// that you haven't added any superfluous files to your MIME database (like
		// a __mime_table backup, for instance).
		CHK(typeSet.size() == 0);
	}
	NextSubTest();
	// Check GetInstalledTypes(2) and GetInstalledSupertypes()
	{
		BMessage msg;

		// Get the list of installed types
		CHK(BMimeType::GetInstalledSupertypes(&msg) == B_OK);
//		msg.PrintToStream();

		// Add all the type strings to a std::set
		std::set<std::string> typeSet;
		SetAdapter typeAdapter(typeSet);
		FillWithMimeTypes(typeAdapter, msg, "super_types");

		// Manually verify that the set of types returned by GetInstalledSupertypes()
		// and the types present in the database are exactly the same (ignoring
		// any files with names made of invalid characters, in case some bozo
		// manually added such a file :-)
		BDirectory rootDir(mimeDatabaseDir.c_str());
		BEntry superEntry;
		CHK(rootDir.InitCheck() == B_OK);
		rootDir.Rewind();
		while (true) {
			status_t err = rootDir.GetNextEntry(&superEntry);
			if (err == B_ENTRY_NOT_FOUND)
				break;	// End of directory listing

			CHK(!err);	// Any other error is unacceptable :-)

			// Get the leaf name
			char superLeafMixed[B_PATH_NAME_LENGTH+1];
			CHK(superEntry.GetName(superLeafMixed) == B_OK);
			std::string superLeaf;
			to_lower(superLeafMixed, superLeaf);

			// We're only interested in directories, as they map to
			// supertypes (and since they map thusly, they must also
			// be valid MIME strings)
			if (superEntry.IsDirectory() && BMimeType::IsValid(superLeaf.c_str())) {
				// First, find and remove the supertype from our set
				CHK(typeSet.find(superLeaf.c_str()) != typeSet.end());
				typeSet.erase(superLeaf.c_str());

				// Second, get the list of corresponding subtypes and add them
				// to a std::set to be used for verification
				BMessage msg;
				CHK(BMimeType::GetInstalledTypes(superLeaf.c_str(), &msg) == B_OK);
//				msg.PrintToStream();

				std::set<std::string> subtypeSet;
				SetAdapter subtypeAdapter(subtypeSet);
				FillWithMimeTypes(subtypeAdapter, msg, "types");

				// Third, iterate through all the entries in the directory.
				// If the entry designates a valid MIME string, find it
				// in the subtype set and remove it.
				BDirectory superDir(&superEntry);
				BEntry subEntry;
				CHK(superDir.InitCheck() == B_OK);
				superDir.Rewind();
				while (true) {
					status_t err = superDir.GetNextEntry(&subEntry);
					if (err == B_ENTRY_NOT_FOUND)
						break;	// End of directory listing

					CHK(!err);	// Any other error is unacceptable :-)

					// Get the leaf name
					char subLeafMixed[B_PATH_NAME_LENGTH+1];
					CHK(subEntry.GetName(subLeafMixed) == B_OK);
					std::string subLeaf;
					to_lower(subLeafMixed, subLeaf);

					// Verify it's a valid mime string. If so, find and remove from our set
					std::string subType = superLeaf + "/" + subLeaf;
					if (BMimeType::IsValid(subType.c_str())) {
						CHK(subtypeSet.find(subType.c_str()) != subtypeSet.end());
						subtypeSet.erase(subType.c_str());
					}
				}

				// At this point our subtype set should be empty :-)
				CHK(subtypeSet.size() == 0);

			}
		}

		// At this point our set should be empty :-)
		CHK(typeSet.size() == 0);
	}

}

void
MimeTypeTest::InstalledTypesTest() {
	// NULL params
	{
		BMessage msg;
		NextSubTest();

#if !TEST_R5
		CHK(BMimeType::GetInstalledTypes(NULL) != B_OK);			// R5 == CRASH!!!, Haiku == B_BAD_VALUE
#endif
		NextSubTest();
#if !TEST_R5
		CHK(BMimeType::GetInstalledTypes("text", NULL) != B_OK);	// R5 == CRASH!!!, Haiku == B_BAD_VALUE
#endif
		NextSubTest();
		CHK(BMimeType::GetInstalledTypes(NULL, &msg) == B_OK);		// Same as GetInstalledTypes(&msg)
// 		msg.PrintToStream();
		NextSubTest();
#if !TEST_R5
		CHK(BMimeType::GetInstalledTypes(NULL, NULL) != B_OK);		// R5 == CRASH!!!, Haiku == B_BAD_VALUE
#endif
		NextSubTest();
#if !TEST_R5
		CHK(BMimeType::GetInstalledSupertypes(NULL) != B_OK);		// R5 == CRASH!!!, Haiku == B_BAD_VALUE
#endif
	}
	// Invalid supertype param to GetInstalledTypes(char *super, BMessage*)
	{
		BMessage msg;
		NextSubTest();
		CHK(!BMimeType::IsValid(testTypeSuperInvalid));
		CHK(BMimeType::GetInstalledTypes(testTypeSuperInvalid, &msg) != B_OK);			// R5 == B_BAD_VALUE
		NextSubTest();
		CHK(BMimeType::IsValid(testTypeSuperValid));
		CHK(BMimeType::GetInstalledTypes(testTypeSuperValid, &msg) != B_OK);	// R5 == B_ENTRY_NOT_FOUND
	}
	// Normal Function -- GetInstalledTypes(BMessage*)
	// This test gets the list of installed types, then iterates through
	// the actual database directory listings and verifies they're identical.
	{
		VerifyInstalledTypes();
		BMimeType mime(testTypeApp1);
		CHK(mime.InitCheck() == B_OK);
		if (mime.IsInstalled()) {
			CHK(mime.Delete() == B_OK);
			VerifyInstalledTypes();
			CHK(mime.Install() == B_OK);
			VerifyInstalledTypes();
		} else {
			CHK(mime.Install() == B_OK);
			VerifyInstalledTypes();
			CHK(mime.Delete() == B_OK);
			VerifyInstalledTypes();
		}
	}
	// Normal Function -- GetInstalledSupertypes()/GetInstalledTypes(char*,BMessage*)
	// This test gets the list of installed super types, then iterates through
	// the actual database directory listings and verifies they're identical.

}

// Short Description

void
MimeTypeTest::ShortDescriptionTest() {
	DescriptionTest(&BMimeType::GetShortDescription, &BMimeType::SetShortDescription,
#if TEST_R5
					   NULL
#else
					   &BMimeType::DeleteShortDescription
#endif
	);
}

// Long Description

void
MimeTypeTest::LongDescriptionTest() {
	DescriptionTest(&BMimeType::GetLongDescription, &BMimeType::SetLongDescription,
#if TEST_R5
					   NULL
#else
					   &BMimeType::DeleteLongDescription
#endif
	);
}

// DescriptionTest Helper Function
void
MimeTypeTest::DescriptionTest(GetDescriptionFunc getDescr, SetDescriptionFunc setDescr,
							    DeleteDescriptionFunc deleteDescr)
{
	char str[B_MIME_TYPE_LENGTH+1];

	// Uninitialized
	NextSubTest();
	{
		str[0] = 0;
		BMimeType mime;
		CPPUNIT_ASSERT(mime.InitCheck() == B_NO_INIT);
		CPPUNIT_ASSERT((mime.*getDescr)(str) != B_OK);	// R5 == B_BAD_VALUE
		CPPUNIT_ASSERT((mime.*setDescr)(str) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Non-installed type
	NextSubTest();
	{
		str[0] = 0;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK((mime.*getDescr)(str) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK((mime.*setDescr)(testDescr) == B_OK);	// R5 == Installs (but doesn't set), B_OK
		CHK(mime.IsInstalled());
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr) == 0);
	}
	// Non-installed type, NULL params
	NextSubTest();
	{
#if !TEST_R5	// NOTE: These tests crash for R5::LongDescription calls but not for R5::ShortDescription
				// calls. Considering the general instability exihibited by most R5 calls when passed
				// NULL pointers, however, I wouldn't suggest it, and thus they aren't even tested here.
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK((mime.*getDescr)(NULL) == B_BAD_VALUE);
		CHK(!mime.IsInstalled());
		CHK((mime.*setDescr)(NULL) == B_ENTRY_NOT_FOUND);	// Trying to delete non-existent attribute
		CHK(!mime.IsInstalled());
		CHK((mime.*setDescr)(testDescr) == B_OK);
		CHK(mime.IsInstalled());
		str[0] = 0;
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr) == 0);
		CHK((mime.*setDescr)(NULL) == B_OK);	// Delete the attribute
		CHK(mime.IsInstalled());
		CHK((mime.*getDescr)(str) == B_ENTRY_NOT_FOUND);
#endif
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK((mime.*deleteDescr)() != B_OK);
		CHK(!mime.IsInstalled());
		CHK((mime.*setDescr)(testDescr) == B_OK);
		CHK(mime.IsInstalled());
		str[0] = 0;
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr) == 0);
		CHK((mime.*deleteDescr)() == B_OK);
		CHK(mime.IsInstalled());
		CHK((mime.*getDescr)(str) != B_OK);
#endif
	}
	// Installed type
	NextSubTest();
	{
		str[0] = 0;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		// Get() with no description installed
		CHK(mime.IsInstalled());
		CHK((mime.*getDescr)(str) == B_ENTRY_NOT_FOUND);	// R5 == B_ENTRY_NOT_FOUND
		// Initial Set()/Get()
		CHK((mime.*setDescr)(testDescr) == B_OK);
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr) == 0);
		// Followup Set()/Get()
		CHK((mime.*setDescr)(testDescr2) == B_OK);
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr2) == 0);
	}
	// Installed Type, Description Too Long
	NextSubTest();
	{
		str[0] = 0;
		CHK(strlen(longDescr) > (B_MIME_TYPE_LENGTH+1));
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		// Initial Set()/Get()
		CHK((mime.*setDescr)(longDescr) != B_OK);		// R5 == B_BAD_VALUE
		CHK((mime.*getDescr)(str) == B_ENTRY_NOT_FOUND);
		// Followup Set()/Get()
		CHK((mime.*setDescr)(testDescr) == B_OK);
		CHK((mime.*setDescr)(longDescr) != B_OK);		// R5 == B_BAD_VALUE
		CHK((mime.*getDescr)(str) == B_OK);
		CHK(strcmp(str, testDescr) == 0);
	}

}


// Preferred App

void
MimeTypeTest::PreferredAppTest() {
	char str[B_MIME_TYPE_LENGTH+1];
	sprintf(str, "%s", testSig);

	// Uninitialized
	NextSubTest();
	{
		BMimeType mime;
		CPPUNIT_ASSERT(mime.InitCheck() == B_NO_INIT);
		CPPUNIT_ASSERT(mime.GetPreferredApp(str) != B_OK);	// R5 == B_BAD_VALUE
		CPPUNIT_ASSERT(mime.SetPreferredApp(str) != B_OK);	// R5 == B_BAD_VALUE
	}
	// Non-installed type
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.GetPreferredApp(str) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetPreferredApp(testSig) == B_OK);	// R5 == Installs (but doesn't set), B_OK
		CHK(mime.IsInstalled());
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig) == 0);
	}
	// Non-installed type, NULL params
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
#if TEST_R5
		CHK(!mime.IsInstalled());
		CHK(mime.GetPreferredApp(NULL) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetPreferredApp(NULL) != B_OK);		// R5 == Installs (but doesn't set), B_ENTRY_NOT_FOUND
		CHK(mime.IsInstalled());
		CHK(mime.GetPreferredApp(str) == B_ENTRY_NOT_FOUND);
#else
		CHK(!mime.IsInstalled());
		CHK(mime.GetPreferredApp(NULL) != B_OK);		// Haiku == B_BAD_VALUE
		CHK(!mime.IsInstalled());
		CHK(mime.SetPreferredApp(NULL) != B_OK);		// Haiku == B_ENTRY_NOT_FOUND
		CHK(!mime.IsInstalled());
		CHK(mime.SetPreferredApp(testSig) == B_OK);
		CHK(mime.IsInstalled());
		str[0] = 0;
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig) == 0);
		CHK(mime.SetPreferredApp(NULL) == B_OK);
		CHK(mime.IsInstalled());
		str[0] = 0;
		CHK(mime.GetPreferredApp(str) != B_OK);			// Haiku == B_ENTRY_NOT_FOUND
#endif // !TEST_R5
	}
	// Installed type, NULL params
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetPreferredApp(NULL) != B_OK);		// R5 == B_BAD_ADDRESS
		CHK(mime.SetPreferredApp(NULL) != B_OK);		// R5 == B_ENTRY_NOT_FOUND
		CHK(mime.GetPreferredApp(NULL) != B_OK);		// R5 == B_BAD_ADDRESS
	}
	// Delete test
	NextSubTest();
	{
#if !TEST_R5
		entry_ref ref;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Make sure the type isn't installed
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.DeletePreferredApp() != B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.SetPreferredApp(testSig) == B_OK);
		CHK(mime.IsInstalled());
		str[0] = 0;
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig) == 0);
		CHK(mime.DeletePreferredApp() == B_OK);
		CHK(mime.IsInstalled());
		CHK(mime.GetPreferredApp(str) != B_OK);
#endif
	}
	// Installed type
	NextSubTest();
	{
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		// Get() with no description installed
		CHK(mime.IsInstalled());
		CHK(mime.GetPreferredApp(str) == B_ENTRY_NOT_FOUND);	// R5 == B_ENTRY_NOT_FOUND
		// Initial Set()/Get()
		CHK(mime.SetPreferredApp(testSig) == B_OK);
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig) == 0);
		// Followup Set()/Get()
		CHK(mime.SetPreferredApp(testSig2) == B_OK);
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig2) == 0);
	}
	// Installed Type, Signature Too Long
	NextSubTest();
	{
		CHK(strlen(longDescr) > (B_MIME_TYPE_LENGTH+1));
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		// Uninstall then reinstall to clear attributes
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		// Initial Set()/Get()
		CHK(mime.SetPreferredApp(longSig) != B_OK);		// R5 == B_BAD_VALUE
		CHK(mime.GetPreferredApp(str) == B_ENTRY_NOT_FOUND);
		// Followup Set()/Get()
		CHK(mime.SetPreferredApp(testSig) == B_OK);
		CHK(mime.SetPreferredApp(longSig) != B_OK);		// R5 == B_BAD_VALUE
		CHK(mime.GetPreferredApp(str) == B_OK);
		CHK(strcmp(str, testSig) == 0);
	}

}

// Converts every character in str to lowercase and places
// the result in result.
void
to_lower(const char *str, std::string &result) {
	CHK(str != NULL);
	result = "";
	for (uint i = 0; i < strlen(str); i++)
		result += tolower(str[i]);
}

std::string
to_lower(const char *str) {
	std::string result;
	to_lower(str, result);
	return result;
}


// Manually removes the file in the MIME database corresponding to
// the given MIME type
void
remove_type(const char *type, const char *databaseDir) {
	CHK(type != NULL);

	// Since the MIME types are converted to lower case before their
	// corresponding file is created in the database, we need to do
	// the same
	std::string typeLower;
	to_lower(type, typeLower);

	BEntry entry((std::string(mimeDatabaseDir) + "/" + typeLower).c_str());
	CHK(entry.InitCheck() == B_OK);
	if (entry.Exists())
		CHK(entry.Remove() == B_OK);
	CHK(!entry.Exists());
}

// Manually verifies that the file in the MIME database corresponding to
// the given MIME type exists
bool
type_exists(const char *type, const char *databaseDir) {
	CHK(type != NULL);

	// Since the MIME types are converted to lower case before their
	// corresponding file is created in the database, we need to do
	// the same
	std::string typeLower;
	to_lower(type, typeLower);

	BEntry entry((std::string(databaseDir) + "/" + typeLower).c_str());
	CHK(entry.InitCheck() == B_OK);
	return entry.Exists();
}

void
MimeTypeTest::InstallDeleteTest() {
	// Uninitialzized
	NextSubTest();
	{
		BMimeType mime;
		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(!mime.IsInstalled());
		CHK(mime.Install() != B_OK);	// R5 == B_BAD_VALUE
		CHK(mime.Delete() != B_OK);	// R5 == B_BAD_VALUE
	}
	// Invalid Type String
	NextSubTest();
	{
		BMimeType mime(testTypeInvalid);
		CHK(mime.InitCheck() != B_OK);	// R5 == B_BAD_VALUE
		CHK(!mime.IsInstalled());
		CHK(mime.Install() != B_OK);	// R5 == B_BAD_VALUE
		CHK(mime.Delete() != B_OK);	// R5 == B_BAD_VALUE
	}
	// Normal function
	NextSubTest();
	{
		remove_type(testType);
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		CHK(!mime.IsInstalled());
		CHK(mime.Delete() != B_OK);	// R5 == B_ENTRY_NOT_FOUND, Haiku == B_ENTRY_NOT_FOUND
		CHK(!type_exists(testType));
		CHK(mime.Install() == B_OK);
		CHK(type_exists(testType));
		CHK(mime.IsInstalled());
#if !TEST_R5
		CHK(mime.Install() != B_OK);	// We ought to return something standard and logical here, as R5 is random
#endif
		CHK(mime.Delete() == B_OK);
		CHK(!type_exists(testType));
		CHK(!mime.IsInstalled());
	}

}

void FillWithMimeTypes(ContainerAdapter &container, BMessage &typeMessage, const char* fieldName) {
	type_code type;
	int32 count;
	status_t err;

//	typeMessage.PrintToStream();

	// Get a count of types in the message
	err = typeMessage.GetInfo(fieldName, &type, &count);
	if (err == B_NAME_NOT_FOUND)
		count = 0;			// No such types installed in the database! :-)
	else
		CHK(err == B_OK);	// Any other error is unacceptable

	// Add them all to the container, after converting to lowercase and
	// checking validity
	for (int i = 0; i < count; i++) {
		char *str;
		CHK(typeMessage.FindString(fieldName, i, (const char**)&str) == B_OK);
		std::string strLower;
		to_lower(str, strLower);
		// Make sure it's a valid type string, since the R5::GetInstalled*Types()
		// functions do no such verification, and we ignore invalid type files
		// in the database.
		if (BMimeType::IsValid(strLower.c_str()))
			container.Add(strLower);
	}
}

bool
types_fields_are_identical(const BMessage &msg1, const BMessage &msg2)
{
	const char *str1;
	const char *str2;
	int i = 0;
	bool result = true;
	while (true) {
		status_t err1 = msg1.FindString(typesField, i, &str1);
		status_t err2 = msg2.FindString(typesField, i, &str2);
		if (err1 != err2) {
			result = false;
			break;
		}
		if (err1 != B_OK)
			break;
		result &= to_lower(str1) == to_lower(str2);
		i++;
	}
	return result;
}

bool
is_supporting_app_for_all_types_in_message(const char *app, const BMessage &msg)
{
	const char *str;
	bool result = true;
	for (int i = 0; msg.FindString(typesField, i, &str) == B_OK; i++) {
		BMimeType supportedType(str);
		BMessage appMsg;

		// Get a list of supporting apps
		CHK(supportedType.InitCheck() == B_OK);
		CHK(supportedType.GetSupportingApps(&appMsg) == B_OK);
//		cout << "-----------------------------------------------------------" << endl;
//		cout << str << endl;
//		cout << "-----------------------------------------------------------" << endl;
//		appMsg.PrintToStream();

		// Look for our supporting app
		int32 directlySupportingAppsCount;
		CHK(appMsg.FindInt32("be:sub", &directlySupportingAppsCount) == B_OK);
		bool foundType = false;
		const char *supportingApp;
		for (int j = 0;
			   j < directlySupportingAppsCount
			     && appMsg.FindString(applicationsField, &supportingApp) == B_OK;
			       j++)
		{
			foundType |= to_lower(app) == to_lower(supportingApp);
		}
		result &= foundType;
	}
	return result;
}

void
MimeTypeTest::SupportedTypesTest() {
#if TEST_R5
	Outputf("(no tests actually performed for R5 version)\n");
#else
	// Create some messages to sling around
	const int32 WHAT = 0;
	BMessage msg1a(WHAT), msg1b(WHAT), msg2(WHAT), msg3(WHAT), msgEmpty(WHAT);

	CHK(msg3.AddString(typesField, testType1) == B_OK);
	CHK(msg3.AddString(typesField, testType2) == B_OK);
	CHK(msg3.AddString(typesField, testType3) == B_OK);

	CHK(msg2.AddString(typesField, testType2) == B_OK);
	CHK(msg2.AddString(typesField, testType3) == B_OK);

	CHK(msg1a.AddString(typesField, testType5) == B_OK);

	CHK(msg1b.AddString(typesField, testType2) == B_OK);

	CHK(msg1a == msg1a);
	CHK(msg1b == msg1b);
	CHK(msg2 == msg2);
	CHK(msg3 == msg3);
	CHK(msg1a != msg2);
	CHK(msg1a != msg3);
	CHK(msg1a != msgEmpty);

	// Uninitialized
	NextSubTest();
	{
		BMimeType mime;
		BMessage msg;

		CHK(mime.InitCheck() == B_NO_INIT);
		CHK(mime.SetSupportedTypes(&msg, true) != B_OK);
		CHK(mime.SetSupportedTypes(&msg, false) != B_OK);
		CHK(mime.GetSupportedTypes(&msg) != B_OK);
		CHK(mime.DeleteSupportedTypes() != B_OK);
	}

	// Test that deleting a type from the database also removes
	// the app as a supporting app for all types it previously
	// supported
	NextSubTest();
	{
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);

		// Set a list of supported types
		CHK(mime.SetSupportedTypes(&msg3, true) == B_OK);

		// Verify that each of those types now lists the
		// type as a directly supporting app
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == true);

		// Delete the type
		CHK(mime.Delete() == B_OK);

		// Verify that each of those types no longer lists the
		// type as a directly supporting app
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == false);
	}

	// Test that SetSupportedTypes(..., false) does not remove the app as a supporting
	// app for newly unsupported types, while SetSupportedTypes(..., true) does. Also
	// test that supported types stranded by multiple sequential calls to
	// SetSupportedTypes(..., false) are properly updated so as to no longer list the
	// app as a supporting app once SetSupportedTypes(..., true) is finally called.
	NextSubTest();
	{
		BMessage msg;
		BMimeType mime(testType);
		CHK(mime.InitCheck() == B_OK);

		// Uninstall then reinstall to clear attributes, etc
		if (mime.IsInstalled())
			CHK(mime.Delete() == B_OK);
		if (!mime.IsInstalled())
			CHK(mime.Install() == B_OK);
		CHK(mime.IsInstalled());

		// Set a list of supported types
		CHK(mime.SetSupportedTypes(&msg3, true) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_OK);
		CHK(types_fields_are_identical(msg3, msg) == true);
		CHK(types_fields_are_identical(msg2, msg) == false);
		CHK(types_fields_are_identical(msg1a, msg) == false);
		CHK(types_fields_are_identical(msg1b, msg) == false);
		CHK(types_fields_are_identical(msgEmpty, msg) == false);

		// Verify that each of those types now lists the
		// type as a directly supporting app
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Set (no sync) to a new list of supported types containing one
		// fewer type than the original list
		CHK(mime.SetSupportedTypes(&msg2, false) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_OK);
		CHK(types_fields_are_identical(msg3, msg) == false);
		CHK(types_fields_are_identical(msg2, msg) == true);
		CHK(types_fields_are_identical(msg1a, msg) == false);
		CHK(types_fields_are_identical(msg1b, msg) == false);
		CHK(types_fields_are_identical(msgEmpty, msg) == false);

		// Verify that the app is still listed as a supporting app for
		// *all* of the originally supported types (even the one no longer
		// listed as being supported)
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Set (no sync) to a new list of supported types containing an
		// entirely new, never supported type
		CHK(mime.SetSupportedTypes(&msg1a, false) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_OK);
		CHK(types_fields_are_identical(msg3, msg) == false);
		CHK(types_fields_are_identical(msg2, msg) == false);
		CHK(types_fields_are_identical(msg1a, msg) == true);
		CHK(types_fields_are_identical(msg1b, msg) == false);
		CHK(types_fields_are_identical(msgEmpty, msg) == false);

		// Verify that the app is still listed as a supporting app for
		// *all* of the originally supported types (none of which are
		// supported any longer) as well as the newly supported type.
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Set (no sync) to a new list of supported types containing only
		// one of the originally supported types that had been previously
		// removed.
		CHK(mime.SetSupportedTypes(&msg1b, false) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_OK);
		CHK(types_fields_are_identical(msg3, msg) == false);
		CHK(types_fields_are_identical(msg2, msg) == false);
		CHK(types_fields_are_identical(msg1a, msg) == false);
		CHK(types_fields_are_identical(msg1b, msg) == true);
		CHK(types_fields_are_identical(msgEmpty, msg) == false);

		// Verify that the app is still listed as a supporting app for
		// *all* of the originally supported types (only one of which is
		// supported any longer) as well as the previous supported type.
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == true);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Set (with sync) to the same list as last time (containing the
		// one type from the original list of supported types)
		CHK(mime.SetSupportedTypes(&msg1b, true) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_OK);
		CHK(types_fields_are_identical(msg3, msg) == false);
		CHK(types_fields_are_identical(msg2, msg) == false);
		CHK(types_fields_are_identical(msg1a, msg) == false);
		CHK(types_fields_are_identical(msg1b, msg) == true);
		CHK(types_fields_are_identical(msgEmpty, msg) == false);

		// Verify that the app is now only listed as a supporting app for the
		// most recently supported type.
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Test SetSupportedTypes(NULL, false) for shits and giggles
		CHK(mime.SetSupportedTypes(NULL, false) == B_OK);
		CHK(mime.GetSupportedTypes(&msg) == B_ENTRY_NOT_FOUND);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == true);

		// Now test that SetSupportedTypes(NULL, true) updates the supporting
		// apps mappings, even if the supported types attribute has already
		// been removed.
		CHK(mime.SetSupportedTypes(NULL, true) == B_ENTRY_NOT_FOUND);
		CHK(mime.GetSupportedTypes(&msg) == B_ENTRY_NOT_FOUND);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg3) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg2) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1a) == false);
		CHK(is_supporting_app_for_all_types_in_message(testType, msg1b) == false);
	}
#endif	// #if TEST_R5 else
}

void
MimeTypeTest::SupportingAppsTest() {
/*	{
		BMessage msg;
		BMimeType::GetInstalledTypes(&msg);
		msg.PrintToStream();
	}
	{
		BMessage msg;
		BMimeType mime("application/octet-stream");
		CHK(mime.InitCheck() == B_OK);
		CHK(mime.GetSupportingApps(&msg) == B_OK);
		msg.PrintToStream();
	}
	{
		BMessage msg;
		BMimeType mime("text");
		CHK(mime.InitCheck() == B_OK);
		CHK(mime.GetSupportingApps(&msg) == B_OK);
		msg.PrintToStream();
	}
	{
		BMessage msg;
		BMimeType mime("text/html");
		CHK(mime.InitCheck() == B_OK);
		CHK(mime.GetSupportingApps(&msg) == B_OK);
		msg.PrintToStream();
	} */
	NextSubTest();
	if (true)
	{
		std::set<std::string> typeList;							// Stores all installed MIME types
		std::set<std::string> appList;							// Stores all installed application subtypes
		std::map< std::string, std::set<std::string> > typeAppMap;	// Stores mapping of types to apps that support them
		std::map< std::string, std::set<std::string> > fakeTypeAppMap;	// Used to keep timing info for R5 and Haiku tests orthogonal

		// Get a list of all the types in the database
		{
			BMessage msg;
			CHK(BMimeType::GetInstalledTypes(&msg) == B_OK);
			SetAdapter typeAdapter(typeList);
			FillWithMimeTypes(typeAdapter, msg, "types");
		}

		// Get a list of all the apps in the database
		{
			BMessage msg;
			CHK(BMimeType::GetInstalledTypes(applicationSupertype, &msg) == B_OK);
			SetAdapter appAdapter(appList);
			FillWithMimeTypes(appAdapter, msg, "types");
		}

		// For each app in the database, manually get a list of the MIME types
		// it supports by reading its META:FILE_TYPES attribute from the database,
		// and add the app to the type->app map for each such type
		{
			std::set<std::string>::iterator i;
			for (i = appList.begin(); i != appList.end(); i++) {
				// Grab the next application
				std::string app = *i;

				// The leaf is all we're interested in -- it's the subtype
//				CHK(StorageKit::split_path(app.c_str(), dir, leaf) == B_OK);
				std::string appFile = std::string(mimeDatabaseDir) + "/" + app;
//				printf("'%s'\n", appFile.c_str());
				BNode node(appFile.c_str());
				CHK(node.InitCheck() == B_OK);

				// Find out how much data there is in the META:FILE_TYPES attribute
				// (assuming it even exists, which it may not...)
				attr_info info;
				if (node.GetAttrInfo("META:FILE_TYPES", &info) == B_OK) {
//					printf("attr_info: type == %lx, size == %lld\n", info.type, info.size);
					// Attribute exists, so alloc a buffer and read it
					char *buffer = new char[info.size+1];
					CHK(node.ReadAttr("META:FILE_TYPES", B_MESSAGE_TYPE, 0, buffer, info.size) == info.size);
					BMessage msg;
					if (msg.Unflatten(buffer) == B_OK) {
//						msg.PrintToStream();

						// Fill up a list with all the supported types
						std::set<std::string> supportList;
						SetAdapter supportAdapter(supportList);
						FillWithMimeTypes(supportAdapter, msg, "types");

						// For each type, add the current application as a supporting
						// app in our type->apps map
						for (std::set<std::string>::iterator type = supportList.begin();
								type != supportList.end();
									type++)
						{
							NextSubTest();
							typeAppMap[*type].insert(app);
							fakeTypeAppMap[*type].insert(app);
						}
					} else {
						// Just in case some bozo writes something other than a flattened
						// BMessage to the META:FILE_TYPES attribute, we'll only issue a
						// warning when the BMessage can't unflatten itself
						printf("Warning: Unable to unflatten META:FILE_TYPES attribute for '%s' type.\n",
							app.c_str());
					}

					delete buffer;

				}
			}
		}

//#if !TEST_R5
		// Now, add in all the types listed in MIME_DB_DIR/__mime_table
		{
			BEntry entry((std::string(mimeDatabaseDir) + "/__mime_table").c_str());
			CHK(entry.InitCheck() == B_OK);
			if (entry.Exists()) {
				BFile file(&entry, B_READ_ONLY);
				CHK(file.InitCheck() == B_OK);
				BMessage msg;
				CHK(msg.Unflatten(&file) == B_OK);

//				msg.PrintToStream();

				char *type;
				uint32 typeVal;
				int32 count;
				for (int i = 0; msg.GetInfo(B_STRING_TYPE, i, &type, &typeVal, &count) == B_OK; i++ ) {
					// Add all the associated applications. Interestingly (or maybe not),
					// any types appearing ONLY in the __mime_table and not in the mime
					// database fail when GetSupportingApps is called on them. Thus, we
					// add them to the type->app map, but not to the list of types.
					const char *app;
					for (int j = 0; j < count; j++) {
						CHK(msg.FindString(type, j, &app) == B_OK);
#if TEST_R5
						typeAppMap[type].insert(to_lower(app));
#else
						fakeTypeAppMap[type].insert(to_lower(app));
#endif
					}
				}
			}
		}
//#endif

		// For each installed type, get a list of the supported apps, and
		// verify that the list matches the list we generated. Also check
		// that the list of apps for the type's supertype (if it exists)
		// is a subset of the list we generated for said supertype.
		for (std::set<std::string>::iterator i = typeList.begin(); i != typeList.end(); i++) {
			// Get the current type
			std::string type = *i;
			BMimeType mime(type.c_str());
			CHK(mime.InitCheck() == B_OK);
//			printf("------------------------------------------------------------\n");
//			printf("%s\n", type.c_str());

			// Get the set of supporting apps for this type (and its supertype, if
			// it's not a supertype itself) that we discovered by manually culling
			// the database
			std::set<std::string> appSetSuper;
			BMimeType superType;
			if (mime.GetSupertype(&superType) == B_OK)
				appSetSuper = typeAppMap[superType.Type()];		// Copy the supertype
/*
			printf("sub.size == %ld\n", appSet.size());
			std::set<std::string>::iterator i;
			for (i = appSet.begin(); i != appSet.end(); i++) {
				printf("  %s\n", (*i).c_str());
			}
			printf("super.size == %ld\n", appSetSuper.size());
			for (i = appSetSuper.begin(); i != appSetSuper.end(); i++) {
				printf("  %s\n", (*i).c_str());
			}
			char* str;
			if (mime.GetPreferredApp(str) == B_OK) {
				printf("preferred app:\n");
				printf("  %s\n", str);
			}
*/
			// Get the set of supporting apps via GetSupportingApps(), then
			// add them to a list.
			BMessage msg;
			CHK(mime.GetSupportingApps(&msg) == B_OK);
			std::queue<std::string> appList;
			QueueAdapter appAdapter(appList);
			FillWithMimeTypes(appAdapter, msg, "applications");

//			msg.PrintToStream();


		}
	}
}

void
MimeTypeTest::WildcardAppsTest() {
	// NULL param
	NextSubTest();
	{
#if TEST_R5
		CHK(BMimeType::GetWildcardApps(NULL) == B_OK);			// R5 == B_OK (???)
#else
		CHK(BMimeType::GetWildcardApps(NULL) == B_BAD_VALUE);
#endif
	}
	// Normal function (compare to BMimeType("application/octet-stream").GetSupportingApps())
	NextSubTest();
	{
		BMessage msg1, msg2;
		CHK(BMimeType::GetWildcardApps(&msg1) == B_OK);
		BMimeType mime(wildcardType);
		CHK(mime.InitCheck() == B_OK);
		CHK(mime.GetSupportingApps(&msg2) == B_OK);
		CHK(msg1 == msg2);
	}
}


// init_long_types
static
void
init_long_types(char *notTooLongType, char *tooLongType)
{
// R5: Allows buffer sizes up to `B_MIME_TYPE_LENGTH + 1'
// Haiku: We stay consistent: `*_LENGTH' defines the buffer size.
#ifdef TEST_R5
	const int notTooLongLength = B_MIME_TYPE_LENGTH;
#else
	const int notTooLongLength = B_MIME_TYPE_LENGTH - 1;
#endif
	const int tooLongLength = notTooLongLength + 1;
	strcpy(notTooLongType, "image/");
	memset(notTooLongType + strlen(notTooLongType), 'a',
		   notTooLongLength - strlen(notTooLongType));
	notTooLongType[notTooLongLength] = '\0';
	strcpy(tooLongType, "image/");
	memset(tooLongType + strlen(tooLongType), 'a',
		   tooLongLength - strlen(tooLongType));
	tooLongType[tooLongLength] = '\0';
}

// InitTest
void
MimeTypeTest::InitTest()
{
	// tests:
	// * constructors
	// * SetTo(), SetType()
	// * Unset()
	// * InitCheck()
	// (* Type())

	// We test only a few types here. Exhausting testing is done in
	// ValidityTest().
	const char *validType	= "image/gif";
	const char *validType2	= "application/octet-stream";
	const char *invalidType	= "invalid type";
	char notTooLongType[B_MIME_TYPE_LENGTH + 3];
	char tooLongType[B_MIME_TYPE_LENGTH + 3];
	init_long_types(notTooLongType, tooLongType);

	// default constructor
	NextSubTest();
	{
		BMimeType type;
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}

	// BMimeType(const char *)
	// valid type
	NextSubTest();
	{
		BMimeType type(validType);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == validType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// invalid type
	NextSubTest();
	{
		BMimeType type(invalidType);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// long, but not too long type
	NextSubTest();
	{
		BMimeType type(notTooLongType);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == notTooLongType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// too long type
	NextSubTest();
	{
		BMimeType type(tooLongType);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}

	// SetTo()
	// valid type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetTo(validType) == B_OK);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == validType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// invalid type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetTo(invalidType) == B_BAD_VALUE);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// long, but not too long type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetTo(notTooLongType) == B_OK);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == notTooLongType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// too long type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetTo(tooLongType) == B_BAD_VALUE);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}

	// SetType()
	// valid type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetType(validType) == B_OK);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == validType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// invalid type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetType(invalidType) == B_BAD_VALUE);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// long, but not too long type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetType(notTooLongType) == B_OK);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == notTooLongType);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}
	// too long type
	NextSubTest();
	{
		BMimeType type;
		CHK(type.SetType(tooLongType) == B_BAD_VALUE);
		CHK(type.InitCheck() == B_BAD_VALUE);
		CHK(type.Type() == NULL);
		type.Unset();
		CHK(type.InitCheck() == B_NO_INIT);
		CHK(type.Type() == NULL);
	}

	// reinitialization
	NextSubTest();
	{
		BMimeType type(validType);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == validType);
		CHK(type.SetTo(validType2) == B_OK);
		CHK(type.InitCheck() == B_OK);
		CHK(string(type.Type()) == validType2);
	}
	// bad args
	NextSubTest();
	{
		BMimeType type(NULL);
		CHK(type.Type() == NULL);
		CHK(type.InitCheck() != B_OK);		// R5 == B_NO_INIT, Haiku == B_BAD_VALUE
		CHK(type.Type() == NULL);
		CHK(type.SetTo(NULL) != B_OK);		// R5 == B_NO_INIT, Haiku == B_BAD_VALUE
		CHK(type.Type() == NULL);
		CHK(type.SetType(NULL) != B_OK);	// R5 == B_NO_INIT, Haiku == B_BAD_VALUE
		CHK(type.Type() == NULL);
	}
}

// StringTest
void
MimeTypeTest::StringTest()
{
	// tests:
	// * IsValid() (static/non static)
	// * Type()
	// * IsSupertypeOnly()
	// * GetSupertype()
	// * Contains()
	// * operator==()

	char notTooLongType[B_MIME_TYPE_LENGTH + 3];
	char tooLongType[B_MIME_TYPE_LENGTH + 3];
	init_long_types(notTooLongType, tooLongType);
	struct mime_type_test {
		const char	*type;
		bool		super_type;
		status_t	error;
	};
	mime_type_test tests[] = {
		// valid types
		{ "application",					true,	B_OK, },
		{ "application/octet-stream",		false,	B_OK, },
		{ "audio",							true,	B_OK, },
		{ "audio/x-aiff",					false,	B_OK, },
		{ "image",							true,	B_OK, },
		{ "image/gif",						false,	B_OK, },
		{ "message",						true,	B_OK, },
		{ "message/rfc822",					false,	B_OK, },
		{ "multipart",						true,	B_OK, },
		{ "multipart/mixed",				false,	B_OK, },
		{ "text",							true,	B_OK, },
		{ "text/plain",						false,	B_OK, },
		{ "video",							true,	B_OK, },
		{ "video/x-msvideo",				false,	B_OK, },
		{ "unknown",						true,	B_OK, },
		{ "unknown/mime-type",				false,	B_OK, },
		{ "$%&./`'~*+#|!^",					false,	B_OK, },
		// invalid types
		{ "",								false,	B_BAD_VALUE, },
		{ "application/",					false,	B_BAD_VALUE, },
		{ "audio/",							false,	B_BAD_VALUE, },
		{ "image/",							false,	B_BAD_VALUE, },
		{ "message/",						false,	B_BAD_VALUE, },
		{ "multipart/",						false,	B_BAD_VALUE, },
		{ "text/",							false,	B_BAD_VALUE, },
		{ "video/",							false,	B_BAD_VALUE, },
		{ "unknown/",						false,	B_BAD_VALUE, },
		{ "/gif",							false,	B_BAD_VALUE, },
		{ "image/very/nice",				false,	B_BAD_VALUE, },
		{ "tex t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla in",					false,	B_BAD_VALUE, },
		{ "tex\tt/plain",					false,	B_BAD_VALUE, },
		{ "text/pla\tin",					false,	B_BAD_VALUE, },
		{ "tex\nt/plain",					false,	B_BAD_VALUE, },
		{ "text/pla\nin",					false,	B_BAD_VALUE, },
		{ "tex<t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla<in",					false,	B_BAD_VALUE, },
		{ "tex>t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla>in",					false,	B_BAD_VALUE, },
		{ "tex@t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla@in",					false,	B_BAD_VALUE, },
		{ "tex,t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla,in",					false,	B_BAD_VALUE, },
		{ "tex;t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla;in",					false,	B_BAD_VALUE, },
		{ "tex:t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla:in",					false,	B_BAD_VALUE, },
		{ "tex\"t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla\"in",					false,	B_BAD_VALUE, },
		{ "tex(t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla(in",					false,	B_BAD_VALUE, },
		{ "tex)t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla)in",					false,	B_BAD_VALUE, },
		{ "tex[t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla[in",					false,	B_BAD_VALUE, },
		{ "tex]t/pla]in",					false,	B_BAD_VALUE, },
		{ "tex?t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla?in",					false,	B_BAD_VALUE, },
		{ "tex=t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla=in",					false,	B_BAD_VALUE, },
		{ "tex\\t/plain",					false,	B_BAD_VALUE, },
		{ "text/pla\\in",					false,	B_BAD_VALUE, },
		// (not) too long types
		{ notTooLongType,					false,	B_OK, },
		{ tooLongType,						false,	B_BAD_VALUE, },
	};
	int32 testCount = sizeof(tests) / sizeof(mime_type_test);
	// test loop
	for (int32 i = 0; i < testCount; i++) {
		NextSubTest();
		mime_type_test &test = tests[i];
		BMimeType type(test.type);
		CHK(type.InitCheck() == test.error);
		bool valid = (test.error == B_OK);
		bool validSuper = (valid && test.super_type);
		// Type()
		if (valid)
			CHK(string(type.Type()) == test.type);
		else
			CHK(type.Type() == NULL);
		// IsValid(), IsSuperTypeOnly()
		CHK(type.IsValid() == valid);
		CHK(type.IsSupertypeOnly() == validSuper);
		CHK(BMimeType::IsValid(test.type) == valid);
		// GetSupertype()
		if (valid && !validSuper) {
			BMimeType super;
			CHK(type.GetSupertype(&super) == B_OK);
			CHK(super.InitCheck() == B_OK);
			CHK(super.Contains(&type) == true);
			BString typeString(test.type);
			BString superString(typeString.String(),
								typeString.FindFirst('/'));
			CHK(superString == super.Type());
		} else {
			BMimeType super;
			CHK(type.GetSupertype(&super) == B_BAD_VALUE);
		}
		// Contains(), ==
		for (int32 k = 0; k < testCount; k++) {
			mime_type_test &test2 = tests[k];
			BMimeType type2(test2.type);
			CHK(type2.InitCheck() == test2.error);
			bool valid2 = (test2.error == B_OK);
			bool validSuper2 = (valid && test2.super_type);
			bool equal = (!strcmp(test.type, test2.type));
			// ==
			if (valid || valid2) {
				CHK((type == type2) == equal);
				CHK((type == test2.type) == equal);
			} else {
				CHK((type == type2) == false);
				CHK((type == test2.type) == false);
			}
			// Contains()
			if (valid || valid2) {
				if (equal)
					CHK(type.Contains(&type2) == true);
				else if (validSuper && valid2 && !validSuper2) {
					BMimeType super2;
					CHK(type2.GetSupertype(&super2) == B_OK);
					bool contains = string(super2.Type()) == type.Type();
					CHK(type.Contains(&type2) == contains);
				} else
					CHK(type.Contains(&type2) == false);
			} else
				CHK(type.Contains(&type2) == false);
		}
	}
	// bad args
	NextSubTest();
	{
		BMimeType type("image/gif");
// R5: crashes when passing NULL
#if !TEST_R5
		CHK(BMimeType::IsValid(NULL) == false);
		CHK(type.GetSupertype(NULL) == B_BAD_VALUE);
		CHK(type.Contains(NULL) == false);
#endif
		CHK((type == NULL) == false);
	}
}

// an easy to construct equivalent of a notification message
class NotificationMessage {
public:
	NotificationMessage(int32 which, string type, string extraType,
						bool largeIcon)
		: which(which), type(type), hasExtraType(true), extraType(extraType),
		  hasLargeIcon(true), largeIcon(largeIcon)
	{
	}

	NotificationMessage(int32 which, string type, string extraType)
		: which(which), type(type), hasExtraType(true), extraType(extraType),
		  hasLargeIcon(false), largeIcon(false)
	{
	}

	NotificationMessage(int32 which, string type, bool largeIcon)
		: which(which), type(type), hasExtraType(false), extraType(),
		  hasLargeIcon(true), largeIcon(largeIcon)
	{
	}

	NotificationMessage(int32 which, string type)
		: which(which), type(type), hasExtraType(false), extraType(),
		  hasLargeIcon(false), largeIcon(false)
	{
	}

public:
	int32	which;
	string	type;
	bool	hasExtraType;
	string	extraType;
	bool	hasLargeIcon;
	bool	largeIcon;
};

// FillAttrInfo
static
void
FillAttrInfo(BMessage &info, int32 variation = 0)
{
	switch (variation) {
		case 0:
		default:
			CHK(info.AddString("attr:name", "attribute1") == B_OK);
			CHK(info.AddString("attr:public_name", "Nice Attribute1") == B_OK);
			CHK(info.AddInt32("attr:type", B_STRING_TYPE) == B_OK);
			CHK(info.AddBool("attr:public", true) == B_OK);
			CHK(info.AddBool("attr:editable", true) == B_OK);
			break;
		case 1:
			CHK(info.AddString("attr:name", "attribute2") == B_OK);
			CHK(info.AddString("attr:public_name", "Nice Attribute2") == B_OK);
			CHK(info.AddInt32("attr:type", B_BOOL_TYPE) == B_OK);
			CHK(info.AddBool("attr:public", false) == B_OK);
			CHK(info.AddBool("attr:editable", false) == B_OK);
			break;
	}
}

// MonitoringTest
void
MimeTypeTest::MonitoringTest()
{
	// tests:
	// * Start/StopWatching()
	// * updates

	// test:
	// * StartWatching()
	// * change something, check message queue (not empty)
	//   - add type
	//   - set icon, preferred app, attr info, file ext., short/long desc.,
	//     icon for, app hint, sniffer rule
	//   - remove type
	// * StopWatching(anotherTarget)
	// * change something, check message queue (not empty)
	// * StopWatching()
	// * change something, check message queue (empty)

	CHK(fApplication != NULL);
	NextSubTest();
	// StartWatching()
	BMessenger target(&fApplication->Handler(), fApplication);
	CHK(BMimeType::StartWatching(target) == B_OK);
	// install
	BMimeType type(testType);
	CHK(type.InitCheck() == B_OK);
	CHK(type.IsInstalled() == false);
	CHK(type.Install() == B_OK);
	// icon
	IconHelper iconHelperLarge(B_LARGE_ICON);
	IconHelper iconHelperMini(B_MINI_ICON);
	CHK(type.SetIcon(iconHelperLarge.Bitmap1(), B_LARGE_ICON) == B_OK);
	CHK(type.SetIcon(iconHelperMini.Bitmap1(), B_MINI_ICON) == B_OK);
	// preferred app
	CHK(type.SetPreferredApp(testTypeApp) == B_OK);
	// attr info
	BMessage attrInfo;
	FillAttrInfo(attrInfo);
	CHK(type.SetAttrInfo(&attrInfo) == B_OK);
	// file extensions
	BMessage extensions;
	CHK(extensions.AddString("extensions", "arg") == B_OK);
	CHK(extensions.AddString("extensions", "ugh") == B_OK);
	CHK(type.SetFileExtensions(&extensions) == B_OK);
	// long/short description
	CHK(type.SetLongDescription("quite short for a long description") == B_OK);
	CHK(type.SetShortDescription("short description") == B_OK);
	// icon for type
	CHK(type.SetIconForType("text/plain", iconHelperLarge.Bitmap1(),
							B_LARGE_ICON) == B_OK);
	CHK(type.SetIconForType("text/plain", iconHelperMini.Bitmap1(),
							B_MINI_ICON) == B_OK);
	// app hint
	entry_ref appHintRef;
	CHK(get_ref_for_path("/boot/beos/apps/StyledEdit", &appHintRef) == B_OK);
	CHK(type.SetAppHint(&appHintRef) == B_OK);
	// sniffer rule
	const char *snifferRule = "0.5 [0:0] ('ARGH')";
	CHK(type.SetSnifferRule(snifferRule) == B_OK);
	{
	//   - set icon, preferred app, attr info, file ext., short/long desc.,
	//     icon for, app hint, sniffer rule
		typedef NotificationMessage NM;
		NotificationMessage messages[] = {
			NM(B_MIME_TYPE_CREATED, testType),
			NM(B_ICON_CHANGED, testType, true),
			NM(B_ICON_CHANGED, testType, false),
			NM(B_PREFERRED_APP_CHANGED, testType),
			NM(B_ATTR_INFO_CHANGED, testType),
			NM(B_FILE_EXTENSIONS_CHANGED, testType),
			NM(B_LONG_DESCRIPTION_CHANGED, testType),
			NM(B_SHORT_DESCRIPTION_CHANGED, testType),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", true),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", false),
			NM(B_APP_HINT_CHANGED, testType),
			NM(B_SNIFFER_RULE_CHANGED, testType),
		};
		CheckNotificationMessages(messages, sizeof(messages) / sizeof(NM));
	}

	// set the same values once again
	NextSubTest();
	// icon
	CHK(type.SetIcon(iconHelperLarge.Bitmap1(), B_LARGE_ICON) == B_OK);
	CHK(type.SetIcon(iconHelperMini.Bitmap1(), B_MINI_ICON) == B_OK);
	// preferred app
	CHK(type.SetPreferredApp(testTypeApp) == B_OK);
	// attr info
	CHK(type.SetAttrInfo(&attrInfo) == B_OK);
// file extensions
	CHK(extensions.AddString("extensions", "arg") == B_OK);
	CHK(extensions.AddString("extensions", "ugh") == B_OK);
	CHK(type.SetFileExtensions(&extensions) == B_OK);
	// long/short description
	CHK(type.SetLongDescription("quite short for a long description") == B_OK);
	CHK(type.SetShortDescription("short description") == B_OK);
	// icon for type
	CHK(type.SetIconForType("text/plain", iconHelperLarge.Bitmap1(),
							B_LARGE_ICON) == B_OK);
	CHK(type.SetIconForType("text/plain", iconHelperMini.Bitmap1(),
							B_MINI_ICON) == B_OK);
	// app hint
	CHK(type.SetAppHint(&appHintRef) == B_OK);
	// sniffer rule
	CHK(type.SetSnifferRule(snifferRule) == B_OK);
	{
	//   - set icon, preferred app, attr info, file ext., short/long desc.,
	//     icon for, app hint, sniffer rule
		typedef NotificationMessage NM;
		NotificationMessage messages[] = {
			NM(B_ICON_CHANGED, testType, true),
			NM(B_ICON_CHANGED, testType, false),
			NM(B_PREFERRED_APP_CHANGED, testType),
			NM(B_ATTR_INFO_CHANGED, testType),
			NM(B_FILE_EXTENSIONS_CHANGED, testType),
			NM(B_LONG_DESCRIPTION_CHANGED, testType),
			NM(B_SHORT_DESCRIPTION_CHANGED, testType),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", true),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", false),
			NM(B_APP_HINT_CHANGED, testType),
			NM(B_SNIFFER_RULE_CHANGED, testType),
		};
		CheckNotificationMessages(messages, sizeof(messages) / sizeof(NM));
	}

	// set different values
	NextSubTest();
	// icon
	CHK(type.SetIcon(iconHelperLarge.Bitmap2(), B_LARGE_ICON) == B_OK);
	CHK(type.SetIcon(iconHelperMini.Bitmap2(), B_MINI_ICON) == B_OK);
	// preferred app
	CHK(type.SetPreferredApp("application/x-vnd.Be-STEE") == B_OK);
	// attr info
	BMessage attrInfo2;
	FillAttrInfo(attrInfo2, 1);
	CHK(type.SetAttrInfo(&attrInfo2) == B_OK);
	// file extensions
	CHK(extensions.AddString("extensions", "uff") == B_OK);
	CHK(extensions.AddString("extensions", "err") == B_OK);
	CHK(type.SetFileExtensions(&extensions) == B_OK);
	// long/short description
	CHK(type.SetLongDescription("not that short description") == B_OK);
	CHK(type.SetShortDescription("pretty short description") == B_OK);
	// icon for type
	CHK(type.SetIconForType("text/plain", iconHelperLarge.Bitmap2(),
							B_LARGE_ICON) == B_OK);
	CHK(type.SetIconForType("text/plain", NULL,
							B_LARGE_ICON) == B_OK);
	CHK(type.SetIconForType("text/plain", iconHelperMini.Bitmap2(),
							B_MINI_ICON) == B_OK);
	// app hint
	entry_ref appHintRef2;
	CHK(get_ref_for_path("/boot/beos/apps/NetPositive", &appHintRef2) == B_OK);
	CHK(type.SetAppHint(&appHintRef2) == B_OK);
	// sniffer rule
	const char *snifferRule2 = "0.7 [0:5] ('YEAH!')";
	CHK(type.SetSnifferRule(snifferRule2) == B_OK);
	// delete
	CHK(type.Delete() == B_OK);
	{
	//   - set icon, preferred app, attr info, file ext., short/long desc.,
	//     icon for, app hint, sniffer rule
		typedef NotificationMessage NM;
		NotificationMessage messages[] = {
			NM(B_ICON_CHANGED, testType, true),
			NM(B_ICON_CHANGED, testType, false),
			NM(B_PREFERRED_APP_CHANGED, testType),
			NM(B_ATTR_INFO_CHANGED, testType),
			NM(B_FILE_EXTENSIONS_CHANGED, testType),
			NM(B_LONG_DESCRIPTION_CHANGED, testType),
			NM(B_SHORT_DESCRIPTION_CHANGED, testType),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", true),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", true),
			NM(B_ICON_FOR_TYPE_CHANGED, testType, "text/plain", false),
			NM(B_APP_HINT_CHANGED, testType),
			NM(B_SNIFFER_RULE_CHANGED, testType),
			NM(B_MIME_TYPE_DELETED, testType),
		};
		CheckNotificationMessages(messages, sizeof(messages) / sizeof(NM));
	}

	// StopWatching() and try again -- no messages should be sent anymore
	CHK(BMimeType::StopWatching(target) == B_OK);
	// install
	CHK(type.InitCheck() == B_OK);
	CHK(type.IsInstalled() == false);
	CHK(type.Install() == B_OK);
	// icon
	CHK(type.SetIcon(iconHelperLarge.Bitmap1(), B_LARGE_ICON) == B_OK);
	CHK(type.SetIcon(iconHelperMini.Bitmap1(), B_MINI_ICON) == B_OK);
	// preferred app
	CHK(type.SetPreferredApp(testTypeApp) == B_OK);
	// attr info
	CHK(type.SetAttrInfo(&attrInfo) == B_OK);
	// file extensions
	CHK(extensions.AddString("extensions", "arg") == B_OK);
	CHK(extensions.AddString("extensions", "ugh") == B_OK);
	CHK(type.SetFileExtensions(&extensions) == B_OK);
	// long/short description
	CHK(type.SetLongDescription("quite short for a long description") == B_OK);
	CHK(type.SetShortDescription("short description") == B_OK);
	// icon for type
	CHK(type.SetIconForType("text/plain", iconHelperLarge.Bitmap1(),
							B_LARGE_ICON) == B_OK);
	CHK(type.SetIconForType("text/plain", iconHelperMini.Bitmap1(),
							B_MINI_ICON) == B_OK);
	// app hint
	CHK(type.SetAppHint(&appHintRef) == B_OK);
	// sniffer rule
	CHK(type.SetSnifferRule(snifferRule) == B_OK);
	// delete
	CHK(type.Delete() == B_OK);
	{
		CheckNotificationMessages(NULL, 0);
	}

	// bad args
	// StopWatching() another target
	NextSubTest();
	// install
	CHK(type.InitCheck() == B_OK);
	CHK(type.IsInstalled() == false);
	CHK(type.Install() == B_OK);
	// try to start/stop watching with an invalid target, stop the wrong target
	BMessenger target2(fApplication);
	CHK(target2.IsValid() == true);
	BMessenger target3("application/does-not_exist");
	CHK(target3.IsValid() == false);
// R5: An invalid messenger is fine for any reason?!
#if !TEST_R5
	CHK(BMimeType::StartWatching(target3) == B_BAD_VALUE);
#endif
	CHK(BMimeType::StartWatching(target) == B_OK);
#if !TEST_R5
	CHK(BMimeType::StopWatching(target3) == B_BAD_VALUE);
#endif
	CHK(BMimeType::StopWatching(target2) != B_OK);	// R5 == B_BAD_VALUE, Haiku == B_ENTRY_NOT_FOUND
	CHK(BMimeType::StopWatching(target) == B_OK);
	// delete
	CHK(type.Delete() == B_OK);
}

// CheckNotificationMessage
void
MimeTypeTest::CheckNotificationMessages(const NotificationMessage *messages,
										int32 count)
{
	// wait for the messages
	snooze(100000);
	if (fApplication) {
		BMessageQueue &queue = fApplication->Handler().Queue();
		CPPUNIT_ASSERT( queue.Lock() );
		try {
			int32 messageNum = 0;
			while (BMessage *_message = queue.NextMessage()) {
				BMessage message(*_message);
				delete _message;
//printf("\nmessage: %ld\n", messageNum);
//message.PrintToStream();
				CPPUNIT_ASSERT( messageNum < count );
				const NotificationMessage &entry = messages[messageNum];
				CPPUNIT_ASSERT( message.what == B_META_MIME_CHANGED );
				// which
				int32 which;
				CPPUNIT_ASSERT( message.FindInt32("be:which", &which)
								== B_OK );
				CPPUNIT_ASSERT( entry.which == which );
				// type
				const char *type;
				CPPUNIT_ASSERT( message.FindString("be:type", &type) == B_OK );
				CPPUNIT_ASSERT( entry.type == type );
				// extra type
				const char *extraType;
				if (entry.hasExtraType) {
					CPPUNIT_ASSERT( message.FindString("be:extra_type",
													   &extraType) == B_OK);
					CPPUNIT_ASSERT( entry.extraType == extraType );
				} else {
					CPPUNIT_ASSERT( message.FindString("be:extra_type",
										&extraType) == B_NAME_NOT_FOUND);
				}
				// large icon
				bool largeIcon;
				if (entry.hasLargeIcon) {
					CPPUNIT_ASSERT( message.FindBool("be:large_icon",
													 &largeIcon) == B_OK);
					CPPUNIT_ASSERT( entry.largeIcon == largeIcon );
				} else {
					CPPUNIT_ASSERT( message.FindBool("be:large_icon",
										&largeIcon) == B_NAME_NOT_FOUND);
				}
				messageNum++;
			}
			CPPUNIT_ASSERT( messageNum == count );
		} catch (CppUnit::Exception exception) {
			queue.Unlock();
			throw exception;
		}
		queue.Unlock();
	}
}

// helper class for update_mime_info() tests
class MimeInfoTestFile {
public:
	MimeInfoTestFile(string name, string type, const void *data = NULL,
					 int32 size = -1)
		: name(name),
		  type(type),
		  data(NULL),
		  size(0)
	{
		if (data) {
			if (size == -1)
				this->size = strlen((const char*)data) + 1;
			else
				this->size = size;
			this->data = new char[this->size];
			memcpy(this->data, data, this->size);
		}
	}

	~MimeInfoTestFile()
	{
		delete[] data;
	}

	status_t Create()
	{
		BFile file(name.c_str(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		status_t error = file.InitCheck();
		if (error == B_OK && data) {
			ssize_t written = file.Write(data, size);
			if (written < 0)
				error = written;
			else if (written != size)
				error = B_ERROR;
		}
		return error;
	}

	status_t Delete()
	{
		return BEntry(name.c_str()).Remove();
	}

	string	name;
	string	type;
	char	*data;
	int32	size;
};

// UpdateMimeInfoTest
void
MimeTypeTest::UpdateMimeInfoTest()
{
// Uncomment the following lines to enjoy the quiet time provided
// by a nice, full mime update. :-)

//	cout << "begin..." << endl;
//	CHK(update_mime_info(NULL, true, true, false) == B_OK);
//	cout << "end..." << endl;

	// tests:
	// * update_mime_info()

	// Note:
	// * Only synchronous calls are tested.
	// * Updating all files is not tested as it takes too long.

	// individual files
	execCommand(string("mkdir ") + testDir + "/subdir1 "
				+ testDir + "/subdir2 "
				+ testDir + "/subdir2/subsubdir1");
	MimeInfoTestFile files[] = {
		MimeInfoTestFile(string(testDir) + "/file1.cpp", "text/x-source-code"),
		MimeInfoTestFile(string(testDir) + "/subdir1/file1.gif", "image/gif"),
		MimeInfoTestFile(string(testDir) + "/subdir2/subsubdir1/file1",
						 "text/html", "<html>\n<body>\n</body></html>\n")
	};
	int fileCount = sizeof(files) / sizeof(MimeInfoTestFile);
	// synchronous
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		MimeInfoTestFile &file = files[i];
		// no recursion
		CHK(file.Create() == B_OK);
		CHK(update_mime_info(file.name.c_str(), false, true, false) == B_OK);
		BNode node(file.name.c_str());
		CHK(node.InitCheck() == B_OK);
		BString type;
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
		CHK(type == file.type.c_str());
		CHK(file.Delete() == B_OK);
		// recursion
		CHK(file.Create() == B_OK);
		CHK(update_mime_info(file.name.c_str(), true, true, false) == B_OK);
		CHK(node.SetTo(file.name.c_str()) == B_OK);
		type = "";
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
		CHK(type == file.type.c_str());
		CHK(file.Delete() == B_OK);
	}

//------------------------------------------------------------------------------
// Asynchronous calls
//------------------------------------------------------------------------------

	const bigtime_t kSnoozeTime = 500000;
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		MimeInfoTestFile &file = files[i];
		// no recursion
		CHK(file.Create() == B_OK);
		CHK(update_mime_info(file.name.c_str(), false, false, false) == B_OK);
		// give the system some time to do the update asynchronously
		snooze(kSnoozeTime);
		BNode node(file.name.c_str());
		CHK(node.InitCheck() == B_OK);
		BString type;
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
		CHK(type == file.type.c_str());
		CHK(file.Delete() == B_OK);
		// recursion
		CHK(file.Create() == B_OK);
		CHK(update_mime_info(file.name.c_str(), true, false, false) == B_OK);
		// give the system some time to do the update asynchronously
		snooze(kSnoozeTime);
		CHK(node.SetTo(file.name.c_str()) == B_OK);
		type = "";
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
		CHK(type == file.type.c_str());
		CHK(file.Delete() == B_OK);
	}

// TODO: The BeBook says: "if force is true, files are updated even if they've
// been updated already."
// As I understand this, calling update_mime_info() with force == true on a
// file, should set the BEOS:TYPE attribute regardless of whether it already
// had a value. The following test shows, that BEOS:TYPE remains unchanged
// though.
#if TEST_OBOS
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
//printf("file: %s\n", file.name.c_str());
		CHK(file.Create() == B_OK);
		// add a type attribute
		BNode node(file.name.c_str());
		CHK(node.InitCheck() == B_OK);
		BString type("text/plain");
		CHK(node.WriteAttrString("BEOS:TYPE", &type) == B_OK);
		// update, force == false
		CHK(update_mime_info(file.name.c_str(), false, true, false) == B_OK);
		type = "";
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		CHK(type == "text/plain");
		// update, force == true
		CHK(update_mime_info(file.name.c_str(), false, true, true) == B_OK);
		type = "";
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
//printf("%s <-> %s\n", type.String(), file.type.c_str());
		CHK(type == file.type.c_str());
		CHK(file.Delete() == B_OK);
	}
#endif	// TEST_OBOS

	// directory
	NextSubTest();
	// create
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
		CHK(file.Create() == B_OK);
	}
	// update, not recursive
	CHK(update_mime_info(testDir, false, true, false) == B_OK);
	// check
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
		BNode node(file.name.c_str());
		CHK(node.InitCheck() == B_OK);
		BString type;
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_ENTRY_NOT_FOUND);
	}
	// delete, re-create
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
		CHK(file.Delete() == B_OK);
		CHK(file.Create() == B_OK);
	}
	// update, recursive
	CHK(update_mime_info(testDir, true, true, false) == B_OK);
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
		BNode node(file.name.c_str());
		CHK(node.InitCheck() == B_OK);
		BString type;
		CHK(node.ReadAttrString("BEOS:TYPE", &type) == B_OK);
		node.Unset();
		CHK(type == file.type.c_str());
	}
	// delete
	for (int32 i = 0; i < fileCount; i++) {
		MimeInfoTestFile &file = files[i];
		CHK(file.Delete() == B_OK);
	}

	// bad args: non-existing file
	NextSubTest();
	BEntry entry(files[0].name.c_str());
	CHK(entry.InitCheck() == B_OK);
	CHK(entry.Exists() == false);
//#if TEST_R5
	CHK(update_mime_info(files[0].name.c_str(), false, true, false) == B_OK);
//#else
//	CHK(update_mime_info(files[0].name.c_str(), false, true, false) == B_ENTRY_NOT_FOUND);
//#endif
}

// WriteStringAttr
static
status_t
WriteStringAttr(BNode &node, string name, string _value)
{
	// Wrapper for BNode::WriteAttrString() taking string rather than
	// const char*/BString* parameters.
	BString value(_value.c_str());
	return node.WriteAttrString(name.c_str(), &value);
}

const uint32 MINI_ICON_TYPE = 'MICN';
const uint32 LARGE_ICON_TYPE = 'ICON';

// helper class for create_app_meta_mime() tests
class AppMimeTestFile {
public:
	AppMimeTestFile(string name, string type, string signature,
					string snifferRule,
					const void *miniIcon = NULL, const void *largeIcon = NULL)
		: name(name),
		  type(type),
		  signature(signature),
		  snifferRule(snifferRule),
		  miniIcon(NULL),
		  largeIcon(NULL)
	{
		SetMiniIcon(miniIcon);
		SetLargeIcon(largeIcon);
	}

	~AppMimeTestFile()
	{
		SetMiniIcon(NULL);
		SetLargeIcon(NULL);
	}

	void SetMiniIcon(const void *icon)
	{
		if (miniIcon) {
			delete[] miniIcon;
			miniIcon = NULL;
		}
		if (icon) {
			miniIcon = new char[256];
			memcpy(miniIcon, icon, 256);
		}
	}

	void SetLargeIcon(const void *icon)
	{
		if (largeIcon) {
			delete[] largeIcon;
			largeIcon = NULL;
		}
		if (icon) {
			largeIcon = new char[1024];
			memcpy(largeIcon, icon, 1024);
		}
	}

	status_t Create(bool setAttributes, bool setResources)
	{
		BFile file(name.c_str(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		status_t error = file.InitCheck();
		// attributes
		if (error == B_OK && setAttributes) {
			// type
			if (type.length() > 0)
				error = WriteStringAttr(file, "BEOS:TYPE", type);
			// signature
			if (error == B_OK)
				error = WriteStringAttr(file, "BEOS:APP_SIG", signature);
			// sniffer rule
			if (error == B_OK)
				error = WriteStringAttr(file, "BEOS:SNIFF_RULE", snifferRule);
			// mini icon
			if (error == B_OK && miniIcon) {
				ssize_t written = file.WriteAttr("BEOS:M:STD_ICON",
												 MINI_ICON_TYPE, 0, miniIcon,
												 256);
				if (written < 0)
					error = written;
				else if (written != 256)
					error = B_ERROR;
			}
			// large icon (ignored)
			if (error == B_OK && largeIcon) {
				ssize_t written = file.WriteAttr("META:L:STD_ICON",
												 LARGE_ICON_TYPE, 0, largeIcon,
												 1024);
				if (written < 0)
					error = written;
				else if (written != 1024)
					error = B_ERROR;
			}
		}
		// resources
		if (error == B_OK && setResources) {
			BResources resources;
			error = resources.SetTo(&file, true);
			// type (ignored)
			if (error == B_OK && type.length() > 0) {
				error = resources.AddResource(B_STRING_TYPE, 2, type.c_str(),
											  type.length() + 1, "BEOS:TYPE");
			}
			// signature (ignored)
			if (error == B_OK) {
				error = resources.AddResource(B_STRING_TYPE, 1,
											  signature.c_str(),
											  signature.length() + 1,
											  "BEOS:APP_SIG");
			}
			// mini icon (ignored)
			if (error == B_OK && miniIcon) {
				error = resources.AddResource(MINI_ICON_TYPE, 101, miniIcon,
											  256, "BEOS:M:STD_ICON");
			}
			// file types (ignored)
			if (error == B_OK) {
				BMessage msg;
				char *buffer = NULL;
				error = msg.AddString("types", "text/x-email");
				if (!error)
					error = msg.AddString("types", "video/mpeg");
				if (!error) {
					buffer = new char[msg.FlattenedSize()];
					if (!buffer)
						error = B_NO_MEMORY;
				}
				if (!error)
					error = msg.Flatten(buffer, msg.FlattenedSize());
				if (!error)
					error = resources.AddResource(B_MESSAGE_TYPE, 1, buffer,
													msg.FlattenedSize(), "BEOS:FILE_TYPES");
				delete [] buffer;
			}
		}
		return error;
	}

	status_t Delete(bool deleteMimeType)
	{
		status_t error = BEntry(name.c_str()).Remove();
		if (error == B_OK && deleteMimeType) {
			BMimeType type;
			// the type need not necessarily exist
			error = type.SetTo(signature.c_str());
			if (error == B_OK && deleteMimeType && type.IsInstalled())
				error = type.Delete();
		}
		return error;
	}

	string	name;
	string	type;
	string	signature;
	string	snifferRule;
	char	*miniIcon;
	char	*largeIcon;
};

// CheckAppMetaMime
static
void
CheckAppMetaMime(AppMimeTestFile &file)
{
	BMimeType type;
	CHK(type.SetTo(file.signature.c_str()) == B_OK);
	CHK(type.IsInstalled() == true);
	// short description
	char shortDescription[B_MIME_TYPE_LENGTH + 1];
	CHK(type.GetShortDescription(shortDescription) == B_OK);
	BPath path(file.name.c_str(), NULL, true);
	CHK(string(path.Leaf()) == shortDescription);
	// preferred app
	char preferredApp[B_MIME_TYPE_LENGTH + 1];
	CHK(type.GetPreferredApp(preferredApp) == B_OK);
	CHK(file.signature == preferredApp);
	// META:PPATH
	BNode typeFile;
	string typeFilename(string(mimeDatabaseDir) + "/" + file.signature);
//	cout << "typeFilename == '" << typeFilename << "'" << endl;
	CHK(typeFile.SetTo(typeFilename.c_str()) == B_OK);
	char filePath[B_PATH_NAME_LENGTH + 1];
	CHK(typeFile.ReadAttr("META:PPATH", B_STRING_TYPE, 0, filePath,
						  B_PATH_NAME_LENGTH + 1) > 0);
	CHK(path == filePath);
	// mini icon
	if (file.miniIcon) {
		BBitmap icon(BRect(0, 0, 15, 15), B_CMAP8);
		CHK(type.GetIcon(&icon, B_MINI_ICON) == B_OK);
		CHK(memcmp(icon.Bits(), file.miniIcon, 256) == 0);
	}
	// large icon
/*	if (file.miniIcon) {
		BBitmap icon(BRect(0, 0, 31, 31), B_CMAP8);
		CHK(type.GetIcon(&icon, B_LARGE_ICON) == B_OK);
		CHK(memcmp(icon.Bits(), file.largeIcon, 1024) == 0);
	}*/
}

// CreateAppMetaMimeTest
void
MimeTypeTest::CreateAppMetaMimeTest()
{

// Uncomment the following lines to enjoy the quiet time provided by
// a nice, full create_app_meta_mime() update. :-)

//	cout << "begin..." << endl;
//	CHK(create_app_meta_mime(NULL, true, true, false) == B_OK);
//	cout << "end" << endl;

	// tests:
	// * create_app_meta_mime()

	// Note:
	// * Only synchronous calls are tested.
	// * The recursive flag isn't tested -- the BeBook sais, it is unused.
	// * Updating all apps is not tested as it takes too long.

	// Create a couple of icons to play around with
	char miniIcon1[256];
	char miniIcon2[256];
	for (int ch = 0; ch < 256; ch++) {
		miniIcon1[ch] = ch;
		miniIcon2[ch] = 255-ch;
	}
	char largeIcon1[1024];
	char largeIcon2[1024];
	for (int i = 0; i < 1024; i++) {
		char ch = i % 256;
		largeIcon1[i] = ch;
		largeIcon2[i] = 255-ch;
	}

	// attributes and resources
	NextSubTest();
	execCommand(string("mkdir ") + testDir + "/subdir1 "
				+ testDir + "/subdir2 "
				+ testDir + "/subdir2/subsubdir1");
	AppMimeTestFile files[] = {
		// AppMimeTestFile(name, type, sig, rule, miniIcon, largeIcon)
		AppMimeTestFile(string(testDir) + "/file1",
						"",
						"application/x-vnd.obos.mime.test.test1",
						"0.0 ('abc')",
						miniIcon1,
						NULL),
		AppMimeTestFile(string(testDir) + "/file2",
						"text/x-source-code",
						"application/x-vnd.obos.mime.test.test2",
						"0.0 ('xyz')",
						miniIcon2,
						largeIcon2),
		AppMimeTestFile(string(testDir) + "/file3",
						"application/x-vnd.Be-elfexecutable",
						"application/x-vnd.obos.mime.test.test3",
						"0.0 ('rst')",
						NULL,
						largeIcon1),
	};
	const int fileCount = sizeof(files) / sizeof(AppMimeTestFile);
//------------------------------------------------------------------------------
// Synchronous calls
//------------------------------------------------------------------------------
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file);
		// clean up
		CHK(file.Delete(true) == B_OK);
	}
//	snooze(999000000);

	// attributes only
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(true, false) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file);
		// clean up
		CHK(file.Delete(true) == B_OK);
	}

	// resources only
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(false, true) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		BMimeType type;
		CHK(type.SetTo(file.signature.c_str()) == B_OK);
		CHK(type.IsInstalled() == false);
		// clean up
		CHK(file.Delete(false) == B_OK);
	}

//------------------------------------------------------------------------------
// Asynchronous calls
//------------------------------------------------------------------------------
	const bigtime_t kSnoozeTime = 500000;
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, false, false)
			== B_OK);
		// give the system some time to do the update asynchronously
		snooze(kSnoozeTime);
		// check the MIME type
		CheckAppMetaMime(file);
		// clean up
		CHK(file.Delete(true) == B_OK);
	}

	// attributes only
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(true, false) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, false, false)
			== B_OK);
		// give the system some time to do the update asynchronously
		snooze(kSnoozeTime);
		// check the MIME type
		CheckAppMetaMime(file);
		// clean up
		CHK(file.Delete(true) == B_OK);
	}

	// resources only
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		// create file, create_app_meta_mime()
		AppMimeTestFile &file = files[i];
		CHK(file.Create(false, true) == B_OK);
		CHK(create_app_meta_mime(file.name.c_str(), false, false, false)
			== B_OK);
		// give the system some time to do the update asynchronously
		snooze(kSnoozeTime);
		BMimeType type;
		CHK(type.SetTo(file.signature.c_str()) == B_OK);
		CHK(type.IsInstalled() == false);
		// clean up
		CHK(file.Delete(false) == B_OK);
	}


	// test the force flag
// TODO: The BeBook says: "If force is true, entries are created even if they
// already exist."
// As I understand this, re-calling create_app_meta_mime() with force == true,
// after modifying the original file (e.g. the mini icon attribute) or
// calling it on another file with the same signature, should update the
// database entry. But the following tests show, that this doesn't happen.
// They fail in the third CheckAppMetaMime().
#if !TEST_R5
	// same file, same signature, other parameters
	{
		char icon1[256];
		char icon2[256];
		memset(icon1, 1, 256);
		memset(icon2, 2, 256);
		AppMimeTestFile file1(string(testDir) + "/file1",
						"application/x-vnd.Be-elfexecutable",
						"application/x-vnd.obos.mime.test.test1",
						icon1);
		AppMimeTestFile file2(string(testDir) + "/file1",
						"application/x-vnd.Be-elfexecutable",
						"application/x-vnd.obos.mime.test.test1",
						icon2);
		// create file 1, create_app_meta_mime()
		CHK(file1.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file1.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file1);
		// create file 2, create_app_meta_mime(), no force
		CHK(file2.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file2.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file1);
		// create_app_meta_mime(), force
		CHK(create_app_meta_mime(file2.name.c_str(), false, true, true)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file2);
		// clean up
		CHK(file2.Delete(true) == B_OK);
	}
	// different file, same signature, other parameters
	{
		char icon1[256];
		char icon2[256];
		memset(icon1, 1, 256);
		memset(icon2, 2, 256);
		AppMimeTestFile file1(string(testDir) + "/file1",
						"application/x-vnd.Be-elfexecutable",
						"application/x-vnd.obos.mime.test.test1",
						icon1);
		AppMimeTestFile file2(string(testDir) + "/file2",
						"application/x-vnd.Be-elfexecutable",
						"application/x-vnd.obos.mime.test.test1",
						icon2);
		// create file 1, create_app_meta_mime()
		CHK(file1.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file1.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file1);
		// create file 2, create_app_meta_mime(), no force
		CHK(file2.Create(true, true) == B_OK);
		CHK(create_app_meta_mime(file2.name.c_str(), false, true, false)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file1);
		// create_app_meta_mime(), force
		CHK(create_app_meta_mime(file2.name.c_str(), false, true, true)
			== B_OK);
		// check the MIME type
		CheckAppMetaMime(file2);
		// clean up
		CHK(file1.Delete(true) == B_OK);
		CHK(file2.Delete(true) == B_OK);
	}
#endif	// !TEST_R5

	// bad args
	NextSubTest();
	// no signature
	CHK(files[0].Create(false, false) == B_OK);
	CHK(create_app_meta_mime(files[0].name.c_str(), false, true, false)
		== B_OK);
	CHK(files[0].Delete(false) == B_OK);
	// non-existing file
	CHK(create_app_meta_mime(files[0].name.c_str(), false, true, false)
		== B_OK);

}

// CheckIconData
static
void
CheckIconData(const char *device, int32 iconSize, const void* data)
{
	// open the device
	int fd = open(device, O_RDONLY);
	CHK(fd != -1);
	// get the icon
	char buffer[1024];
	device_icon iconData = {
		iconSize,
		buffer
	};
	int error = ioctl(fd, B_GET_ICON, &iconData);
	// close the device
	CHK(close(fd) == 0);
	CHK(error == 0);
	// compare the icon data
	CHK(memcmp(data, buffer, iconSize * iconSize) == 0);
}

// GetDeviceIconTest
void
MimeTypeTest::GetDeviceIconTest()
{
	// tests:
	// * get_device_icon()

	// test a volume device, a non-volume device, and an invalid dev name
	struct test_case {
		const char	*path;
		bool		valid;
	} testCases[] = {
		{ "/dev/zero", false },
		{ "/boot", true },
		{ "/boot/home", false }
	};
	const int testCaseCount = sizeof(testCases) / sizeof(test_case);
	for (int32 i = 0; i < testCaseCount; i++) {
		NextSubTest();
		test_case &testCase = testCases[i];
		// get device name from path name
		fs_info info;
		const char *deviceName = testCase.path;
		if (testCase.valid) {
			dev_t dev = dev_for_path(testCase.path);
			CHK(dev > 0);
			CHK(fs_stat_dev(dev, &info) == 0);
			deviceName = info.device_name;
		}
		// the two valid and one invalid icon size
		const int32	iconSizes[] = { 16, 32, 20 };
		const bool 	validSizes[] = { true, true, false };
		const int sizeCount = sizeof(iconSizes) / sizeof(int32);
		for (int32 k = 0; k < sizeCount; k++) {
			int32 size = iconSizes[k];
			bool valid = testCase.valid && validSizes[k];
			char buffer[1024];
			if (valid) {
				CHK(get_device_icon(deviceName, buffer, size) == B_OK);
				CheckIconData(deviceName, size, buffer);
				// bad args: NULL buffer
// R5: Wanna see KDL? Here you go...
#if !TEST_R5
				CHK(get_device_icon(deviceName, NULL, size) == B_BAD_VALUE);
#endif
			} else
				CHK(get_device_icon(deviceName, buffer, size) != B_OK);
		}
	}
}

// SnifferRuleTest
void
MimeTypeTest::SnifferRuleTest()
{
	// tests:
	// * status_t GetSnifferRule(BString *result) const;
	// * status_t SetSnifferRule(const char *);
	// * static status_t CheckSnifferRule(const char *rule, BString *parseError);

	// test a couple of valid and invalid rules
	struct test_case {
		const char	*rule;
		const char	*error;	// NULL, if valid
	} testCases[] = {
		// valid rules
		{ "1.0 (\"ABCD\")", NULL },
		{ "1.0 ('ABCD')", NULL },
		{ "  1.0 ('ABCD')  ", NULL },
		{ "0.8 [0:3] ('ABCDEFG' | 'abcdefghij')", NULL },
		{ "0.5([10]'ABCD'|[17]'abcd'|[13]'EFGH')", NULL } ,
		{ "0.5  \n   [0:3]  \t ('ABCD' \n | 'abcd' | 'EFGH')", NULL },
		{ "0.8 [  0  :  3  ] ('ABCDEFG' | 'abcdefghij')", NULL },
		{ "0.8 [0:3] ('ABCDEFG' & 'abcdefg')", NULL },
// These two rules are accepted by the R5 sniffer checker, but not
// by the parser. Thus, we're not accepting them with either.
#if TEST_R5
		{ "1.0 ('ABCD') | ('EFGH')", NULL },
		{ "1.0 [0:3] ('ABCD') | [2:4] ('EFGH')", NULL },
#else
		{ "1.0 ('ABCD') | ('EFGH')", "Sniffer pattern error: missing pattern" },
		{ "1.0 [0:3] ('ABCD') | [2:4] ('EFGH')", "Sniffer pattern error: missing pattern" },
#endif
		{ "0.8 [0:3] (\\077Mkl0x34 & 'abcdefgh')", NULL },
		{ "0.8 [0:3] (\\077034 & 'abcd')", NULL },
		{ "0.8 [0:3] (\\077\\034 & 'ab')", NULL },
		{ "0.8 [0:3] (\\77\\034 & 'ab')", NULL },
		{ "0.8 [0:3] (\\7 & 'a')", NULL },
		{ "0.8 [0:3] (\"\\17\" & 'a')", NULL },
		{ "0.8 [0:3] ('\\17' & 'a')", NULL },
		{ "0.8 [0:3] (\\g & 'a')", NULL },
		{ "0.8 [0:3] (\\g&\\b)", NULL },
		{ "0.8 [0:3] (\\g\\&b & 'abc')", NULL },
		{ "0.8 [0:3] (0x3457 & 'ab')", NULL },
		{ "0.8 [0:3] (0xA4b7 & 'ab')", NULL },
		{ "0.8 [0:3] ('ab\"' & 'abc')", NULL },
		{ "0.8 [0:3] (\"ab\\\"\" & 'abc')", NULL },
		{ "0.8 [0:3] (\"ab\\A\" & 'abc')", NULL },
		{ "0.8 [0:3] (\"ab'\" & 'abc')", NULL },
		{ "0.8 [0:3] (\"ab\\\\\" & 'abc')", NULL },
		{ "0.8 [-5:-3] (\"abc\" & 'abc')", NULL },
// Also accepted by the R5 sniffer but not the R5 parser. We reject.
#if TEST_R5
		{ "0.8 [5:3] (\"abc\" & 'abc')", NULL },
#else
		{ "0.8 [5:3] (\"abc\" & 'abc')", "Sniffer Parser Error -- Invalid range: [5:3]" },
#endif
		{ "1.0 ('ABCD')", NULL },
		{ ".2 ('ABCD')", NULL },
		{ "0. ('ABCD')", NULL },
		{ "1 ('ABCD')", NULL },
		{ "+1 ('ABCD')", NULL },
// We accept extended notation floating point numbers now, but
// not invalid priorities. Thus our checker chokes on these rules,
// whilest R5's does not
#if TEST_R5
		{ "1E25 ('ABCD')", NULL },
		{ "1e25 ('ABCD')", NULL },
#else
		{ "1E25 ('ABCD')", "Sniffer pattern error: invalid priority" },
		{ "1e25 ('ABCD')", "Sniffer pattern error: invalid priority" },
#endif

// R5 chokes on this rule :-( Why? I don't know. :-)
#if TEST_R5
		{ "1e-3 ('ABCD')", "Sniffer pattern error: missing pattern" },
#else
		{ "1e-3 ('ABCD')", NULL },
#endif
		{ "+.003e2 ('ABCD')", NULL },
// R5 chokes on this one too. See how much better our checker/parser is? ;-)
#if TEST_R5
		{ "-123e-9999999999 ('ABCD')", "Sniffer pattern error: bad token" },	// Hooray for the stunning accuracy of floating point :-)
#else
		{ "-123e-9999999999 ('ABCD')", NULL },	// Hooray for the stunning accuracy of floating point :-)
#endif
		// invalid rules
		{ "0.0 ('')",
			"Sniffer pattern error: illegal empty pattern" },
		{ "('ABCD')",
			"Sniffer pattern error: match level expected" },
		{ "[0:3] ('ABCD')",
			"Sniffer pattern error: match level expected" },
		{ "0.8 [0:3] ( | 'abcdefghij')",
		  "Sniffer pattern error: missing pattern" },
		{ "0.8 [0:3] ('ABCDEFG' | )",
		  "Sniffer pattern error: missing pattern" },
		{ "[0:3] ('ABCD')",
			"Sniffer pattern error: match level expected" },
		{ "1.0 (ABCD')",
#if TEST_R5
			"Sniffer pattern error: misplaced single quote"
#else
			"Sniffer pattern error: invalid character 'A'"
#endif
		},
		{ "1.0 ('ABCD)",
#if TEST_R5
			"Sniffer pattern error: unterminated rule"
#else
			"Sniffer pattern error: unterminated single-quoted string"
#endif
		},
		{ "1.0 (ABCD)",
#if TEST_R5
			"Sniffer pattern error: missing pattern"
#else
			"Sniffer pattern error: invalid character 'A'"
#endif
		},
		{ "1.0 (ABCD 'ABCD')",
#if TEST_R5
			"Sniffer pattern error: missing pattern"
#else
			"Sniffer pattern error: invalid character 'A'"
#endif
		},
		{ "1.0 'ABCD')",
#if TEST_R5
			"Sniffer pattern error: missing pattern"
#else
			"Sniffer pattern error: missing pattern"
#endif
		},
		{ "1.0 ('ABCD'",
			"Sniffer pattern error: unterminated rule" },
		{ "1.0 'ABCD'",
#if TEST_R5
			"Sniffer pattern error: missing sniff pattern"
#else
			"Sniffer pattern error: missing pattern"
#endif
		},
		{ "0.5 [0:3] ('ABCD' | 'abcd' | [13] 'EFGH')",
		  	"Sniffer pattern error: missing pattern" },
		{ "0.5('ABCD'|'abcd'|[13]'EFGH')",
		  	"Sniffer pattern error: missing pattern" },
		{ "0.5[0:3]([10]'ABCD'|[17]'abcd'|[13]'EFGH')",
		  	"Sniffer pattern error: missing pattern" },
		{ "0.8 [0x10:3] ('ABCDEFG' | 'abcdefghij')",
		  	"Sniffer pattern error: pattern offset expected" },
		{ "0.8 [0:A] ('ABCDEFG' | 'abcdefghij')",
#if TEST_R5
		  	"Sniffer pattern error: pattern range end expected"
#else
			"Sniffer pattern error: invalid character 'A'"
#endif
		},
		{ "0.8 [0:3] ('ABCDEFG' & 'abcdefghij')",
		  	"Sniffer pattern error: pattern and mask lengths do not match" },
		{ "0.8 [0:3] ('ABCDEFG' & 'abcdefg' & 'xyzwmno')",
#if TEST_R5
		  	"Sniffer pattern error: unterminated rule"
#else
			"Sniffer pattern error: expecting '|', ')', or possibly '&'"
#endif
		},
		{ "0.8 [0:3] (\\g&b & 'a')",
#if TEST_R5
			"Sniffer pattern error: missing mask"
#else
			"Sniffer pattern error: invalid character 'b'"
#endif
		},
		{ "0.8 [0:3] (\\19 & 'a')",
		  	"Sniffer pattern error: pattern and mask lengths do not match" },
		{ "0.8 [0:3] (0x345 & 'ab')",
		  	"Sniffer pattern error: bad hex literal" },
		{ "0.8 [0:3] (0x3457M & 'abc')",
#if TEST_R5
		  	"Sniffer pattern error: expecting '|' or '&'"
#else
			"Sniffer pattern error: invalid character 'M'"
#endif
		},
		{ "0.8 [0:3] (0x3457\\7 & 'abc')",
#if TEST_R5
		  	"Sniffer pattern error: expecting '|' or '&'"
#else
			"Sniffer pattern error: expecting '|', ')', or possibly '&'"
#endif
		},

		// Miscellaneous tests designed to hit every remaining
		// relevant "throw new Err()" statement in our scanner.
		// R5 versions may come later, but I don't really see any
		// good reason why at this point...
#if !TEST_R5
		{ "\x03  ", "Sniffer pattern error: invalid character '\x03'" },
		{ "\"blah", "Sniffer pattern error: unterminated double-quoted string" },
		{ "0xThisIsNotAHexCode", "Sniffer pattern error: incomplete hex code" },
		{ "0xAndNeitherIsThis:-)", "Sniffer pattern error: bad hex literal" },
		{ ".NotAFloat", "Sniffer pattern error: incomplete floating point number" },
		{ "-NotANumber", "Sniffer pattern error: incomplete signed number" },
		{ "+NotANumber", "Sniffer pattern error: incomplete signed number" },

		{ "0.0e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1.0e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ ".0e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "0e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.0e", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.0e", "Sniffer pattern error: incomplete extended-notation floating point number" },

		{ "0.0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1.0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ ".0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.0e-", "Sniffer pattern error: incomplete extended-notation floating point number" },

		{ "0.0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1.0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ ".0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "1e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "-1.0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },
		{ "+1.0e+", "Sniffer pattern error: incomplete extended-notation floating point number" },

		{ "\\11\\", "Sniffer pattern error: incomplete escape sequence" },
		{ "\"Escape!! \\", "Sniffer pattern error: incomplete escape sequence" },
		{ "'Escape!! \\", "Sniffer pattern error: incomplete escape sequence" },

		{ "\\x", "Sniffer pattern error: incomplete escaped hex code" },
		{ "\\xNotAHexCode", "Sniffer pattern error: incomplete escaped hex code" },
		{ "\\xAlsoNotAHexCode", "Sniffer pattern error: incomplete escaped hex code" },
		{ "\\x0", "Sniffer pattern error: incomplete escaped hex code" },

		{ "1.0 (\\377)", NULL },
		{ "\\400", "Sniffer pattern error: invalid octal literal (octals must be between octal 0 and octal 377 inclusive)" },
		{ "\\777", "Sniffer pattern error: invalid octal literal (octals must be between octal 0 and octal 377 inclusive)" },
		{ "1.0 (\\800)", NULL },

		{ NULL, "Sniffer pattern error: NULL pattern" },

		{ "-2", "Sniffer pattern error: invalid priority" },
		{ "+2", "Sniffer pattern error: invalid priority" },

		{ "1.0", "Sniffer pattern error: missing expression" },
#endif	// !TEST_R5

//! \todo Our parser chokes on this rule and I have no idea why
// I don't currently understand what's wrong with the following rule...
// R5 rejects it though, for whatever reason.
#if TEST_R5
		{ "1E-25 ('ABCD')", "Sniffer pattern error: missing pattern" },
#else
//		{ "1E-25 ('ABCD')", NULL },
#endif
	};

	const int testCaseCount = sizeof(testCases) / sizeof(test_case);
	BMimeType type;
	CHK(type.SetTo(testType) == B_OK);
	CHK(type.Install() == B_OK);
	for (int32 i = 0; i < testCaseCount; i++) {
		NextSubTest();
		test_case &testCase = testCases[i];
		BString parseError;
		status_t error = BMimeType::CheckSnifferRule(testCase.rule,
													 &parseError);
//		printf("\n---------------------\n");
//		printf("rule == '%s', %s\n", testCase.rule, (testCase.error ? "should not pass" : "should pass"));
		if (testCase.error == NULL) {
if (error != B_OK)
printf("\nerror:\n%s\n", parseError.String());
			CHK(error == B_OK);
			CHK(type.SetSnifferRule(testCase.rule) == B_OK);
			BString rule;
			CHK(type.GetSnifferRule(&rule) == B_OK);
			CHK(rule == testCase.rule);
		} else {
//			printf("error == 0x%lx\n", error);
//			if (parseError.FindLast(testCase.error) < 0) {
//				printf("\nexpected:\n%s\n", testCase.error);
//				printf("\nfound:\n%s\n", parseError.String());
//			}
			CHK(error == (testCase.rule ? B_BAD_MIME_SNIFFER_RULE : B_BAD_VALUE));
			CHK(parseError.FindLast(testCase.error) >= 0);

// R5 treats a NULL rule string as an error, and thus R5::SetSnifferRule(NULL) fails.
// We also treat a NULL rule string as an error, but OBOS::SetSnifferRule(NULL) does
// not fail, as all OBOS::BMimeType::Set*(NULL) calls are equivalent to the
// corresponding OBOS::BMimeType::Delete*() calls.
#if TEST_R5
			CHK(type.SetSnifferRule(testCase.rule) == B_BAD_MIME_SNIFFER_RULE);
#else
			if (testCase.rule)
				CHK(type.SetSnifferRule(testCase.rule) == B_BAD_MIME_SNIFFER_RULE);
			else
				CHK(type.SetSnifferRule(testCase.rule) == B_OK);
#endif
		}
	}

	// bad args: NULL rule/result string
	NextSubTest();
	BString parseError;
	CHK(BMimeType::CheckSnifferRule("0.0 ('')", NULL)
		== B_BAD_MIME_SNIFFER_RULE);
// R5: crashes when passing a NULL rule/result buffer.
#if !TEST_R5
	CHK(BMimeType::CheckSnifferRule(NULL, &parseError) == B_BAD_VALUE);
	CHK(BMimeType::CheckSnifferRule(NULL, NULL) == B_BAD_VALUE);
	CHK(type.GetSnifferRule(NULL) == B_BAD_VALUE);
#endif

	BString rule;

	// NULL rule to SetSnifferRule unsets the attribute
	NextSubTest();
#if TEST_R5
	CHK(type.IsInstalled() == true);
	CHK(type.SetSnifferRule(NULL) == B_OK);
	CHK(type.GetSnifferRule(&rule) == B_ENTRY_NOT_FOUND);
#else
	CHK(type.IsInstalled() == true);
	if (type.GetSnifferRule(&rule) == B_ENTRY_NOT_FOUND)
		CHK(type.SetSnifferRule("0.0 ('abc')") == B_OK);
	CHK(type.GetSnifferRule(&rule) == B_OK);
	CHK(type.SetSnifferRule(NULL) == B_OK);
	CHK(type.GetSnifferRule(&rule) == B_ENTRY_NOT_FOUND);
	CHK(type.SetSnifferRule(NULL) == B_ENTRY_NOT_FOUND);
#endif

	// bad args: uninstalled type
	CHK(type.Delete() == B_OK);
	CHK(type.GetSnifferRule(&rule) == B_ENTRY_NOT_FOUND);
	CHK(type.SetSnifferRule("0.0 ('ABC')") == B_OK);
#if TEST_R5
	CHK(type.GetSnifferRule(&rule) == B_ENTRY_NOT_FOUND);
#else
	CHK(type.GetSnifferRule(&rule) == B_OK);
#endif

	// bad args: uninitialized BMimeType
	type.Unset();
	CHK(type.GetSnifferRule(&rule) != B_OK);
	CHK(type.SetSnifferRule("0.0 ('ABC')") != B_OK);
}

// helper class for GuessMimeType() tests
class SniffingTestFile {
public:
	SniffingTestFile(string name, string extensionType, string contentType,
					 const void *data = NULL, int32 size = -1, string metaType = "")
		: name(name)
		, extensionType(extensionType)
		, contentType(contentType)
		, data(NULL)
		, size(0)
		, metaType(metaType)
	{
		// replace wildcard types
		if (this->extensionType == "")
			this->extensionType = "application/octet-stream";
		if (this->contentType == "")
			this->contentType = "application/octet-stream";
		// copy data
		if (data) {
			if (size == -1)
				this->size = strlen((const char*)data) + 1;
			else
				this->size = size;
			this->data = new char[this->size];
			memcpy(this->data, data, this->size);
		}
	}

	~SniffingTestFile()
	{
		delete[] data;
	}

	status_t Create()
	{
		BFile file(name.c_str(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		ssize_t error = file.InitCheck();
		if (error == B_OK && data) {
			ssize_t written = file.Write(data, size);
			if (written < 0)
				error = written;
			else if (written != size)
				error = B_ERROR;
		}
		if (!error && metaType.length() > 0) {
			error = file.WriteAttr("META:TYPE", B_STRING_TYPE, 0, metaType.c_str(),
				metaType.length()+1);
			error = error == (ssize_t)(metaType.length()+1) ? B_OK : error;
		}
		return error;
	}

	status_t Delete()
	{
		return BEntry(name.c_str()).Remove();
	}

	string	name;
	string	extensionType;
	string	contentType;
	char	*data;
	int32	size;
	string metaType;
};

// SniffingTest
void
MimeTypeTest::SniffingTest()
{
	// tests:
	// * GuessMimeType()

	// install some test types with sniffer rules
	{
		BMimeType type;
		CHK(type.SetTo(testType) == B_OK);
		CHK(type.Install() == B_OK);
		CHK(type.SetSnifferRule("0.5 [0:1] ('ABCD_EFGH' & 0xffffffff00ffffffff)")
			== B_OK);
		CHK(type.SetTo(testType1) == B_OK);
		CHK(type.Install() == B_OK);
		CHK(type.SetSnifferRule("0.4 ('ABCD')") == B_OK);
		CHK(type.SetTo(testType2) == B_OK);
		CHK(type.Install() == B_OK);
#if TEST_R5
		// This rule is invalid!
		CHK(type.SetSnifferRule("0.4 [0] ('XYZ') | [0:5] ('CD  E')") == B_OK);
#else
//		CHK(type.SetSnifferRule("0.4 ([0] 'XYZ' | [0:5] 'CD  E')") == B_OK);
#endif
		CHK(type.SetTo(testType3) == B_OK);
		CHK(type.Install() == B_OK);
		CHK(type.SetSnifferRule("0.3 [0:8] ('ABCD' | 'EFGH')") == B_OK);
		CHK(type.SetTo(testType4) == B_OK);
		CHK(type.Install() == B_OK);
		CHK(type.SetSnifferRule("0.2 [0:3] ('ABCD' | 'abcd')") == B_OK);
		CHK(type.SetTo(testType5) == B_OK);
		CHK(type.Install() == B_OK);
		CHK(type.SetSnifferRule("0.2 ('LMNO' & 0xfffeffff)") == B_OK);
	}

	SniffingTestFile files[] = {
		SniffingTestFile(string(testDir) + "/file1.cpp",
						 "text/x-source-code", ""),
		SniffingTestFile(string(testDir) + "/file2.gif",
						 "image/gif", ""),
		SniffingTestFile(string(testDir) + "/file3",
						 "", "text/html",
						 "<html>\n<body>\n</body></html>\n"),
		SniffingTestFile(string(testDir) + "/file4.cpp",
						 "text/x-source-code", "text/html",
						 "<html>\n<body>\n</body></html>\n"),
		SniffingTestFile(string(testDir) + "/file5", "", testType1, "ABCD"),
		SniffingTestFile(string(testDir) + "/file6", "", testType3, " ABCD"),
		SniffingTestFile(string(testDir) + "/file7", "", testType4, "abcd"),
		SniffingTestFile(string(testDir) + "/file8", "", testType3,
						 " ABCDEFGH"),
		SniffingTestFile(string(testDir) + "/file9", "", testType,
						 " ABCD EFGH"),
//		SniffingTestFile(string(testDir) + "/file10", "", testType2,
		SniffingTestFile(string(testDir) + "/file10", "", testType3,
						 " ABCD  EFGH"),
		SniffingTestFile(string(testDir) + "/file11", "", testType5,
						 "LMNO"),
		SniffingTestFile(string(testDir) + "/file12", "", testType5,
						 "LLNO"),
		SniffingTestFile(string(testDir) + "/file13", "", "",
						 "LNNO"),
		// meta mime test
// bonefish: TODO: Now that content sniffing is enabled again, this doesn't
// work properly anymore, since there are actually three types involved: The
// extension type ("text/html"), the content type (also "text/html") and the
// real type ("application/x-vnd.be-meta-mime") which is concluded from the
// existence of the "META:TYPE" attribute rather than the extension or content.
//#if !TEST_R5
//		SniffingTestFile(string(testDir) + "/file14.html",
//						 "text/html", "application/x-vnd.be-meta-mime",
//						 "<html>\n<body>\n</body></html>\n", -1,
//						 "fake-meta-mime-string"),
//#endif	// !TEST_R5
	};
	int fileCount = sizeof(files) / sizeof(SniffingTestFile);
	for (int32 i = 0; i < fileCount; i++) {
		NextSubTest();
		SniffingTestFile &file = files[i];
		const char *filename = file.name.c_str();
//printf("file: %s\n", filename);
		const char *extensionType = file.extensionType.c_str();
		const char *contentType = file.contentType.c_str();
		const char *realType = contentType;
		if (file.contentType == "application/octet-stream")
			realType = extensionType;
		// GuessMimeType(const char*,)
		BMimeType type;
		CHK(BMimeType::GuessMimeType(filename, &type) == B_OK);
//printf("type: `%s', extensionType: `%s'\n", type.Type(), extensionType);
		CHK(type == extensionType);
		type.Unset();
		// GuessMimeType(const void*, int32,)
		if (file.data != NULL) {
			CHK(BMimeType::GuessMimeType(file.data, file.size, &type) == B_OK);
if (!(type == contentType))
printf("type: %s, should be: %s\n", type.Type(), realType);
			CHK(type == contentType);
			type.Unset();
		}
		CHK(file.Create() == B_OK);
		// set BEOS:TYPE to something confusing ;-)
		BNode node;
		CHK(node.SetTo(filename) == B_OK);
		CHK(WriteStringAttr(node, "BEOS:TYPE", "application/x-person") == B_OK);
		// GuessMimeType(const ref*,)
		entry_ref ref;
		CHK(get_ref_for_path(filename, &ref) == B_OK);
		CHK(BMimeType::GuessMimeType(&ref, &type) == B_OK);
if (!(type == realType))
printf("type: %s, should be: %s (file == '%s')\n", type.Type(), realType, filename);
		CHK(type == realType);
		type.Unset();
		CHK(file.Delete() == B_OK);
	}

	// GuessMimeType(const ref*,), invalid/abstract entry
	{
		NextSubTest();
		string filename = string(testDir) + "/file100.cpp";
		BMimeType type;
		entry_ref ref;
// invalid entry_ref: R5: Is fine! Haiku: no dice
#if TEST_R5
		CHK(BMimeType::GuessMimeType(&ref, &type) == B_OK);
		CHK(type == "application/octet-stream");
#else
		CHK(BMimeType::GuessMimeType(&ref, &type) != B_OK);
#endif
		// abstract entry_ref
		CHK(get_ref_for_path(filename.c_str(), &ref) == B_OK);
		// R5: B_NAME_NOT_FOUND, Haiku:
		CHK(BMimeType::GuessMimeType(&ref, &type) != B_OK);
	}

	// bad args
	{
		NextSubTest();
		SniffingTestFile &file = files[0];
		CHK(file.Create() == B_OK);
		const char *filename = file.name.c_str();
		entry_ref ref;
		CHK(get_ref_for_path(filename, &ref) == B_OK);
		BMimeType type;
		// NULL BMimeType
		CHK(BMimeType::GuessMimeType(filename, NULL) == B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType(file.data, file.size, NULL)
			== B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType(&ref, NULL) == B_BAD_VALUE);
		// NULL filename/ref/data
		CHK(BMimeType::GuessMimeType((const char*)NULL, &type) == B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType(NULL, 10, &type) == B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType((const entry_ref*)NULL, &type)
			== B_BAD_VALUE);
		// NULL BMimeType and filename/ref/data
		CHK(BMimeType::GuessMimeType((const char*)NULL, NULL) == B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType(NULL, 10, NULL) == B_BAD_VALUE);
		CHK(BMimeType::GuessMimeType((const entry_ref*)NULL, NULL)
			== B_BAD_VALUE);
		CHK(file.Delete() == B_OK);
	}
}


/* KEY:
   + == Tests implemented
   * == Function implemented
*/

/* Ingo's functions:

	// initialization
+*	BMimeType();
+*	BMimeType(const char *mimeType);
(*	virtual ~BMimeType();)

+*	status_t SetTo(const char *mimeType);
+*	status_t SetType(const char *mimeType);
+*	void Unset();
+*	status_t InitCheck() const;

	// string access
+*	const char *Type() const;
+*	bool IsValid() const;
+*	static bool IsValid(const char *mimeType);
+*	bool IsSupertypeOnly() const;
+*	status_t GetSupertype(BMimeType *superType) const;
+*	bool Contains(const BMimeType *type) const;
+*	bool operator==(const BMimeType &type) const;
+*	bool operator==(const char *type) const;

	// MIME database monitoring
+	static status_t StartWatching(BMessenger target);
+	static status_t StopWatching(BMessenger target);

	// C functions
+	int update_mime_info(const char *path, int recursive, int synchronous,
						 int force);
+	status_t create_app_meta_mime(const char *path, int recursive,
								  int synchronous, int force);
+	status_t get_device_icon(const char *dev, void *icon, int32 size);

	// sniffer rule manipulation
+	status_t GetSnifferRule(BString *result) const;
+	status_t SetSnifferRule(const char *);
+	static status_t CheckSnifferRule(const char *rule, BString *parseError);

	// sniffing
+	status_t GuessMimeType(const entry_ref *file, BMimeType *result);
+	static status_t GuessMimeType(const void *buffer, int32 length,
								  BMimeType *result);
+	static status_t GuessMimeType(const char *filename, BMimeType *result);
*/


/* Tyler's functions:

	// MIME database access
+	status_t Install();
+	status_t Delete();
+	bool IsInstalled() const;
+	status_t GetIcon(BBitmap *icon, icon_size size) const;
+	status_t GetPreferredApp(char *signature, app_verb verb = B_OPEN) const;
+	status_t GetAttrInfo(BMessage *info) const;
+	status_t GetFileExtensions(BMessage *extensions) const;
+	status_t GetShortDescription(char *description) const;
+	status_t GetLongDescription(char *description) const;
	status_t GetSupportingApps(BMessage *signatures) const;

+	status_t SetIcon(const BBitmap *icon, icon_size size);
+	status_t SetPreferredApp(const char *signature, app_verb verb = B_OPEN);
+	status_t SetAttrInfo(const BMessage *info);
+	status_t SetFileExtensions(const BMessage *extensions);
+	status_t SetShortDescription(const char *description);
+	status_t SetLongDescription(const char *description);

+	static status_t GetInstalledSupertypes(BMessage *super_types);
+	static status_t GetInstalledTypes(BMessage *types);
+	static status_t GetInstalledTypes(const char *super_type,
									  BMessage *subtypes);
+	static status_t GetWildcardApps(BMessage *wild_ones);

+	status_t GetAppHint(entry_ref *ref) const;
+	status_t SetAppHint(const entry_ref *ref);

+	status_t GetIconForType(const char *type, BBitmap *icon,
							icon_size which) const;
+	status_t SetIconForType(const char *type, const BBitmap *icon,
							icon_size which);
*/