path: root/src/testsuite.cpp

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2011 Jackmcbarn <jackmcbarn@jackmcbarn.no-ip.org>
 *   Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org>
 *   Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net>
 *   Copyright (C) 2008 Craig Edwards <craigedwards@brainbox.cc>
 *   Copyright (C) 2008 Dennis Friis <peavey@inspircd.org>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/* $Core */

#include "inspircd.h"
#include "cull_list.h"
#include "testsuite.h"
#include <iostream>

#define COUTFAILED() std::cout << std::endl << (failed ? "FAILURE" : "SUCCESS") << std::endl << std::endl

/* Test that x matches y with match() */
#define WCTEST(x, y) do { std::cout << "match(\"" << x << "\",\"" << y "\") " << ((testpassed = (InspIRCd::Match(x, y, NULL))) ? "SUCCESS" : "FAILURE") << std::endl; failed = !testpassed || failed; } while(0)
/* Test that x does not match y with match() */
#define WCTESTNOT(x, y) do { std::cout << "!match(\"" << x << "\",\"" << y "\") " << ((testpassed = ((!InspIRCd::Match(x, y, NULL)))) ? "SUCCESS" : "FAILURE") << std::endl; failed = !testpassed || failed; } while(0)

/* Test that x matches y with match() and cidr enabled */
#define CIDRTEST(x, y) do { std::cout << "match(\"" << x << "\",\"" << y "\", true) " << ((testpassed = (InspIRCd::MatchCIDR(x, y, NULL))) ? "SUCCESS" : "FAILURE") << std::endl; failed = !testpassed || failed; } while(0)
/* Test that x does not match y with match() and cidr enabled */
#define CIDRTESTNOT(x, y) do { std::cout << "!match(\"" << x << "\",\"" << y "\", true) " << ((testpassed = ((!InspIRCd::MatchCIDR(x, y, NULL)))) ? "SUCCESS" : "FAILURE") << std::endl; failed = !testpassed || failed; } while(0)

static bool DoWildTests()
{
	std::cout << "Wildcard and CIDR tests" << std::endl << std::endl;
	bool testpassed = false, failed = false;

	WCTEST("foobar", "*");
	WCTEST("foobar", "foo*");
	WCTEST("foobar", "*bar");
	WCTEST("foobar", "foo??r");
	WCTEST("foobar.test", "fo?bar.*t");
	WCTEST("foobar.test", "fo?bar.t*t");
	WCTEST("foobar.tttt", "fo?bar.**t");
	WCTEST("foobar", "foobar");
	WCTEST("foobar", "foo***bar");
	WCTEST("foobar", "*foo***bar");
	WCTEST("foobar", "**foo***bar");
	WCTEST("foobar", "**foobar*");
	WCTEST("foobar", "**foobar**");
	WCTEST("foobar", "**foobar");
	WCTEST("foobar", "**f?*?ar");
	WCTEST("foobar", "**f?*b?r");
	WCTEST("foofar", "**f?*f*r");
	WCTEST("foofar", "**f?*f*?");
	WCTEST("r", "*");
	WCTEST("", "");
	WCTEST("test@foo.bar.test", "*@*.bar.test");
	WCTEST("test@foo.bar.test", "*test*@*.bar.test");
	WCTEST("test@foo.bar.test", "*@*test");

	WCTEST("a", "*a");
	WCTEST("aa", "*a");
	WCTEST("aaa", "*a");
	WCTEST("aaaa", "*a");
	WCTEST("aaaaa", "*a");
	WCTEST("aaaaaa", "*a");
	WCTEST("aaaaaaa", "*a");
	WCTEST("aaaaaaaa", "*a");
	WCTEST("aaaaaaaaa", "*a");
	WCTEST("aaaaaaaaaa", "*a");
	WCTEST("aaaaaaaaaaa", "*a");

	WCTESTNOT("foobar", "bazqux");
	WCTESTNOT("foobar", "*qux");
	WCTESTNOT("foobar", "foo*x");
	WCTESTNOT("foobar", "baz*");
	WCTESTNOT("foobar", "foo???r");
	WCTESTNOT("foobar", "foobars");
	WCTESTNOT("foobar", "**foobar**h");
	WCTESTNOT("foobar", "**foobar**h*");
	WCTESTNOT("foobar", "**f??*bar?");
	WCTESTNOT("foobar", "");
	WCTESTNOT("", "foobar");
	WCTESTNOT("OperServ", "O");
	WCTESTNOT("O", "OperServ");
	WCTESTNOT("foobar.tst", "fo?bar.*g");
	WCTESTNOT("foobar.test", "fo?bar.*tt");

	CIDRTEST("brain@1.2.3.4", "*@1.2.0.0/16");
	CIDRTEST("brain@1.2.3.4", "*@1.2.3.0/24");
	CIDRTEST("192.168.3.97", "192.168.3.0/24");
	CIDRTEST("2001:db8::1", "2001:db8::/32");

	CIDRTESTNOT("brain@1.2.3.4", "x*@1.2.0.0/16");
	CIDRTESTNOT("brain@1.2.3.4", "*@1.3.4.0/24");
	CIDRTESTNOT("1.2.3.4", "1.2.4.0/24");
	CIDRTESTNOT("brain@1.2.3.4", "*@/24");
	CIDRTESTNOT("brain@1.2.3.4", "@1.2.3.4/9");
	CIDRTESTNOT("brain@1.2.3.4", "@");
	CIDRTESTNOT("brain@1.2.3.4", "");
	CIDRTESTNOT("2001:db8:aaaa::1", "2001:db8:bbbb::/48");

	std::cout << std::endl << "Result of wildcard and CIDR tests:";
	COUTFAILED();
	return !failed;
}

