koffi 0.9.3 → 0.9.6

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

@@ -1,217 +1,217 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function assertPropertyIs(obj, key, attribute) {
-    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
-    assert.ok(propDesc);
-    assert.ok(propDesc[attribute]);
-  }
-
-  function assertPropertyIsNot(obj, key, attribute) {
-    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
-    assert.ok(propDesc);
-    assert.ok(!propDesc[attribute]);
-  }
-
-  function testDefineProperties(nameType) {
-    const obj = {};
-    binding.object.defineProperties(obj, nameType);
-
-    // accessors
-    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
-    assert.strictEqual(obj.readonlyAccessor, true);
-
-    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'configurable');
-    assert.strictEqual(obj.readonlyAccessorWithUserData, 1234, nameType);
-
-    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
-    obj.readwriteAccessor = false;
-    assert.strictEqual(obj.readwriteAccessor, false);
-    obj.readwriteAccessor = true;
-    assert.strictEqual(obj.readwriteAccessor, true);
-
-    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'configurable');
-    obj.readwriteAccessorWithUserData = 2;
-    assert.strictEqual(obj.readwriteAccessorWithUserData, 2);
-    obj.readwriteAccessorWithUserData = -14;
-    assert.strictEqual(obj.readwriteAccessorWithUserData, -14);
-
-    // templated accessors
-    assertPropertyIsNot(obj, 'readonlyAccessorT', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyAccessorT', 'configurable');
-    assert.strictEqual(obj.readonlyAccessorT, true);
-
-    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'configurable');
-    assert.strictEqual(obj.readonlyAccessorWithUserDataT, -14, nameType);
-
-    assertPropertyIsNot(obj, 'readwriteAccessorT', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteAccessorT', 'configurable');
-    obj.readwriteAccessorT = false;
-    assert.strictEqual(obj.readwriteAccessorT, false);
-    obj.readwriteAccessorT = true;
-    assert.strictEqual(obj.readwriteAccessorT, true);
-
-    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'configurable');
-    obj.readwriteAccessorWithUserDataT = 2;
-    assert.strictEqual(obj.readwriteAccessorWithUserDataT, 2);
-    obj.readwriteAccessorWithUserDataT = -14;
-    assert.strictEqual(obj.readwriteAccessorWithUserDataT, -14);
-
-    // values
-    assertPropertyIsNot(obj, 'readonlyValue', 'writable');
-    assertPropertyIsNot(obj, 'readonlyValue', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyValue', 'configurable');
-    assert.strictEqual(obj.readonlyValue, true);
-
-    assertPropertyIs(obj, 'readwriteValue', 'writable');
-    assertPropertyIsNot(obj, 'readwriteValue', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteValue', 'configurable');
-    obj.readwriteValue = false;
-    assert.strictEqual(obj.readwriteValue, false);
-    obj.readwriteValue = true;
-    assert.strictEqual(obj.readwriteValue, true);
-
-    assertPropertyIsNot(obj, 'enumerableValue', 'writable');
-    assertPropertyIs(obj, 'enumerableValue', 'enumerable');
-    assertPropertyIsNot(obj, 'enumerableValue', 'configurable');
-
-    assertPropertyIsNot(obj, 'configurableValue', 'writable');
-    assertPropertyIsNot(obj, 'configurableValue', 'enumerable');
-    assertPropertyIs(obj, 'configurableValue', 'configurable');
-
-    // functions
-    assertPropertyIsNot(obj, 'function', 'writable');
-    assertPropertyIsNot(obj, 'function', 'enumerable');
-    assertPropertyIsNot(obj, 'function', 'configurable');
-    assert.strictEqual(obj.function(), true);
-    assert.strictEqual(obj.functionWithUserData(), obj.readonlyAccessorWithUserDataT);
-  }
-
-  testDefineProperties('literal');
-  testDefineProperties('string');
-  testDefineProperties('value');
-
-  {
-    assert.strictEqual(binding.object.emptyConstructor(true), true);
-    assert.strictEqual(binding.object.emptyConstructor(false), false);
-  }
-
-  {
-    const expected = { 'one': 1, 'two': 2, 'three': 3 };
-    const actual = binding.object.constructorFromObject(expected);
-    assert.deepStrictEqual(actual, expected);
-  }
-
-  {
-    const obj = {};
-    const testSym = Symbol();
-    binding.object.defineValueProperty(obj, testSym, 1);
-    assert.strictEqual(obj[testSym], 1);
-  }
-
-  {
-    const testSym = Symbol();
-    const obj = { 'one': 1, 'two': 2, 'three': 3, [testSym]: 4 };
-    var arr = binding.object.GetPropertyNames(obj);
-    assert.deepStrictEqual(arr, ['one', 'two', 'three']);
-  }
-
-  {
-    const magicObject = binding.object.createObjectUsingMagic();
-    assert.deepStrictEqual(magicObject, {
-      0: 0,
-      42: 120,
-      cp_false: false,
-      cp_true: true,
-      s_true: true,
-      s_false: false,
-      '0.0f': 0,
-      '0.0': 0,
-      '-1': -1,
-      foo2: 'foo',
-      foo4: 'foo',
-      foo5: 'foo',
-      foo6: 'foo',
-      foo7: 'foo',
-      circular: magicObject,
-      circular2: magicObject
-    });
-  }
-
-  {
-    function Ctor() {};
-
-    assert.strictEqual(binding.object.instanceOf(new Ctor(), Ctor), true);
-    assert.strictEqual(binding.object.instanceOf(new Ctor(), Object), true);
-    assert.strictEqual(binding.object.instanceOf({}, Ctor), false);
-    assert.strictEqual(binding.object.instanceOf(null, Ctor), false);
-  }
-
-  if ('sum' in binding.object) {
-      {
-        const obj = {
-          '-forbid': -0x4B1D,
-          '-feedcode': -0xFEEDC0DE,
-          '+office': +0x0FF1CE,
-          '+forbid': +0x4B1D,
-          '+deadbeef': +0xDEADBEEF,
-          '+feedcode': +0xFEEDC0DE,
-        };
-
-        let sum = 0;
-        for (const key in obj) {
-          sum += obj[key];
-        }
-
-        assert.strictEqual(binding.object.sum(obj), sum);
-      }
-
-      {
-        const obj = new Proxy({
-          '-forbid': -0x4B1D,
-          '-feedcode': -0xFEEDC0DE,
-          '+office': +0x0FF1CE,
-          '+forbid': +0x4B1D,
-          '+deadbeef': +0xDEADBEEF,
-          '+feedcode': +0xFEEDC0DE,
-        }, {
-          getOwnPropertyDescriptor(target, p) {
-            throw new Error("getOwnPropertyDescriptor error");
-          },
-          ownKeys(target) {
-            throw new Error("ownKeys error");
-          },
-        });
-
-        assert.throws(() => {
-          binding.object.sum(obj);
-        }, /ownKeys error/);
-    }
-  }
-
-  if ('increment' in binding.object) {
-    const obj = {
-      'a': 0,
-      'b': 1,
-      'c': 2,
-    };
-
-    binding.object.increment(obj);
-
-    assert.deepStrictEqual(obj, {
-      'a': 1,
-      'b': 2,
-      'c': 3,
-    });
-  }
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function assertPropertyIs(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(propDesc[attribute]);
+  }
+
+  function assertPropertyIsNot(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(!propDesc[attribute]);
+  }
+
+  function testDefineProperties(nameType) {
+    const obj = {};
+    binding.object.defineProperties(obj, nameType);
+
+    // accessors
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
+    assert.strictEqual(obj.readonlyAccessor, true);
+
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserData', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorWithUserData, 1234, nameType);
+
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
+    obj.readwriteAccessor = false;
+    assert.strictEqual(obj.readwriteAccessor, false);
+    obj.readwriteAccessor = true;
+    assert.strictEqual(obj.readwriteAccessor, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserData', 'configurable');
+    obj.readwriteAccessorWithUserData = 2;
+    assert.strictEqual(obj.readwriteAccessorWithUserData, 2);
+    obj.readwriteAccessorWithUserData = -14;
+    assert.strictEqual(obj.readwriteAccessorWithUserData, -14);
+
+    // templated accessors
+    assertPropertyIsNot(obj, 'readonlyAccessorT', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorT', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorT, true);
+
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessorWithUserDataT', 'configurable');
+    assert.strictEqual(obj.readonlyAccessorWithUserDataT, -14, nameType);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorT', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorT', 'configurable');
+    obj.readwriteAccessorT = false;
+    assert.strictEqual(obj.readwriteAccessorT, false);
+    obj.readwriteAccessorT = true;
+    assert.strictEqual(obj.readwriteAccessorT, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessorWithUserDataT', 'configurable');
+    obj.readwriteAccessorWithUserDataT = 2;
+    assert.strictEqual(obj.readwriteAccessorWithUserDataT, 2);
+    obj.readwriteAccessorWithUserDataT = -14;
+    assert.strictEqual(obj.readwriteAccessorWithUserDataT, -14);
+
+    // values
+    assertPropertyIsNot(obj, 'readonlyValue', 'writable');
+    assertPropertyIsNot(obj, 'readonlyValue', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyValue', 'configurable');
+    assert.strictEqual(obj.readonlyValue, true);
+
+    assertPropertyIs(obj, 'readwriteValue', 'writable');
+    assertPropertyIsNot(obj, 'readwriteValue', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteValue', 'configurable');
+    obj.readwriteValue = false;
+    assert.strictEqual(obj.readwriteValue, false);
+    obj.readwriteValue = true;
+    assert.strictEqual(obj.readwriteValue, true);
+
+    assertPropertyIsNot(obj, 'enumerableValue', 'writable');
+    assertPropertyIs(obj, 'enumerableValue', 'enumerable');
+    assertPropertyIsNot(obj, 'enumerableValue', 'configurable');
+
+    assertPropertyIsNot(obj, 'configurableValue', 'writable');
+    assertPropertyIsNot(obj, 'configurableValue', 'enumerable');
+    assertPropertyIs(obj, 'configurableValue', 'configurable');
+
+    // functions
+    assertPropertyIsNot(obj, 'function', 'writable');
+    assertPropertyIsNot(obj, 'function', 'enumerable');
+    assertPropertyIsNot(obj, 'function', 'configurable');
+    assert.strictEqual(obj.function(), true);
+    assert.strictEqual(obj.functionWithUserData(), obj.readonlyAccessorWithUserDataT);
+  }
+
+  testDefineProperties('literal');
+  testDefineProperties('string');
+  testDefineProperties('value');
+
+  {
+    assert.strictEqual(binding.object.emptyConstructor(true), true);
+    assert.strictEqual(binding.object.emptyConstructor(false), false);
+  }
+
+  {
+    const expected = { 'one': 1, 'two': 2, 'three': 3 };
+    const actual = binding.object.constructorFromObject(expected);
+    assert.deepStrictEqual(actual, expected);
+  }
+
+  {
+    const obj = {};
+    const testSym = Symbol();
+    binding.object.defineValueProperty(obj, testSym, 1);
+    assert.strictEqual(obj[testSym], 1);
+  }
+
+  {
+    const testSym = Symbol();
+    const obj = { 'one': 1, 'two': 2, 'three': 3, [testSym]: 4 };
+    var arr = binding.object.GetPropertyNames(obj);
+    assert.deepStrictEqual(arr, ['one', 'two', 'three']);
+  }
+
+  {
+    const magicObject = binding.object.createObjectUsingMagic();
+    assert.deepStrictEqual(magicObject, {
+      0: 0,
+      42: 120,
+      cp_false: false,
+      cp_true: true,
+      s_true: true,
+      s_false: false,
+      '0.0f': 0,
+      '0.0': 0,
+      '-1': -1,
+      foo2: 'foo',
+      foo4: 'foo',
+      foo5: 'foo',
+      foo6: 'foo',
+      foo7: 'foo',
+      circular: magicObject,
+      circular2: magicObject
+    });
+  }
+
+  {
+    function Ctor() {};
+
+    assert.strictEqual(binding.object.instanceOf(new Ctor(), Ctor), true);
+    assert.strictEqual(binding.object.instanceOf(new Ctor(), Object), true);
+    assert.strictEqual(binding.object.instanceOf({}, Ctor), false);
+    assert.strictEqual(binding.object.instanceOf(null, Ctor), false);
+  }
+
+  if ('sum' in binding.object) {
+      {
+        const obj = {
+          '-forbid': -0x4B1D,
+          '-feedcode': -0xFEEDC0DE,
+          '+office': +0x0FF1CE,
+          '+forbid': +0x4B1D,
+          '+deadbeef': +0xDEADBEEF,
+          '+feedcode': +0xFEEDC0DE,
+        };
+
+        let sum = 0;
+        for (const key in obj) {
+          sum += obj[key];
+        }
+
+        assert.strictEqual(binding.object.sum(obj), sum);
+      }
+
+      {
+        const obj = new Proxy({
+          '-forbid': -0x4B1D,
+          '-feedcode': -0xFEEDC0DE,
+          '+office': +0x0FF1CE,
+          '+forbid': +0x4B1D,
+          '+deadbeef': +0xDEADBEEF,
+          '+feedcode': +0xFEEDC0DE,
+        }, {
+          getOwnPropertyDescriptor(target, p) {
+            throw new Error("getOwnPropertyDescriptor error");
+          },
+          ownKeys(target) {
+            throw new Error("ownKeys error");
+          },
+        });
+
+        assert.throws(() => {
+          binding.object.sum(obj);
+        }, /ownKeys error/);
+    }
+  }
+
+  if ('increment' in binding.object) {
+    const obj = {
+      'a': 0,
+      'b': 1,
+      'c': 2,
+    };
+
+    binding.object.increment(obj);
+
+    assert.deepStrictEqual(obj, {
+      'a': 1,
+      'b': 2,
+      'c': 3,
+    });
+  }
+}

package/vendor/node-addon-api/test/object/object_deprecated.cc

@@ -1,66 +1,66 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static bool testValue = true;
-
-namespace {
-
-Value TestGetter(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), testValue);
-}
-
-void TestSetter(const CallbackInfo& info) {
-   testValue = info[0].As<Boolean>();
-}
-
-Value TestFunction(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), true);
-}
-
-void DefineProperties(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String nameType = info[1].As<String>();
-  Env env = info.Env();
-
-  if (nameType.Utf8Value() == "literal") {
-    obj.DefineProperties({
-      PropertyDescriptor::Accessor("readonlyAccessor", TestGetter),
-      PropertyDescriptor::Accessor("readwriteAccessor", TestGetter, TestSetter),
-      PropertyDescriptor::Function("function", TestFunction),
-    });
-  } else if (nameType.Utf8Value() == "string") {
-    // VS2013 has lifetime issues when passing temporary objects into the constructor of another
-    // object. It generates code to destruct the object as soon as the constructor call returns.
-    // Since this isn't a common case for using std::string objects, I'm refactoring the test to
-    // work around the issue.
-    std::string str1("readonlyAccessor");
-    std::string str2("readwriteAccessor");
-    std::string str7("function");
-
-    obj.DefineProperties({
-      PropertyDescriptor::Accessor(str1, TestGetter),
-      PropertyDescriptor::Accessor(str2, TestGetter, TestSetter),
-      PropertyDescriptor::Function(str7, TestFunction),
-    });
-  } else if (nameType.Utf8Value() == "value") {
-    obj.DefineProperties({
-      PropertyDescriptor::Accessor(
-        Napi::String::New(env, "readonlyAccessor"), TestGetter),
-      PropertyDescriptor::Accessor(
-        Napi::String::New(env, "readwriteAccessor"), TestGetter, TestSetter),
-      PropertyDescriptor::Function(
-        Napi::String::New(env, "function"), TestFunction),
-    });
-  }
-}
-
-} // end of anonymous namespace
-
-Object InitObjectDeprecated(Env env) {
-  Object exports = Object::New(env);
-
-  exports["defineProperties"] = Function::New(env, DefineProperties);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+static bool testValue = true;
+
+namespace {
+
+Value TestGetter(const CallbackInfo& info) {
+   return Boolean::New(info.Env(), testValue);
+}
+
+void TestSetter(const CallbackInfo& info) {
+   testValue = info[0].As<Boolean>();
+}
+
+Value TestFunction(const CallbackInfo& info) {
+   return Boolean::New(info.Env(), true);
+}
+
+void DefineProperties(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String nameType = info[1].As<String>();
+  Env env = info.Env();
+
+  if (nameType.Utf8Value() == "literal") {
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor("readonlyAccessor", TestGetter),
+      PropertyDescriptor::Accessor("readwriteAccessor", TestGetter, TestSetter),
+      PropertyDescriptor::Function("function", TestFunction),
+    });
+  } else if (nameType.Utf8Value() == "string") {
+    // VS2013 has lifetime issues when passing temporary objects into the constructor of another
+    // object. It generates code to destruct the object as soon as the constructor call returns.
+    // Since this isn't a common case for using std::string objects, I'm refactoring the test to
+    // work around the issue.
+    std::string str1("readonlyAccessor");
+    std::string str2("readwriteAccessor");
+    std::string str7("function");
+
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor(str1, TestGetter),
+      PropertyDescriptor::Accessor(str2, TestGetter, TestSetter),
+      PropertyDescriptor::Function(str7, TestFunction),
+    });
+  } else if (nameType.Utf8Value() == "value") {
+    obj.DefineProperties({
+      PropertyDescriptor::Accessor(
+        Napi::String::New(env, "readonlyAccessor"), TestGetter),
+      PropertyDescriptor::Accessor(
+        Napi::String::New(env, "readwriteAccessor"), TestGetter, TestSetter),
+      PropertyDescriptor::Function(
+        Napi::String::New(env, "function"), TestFunction),
+    });
+  }
+}
+
+} // end of anonymous namespace
+
+Object InitObjectDeprecated(Env env) {
+  Object exports = Object::New(env);
+
+  exports["defineProperties"] = Function::New(env, DefineProperties);
+
+  return exports;
+}

