koffi 0.9.2 → 0.9.5

package/vendor/node-addon-api/test/globalObject/global_object_get_property.cc

@@ -1,40 +1,40 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-Value GetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
-  return MaybeUnwrap(globalObject.Get(key));
-}
-
-Value GetPropertyWithInt32AsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Number key = info[0].As<Napi::Number>();
-  return MaybeUnwrapOr(globalObject.Get(key.Uint32Value()), Value());
-}
-
-Value GetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String cStrkey = info[0].As<String>();
-  return MaybeUnwrapOr(globalObject.Get(cStrkey.Utf8Value().c_str()), Value());
-}
-
-Value GetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String cppStrKey = info[0].As<String>();
-  return MaybeUnwrapOr(globalObject.Get(cppStrKey.Utf8Value()), Value());
-}
-
-void CreateMockTestObject(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Number napi_key = Number::New(info.Env(), 2);
-  const char* CStringKey = "c_str_key";
-
-  globalObject.Set(napi_key, "napi_attribute");
-  globalObject[CStringKey] = "c_string_attribute";
-  globalObject[std::string("cpp_string_key")] = "cpp_string_attribute";
-  globalObject[std::string("circular")] = globalObject;
-  globalObject[(uint32_t)15] = 15;
-}
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value GetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  return MaybeUnwrap(globalObject.Get(key));
+}
+
+Value GetPropertyWithInt32AsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number key = info[0].As<Napi::Number>();
+  return MaybeUnwrapOr(globalObject.Get(key.Uint32Value()), Value());
+}
+
+Value GetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String cStrkey = info[0].As<String>();
+  return MaybeUnwrapOr(globalObject.Get(cStrkey.Utf8Value().c_str()), Value());
+}
+
+Value GetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String cppStrKey = info[0].As<String>();
+  return MaybeUnwrapOr(globalObject.Get(cppStrKey.Utf8Value()), Value());
+}
+
+void CreateMockTestObject(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number napi_key = Number::New(info.Env(), 2);
+  const char* CStringKey = "c_str_key";
+
+  globalObject.Set(napi_key, "napi_attribute");
+  globalObject[CStringKey] = "c_string_attribute";
+  globalObject[std::string("cpp_string_key")] = "cpp_string_attribute";
+  globalObject[std::string("circular")] = globalObject;
+  globalObject[(uint32_t)15] = 15;
+}

package/vendor/node-addon-api/test/globalObject/global_object_get_property.js