#define STREQUALTEST(x, y) std::cout << "==(\"" << x << "\",\"" << y << "\") " << ((testpassed = (x == y)) ? "SUCCESS" : "FAILURE") << std::endl

template<typename T>
static bool DoStreamTest(const char* expected[], T& stream)
{
	std::string token;
	bool tooMany = false, failed = false, testpassed;
	size_t i;
	for(i = 0; stream.GetToken(token); ++i)
	{
		if(tooMany || !expected[i])
		{
			tooMany = failed = true;
			std::cout << "FAILURE: Received extra token \"" << token << "\"" << std::endl;
		}
		else
		{
			STREQUALTEST(token, expected[i]);
			failed = !testpassed || failed;
		}
	}
	if(!tooMany)
		while(expected[i])
		{
			failed = true;
			std::cout << "FAILURE: Did not receive expected token \"" << expected[i++] << "\"" << std::endl;
		}
	return !failed;
}

#define STREAMTEST(a,b,...) \
do { \
	a stream b; \
	static const char* expected[] = __VA_ARGS__; \
	failed = !DoStreamTest(expected, stream) || failed; \
	std::cout << std::endl; \
} while(0)

static bool DoCommaSepStreamTests()
{
	std::cout << "Comma sepstream tests" << std::endl << std::endl;
	bool failed = false;

	STREAMTEST(irc::commasepstream, ("this,is,a,comma,stream", false), { "this", "is", "a", "comma", "stream", NULL });
	STREAMTEST(irc::commasepstream, ("with,lots,,of,,,commas", false), { "with", "lots", "", "of", "", "", "commas", NULL });
	STREAMTEST(irc::commasepstream, (",comma,at,the,beginning", false), { "", "comma", "at", "the", "beginning", NULL });
	STREAMTEST(irc::commasepstream, ("commas,at,the,end,,", false), { "commas", "at", "the", "end", "", "", NULL });
	STREAMTEST(irc::commasepstream, (",", false), { "", "", NULL });
	STREAMTEST(irc::commasepstream, ("", false), { "", NULL });

	std::cout << "Result of comma sepstream tests:";
	COUTFAILED();
	return !failed;
}

