Merge lp:~marcustomlinson/v8-cpp/add_tests into lp:v8-cpp

[Marcus Tomlinson]

Added tests

[lp:~marcustomlinson/v8-cpp/add_tests]

37. By Marcus Tomlinson on 2015-07-02

Merged v8runner

38. By Marcus Tomlinson on 2015-07-02

Merged v8runner

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-07-02 11:59:44 +0000
+++ CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -9,7 +9,7 @@
     -fno-permissive
     -pedantic
     -Wall
-    -Wextra
+#    -Wextra
     -fPIC
 )
 
@@ -21,6 +21,9 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/deps/v8/out/native/obj.target/tools/gyp
 )
 
+add_subdirectory(example)
 add_subdirectory(src)
-add_subdirectory(test)
 add_subdirectory(v8runner)
+
+enable_testing()
+add_subdirectory(tests)
 
=== renamed directory 'test' => 'example'
=== modified file 'example/CMakeLists.txt'
--- test/CMakeLists.txt	2015-07-02 11:59:44 +0000
+++ example/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -6,20 +6,20 @@
 
 file(
     GLOB
-    TEST_FILES
+    EXAMPLE_FILES
     *.h *.cpp *.js
 )
 
-configure_file(test.js test.js)
+configure_file(example.js example.js)
 
 add_library(
-    v8-cpp-test SHARED
-    ${TEST_FILES}
+    v8-cpp-example SHARED
+    ${EXAMPLE_FILES}
 )
 
