[test] ConstructArray, DestructArray, Allocate and Deallocate

Author: aaronj0

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1987,6 +1987,49 @@ TEST(FunctionReflectionTest, Construct) {
   clang_Interpreter_dispose(I);
 }
 
+// Test zero initialization of PODs and default initialization cases
+TEST(FunctionReflectionTest, ConstructPOD) {
+#ifdef EMSCRIPTEN
+#if CLANG_VERSION_MAJOR < 20
+  GTEST_SKIP() << "Test fails for Emscipten builds";
+#endif
+#endif
+  if (llvm::sys::RunningOnValgrind())
+    GTEST_SKIP() << "XFAIL due to Valgrind report";
+#ifdef _WIN32
+  GTEST_SKIP() << "Disabled on Windows. Needs fixing.";
+#endif
+  std::vector<const char*> interpreter_args = {"-include", "new"};
+  Cpp::CreateInterpreter(interpreter_args);
+
+  Interp->declare(R"(
+    namespace PODS {
+      struct SomePOD_B {
+          int fInt;
+      };
+      struct SomePOD_C {
+          int fInt;
+          double fDouble;
+      };
+    })");
+
+  auto *ns = Cpp::GetNamed("PODS");
+  Cpp::TCppScope_t scope = Cpp::GetNamed("SomePOD_B", ns);
+  EXPECT_TRUE(scope);
+  Cpp::TCppObject_t object = Cpp::Construct(scope);
+  EXPECT_TRUE(object != nullptr);
+  int* fInt = reinterpret_cast<int*>(reinterpret_cast<char*>(object));
+  EXPECT_TRUE(*fInt == 0);
+
+  scope = Cpp::GetNamed("SomePOD_C", ns);
+  EXPECT_TRUE(scope);
+  object = Cpp::Construct(scope);
+  EXPECT_TRUE(object);
+  auto* fDouble =
+      reinterpret_cast<double*>(reinterpret_cast<char*>(object) + sizeof(int));
+  EXPECT_EQ(*fDouble, 0.0);
+}
+
 // Test nested constructor calls
 TEST(FunctionReflectionTest, ConstructNested) {
 #ifdef EMSCRIPTEN
@@ -2050,6 +2093,61 @@ TEST(FunctionReflectionTest, ConstructNested) {
   output.clear();
 }
 
+TEST(FunctionReflectionTest, ConstructArray) {
+#if defined(EMSCRIPTEN)
+  GTEST_SKIP() << "Test fails for Emscripten builds";
+#endif
+  if (llvm::sys::RunningOnValgrind())
+    GTEST_SKIP() << "XFAIL due to Valgrind report";
+#ifdef _WIN32
+  GTEST_SKIP() << "Disabled on Windows. Needs fixing.";
+#endif
+#if defined(__APPLE__) && (CLANG_VERSION_MAJOR == 16)
+  GTEST_SKIP() << "Test fails on Clang16 OS X";
+#endif
+
+  Cpp::CreateInterpreter();
+
+  Interp->declare(R"(
+      #include <new>
+      extern "C" int printf(const char*,...);
+      class C {
+        int x;
+        C() {
+          x = 42;
+          printf("\nConstructor Executed\n");
+        }
+      };
+      )");
+
+  Cpp::TCppScope_t scope = Cpp::GetNamed("C");
+  std::string output;
+
+  size_t a = 5;                          // Construct an array of 5 objects
+  void* where = Cpp::Allocate(scope, a); // operator new
+
+  testing::internal::CaptureStdout();
+  EXPECT_TRUE(where == Cpp::Construct(scope, where, a)); // placement new
+  // Check for the value of x which should be at the start of the object.
+  EXPECT_TRUE(*(int*)where == 42);
+  // Check for the value of x in the second object
+  int* obj = reinterpret_cast<int*>(reinterpret_cast<char*>(where) +
+                                    Cpp::SizeOf(scope));
+  EXPECT_TRUE(*obj == 42);
+
+  // Check for the value of x in the last object
+  obj = reinterpret_cast<int*>(reinterpret_cast<char*>(where) +
+                               (Cpp::SizeOf(scope) * 4));
+  EXPECT_TRUE(*obj == 42);
+  Cpp::Destruct(where, scope, /*withFree=*/false, 5);
+  Cpp::Deallocate(scope, where, 5);
+  output = testing::internal::GetCapturedStdout();
+  EXPECT_EQ(output,
+            "\nConstructor Executed\n\nConstructor Executed\n\nConstructor "
+            "Executed\n\nConstructor Executed\n\nConstructor Executed\n");
+  output.clear();
+}
+
 TEST(FunctionReflectionTest, Destruct) {
 #ifdef EMSCRIPTEN
   GTEST_SKIP() << "Test fails for Emscipten builds";
@@ -2107,6 +2205,85 @@ TEST(FunctionReflectionTest, Destruct) {
   clang_Interpreter_dispose(I);
 }
 
+TEST(FunctionReflectionTest, DestructArray) {
+#ifdef EMSCRIPTEN
+  GTEST_SKIP() << "Test fails for Emscipten builds";
+#endif
+  if (llvm::sys::RunningOnValgrind())
+    GTEST_SKIP() << "XFAIL due to Valgrind report";
+
+#ifdef _WIN32
+  GTEST_SKIP() << "Disabled on Windows. Needs fixing.";
+#endif
+#if defined(__APPLE__) && (CLANG_VERSION_MAJOR == 16)
+  GTEST_SKIP() << "Test fails on Clang16 OS X";
+#endif
+
+  std::vector<const char*> interpreter_args = {"-include", "new"};
+  Cpp::CreateInterpreter(interpreter_args);
+
+  Interp->declare(R"(
+      #include <new>
+      extern "C" int printf(const char*,...);
+      class C {
+        int x;
+        C() {
+          printf("\nCtor Executed\n");
+          x = 42;
+        }
+        ~C() {
+          printf("\nDestructor Executed\n");
+        }
+      };
+      )");
+
+  Cpp::TCppScope_t scope = Cpp::GetNamed("C");
+  std::string output;
+
+  size_t a = 5;                          // Construct an array of 5 objects
+  void* where = Cpp::Allocate(scope, a); // operator new
+  EXPECT_TRUE(where == Cpp::Construct(scope, where, a)); // placement new
+
+  // verify the array of objects has been constructed
+  int* obj = reinterpret_cast<int*>(reinterpret_cast<char*>(where) +
+                                    Cpp::SizeOf(scope) * 4);
+  EXPECT_TRUE(*obj == 42);
+
+  testing::internal::CaptureStdout();
+  // destruct 3 out of 5 objects
+  Cpp::Destruct(where, scope, false, 3);
+  output = testing::internal::GetCapturedStdout();
+
+  EXPECT_EQ(
+      output,
+      "\nDestructor Executed\n\nDestructor Executed\n\nDestructor Executed\n");
+  output.clear();
+  testing::internal::CaptureStdout();
+
+  // destruct the rest
+  auto *new_head = reinterpret_cast<void*>(reinterpret_cast<char*>(where) +
+                                          (Cpp::SizeOf(scope) * 3));
+  Cpp::Destruct(new_head, scope, false, 2);
+
+  output = testing::internal::GetCapturedStdout();
+  EXPECT_EQ(output, "\nDestructor Executed\n\nDestructor Executed\n");
+  output.clear();
+
+  // deallocate since we call the destructor withFree = false
+  Cpp::Deallocate(scope, where, 5);
+
+  // perform the same withFree=true
+  where = Cpp::Allocate(scope, a);
+  EXPECT_TRUE(where == Cpp::Construct(scope, where, a));
+  testing::internal::CaptureStdout();
+  // FIXME : This should work with the array of objects as well
+  // Cpp::Destruct(where, scope, true, 5);
+  Cpp::Destruct(where, scope, true);
+  output = testing::internal::GetCapturedStdout();
+  EXPECT_EQ(output, "\nDestructor Executed\n");
+  output.clear();
+}
+
 TEST(FunctionReflectionTest, UndoTest) {
 #ifdef _WIN32
   GTEST_SKIP() << "Disabled on Windows. Needs fixing.";