static bool DoSpaceSepStreamTests()
{
	std::cout << "Space sepstream tests" << std::endl << std::endl;
	bool failed = false;

	STREAMTEST(irc::spacesepstream, ("this is a space stream", true), { "this", "is", "a", "space", "stream", NULL });
	STREAMTEST(irc::spacesepstream, ("with lots  of   spaces", true), { "with", "lots", "of", "spaces", NULL });
	STREAMTEST(irc::spacesepstream, (" space at the beginning", true), { "space", "at", "the", "beginning", NULL });
	STREAMTEST(irc::spacesepstream, ("spaces at the end  ", true), { "spaces", "at", "the", "end", NULL });
	STREAMTEST(irc::spacesepstream, (" ", true), { NULL });
	STREAMTEST(irc::spacesepstream, ("", true), { NULL });

	std::cout << "Result of space sepstream tests:";
	COUTFAILED();
	return !failed;
}

static bool DoTokenStreamTests()
{
	std::cout << "Token stream tests" << std::endl << std::endl;
	bool failed = false;

	STREAMTEST(irc::tokenstream, ("just some words and spaces"), { "just", "some", "words", "and", "spaces", NULL });
	STREAMTEST(irc::tokenstream, (":not actually all one token"), { ":not", "actually", "all", "one", "token", NULL });
	STREAMTEST(irc::tokenstream, ("several small tokens :and one large one"), { "several", "small", "tokens", "and one large one", NULL });
	STREAMTEST(irc::tokenstream, ("with 3 tokens "), { "with", "3", "tokens", NULL });
	STREAMTEST(irc::tokenstream, ("with a blank token at the end :"), { "with", "a", "blank", "token", "at", "the", "end", "", NULL });
	STREAMTEST(irc::tokenstream, ("with a space at the end : "), { "with", "a", "space", "at", "the", "end", " ", NULL });
	STREAMTEST(irc::tokenstream, ("a :large token ending in a colon:"), { "a", "large token ending in a colon:", NULL });
	STREAMTEST(irc::tokenstream, ("several tokens with the last ending in a colon:"), { "several", "tokens", "with", "the", "last", "ending", "in", "a", "colon:", NULL });

	std::cout << "Result of token stream tests:";
	COUTFAILED();
	return !failed;
}

bool RealGenerateUIDTests()
{
	std::string first_uid = ServerInstance->GetUID();
	if (first_uid.length() != UUID_LENGTH-1)
	{
		std::cout << "GENERATEUID: Generated UID is " << first_uid.length() << " characters long instead of " << UUID_LENGTH-1 << std::endl;
		return false;
	}

	if (ServerInstance->current_uid[UUID_LENGTH-1] != '\0')
	{
		std::cout << "GENERATEUID: The null terminator is missing from the end of current_uid" << std::endl;
		return false;
	}

	// The correct UID when generating one for the first time is ...AAAAAA
	std::string correct_uid = ServerInstance->Config->sid + std::string(UUID_LENGTH - 4, 'A');
	if (first_uid != correct_uid)
	{
		std::cout << "GENERATEUID: Generated an invalid first UID: " << first_uid << " instead of " << correct_uid << std::endl;
		return false;
	}

	// Set current_uid to be ...Z99999
	ServerInstance->current_uid[3] = 'Z';
	for (unsigned int i = 4; i < UUID_LENGTH-1; i++)
		ServerInstance->current_uid[i] = '9';

	// Store the UID we'll be incrementing so we can display what's wrong later if necessary
	std::string before_increment(ServerInstance->current_uid);
	std::string generated_uid = ServerInstance->GetUID();

	// Correct UID after incrementing ...Z99999 is ...0AAAAA
	correct_uid = ServerInstance->Config->sid + "0" + std::string(UUID_LENGTH - 5, 'A');

	if (generated_uid != correct_uid)
	{
		std::cout << "GENERATEUID: Generated an invalid UID after incrementing " << before_increment << ": " << generated_uid << " instead of " << correct_uid << std::endl;
		return false;
	}

	// Set current_uid to be ...999999 to see if it rolls over correctly
	for (unsigned int i = 3; i < UUID_LENGTH-1; i++)
		ServerInstance->current_uid[i] = '9';

	before_increment.assign(ServerInstance->current_uid);
	generated_uid = ServerInstance->GetUID();

	// Correct UID after rolling over is the first UID we've generated (...AAAAAA)
	if (generated_uid != first_uid)
	{
		std::cout << "GENERATEUID: Generated an invalid UID after incrementing " << before_increment << ": " << generated_uid << " instead of " << first_uid << std::endl;
		return false;
	}

	return true;
}

