Differential D2818 Diff 12348 source/scriptinterface/tests/test_FunctionWrapper.h

Changeset View

Standalone View

source/scriptinterface/tests/test_FunctionWrapper.h

This file was added.

				/* Copyright (C) 2020 Wildfire Games.
				* This file is part of 0 A.D.
				*
				* 0 A.D. 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, either version 2 of the License, or
				* (at your option) any later version.
				*
				* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
				*/

				#include "lib/self_test.h"

				#include "ps/CLogger.h"

				#include "scriptinterface/FunctionWrapper.h"

				static bool simpleGlobalFunctionData = false;
				static int setterGlobalFunctionData = 0;
				static std::string stringGlobal = "";

				void simpleGlobalFunction()
				{
				StanUnsubmitted Not Done Inline Actions It took me a at least three reads to get what those meant ^^ also breaks all conventions... Stan: It took me a at least three reads to get what those meant ^^ also breaks all conventions...
				simpleGlobalFunctionData = true;
				}

				void setterGlobalFunction(int newData)
				{
				setterGlobalFunctionData = newData;
				}

				int returningGlobalFunction()
				{
				return 3;
				}

				int fancyReturningGlobalFunction(int data)
				{
				return data;
				}

				int adderGlobalFunction(int a, int b)
				{
				return a + b;
				}

				// Some fancier types
				void stringSetterGlobalFunction(std::string newData)
				{
				stringGlobal = newData;
				}

				std::string substrGlobalFunction(std::string a, int start, int len)
				{
				return a.substr(start, len);
				}

				const JSClass m_PrivateDataClass = {
				"m_PrivateDataClass",
				JSCLASS_HAS_PRIVATE
				};


				class TestFunctionWrapper : public CxxTest::TestSuite
				{
				public:
				std::string m_Data = "";

				int mySetter(std::string input)
				{
				m_Data = input;
				return m_Data.size();
				}

				void setUp()
				{
				simpleGlobalFunctionData = false;
				setterGlobalFunctionData = 0;
				stringGlobal = "";
				}

				void test_simple_functions()
				{
				ScriptInterface script("Test", "Test", g_ScriptRuntime);
				JSAutoRequest rq(script.GetContext());

				ScriptWrapper::WrapAndRegister<decltype(&simpleGlobalFunction), &simpleGlobalFunction>(script, "simpleGlobal");
				script.Eval("Test.simpleGlobal()");
				TS_ASSERT_EQUALS(simpleGlobalFunctionData, true);

				ScriptWrapper::WrapAndRegister<decltype(&setterGlobalFunction), &setterGlobalFunction>(script, "setterGlobal");
				script.Eval("Test.setterGlobal(3)");
				TS_ASSERT_EQUALS(setterGlobalFunctionData, 3);
				script.Eval("Test.setterGlobal(5)");
				TS_ASSERT_EQUALS(setterGlobalFunctionData, 5);
				}

				void test_simple_returns()
				{
				ScriptInterface script("Test", "Test", g_ScriptRuntime);
				JSAutoRequest rq(script.GetContext());

				ScriptWrapper::WrapAndRegister<decltype(&setterGlobalFunction), &setterGlobalFunction>(script, "setterGlobal");

				ScriptWrapper::WrapAndRegister<decltype(&returningGlobalFunction), &returningGlobalFunction>(script, "returning");
				ScriptWrapper::WrapAndRegister<decltype(&fancyReturningGlobalFunction), &fancyReturningGlobalFunction>(script, "fancyReturning");
				ScriptWrapper::WrapAndRegister<decltype(&adderGlobalFunction), &adderGlobalFunction>(script, "adder");

				TS_ASSERT_EQUALS(setterGlobalFunctionData, 0);
				script.Eval("Test.setterGlobal(Test.returning())");
				TS_ASSERT_EQUALS(setterGlobalFunctionData, 3);
				script.Eval("Test.setterGlobal(Test.fancyReturning(5))");
				TS_ASSERT_EQUALS(setterGlobalFunctionData, 5);
				script.Eval("Test.setterGlobal(Test.adder(5, 4))");
				TS_ASSERT_EQUALS(setterGlobalFunctionData, 9);
				}

				void test_strings()
				{
				ScriptInterface script("Test", "Test", g_ScriptRuntime);
				JSAutoRequest rq(script.GetContext());

				ScriptWrapper::WrapAndRegister<decltype(&stringSetterGlobalFunction), &stringSetterGlobalFunction>(script, "set");
				ScriptWrapper::WrapAndRegister<decltype(&substrGlobalFunction), &substrGlobalFunction>(script, "substr");

				TS_ASSERT_EQUALS(stringGlobal, "");
				script.Eval("Test.set('fineas')");
				TS_ASSERT_EQUALS(stringGlobal, "fineas");
				script.Eval("Test.set(Test.substr('elem_0_2', 4, 2))");
				TS_ASSERT_EQUALS(stringGlobal, "_0");
				}

				void test_members()
				{
				ScriptInterface script("Test", "Test", g_ScriptRuntime);
				JSContext* cx = script.GetContext();
				JSAutoRequest rq(cx);

				ScriptWrapper::WrapAndRegister<decltype(&setterGlobalFunction), &setterGlobalFunction>(script, "setterGlobal");
				JSFunctionSpec spec[] = {
				ScriptWrapper::Wrap<decltype(&TestFunctionWrapper::mySetter), &TestFunctionWrapper::mySetter>("mySetter"),
				JS_FS_END
				};

				JS::RootedObject obj(cx, JS_NewObject(cx, &m_PrivateDataClass));
				JS::RootedValue glob(cx, script.GetGlobalObject());
				JS::RootedValue bob(cx);
				bob.setObjectOrNull(obj.get());
				script.SetProperty(glob, "bob", bob, false, true);

				JS_DefineFunctions(cx, obj, spec);
				JS_SetPrivate(obj, this);
				script.Eval("Test.setterGlobal(bob.mySetter('jack'))");

				TS_ASSERT_EQUALS(setterGlobalFunctionData, 4);
				TS_ASSERT_EQUALS(m_Data, "jack");

				}
				};