BRoster()
none

bool IsRunning(const char *signature) const
case 1:	signature is NULL =>
		Should return false.
case 2:	signature is not NULL, but no app with this signature is running =>
		Should return false.
case 3:	signature is not NULL and an (two) app(s) with this signature is (are)
		running; quit one; quit the second one =>
		Should return true; true; false.

bool IsRunning(entry_ref *ref) const
case 1:	ref is NULL =>
		Should return false.
case 2:	ref is not NULL, but no app with this ref is running =>
		Should return false.
case 3:	ref is not NULL and an (two) app(s) with this ref is (are)
		running; quit one; quit the second one =>
		Should return true; true; false.

team_id TeamFor(const char *signature) const
case 1:	signature is NULL =>
		Should return B_BAD_VALUE.
case 2:	signature is not NULL, but no app with this signature is running =>
		Should return B_ERROR.
case 3:	signature is not NULL and an (two) app(s) with this signature is (are)
		running; quit one; quit the second one =>
		Should return the ID of one of the teams; the ID of the second team;
		B_ERROR.

team_id TeamFor(entry_ref *ref) const
case 1:	ref is NULL =>
		Should return B_BAD_VALUE.
case 2:	ref is not NULL, but no app with this ref is running =>
		Should return B_ERROR.
case 3:	ref is not NULL and an (two) app(s) with this ref is (are)
		running; quit one; quit the second one =>
		Should return the ID of one of the teams; the ID of the second team;
		B_ERROR.

status_t GetAppInfo(const char *signature, app_info *info) const
case 1:	signature is NULL or info is NULL =>
		Should return B_BAD_VALUE.
case 2:	signature/info are not NULL, but no app with this signature is
		running =>
		Should return B_ERROR.
case 3:	signature/info are not NULL and an (two) app(s) with this signature
		is (are) running; quit one; quit the second one =>
		Should
		- fill the app info with the data of one of the apps and return B_OK;
		- fill the app info with the data of the second apps and return B_OK;
		- return B_ERROR.

status_t GetAppInfo(entry_ref *ref, app_info *info) const
case 1:	ref is NULL or info is NULL =>
		Should return B_BAD_VALUE.
case 2:	ref/info are not NULL, but no app with this ref is running =>
		Should return B_ERROR.
case 3:	ref/info are not NULL and an (two) app(s) with this ref
		is (are) running; quit one; quit the second one =>
		Should
		- fill the app info with the data of one of the apps and return B_OK;
		- fill the app info with the data of the second apps and return B_OK;
		- return B_ERROR.

status_t GetRunningAppInfo(team_id team, app_info *info) const
case 1:	info is NULL =>
		Should return B_BAD_VALUE.
case 2:	info is not NULL, but no app with the team ID is running =>
		Should return B_BAD_TEAM_ID, if team >= 0, B_ERROR otherwise.
case 3:	info is not NULL, and an app with the team ID is running =>
		Should fill the app info and return B_OK.

void GetAppList(BList *teamIDList) const
case 1:	teamIDList is NULL =>
		Should do nothing.
case 2:	teamIDList is not NULL and not empty =>
		Should append the team IDs of all running apps to teamIDList.

void GetAppList(const char *signature, BList *teamIDList) const
case 1:	signature or teamIDList are NULL =>
		Should do nothing/should not modify teamIDList.
case 2:	teamIDList is not NULL and not empty, signature is not NULL, but no
		app with this signature is running =>
		Should not modify teamIDList.
case 3:	teamIDList is not NULL and not empty, signature is not NULL and
		app(s) with this signature is (are) running =>
		Should append the team IDs of all running apps with the supplied
		signature to teamIDList.
		
void GetRecentApps(BMessage *refList, int32 maxCount)
case A1:	refList is NULL; maxCount < 0
			R5: crashes
			Haiku: should quietly do nothing.
case A1:	refList is NULL; maxCount == 0
			R5: crashes
			Haiku: should quietly do nothing.
