koffi 2.3.4 → 2.3.6-beta.1

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

@@ -7,7 +7,8 @@ Napi::Value StaticGetter(const Napi::CallbackInfo& /*info*/) {
   return MaybeUnwrap(testStaticContextRef.Value().Get("value"));
 }
 
-void StaticSetter(const Napi::CallbackInfo& /*info*/, const Napi::Value& value) {
+void StaticSetter(const Napi::CallbackInfo& /*info*/,
+                  const Napi::Value& value) {
   testStaticContextRef.Value().Set("value", value);
 }
 
@@ -22,11 +23,9 @@ Napi::Value TestStaticMethodInternal(const Napi::CallbackInfo& info) {
 }
 
 class Test : public Napi::ObjectWrap<Test> {
-public:
-  Test(const Napi::CallbackInfo& info) :
-    Napi::ObjectWrap<Test>(info) {
-
-    if(info.Length() > 0) {
+ public:
+  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
+    if (info.Length() > 0) {
       finalizeCb_ = Napi::Persistent(info[0].As<Napi::Function>());
     }
     // Create an own instance property.
@@ -35,20 +34,19 @@ public:
                                            info.This().As<Napi::Object>(),
                                            "ownProperty",
                                            OwnPropertyGetter,
-                                           napi_enumerable, this));
+                                           napi_enumerable,
+                                           this));
 
     // Create an own instance property with a templated function.
     info.This().As<Napi::Object>().DefineProperty(
-        Napi::PropertyDescriptor::Accessor<OwnPropertyGetter>("ownPropertyT",
-                                                              napi_enumerable, this));
+        Napi::PropertyDescriptor::Accessor<OwnPropertyGetter>(
+            "ownPropertyT", napi_enumerable, this));
 
     bufref_ = Napi::Persistent(Napi::Buffer<uint8_t>::New(
         Env(),
         static_cast<uint8_t*>(malloc(1)),
         1,
-        [](Napi::Env, uint8_t* bufaddr) {
-            free(bufaddr);
-        }));
+        [](Napi::Env, uint8_t* bufaddr) { free(bufaddr); }));
   }
 
   static Napi::Value OwnPropertyGetter(const Napi::CallbackInfo& info) {
@@ -88,16 +86,16 @@ public:
             .Call(array, {}));
   }
 