-# This line sets the output binary name to "v8-cpp-exampleX.node"
+# This line sets the output binary name to "v8-cpp-example.node"
 set_target_properties(
-    v8-cpp-test
+    v8-cpp-example
     PROPERTIES
     PREFIX ""
     SUFFIX ".node"
 
=== renamed file 'test/test.js' => 'example/example.js'
--- test/test.js	2015-06-10 05:57:04 +0000
+++ example/example.js	2015-07-02 11:59:44 +0000
@@ -1,4 +1,4 @@
-var addon = require('./v8-cpp-test');
+var addon = require('./v8-cpp-example');
 
 var obj = addon.new_MyObject(10);
 console.log( obj.plus_one() ); // 11
 
=== renamed file 'test/addon.cpp' => 'example/module.cpp'
=== added directory 'tests'
=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -0,0 +1,12 @@
+include(FindGMock)
+
+include_directories(
+  ${GTEST_INCLUDE_DIRS}
+  ${GMOCK_INCLUDE_DIRS}
+  ${TEST_INCLUDE_DIRS}
+)
+
+add_subdirectory(functions)
+add_subdirectory(members)
+add_subdirectory(methods)
+add_subdirectory(objects)
 
=== added directory 'tests/functions'
=== added file 'tests/functions/CMakeLists.txt'
--- tests/functions/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/functions/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -0,0 +1,35 @@
+# MODULE
+add_library(
+    test-functions-module SHARED
+    module.cpp
+)
+
+# This line sets the output binary name to "<target_name>.node"
+set_target_properties(
+    test-functions-module
+    PROPERTIES
+    PREFIX ""
+    SUFFIX ".node"
+)
+
+# TEST
+add_executable(
+    test-functions
+    test.h
+    test.cpp
+)
+
+target_link_libraries(
+    test-functions
+
+    v8-cpp
+
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+    ${TEST_LDFLAGS}
+)
+
+add_test(
+    test-functions
+    test-functions
+)
 
=== added file 'tests/functions/module.cpp'
--- tests/functions/module.cpp	1970-01-01 00:00:00 +0000
+++ tests/functions/module.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,28 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+using namespace v8;
+
+void InitAll(Handle<Object> exports)
+{
+    // Get current isolate
+    Isolate* isolate = Isolate::GetCurrent();
+
+    // Prepare TestClass binding
+    v8cpp::Class<TestCaller> testcaller(isolate);
+    testcaller
+            .set_constructor<Local<Function>>()
+            .add_method("call_me", &TestCaller::call_me);
+
+    // Prepare module
+    v8cpp::Module module(isolate);
+
+    module.add_class("TestCaller", testcaller);
+    module.add_function("simple_function", &simple_function);
+    module.add_function("complex_function", &complex_function);
+
+    exports->SetPrototype(module.create_prototype());
+}
+
+V8CPP_MODULE(addon, InitAll)
 
=== added file 'tests/functions/test.cpp'
--- tests/functions/test.cpp	1970-01-01 00:00:00 +0000
+++ tests/functions/test.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,57 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+#include <gtest/gtest.h>
+
+// FUNCTIONS
+// call JS function from C++ (callback)
+// call C++ functions from JS
+
+TEST(Test, call_to_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto callback_result = v8cpp::run_script<std::string>(isolate,
+    R"(
+        var module = require("./test-functions-module");
+
+        var caller = new module.TestCaller(function(message)
+        {
+            return message + " world" // "hello world"
+        });
+
+        caller.call_me();
+    )");
+
+    EXPECT_EQ(callback_result, "hello world");
+
+    isolate->Dispose();
+}
+
+TEST(Test, call_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<std::string>(isolate,
+    R"(
+        var module = require("./test-functions-module");
+        module.simple_function();
+    )");
+
+    EXPECT_EQ(result, "hello there");
+
+    auto result2 = v8cpp::run_script<std::vector<float>>(isolate,
+    R"(
+        var module = require("./test-functions-module");
+        module.complex_function(4, "3", 2.1, false);
+    )");
+
+    ASSERT_EQ(result2.size(), 4);
+    EXPECT_FLOAT_EQ(result2[0], 4);
+    EXPECT_FLOAT_EQ(result2[1], 3);
+    EXPECT_FLOAT_EQ(result2[2], 2.1);
+    EXPECT_FLOAT_EQ(result2[3], 0);
+
+    isolate->Dispose();
+}
 
=== added file 'tests/functions/test.h'
--- tests/functions/test.h	1970-01-01 00:00:00 +0000
+++ tests/functions/test.h	2015-07-02 11:59:44 +0000
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include <v8-cpp.h>
+
+class TestCaller
+{
+public:
+    explicit TestCaller(v8::Local<v8::Function> const& cb)
+        : cb_(v8::Isolate::GetCurrent(), cb)
+    {
+    }
+
+    std::string call_me() const
+    {
+        v8::Local<v8::Function> cb = v8cpp::to_local<v8::Function>(v8::Isolate::GetCurrent(), cb_);
+        auto result = v8cpp::call_v8(v8::Isolate::GetCurrent(), cb, "hello");
+        return v8cpp::from_v8<std::string>(v8::Isolate::GetCurrent(), result);
+    }
+
+private:
+    v8::Persistent<v8::Function> cb_;
+};
+
+std::string simple_function()
+{
+    return "hello there";
+}
+
+std::vector<float> complex_function(int first, std::string const& second, float third, bool forth)
+{
+    EXPECT_EQ(first, 4);
+    EXPECT_EQ(second, "3");
+    EXPECT_FLOAT_EQ(third, 2.1);
+    EXPECT_EQ(forth, false);
+
+    std::vector<float> num_list;
+    num_list.push_back(first);
+    num_list.push_back(stoi(second));
+    num_list.push_back(third);
+    num_list.push_back(forth);
+    return num_list;
+}
 
=== added directory 'tests/members'
=== added file 'tests/members/CMakeLists.txt'
--- tests/members/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/members/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -0,0 +1,35 @@
+# MODULE
+add_library(
+    test-members-module SHARED
+    module.cpp
+)
+
+# This line sets the output binary name to "<target_name>.node"
+set_target_properties(
+    test-members-module
+    PROPERTIES
+    PREFIX ""
+    SUFFIX ".node"
+)
+
+# TEST
+add_executable(
+    test-members
+    test.h
+    test.cpp
+)
+
+target_link_libraries(
+    test-members
+
+    v8-cpp
+
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+    ${TEST_LDFLAGS}
+)
+
+add_test(
+    test-members
+    test-members
+)
 
=== added file 'tests/members/module.cpp'
--- tests/members/module.cpp	1970-01-01 00:00:00 +0000
+++ tests/members/module.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,29 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+using namespace v8;
+
+void InitAll(Handle<Object> exports)
+{
+    // Get current isolate
+    Isolate* isolate = Isolate::GetCurrent();
+
+    // Prepare TestStruct binding
+    v8cpp::Class<TestStruct> teststruct(isolate);
+    teststruct
+            .set_constructor()
+            .add_member("bool_value", &TestStruct::bool_value)
+            .add_member("int_value", &TestStruct::int_value)
+            .add_member("float_value", &TestStruct::float_value)
+            .add_member("string_value", &TestStruct::string_value);
+
+    // Prepare module
+    v8cpp::Module module(isolate);
+
+    module.add_class("TestStruct", teststruct);
+
+    exports->SetPrototype(module.create_prototype());
+}
+
+V8CPP_MODULE(addon, InitAll)
 
=== added file 'tests/members/test.cpp'
--- tests/members/test.cpp	1970-01-01 00:00:00 +0000
+++ tests/members/test.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,46 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+#include <gtest/gtest.h>
+
+// MEMBERS
+// get/set class/struct members from JS
+
+TEST(Test, get_set_members_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto test_struct = v8cpp::run_script<TestStruct>(isolate,
+    R"(
+        var module = require("./test-members-module");
+        var test_struct = new module.TestStruct();
+        test_struct;
+    )");
+
+    EXPECT_EQ(test_struct.bool_value, true);
+    EXPECT_EQ(test_struct.int_value, 9);
+    EXPECT_FLOAT_EQ(test_struct.float_value, 0.1);
+    EXPECT_EQ(test_struct.string_value, "hello");
+
+    test_struct = v8cpp::run_script<TestStruct>(isolate,
+    R"(
+        var module = require("./test-members-module");
+        var test_struct = new module.TestStruct();
+        if (test_struct.bool_value)
+        {
+            test_struct.bool_value = false;
+            test_struct.int_value = -1;
+            test_struct.float_value = test_struct.int_value + 0.12;
+            test_struct.string_value = test_struct.string_value + " there";
+        }
+        test_struct;
+    )");
+
+    EXPECT_EQ(test_struct.bool_value, false);
+    EXPECT_EQ(test_struct.int_value, -1);
+    EXPECT_FLOAT_EQ(test_struct.float_value, -0.88);
+    EXPECT_EQ(test_struct.string_value, "hello there");
+
+    isolate->Dispose();
+}
 
=== added file 'tests/members/test.h'
--- tests/members/test.h	1970-01-01 00:00:00 +0000
+++ tests/members/test.h	2015-07-02 11:59:44 +0000
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <gtest/gtest.h>
+
+struct TestStruct
+{
+    bool bool_value = true;
+    int int_value = 9;
+    float float_value = 0.1;
+    std::string string_value = "hello";
+};
 
=== added directory 'tests/methods'
=== added file 'tests/methods/CMakeLists.txt'
--- tests/methods/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/methods/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -0,0 +1,35 @@
+# MODULE
+add_library(
+    test-methods-module SHARED
+    module.cpp
+)
+
+# This line sets the output binary name to "<target_name>.node"
+set_target_properties(
+    test-methods-module
+    PROPERTIES
+    PREFIX ""
+    SUFFIX ".node"
+)
+
+# TEST
+add_executable(
+    test-methods
+    test.h
+    test.cpp
+)
+
+target_link_libraries(
+    test-methods
+
+    v8-cpp
+
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+    ${TEST_LDFLAGS}
+)
+
+add_test(
+    test-methods
+    test-methods
+)
 
=== added file 'tests/methods/module.cpp'
--- tests/methods/module.cpp	1970-01-01 00:00:00 +0000
+++ tests/methods/module.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,32 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+using namespace v8;
+
+void InitAll(Handle<Object> exports)
+{
+    // Get current isolate
+    Isolate* isolate = Isolate::GetCurrent();
+
+    // Prepare TestClass binding
+    v8cpp::Class<TestClass_OL> testclass(isolate);
+    testclass
+            .add_inheritance<BaseTestClass>()
+            .add_inheritance<TestClass>()
+            .set_constructor()
+            .add_method("regular_method", &TestClass::regular_method)
+            .add_method("static_method", &TestClass::static_method)
+            .add_method("base_method", &BaseTestClass::base_method)
+            .add_method("virtual_method", &TestClass::virtual_method)
+            .add_method("overload_method", &TestClass_OL::overload_method);
+
+    // Prepare module
+    v8cpp::Module module(isolate);
+
+    module.add_class("TestClass", testclass);
+
+    exports->SetPrototype(module.create_prototype());
+}
+
+V8CPP_MODULE(addon, InitAll)
 
=== added file 'tests/methods/test.cpp'
--- tests/methods/test.cpp	1970-01-01 00:00:00 +0000
+++ tests/methods/test.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,100 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+#include <gtest/gtest.h>
+
+// METHODS
+// call regular class methods from JS
+// call static class methods from JS
+// call base class methods from JS (inheritance)
+// call overridden class methods from JS (inheritance)
+// call overloaded class methods from JS
+
+TEST(Test, call_regular_method_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        var test_object = new module.TestClass();
+        test_object.regular_method();
+    )");
+
+    EXPECT_EQ(result, 2);
+
+    isolate->Dispose();
+}
+
+TEST(Test, call_static_method_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        module.TestClass.static_method();
+    )");
+
+    EXPECT_EQ(result, 3);
+
+    isolate->Dispose();
+}
+
+TEST(Test, call_base_method_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        var test_object = new module.TestClass();
+        test_object.base_method();
+    )");
+
+    EXPECT_EQ(result, 1);
+
+    isolate->Dispose();
+}
+
+TEST(Test, call_override_method_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        var test_object = new module.TestClass();
+        test_object.virtual_method();
+    )");
+
+    EXPECT_EQ(result, 4);
+
+    isolate->Dispose();
+}
+
+TEST(Test, call_overload_method_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        var test_object = new module.TestClass();
+        test_object.overload_method(5);
+    )");
+
+    EXPECT_EQ(result, 5);
+
+    auto result2 = v8cpp::run_script<std::string>(isolate,
+    R"(
+        var module = require("./test-methods-module");
+        var test_object = new module.TestClass();
+        test_object.overload_method(1, 5);
+    )");
+
+    EXPECT_EQ(result2, "6");
+
+    isolate->Dispose();
+}
 
