add test case: nested_objects

Author: peacalm

test/unit_test/nested_objects.cpp

@@ -0,0 +1,250 @@
+// Copyright (c) 2024 Li Shuangquan. All Rights Reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file
+// except in compliance with the License. You may obtain a copy of the License
+// at
+//
+//   http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+#include "main.h"
+
+#if 1
+namespace {
+
+struct A {
+  int i = 1;
+};
+
+struct Ac {
+  const int ci = 11;
+};
+
+struct B {
+  int i = 2;
+  A   a;
+};
+
+struct Bac {
+  Ac ac;
+};
+
+struct Bcac {
+  const Ac cac;
+};
+
+TEST(nested_objects, register_nested_members) {
+  peacalm::luaw l;
+  l.register_member("i", &A::i);
+  l.register_member("ci", &Ac::ci);
+  l.register_member("i", &B::i);
+  l.register_member("a", &B::a);
+  l.register_member<const A(B::*)>("a_as_c", &B::a);
+
+  // l.register_member("ac", &Bac::ac); // Error: no operator=
+  l.register_member<const Ac(Bac::*)>("ac_as_c", &Bac::ac);  // OK: set ac const
+
+  l.register_member("cac", &Bcac::cac);  // OK cac already const
+}
+
+TEST(nested_objects, register_solid_nested_member) {
+  peacalm::luaw l;
+  l.register_member("i", &A::i);
+  l.register_member("i", &B::i);
+  l.register_member("a", &B::a);  // solid member a, which can not be modified
+
+  auto b = std::make_shared<B>();
+  l.set("b", b);
+
+  EXPECT_EQ(l.eval<int>("return b.i"), b->i);
+  EXPECT_TRUE(l.dostring("b.i = 5") == LUA_OK);
+  EXPECT_TRUE(l.dostring("assert(b.i == 5)") == LUA_OK);
+  EXPECT_EQ(l.eval<int>("return b.i"), b->i);
+  EXPECT_EQ(b->i, 5);
+
+  // can't modify b's a
+  int oldbai = b->a.i;
+  EXPECT_EQ(l.eval<int>("return b.a.i"), b->a.i);
+  EXPECT_TRUE(l.dostring("b.a.i = 5") == LUA_OK);
+  EXPECT_TRUE(l.dostring("assert(b.a.i ~= 5);") == LUA_OK);
+  EXPECT_EQ(l.eval<int>("return b.a.i"), oldbai);
+  EXPECT_EQ(b->a.i, oldbai);
+
+  // get a copy of b'a, and can modify it's i
+  EXPECT_EQ(l.dostring("a = b.a"), LUA_OK);
+  EXPECT_EQ(l.eval<int>("return a.i"), oldbai);
+  EXPECT_EQ(l.dostring("a.i = 1212"), LUA_OK);
+  EXPECT_EQ(l.eval<int>("return a.i"), 1212);
+}
+
+TEST(nested_objects, register_member_address) {
+  peacalm::luaw l;
+  l.register_member("i", &A::i);
+  l.register_member("i", &B::i);
+  l.register_member("a", &B::a);
+
+  auto b = std::make_shared<B>();
+  l.set("b", b);
+
+  // get a's non-const ptr.
+  // The first arg could be "const B*" or "auto*", both ok.
+  l.register_member<A* const B::*>(
+      "aptr", [](const B* p) { return &(const_cast<B*>(p)->a); });
+  l.register_member<A* const B::*>(
+      "aptr2", [](auto* p) { return &(const_cast<B*>(p)->a); });
+
+  EXPECT_TRUE(l.dostring("assert(b.aptr == b.aptr2)") == LUA_OK);
+  EXPECT_EQ(l.eval<void*>("return b.aptr"), (void*)(&b->a));
+  EXPECT_EQ(l.eval<void*>("return b.aptr2"), (void*)(&b->a));
+  {
+    auto t = l.eval<std::tuple<void*, void*>>("return b.aptr, b.aptr2");
+    EXPECT_EQ(std::get<0>(t), std::get<1>(t));
+  }
+
+#if 0
+  {
+    // maybe compile error after cpp17
+    auto vb = std::make_shared<volatile B>();
+
+    l.set("vb", vb);
+    EXPECT_TRUE(l.dostring("assert(vb.aptr == vb.aptr2)") == LUA_OK);
+    bool supportv = PEACALM_LUAW_SUPPORT_VOLATILE_OBJECT;
+    EXPECT_EQ((l.eval<void*>("return vb.aptr") == (void*)(&vb->a)), supportv);
+    EXPECT_EQ((l.eval<void*>("return vb.aptr2") == (void*)(&vb->a)), supportv);
+  }
+#endif
+
+  // get a's const ptr
+  l.register_member<const A* const B::*>("acptr",
+                                         [](const B* p) { return &(p->a); });
+  l.register_member<const A* const B::*>("acptr2",
+                                         [](auto* p) { return &(p->a); });
+
+  EXPECT_TRUE(l.dostring("assert(b.acptr == b.acptr2)") == LUA_OK);
+  EXPECT_EQ(l.eval<void*>("return b.acptr"), (void*)(&b->a));
+  EXPECT_EQ(l.eval<void*>("return b.acptr2"), (void*)(&b->a));
+  {
+    auto t = l.eval<std::tuple<void*, void*>>("return b.acptr, b.acptr2");
+    EXPECT_EQ(std::get<0>(t), std::get<1>(t));
+  }
+
+  // check metatable of ptr
+  {
+    EXPECT_EQ(l.gettop(), 0);
+
+    EXPECT_EQ(l.dostring("aptr = b.aptr"), LUA_OK);
+    l.gseek("aptr");
+    std::string mtaptr = l.get_metatable_name(-1);
+    l.pop();
+
+    EXPECT_EQ(l.dostring("acptr = b.acptr"), LUA_OK);
+    l.gseek("acptr");
+    std::string mtacptr = l.get_metatable_name(-1);
+    l.pop();
+
+    watch(mtaptr, mtacptr);
+    EXPECT_NE(mtaptr, mtacptr);
+
+    EXPECT_EQ(l.gettop(), 0);
+
+    {
+      l.eval<void>("print('b.aptr  = ', b.aptr, b.aptr2)");
+      l.eval<void>("print('b.acptr = ', b.acptr, b.acptr2)");
+
+      // metatable of aptr now equals to acptr's
+      l.eval<void>("print('aptr  = ', aptr)");
+      l.eval<void>("print('acptr = ', acptr)");
+    }
+
+    puts("");
+
+    {
+      // modify order
+      l.eval<void>("print('b.acptr = ', b.acptr, b.acptr2)");
+      l.eval<void>("print('b.aptr  = ', b.aptr, b.aptr2)");
+
+      // metatable of acptr now equals to aptr's
+      l.eval<void>("print('aptr  = ', aptr)");
+      l.eval<void>("print('acptr = ', acptr)");
+    }
+  }
+
+  // change member a
+  {
+    EXPECT_EQ(b->a.i, 1);
+    EXPECT_EQ(l.eval<int>("return b.a.i"), 1);
+    b->a.i = 2;
+    EXPECT_EQ(l.eval<int>("return b.a.i"), 2);
+    A* p = l.eval<A*>("return b.aptr");
+    p->i = 3;
+    EXPECT_EQ(l.eval<int>("return b.a.i"), 3);
+    EXPECT_EQ(b->a.i, 3);
+
+    // modify b.a.i in Lua by aptr
+    EXPECT_EQ(l.eval<int>("return b.aptr.i"), 3);
+    EXPECT_EQ(l.dostring("b.aptr.i = 4"), LUA_OK);
+    EXPECT_EQ(l.eval<int>("return b.aptr.i"), 4);
+    EXPECT_EQ(l.eval<int>("return b.acptr.i"), 4);
+
+    // can't modify by acptr
+    EXPECT_NE(l.dostring("b.acptr.i = 5"), LUA_OK);
+    l.log_error_out();
+  }
+}
+
+// TEST(nested_objects, volatile_outer) {
+//   peacalm::luaw l;
+
+//   B x, y;
+//   x = y;
+
+//   {
+//     volatile B b;
+//     l.set("b", &b);
+//     bool failed;
+//     int  bi = l.eval_int("return b.i", 0, false, &failed);
+//     EXPECT_FALSE(failed);
+
+// #if PEACALM_LUAW_SUPPORT_VOLATILE_OBJECT
+//     EXPECT_EQ(bi, 1);
+// #else
+//     EXPECT_EQ(bi, 0);
+// #endif
+//     // int retcode = l.dostring("acopy = b.a; acopy.i = 100");
+//     // if (retcode != LUA_OK) l.log_error_out();
+//     // A a = l.eval<A>("return acopy");
+//     // watch(a.i);
+//   }
+//   EXPECT_TRUE(true);
+// }
+
+// TEST(nested_objects, raw) {
+//   peacalm::luaw l;
+//   l.register_member("i", &A::i);
+//   l.register_member("i", &B::i);
+//   // l.register_member("a", &B::a);
+
+//   // VA va{};
+//   // l.set("va", &va);
+
+//   // auto sva = std::make_shared<VA>();
+//   // l.set("sva", sva);
+
+//   EXPECT_TRUE(true);
+//   watch(PEACALM_LUAW_SUPPORT_VOLATILE_OBJECT);
+//   watch(PEACALM_LUAW_SUPPORT_VOLATILE_OBJECT + 1);
+
+// #if PEACALM_LUAW_SUPPORT_VOLATILE_OBJECT
+// // EXPECT_TRUE(0);
+// #else
+
+// #endif
+// }
+
+}  // namespace
+#endif