@@ -1,57 +1,57 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  const KEY_TYPE = {
-        C_STR: 'KEY_AS_C_STRING',
-        CPP_STR: 'KEY_AS_CPP_STRING',
-        NAPI:  'KEY_AS_NAPI_VALUES',
-        INT_32: 'KEY_AS_INT_32_NUM'
-    };
-
-  binding.globalObject.createMockTestObject();
-  function assertGlobalObjectPropertyIs(key, attribute, keyType) {
-    let napiObjectAttr;
-    switch(keyType)
-      {
-        case KEY_TYPE.NAPI:
-          napiObjectAttr = binding.globalObject.getPropertyWithNapiValue(key);
-          assert.deepStrictEqual(attribute, napiObjectAttr);
-          break;
-
-        case KEY_TYPE.C_STR:
-          napiObjectAttr = binding.globalObject.getPropertyWithCString(key);
-          assert.deepStrictEqual(attribute, napiObjectAttr);
-          break;
-
-        case KEY_TYPE.CPP_STR:
-          napiObjectAttr = binding.globalObject.getPropertyWithCppString(key);
-          assert.deepStrictEqual(attribute, napiObjectAttr);
-          break;
-
-        case KEY_TYPE.INT_32:
-          napiObjectAttr = binding.globalObject.getPropertyWithInt32(key);
-          assert.deepStrictEqual(attribute, napiObjectAttr);
-          break;
-      }
-  }
-
-  function assertErrMessageIsThrown(propertyFetchFunction, errMsg) {
-    assert.throws(() => {
-      propertyFetchFunction(undefined);
-    }, errMsg);
-  }
-
-  assertGlobalObjectPropertyIs('2',global['2'], KEY_TYPE.NAPI);
-  assertGlobalObjectPropertyIs('c_str_key',global['c_str_key'],KEY_TYPE.C_STR);
-  assertGlobalObjectPropertyIs('cpp_string_key',global['cpp_string_key'],KEY_TYPE.CPP_STR);
-  assertGlobalObjectPropertyIs('circular',global['circular'],KEY_TYPE.CPP_STR);
-  assertGlobalObjectPropertyIs(15, global['15'], KEY_TYPE.INT_32);
-
-  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCString, 'Error: A string was expected');
-  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCppString, 'Error: A string was expected');
-  assertErrMessageIsThrown(binding.globalObject.getPropertyWithInt32, 'Error: A number was expected');
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  const KEY_TYPE = {
+        C_STR: 'KEY_AS_C_STRING',
+        CPP_STR: 'KEY_AS_CPP_STRING',
+        NAPI:  'KEY_AS_NAPI_VALUES',
+        INT_32: 'KEY_AS_INT_32_NUM'
+    };
+
+  binding.globalObject.createMockTestObject();
+  function assertGlobalObjectPropertyIs(key, attribute, keyType) {
+    let napiObjectAttr;
+    switch(keyType)
+      {
+        case KEY_TYPE.NAPI:
+          napiObjectAttr = binding.globalObject.getPropertyWithNapiValue(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.C_STR:
+          napiObjectAttr = binding.globalObject.getPropertyWithCString(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.CPP_STR:
+          napiObjectAttr = binding.globalObject.getPropertyWithCppString(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.INT_32:
+          napiObjectAttr = binding.globalObject.getPropertyWithInt32(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+      }
+  }
+
+  function assertErrMessageIsThrown(propertyFetchFunction, errMsg) {
+    assert.throws(() => {
+      propertyFetchFunction(undefined);
+    }, errMsg);
+  }
+
+  assertGlobalObjectPropertyIs('2',global['2'], KEY_TYPE.NAPI);
+  assertGlobalObjectPropertyIs('c_str_key',global['c_str_key'],KEY_TYPE.C_STR);
+  assertGlobalObjectPropertyIs('cpp_string_key',global['cpp_string_key'],KEY_TYPE.CPP_STR);
+  assertGlobalObjectPropertyIs('circular',global['circular'],KEY_TYPE.CPP_STR);
+  assertGlobalObjectPropertyIs(15, global['15'], KEY_TYPE.INT_32);
+
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCppString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithInt32, 'Error: A number was expected');
+}

package/vendor/node-addon-api/test/globalObject/global_object_has_own_property.cc

@@ -1,28 +1,28 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value().c_str()),
-                    false));
-}
-
-Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value()), false));
-}
-
-Value HasPropertyWithNapiValueAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
-  return Boolean::New(info.Env(),
-                      MaybeUnwrap(globalObject.HasOwnProperty(key)));
-}
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value().c_str()),
+                    false));
+}
+
+Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value()), false));
+}
+
+Value HasPropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrap(globalObject.HasOwnProperty(key)));
+}

package/vendor/node-addon-api/test/globalObject/global_object_has_own_property.js

@@ -1,48 +1,48 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-    const KEY_TYPE = {
-        C_STR: 'KEY_AS_C_STRING',
-        CPP_STR: 'KEY_AS_CPP_STRING',
-        NAPI:  'KEY_AS_NAPI_VALUES',
-        INT_32: 'KEY_AS_INT_32_NUM'
-    };
-
-    function assertGlobalObjectHasProperty(key, keyType)
-    {
-        switch(keyType)
-        {
-            case KEY_TYPE.NAPI:
-                assert.strictEqual(binding.globalObject.hasPropertyWithNapiValue(key), true);
-                break;
-
-              case KEY_TYPE.C_STR:
-                assert.strictEqual(binding.globalObject.hasPropertyWithCStyleString(key), true);
-                break;
-
-              case KEY_TYPE.CPP_STR:
-                assert.strictEqual(binding.globalObject.hasPropertyWithCppStyleString(key), true);
-                break;
-        }
-    }
-
-    function assertErrMessageIsThrown(propertyCheckExistenceFunction, errMsg) {
-        assert.throws(() => {
-          propertyCheckExistenceFunction(undefined);
-        }, errMsg);
-    }
-
-    binding.globalObject.createMockTestObject();
-    assertGlobalObjectHasProperty('c_str_key',KEY_TYPE.C_STR);
-    assertGlobalObjectHasProperty('cpp_string_key',KEY_TYPE.CPP_STR);
-    assertGlobalObjectHasProperty('circular',KEY_TYPE.CPP_STR);
-    assertGlobalObjectHasProperty('2', KEY_TYPE.NAPI);
-
-    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCppStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithInt32, 'Error: A number was expected');
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+    const KEY_TYPE = {
+        C_STR: 'KEY_AS_C_STRING',
+        CPP_STR: 'KEY_AS_CPP_STRING',
+        NAPI:  'KEY_AS_NAPI_VALUES',
+        INT_32: 'KEY_AS_INT_32_NUM'
+    };
+
+    function assertGlobalObjectHasProperty(key, keyType)
+    {
+        switch(keyType)
+        {
+            case KEY_TYPE.NAPI:
+                assert.strictEqual(binding.globalObject.hasPropertyWithNapiValue(key), true);
+                break;
+
+              case KEY_TYPE.C_STR:
+                assert.strictEqual(binding.globalObject.hasPropertyWithCStyleString(key), true);
+                break;
+
+              case KEY_TYPE.CPP_STR:
+                assert.strictEqual(binding.globalObject.hasPropertyWithCppStyleString(key), true);
+                break;
+        }
+    }
+
+    function assertErrMessageIsThrown(propertyCheckExistenceFunction, errMsg) {
+        assert.throws(() => {
+          propertyCheckExistenceFunction(undefined);
+        }, errMsg);
+    }
+
+    binding.globalObject.createMockTestObject();
+    assertGlobalObjectHasProperty('c_str_key',KEY_TYPE.C_STR);
+    assertGlobalObjectHasProperty('cpp_string_key',KEY_TYPE.CPP_STR);
+    assertGlobalObjectHasProperty('circular',KEY_TYPE.CPP_STR);
+    assertGlobalObjectHasProperty('2', KEY_TYPE.NAPI);
+
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCppStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithInt32, 'Error: A number was expected');
+}