case A1:	refList is NULL; maxCount > 0
			R5: crashes
			Haiku: should quietly do nothing.
case B1:	refList is valid; maxCount < 0
			Should return zero recent apps
case B2:	refList is valid; maxCount == 0
			Should return zero recent apps
case B3:	refList is valid; maxCount > 0
			Should return maxCount apps
case C1:	Normal function, with the second most recent app being one with a
			qualifying BEOS:APP_FLAGS attribute, and the most recent app launched
			being one with no BEOS:APP_FLAGS attribute.
			The latter application should *not* appear at the top
			of the recent apps list.
case C2:	Normal function, with the second most recent app being one with a
			qualifying BEOS:APP_FLAGS attribute, and the most recent app launched
			also being one with a qualifying BEOS:APP_FLAGS attribute.
			The latter application *should* appear at the top of the recent
			apps list.
case C3:	Normal function, with the second most recent app being one with a
			qualifying BEOS:APP_FLAGS attribute, and the most recent app launched
			being one with a non-qualifying BEOS:APP_FLAGS attribute.
			The latter application *should* appear at the top of the recent
			apps list.

void GetRecentDocuments(BMessage *refList, int32 maxCount, const char *fileType,
                        const char *appSig)
void GetRecentDocuments(BMessage *refList, int32 maxCount, const char *fileTypes[],
                        int32 fileTypesCount, const char *appSig)
case 1:	refList is NULL; all other params are valid.
		Should quietly do nothing.
case 2:	refList is non-NULL, maxCount is zero, fileType and appSig are NULL.
		R5: Returns one recent document.
		Haiku: Returns an empty message
case 3:	refList is non-NULL, maxCount is negative, fileType and appSig are NULL.
		R5: Returns one recent document.
		Haiku: Returns an empty message
case 4:	Normal function.
case 5: Duplicate entries with different app sigs are added. When requested,
        only most recent instance among the duplicates is returned.

void GetRecentFolders(BMessage *refList, int32 maxCount, const char *appSig)
case 1:	refList is NULL; maxCount is valid, appSig is NULL.
		Should quietly do nothing.
case 2:	refList is valid, maxCount is negative, appSig is NULL.
		R5: Returns one recent document.
		Haiku: Returns an empty message.
case 3:	refList is valid, maxCount is zero, appSig is NULL.
		R5: Returns one recent document.
		Haiku: Returns an empty message.
case 4: Normal function
case 5: Duplicate entries with different app sigs are added. When requested,
        only most recent instance among the duplicates is returned.

status_t FindApp() const: common cases
case 1:	uninstalled type mimeType =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND.
case 2:	installed type mimeType, no preferred app =>
		Should return B_LAUNCH_FAILED_NO_PREFERRED_APP.
case 3:	installed type mimeType, preferred app, app type not installed,
		app has no signature =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND.
case 4:	installed type mimeType, preferred app, app type not installed,
		app has signature =>
		Should return B_OK and set the ref to refer to the application's
		executable. Should install the app type and set the app hint on it.
case 5:	installed type mimeType, preferred app, app type installed,
		app has signature =>
		Should return B_OK and set the ref to refer to the application's
		executable. Should set the app hint on the app type.
case 6:	installed type mimeType, preferred app, app type installed,
		app has signature, app has no execute permission =>
		Should return B_OK and set the ref to refer to the application's
		executable. Should set the app hint on the app type.
case 7:	installed type mimeType, preferred app, app type installed,
		two apps have the signature =>
		Should return B_OK and set the ref to refer to the application
		executable with the most recent modification time. Should set the app
		hint on the app type.
case 8:	installed type mimeType, preferred app, app type installed,
		two apps have the signature, one has a version info, the other one is
		newer =>
		Should return B_OK and set the ref to refer to the application
		executable with version info. Should set the app hint on the app type.
case 9:	installed type mimeType, preferred app, app type installed,
		two apps have the signature, both apps have a version info =>
		Should return B_OK and set the ref to refer to the application
		executable with the greater version. Should set the app
		hint on the app type.
