Files
dl_old/third/LuaBridge3/Tests/Source/StackTests.cpp
T
2024-12-25 20:57:42 +08:00

2540 lines
90 KiB
C++

// https://github.com/kunitoki/LuaBridge3
// Copyright 2021, Lucio Asnaghi
// Copyright 2020, Dmitry Tarakanov
// SPDX-License-Identifier: MIT
#include "TestBase.h"
namespace {
struct Unregistered {};
} // namespace
struct StackTests : TestBase
{
};
TEST_F(StackTests, Void)
{
ASSERT_TRUE(luabridge::Stack<void>::push(L));
}
TEST_F(StackTests, VoidStackOverflow)
{
exhaustStackSpace();
ASSERT_TRUE(luabridge::Stack<void>::push(L));
}
TEST_F(StackTests, NullptrType)
{
{
ASSERT_TRUE(luabridge::push(L, nullptr));
}
{
EXPECT_TRUE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<std::nullptr_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<std::nullptr_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::nullptr_t>>(L, -1));
}
{
auto result = *luabridge::get<std::nullptr_t>(L, -1);
EXPECT_EQ(nullptr, result);
}
}
TEST_F(StackTests, NullptrStackOverflow)
{
exhaustStackSpace();
auto result = luabridge::Stack<std::nullptr_t>::push(L, nullptr);
ASSERT_FALSE(result);
EXPECT_FALSE(result.message().empty());
}
TEST_F(StackTests, NullptrInvalidType)
{
(void)luabridge::Stack<int>::push(L, 42);
auto result = luabridge::Stack<std::nullptr_t>::get(L, -1);
ASSERT_FALSE(result);
}
TEST_F(StackTests, LuaStateType)
{
{
auto result = luabridge::get<lua_State*>(L, -1);
EXPECT_TRUE(result);
EXPECT_EQ(L, *result);
}
}
TEST_F(StackTests, LuaCFunctionType)
{
lua_CFunction value = +[](lua_State*) { return 0; };
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<lua_CFunction>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<lua_CFunction>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<lua_CFunction>>(L, -1));
{
auto result = *luabridge::get<lua_CFunction>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, LuaCFunctionStackOverflow)
{
exhaustStackSpace();
lua_CFunction value = +[](lua_State*) { return 0; };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, LuaCFunctionInvalidType)
{
(void)luabridge::Stack<int>::push(L, 42);
auto result = luabridge::Stack<lua_CFunction>::get(L, -1);
ASSERT_FALSE(result);
}
TEST_F(StackTests, BoolType)
{
bool value = true;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<bool>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<bool>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<bool>>(L, -1));
{
auto result = *luabridge::get<bool>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, BoolStackOverflow)
{
exhaustStackSpace();
bool value = true;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, BoolInvalidType)
{
{
(void)luabridge::Stack<int>::push(L, 0);
auto result = luabridge::Stack<bool>::get(L, -1);
ASSERT_TRUE(result);
EXPECT_TRUE(*result);
}
{
(void)luabridge::Stack<int>::push(L, 42);
auto result = luabridge::Stack<bool>::get(L, -1);
ASSERT_TRUE(result);
EXPECT_TRUE(*result);
}
{
(void)luabridge::Stack<std::nullptr_t>::push(L, nullptr);
auto result = luabridge::Stack<bool>::get(L, -1);
ASSERT_TRUE(result);
EXPECT_FALSE(*result);
}
}
TEST_F(StackTests, CharType)
{
char value = 'a';
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_TRUE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<char>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = *luabridge::get<char>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, CharStackOverflow)
{
exhaustStackSpace();
char value = 'a';
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, CharInvalidType)
{
{
(void)luabridge::Stack<int>::push(L, 1024);
auto result = luabridge::Stack<char>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<std::string_view>::push(L, "");
auto result = luabridge::Stack<char>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<std::string_view>::push(L, "123456");
auto result = luabridge::Stack<char>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, StdByteType)
{
std::byte value{ 128 };
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::byte>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<std::byte>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, StdByteStackOVerflow)
{
exhaustStackSpace();
std::byte value { 128 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, StdByteInvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "1024");
auto result = luabridge::Stack<std::byte>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int>::push(L, 1024);
auto result = luabridge::Stack<std::byte>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Int8Type)
{
int8_t value = 127;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<int8_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Int8StackOverflow)
{
exhaustStackSpace();
int8_t value = 127;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Int8InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "1024");
auto result = luabridge::Stack<int8_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int>::push(L, 1024);
auto result = luabridge::Stack<int8_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Int16Type)
{
int16_t value = 32767;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
{
auto result = *luabridge::get<int16_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Int16StackOverflow)
{
exhaustStackSpace();
int16_t value = 32767;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Int16InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "1000000");
auto result = luabridge::Stack<int16_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int>::push(L, 1000000);
auto result = luabridge::Stack<int16_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Int32Type)
{
int32_t value = 2147483647;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
{
auto result = *luabridge::get<int32_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Int32StackOverflow)
{
exhaustStackSpace();
int32_t value = 2147483647;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Int32InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<int32_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int64_t>::push(L, 2147483648ll);
auto result = luabridge::Stack<int32_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Int64Type)
{
constexpr int64_t max_integral = static_cast<int64_t>(std::numeric_limits<lua_Integer>::max());
int64_t value = max_integral < 4294967296ll ? max_integral : 4294967296ll;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(uint32_t))
{
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
{
auto result = *luabridge::get<int64_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Int64StackOverflow)
{
exhaustStackSpace();
int64_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Int64InvalidType)
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<int64_t>::get(L, -1);
ASSERT_FALSE(result);
}
#if 0 // defined(__SIZEOF_INT128__)
TEST_F(StackTests, Int128Type)
{
constexpr __int128_t max_integral = static_cast<__int128_t>(std::numeric_limits<lua_Integer>::max());
__int128_t value = max_integral < 4294967296ll ? max_integral : 4294967296ll;
{
ASSERT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<__int128_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(uint32_t))
{
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<__uint128_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<__int128_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<__int128_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<__int128_t>>(L, -1));
{
auto result = luabridge::get<__int128_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Int128StackOverflow)
{
exhaustStackSpace();
__int128_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
#endif
TEST_F(StackTests, Uint8Type)
{
uint8_t value = 128;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<uint8_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Uint8StackOverflow)
{
exhaustStackSpace();
uint8_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Uint8InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<uint8_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int64_t>::push(L, 2147483648ll);
auto result = luabridge::Stack<uint8_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Uint16Type)
{
uint16_t value = 32768;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<uint16_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Uint16StackOverflow)
{
exhaustStackSpace();
uint16_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Uint16InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<uint16_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<int64_t>::push(L, 2147483648ll);
auto result = luabridge::Stack<uint16_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Uint32Type)
{
constexpr uint32_t max_integral = static_cast<uint32_t>(std::numeric_limits<lua_Integer>::max());
uint32_t value = max_integral < 2147483648u ? max_integral : 2147483648u;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
if constexpr (sizeof(lua_Integer) == sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<uint32_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Uint32StackOverflow)
{
exhaustStackSpace();
uint32_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Uint32InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<uint32_t>::get(L, -1);
ASSERT_FALSE(result);
}
{
(void)luabridge::Stack<uint64_t>::push(L, 9223372036854775808ull);
auto result = luabridge::Stack<uint32_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, Uint64Type)
{
uint64_t value = static_cast<uint64_t>(std::numeric_limits<int32_t>::max());
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(uint32_t))
{
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
{
auto result = *luabridge::get<uint64_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Uint64StackOverflow)
{
exhaustStackSpace();
uint64_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Uint64InvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<uint32_t>::get(L, -1);
ASSERT_FALSE(result);
}
}
#if 0 // defined(__SIZEOF_INT128__)
TEST_F(StackTests, Uint128Type)
{
__uint128_t value = static_cast<__uint128_t>(std::numeric_limits<int32_t>::max());
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<int32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<__int128_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(uint32_t))
{
EXPECT_TRUE(luabridge::isInstance<uint32_t>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<__uint128_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<__uint128_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<__uint128_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
if constexpr (sizeof(lua_Integer) >= sizeof(int32_t))
{
EXPECT_TRUE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
}
else
{
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
}
EXPECT_TRUE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<__int128_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<__uint128_t>>(L, -1));
{
auto result = *luabridge::get<__uint128_t>(L, -1);
EXPECT_EQ(value, result);
}
}
TEST_F(StackTests, Uint128StackOverflow)
{
exhaustStackSpace();
__uint128_t value = 42;
ASSERT_FALSE(luabridge::push(L, value));
}
#endif
TEST_F(StackTests, IntTypeNotFittingPush)
{
std::error_code ec;
if constexpr (sizeof(uint32_t) == sizeof(lua_Integer) && ! std::is_unsigned_v<lua_Integer>)
{
uint32_t value = 4294967295u;
auto result = luabridge::push(L, value);
EXPECT_FALSE(result);
EXPECT_STREQ("luabridge", static_cast<std::error_code>(result).category().name());
}
if constexpr (sizeof(uint64_t) == sizeof(lua_Integer) && ! std::is_unsigned_v<lua_Integer>)
{
uint64_t value = 9223372036854775808ull;
auto result = luabridge::push(L, value);
EXPECT_FALSE(result);
EXPECT_STREQ("luabridge", static_cast<std::error_code>(result).category().name());
}
#if 0 // defined(__SIZEOF_INT128__)
if constexpr (sizeof(uint64_t) == sizeof(lua_Integer) && ! std::is_unsigned_v<lua_Integer>)
{
__uint128_t value = __uint128_t(9223372036854775808ull) + __uint128_t(9223372036854775808ull);
auto result = luabridge::push(L, value);
EXPECT_FALSE(result);
EXPECT_STREQ("luabridge", static_cast<std::error_code>(result).category().name());
}
#endif
}
TEST_F(StackTests, IntTypeNotFittingIsInstance)
{
if constexpr (sizeof(int32_t) == sizeof(lua_Integer))
{
const luabridge::StackRestore sr(L);
EXPECT_TRUE(luabridge::push(L, 2147483647));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, 1));
}
if constexpr (sizeof(int64_t) == sizeof(lua_Integer))
{
const luabridge::StackRestore sr(L);
EXPECT_TRUE(luabridge::push(L, 9223372036854775807ll));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, 1));
}
#if 0 // defined(__SIZEOF_INT128__)
if constexpr (sizeof(int64_t) == sizeof(lua_Integer))
{
const luabridge::StackRestore sr(L);
EXPECT_TRUE(luabridge::push(L, __int128_t(9223372036854775807ll)));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, 1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, 1));
}
#endif
}
TEST_F(StackTests, FloatType)
{
float value = 123.5678f;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<float>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<double>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<long double>>(L, -1));
{
auto result = *luabridge::get<float>(L, -1);
EXPECT_FLOAT_EQ(value, result);
}
}
TEST_F(StackTests, FloatStackOverflow)
{
exhaustStackSpace();
float value = 42.0f;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, FloatInvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<float>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, DoubleType)
{
double value = 123.5678;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<float>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<double>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<long double>>(L, -1));
{
auto result = *luabridge::get<double>(L, -1);
EXPECT_DOUBLE_EQ(value, result);
}
}
TEST_F(StackTests, DoubleStackOverflow)
{
exhaustStackSpace();
double value = 42.0;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, DoubleInvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<double>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, LongDoubleType)
{
long double value = 123.5678l;
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_TRUE(luabridge::isInstance<float>(L, -1));
EXPECT_TRUE(luabridge::isInstance<double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint8_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint16_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint32_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int64_t>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<uint64_t>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<float>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<double>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<long double>>(L, -1));
{
auto result = *luabridge::get<long double>(L, -1);
EXPECT_DOUBLE_EQ(value, result);
}
}
TEST_F(StackTests, LongDoubleStackOverflow)
{
exhaustStackSpace();
long double value = 42.0l;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, LongDoubleInvalidType)
{
{
(void)luabridge::Stack<std::string_view>::push(L, "100000000");
auto result = luabridge::Stack<long double>::get(L, -1);
ASSERT_FALSE(result);
}
}
TEST_F(StackTests, FloatTypeNotFittingPush)
{
if constexpr (sizeof(double) > sizeof(lua_Number))
{
double value = std::numeric_limits<double>::max();
auto result = luabridge::push(L, value);
EXPECT_FALSE(result);
EXPECT_STREQ("luabridge", static_cast<std::error_code>(result).category().name());
}
if constexpr (sizeof(long double) > sizeof(double) && sizeof(long double) > sizeof(lua_Number))
{
long double value = std::numeric_limits<long double>::max();
auto result = luabridge::push(L, value);
EXPECT_FALSE(result);
EXPECT_STREQ("luabridge", static_cast<std::error_code>(result).category().name());
}
}
TEST_F(StackTests, FloatTypeNotFittingIsInstance)
{
const luabridge::StackRestore sr(L);
EXPECT_TRUE(luabridge::push(L, std::numeric_limits<lua_Number>::max()));
EXPECT_FALSE(luabridge::isInstance<float>(L, 1));
if constexpr (sizeof(double) == sizeof(lua_Number))
{
EXPECT_TRUE(luabridge::isInstance<double>(L, 1));
}
if constexpr (sizeof(long double) > sizeof(double) && sizeof(long double) == sizeof(lua_Number))
{
EXPECT_FALSE(luabridge::isInstance<double>(L, 1));
}
EXPECT_TRUE(luabridge::isInstance<long double>(L, 1));
}
TEST_F(StackTests, CharArrayType)
{
char value[] = "xyz";
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = *luabridge::get<const char*>(L, -1);
EXPECT_STREQ(value, result);
}
}
TEST_F(StackTests, CharArrayStackOverflow)
{
exhaustStackSpace();
char value[] = "xyz";
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstCharArrayType)
{
const char value[] = "xyz";
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = *luabridge::get<const char*>(L, -1);
EXPECT_STREQ(value, result);
}
}
TEST_F(StackTests, ConstCharArrayStackOverflow)
{
exhaustStackSpace();
const char value[] = "xyz";
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstCharLiteralType)
{
EXPECT_TRUE(luabridge::push(L, "xyz"));
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = *luabridge::get<const char*>(L, -1);
EXPECT_STREQ("xyz", result);
}
}
TEST_F(StackTests, ConstCharLiteralStackOverflow)
{
exhaustStackSpace();
ASSERT_FALSE(luabridge::push(L, "xyz"));
}
TEST_F(StackTests, ConstCharPointerType)
{
// Normal value
const char* value = "xyz";
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = *luabridge::get<const char*>(L, -1);
EXPECT_STREQ(value, result);
}
// Nullptr value
const char* nullptr_value = nullptr;
{
EXPECT_TRUE(luabridge::push(L, nullptr_value));
}
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<const char*>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = luabridge::get<char>(L, -1);
EXPECT_FALSE(result);
}
{
auto result = luabridge::get<const char*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(nullptr, *result);
}
{
auto result = luabridge::get<std::string_view>(L, -1);
EXPECT_FALSE(result);
}
{
auto result = luabridge::get<std::string>(L, -1);
EXPECT_FALSE(result);
}
{
auto result = luabridge::get<std::optional<const char*>>(L, -1);
ASSERT_TRUE(result);
EXPECT_FALSE(*result);
}
{
auto result = luabridge::get<std::optional<std::string_view>>(L, -1);
ASSERT_TRUE(result);
EXPECT_FALSE(*result);
}
{
auto result = luabridge::get<std::optional<std::string>>(L, -1);
ASSERT_TRUE(result);
EXPECT_FALSE(*result);
}
}
TEST_F(StackTests, ConstCharPointerStackOverflow)
{
exhaustStackSpace();
const char* value = "xyz";
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstCharPointerAsNullptr)
{
ASSERT_TRUE(luabridge::push(L, luabridge::LuaNil()));
{
auto result = luabridge::get<const char*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(nullptr, *result);
}
}
TEST_F(StackTests, StringViewType)
{
// Normal value
std::string_view value = "xyz";
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<std::string_view>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<std::string_view>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
{
auto result = luabridge::get<char>(L, -1);
EXPECT_FALSE(result);
}
{
auto result = *luabridge::get<std::string_view>(L, -1);
EXPECT_EQ(value, result);
}
{
auto result = *luabridge::get<const char*>(L, -1);
EXPECT_EQ(value, result);
}
{
auto result = *luabridge::get<std::string>(L, -1);
EXPECT_EQ(value, result);
}
{
auto result = *luabridge::get<std::optional<const char*>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
{
auto result = *luabridge::get<std::optional<std::string_view>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
{
auto result = *luabridge::get<std::optional<std::string>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
}
TEST_F(StackTests, StringViewStackOverflow)
{
exhaustStackSpace();
std::string_view value = "xyz";
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, StringViewInvalidType)
{
ASSERT_TRUE(luabridge::push(L, luabridge::LuaNil()));
{
auto result = luabridge::get<std::string_view>(L, -1);
EXPECT_FALSE(result);
}
}
TEST_F(StackTests, StringType)
{
// Normal value
std::string value = "xyz";
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const char*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<std::string>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<std::string>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<std::optional<std::string>>(L, -1));
EXPECT_EQ(value, (*luabridge::get<std::string>(L, -1)));
EXPECT_EQ(value, (*luabridge::get<const char*>(L, -1)));
{
auto result = luabridge::get<char>(L, -1);
EXPECT_FALSE(result);
}
{
auto result = *luabridge::get<std::optional<const char*>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
{
auto result = *luabridge::get<std::optional<std::string_view>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
{
auto result = *luabridge::get<std::optional<std::string>>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(value, *result);
}
}
TEST_F(StackTests, StringStackOverflow)
{
exhaustStackSpace();
std::string value = "xyz";
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, StringInvalidType)
{
ASSERT_TRUE(luabridge::push(L, luabridge::LuaNil()));
{
auto result = luabridge::get<std::string>(L, -1);
EXPECT_FALSE(result);
}
}
TEST_F(StackTests, IntArrayType)
{
int value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 , 10 };
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<char>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<std::string>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<int[10]>(L, -1));
}
TEST_F(StackTests, IntArrayStackOverflow)
{
exhaustStackSpace();
int value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 , 10 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstIntArrayType)
{
const int value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
{
EXPECT_TRUE(luabridge::push(L, value));
}
EXPECT_FALSE(luabridge::isInstance<std::nullptr_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<lua_CFunction>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint8_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint16_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint32_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<uint64_t>(L, -1));
EXPECT_FALSE(luabridge::isInstance<bool>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::byte>(L, -1));
EXPECT_FALSE(luabridge::isInstance<char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned char>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned short>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned int>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<unsigned long long>(L, -1));
EXPECT_FALSE(luabridge::isInstance<float>(L, -1));
EXPECT_FALSE(luabridge::isInstance<double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<long double>(L, -1));
EXPECT_FALSE(luabridge::isInstance<const char*>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::string>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::tuple<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::vector<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<int>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<const char*>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<std::string_view>>(L, -1));
EXPECT_FALSE(luabridge::isInstance<std::optional<std::string>>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const int[10]>(L, -1));
}
TEST_F(StackTests, ConstIntArrayStackOverflow)
{
exhaustStackSpace();
const int value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstLongArrayStackOverflow)
{
exhaustStackSpace();
const long value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstLongLongArrayStackOverflow)
{
exhaustStackSpace();
const long long value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, ConstUnsignedLongLongArrayStackOverflow)
{
exhaustStackSpace();
const unsigned long long value[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, OptionalStackOverflow)
{
exhaustStackSpace();
std::optional<int> value = 1;
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, Pair)
{
{
auto value = std::make_pair(1, "one");
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<decltype(value)>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(1, std::get<0>(*result));
EXPECT_STREQ("one", std::get<1>(*result));
}
{
auto value = std::make_pair(1, std::string("one"));
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<std::pair<std::string, int>>(L, -1);
ASSERT_FALSE(result);
EXPECT_EQ(luabridge::ErrorCode::InvalidTypeCast, result.error());
}
{
auto value = std::make_tuple(1, 2, 3);
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<std::pair<int, int>>(L, -1);
ASSERT_FALSE(result);
EXPECT_EQ(luabridge::ErrorCode::InvalidTableSizeInCast, result.error());
}
}
TEST_F(StackTests, PairNesting)
{
auto value = std::make_pair(1, std::make_pair(1, std::make_pair(1, std::string("one"))));
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<decltype(value)>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(1, std::get<0>(*result));
EXPECT_EQ(1, std::get<0>(std::get<1>(*result)));
EXPECT_EQ(1, std::get<0>(std::get<1>(std::get<1>(*result))));
EXPECT_EQ("one", std::get<1>(std::get<1>(std::get<1>(*result))));
}
TEST_F(StackTests, PairStackOverflow)
{
exhaustStackSpace();
auto value = std::make_pair(1, "one");
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, PairFailUnregistered)
{
{
auto value = std::make_pair(Unregistered(), 1);
#if LUABRIDGE_HAS_EXCEPTIONS
EXPECT_ANY_THROW(luabridge::push(L, value).error());
#else
ASSERT_FALSE(luabridge::push(L, value));
EXPECT_EQ(luabridge::ErrorCode::ClassNotRegistered, luabridge::push(L, value).error());
#endif
}
{
auto value = std::make_pair(1, Unregistered());
#if LUABRIDGE_HAS_EXCEPTIONS
EXPECT_ANY_THROW(luabridge::push(L, value).error());
#else
ASSERT_FALSE(luabridge::push(L, value));
EXPECT_EQ(luabridge::ErrorCode::ClassNotRegistered, luabridge::push(L, value).error());
#endif
}
}
TEST_F(StackTests, Tuple)
{
{
auto value = std::make_tuple(1, 1.0f, "one");
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<decltype(value)>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(1, std::get<0>(*result));
EXPECT_FLOAT_EQ(1.0f, std::get<1>(*result));
EXPECT_STREQ("one", std::get<2>(*result));
}
{
auto value = std::make_tuple(1, std::string("one"));
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<std::tuple<std::string, int>>(L, -1);
ASSERT_FALSE(result);
EXPECT_EQ(luabridge::ErrorCode::InvalidTypeCast, result.error());
}
{
auto value = std::make_tuple(1, 2, 3);
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<std::tuple<int, int>>(L, -1);
ASSERT_FALSE(result);
EXPECT_EQ(luabridge::ErrorCode::InvalidTableSizeInCast, result.error());
}
}
TEST_F(StackTests, TupleNesting)
{
auto value = std::make_tuple(1, std::make_tuple(1, std::make_tuple(1, std::string("one"))));
ASSERT_TRUE(luabridge::push(L, value));
auto result = luabridge::get<decltype(value)>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(1, std::get<0>(*result));
EXPECT_EQ(1, std::get<0>(std::get<1>(*result)));
EXPECT_EQ(1, std::get<0>(std::get<1>(std::get<1>(*result))));
EXPECT_EQ("one", std::get<1>(std::get<1>(std::get<1>(*result))));
}
TEST_F(StackTests, TupleStackOverflow)
{
exhaustStackSpace();
auto value = std::make_tuple(1, 1.0f, "one");
ASSERT_FALSE(luabridge::push(L, value));
}
TEST_F(StackTests, TupleFailUnregistered)
{
{
auto value = std::make_tuple(Unregistered(), 1);
#if LUABRIDGE_HAS_EXCEPTIONS
EXPECT_ANY_THROW(luabridge::push(L, value).error());
#else
ASSERT_FALSE(luabridge::push(L, value));
EXPECT_EQ(luabridge::ErrorCode::ClassNotRegistered, luabridge::push(L, value).error());
#endif
}
{
auto value = std::make_tuple(1, Unregistered());
#if LUABRIDGE_HAS_EXCEPTIONS
EXPECT_ANY_THROW(luabridge::push(L, value).error());
#else
ASSERT_FALSE(luabridge::push(L, value));
EXPECT_EQ(luabridge::ErrorCode::ClassNotRegistered, luabridge::push(L, value).error());
#endif
}
}
TEST_F(StackTests, NilStackOverflow)
{
exhaustStackSpace();
ASSERT_FALSE(luabridge::push(L, luabridge::LuaNil()));
}
TEST_F(StackTests, Nil)
{
(void)luabridge::push(L, luabridge::LuaNil());
ASSERT_TRUE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_FALSE(luabridge::isInstance<float>(L, -1));
ASSERT_FALSE(luabridge::isInstance<double>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
}
TEST_F(StackTests, Bool)
{
(void)luabridge::push(L, true);
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_TRUE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_FALSE(luabridge::isInstance<float>(L, -1));
ASSERT_FALSE(luabridge::isInstance<double>(L, -1));
ASSERT_FALSE(luabridge::isInstance<const char*>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_EQ(true, *luabridge::get<bool>(L, -1));
}
TEST_F(StackTests, Int)
{
(void)luabridge::push(L, 5);
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_TRUE(luabridge::isInstance<int>(L, -1));
ASSERT_TRUE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_TRUE(luabridge::isInstance<float>(L, -1));
ASSERT_TRUE(luabridge::isInstance<double>(L, -1));
ASSERT_FALSE(luabridge::isInstance<const char*>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_EQ(5, *luabridge::get<int>(L, -1));
ASSERT_NEAR(5.f, *luabridge::get<float>(L, -1), 1e-5);
ASSERT_NEAR(5.0, *luabridge::get<double>(L, -1), 1e-6);
}
TEST_F(StackTests, Float)
{
(void)luabridge::push(L, 3.14f);
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_TRUE(luabridge::isInstance<float>(L, -1));
ASSERT_TRUE(luabridge::isInstance<double>(L, -1));
ASSERT_FALSE(luabridge::isInstance<const char*>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string>(L, -1));
ASSERT_FALSE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_NEAR(3.14f, *luabridge::get<float>(L, -1), 1e-5);
ASSERT_NEAR(3.14, *luabridge::get<double>(L, -1), 1e-6);
}
TEST_F(StackTests, CString)
{
(void)luabridge::push(L, "abc");
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_FALSE(luabridge::isInstance<float>(L, -1));
ASSERT_FALSE(luabridge::isInstance<double>(L, -1));
ASSERT_TRUE(luabridge::isInstance<const char*>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_STREQ("abc", *luabridge::get<const char*>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string_view>(L, -1));
}
TEST_F(StackTests, StdString)
{
(void)luabridge::push(L, std::string("abc"));
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_FALSE(luabridge::isInstance<float>(L, -1));
ASSERT_FALSE(luabridge::isInstance<double>(L, -1));
ASSERT_TRUE(luabridge::isInstance<const char*>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_STREQ("abc", *luabridge::get<const char*>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string_view>(L, -1));
}
TEST_F(StackTests, StdStringView)
{
(void)luabridge::push(L, std::string_view("abc"));
ASSERT_FALSE(luabridge::isInstance<luabridge::LuaNil>(L, -1));
ASSERT_FALSE(luabridge::isInstance<bool>(L, -1));
ASSERT_FALSE(luabridge::isInstance<int>(L, -1));
ASSERT_FALSE(luabridge::isInstance<unsigned>(L, -1));
ASSERT_FALSE(luabridge::isInstance<float>(L, -1));
ASSERT_FALSE(luabridge::isInstance<double>(L, -1));
ASSERT_TRUE(luabridge::isInstance<const char*>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string>(L, -1));
ASSERT_TRUE(luabridge::isInstance<std::string_view>(L, -1));
ASSERT_STREQ("abc", *luabridge::get<const char*>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string>(L, -1));
ASSERT_EQ("abc", *luabridge::get<std::string_view>(L, -1));
}
TEST_F(StackTests, VoidPointer)
{
{
void* ptr = reinterpret_cast<void*>(0xdead1984);
(void)luabridge::push(L, ptr);
EXPECT_TRUE(luabridge::isInstance<void*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const void*>(L, -1));
{
auto result = luabridge::get<void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
{
auto result = luabridge::get<const void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
}
{
void* ptr = nullptr;
(void)luabridge::push(L, ptr);
EXPECT_TRUE(luabridge::isInstance<void*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const void*>(L, -1));
{
auto result = luabridge::get<void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
{
auto result = luabridge::get<const void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
}
{
lua_pushnumber(L, 0.0);
EXPECT_FALSE(luabridge::isInstance<void*>(L, -1));
{
auto result = luabridge::get<void*>(L, -1);
EXPECT_FALSE(result);
}
}
}
TEST_F(StackTests, VoidPointerStackOverflow)
{
exhaustStackSpace();
void* ptr = reinterpret_cast<void*>(0xdead1984);
ASSERT_FALSE(luabridge::push(L, ptr));
}
TEST_F(StackTests, ConstVoidPointer)
{
{
const void* ptr = reinterpret_cast<const void*>(0xdead1984);
(void)luabridge::push(L, ptr);
EXPECT_TRUE(luabridge::isInstance<void*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const void*>(L, -1));
{
auto result = luabridge::get<void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
{
auto result = luabridge::get<const void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
}
{
const void* ptr = nullptr;
(void)luabridge::push(L, ptr);
EXPECT_TRUE(luabridge::isInstance<void*>(L, -1));
EXPECT_TRUE(luabridge::isInstance<const void*>(L, -1));
{
auto result = luabridge::get<void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
{
auto result = luabridge::get<const void*>(L, -1);
ASSERT_TRUE(result);
EXPECT_EQ(ptr, *result);
}
}
{
lua_pushnumber(L, 0.0);
EXPECT_FALSE(luabridge::isInstance<const void*>(L, -1));
{
auto result = luabridge::get<const void*>(L, -1);
EXPECT_FALSE(result);
}
}
}
TEST_F(StackTests, ConstVoidPointerStackOverflow)
{
exhaustStackSpace();
const void* ptr = reinterpret_cast<const void*>(0xdead1984);
ASSERT_FALSE(luabridge::push(L, ptr));
}
TEST_F(StackTests, ResultCheck)
{
#if LUABRIDGE_HAS_EXCEPTIONS
EXPECT_ANY_THROW(luabridge::push(L, std::optional<Unregistered>(Unregistered{})).error());
#else
EXPECT_EQ(luabridge::ErrorCode::ClassNotRegistered, luabridge::push(L, std::optional<Unregistered>(Unregistered{})).error());
#endif
}
TEST_F(StackTests, TypeResultCheck)
{
(void)luabridge::push(L, std::string_view("abc"));
EXPECT_EQ(std::string{ "abc" }, luabridge::get<std::string>(L, -1));
EXPECT_EQ(luabridge::get<std::string>(L, -1), std::string{ "abc" });
EXPECT_NE(std::string{ "123" }, luabridge::get<std::string>(L, -1));
EXPECT_NE(luabridge::get<std::string>(L, -1), std::string{ "123" });
EXPECT_EQ(luabridge::ErrorCode::InvalidTypeCast, luabridge::get<int>(L, -1).error());
EXPECT_EQ(luabridge::ErrorCode::InvalidTypeCast, static_cast<std::error_code>(luabridge::get<int>(L, -1)));
}
TEST_F(StackTests, TypeResultValueOr)
{
(void)luabridge::push(L, std::string_view("abc"));
EXPECT_EQ(1337, luabridge::get<int>(L, -1).valueOr(1337));
auto result1 = luabridge::get<int>(L, -1);
EXPECT_EQ(1337, result1.valueOr(1337));
(void)luabridge::push(L, 42);
EXPECT_EQ(42, luabridge::get<int>(L, -1).valueOr(1337));
auto result2 = luabridge::get<int>(L, -1);
EXPECT_EQ(42, result2.valueOr(1337));
}
#if LUABRIDGE_HAS_EXCEPTIONS
TEST_F(StackTests, ResultThrowOnError)
{
exhaustStackSpace();
EXPECT_THROW(luabridge::push(L, 1337).throw_on_error(), std::system_error);
}
TEST_F(StackTests, ResultNoThrowOnError)
{
EXPECT_NO_THROW(luabridge::push(L, 1337).throw_on_error());
}
TEST_F(StackTests, TypeResultThrowOnError)
{
(void)luabridge::push(L, std::string_view("abc"));
EXPECT_THROW(luabridge::get<int>(L, -1).throw_on_error(), std::system_error);
}
TEST_F(StackTests, TypeResultNoThrowOnError)
{
(void)luabridge::push(L, std::string_view("abc"));
EXPECT_NO_THROW(luabridge::get<std::string>(L, -1).throw_on_error());
}
#endif