package/vendor/node-addon-api/test/globalObject/global_object_set_property.cc

@@ -1,31 +1,31 @@
-#include "napi.h"
-
-using namespace Napi;
-
-void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value().c_str(), value);
-}
-
-void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value(), value);
-}
-
-void SetPropertyWithInt32AsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Number key = info[0].As<Number>();
-  Value value = info[1];
-  globalObject.Set(key.Uint32Value(), value);
-}
-
-void SetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
-  Value value = info[1];
-  globalObject.Set(key, value);
+#include "napi.h"
+
+using namespace Napi;
+
+void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  Value value = info[1];
+  globalObject.Set(key.Utf8Value().c_str(), value);
+}
+
+void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  Value value = info[1];
+  globalObject.Set(key.Utf8Value(), value);
+}
+
+void SetPropertyWithInt32AsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number key = info[0].As<Number>();
+  Value value = info[1];
+  globalObject.Set(key.Uint32Value(), value);
+}
+
+void SetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  Value value = info[1];
+  globalObject.Set(key, value);
 }

package/vendor/node-addon-api/test/globalObject/global_object_set_property.js

@@ -1,58 +1,58 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  const KEY_TYPE = {
-        C_STR: 'KEY_AS_C_STRING',
-        CPP_STR: 'KEY_AS_CPP_STRING',
-        NAPI:  'KEY_AS_NAPI_VALUES',
-        INT_32: 'KEY_AS_INT_32_NUM'
-    };
-
-    function setGlobalObjectKeyValue(key, value, keyType) {
-        switch(keyType)
-        {
-            case KEY_TYPE.CPP_STR:
-            binding.globalObject.setPropertyWithCppStyleString(key,value);
-            break;
-
-            case KEY_TYPE.C_STR:
-            binding.globalObject.setPropertyWithCStyleString(key,value);
-            break;
-
-            case KEY_TYPE.INT_32:
-            binding.globalObject.setPropertyWithInt32(key,value);
-            break;
-
-            case KEY_TYPE.NAPI:
-            binding.globalObject.setPropertyWithNapiValue(key,value);
-            break;
-        }
-    }
-
-    function assertErrMessageIsThrown(nativeObjectSetFunction, errMsg) {
-        assert.throws(() => {
-          nativeObjectSetFunction(undefined, 1);
-        }, errMsg);
-      }
-
-
-    setGlobalObjectKeyValue("cKey","cValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue(1,10,KEY_TYPE.INT_32);
-    setGlobalObjectKeyValue("napi_key","napi_value",KEY_TYPE.NAPI);
-    setGlobalObjectKeyValue("cppKey","cppValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue("circular",global,KEY_TYPE.NAPI);
-
-    assert.deepStrictEqual(global["circular"], global);
-    assert.deepStrictEqual(global["cppKey"],"cppValue");
-    assert.deepStrictEqual(global["napi_key"],"napi_value");
-    assert.deepStrictEqual(global[1],10);
-    assert.deepStrictEqual(global["cKey"],"cValue");
-
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  const KEY_TYPE = {
+        C_STR: 'KEY_AS_C_STRING',
+        CPP_STR: 'KEY_AS_CPP_STRING',
+        NAPI:  'KEY_AS_NAPI_VALUES',
+        INT_32: 'KEY_AS_INT_32_NUM'
+    };
+
+    function setGlobalObjectKeyValue(key, value, keyType) {
+        switch(keyType)
+        {
+            case KEY_TYPE.CPP_STR:
+            binding.globalObject.setPropertyWithCppStyleString(key,value);
+            break;
+
+            case KEY_TYPE.C_STR:
+            binding.globalObject.setPropertyWithCStyleString(key,value);
+            break;
+
+            case KEY_TYPE.INT_32:
+            binding.globalObject.setPropertyWithInt32(key,value);
+            break;
+
+            case KEY_TYPE.NAPI:
+            binding.globalObject.setPropertyWithNapiValue(key,value);
+            break;
+        }
+    }
+
+    function assertErrMessageIsThrown(nativeObjectSetFunction, errMsg) {
+        assert.throws(() => {
+          nativeObjectSetFunction(undefined, 1);
+        }, errMsg);
+      }
+
+
+    setGlobalObjectKeyValue("cKey","cValue",KEY_TYPE.CPP_STR);
+    setGlobalObjectKeyValue(1,10,KEY_TYPE.INT_32);
+    setGlobalObjectKeyValue("napi_key","napi_value",KEY_TYPE.NAPI);
+    setGlobalObjectKeyValue("cppKey","cppValue",KEY_TYPE.CPP_STR);
+    setGlobalObjectKeyValue("circular",global,KEY_TYPE.NAPI);
+
+    assert.deepStrictEqual(global["circular"], global);
+    assert.deepStrictEqual(global["cppKey"],"cppValue");
+    assert.deepStrictEqual(global["napi_key"],"napi_value");
+    assert.deepStrictEqual(global[1],10);
+    assert.deepStrictEqual(global["cKey"],"cValue");
+
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
+}

package/vendor/node-addon-api/test/handlescope.cc

@@ -1,60 +1,60 @@
-#include "napi.h"
-#include "string.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace Napi;
-
-Value createScope(const CallbackInfo& info) {
-  {
-    HandleScope scope(info.Env());
-    String::New(info.Env(), "inner-scope");
-  }
-  return String::New(info.Env(), "scope");
-}
-
-Value escapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-#define LOOP_MAX 1000000
-Value stressEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  for (int i = 0; i < LOOP_MAX; i++) {
-    EscapableHandleScope scope(info.Env());
-    char buffer[128];
-    snprintf(buffer, 128, "%d", i);
-    std::string name = std::string("inner-scope") + std::string(buffer);
-    Value newValue = String::New(info.Env(), name.c_str());
-    if (i == (LOOP_MAX -1)) {
-      result = scope.Escape(newValue);
-    }
-  }
-  return result;
-}
-
-Value doubleEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-Object InitHandleScope(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createScope"] = Function::New(env, createScope);
-  exports["escapeFromScope"] = Function::New(env, escapeFromScope);
-  exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
-  exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
-
-  return exports;
-}
+#include "napi.h"
+#include "string.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace Napi;
+
+Value createScope(const CallbackInfo& info) {
+  {
+    HandleScope scope(info.Env());
+    String::New(info.Env(), "inner-scope");
+  }
+  return String::New(info.Env(), "scope");
+}
+
+Value escapeFromScope(const CallbackInfo& info) {
+  Value result;
+  {
+    EscapableHandleScope scope(info.Env());
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+  }
+  return result;
+}
+
+#define LOOP_MAX 1000000
+Value stressEscapeFromScope(const CallbackInfo& info) {
+  Value result;
+  for (int i = 0; i < LOOP_MAX; i++) {
+    EscapableHandleScope scope(info.Env());
+    char buffer[128];
+    snprintf(buffer, 128, "%d", i);
+    std::string name = std::string("inner-scope") + std::string(buffer);
+    Value newValue = String::New(info.Env(), name.c_str());
+    if (i == (LOOP_MAX -1)) {
+      result = scope.Escape(newValue);
+    }
+  }
+  return result;
+}
+
+Value doubleEscapeFromScope(const CallbackInfo& info) {
+  Value result;
+  {
+    EscapableHandleScope scope(info.Env());
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+  }
+  return result;
+}
+
+Object InitHandleScope(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createScope"] = Function::New(env, createScope);
+  exports["escapeFromScope"] = Function::New(env, escapeFromScope);
+  exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
+  exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
+
+  return exports;
+}