=== added file 'tests/methods/test.h'
--- tests/methods/test.h	1970-01-01 00:00:00 +0000
+++ tests/methods/test.h	2015-07-02 11:59:44 +0000
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include <v8-cpp.h>
+
+class BaseTestClass
+{
+public:
+    virtual ~BaseTestClass() = default;
+
+    int base_method()
+    {
+        return 1;
+    }
+
+    virtual int virtual_method() = 0;
+};
+
+class TestClass : public BaseTestClass
+{
+public:
+    virtual ~TestClass() = default;
+
+    int regular_method()
+    {
+        return 2;
+    }
+
+    static int static_method()
+    {
+        return 3;
+    }
+
+    int virtual_method() override
+    {
+        return 4;
+    }
+
+    int overload_method(int a)
+    {
+        return a;
+    }
+
+    std::string overload_method(int a, int b)
+    {
+        return std::to_string(a + b);
+    }
+};
+
+class TestClass_OL : public TestClass
+{
+public:
+    using TestClass::TestClass;
+
+    v8::Local<v8::Value> overload_method(v8::FunctionCallbackInfo<v8::Value> const& args)
+    {
+        if (args.Length() == 1)
+        {
+            int arg = v8cpp::from_v8<int>(v8::Isolate::GetCurrent(), args[0]);
+            return v8cpp::to_v8(v8::Isolate::GetCurrent(), TestClass::overload_method(arg));
+        }
+        else if (args.Length() == 2)
+        {
+            int arg = v8cpp::from_v8<int>(v8::Isolate::GetCurrent(), args[0]);
+            int arg2 = v8cpp::from_v8<int>(v8::Isolate::GetCurrent(), args[1]);
+            return v8cpp::to_v8(v8::Isolate::GetCurrent(), TestClass::overload_method(arg, arg2));
+        }
+        return v8cpp::to_v8(v8::Isolate::GetCurrent(), 0);
+    }
+};
 