case 10:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint that points to an app with a
		different signature =>
		Should return B_OK and set the ref to refer to the application's
		executable. Should remove the incorrect app hint on the app type.
		(Haiku: Should set the correct app hint.
		 Don't even return the wrong app?)
case 11:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to void,
		a differently named app with this signature exists =>
		Should return B_OK and set the ref to refer to the application's
		executable. (not R5: Should update the app hint on the app type?)
case 12:mimeType is app signature, not installed =>
		Should return B_OK and set the ref to refer to the application
		executable. Should set the app hint on the app type.
case 13:mimeType is installed, but has no preferred application,
		super type has preferred application =>
		Should return B_OK and set the ref to refer to the application
		executable associated with the preferred app of the supertype.
		Should set the app hint on the app type.
case 14:installed type mimeType, preferred app, app type not installed,
		app has signature, app is trash =>
		Should return B_LAUNCH_FAILED_APP_IN_TRASH.
case 15:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to void,
		no app with this signature exists =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app type's
		app hint.
case 16:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to a cyclic link,
		no app with this signature exists =>
		R5: Should return B_OK and set the ref to refer to the link.
		Haiku: Should return B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app
		type's app hint.

status_t FindApp(const char *mimeType, entry_ref *app) const
case 1:	mimeType or app are NULL =>
		Should return B_BAD_VALUE.
case 2:	mimeType is invalid =>
		Should return B_BAD_VALUE.
case 3:	common tests (all)

status_t FindApp(entry_ref *ref, entry_ref *app) const
case 1:	ref or app are NULL =>
		Should return B_BAD_VALUE.
case 2:	ref doesn't refer to an existing entry =>
		Should return B_ENTRY_NOT_FOUND.
case 3:	ref is valid, file has type and preferred app, preferred app is in
		trash =>
		Should return B_LAUNCH_FAILED_APP_IN_TRASH.
case 4:	ref is valid, file has type and preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set the ref to refer to the file's (not the
		file type's) preferred application's executable. Should install the
		app type and set the app hint on it.
case 5:	ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set the ref to refer to the application's
		executable. Should install the app type and set the app hint on it.
case 6:	ref is valid, file has type and app hint, the type's preferred app
		type is not installed, app exists and has signature =>
		Should return B_OK and set the ref to refer to the file type's
		preferred application's executable. Should install the app type and
		set the app hint on it.
case 7:	ref is valid, file has type, the type's preferred app
		type is not installed, app exists and has signature, file is
		executable =>
		Should return B_OK and set the ref to refer to the file.
		Should not set the app hint on the app or file type (Why?).
case 8:	ref is valid and refers to a link to a file, file has type,
		the type's preferred app type is not installed,
		app exists and has signature =>
		Should return B_OK and set the ref to refer to the file type's
		preferred application's executable. Should install the app type and
		set the app hint on it.
case 9:	ref is valid, file has type,
		common cases 1-14
case 10:ref is valid, file has no type, sniffing results in a type,
		type is set on file,
		common cases 2-14
case 11:ref is valid and refers to a cyclic link =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 12:ref is valid and refers to a link to void =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.

status_t Launch() const: common cases
case 1:	uninstalled type mimeType =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND.
case 2:	installed type mimeType, no preferred app =>
		Should return B_LAUNCH_FAILED_NO_PREFERRED_APP.
case 3:	installed type mimeType, preferred app, app type not installed,
		app has no signature =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND.
case 4:	installed type mimeType, preferred app, app type not installed,
		app has signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the
		app hint on it.
case 5:	installed type mimeType, preferred app, app type installed,
		app has signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should set the app hint on the app type.
case 6:	installed type mimeType, preferred app, app type installed,
		app has signature, app has no execute permission =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should set the app hint on the app type.
case 7:	installed type mimeType, preferred app, app type installed,
		two apps have the signature =>
		Should return B_OK and set team to the ID of the team running the
		application executable with the most recent modification time.
		Should set the app hint on the app type.
case 8:	installed type mimeType, preferred app, app type installed,
		two apps have the signature, one has a version info, the other one is
		newer =>
		Should return B_OK and set team to the ID of the team running the
		application executable with version info. Should set the app hint
		on the app type.
case 9:	installed type mimeType, preferred app, app type installed,
		two apps have the signature, both apps have a version info =>
		Should return B_OK and set team to the ID of the team running the
		application executable with the greater version. Should set the app
		hint on the app type.
case 10:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint that points to an app with a
		different signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should remove the incorrect app hint on
		the app type.
		(Haiku: Should set the correct app hint.
		 Don't even run the wrong app?)
case 11:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to void,
		a differently named app with this signature exists =>
		Should return B_OK and set team to the ID of the team running the
		application's executable.
		(not R5: Should update the app hint on the app type?)
case 12:mimeType is app signature, not installed =>
		Should return B_OK and set team to the ID of the team running the
		application executable. Should set the app hint on the app type.
case 13:mimeType is installed, but has no preferred application,
		super type has preferred application =>
		Should return B_OK and set team to the ID of the team running the
		application executable associated with the preferred app of the
		supertype. Should set the app hint on the app type.
case 14:installed type mimeType, preferred app, app type not installed,
		app has signature, app is trash =>
		Should return B_LAUNCH_FAILED_APP_IN_TRASH.
case 15:installed type mimeType, preferred app, app type not installed,
		app has signature, team is NULL =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the
		app hint on it.
case 16:launch the app two times: B_MULTIPLE_LAUNCH | B_ARGV_ONLY =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
		second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
case 17:launch the app two times: B_MULTIPLE_LAUNCH =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					QuitRequested()
		second app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					QuitRequested()
case 18:launch the app two times: B_SINGLE_LAUNCH | B_ARGV_ONLY =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					(No second ArgvReceived()!)
		second app:	Launch() fails with B_ALREADY_RUNNING
case 19:launch the app two times: B_SINGLE_LAUNCH =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					{Message,Argv,Refs}Received()*, QuitRequested()
		second app:	Launch() fails with B_ALREADY_RUNNING
case 20:launch two apps with the same signature:
		B_SINGLE_LAUNCH | B_ARGV_ONLY =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
		second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
case 21:launch two apps with the same signature: B_SINGLE_LAUNCH =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					QuitRequested()
		second app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					QuitRequested()
case 22:launch the app two times: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					(No second ArgvReceived()!)
		second app:	Launch() fails with B_ALREADY_RUNNING
case 23:launch the app two times: B_EXCLUSIVE_LAUNCH =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					{Message,Argv,Refs}Received()*, QuitRequested()
		second app:	Launch() fails with B_ALREADY_RUNNING
case 24:launch two apps with the same signature:
		B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					(No second ArgvReceived()!)
		second app:	Launch() fails with B_ALREADY_RUNNING
case 25:launch two apps with the same signature: B_EXCLUSIVE_LAUNCH =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					{Message,Argv,Refs}Received()*, QuitRequested()
		second app:	Launch() fails with B_ALREADY_RUNNING
case 26:launch two apps with the same signature:
		first: B_EXCLUSIVE_LAUNCH,
		second: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY =>
		first app:	{Message,Argv,Refs}Received()*, ReadyToRun(),
					QuitRequested()
		second app:	Launch() fails with B_ALREADY_RUNNING
case 27:launch two apps with the same signature:
		first: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
		second: B_EXCLUSIVE_LAUNCH =>
		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					(No second ArgvReceived()!)
		second app:	Launch() fails with B_ALREADY_RUNNING
case 28:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to void,
		no app with this signature exists =>
		Should return B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app type's
		app hint.
case 29:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint pointing to a cyclic link,
		no app with this signature exists =>
		Should return
		Haiku: B_LAUNCH_FAILED_APP_NOT_FOUND and unset the app type's app hint.
		R5: B_ENTRY_NOT_FOUND or B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 30:installed type mimeType, preferred app, app type installed,
		preferred app type has an app hint that points to an app without a
		signature, app will pass a different signature to the
		BApplication constructor =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should remove the incorrect app hint on
		the app type. BRoster::GetRunningAppInfo() should return an app_info
		with the signature passed to the BApplication constructor.

status_t Launch(const char *mimeType, BMessage *initialMsg,
				team_id *appTeam) const
case 1:	mimeType is NULL =>
		Should return B_BAD_VALUE.
case 2:	mimeType is invalid =>
		Should return B_BAD_VALUE.
case 3:	common cases (all)
case 4:	installed type mimeType, preferred app, app type not installed,
		app has signature, NULL initialMsg =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the
		app hint on it.


status_t Launch(const char *mimeType, BList *messageList,
				team_id *appTeam) const
case 1:	mimeType is NULL =>
		Should return B_BAD_VALUE.
case 2:	mimeType is invalid =>
		Should return B_BAD_VALUE.
case 3:	common cases (all)
case 4:	installed type mimeType, preferred app, app type not installed,
		app has signature, NULL messageList =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the
		app hint on it.
case 5:	installed type mimeType, preferred app, app type not installed,
		app has signature, empty messageList =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the
		app hint on it.

status_t Launch(const char *mimeType, int argc, char **args,
				team_id *appTeam) const
case 1:	mimeType is NULL or argc > 0 and args is NULL =>
		Should return B_BAD_VALUE.
case 2:	mimeType is invalid =>
		Should return B_BAD_VALUE.
case 3:	common cases (all)
case 4:	installed type mimeType, preferred app, app type not installed,
		app has signature, NULL args, argc is 0 =>
		Should return B_OK and set team to the ID of the team running
		the application's executable. Should install the app type and set the
		app hint on it.

status_t Launch(const entry_ref *ref, const BMessage *initialMessage,
				team_id *app_team) const
case 1:	ref is NULL =>
		Should return B_BAD_VALUE.
case 2:	ref doesn't refer to an existing entry =>
		Should return B_ENTRY_NOT_FOUND.
case 3:	ref is valid, file has type and preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		file's (not the file type's) preferred application's executable.
		Should install the app type and set the app hint on it.
case 4:	ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
case 5:	ref is valid, file has type and app hint, the type's preferred app
		type is not installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
case 6:	ref is valid, file has type, the type's preferred app
		type is not installed, app exists and has signature, file has
		executable permission, but is not executable  =>
		Should return B_LAUNCH_FAILED_EXECUTABLE.
		Should not set the app hint on the app or file type.
case 7:	ref is valid and refers to a link to a file, file has type,
		the type's preferred app type is not installed,
		app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
case 8:	ref is valid, file has type,
		common cases 1-14
case 9:	ref is valid, file has no type, sniffing results in a type,
		type is set on file,
		common cases 2-14
case 10:ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature, NULL initialMessage =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
case 11:ref is valid and refers to a cyclic link =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 12:ref is valid and refers to a link to void =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 13:ref is valid and refers to an executable without signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable.


status_t Launch(const entry_ref *ref, const BList *messageList,
				team_id *appTeam) const
case 1:	ref is NULL =>
		Should return B_BAD_VALUE.
case 2:	ref doesn't refer to an existing entry =>
		Should return B_ENTRY_NOT_FOUND.
case 3:	ref is valid, file has type and preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		file's (not the file type's) preferred application's executable.
		Should install the app type and set the app hint on it.
