haiku.git

/*
 * Copyright (C) 2008-2009 Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */

#include <memory>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Application.h>
#include <Screen.h>

#include "DrawingModeToString.h"
#include "TestWindow.h"

// tests
#include "HorizontalLineTest.h"
#include "RandomLineTest.h"
#include "StringTest.h"
#include "VerticalLineTest.h"


struct test_info {
	const char*				name;
	Test*					(*create)();
};

const test_info kTestInfos[] = {
	{ "HorizontalLines",	HorizontalLineTest::CreateTest },
	{ "RandomLines",		RandomLineTest::CreateTest },
	{ "Strings",			StringTest::CreateTest },
	{ "VerticalLines",		VerticalLineTest::CreateTest },
	{ NULL, NULL }
};


class Benchmark : public BApplication {
public:
	Benchmark(Test* test, drawing_mode mode, bool clipping)
		: BApplication("application/x-vnd.haiku-benchmark"),
		  fTest(test),
		  fTestWindow(NULL),
		  fDrawingMode(mode),
		  fUseClipping(clipping)
	{
	}

	~Benchmark()
	{
		delete fTest;
	}

	virtual	void ReadyToRun()
	{
		uint32 width = 500;
		uint32 height = 500;
		BScreen screen;
		BRect frame = screen.Frame();
		frame.left = (frame.left + frame.right - width) / 2;
		frame.top = (frame.top + frame.bottom - width) / 2;
		frame.right = frame.left + width - 1;
		frame.bottom = frame.top + height - 1;

		fTestWindow = new TestWindow(frame, fTest, fDrawingMode,
			fUseClipping, BMessenger(this));
	}

	virtual bool QuitRequested()
	{
		if (fTestWindow != NULL)
			fTestWindow->SetAllowedToQuit(true);
		return BApplication::QuitRequested();
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case MSG_TEST_CANCELED:
				printf("Test canceled early.\n");
				// fall through
			case MSG_TEST_FINISHED:
				fTestWindow->Lock();
				fTest->PrintResults(fTestWindow->View());
				fTestWindow->Unlock();
				PostMessage(B_QUIT_REQUESTED);
				break;
			default:
				BApplication::MessageReceived(message);
				break;
		}
	}

private:
	Test*			fTest;
	TestWindow*		fTestWindow;
	drawing_mode	fDrawingMode;
	bool			fUseClipping;
};


static void
print_test_list(bool error)
{
	FILE* out = (error ? stderr : stdout);

	fprintf(out, "available tests:\n");

	for (int32 i = 0; kTestInfos[i].name; i++)
		fprintf(out, "  %s\n", kTestInfos[i].name);
}


int
main(int argc, char** argv)
{
	// get test name
	const char* testName;
	if (argc < 2) {
		fprintf(stderr, "Usage: %s <test name>\n", argv[0]);
		print_test_list(true);
		exit(1);
	}
	// skip program name
	argc--;
	argv++;

	testName = argv[0];
	bool clipping = false;
	drawing_mode mode = B_OP_COPY;

	while (argc > 0) {
		drawing_mode possibleMode;
		if (strcmp(argv[0], "--clipping") == 0 || strcmp(argv[0], "-c") == 0) {
			clipping = true;
		} else if (ToDrawingMode(argv[0], possibleMode)) {
			mode = possibleMode;
		}
		argc--;
		argv++;
	}


	// find and create the test
	Test* test = NULL;
	try {
		for (int32 i = 0; kTestInfos[i].name; i++) {
			if (strcmp(testName, kTestInfos[i].name) == 0) {
				test = (kTestInfos[i].create)();
				break;
			}
		}
	} catch (std::bad_alloc) {
		fprintf(stderr, "Insufficient memory to create the test. Sorry.\n");
		exit(1);
	}

	if (test == NULL) {
		fprintf(stderr, "Error: Invalid test name: \"%s\"\n", testName);
		print_test_list(true);
		exit(1);
	}

	Benchmark app(test, mode, clipping);
	app.Run();
	return 0;
}