package/vendor/node-addon-api/test/object/object_deprecated.js

@@ -1,47 +1,47 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  if (!('object_deprecated' in binding)) {
-    return;
-  }
-  function assertPropertyIs(obj, key, attribute) {
-    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
-    assert.ok(propDesc);
-    assert.ok(propDesc[attribute]);
-  }
-
-  function assertPropertyIsNot(obj, key, attribute) {
-    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
-    assert.ok(propDesc);
-    assert.ok(!propDesc[attribute]);
-  }
-
-  function testDefineProperties(nameType) {
-    const obj = {};
-    binding.object.defineProperties(obj, nameType);
-
-    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
-    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
-    assert.strictEqual(obj.readonlyAccessor, true);
-
-    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
-    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
-    obj.readwriteAccessor = false;
-    assert.strictEqual(obj.readwriteAccessor, false);
-    obj.readwriteAccessor = true;
-    assert.strictEqual(obj.readwriteAccessor, true);
-
-    assertPropertyIsNot(obj, 'function', 'writable');
-    assertPropertyIsNot(obj, 'function', 'enumerable');
-    assertPropertyIsNot(obj, 'function', 'configurable');
-    assert.strictEqual(obj.function(), true);
-  }
-
-  testDefineProperties('literal');
-  testDefineProperties('string');
-  testDefineProperties('value');
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  if (!('object_deprecated' in binding)) {
+    return;
+  }
+  function assertPropertyIs(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(propDesc[attribute]);
+  }
+
+  function assertPropertyIsNot(obj, key, attribute) {
+    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
+    assert.ok(propDesc);
+    assert.ok(!propDesc[attribute]);
+  }
+
+  function testDefineProperties(nameType) {
+    const obj = {};
+    binding.object.defineProperties(obj, nameType);
+
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readonlyAccessor', 'configurable');
+    assert.strictEqual(obj.readonlyAccessor, true);
+
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'enumerable');
+    assertPropertyIsNot(obj, 'readwriteAccessor', 'configurable');
+    obj.readwriteAccessor = false;
+    assert.strictEqual(obj.readwriteAccessor, false);
+    obj.readwriteAccessor = true;
+    assert.strictEqual(obj.readwriteAccessor, true);
+
+    assertPropertyIsNot(obj, 'function', 'writable');
+    assertPropertyIsNot(obj, 'function', 'enumerable');
+    assertPropertyIsNot(obj, 'function', 'configurable');
+    assert.strictEqual(obj.function(), true);
+  }
+
+  testDefineProperties('literal');
+  testDefineProperties('string');
+  testDefineProperties('value');
+}