case 4:	ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
case 5:	ref is valid, file has type and app hint, the type's preferred app
		type is not installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
case 6:	ref is valid, file has type, the type's preferred app
		type is not installed, app exists and has signature, file has
		executable permission, but is not executable  =>
		Should return B_LAUNCH_FAILED_EXECUTABLE.
		Should not set the app hint on the app or file type.
case 7:	ref is valid and refers to a link to a file, file has type,
		the type's preferred app type is not installed,
		app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
case 8:	ref is valid, file has type,
		common cases 1-14
case 9:	ref is valid, file has no type, sniffing results in a type,
		type is set on file,
		common cases 2-14
case 10:ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature, NULL messageList =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
case 11:ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature, empty messageList =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
case 12:ref is valid and refers to a cyclic link =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 13:ref is valid and refers to a link to void =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 14:ref is valid and refers to an executable without signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable.

status_t Launch(const entry_ref *ref, int argc, const char * const *args,
				team_id *appTeam) const
case 1:	ref is NULL =>
		Should return B_BAD_VALUE.
case 2:	ref doesn't refer to an existing entry =>
		Should return B_ENTRY_NOT_FOUND.
case 3:	ref is valid, file has type and preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		file's (not the file type's) preferred application's executable.
		Should install the app type and set the app hint on it.
		ref is converted to path and added as additional argv.
