//------------------------------------------------------------------------------
//	AppRunTester.cpp
//
//------------------------------------------------------------------------------

// Standard Includes -----------------------------------------------------------
#include <stdio.h>

// System Includes -------------------------------------------------------------
#include <Message.h>
#include <OS.h>
#include <Application.h>
#include <Handler.h>
#include <Looper.h>
#include <String.h>

// Project Includes ------------------------------------------------------------
#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

// Local Includes --------------------------------------------------------------
#include "AppRunner.h"
#include "AppRunTester.h"

// Local Defines ---------------------------------------------------------------

// Globals ---------------------------------------------------------------------

//------------------------------------------------------------------------------

// check_output
static
void
check_output(AppRunner &runner, const char *expectedOutput)
{
	BString buffer;
	CHK(runner.GetOutput(&buffer) == B_OK);
if (buffer != expectedOutput)
printf("result is `%s', but should be `%s'\n", buffer.String(),
expectedOutput);
	CHK(buffer == expectedOutput);
}

/*
	thread_id Run()
	@case 1			launch the app two times: B_MULTIPLE_LAUNCH | B_ARGV_ONLY,
					no command line args, send B_QUIT_REQUESTED to both of
					them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest1()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 = output1;
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp1") == B_OK);
	CHK(runner2.Run("AppRunTestApp1") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 2			launch the app two times: B_MULTIPLE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of
					them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest2()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp1", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp1", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 3			launch the app two times: B_MULTIPLE_LAUNCH,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest3()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 = output1;
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp2") == B_OK);
	CHK(runner2.Run("AppRunTestApp2") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 4			launch the app two times: B_MULTIPLE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest4()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp2", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp2", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 5			launch the app two times: B_SINGLE_LAUNCH | B_ARGV_ONLY,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest5()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp3") == B_OK);
	CHK(runner2.Run("AppRunTestApp3") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 6			launch the app two times: B_SINGLE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest6()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp3", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp3", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 7			launch the app two times: B_SINGLE_LAUNCH,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest7()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp4") == B_OK);
	CHK(runner2.Run("AppRunTestApp4") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 8			launch the app two times: B_SINGLE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), ArgvReceived(),
					QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest8()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp4", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp4", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 9			launch two apps with the same signature:
					B_SINGLE_LAUNCH | B_ARGV_ONLY,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest9()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 = output1;
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp3") == B_OK);
	CHK(runner2.Run("AppRunTestApp3a") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 10		launch two apps with the same signature:
					B_SINGLE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest10()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp3", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp3a", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 11		launch two apps with the same signature:
					B_SINGLE_LAUNCH,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest11()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 = output1;
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp4") == B_OK);
	CHK(runner2.Run("AppRunTestApp4a") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 12		launch two apps with the same signature:
					B_SINGLE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	ArgvReceived(), ReadyToRun(), QuitRequested()
*/
void AppRunTester::RunTest12()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp4", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp4a", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 13		launch the app two times: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest13()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp5") == B_OK);
	CHK(runner2.Run("AppRunTestApp5") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 14		launch the app two times: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest14()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp5", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp5", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 15		launch the app two times: B_EXCLUSIVE_LAUNCH,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest15()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp6") == B_OK);
	CHK(runner2.Run("AppRunTestApp6") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 16		launch the app two times: B_EXCLUSIVE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), ArgvReceived(),
					QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest16()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp6", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp6", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 17		launch two apps with the same signature:
					B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest17()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp5") == B_OK);
	CHK(runner2.Run("AppRunTestApp5a") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 18		launch two apps with the same signature:
					B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest18()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp5", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp5a", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 19		launch two apps with the same signature: B_EXCLUSIVE_LAUNCH,
					no command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest19()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp6") == B_OK);
	CHK(runner2.Run("AppRunTestApp6a") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 20		launch two apps with the same signature: B_EXCLUSIVE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), ArgvReceived(),
					QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest20()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp6", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp6a", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 21		launch the app two times: first: B_EXCLUSIVE_LAUNCH,
					second: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), ArgvReceived(),
					QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest21()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::ArgvReceived()\n"
		"args: c d e\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp6", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp5", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}

/*
	thread_id Run()
	@case 22		launch the app two times:
					first: B_EXCLUSIVE_LAUNCH | B_ARGV_ONLY,
					second: B_EXCLUSIVE_LAUNCH,
					command line args, send B_QUIT_REQUESTED to both of them
	@results		first app:	ArgvReceived(), ReadyToRun(), QuitRequested()
					second app:	quits
*/
void AppRunTester::RunTest22()
{
	BApplication app("application/x-vnd.obos-app-run-test");
	const char *output1 =
		"error: 0\n"
		"InitCheck(): 0\n"
		"BApplication::ArgvReceived()\n"
		"args: a b\n"
		"BApplication::ReadyToRun()\n"
		"BApplication::QuitRequested()\n"
		"BApplication::Run() done: 1\n";
	const char *output2 =
		"error: 80002004\n"
		"InitCheck(): 80002004\n";
	// run the apps
	AppRunner runner1, runner2;
	CHK(runner1.Run("AppRunTestApp5", "a b") == B_OK);
	CHK(runner2.Run("AppRunTestApp6", "c d e") == B_OK);
	runner1.WaitFor(true);
	runner2.WaitFor(true);
	// get the outputs and compare the results
	check_output(runner1, output1);
	check_output(runner2, output2);
}


Test* AppRunTester::Suite()
{
	TestSuite* SuiteOfTests = new TestSuite;

	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest1);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest2);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest3);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest4);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest5);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest6);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest7);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest8);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest9);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest10);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest11);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest12);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest13);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest14);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest15);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest16);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest17);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest18);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest19);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest20);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest21);
	ADD_TEST4(BApplication, SuiteOfTests, AppRunTester, RunTest22);

	return SuiteOfTests;
}