=== added directory 'tests/objects'
=== added file 'tests/objects/CMakeLists.txt'
--- tests/objects/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/objects/CMakeLists.txt	2015-07-02 11:59:44 +0000
@@ -0,0 +1,35 @@
+# MODULE
+add_library(
+    test-objects-module SHARED
+    module.cpp
+)
+
+# This line sets the output binary name to "<target_name>.node"
+set_target_properties(
+    test-objects-module
+    PROPERTIES
+    PREFIX ""
+    SUFFIX ".node"
+)
+
+# TEST
+add_executable(
+    test-objects
+    test.h
+    test.cpp
+)
+
+target_link_libraries(
+    test-objects
+
+    v8-cpp
+
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+    ${TEST_LDFLAGS}
+)
+
+add_test(
+    test-objects
+    test-objects
+)
 
=== added file 'tests/objects/module.cpp'
--- tests/objects/module.cpp	1970-01-01 00:00:00 +0000
+++ tests/objects/module.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,40 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+using namespace v8;
+
+void InitAll(Handle<Object> exports)
+{
+    // Get current isolate
+    Isolate* isolate = Isolate::GetCurrent();
+
+    // Prepare TestClass binding
+    v8cpp::Class<TestClass> testclass(isolate);
+    testclass
+            .set_constructor<int, int>()
+            .add_method("i", &TestClass::i)
+            .add_method("embedded_class_ptr", &TestClass::embedded_class_ptr)
+            .add_method("embedded_class_ref", &TestClass::embedded_class_ref)
+            .add_method("embedded_class_copy", &TestClass::embedded_class_copy)
+            .add_method("replace_i", &TestClass::replace_i)
+            .add_method("add_i", &TestClass::add_i);
+
+    // Prepare EmbeddedTestClass binding
+    v8cpp::Class<EmbeddedTestClass> embeddedtestclass(isolate);
+    embeddedtestclass
+            .set_constructor<int, int>()
+            .add_method("i", &EmbeddedTestClass::i);
+
+    // Prepare module
+    v8cpp::Module module(isolate);
+
+    module.add_class("TestClass", testclass);
+    module.add_class("EmbeddedTestClass", embeddedtestclass);
+
+    module.add_function("new_TestClass", &new_TestClass);
+
+    exports->SetPrototype(module.create_prototype());
+}
+
+V8CPP_MODULE(addon, InitAll)
 
