GEEKING

App.UnitTest.Lib/include/rbx/test/App.UnitTest.Lib.h

@@ -0,0 +1,19 @@
+
+#include <boost/test/unit_test.hpp>
+
+#include "rbx/test/Base.UnitTest.Lib.h"
+
+namespace RBX {
+	namespace Test {
+		// Define this fixture in your project:
+		// BOOST_GLOBAL_FIXTURE(AppGlobalFixture);
+		class AppGlobalFixture
+		{
+		public:
+			AppGlobalFixture();
+
+			// returns true if the arg is processed
+			static bool processArg(const std::string arg);
+		};
+	}
+}

App.UnitTest.Lib/include/rbx/test/DataModelFixture.h

@@ -0,0 +1,152 @@
+#pragma once
+
+// Helpful utility classes you can use to do DataModel-driven tests
+
+#include "v8datamodel/datamodel.h"
+#include "v8datamodel/factoryregistration.h"
+#include "v8datamodel/GameSettings.h"
+#include "v8datamodel/DebugSettings.h"
+#include "v8datamodel/PhysicsSettings.h"
+#include "v8datamodel/CommonVerbs.h"
+#include "script/LuaSettings.h"
+#include "Util/Http.h"
+#include "Util/Profiling.h"
+#include "Util/StandardOut.h"
+#include "script/LuaSettings.h"
+#include "script/ScriptContext.h"
+#include "Network/API.h"
+#include "Network/Players.h"
+#include "rbx/test/test_tools.h"
+#include "gui/ProfanityFilter.h"
+
+// Use this fixture to create a DataModel
+class DataModelFixture
+{
+	static void init()
+	{
+		static boost::shared_ptr<RBX::ProfanityFilter> s_profanityFilter;
+		s_profanityFilter = RBX::ProfanityFilter::getInstance();
+
+		RBX::Profiling::init(false);
+
+		static RBX::FactoryRegistrator registerFactoryObjects;
+
+		// This is needed before you can instantiate a DataModel
+		RBX::Http::init(RBX::Http::WinHttp, RBX::Http::CookieSharingSingleProcessMultipleThreads);
+
+		RBX::GameSettings::singleton();
+		RBX::LuaSettings::singleton();
+		RBX::DebugSettings::singleton();
+		RBX::PhysicsSettings::singleton();
+	}
+	boost::scoped_ptr<RBX::CommonVerbs> commonVerbs;
+public:
+	boost::shared_ptr<RBX::DataModel> dataModel;
+	RBX::DataModel* operator&() { return dataModel.get(); }
+	RBX::DataModel* operator->() { return dataModel.get(); }
+
+	std::auto_ptr<RBX::Reflection::Tuple> execute(const char* script, const RBX::Reflection::Tuple& args, RBX::Security::Identities identity = RBX::Security::CmdLine_);
+	std::auto_ptr<RBX::Reflection::Tuple> execute(const char* script)
+	{
+		RBX::Reflection::Tuple args;
+		return execute(script, args);
+	}
+
+	void run()
+	{
+		RBX::RunService* runService = RBX::ServiceProvider::create<RBX::RunService>(dataModel.get());
+		BOOST_REQUIRE(runService);
+		runService->run();
+	}
+
+	DataModelFixture()
+	{
+		static boost::once_flag flag = BOOST_ONCE_INIT;
+		boost::call_once(&init, flag);
+		dataModel = RBX::DataModel::createDataModel(true, new RBX::NullVerb(NULL,""), false);
+
+		{
+			RBX::DataModel::LegacyLock lock(dataModel.get(), RBX::DataModelJob::Write);
+			commonVerbs.reset(new RBX::CommonVerbs(dataModel.get()));
+		}
+	}
+	~DataModelFixture()
+	{
+		commonVerbs.reset();
+		RBX::DataModel::closeDataModel(dataModel);
+	}
+};
+
+
+class NetworkFixture
+{
+public:
+	NetworkFixture()
+	{
+		static boost::once_flag flag = BOOST_ONCE_INIT;
+		boost::call_once(&RBX::Network::initWithoutSecurity, flag);
+	}
+
+	static void startServer(DataModelFixture& dm)
+	{
+		const char* serverScript = "local ns = game:GetService('NetworkServer')\n"\
+								   "ns:Start(53640, 0)\n";
+
+		RBX_REQUIRE_NO_EXECEPTION(dm.execute(serverScript));
+	}
+
+	static void startClient(DataModelFixture& dm, bool waitForClientToReceiveCharacter=false);
+
+private:
+	static shared_ptr<RBX::Reflection::Tuple> accepted(RBX::CEvent* event)
+	{
+		//BOOST_TEST_MESSAGE("connection accepted");
+		event->Set();
+		return shared_ptr<RBX::Reflection::Tuple>();
+	};
+
+	static shared_ptr<RBX::Reflection::Tuple> failed(shared_ptr<const RBX::Reflection::Tuple> args, RBX::CEvent* event)
+	{
+		std::string reason = args->values[1].get<std::string>();
+		BOOST_TEST_MESSAGE(reason);
+		event->Set();
+		return shared_ptr<RBX::Reflection::Tuple>();
+	};
+
+	static shared_ptr<RBX::Reflection::Tuple> rejected(shared_ptr<const RBX::Reflection::Tuple> args, RBX::CEvent* event)
+	{
+		BOOST_TEST_MESSAGE("connection rejected");
+		event->Set();
+		return shared_ptr<RBX::Reflection::Tuple>();
+	};
+};
+
+
+// Use this fixture for debugging
+class OutputLoggingFixture
+{
+	rbx::signals::scoped_connection messageConnection;
+	static void print(const RBX::StandardOutMessage& message)
+	{
+		switch (message.type)
+		{
+		case RBX::MESSAGE_INFO:
+			std::cout << "RBX INFO: " << message.message << '\n';
+			break;
+		case RBX::MESSAGE_WARNING:
+			std::cout << "RBX WARNING: " << message.message << '\n';
+			break;
+		case RBX::MESSAGE_ERROR:
+			std::cout << "RBX ERROR: " << message.message << '\n';
+			break;
+		default:
+			std::cout << "RBX: " << message.message << '\n';
+			break;
+		}
+	}
+public:
+	OutputLoggingFixture()
+	{
+		messageConnection = RBX::StandardOut::singleton()->messageOut.connect(&OutputLoggingFixture::print);
+	}
+};

App.UnitTest.Lib/include/rbx/test/Performance.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RBX { namespace Test {
+	class Memory
+	{
+		long initialBytes;
+	public:
+		Memory();
+		long GetBytes();
+	};
+}}