bool DoGenerateUIDTests()
{
	bool failed = !RealGenerateUIDTests();

	// Reset the UID generation state so running the tests multiple times won't mess things up
	for (unsigned int i = 0; i < 3; i++)
		ServerInstance->current_uid[i] = ServerInstance->Config->sid[i];
	for (unsigned int i = 3; i < UUID_LENGTH-1; i++)
		ServerInstance->current_uid[i] = '9';

	ServerInstance->current_uid[UUID_LENGTH-1] = '\0';

	std::cout << "Result of UID generation tests:";
	COUTFAILED();
	return !failed;
}

TestSuite::TestSuite()
{
	std::cout << std::endl << "*** STARTING TESTSUITE ***" << std::endl;

	std::string modname;
	char choice;
	bool failed;

	while (1)
	{
		std::cout << "(1) Call all module RunTestSuite() methods" << std::endl;
		std::cout << "(2) Run all core tests" << std::endl;

		std::cout << std::endl << "(3) Run wildcard and CIDR tests" << std::endl;
		std::cout << "(4) Run comma sepstream tests" << std::endl;
		std::cout << "(5) Run space sepstream tests" << std::endl;
		std::cout << "(6) Run token stream tests" << std::endl;
		std::cout << "(7) Run UID generation tests" << std::endl;

		std::cout << std::endl << "(L) Load a module" << std::endl;
		std::cout << "(U) Unload a module" << std::endl;
		std::cout << "(X) Exit test suite" << std::endl;

		std::cout << std::endl << "Choices (Enter one or more options as a list then press enter, e.g. 15X): ";
		std::cin >> choice;

		std::cout << std::endl;

		switch (choice)
		{
			case '1':
				for(std::map<std::string, Module*>::const_iterator i = ServerInstance->Modules->GetModules().begin(); i != ServerInstance->Modules->GetModules().end(); i++)
				{
					Module* m = i->second;
					try
					{
						m->RunTestSuite();
					}
					catch (CoreException& e)
					{
						std::cout << "Module " << m->ModuleSourceFile << " failed: " << e.err;
					}
				}
				break;

			case '2':
				failed = false;
				failed = !DoWildTests() || failed;
				failed = !DoCommaSepStreamTests() || failed;
				failed = !DoSpaceSepStreamTests() || failed;
				failed = !DoTokenStreamTests() || failed;
				failed = !DoGenerateUIDTests() || failed;
				std::cout << "Final result of all tests:";
				COUTFAILED();
				break;

			case '3':
				DoWildTests();
				break;

			case '4':
				DoCommaSepStreamTests();
				break;

			case '5':
				DoSpaceSepStreamTests();
				break;

			case '6':
				DoTokenStreamTests();
				break;

			case '7':
				DoGenerateUIDTests();
				break;

			case 'L':
				std::cout << "Enter module filename to load: ";
				std::cin >> modname;
				std::cout << std::endl << (ServerInstance->Modules->Load(modname.c_str()) ? "SUCCESS" : "FAILURE") << std::endl;
				break;

			case 'U':
				std::cout << "Enter module filename to unload: ";
				std::cin >> modname;
				{
					Module* m = ServerInstance->Modules->Find(modname);
					std::cout << std::endl << (ServerInstance->Modules->Unload(m) ? "SUCCESS" : "FAILURE") << std::endl;
					ServerInstance->AtomicActions->Run();
				}
				break;

			case 'X':
				return;

			default:
				std::cout << "Invalid option" << std::endl;
				break;
		}
	}
}

TestSuite::~TestSuite()
{
	std::cout << std::endl << "*** END OF TEST SUITE ***" << std::endl;
}