case 4:	ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it.
		ref is converted to path and added as additional argv.
case 5:	ref is valid, file has type and app hint, the type's preferred app
		type is not installed, app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
		ref is converted to path and added as additional argv.
case 6:	ref is valid, file has type, the type's preferred app
		type is not installed, app exists and has signature, file has
		executable permission, but is not executable  =>
		Should return B_LAUNCH_FAILED_EXECUTABLE.
		Should not set the app hint on the app or file type.
case 7:	ref is valid and refers to a link to a file, file has type,
		the type's preferred app type is not installed,
		app exists and has signature =>
		Should return B_OK and set team to the ID of the team running the file
		type's preferred application's executable. Should install the app
		type and set the app hint on it.
		ref is converted to path and added as additional argv.
case 8:	ref is valid, file has type,
		common cases 1-14
		(ref is converted to path and added as additional argv.)
case 9:	ref is valid, file has no type, sniffing results in a type,
		type is set on file,
		common cases 2-14
		(ref is converted to path and added as additional argv.)
case 10:ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature, NULL args, argc is 0 =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it. argv are ignored.
case 11:ref is valid, file has no type, but preferred app, app type is not
		installed, app exists and has signature, NULL args, argc > 0 =>
		Should return B_OK and set team to the ID of the team running the
		application's executable. Should install the app type and set the app
		hint on it. argv are ignored.
