mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-02 09:41:13 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
d2fbfdbf227a270ac16ae4ec117c81e55f12eaa5
OpenSpace/tests/test_luaconversions.cpp
Alexander Bock d8e9db76a3 Update the copyright header to 2020
2020-02-10 21:51:01 +01:00

878 lines
26 KiB
C++
Raw Blame History

/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2020 *
* *
* 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. *
****************************************************************************************/
#include "catch2/catch.hpp"
#include <openspace/properties/propertydelegate.h>
#include <openspace/properties/scalar/boolproperty.h>
#include <openspace/properties/scalar/charproperty.h>
#include <openspace/properties/scalar/doubleproperty.h>
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/properties/scalar/intproperty.h>
#include <openspace/properties/scalar/longdoubleproperty.h>
#include <openspace/properties/scalar/longlongproperty.h>
#include <openspace/properties/scalar/longproperty.h>
#include <openspace/properties/scalar/shortproperty.h>
#include <openspace/properties/scalar/signedcharproperty.h>
#include <openspace/properties/scalar/ucharproperty.h>
#include <openspace/properties/scalar/uintproperty.h>
#include <openspace/properties/scalar/ulonglongproperty.h>
#include <openspace/properties/scalar/ulongproperty.h>
#include <openspace/properties/scalar/ushortproperty.h>
#include <openspace/properties/scalar/wcharproperty.h>
#include <openspace/properties/vector/bvec2property.h>
#include <openspace/properties/vector/bvec3property.h>
#include <openspace/properties/vector/bvec4property.h>
#include <openspace/properties/vector/dvec2property.h>
#include <openspace/properties/vector/dvec3property.h>
#include <openspace/properties/vector/dvec4property.h>
#include <openspace/properties/vector/ivec2property.h>
#include <openspace/properties/vector/ivec3property.h>
#include <openspace/properties/vector/ivec4property.h>
#include <openspace/properties/vector/uvec2property.h>
#include <openspace/properties/vector/uvec3property.h>
#include <openspace/properties/vector/uvec4property.h>
#include <openspace/properties/vector/vec2property.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/properties/vector/vec4property.h>
#include <openspace/properties/matrix/mat2property.h>
#include <openspace/properties/matrix/mat2x3property.h>
#include <openspace/properties/matrix/mat2x4property.h>
#include <openspace/properties/matrix/mat3x2property.h>
#include <openspace/properties/matrix/mat3property.h>
#include <openspace/properties/matrix/mat3x4property.h>
#include <openspace/properties/matrix/mat4x2property.h>
#include <openspace/properties/matrix/mat4x3property.h>
#include <openspace/properties/matrix/mat4property.h>
#include <openspace/properties/matrix/dmat2property.h>
#include <openspace/properties/matrix/dmat2x3property.h>
#include <openspace/properties/matrix/dmat2x4property.h>
#include <openspace/properties/matrix/dmat3x2property.h>
#include <openspace/properties/matrix/dmat3property.h>
#include <openspace/properties/matrix/dmat3x4property.h>
#include <openspace/properties/matrix/dmat4x2property.h>
#include <openspace/properties/matrix/dmat4x3property.h>
#include <openspace/properties/matrix/dmat4property.h>
#include <openspace/properties/stringproperty.h>
#include <ghoul/lua/ghoul_lua.h>
#include <random>
namespace {
constexpr const int NumberFuzzTests = 10000;
} // namespace
TEST_CASE("LuaConversion: LuaExecution", "[luaconversion]") {
lua_State* state = luaL_newstate();
luaL_openlibs(state);
const int status = luaL_loadstring(state, "");
REQUIRE(status == LUA_OK);
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion", "[luaconversion]", bool, char, signed char,
unsigned char, short, unsigned short, int, unsigned int, long, unsigned long,
long long, unsigned long long, float, double, long double, glm::vec2, glm::vec3,
glm::vec4, glm::dvec2, glm::dvec3, glm::dvec4, glm::ivec2, glm::ivec3, glm::ivec4,
glm::uvec2, glm::uvec3, glm::uvec4, glm::mat2x2, glm::mat2x3, glm::mat2x4,
glm::mat3x2, glm::mat3x3, glm::mat3x4, glm::mat4x2, glm::mat4x3, glm::mat4x4,
glm::dmat2x2, glm::dmat2x3, glm::dmat2x4, glm::dmat3x2, glm::dmat3x3, glm::dmat3x4,
glm::dmat4x2, glm::dmat4x3, glm::dmat4x4)
{
using T = TestType;
lua_State* state = luaL_newstate();
luaL_openlibs(state);
const T val(1);
using namespace openspace::properties;
const bool success = PropertyDelegate<TemplateProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<TemplateProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion Fuzz <short", "[luaconversion]", char, signed char,
unsigned char)
{
using T = TestType;
using namespace openspace::properties;
lua_State* state = luaL_newstate();
std::mt19937 gen(1337);
std::uniform_int_distribution<short> dis(
std::numeric_limits<T>::lowest(),
std::numeric_limits<T>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion Fuzz >short", "[luaconversion]", short, unsigned short,
int, unsigned int)
{
using T = TestType;
using namespace openspace::properties;
lua_State* state = luaL_newstate();
std::mt19937 gen(1337);
std::uniform_int_distribution<T> dis(
std::numeric_limits<T>::lowest(),
std::numeric_limits<T>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion Fuzz Limited Signed", "[luaconversion]", long,
long long)
{
using T = TestType;
lua_State* state = luaL_newstate();
using namespace openspace::properties;
std::mt19937 gen(1337);
std::uniform_int_distribution<> dis(
// We need to limit the range of values as Lua uses 'doubles' to store, and some
// values will not be representable
std::numeric_limits<int>::lowest(),
std::numeric_limits<int>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion Fuzz Limited Unsigned", "[luaconversion]",
unsigned long, unsigned long long)
{
using T = TestType;
lua_State* state = luaL_newstate();
using namespace openspace::properties;
std::mt19937 gen(1337);
std::uniform_int_distribution<unsigned int> dis(
// We need to limit the range of values as Lua uses 'doubles' to store, and some
// values will not be representable
std::numeric_limits<unsigned int>::lowest(),
std::numeric_limits<unsigned int>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion Float Fuzz", "[luaconversion]", float, double,
long double)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<T> dis(
0.f,
std::numeric_limits<T>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec2 Float Fuzz", "[luaconversion]", glm::vec2,
glm::dvec2)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec2 Fuzz", "[luaconversion]", glm::ivec2, glm::uvec2)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_int_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec3 Float Fuzz", "[luaconversion]", glm::vec3,
glm::dvec3)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec3 Fuzz", "[luaconversion]", glm::ivec3, glm::uvec3)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_int_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec4 Float Fuzz", "[luaconversion]", glm::vec4,
glm::dvec4)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Vec4 Fuzz", "[luaconversion]", glm::ivec4, glm::uvec4)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_int_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat2x2 Fuzz", "[luaconversion]", glm::mat2x2,
glm::dmat2x2)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat2x3 Fuzz", "[luaconversion]", glm::mat2x3,
glm::dmat2x3)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat2x4 Fuzz", "[luaconversion]", glm::mat2x4,
glm::dmat2x4)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat3x2 Fuzz", "[luaconversion]", glm::mat3x2,
glm::dmat3x2)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat3x3 Fuzz", "[luaconversion]", glm::mat3x3,
glm::dmat3x3)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat3x4 Fuzz", "[luaconversion]", glm::mat3x4,
glm::dmat3x4)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat4x2 Fuzz", "[luaconversion]", glm::mat4x2,
glm::dmat4x2)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat4x3 Fuzz", "[luaconversion]", glm::mat4x3,
glm::dmat4x3)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEMPLATE_TEST_CASE("LuaConversion: Mat4x4 Fuzz", "[luaconversion]", glm::mat4x4,
glm::dmat4x4)
{
lua_State* state = luaL_newstate();
using namespace openspace::properties;
using T = TestType;
std::mt19937 gen(1337);
std::uniform_real_distribution<typename T::value_type> dis(
std::numeric_limits<typename T::value_type>::min(),
std::numeric_limits<typename T::value_type>::max()
);
for (int i = 0; i < NumberFuzzTests; ++i) {
const T val = T(dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen), dis(gen),
dis(gen), dis(gen), dis(gen));
const bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(
state,
val
);
REQUIRE(success);
bool success2;
const T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == val);
lua_pop(state, 1);
}
lua_close(state);
}
TEST_CASE("LuaConversion: String", "[luaconversion]") {
lua_State* state = luaL_newstate();
using namespace openspace::properties;
bool success
= PropertyDelegate<TemplateProperty<std::string>>::template toLuaValue<std::string>(
state, "value");
REQUIRE(success);
std::string value;
bool success2;
value = PropertyDelegate<TemplateProperty<std::string>>::template fromLuaValue<std::string>(
state,
success2
);
REQUIRE(success2);
REQUIRE(value == "value");
lua_close(state);
}
Reference in New Issue View Git Blame Copy Permalink