mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
396 lines
8.2 KiB
C++
396 lines
8.2 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef TORQUE_TESTS_ENABLED
|
|
#include "testing/unitTesting.h"
|
|
#include "platform/platform.h"
|
|
#include "console/simBase.h"
|
|
#include "console/consoleTypes.h"
|
|
#include "console/simBase.h"
|
|
#include "console/engineAPI.h"
|
|
#include "math/mMath.h"
|
|
#include "console/stringStack.h"
|
|
|
|
template<typename T>
|
|
inline T Convert(ConsoleValueRef);
|
|
|
|
template<>
|
|
inline U32 Convert(ConsoleValueRef val)
|
|
{
|
|
return val.getIntValue();
|
|
}
|
|
|
|
template<>
|
|
inline S32 Convert(ConsoleValueRef val)
|
|
{
|
|
return val.getSignedIntValue();
|
|
}
|
|
|
|
template<>
|
|
inline bool Convert(ConsoleValueRef val)
|
|
{
|
|
return val.getBoolValue();
|
|
}
|
|
|
|
template<>
|
|
inline F32 Convert(ConsoleValueRef val)
|
|
{
|
|
return val.getFloatValue();
|
|
}
|
|
|
|
template<>
|
|
inline const char* Convert(ConsoleValueRef val)
|
|
{
|
|
return val.getStringValue();
|
|
}
|
|
|
|
template<>
|
|
inline SimObject* Convert(ConsoleValueRef val)
|
|
{
|
|
return Sim::findObject(val);
|
|
}
|
|
|
|
template<typename T>
|
|
inline T RunScript(const char* str)
|
|
{
|
|
return Convert<T>(Con::evaluate(str, false, NULL));
|
|
}
|
|
|
|
TEST(Script, Basic_Arithmetic)
|
|
{
|
|
S32 add = RunScript<S32>(R"(
|
|
return 1.0 + 1;
|
|
)");
|
|
|
|
EXPECT_EQ(add, 2);
|
|
|
|
S32 sub = RunScript<S32>(R"(
|
|
return 10 - 1.0;
|
|
)");
|
|
|
|
EXPECT_EQ(sub, 9);
|
|
|
|
S32 mult = RunScript<S32>(R"(
|
|
return 10 * 2.5;
|
|
)");
|
|
|
|
EXPECT_EQ(mult, 25);
|
|
|
|
S32 div = RunScript<S32>(R"(
|
|
return 10.0 / 2;
|
|
)");
|
|
|
|
EXPECT_EQ(div, 5);
|
|
}
|
|
|
|
TEST(Script, Complex_Arithmetic)
|
|
{
|
|
S32 result = RunScript<S32>(R"(
|
|
return 1 * 2 - (0.5 * 2);
|
|
)");
|
|
|
|
EXPECT_EQ(result, 1);
|
|
|
|
S32 result2 = RunScript<S32>(R"(
|
|
return 1 * 2 * 3 % 2;
|
|
)");
|
|
|
|
EXPECT_EQ(result2, 0);
|
|
}
|
|
|
|
TEST(Script, Basic_Concatination)
|
|
{
|
|
const char* result1 = RunScript<const char*>(R"(
|
|
return "a" @ "b";
|
|
)");
|
|
|
|
EXPECT_STREQ(result1, "ab");
|
|
|
|
const char* result2 = RunScript<const char*>(R"(
|
|
return "a" SPC "b";
|
|
)");
|
|
|
|
EXPECT_STREQ(result2, "a b");
|
|
|
|
const char* result3 = RunScript<const char*>(R"(
|
|
return "a" TAB "b";
|
|
)");
|
|
|
|
EXPECT_STREQ(result3, "a\tb");
|
|
|
|
const char* result4 = RunScript<const char*>(R"(
|
|
return "a" NL "b";
|
|
)");
|
|
|
|
EXPECT_STREQ(result4, "a\nb");
|
|
|
|
const char* complex = RunScript<const char*>(R"(
|
|
return "a" @ "b" @ "c" @ "d";
|
|
)");
|
|
|
|
EXPECT_STREQ(complex, "abcd");
|
|
}
|
|
|
|
TEST(Script, Basic_Global_Variable_Tests)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
$a = 1;
|
|
return $a;
|
|
)");
|
|
|
|
EXPECT_EQ(value, 1);
|
|
}
|
|
|
|
TEST(Script, Variable_Chaining_And_Usage)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
function t()
|
|
{
|
|
%a = %b = 2;
|
|
return %a;
|
|
}
|
|
return t();
|
|
)");
|
|
|
|
EXPECT_EQ(value, 2);
|
|
|
|
S32 valueGlobal = RunScript<S32>(R"(
|
|
function t()
|
|
{
|
|
$a = %b = 2;
|
|
}
|
|
t();
|
|
return $a;
|
|
)");
|
|
|
|
EXPECT_EQ(valueGlobal, 2);
|
|
|
|
S32 value2 = RunScript<S32>(R"(
|
|
function t(%a)
|
|
{
|
|
if ((%b = 2 * %a) != 5)
|
|
return %b;
|
|
return 5;
|
|
}
|
|
|
|
return t(2);
|
|
)");
|
|
|
|
EXPECT_EQ(value2, 4);
|
|
}
|
|
|
|
TEST(Script, Basic_Function_Call_And_Local_Variable_Testing)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
function t() { %a = 2; return %a; }
|
|
return t();
|
|
)");
|
|
|
|
EXPECT_EQ(value, 2);
|
|
|
|
S32 value2 = RunScript<S32>(R"(
|
|
function add(%a, %b) { return %a + %b; }
|
|
return add(2, 4);
|
|
)");
|
|
|
|
EXPECT_EQ(value2, 6);
|
|
|
|
S32 value3 = RunScript<S32>(R"(
|
|
function fib(%a) {
|
|
if (%a == 0)
|
|
return 0;
|
|
if (%a == 1)
|
|
return 1;
|
|
return fib(%a - 1) + fib(%a - 2);
|
|
}
|
|
return fib(15);
|
|
)");
|
|
|
|
EXPECT_EQ(value3, 610);
|
|
|
|
S32 staticCall = RunScript<S32>(R"(
|
|
function SimObject::bar(%a, %b) {
|
|
return %a + %b;
|
|
}
|
|
return SimObject::bar(1, 2);
|
|
)");
|
|
|
|
EXPECT_EQ(staticCall, 3);
|
|
}
|
|
|
|
TEST(Script, Basic_Conditional_Statements)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
$a = "hello";
|
|
if ($a $= "hello")
|
|
return 1;
|
|
return 2;
|
|
)");
|
|
|
|
EXPECT_EQ(value, 1);
|
|
|
|
const char* ternaryValue = RunScript<const char*>(R"(
|
|
return $a $= "hello" ? "World" : "No U";
|
|
)");
|
|
|
|
EXPECT_STREQ(ternaryValue, "World");
|
|
}
|
|
|
|
TEST(Script, Basic_Loop_Statements)
|
|
{
|
|
S32 whileValue = RunScript<S32>(R"(
|
|
$count = 0;
|
|
while ($count < 5)
|
|
$count++;
|
|
return $count;
|
|
)");
|
|
|
|
EXPECT_EQ(whileValue, 5);
|
|
|
|
const char* forValue = RunScript<const char*>(R"(
|
|
function t(%times)
|
|
{
|
|
%result = "";
|
|
for (%i = 0; %i < %times; %i++)
|
|
%result = %result @ "a";
|
|
return %result;
|
|
}
|
|
|
|
return t(3);
|
|
)");
|
|
|
|
EXPECT_STREQ(forValue, "aaa");
|
|
|
|
const char* forIfValue = RunScript<const char*>(R"(
|
|
function t() {
|
|
%str = "";
|
|
for (%i = 0; %i < 5; %i++) {
|
|
|
|
%loopValue = %i;
|
|
|
|
if (%str $= "")
|
|
%str = %loopValue;
|
|
else
|
|
%str = %str @ "," SPC %loopValue;
|
|
}
|
|
return %str;
|
|
}
|
|
|
|
return t();
|
|
)");
|
|
|
|
EXPECT_STREQ(forIfValue, "0, 1, 2, 3, 4");
|
|
}
|
|
|
|
TEST(Script, TorqueScript_Array_Testing)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
function t(%idx) { %a[idx] = 2; return %a[idx]; }
|
|
return t(5);
|
|
)");
|
|
|
|
EXPECT_EQ(value, 2);
|
|
|
|
S32 value2 = RunScript<S32>(R"(
|
|
function t(%idx) { %a[idx, 0] = 2; return %a[idx, 0]; }
|
|
return t(5);
|
|
)");
|
|
|
|
EXPECT_EQ(value2, 2);
|
|
}
|
|
|
|
TEST(Script, Basic_SimObject)
|
|
{
|
|
SimObject* object = RunScript<SimObject*>(R"(
|
|
return new SimObject(FudgeCollector) {
|
|
fudge = "Chocolate";
|
|
};
|
|
)");
|
|
|
|
EXPECT_NE(object, (SimObject*)NULL);
|
|
|
|
const char* propertyValue = RunScript<const char*>(R"(
|
|
return FudgeCollector.fudge;
|
|
)");
|
|
|
|
EXPECT_STREQ(propertyValue, "Chocolate");
|
|
|
|
const char* funcReturn = RunScript<const char*>(R"(
|
|
function SimObject::fooFunc(%this)
|
|
{
|
|
return "Bar";
|
|
}
|
|
|
|
return FudgeCollector.fooFunc();
|
|
)");
|
|
|
|
EXPECT_STREQ(funcReturn, "Bar");
|
|
|
|
const char* parentFn = RunScript<const char*>(R"(
|
|
new SimObject(Hello);
|
|
|
|
function SimObject::fooFunc2(%this)
|
|
{
|
|
return "Bar";
|
|
}
|
|
|
|
function Hello::fooFunc2(%this)
|
|
{
|
|
%bar = Parent::fooFunc2(%this);
|
|
return "Foo" @ %bar;
|
|
}
|
|
|
|
return Hello.fooFunc2();
|
|
)");
|
|
|
|
EXPECT_STREQ(parentFn, "FooBar");
|
|
}
|
|
|
|
TEST(Script, Basic_Package)
|
|
{
|
|
S32 value = RunScript<S32>(R"(
|
|
function a() { return 3; }
|
|
package overrides {
|
|
function a() { return 5; }
|
|
};
|
|
return a();
|
|
)");
|
|
|
|
EXPECT_EQ(value, 3);
|
|
|
|
S32 overrideValue = RunScript<S32>(R"(
|
|
activatePackage(overrides);
|
|
return a();
|
|
)");
|
|
|
|
EXPECT_EQ(overrideValue, 5);
|
|
|
|
S32 deactivatedValue = RunScript<S32>(R"(
|
|
deactivatePackage(overrides);
|
|
return a();
|
|
)");
|
|
|
|
EXPECT_EQ(deactivatedValue, 3);
|
|
}
|
|
|
|
#endif
|