=== added file 'tests/objects/test.cpp'
--- tests/objects/test.cpp	1970-01-01 00:00:00 +0000
+++ tests/objects/test.cpp	2015-07-02 11:59:44 +0000
@@ -0,0 +1,108 @@
+#include "test.h"
+
+#include <v8-cpp.h>
+
+#include <gtest/gtest.h>
+
+// OBJECTS
+// construct class via new() from JS
+// construct class via factory methods from JS (constructor overloads)
+// move/ref objects to JS
+// move/ref objects back to C++
+
+TEST(Test, construct_class_via_new)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto test_object = v8cpp::run_script<TestClass>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = new module.TestClass(1, 2);
+        test_object;
+    )");
+
+    EXPECT_EQ(test_object.i(), 3);
+
+    isolate->Dispose();
+}
+
+TEST(Test, construct_class_via_factory)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto test_object = v8cpp::run_script<TestClass>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        test_object;
+    )");
+
+    EXPECT_EQ(test_object.i(), 3);
+
+    isolate->Dispose();
+}
+
+TEST(Test, object_to_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto test_object = v8cpp::run_script<EmbeddedTestClass*>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        test_object.embedded_class_ptr();
+    )");
+
+    EXPECT_EQ(test_object->i(), -1);
+
+    auto test_object2 = v8cpp::run_script<EmbeddedTestClass&>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        test_object.embedded_class_ref();
+    )");
+
+    EXPECT_EQ(test_object2.i(), -1);
+
+    auto test_object3 = v8cpp::run_script<EmbeddedTestClass>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        test_object.embedded_class_copy();
+    )");
+
+    EXPECT_EQ(test_object3.i(), -1);
+
+    isolate->Dispose();
+}
+
+TEST(Test, object_from_js)
+{
+    v8::Isolate* isolate = v8::Isolate::New();
+
+    auto test_object = v8cpp::run_script<TestClass>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        var test_object2 = module.new_TestClass(1, 2);
+
+        test_object.replace_i(test_object2.embedded_class_copy());
+        test_object;
+    )");
+
+    EXPECT_EQ(test_object.i(), -1);
+
+    auto result = v8cpp::run_script<int>(isolate,
+    R"(
+        var module = require("./test-objects-module");
+        var test_object = module.new_TestClass(1, 2);
+        var test_object2 = module.new_TestClass(1, 2);
+
+        test_object.add_i(test_object.embedded_class_ptr(),
+                          test_object2.embedded_class_ref());
+    )");
+
+    EXPECT_EQ(result, -2);
+
+    isolate->Dispose();
+}
 
