////////////////////////////////////////////////////////////////////////////////
// Distributed under the Boost Software License, Version 1.0. //
// (See accompanying file LICENSE or copy at //
// https://www.boost.org/LICENSE_1_0.txt) //
////////////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#include "core/exception.h"
#include "scripting/lua/lua_script.h"
#include "scripting/script_runner.h"
TEST(lua_script, void_function)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(function go() print('hello') end)")};
runner.execute("go");
}
TEST(lua_script, missing_function)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(function go() print('hello') end)")};
EXPECT_THROW(runner.execute("go2"), iris::Exception);
}
TEST(lua_script, add_function)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(function add(a, b) return a + b end)")};
EXPECT_EQ(runner.execute("add", 3, 4), 7);
}
TEST(lua_script, string_reverse_function)
{
iris::ScriptRunner runner{
std::make_unique<:luascript>(R"(function reverse(str) return string.reverse(str) end)")};
EXPECT_EQ(runner.execute<:string>("reverse", "abcd"), "dcba");
}
TEST(lua_script, add_multiple_return)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function add(x)
return x + 1, x + 2
end
)")};
EXPECT_EQ((runner.execute<:int32_t std::int32_t>("add", 5)), std::make_tuple(6, 7));
}
TEST(lua_script, add_multiple_functions)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function func1(x)
return x + 1
end
function func2(x)
return x + 2
end
)")};
EXPECT_EQ((runner.execute<:int32_t>("func1", 5)), 6);
EXPECT_EQ((runner.execute<:int32_t>("func2", 5)), 7);
}
TEST(lua_script, shared_state)
{
iris::Vector3 v1{1.0f, 2.0f, 3.0f};
iris::Vector3 v2{1.0f, 2.0f, 3.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function func1(v1, v2)
v = v1 + v2
end
function func2()
return v
end
)")};
runner.execute("func1", v1, v2);
EXPECT_EQ((runner.execute<:vector3>("func2")), v1 + v2);
}
TEST(lua_script, vector3_function)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec3()
local v = Vector3(1.0, 2.0, 3.0)
return v:x(), v:y(), v:z()
end)")};
EXPECT_EQ((runner.execute("vec3")), std::make_tuple(1.0f, 2.0f, 3.0f));
}
TEST(lua_script, pass_vector3)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function split(vec3)
return vec3:x(), vec3:y(), vec3:z()
end)")};
EXPECT_EQ(
(runner.execute("split", iris::Vector3(1.1f, 2.2f, 3.3f))),
std::make_tuple(1.1f, 2.2f, 3.3f));
}
TEST(lua_script, get_vector3)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function create_vector(x, y, z)
local vec = Vector3(x, y, z)
return vec
end)")};
EXPECT_EQ((runner.execute<:vector3>("create_vector", 2.1f, 2.2f, 2.3f)), iris::Vector3(2.1f, 2.2f, 2.3f));
}
TEST(lua_script, vector3_setters)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function set(vec3)
vec3:set_x(-1.0);
vec3:set_y(-2.0);
vec3:set_z(-3.0);
return vec3:x(), vec3:y(), vec3:z()
end)")};
EXPECT_EQ(
(runner.execute("set", iris::Vector3(1.1f, 2.2f, 3.3f))),
std::make_tuple(-1.0f, -2.0f, -3.0f));
}
TEST(lua_script, vector3_to_string)
{
const iris::Vector3 vec{2.1f, 2.2f, 2.3f};
std::stringstream strm{};
strm << vec;
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_tostring(vec)
return tostring(vec)
end)")};
EXPECT_EQ((runner.execute<:string>("vec_tostring", vec)), strm.str());
}
TEST(lua_script, vector3_equality)
{
const iris::Vector3 vec1{2.1f, 2.2f, 2.3f};
const iris::Vector3 vec2{vec1};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_compare(vec1, vec2)
return vec1 == vec2
end)")};
EXPECT_TRUE(runner.execute("vec_compare", vec1, vec2));
}
TEST(lua_script, vector3_negate)
{
iris::Vector3 vec{2.1f, 2.2f, 2.3f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_negate(vec)
return -vec;
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_negate", vec)), -vec);
}
TEST(lua_script, vector3_add)
{
const iris::Vector3 vec1{2.1f, 2.2f, 2.3f};
const iris::Vector3 vec2{3.1f, 3.2f, 3.3f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_add(vec1, vec2)
return vec1 + vec2;
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_add", vec1, vec2)), vec1 + vec2);
}
TEST(lua_script, vector3_sub)
{
const iris::Vector3 vec1{2.1f, 2.2f, 2.3f};
const iris::Vector3 vec2{3.1f, 3.2f, 3.3f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_sub(vec1, vec2)
return vec1 - vec2;
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_sub", vec1, vec2)), vec1 - vec2);
}
TEST(lua_script, vector3_mul)
{
const iris::Vector3 vec1{2.1f, 2.2f, 2.3f};
const iris::Vector3 vec2{3.1f, 3.2f, 3.3f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_mul(vec1, vec2)
return vec1 * vec2;
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_mul", vec1, vec2)), vec1 * vec2);
}
TEST(lua_script, vector3_dot)
{
iris::Vector3 vec1{1.0f, 3.0f, -5.0f};
const iris::Vector3 vec2{4.0f, -2.0f, -1.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_dot(vec1, vec2)
return vec1:dot(vec2);
end)")};
EXPECT_EQ((runner.execute("vec_dot", vec1, vec2)), vec1.dot(vec2));
}
TEST(lua_script, vector3_cross)
{
const iris::Vector3 vec1{1.0f, 3.0f, -5.0f};
const iris::Vector3 vec2{4.0f, -2.0f, -1.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_cross(vec1, vec2)
return vec1:cross(vec2);
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_cross", vec1, vec2)), iris::Vector3::cross(vec1, vec2));
}
TEST(lua_script, vector3_normalise)
{
const iris::Vector3 vec{1.0f, 3.0f, -5.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_normalise(vec)
vec:normalise()
return vec
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_normalise", vec)), iris::Vector3::normalise(vec));
}
TEST(lua_script, vector3_magnitude)
{
const iris::Vector3 vec{1.0f, 3.0f, -5.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_magnitude(vec)
return vec:magnitude()
end)")};
EXPECT_EQ((runner.execute("vec_magnitude", vec)), vec.magnitude());
}
TEST(lua_script, vector3_lerp)
{
const iris::Vector3 vec1{1.0f, 3.0f, -5.0f};
const iris::Vector3 vec2{4.0f, -2.0f, -1.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function vec_lerp(vec1, vec2, amount)
vec1:lerp(vec2, amount)
return vec1
end)")};
EXPECT_EQ((runner.execute<:vector3>("vec_lerp", vec1, vec2, 0.5f)), iris::Vector3::lerp(vec1, vec2, 0.5f));
}
TEST(lua_script, quaternion_function)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion()
local q = Quaternion(1.0, 2.0, 3.0, 4.0)
return q:x(), q:y(), q:z(), q:w()
end)")};
EXPECT_EQ((runner.execute("quaternion")), std::make_tuple(1.0f, 2.0f, 3.0f, 4.0f));
}
TEST(lua_script, pass_quaternion)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function split(q)
return q:x(), q:y(), q:z(), q:w()
end)")};
EXPECT_EQ(
(runner.execute("split", iris::Quaternion(1.1f, 2.2f, 3.3f, 4.4f))),
std::make_tuple(1.1f, 2.2f, 3.3f, 4.4f));
}
TEST(lua_script, get_quaternion_with_components)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function create_quaternion(x, y, z, w)
local q = Quaternion(x, y, z, w)
return q
end)")};
EXPECT_EQ(
(runner.execute<:quaternion>("create_quaternion", 2.1f, 2.2f, 2.3f, 2.4f)),
iris::Quaternion(2.1f, 2.2f, 2.3f, 2.4f));
}
TEST(lua_script, get_quaternion_with_vector)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function create_quaternion(x, y, z, w)
local q = Quaternion(Vector3(x, y, z), w)
return q
end)")};
EXPECT_EQ(
(runner.execute<:quaternion>("create_quaternion", 2.1f, 2.2f, 2.3f, 2.4f)),
iris::Quaternion(iris::Vector3(2.1f, 2.2f, 2.3f), 2.4f));
}
TEST(lua_script, quaternion_setters)
{
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function set(q)
q:set_x(-1.0);
q:set_y(-2.0);
q:set_z(-3.0);
q:set_w(-4.0);
return q:x(), q:y(), q:z(), q:w()
end)")};
EXPECT_EQ(
(runner.execute("set", iris::Quaternion(1.1f, 2.2f, 3.3f, 4.4f))),
std::make_tuple(-1.0f, -2.0f, -3.0f, -4.0f));
}
TEST(lua_script, quaternion_to_string)
{
const iris::Quaternion q{1.0f, 2.0f, 3.0f, 4.0f};
std::stringstream strm{};
strm << q;
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_tostring(q)
return tostring(q)
end)")};
EXPECT_EQ((runner.execute<:string>("quaternion_tostring", q)), strm.str());
}
TEST(lua_script, quaternion_equality)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{q1};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_compare(q1, q2)
return q1 == q2
end)")};
EXPECT_TRUE(runner.execute("quaternion_compare", q1, q2));
}
TEST(lua_script, quaternion_negate)
{
const iris::Quaternion q{1.0f, 2.0f, 3.0f, 4.0f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_negate(q)
return -q
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_negate", q)), -q);
}
TEST(lua_script, quaternion_add)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{1.2f, 2.4f, 3.6f, 4.6f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_add(q1, q2)
return q1 + q2
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_add", q1, q2)), q1 + q2);
}
TEST(lua_script, quaternion_sub)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{1.2f, 2.4f, 3.6f, 4.6f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_sub(q1, q2)
return q1 - q2
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_sub", q1, q2)), q1 - q2);
}
TEST(lua_script, quaternion_mul)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{1.2f, 2.4f, 3.6f, 4.6f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_mul(q1, q2)
return q1 * q2
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_mul", q1, q2)), q1 * q2);
}
TEST(lua_script, quaternion_dot)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{1.2f, 2.4f, 3.6f, 4.6f};
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_dot(q1, q2)
return q1:dot(q2)
end)")};
EXPECT_EQ((runner.execute("quaternion_dot", q1, q2)), q1.dot(q2));
}
TEST(lua_script, quaternion_slerp)
{
const iris::Quaternion q1{1.0f, 2.0f, 3.0f, 4.0f};
const iris::Quaternion q2{1.2f, 2.4f, 3.6f, 4.6f};
const auto amount = 0.5f;
auto expected = q1;
expected.slerp(q2, amount);
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_slerp(q1, q2, amount)
return q1:slerp(q2, amount)
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_slerp", q1, q2, amount)), expected);
}
TEST(lua_script, quaternion_normalise)
{
const iris::Quaternion q{1.0f, 2.0f, 3.0f, 4.0f};
auto expected = q;
expected.normalise();
iris::ScriptRunner runner{std::make_unique<:luascript>(R"(
function quaternion_normalise(q)
return q:normalise()
end)")};
EXPECT_EQ((runner.execute<:quaternion>("quaternion_normalise", q)), expected);
}