case 12:ref is valid and refers to a cyclic link =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 13:ref is valid and refers to a link to void =>
		Should return B_LAUNCH_FAILED_NO_RESOLVE_LINK.
case 14:ref is valid and refers to an executable without signature =>
		Should return B_OK and set team to the ID of the team running the
		application's executable.

status_t Broadcast(BMessage *message) const
case 1:	NULL message =>
		Should return B_BAD_VALUE.
case 2:	valid message, several apps, one is B_ARGV_ONLY =>
		Should return B_OK and send the message to all (including the
		B_ARGV_ONLY) apps.
		Replies go to be_app_messenger.

status_t Broadcast(BMessage *message, BMessenger replyTo) const
case 1:	NULL message =>
		Should return B_BAD_VALUE.
case 2:	valid message, several apps, one is B_ARGV_ONLY, valid replyTo =>
		Should return B_OK and send the message to all (including the
		B_ARGV_ONLY) apps.
		Replies go to the specified messenger.
case 3:	valid message, several apps, one is B_ARGV_ONLY, invalid replyTo =>
		Should return B_OK and send the message to all (including the
		B_ARGV_ONLY) apps.
		Replies go to the roster!

status_t StartWatching(BMessenger target, uint32 eventMask) const
status_t StopWatching(BMessenger target) const
case 1:	{Start,Stop}Watching() with invalid messenger or invalid flags,
		StopWatching() non-watching messenger =>
		Should return B_OK/B_BAD_VALUE.
case 2:	several apps, several watchers, different eventMasks =>
		Should return B_OK...
		Watching ends, when target has become invalid and the next watching
		message is tried to be sent.
case 3:	call StartWatching() twice, second time with different mask =>
		Should return B_OK. The second call simply overrides the first one.
TODO: Watching app activation.