///////////////////////////////////////////////////////////////////////////////
// Unit Test framework
//
// Copyright Terje Slettebų and Pavel Vozenilek 2002.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.
//
// Last update: September 16, 2002
///////////////////////////////////////////////////////////////////////////////

#ifndef UNITTEST_H
#define UNITTEST_H

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

///////////////////////////////////////////////////////////////////////////////
// SameType
///////////////////////////////////////////////////////////////////////////////

#if _MSC_VER && !__INTEL_COMPILER && !__MWERKS__

// Rani Sharoni's SameType

//This is non-standard code, you are not allowed to 
// specialize a nested template
template<class T1,class T2>
struct SameType
{
private:
	template<class>
	struct In 
	{ enum { value = false }; };

	template<>
	struct In<T1>
	{ enum { value = true };	};

public:
	enum { value = In<T2>::value };
};

#else

template<class T1,class T2>
struct SameType
{
	static const bool value=false;
};

template<class T>
struct SameType<T,T>
{
	static const bool value=true;
};

#endif

///////////////////////////////////////////////////////////////////////////////
// TestResult
///////////////////////////////////////////////////////////////////////////////

class TestResult
{
public:
	TestResult() : pos(0),passed(0),failed(0),notSupported(0) {}

	int pos;
	int passed;
	int failed;
	int notSupported;
};


///////////////////////////////////////////////////////////////////////////////
// Test
///////////////////////////////////////////////////////////////////////////////

class Test
{
typedef std::vector<Test*> tests_type;
static tests_type tests;

public:
	explicit Test(const std::string &n) : name(n)
		{
		Test::tests.push_back(this);
		}

	virtual void execute(TestResult &) =0;
	
protected:
	~Test() {}

	void printName(const TestResult &result) const
		{
		if(name.length()!=0)
			std::cout << std::string(result.pos,' ') << name << '\n';
		}

	void testAssert(const std::string &s,bool assertion,TestResult &result,bool supported =true,
									const std::string &failStr =emptyStr())
		{
		std::string str=std::string(result.pos+2,' ')+s;

		str+=std::string(offset-str.length(),' ');

		if(supported)
			{
			if(assertion)
				{
				std::cout << str << "Passed\n";

				++result.passed;
				}
			else
				{
				std::cout << str << (failStr==emptyStr() ? std::string("Failed") : "Failed - "+failStr) << '\n';

				++result.failed;
				}
			}
		else
			{
			std::cout << str << "Not Supported\n";

			++result.notSupported;
			}
		}

	static std::string emptyStr()
		{
		return std::string();
		}

public:
	enum { offset=63 };

protected:
	const std::string name;
	
public:
	static int run(const std::string &title)
		{
		std::cout << title << std::string(Test::offset-title.length(),' ') << "Result\n";
		std::cout << std::string(76,'-') << '\n';
		
		TestResult testResult;
		
		tests_type::iterator it;
		tests_type::const_iterator itEnd = Test::tests.end();
		for(it=Test::tests.begin(); it!=itEnd; ++it)
			{
			Test* test = *it;
			test->execute(testResult);
			}
		
		std::cout << std::string(76,'-') << '\n';

		const int total=testResult.passed+testResult.failed;
		const int totalAll=total+testResult.notSupported;

		if(total!=0)
			std::cout << "Total - " << testResult.passed << '/' << total << (total==1 ? " test, " : " tests, ")
								<< testResult.passed*100/total << "% Passed\n";

		if(testResult.notSupported!=0)
			std::cout << "Not Supported - " << testResult.notSupported << '/' << totalAll << ", "
								<< testResult.notSupported*100/totalAll << "%\n";

		return testResult.failed;
		}

};


#endif