Upload Kmake

test/addons/make-callback/binding.cc

@@ -0,0 +1,41 @@
+#include "node.h"
+#include "v8.h"
+
+#include <assert.h>
+#include <vector>
+
+namespace {
+
+void MakeCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  assert(args[0]->IsObject());
+  assert(args[1]->IsFunction() || args[1]->IsString());
+  auto isolate = args.GetIsolate();
+  auto recv = args[0].As<v8::Object>();
+  v8::LocalVector<v8::Value> argv(isolate);
+  for (size_t n = 2; n < static_cast<size_t>(args.Length()); n += 1) {
+    argv.push_back(args[n]);
+  }
+  v8::Local<v8::Value> result;
+  if (args[1]->IsFunction()) {
+    auto method = args[1].As<v8::Function>();
+    result =
+        node::MakeCallback(isolate, recv, method, argv.size(), argv.data(),
+                           node::async_context{0, 0}).ToLocalChecked();
+  } else if (args[1]->IsString()) {
+    auto method = args[1].As<v8::String>();
+    result =
+        node::MakeCallback(isolate, recv, method, argv.size(), argv.data(),
+                           node::async_context{0, 0}).ToLocalChecked();
+  } else {
+    assert(0 && "unreachable");
+  }
+  args.GetReturnValue().Set(result);
+}
+
+void Initialize(v8::Local<v8::Object> exports) {
+  NODE_SET_METHOD(exports, "makeCallback", MakeCallback);
+}
+
+}  // anonymous namespace
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)

test/addons/make-callback/binding.gyp

@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'sources': [ 'binding.cc' ],
+      'includes': ['../common.gypi'],
+    }
+  ]
+}

test/addons/make-callback/test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const vm = require('vm');
+const binding = require(`./build/${common.buildType}/binding`);
+const makeCallback = binding.makeCallback;
+
+assert.strictEqual(makeCallback(process, common.mustCall(function() {
+  assert.strictEqual(arguments.length, 0);
+  assert.strictEqual(process, this);
+  return 42;
+})), 42);
+
+assert.strictEqual(makeCallback(process, common.mustCall(function(x) {
+  assert.strictEqual(arguments.length, 1);
+  assert.strictEqual(process, this);
+  assert.strictEqual(x, 1337);
+  return 42;
+}), 1337), 42);
+
+const recv = {
+  one: common.mustCall(function() {
+    assert.strictEqual(arguments.length, 0);
+    assert.strictEqual(recv, this);
+    return 42;
+  }),
+  two: common.mustCall(function(x) {
+    assert.strictEqual(arguments.length, 1);
+    assert.strictEqual(recv, this);
+    assert.strictEqual(x, 1337);
+    return 42;
+  }),
+};
+
+assert.strictEqual(makeCallback(recv, 'one'), 42);
+assert.strictEqual(makeCallback(recv, 'two', 1337), 42);
+
+// Check that callbacks on a receiver from a different context works.
+const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
+assert.strictEqual(makeCallback(foreignObject, 'fortytwo'), 42);
+
+// Check that the callback is made in the context of the receiver.
+const target = vm.runInNewContext(`
+    (function($Object) {
+      if (Object === $Object)
+        throw new Error('bad');
+      return Object;
+    })
+`);
+assert.notStrictEqual(makeCallback(process, target, Object), Object);
+
+// Runs in inner context.
+const forward = vm.runInNewContext(`
+    (function(forward) {
+      return forward(Object);
+    })
+`);
+// Runs in outer context.
+function endpoint($Object) {
+  if (Object === $Object)
+    throw new Error('bad');
+  return Object;
+}
+assert.strictEqual(makeCallback(process, forward, endpoint), Object);