=== added file 'tests/objects/test.h'
--- tests/objects/test.h	1970-01-01 00:00:00 +0000
+++ tests/objects/test.h	2015-07-02 11:59:44 +0000
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <gtest/gtest.h>
+
+class EmbeddedTestClass
+{
+public:
+    EmbeddedTestClass(int a, int b)
+    {
+        EXPECT_EQ(a, 1);
+        EXPECT_EQ(b, 2);
+        i_ = a - b;
+    }
+
+    int i() const
+    {
+        return i_;
+    }
+
+private:
+    int i_;
+};
+
+class TestClass
+{
+public:
+    TestClass(int a, int b)
+        : embedded_class_(a, b)
+    {
+        EXPECT_EQ(a, 1);
+        EXPECT_EQ(b, 2);
+        i_ = a + b;
+    }
+
+    int i() const
+    {
+        return i_;
+    }
+
+    EmbeddedTestClass* embedded_class_ptr()
+    {
+        return &embedded_class_;
+    }
+
+    EmbeddedTestClass& embedded_class_ref()
+    {
+        return embedded_class_;
+    }
+
+    EmbeddedTestClass embedded_class_copy()
+    {
+        return embedded_class_;
+    }
+
+    void replace_i(EmbeddedTestClass const& other)
+    {
+        i_ = other.i();
+    }
+
+    int add_i(EmbeddedTestClass const& other, EmbeddedTestClass const& other2)
+    {
+        return other.i() + other2.i();
+    }
+
+private:
+    EmbeddedTestClass embedded_class_;
+    int i_;
+};
+
+TestClass* new_TestClass(int a, int b)
+{
+    return new TestClass(a, b);
+}