-  void TestVoidMethodT(const Napi::CallbackInfo &info) {
+  void TestVoidMethodT(const Napi::CallbackInfo& info) {
     value_ = MaybeUnwrap(info[0].ToString());
   }
 
-  Napi::Value TestMethodT(const Napi::CallbackInfo &info) {
-      return Napi::String::New(info.Env(), value_);
+  Napi::Value TestMethodT(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), value_);
   }
 
   static Napi::Value TestStaticMethodT(const Napi::CallbackInfo& info) {
-      return Napi::String::New(info.Env(), s_staticMethodText);
+    return Napi::String::New(info.Env(), s_staticMethodText);
   }
 
   static void TestStaticVoidMethodT(const Napi::CallbackInfo& info) {
@@ -105,20 +103,31 @@ public:
   }
 
   static void Initialize(Napi::Env env, Napi::Object exports) {
-
-    Napi::Symbol kTestStaticValueInternal = Napi::Symbol::New(env, "kTestStaticValueInternal");
-    Napi::Symbol kTestStaticAccessorInternal = Napi::Symbol::New(env, "kTestStaticAccessorInternal");
-    Napi::Symbol kTestStaticAccessorTInternal = Napi::Symbol::New(env, "kTestStaticAccessorTInternal");
-    Napi::Symbol kTestStaticMethodInternal = Napi::Symbol::New(env, "kTestStaticMethodInternal");
-    Napi::Symbol kTestStaticMethodTInternal     = Napi::Symbol::New(env, "kTestStaticMethodTInternal");
-    Napi::Symbol kTestStaticVoidMethodTInternal = Napi::Symbol::New(env, "kTestStaticVoidMethodTInternal");
-
-    Napi::Symbol kTestValueInternal = Napi::Symbol::New(env, "kTestValueInternal");
-    Napi::Symbol kTestAccessorInternal = Napi::Symbol::New(env, "kTestAccessorInternal");
-    Napi::Symbol kTestAccessorTInternal = Napi::Symbol::New(env, "kTestAccessorTInternal");
-    Napi::Symbol kTestMethodInternal = Napi::Symbol::New(env, "kTestMethodInternal");
-    Napi::Symbol kTestMethodTInternal     = Napi::Symbol::New(env, "kTestMethodTInternal");
-    Napi::Symbol kTestVoidMethodTInternal = Napi::Symbol::New(env, "kTestVoidMethodTInternal");
+    Napi::Symbol kTestStaticValueInternal =
+        Napi::Symbol::New(env, "kTestStaticValueInternal");
+    Napi::Symbol kTestStaticAccessorInternal =
+        Napi::Symbol::New(env, "kTestStaticAccessorInternal");
+    Napi::Symbol kTestStaticAccessorTInternal =
+        Napi::Symbol::New(env, "kTestStaticAccessorTInternal");
+    Napi::Symbol kTestStaticMethodInternal =
+        Napi::Symbol::New(env, "kTestStaticMethodInternal");
+    Napi::Symbol kTestStaticMethodTInternal =
+        Napi::Symbol::New(env, "kTestStaticMethodTInternal");
+    Napi::Symbol kTestStaticVoidMethodTInternal =
+        Napi::Symbol::New(env, "kTestStaticVoidMethodTInternal");
+
+    Napi::Symbol kTestValueInternal =
+        Napi::Symbol::New(env, "kTestValueInternal");
+    Napi::Symbol kTestAccessorInternal =
+        Napi::Symbol::New(env, "kTestAccessorInternal");
+    Napi::Symbol kTestAccessorTInternal =
+        Napi::Symbol::New(env, "kTestAccessorTInternal");
+    Napi::Symbol kTestMethodInternal =
+        Napi::Symbol::New(env, "kTestMethodInternal");
+    Napi::Symbol kTestMethodTInternal =
+        Napi::Symbol::New(env, "kTestMethodTInternal");
+    Napi::Symbol kTestVoidMethodTInternal =
+        Napi::Symbol::New(env, "kTestVoidMethodTInternal");
 
     exports.Set(
         "Test",
@@ -237,17 +246,15 @@ public:
   }
 
   void Finalize(Napi::Env env) {
-
-    if(finalizeCb_.IsEmpty()) {
+    if (finalizeCb_.IsEmpty()) {
       return;
     }
 
     finalizeCb_.Call(env.Global(), {Napi::Boolean::New(env, true)});
     finalizeCb_.Unref();
-
   }
 
-private:
+ private:
   std::string value_;
   Napi::FunctionReference finalizeCb_;
 

package/vendor/node-addon-api/test/objectwrap.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-lone-blocks */
 'use strict';
 
 const assert = require('assert');
@@ -5,7 +6,7 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(test);
 
-async function test(binding) {
+async function test (binding) {
   const Test = binding.objectwrap.Test;
 
   const testValue = (obj, clazz) => {
@@ -28,6 +29,7 @@ async function test(binding) {
     // read write-only
     {
       let error;
+      // eslint-disable-next-line no-unused-vars
       try { const read = obj.testSetter; } catch (e) { error = e; }
       // no error
       assert.strictEqual(error, undefined);
@@ -107,19 +109,19 @@ async function test(binding) {
     // for..in: object and prototype
     {
       const keys = [];
-      for (let key in obj) {
+      for (const key in obj) {
         keys.push(key);
       }
 
-      assert(keys.length == 6);
+      assert(keys.length === 6);
       // on prototype
-      assert(keys.includes("testGetSet"));
-      assert(keys.includes("testGetter"));
-      assert(keys.includes("testValue"));
-      assert(keys.includes("testMethod"));
+      assert(keys.includes('testGetSet'));
+      assert(keys.includes('testGetter'));
+      assert(keys.includes('testValue'));
+      assert(keys.includes('testMethod'));
       // on object only
-      assert(keys.includes("ownProperty"));
-      assert(keys.includes("ownPropertyT"));
+      assert(keys.includes('ownProperty'));
+      assert(keys.includes('ownPropertyT'));
     }
   };
 
@@ -135,7 +137,7 @@ async function test(binding) {
       obj.testSetter = 'iterator';
       const values = [];
 
-      for (let item of obj) {
+      for (const item of obj) {
         values.push(item);
       }
 
@@ -146,7 +148,7 @@ async function test(binding) {
   const testStaticValue = (clazz) => {
     assert.strictEqual(clazz.testStaticValue, 'value');
     assert.strictEqual(clazz[clazz.kTestStaticValueInternal], 5);
-  }
+  };
 
   const testStaticAccessor = (clazz) => {
     // read-only, write-only
@@ -165,6 +167,7 @@ async function test(binding) {
     // read write-only
     {
       let error;
+      // eslint-disable-next-line no-unused-vars
       try { const read = clazz.testStaticSetter; } catch (e) { error = e; }
       // no error
       assert.strictEqual(error, undefined);
@@ -227,7 +230,7 @@ async function test(binding) {
     // for..in
     {
       const keys = [];
-      for (let key in clazz) {
+      for (const key in clazz) {
         keys.push(key);
       }
 
@@ -240,21 +243,22 @@ async function test(binding) {
     }
   };
 
-  async function testFinalize(clazz) {
+  async function testFinalize (clazz) {
     let finalizeCalled = false;
     await testUtil.runGCTests([
       'test finalize',
       () => {
-        const finalizeCb = function(called) {
+        const finalizeCb = function (called) {
           finalizeCalled = called;
         };
 
-        //Scope Test instance so that it can be gc'd.
+        // Scope Test instance so that it can be gc'd.
+        // eslint-disable-next-line no-new
         (() => { new Test(finalizeCb); })();
       },
       () => assert.strictEqual(finalizeCalled, true)
     ]);
-  };
+  }
 
   const testObj = (obj, clazz) => {
     testValue(obj, clazz);
@@ -264,16 +268,16 @@ async function test(binding) {
     testEnumerables(obj, clazz);
 
     testConventions(obj, clazz);
-  }
+  };
 
-  async function testClass(clazz) {
+  async function testClass (clazz) {
     testStaticValue(clazz);
     testStaticAccessor(clazz);
     testStaticMethod(clazz);
 
     testStaticEnumerables(clazz);
     await testFinalize(clazz);
-  };
+  }
 
   // `Test` is needed for accessing exposed symbols
   testObj(new Test(), Test);

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

@@ -1,10 +1,10 @@
 #include <napi.h>
 
-class ConstructorExceptionTest :
-  public Napi::ObjectWrap<ConstructorExceptionTest> {
-public:
-  ConstructorExceptionTest(const Napi::CallbackInfo& info) :
-    Napi::ObjectWrap<ConstructorExceptionTest>(info) {
+class ConstructorExceptionTest
+    : public Napi::ObjectWrap<ConstructorExceptionTest> {
+ public:
+  ConstructorExceptionTest(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<ConstructorExceptionTest>(info) {
     Napi::Error error = Napi::Error::New(info.Env(), "an exception");
 #ifdef NAPI_DISABLE_CPP_EXCEPTIONS
     error.ThrowAsJavaScriptException();

package/vendor/node-addon-api/test/objectwrap_constructor_exception.js

@@ -3,7 +3,7 @@
 const assert = require('assert');
 const testUtil = require('./testUtil');
 
-function test(binding) {
+function test (binding) {
   return testUtil.runGCTests([
     'objectwrap constructor exception',
     () => {

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

@@ -1,25 +1,25 @@
 #include <napi.h>
 
 class TestMIBase {
-public:
+ public:
   TestMIBase() : test(0) {}
   virtual void dummy() {}
   uint32_t test;
 };
 
 class TestMI : public TestMIBase, public Napi::ObjectWrap<TestMI> {
-public:
-  TestMI(const Napi::CallbackInfo& info) :
-    Napi::ObjectWrap<TestMI>(info) {}
+ public:
+  TestMI(const Napi::CallbackInfo& info) : Napi::ObjectWrap<TestMI>(info) {}
 
   Napi::Value GetTest(const Napi::CallbackInfo& info) {
     return Napi::Number::New(info.Env(), test);
   }
 
   static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set("TestMI", DefineClass(env, "TestMI", {
-      InstanceAccessor<&TestMI::GetTest>("test")
-    }));
+    exports.Set(
+        "TestMI",
+        DefineClass(
+            env, "TestMI", {InstanceAccessor<&TestMI::GetTest>("test")}));
   }
 };
 

package/vendor/node-addon-api/test/objectwrap_multiple_inheritance.js

@@ -8,6 +8,6 @@ const test = bindingName => {
   const testmi = new TestMI();
 
   assert.strictEqual(testmi.test, 0);
-}
+};
 
 module.exports = require('./common').runTestWithBindingPath(test);

package/vendor/node-addon-api/test/objectwrap_removewrap.js

@@ -2,39 +2,31 @@
 
 if (process.argv[2] === 'child') {
   // Create a single wrapped instance then exit.
-  return new (require(process.argv[3]).objectwrap.Test)();
-}
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTestWithBindingPath(test);
+  // eslint-disable-next-line no-new
+  new (require(process.argv[3]).objectwrap.Test)();
+} else {
+  const assert = require('assert');
+  const testUtil = require('./testUtil');
 
-function test(bindingName) {
-  return testUtil.runGCTests([
-    'objectwrap removewrap test',
-    () => {
-      const binding = require(bindingName);
-      const Test = binding.objectwrap_removewrap.Test;
-      const getDtorCalled = binding.objectwrap_removewrap.getDtorCalled;
+  module.exports = require('./common').runTestWithBindingPath(test);
 
-      assert.strictEqual(getDtorCalled(), 0);
-      assert.throws(() => {
-        new Test();
-      });
-      assert.strictEqual(getDtorCalled(), 1);
-    },
-    // Test that gc does not crash.
-    () => {}
-  ]);
+  function test (bindingName) {
+    return testUtil.runGCTests([
+      'objectwrap removewrap test',
+      () => {
+        const binding = require(bindingName);
+        const Test = binding.objectwrap_removewrap.Test;
+        const getDtorCalled = binding.objectwrap_removewrap.getDtorCalled;
 
-  // Start a child process that creates a single wrapped instance to ensure that
-  // it is properly freed at its exit. It must not segfault.
-  // Re: https://github.com/nodejs/node-addon-api/issues/660
-  const child = spawnSync(process.execPath, [
-    __filename, 'child', bindingName
-  ]);
-  assert.strictEqual(child.signal, null);
-  assert.strictEqual(child.status, 0);
+        assert.strictEqual(getDtorCalled(), 0);
+        assert.throws(() => {
+          // eslint-disable-next-line no-new
+          new Test();
+        });
+        assert.strictEqual(getDtorCalled(), 1);
+      },
+      // Test that gc does not crash.
+      () => {}
+    ]);
+  }
 }

package/vendor/node-addon-api/test/objectwrap_worker_thread.js

@@ -1,12 +1,13 @@
 'use strict';
 const path = require('path');
-const { Worker, isMainThread, workerData } = require('worker_threads');
+const { Worker, isMainThread } = require('worker_threads');
+const { runTestWithBuildType, whichBuildType } = require('./common');
 
-module.exports = require('./common').runTestWithBuildType(test);
+module.exports = runTestWithBuildType(test);
 
-async function test(buildType) {
+async function test () {
   if (isMainThread) {
-    const buildType = process.config.target_defaults.default_configuration;
+    const buildType = await whichBuildType();
     const worker = new Worker(__filename, { workerData: buildType });
     return new Promise((resolve, reject) => {
       worker.on('exit', () => {

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

@@ -18,12 +18,19 @@ Value RejectPromise(const CallbackInfo& info) {
   return deferred.Promise();
 }
 
+Value PromiseReturnsCorrectEnv(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  return Boolean::New(info.Env(), deferred.Env() == info.Env());
+}
+
 Object InitPromise(Env env) {
   Object exports = Object::New(env);
 
   exports["isPromise"] = Function::New(env, IsPromise);
   exports["resolvePromise"] = Function::New(env, ResolvePromise);
   exports["rejectPromise"] = Function::New(env, RejectPromise);
+  exports["promiseReturnsCorrectEnv"] =
+      Function::New(env, PromiseReturnsCorrectEnv);
 
   return exports;
 }

package/vendor/node-addon-api/test/promise.js

@@ -5,7 +5,7 @@ const common = require('./common');
 
 module.exports = common.runTest(test);
 
-async function test(binding) {
+async function test (binding) {
   assert.strictEqual(binding.promise.isPromise({}), false);
 
   const resolving = binding.promise.resolvePromise('resolved');
@@ -15,4 +15,6 @@ async function test(binding) {
   const rejecting = binding.promise.rejectPromise('error');
   await assert.strictEqual(binding.promise.isPromise(rejecting), true);
   rejecting.then(common.mustNotCall()).catch(common.mustCall());
+
+  assert(binding.promise.promiseReturnsCorrectEnv());
 }

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

@@ -4,7 +4,7 @@ using namespace Napi;
 
 static Reference<Buffer<uint8_t>> weak;
 
-void  CreateWeakArray(const CallbackInfo& info) {
+void CreateWeakArray(const CallbackInfo& info) {
   weak = Weak(Buffer<uint8_t>::New(info.Env(), 1));
   weak.SuppressDestruct();
 }

package/vendor/node-addon-api/test/reference.js

@@ -5,10 +5,10 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   return testUtil.runGCTests([
     'test reference',
     () => binding.reference.createWeakArray(),
     () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty())
   ]);
-};
+}

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

@@ -42,7 +42,7 @@ Value RunWithContext(const CallbackInfo& info) {
   return MaybeUnwrap(fn.Call(args));
 }
 
-} // end anonymous namespace
+}  // end anonymous namespace
 
 Object InitRunScript(Env env) {
   Object exports = Object::New(env);

package/vendor/node-addon-api/test/symbol.js

@@ -1,73 +1,66 @@
 'use strict';
 
-const buildType = process.config.target_defaults.default_configuration;
 const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-
-function test(binding)
-{
-    const majorNodeVersion = process.versions.node.split('.')[0];
-
-    let wellKnownSymbolFunctions = ['asyncIterator','hasInstance','isConcatSpreadable', 'iterator','match','replace','search','split','species','toPrimitive','toStringTag','unscopables'];
-    if (majorNodeVersion >= 12) {
-      wellKnownSymbolFunctions.push('matchAll');
-    }
-
-    function assertCanCreateSymbol(symbol)
-    {
-      assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
-      assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
-      assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
-    }
-
-    function assertSymbolAreUnique(symbol)
-    {
-        const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
-        const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
-
-        assert(symbolOne !== symbolTwo);
-    }
-
-    function assertSymbolIsWellknown(symbol)
-    {
-      const symbOne = binding.symbol.getWellKnownSymbol(symbol);
-      const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
-      assert(symbOne && symbTwo);
-      assert(symbOne === symbTwo);
-    }
-
-    function assertSymbolIsNotWellknown(symbol)
-    {
-      const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
-      assert(symbolTest === undefined);
-    }
-
-    function assertCanCreateOrFetchGlobalSymbols(symbol, fetchFunction)
-    {
-      const symbOne = fetchFunction(symbol);
-      const symbTwo = fetchFunction(symbol);
-      assert(symbOne && symbTwo);
-      assert(symbOne === symbTwo);
-    }
-
-    assertCanCreateSymbol("testing");
-    assertSymbolAreUnique("symbol");
-    assertSymbolIsNotWellknown("testing");
-
-     for(const wellknownProperty of wellKnownSymbolFunctions)
-     {
-       assertSymbolIsWellknown(wellknownProperty);
-     }
-
-     assertCanCreateOrFetchGlobalSymbols("data", binding.symbol.getSymbolFromGlobalRegistry);
-     assertCanCreateOrFetchGlobalSymbols("CppKey", binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
-     assertCanCreateOrFetchGlobalSymbols("CKey", binding.symbol.getSymbolFromGlobalRegistryWithCKey);
-
-    assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
-
-    assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
-    assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
-    assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
+function test (binding) {
+  const majorNodeVersion = process.versions.node.split('.')[0];
+
+  const wellKnownSymbolFunctions = ['asyncIterator', 'hasInstance', 'isConcatSpreadable', 'iterator', 'match', 'replace', 'search', 'split', 'species', 'toPrimitive', 'toStringTag', 'unscopables'];
+  if (majorNodeVersion >= 12) {
+    wellKnownSymbolFunctions.push('matchAll');
+  }
+
+  function assertCanCreateSymbol (symbol) {
+    assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
+    assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
+    assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
+  }
+
+  function assertSymbolAreUnique (symbol) {
+    const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
+    const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
+
+    assert(symbolOne !== symbolTwo);
+  }
+
+  function assertSymbolIsWellknown (symbol) {
+    const symbOne = binding.symbol.getWellKnownSymbol(symbol);
+    const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
+    assert(symbOne && symbTwo);
+    assert(symbOne === symbTwo);
+  }
+
+  function assertSymbolIsNotWellknown (symbol) {
+    const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
+    assert(symbolTest === undefined);
+  }
+
+  function assertCanCreateOrFetchGlobalSymbols (symbol, fetchFunction) {
+    const symbOne = fetchFunction(symbol);
+    const symbTwo = fetchFunction(symbol);
+    assert(symbOne && symbTwo);
+    assert(symbOne === symbTwo);
+  }
+
+  assertCanCreateSymbol('testing');
+  assertSymbolAreUnique('symbol');
+  assertSymbolIsNotWellknown('testing');
+
+  for (const wellknownProperty of wellKnownSymbolFunctions) {
+    assertSymbolIsWellknown(wellknownProperty);
+  }
+
+  assertCanCreateOrFetchGlobalSymbols('data', binding.symbol.getSymbolFromGlobalRegistry);
+  assertCanCreateOrFetchGlobalSymbols('CppKey', binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
+  assertCanCreateOrFetchGlobalSymbols('CKey', binding.symbol.getSymbolFromGlobalRegistryWithCKey);
+
+  assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
+
+  // eslint-disable-next-line no-self-compare
+  assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
+  // eslint-disable-next-line no-self-compare
+  assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
+  assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
 }