haiku.git

// restest.cpp

#include <algobase.h>
#include <stdio.h>
#include <string.h>

#include <Entry.h>
#include <File.h>
#include <String.h>

#include "Exception.h"
#include "OffsetFile.h"
#include "ResourceFile.h"
#include "Warnings.h"

const char kUsage[] = {
"Usage: %s <options> <filenames>\n"
"options:\n"
"  -h, --help         print this help\n"
"  -l, --list         list each file's resources (short version)\n"
"  -L, --list-long    list each file's resources (long version)\n"
"  -s, --summary      print a summary\n"
"  -w, --write-test   write the file resources (in memory only) and\n"
"                     compare the data with the file's\n"
};

const status_t USAGE_ERROR	= B_ERRORS_END + 1;
const status_t USAGE_HELP	= B_ERRORS_END + 2;

enum listing_level {
	NO_LISTING,
	SHORT_LISTING,
	LONG_LISTING,
};

struct TestOptions {
	listing_level	listing;
	bool			write_test;
	bool			summary;
};

struct TestResult {
	TestResult(const char* filename)
		: filename(filename), warnings(), exception(NULL)
	{
	}

	~TestResult()
	{
		delete exception;
	}

	BString			filename;
	Warnings		warnings;
	Exception*		exception;
};

// print_indented
void
print_indented(const char* str, uint32 chars, bool indentFirst = true)
{
	const uint32 MAX_CHARS_PER_LINE = 75;
	int32 charsLeft = strlen(str);
	if (chars < MAX_CHARS_PER_LINE) {
		for (int32 line = 0; charsLeft > 0; line++) {
			if (line != 0 || indentFirst) {
				for (int32 i = 0; (uint32)i < chars; i++)
					printf(" ");
			}
			int32 bytesLeftOnLine = MAX_CHARS_PER_LINE - chars;
			int32 printChars = min(bytesLeftOnLine, charsLeft);
			printf("%.*s\n", (int)printChars, str);
			str += printChars;
			charsLeft -= printChars;
			// skip spaces
			while (*str == ' ') {
				str++;
				charsLeft--;
			}
		}
	}
}

// print_indented
void
print_indented(const char* indentStr, const char* str)
{
	uint32 chars = strlen(indentStr);
	printf(indentStr);
	print_indented(str, chars, false);
}

// parse_arguments
void
parse_arguments(int argc, const char* const* argv, BList& files,
				TestOptions& options)
{
	// default options
	options.listing = NO_LISTING;
	options.write_test = false;
	options.summary = false;
	// parse arguments
	for (int32 i = 1; i < argc; i++) {
		const char* arg = argv[i];
		int32 len = strlen(arg);
		if (len == 0)
			throw Exception(USAGE_ERROR, "Illegal argument: `'.");
		if (arg[0] == '-') {
			if (len < 2)
				throw Exception(USAGE_ERROR, "Illegal argument: `-'.");
			if (arg[1] == '-') {
				const char* option = arg + 2;
				// help
				if (!strcmp(option, "help")) {
					throw Exception(USAGE_HELP);
				// list
				} else if (!strcmp(option, "list")) {
					if (options.listing == NO_LISTING)
						options.listing = SHORT_LISTING;
				// list-long
				} else if (!strcmp(option, "list-long")) {
					options.listing = LONG_LISTING;
				// summary
				} else if (!strcmp(option, "summary")) {
					options.summary = true;
				// write-test
				} else if (!strcmp(option, "write-test")) {
					options.write_test = true;
				// error
				} else {
					throw Exception(USAGE_ERROR, BString("Illegal option: `")
												 << arg << "'.");
				}
			} else {
				for (int32 i = 1; i < len; i++) {
					char option = arg[i];
					switch (option) {
						// help
						case 'h':
							throw Exception(USAGE_HELP);
							break;
						// list
						case 'l':
							if (options.listing == NO_LISTING)
								options.listing = SHORT_LISTING;
							break;
						// list long
						case 'L':
							options.listing = LONG_LISTING;
							break;
						// summary
						case 's':
							options.summary = true;
							break;
						// write test
						case 'w':
							options.write_test = true;
							break;
						// error
						default:
							throw Exception(USAGE_ERROR,
											BString("Illegal option: `")
											<< arg << "'.");
							break;
					}
				}
			}
		} else
			files.AddItem(const_cast<char*>(arg));
	}
}

