test: expand LuaRef/TableItem coverage — symmetry, hash contract, move semantics, moveTo variants

Author: kunitoki

Tests/Source/LuaRefTests.cpp

@@ -1697,8 +1697,215 @@ TEST_F(LuaRefTests, TableItemIsValid)
     auto item2 = result()[dynKey];
     EXPECT_TRUE(item2.isValid());
 
-    // Moved-from TableItem is invalid
+    // After move: target is valid, source is invalid
     auto moved = std::move(item2);
     EXPECT_TRUE(moved.isValid());
     EXPECT_FALSE(item2.isValid());
+
+    // Copy-constructed and copy-assigned TableItems are valid
+    auto copied = item;
+    EXPECT_TRUE(item.isValid());
+    EXPECT_TRUE(copied.isValid());
+}
+
+// --- NonMemberComparison additional coverage ---
+
+TEST_F(LuaRefTests, NonMemberComparisonStrings)
+{
+    luabridge::LuaRef hello(L, "hello");
+    luabridge::LuaRef world(L, "world");
+
+    // "hello" < "world" lexicographically
+    EXPECT_TRUE(std::string("hello") < world);
+    EXPECT_TRUE(std::string("hello") <= world);
+    EXPECT_FALSE(std::string("hello") > world);
+    EXPECT_FALSE(std::string("hello") >= world);
+
+    // Equal string values
+    EXPECT_FALSE(std::string("hello") < hello);
+    EXPECT_TRUE(std::string("hello") <= hello);
+    EXPECT_FALSE(std::string("hello") > hello);
+    EXPECT_TRUE(std::string("hello") >= hello);
+
+    EXPECT_FALSE(std::string("world") < world);
+    EXPECT_TRUE(std::string("world") <= world);
+    EXPECT_FALSE(std::string("world") > world);
+    EXPECT_TRUE(std::string("world") >= world);
+}
+
+TEST_F(LuaRefTests, NonMemberComparisonSymmetry)
+{
+    luabridge::LuaRef seven(L, 7);
+    luabridge::LuaRef eight(L, 8);
+
+    // (T op LuaRef) must produce the same answer as (LuaRef reverse-op T)
+    EXPECT_EQ((7 < eight),  static_cast<bool>(eight > 7));
+    EXPECT_EQ((7 <= eight), static_cast<bool>(eight >= 7));
+    EXPECT_EQ((8 > seven),  static_cast<bool>(seven < 8));
+    EXPECT_EQ((8 >= seven), static_cast<bool>(seven <= 8));
+
+    // Equal values
+    EXPECT_EQ((7 < seven),  static_cast<bool>(seven > 7));
+    EXPECT_EQ((7 <= seven), static_cast<bool>(seven >= 7));
+    EXPECT_EQ((7 > seven),  static_cast<bool>(seven < 7));
+    EXPECT_EQ((7 >= seven), static_cast<bool>(seven <= 7));
+}
+
+TEST_F(LuaRefTests, NonMemberEqualityAndInequality)
+{
+    luabridge::LuaRef seven(L, 7);
+    luabridge::LuaRef eight(L, 8);
+
+    EXPECT_TRUE(7 == seven);
+    EXPECT_FALSE(7 == eight);
+    EXPECT_FALSE(8 == seven);
+    EXPECT_TRUE(8 == eight);
+
+    EXPECT_FALSE(7 != seven);
+    EXPECT_TRUE(7 != eight);
+}
+
+// --- Hash additional coverage ---
+
+TEST_F(LuaRefTests, HashBooleans)
+{
+    luabridge::LuaRef t1(L, true);
+    luabridge::LuaRef t2(L, true);
+    luabridge::LuaRef f1(L, false);
+
+    EXPECT_EQ(t1.hash(), t2.hash());
+    EXPECT_NE(t1.hash(), f1.hash());
+}
+
+TEST_F(LuaRefTests, HashNumbers)
+{
+    luabridge::LuaRef a(L, 42);
+    luabridge::LuaRef b(L, 42);
+    luabridge::LuaRef c(L, 43);
+
+    EXPECT_EQ(a.hash(), b.hash());
+    EXPECT_NE(a.hash(), c.hash());
+}
+
+TEST_F(LuaRefTests, HashDistinctTablesDistinct)
+{
+    runLua("hashT1 = {}; hashT2 = {}");
+    auto t1 = luabridge::getGlobal(L, "hashT1");
+    auto t2 = luabridge::getGlobal(L, "hashT2");
+
+    EXPECT_FALSE(t1 == t2);
+    EXPECT_NE(t1.hash(), t2.hash());
+}
+
+TEST_F(LuaRefTests, HashUsableInUnorderedMap)
+{
+    std::unordered_map<luabridge::LuaRef, int> map;
+
+    luabridge::LuaRef key1(L, "mapkey1");
+    luabridge::LuaRef key2(L, "mapkey2");
+
+    map[key1] = 100;
+    map[key2] = 200;
+
+    luabridge::LuaRef key1Copy(L, "mapkey1");
+    EXPECT_EQ(100, map.at(key1Copy));
+    EXPECT_EQ(200, map.at(key2));
+}
+
+// --- TableItem copy/move additional coverage ---
+
+TEST_F(LuaRefTests, TableItemCopyAssignmentSelfAssign)
+{
+    runLua("result = { a = 42 }");
+    auto item = result()["a"];
+    EXPECT_TRUE(item.isValid());
+
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wself-assign-overloaded"
+#endif
+    item = item;
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+    EXPECT_TRUE(item.isValid());
+    EXPECT_EQ(42, item.unsafe_cast<int>());
+}
+
+TEST_F(LuaRefTests, TableItemCopyAssignmentSharesSlot)
+{
+    // After b = a, b proxies the same table slot as a.
+    // Writing through b must also be visible when reading through a.
+    runLua("result = { a = 1, b = 2 }");
+    auto table = result();
+
+    auto a = table["a"];
+    auto b = table["b"];
+
+    b = a;
+    EXPECT_EQ(1, luabridge::LuaRef(b).unsafe_cast<int>());
+
+    b = 99;
+    EXPECT_EQ(99, table["a"].unsafe_cast<int>());
+    EXPECT_EQ(99, luabridge::LuaRef(a).unsafe_cast<int>());
+}
+
+TEST_F(LuaRefTests, TableItemMovedFromDestructible)
+{
+    runLua("result = { key = 1 }");
+    auto item = result()["key"];
+
+    auto moved = std::move(item);
+
+    EXPECT_FALSE(item.isValid());
+    EXPECT_TRUE(moved.isValid());
+    // item goes out of scope here — must not double-unref or crash
+}
+
+TEST_F(LuaRefTests, TableItemMoveAssignReleasesOldRefs)
+{
+    runLua("result = { a = 10, b = 20 }");
+    auto a = result()["a"];
+    auto b = result()["b"];
+
+    b = std::move(a);
+
+    EXPECT_FALSE(a.isValid());
+    EXPECT_TRUE(b.isValid());
+    EXPECT_EQ(10, luabridge::LuaRef(b).unsafe_cast<int>());
+}
+
+// --- moveTo() additional coverage ---
+
+TEST_F(LuaRefTests, MoveToTransfersString)
+{
+    runLua("result = 'hello'");
+    luabridge::LuaRef ref = result();
+    EXPECT_TRUE(ref.isString());
+
+    lua_State* thread = lua_newthread(L);
+    const int threadTop = lua_gettop(thread);
+
+    ref.moveTo(thread);
+
+    EXPECT_EQ(threadTop, lua_gettop(thread));
+    EXPECT_TRUE(ref.isString());
+    EXPECT_EQ("hello", ref.cast<std::string>().valueOr(""));
+}
+
+TEST_F(LuaRefTests, MoveToNilRef)
+{
+    luabridge::LuaRef nilRef(L, luabridge::LuaNil());
+    EXPECT_TRUE(nilRef.isNil());
+
+    lua_State* thread = lua_newthread(L);
+    const int mainTop = lua_gettop(L);
+    const int threadTop = lua_gettop(thread);
+
+    nilRef.moveTo(thread);
+
+    EXPECT_EQ(mainTop, lua_gettop(L));
+    EXPECT_EQ(threadTop, lua_gettop(thread));
+    EXPECT_TRUE(nilRef.isNil());
 }