// test_file
void
test_file(const char* filename, const TestOptions& options,
		  TestResult& testResult)
{
	Warnings::SetCurrentWarnings(&testResult.warnings);
	ResourceFile resFile;
	try {
		// check if the file exists
		BEntry entry(filename, true);
		status_t error = entry.InitCheck();
		if (error != B_OK)
			throw Exception(error);
		if (!entry.Exists() || !entry.IsFile())
			throw Exception("Entry doesn't exist or is no regular file.");
		entry.Unset();
		// open the file
		BFile file(filename, B_READ_ONLY);
		error = file.InitCheck();
		if (error != B_OK)
			throw Exception(error, "Failed to open file.");
		// do the actual test
		resFile.Init(file);
		if (options.write_test)
			resFile.WriteTest();
	} catch (Exception exception) {
		testResult.exception = new Exception(exception);
	}
	Warnings::SetCurrentWarnings(NULL);
	// print warnings and error
	if (options.listing != NO_LISTING
		|| testResult.warnings.CountWarnings() > 0 || testResult.exception) {
		printf("\nFile `%s':\n", filename);
	}
	// warnings
	if (testResult.warnings.CountWarnings() > 0) {
		for (int32 i = 0;
			 const char* warning = testResult.warnings.WarningAt(i);
			 i++) {
			print_indented("  Warning: ", warning);
		}
	}
	// error
	if (testResult.exception) {
		status_t error = testResult.exception->GetError();
		const char* description = testResult.exception->GetDescription();
		if (strlen(description) > 0) {
			print_indented("  Error:   ", description);
			if (error != B_OK)
				print_indented("           ", strerror(error));
		} else if (error != B_OK)
			print_indented("  Error:   ", strerror(error));
	}
	// list resources
	if (resFile.InitCheck() == B_OK) {
		switch (options.listing) {
			case NO_LISTING:
				break;
			case SHORT_LISTING:
				resFile.PrintToStream(false);
				break;
			case LONG_LISTING:
				resFile.PrintToStream(true);
				break;
		}
	}
}

// test_files
void
test_files(BList& files, TestOptions& options)
{
	BList testResults;
	int32 successTestCount = 0;
	int32 warningTestCount = 0;
	int32 failedTestCount = 0;
	for (int32 i = 0;
		 const char* filename = (const char*)files.ItemAt(i);
		 i++) {
		TestResult* testResult = new TestResult(filename);
		testResults.AddItem(testResult);
		test_file(filename, options, *testResult);
		if (testResult->exception)
			failedTestCount++;
		else if (testResult->warnings.CountWarnings() > 0)
			warningTestCount++;
		else
			successTestCount++;
	}
	// print summary
	if (options.summary) {
		printf("\nSummary:\n");
		printf(  "=======\n");
		// successful tests
		if (successTestCount > 0) {
			if (successTestCount == 1)
				printf("one successful test\n");
			else
				printf("%ld successful tests\n", successTestCount);
		}
		// tests with warnings
		if (warningTestCount > 0) {
			if (warningTestCount == 1)
				printf("one test with warnings:\n");
			else
				printf("%ld tests with warnings:\n", warningTestCount);
			for (int32 i = 0;
				 TestResult* testResult = (TestResult*)testResults.ItemAt(i);
				 i++) {
				if (!testResult->exception
					&& testResult->warnings.CountWarnings() > 0) {
					printf("  `%s'\n", testResult->filename.String());
				}
			}
		}
		// failed tests
		if (failedTestCount > 0) {
			if (failedTestCount == 1)
				printf("one test failed:\n");
			else
				printf("%ld tests failed:\n", failedTestCount);
			for (int32 i = 0;
				 TestResult* testResult = (TestResult*)testResults.ItemAt(i);
				 i++) {
				if (testResult->exception)
					printf("  `%s'\n", testResult->filename.String());
			}
		}
	}
	// cleanup
	for (int32 i = 0;
		 TestResult* testResult = (TestResult*)testResults.ItemAt(i);
		 i++) {
		delete testResult;
	}
}

// main
int
main(int argc, const char* const* argv)
{
	int returnValue = 0;
	const char* cmdName = argv[0];
	TestOptions options;
	BList files;
	try {
		// parse arguments
		parse_arguments(argc, argv, files, options);
		if (files.CountItems() == 0)
			throw Exception(USAGE_ERROR, "No files given.");
		// test the files
		test_files(files, options);
	} catch (Exception exception) {
		status_t error = exception.GetError();
		const char* description = exception.GetDescription();
		switch (error) {
			case B_OK:
				if (strlen(description) > 0)
					fprintf(stderr, "%s\n", description);
				returnValue = 1;
				break;
			case USAGE_ERROR:
				if (strlen(description) > 0)
					fprintf(stderr, "%s\n", description);
				fprintf(stderr, kUsage, cmdName);
				returnValue = 1;
				break;
			case USAGE_HELP:
				printf(kUsage, cmdName);
				break;
			default:
				fprintf(stderr, "  error: %s\n", strerror(error));
				returnValue = 1;
				break;
		}
	}
	return returnValue;
}