From 6937cd993702c5f0e9cac03df3ba45c7d2388365 Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Fri, 12 Jan 2018 11:23:56 -0500 Subject: [PATCH 1/7] Add ObjectReference test case --- test/binding.cc | 2 + test/binding.gyp | 1 + test/index.js | 3 +- test/objectreference.cc | 163 +++++++++++++++++++++++++++++++++ test/objectreference.js | 194 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 362 insertions(+), 1 deletion(-) create mode 100644 test/objectreference.cc create mode 100644 test/objectreference.js diff --git a/test/binding.cc b/test/binding.cc index 3f08d33a2..ec0f5ec0a 100644 --- a/test/binding.cc +++ b/test/binding.cc @@ -15,6 +15,7 @@ Object InitObject(Env env); Object InitPromise(Env env); Object InitTypedArray(Env env); Object InitObjectWrap(Env env); +Object InitObjectReference(Env env); Object Init(Env env, Object exports) { exports.Set("arraybuffer", InitArrayBuffer(env)); @@ -30,6 +31,7 @@ Object Init(Env env, Object exports) { exports.Set("promise", InitPromise(env)); exports.Set("typedarray", InitTypedArray(env)); exports.Set("objectwrap", InitObjectWrap(env)); + exports.Set("objectreference", InitObjectReference(env)); return exports; } diff --git a/test/binding.gyp b/test/binding.gyp index 637db1e51..ba7928241 100644 --- a/test/binding.gyp +++ b/test/binding.gyp @@ -20,6 +20,7 @@ 'promise.cc', 'typedarray.cc', 'objectwrap.cc', + 'objectreference.cc', ], 'include_dirs': ["::New(Object::New(env), 2); + + if (info[0].IsString()) { + if (info[2].As() == String::New(env, "javascript")) { + dummy_weak.Set(info[0].As(), info[1]); + dummy_persistent.Set(info[0].As(), info[1]); + unrefDummy(); + dummy_reference.Set(info[0].As(), info[1]); + } else { + dummy_weak.Set(info[0].As().Utf8Value(), info[1]); + dummy_persistent.Set(info[0].As().Utf8Value(), info[1]); + dummy_reference.Set(info[0].As().Utf8Value(), info[1]); + } + } else if (info[0].IsNumber()) { + dummy_weak.Set(info[0].As(), info[1]); + dummy_persistent.Set(info[0].As(), info[1]); + dummy_reference.Set(info[0].As(), info[1]); + } +} + +void SetCastedObjects(const CallbackInfo& info) { + Env env = info.Env(); + HandleScope scope(env); + + Array ex = Array::New(env); + ex.Set(Number::New(env, 0), String::New(env, "hello")); + ex.Set(Number::New(env, 1), String::New(env, "world")); + ex.Set(Number::New(env, 2), String::New(env, "!")); + + casted_weak = Weak(ex.As()); + casted_persistent = Persistent(ex.As()); + casted_reference = Reference::New(ex.As(), 2); +} + + +Value GetFromValue(const CallbackInfo& info) { + Env env = info.Env(); + + if (info[0].As() == String::New(env, "weak")) { + if (dummy_weak.IsEmpty()) { + return String::New(env, "No Referenced Value"); + } else { + return dummy_weak.Value(); + } + } else if (info[0].As() == String::New(env, "persistent")) { + return dummy_persistent.Value(); + } else { + return dummy_reference.Value(); + } +} + +Value GetFromGetter(const CallbackInfo& info) { + Env env = info.Env(); + + if (info[0].As() == String::New(env, "weak")) { + if (dummy_weak.IsEmpty()) { + return String::New(env, "No Referenced Value"); + } else { + if (info[1].IsString()) { + return dummy_weak.Get(info[1].As().Utf8Value()); + } else if (info[1].IsNumber()) { + return dummy_weak.Get(info[1].As().Uint32Value()); + } + } + } else if (info[0].As() == String::New(env, "persistent")) { + if (info[1].IsString()) { + return dummy_persistent.Get(info[1].As().Utf8Value()); + } else if (info[1].IsNumber()) { + return dummy_persistent.Get(info[1].As().Uint32Value()); + } + } else { + if (info[0].IsString()) { + return dummy_reference.Get(info[0].As().Utf8Value()); + } else if (info[0].IsNumber()) { + return dummy_reference.Get(info[0].As().Uint32Value()); + } + } + + return String::New(env, "Error: Reached end of getter"); +} + +Value GetCastedFromValue(const CallbackInfo& info) { + Env env = info.Env(); + + if (info[0].As() == String::New(env, "weak")) { + if (casted_weak.IsEmpty()) { + return String::New(env, "No Referenced Value"); + } else { + return casted_weak.Value(); + } + } else if (info[0].As() == String::New(env, "persistent")) { + return casted_persistent.Value(); + } else { + return casted_reference.Value(); + } +} + +Value GetCastedFromGetter(const CallbackInfo& info) { + Env env = info.Env(); + + if (info[0].As() == String::New(env, "weak")) { + if (casted_weak.IsEmpty()) { + return String::New(env, "No Referenced Value"); + } else { + return casted_weak.Get(info[1].As()); + } + } else if (info[0].As() == String::New(env, "persistent")) { + return casted_persistent.Get(info[1].As()); + } else { + return casted_reference.Get(info[1].As()); + } +} + +void UnrefObjects(const CallbackInfo& info) { + Env env = info.Env(); + + if (info[0].As() == String::New(env, "dummy persistent")) { + dummy_persistent.Unref(); + } else if (info[0].As() == String::New(env, "dummy references")) { + dummy_reference.Unref(); + } else if (info[0].As() == String::New(env, "casted persistent")) { + casted_persistent.Unref(); + } else if (info[0].As() == String::New(env, "casted reference")) { + casted_reference.Unref(); + } +} + +Object InitObjectReference(Env env) { + Object exports = Object::New(env); + + exports["setCastedObjects"] = Function::New(env, SetCastedObjects); + exports["setObjects"] = Function::New(env, SetObjects); + exports["getCastedFromValue"] = Function::New(env, GetCastedFromValue); + exports["getFromGetter"] = Function::New(env, GetFromGetter); + exports["getCastedFromGetter"] = Function::New(env, GetCastedFromGetter); + exports["getFromValue"] = Function::New(env, GetFromValue); + exports["unrefObjects"] = Function::New(env, UnrefObjects); + + return exports; +} diff --git a/test/objectreference.js b/test/objectreference.js new file mode 100644 index 000000000..348fa7e3a --- /dev/null +++ b/test/objectreference.js @@ -0,0 +1,194 @@ +'use strict'; +const buildType = process.config.target_defaults.default_configuration; +const assert = require('assert'); +const testUtil = require('./testUtil'); + +test(require(`./build/${buildType}/binding.node`)); +test(require(`./build/${buildType}/binding_noexcept.node`)); + +function test(binding) { + function testCastedEqual(testToCompare) { + var compare_test = ["hello", "world", "!"]; + if (testToCompare instanceof Array) { + assert.deepEqual(compare_test, testToCompare); + } else if (testToCompare instanceof String) { + assert.deepEqual("No Referenced Value", testToCompare); + } else { + assert.fail(); + } + } + + testUtil.runGCTests([ + 'Weak Casted Array', + () => { + binding.objectreference.setCastedObjects(); + var test = binding.objectreference.getCastedFromValue("weak"); + var test2 = new Array(); + test2[0] = binding.objectreference.getCastedFromGetter("weak", 0); + test2[1] = binding.objectreference.getCastedFromGetter("weak", 1); + test2[2] = binding.objectreference.getCastedFromGetter("weak", 2); + + testCastedEqual(test); + testCastedEqual(test2); + }, + + 'Persistent Casted Array', + () => { + binding.objectreference.setCastedObjects(); + const test = binding.objectreference.getCastedFromValue("persistent"); + const test2 = new Array(); + test2[0] = binding.objectreference.getCastedFromGetter("persistent", 0); + test2[1] = binding.objectreference.getCastedFromGetter("persistent", 1); + test2[2] = binding.objectreference.getCastedFromGetter("persistent", 2); + + assert.ok(test instanceof Array); + assert.ok(test2 instanceof Array); + testCastedEqual(test); + testCastedEqual(test2); + }, + + 'References Casted Array', + () => { + binding.objectreference.setCastedObjects(); + const test = binding.objectreference.getCastedFromValue(); + const test2 = new Array(); + test2[0] = binding.objectreference.getCastedFromGetter("reference", 0); + test2[1] = binding.objectreference.getCastedFromGetter("reference", 1); + test2[2] = binding.objectreference.getCastedFromGetter("reference", 2); + + assert.ok(test instanceof Array); + assert.ok(test2 instanceof Array); + testCastedEqual(test); + testCastedEqual(test2); + }, + + 'Weak Dummy', + () => { + binding.objectreference.setDummyObjects("hello", "world"); + const test = binding.objectreference.getDummyFromValue("weak"); + const test2 = binding.objectreference.getDummyFromGetter("weak", "hello"); + + assert.deepEqual({ hello: "world"}, test); + assert.equal("world", test2); + assert.equal(test["hello"], test2); + }, + () => { + binding.objectreference.setDummyObjects(1, "hello world"); + const test = binding.objectreference.getDummyFromValue("weak"); + const test2 = binding.objectreference.getDummyFromGetter("weak", 1); + + assert.deepEqual({ 1: "hello world"}, test); + assert.equal("hello world", test2); + assert.equal(test[1], test2); + }, + () => { + binding.objectreference.setDummyObjects(0, "hello"); + binding.objectreference.setDummyObjects(1, "world"); + const test = binding.objectreference.getDummyFromValue("weak"); + const test2 = binding.objectreference.getDummyFromGetter("weak", 0); + const test3 = binding.objectreference.getDummyFromGetter("weak", 1); + + assert.deepEqual({ 1: "world"}, test); + assert.equal(undefined, test2); + assert.equal("world", test3); + }, + + 'Persistent Dummy', + () => { + binding.objectreference.setDummyObjects("hello", "world"); + const test = binding.objectreference.getDummyFromValue("persistent"); + const test2 = binding.objectreference.getDummyFromGetter("persistent", "hello"); + + assert.deepEqual({ hello: "world"}, test); + assert.equal("world", test2); + assert.equal(test["hello"], test2); + }, + () => { + binding.objectreference.setDummyObjects(1, "hello world"); + const test = binding.objectreference.getDummyFromValue("persistent"); + const test2 = binding.objectreference.getDummyFromGetter("persistent", 1); + + assert.deepEqual({ 1: "hello world"}, test); + assert.equal("hello world", test2); + assert.equal(test[1], test2); + }, + () => { + binding.objectreference.setDummyObjects(0, "hello"); + binding.objectreference.setDummyObjects(1, "world"); + const test = binding.objectreference.getDummyFromValue("persistent"); + const test2 = binding.objectreference.getDummyFromGetter("persistent", 0); + const test3 = binding.objectreference.getDummyFromGetter("persistent", 1); + + assert.deepEqual({ 1: "world"}, test); + assert.equal(undefined, test2); + assert.equal("world", test3); + }, + () => { + binding.objectreference.setDummyObjects("hello", "world"); + assert.doesNotThrow( + () => { + binding.objectreference.unrefObjects("dummy persistent"); + }, + Error + ); + assert.throws( + () => { + binding.objectreference.unrefObjects("dummy persistent"); + }, + Error + ); + }, + + 'References Dummy', + () => { + binding.objectreference.setDummyObjects("hello", "world"); + const test = binding.objectreference.getDummyFromValue(); + const test2 = binding.objectreference.getDummyFromGetter("hello"); + + assert.deepEqual({ hello: "world"}, test); + assert.equal("world", test2); + assert.equal(test["hello"], test2); + }, + () => { + binding.objectreference.setDummyObjects(1, "hello world"); + const test = binding.objectreference.getDummyFromValue(); + const test2 = binding.objectreference.getDummyFromGetter(1); + + assert.deepEqual({ 1: "hello world"}, test); + assert.equal("hello world", test2); + assert.equal(test[1], test2); + }, + () => { + binding.objectreference.setDummyObjects(0, "hello"); + binding.objectreference.setDummyObjects(1, "world"); + const test = binding.objectreference.getDummyFromValue(); + const test2 = binding.objectreference.getDummyFromGetter(0); + const test3 = binding.objectreference.getDummyFromGetter(1); + + assert.deepEqual({ 1: "world"}, test); + assert.equal(undefined, test2); + assert.equal("world", test3); + }, + () => { + binding.objectreference.setDummyObjects("hello", "world"); + assert.doesNotThrow( + () => { + binding.objectreference.unrefObjects("dummy reference"); + }, + Error + ); + assert.doesNotThrow( + () => { + binding.objectreference.unrefObjects("dummy reference"); + }, + Error + ); + assert.throws( + () => { + binding.objectreference.unrefObjects("dummy reference"); + }, + Error + ); + } + ]) +}; From 3920572384208d53bb10582898d5942d362d6709 Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Mon, 15 Jan 2018 12:57:56 -0500 Subject: [PATCH 2/7] naming changes --- test/objectreference.cc | 63 +++++++++++++++--------------- test/objectreference.js | 86 ++++++++++++++++++++--------------------- 2 files changed, 74 insertions(+), 75 deletions(-) diff --git a/test/objectreference.cc b/test/objectreference.cc index e428160ce..a14c93733 100644 --- a/test/objectreference.cc +++ b/test/objectreference.cc @@ -1,4 +1,4 @@ -/* ObjectReference cant be used to create references to Values that +/* ObjectReference can be used to create references to Values that are not Objects by creating a blank Object and setting Values to it. Subclasses of Objects can only be set using an ObjectReference by first casting it as an Object. */ @@ -19,25 +19,24 @@ void SetObjects(const CallbackInfo& info) { Env env = info.Env(); HandleScope scope(env); - dummy_weak = Weak(Object::New(env)); - dummy_persistent = Persistent(Object::New(env)); - dummy_reference = Reference::New(Object::New(env), 2); + weak = Weak(Object::New(env)); + persistent = Persistent(Object::New(env)); + reference = Reference::New(Object::New(env), 2); if (info[0].IsString()) { if (info[2].As() == String::New(env, "javascript")) { - dummy_weak.Set(info[0].As(), info[1]); - dummy_persistent.Set(info[0].As(), info[1]); - unrefDummy(); - dummy_reference.Set(info[0].As(), info[1]); + weak.Set(info[0].As(), info[1]); + persistent.Set(info[0].As(), info[1]); + reference.Set(info[0].As(), info[1]); } else { - dummy_weak.Set(info[0].As().Utf8Value(), info[1]); - dummy_persistent.Set(info[0].As().Utf8Value(), info[1]); - dummy_reference.Set(info[0].As().Utf8Value(), info[1]); + weak.Set(info[0].As().Utf8Value(), info[1]); + persistent.Set(info[0].As().Utf8Value(), info[1]); + reference.Set(info[0].As().Utf8Value(), info[1]); } } else if (info[0].IsNumber()) { - dummy_weak.Set(info[0].As(), info[1]); - dummy_persistent.Set(info[0].As(), info[1]); - dummy_reference.Set(info[0].As(), info[1]); + weak.Set(info[0].As(), info[1]); + persistent.Set(info[0].As(), info[1]); + reference.Set(info[0].As(), info[1]); } } @@ -46,9 +45,9 @@ void SetCastedObjects(const CallbackInfo& info) { HandleScope scope(env); Array ex = Array::New(env); - ex.Set(Number::New(env, 0), String::New(env, "hello")); - ex.Set(Number::New(env, 1), String::New(env, "world")); - ex.Set(Number::New(env, 2), String::New(env, "!")); + ex.Set((uint32_t)0, String::New(env, "hello")); + ex.Set(1, String::New(env, "world")); + ex.Set(2, String::New(env, "!")); casted_weak = Weak(ex.As()); casted_persistent = Persistent(ex.As()); @@ -60,15 +59,15 @@ Value GetFromValue(const CallbackInfo& info) { Env env = info.Env(); if (info[0].As() == String::New(env, "weak")) { - if (dummy_weak.IsEmpty()) { + if (weak.IsEmpty()) { return String::New(env, "No Referenced Value"); } else { - return dummy_weak.Value(); + return weak.Value(); } } else if (info[0].As() == String::New(env, "persistent")) { - return dummy_persistent.Value(); + return persistent.Value(); } else { - return dummy_reference.Value(); + return reference.Value(); } } @@ -76,26 +75,26 @@ Value GetFromGetter(const CallbackInfo& info) { Env env = info.Env(); if (info[0].As() == String::New(env, "weak")) { - if (dummy_weak.IsEmpty()) { + if (weak.IsEmpty()) { return String::New(env, "No Referenced Value"); } else { if (info[1].IsString()) { - return dummy_weak.Get(info[1].As().Utf8Value()); + return weak.Get(info[1].As().Utf8Value()); } else if (info[1].IsNumber()) { - return dummy_weak.Get(info[1].As().Uint32Value()); + return weak.Get(info[1].As().Uint32Value()); } } } else if (info[0].As() == String::New(env, "persistent")) { if (info[1].IsString()) { - return dummy_persistent.Get(info[1].As().Utf8Value()); + return persistent.Get(info[1].As().Utf8Value()); } else if (info[1].IsNumber()) { - return dummy_persistent.Get(info[1].As().Uint32Value()); + return persistent.Get(info[1].As().Uint32Value()); } } else { if (info[0].IsString()) { - return dummy_reference.Get(info[0].As().Utf8Value()); + return reference.Get(info[0].As().Utf8Value()); } else if (info[0].IsNumber()) { - return dummy_reference.Get(info[0].As().Uint32Value()); + return reference.Get(info[0].As().Uint32Value()); } } @@ -137,10 +136,10 @@ Value GetCastedFromGetter(const CallbackInfo& info) { void UnrefObjects(const CallbackInfo& info) { Env env = info.Env(); - if (info[0].As() == String::New(env, "dummy persistent")) { - dummy_persistent.Unref(); - } else if (info[0].As() == String::New(env, "dummy references")) { - dummy_reference.Unref(); + if (info[0].As() == String::New(env, "persistent")) { + persistent.Unref(); + } else if (info[0].As() == String::New(env, "references")) { + reference.Unref(); } else if (info[0].As() == String::New(env, "casted persistent")) { casted_persistent.Unref(); } else if (info[0].As() == String::New(env, "casted reference")) { diff --git a/test/objectreference.js b/test/objectreference.js index 348fa7e3a..fbdb49fc7 100644 --- a/test/objectreference.js +++ b/test/objectreference.js @@ -62,130 +62,130 @@ function test(binding) { testCastedEqual(test2); }, - 'Weak Dummy', + 'Weak', () => { - binding.objectreference.setDummyObjects("hello", "world"); - const test = binding.objectreference.getDummyFromValue("weak"); - const test2 = binding.objectreference.getDummyFromGetter("weak", "hello"); + binding.objectreference.setObjects("hello", "world"); + const test = binding.objectreference.getFromValue("weak"); + const test2 = binding.objectreference.getFromGetter("weak", "hello"); assert.deepEqual({ hello: "world"}, test); assert.equal("world", test2); assert.equal(test["hello"], test2); }, () => { - binding.objectreference.setDummyObjects(1, "hello world"); - const test = binding.objectreference.getDummyFromValue("weak"); - const test2 = binding.objectreference.getDummyFromGetter("weak", 1); + binding.objectreference.setObjects(1, "hello world"); + const test = binding.objectreference.getFromValue("weak"); + const test2 = binding.objectreference.getFromGetter("weak", 1); assert.deepEqual({ 1: "hello world"}, test); assert.equal("hello world", test2); assert.equal(test[1], test2); }, () => { - binding.objectreference.setDummyObjects(0, "hello"); - binding.objectreference.setDummyObjects(1, "world"); - const test = binding.objectreference.getDummyFromValue("weak"); - const test2 = binding.objectreference.getDummyFromGetter("weak", 0); - const test3 = binding.objectreference.getDummyFromGetter("weak", 1); + binding.objectreference.setObjects(0, "hello"); + binding.objectreference.setObjects(1, "world"); + const test = binding.objectreference.getFromValue("weak"); + const test2 = binding.objectreference.getFromGetter("weak", 0); + const test3 = binding.objectreference.getFromGetter("weak", 1); assert.deepEqual({ 1: "world"}, test); assert.equal(undefined, test2); assert.equal("world", test3); }, - 'Persistent Dummy', + 'Persistent', () => { - binding.objectreference.setDummyObjects("hello", "world"); - const test = binding.objectreference.getDummyFromValue("persistent"); - const test2 = binding.objectreference.getDummyFromGetter("persistent", "hello"); + binding.objectreference.setObjects("hello", "world"); + const test = binding.objectreference.getFromValue("persistent"); + const test2 = binding.objectreference.getFromGetter("persistent", "hello"); assert.deepEqual({ hello: "world"}, test); assert.equal("world", test2); assert.equal(test["hello"], test2); }, () => { - binding.objectreference.setDummyObjects(1, "hello world"); - const test = binding.objectreference.getDummyFromValue("persistent"); - const test2 = binding.objectreference.getDummyFromGetter("persistent", 1); + binding.objectreference.setObjects(1, "hello world"); + const test = binding.objectreference.getFromValue("persistent"); + const test2 = binding.objectreference.getFromGetter("persistent", 1); assert.deepEqual({ 1: "hello world"}, test); assert.equal("hello world", test2); assert.equal(test[1], test2); }, () => { - binding.objectreference.setDummyObjects(0, "hello"); - binding.objectreference.setDummyObjects(1, "world"); - const test = binding.objectreference.getDummyFromValue("persistent"); - const test2 = binding.objectreference.getDummyFromGetter("persistent", 0); - const test3 = binding.objectreference.getDummyFromGetter("persistent", 1); + binding.objectreference.setObjects(0, "hello"); + binding.objectreference.setObjects(1, "world"); + const test = binding.objectreference.getFromValue("persistent"); + const test2 = binding.objectreference.getFromGetter("persistent", 0); + const test3 = binding.objectreference.getFromGetter("persistent", 1); assert.deepEqual({ 1: "world"}, test); assert.equal(undefined, test2); assert.equal("world", test3); }, () => { - binding.objectreference.setDummyObjects("hello", "world"); + binding.objectreference.setObjects("hello", "world"); assert.doesNotThrow( () => { - binding.objectreference.unrefObjects("dummy persistent"); + binding.objectreference.unrefObjects("persistent"); }, Error ); assert.throws( () => { - binding.objectreference.unrefObjects("dummy persistent"); + binding.objectreference.unrefObjects("persistent"); }, Error ); }, - 'References Dummy', + 'References', () => { - binding.objectreference.setDummyObjects("hello", "world"); - const test = binding.objectreference.getDummyFromValue(); - const test2 = binding.objectreference.getDummyFromGetter("hello"); + binding.objectreference.setObjects("hello", "world"); + const test = binding.objectreference.getFromValue(); + const test2 = binding.objectreference.getFromGetter("hello"); assert.deepEqual({ hello: "world"}, test); assert.equal("world", test2); assert.equal(test["hello"], test2); }, () => { - binding.objectreference.setDummyObjects(1, "hello world"); - const test = binding.objectreference.getDummyFromValue(); - const test2 = binding.objectreference.getDummyFromGetter(1); + binding.objectreference.setObjects(1, "hello world"); + const test = binding.objectreference.getFromValue(); + const test2 = binding.objectreference.getFromGetter(1); assert.deepEqual({ 1: "hello world"}, test); assert.equal("hello world", test2); assert.equal(test[1], test2); }, () => { - binding.objectreference.setDummyObjects(0, "hello"); - binding.objectreference.setDummyObjects(1, "world"); - const test = binding.objectreference.getDummyFromValue(); - const test2 = binding.objectreference.getDummyFromGetter(0); - const test3 = binding.objectreference.getDummyFromGetter(1); + binding.objectreference.setObjects(0, "hello"); + binding.objectreference.setObjects(1, "world"); + const test = binding.objectreference.getFromValue(); + const test2 = binding.objectreference.getFromGetter(0); + const test3 = binding.objectreference.getFromGetter(1); assert.deepEqual({ 1: "world"}, test); assert.equal(undefined, test2); assert.equal("world", test3); }, () => { - binding.objectreference.setDummyObjects("hello", "world"); + binding.objectreference.setObjects("hello", "world"); assert.doesNotThrow( () => { - binding.objectreference.unrefObjects("dummy reference"); + binding.objectreference.unrefObjects("references"); }, Error ); assert.doesNotThrow( () => { - binding.objectreference.unrefObjects("dummy reference"); + binding.objectreference.unrefObjects("references"); }, Error ); assert.throws( () => { - binding.objectreference.unrefObjects("dummy reference"); + binding.objectreference.unrefObjects("references"); }, Error ); From 6bba1413173283352012353b5ded6f4687f54025 Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Tue, 16 Jan 2018 13:19:17 -0500 Subject: [PATCH 3/7] Added ref tests and more unref tests --- test/objectreference.cc | 43 ++++++++++++++++++++++++++++++++++------- test/objectreference.js | 39 +++++++++++++++++++++++++++++-------- 2 files changed, 67 insertions(+), 15 deletions(-) diff --git a/test/objectreference.cc b/test/objectreference.cc index a14c93733..de09ba6bd 100644 --- a/test/objectreference.cc +++ b/test/objectreference.cc @@ -133,18 +133,46 @@ Value GetCastedFromGetter(const CallbackInfo& info) { } } -void UnrefObjects(const CallbackInfo& info) { +Number UnrefObjects(const CallbackInfo& info) { Env env = info.Env(); + uint32_t num; - if (info[0].As() == String::New(env, "persistent")) { - persistent.Unref(); + if (info[0].As() == String::New(env, "weak")) { + num = weak.Unref(); + } else if (info[0].As() == String::New(env, "persistent")) { + num = persistent.Unref(); } else if (info[0].As() == String::New(env, "references")) { - reference.Unref(); + num = reference.Unref(); + } else if (info[0].As() == String::New(env, "casted weak")) { + num = casted_weak.Unref(); } else if (info[0].As() == String::New(env, "casted persistent")) { - casted_persistent.Unref(); - } else if (info[0].As() == String::New(env, "casted reference")) { - casted_reference.Unref(); + num = casted_persistent.Unref(); + } else { + num = casted_reference.Unref(); } + + return Number::New(env, num); +} + +Number RefObjects(const CallbackInfo& info) { + Env env = info.Env(); + uint32_t num; + + if (info[0].As() == String::New(env, "weak")) { + num = weak.Ref(); + } else if (info[0].As() == String::New(env, "persistent")) { + num = persistent.Ref(); + } else if (info[0].As() == String::New(env, "references")) { + num = reference.Ref(); + } else if (info[0].As() == String::New(env, "casted weak")) { + num = casted_weak.Ref(); + } else if (info[0].As() == String::New(env, "casted persistent")) { + num = casted_persistent.Ref(); + } else { + num = casted_reference.Ref(); + } + + return Number::New(env, num); } Object InitObjectReference(Env env) { @@ -157,6 +185,7 @@ Object InitObjectReference(Env env) { exports["getCastedFromGetter"] = Function::New(env, GetCastedFromGetter); exports["getFromValue"] = Function::New(env, GetFromValue); exports["unrefObjects"] = Function::New(env, UnrefObjects); + exports["refObjects"] = Function::New(env, RefObjects); return exports; } diff --git a/test/objectreference.js b/test/objectreference.js index fbdb49fc7..b48107b51 100644 --- a/test/objectreference.js +++ b/test/objectreference.js @@ -92,6 +92,19 @@ function test(binding) { assert.equal(undefined, test2); assert.equal("world", test3); }, + () => { + binding.objectreference.setObjects("hello", "world"); + assert.throws( + () => { + var rcount = binding.objectreference.refObjects("weak"); + assert.equal(rcount, 1); + rcount = binding.objectreference.unrefObjects("weak"); + assert.equal(rcount, 0); + binding.objectreference.unrefObjects("weak"); + }, + Error + ); + }, 'Persistent', () => { @@ -127,7 +140,16 @@ function test(binding) { binding.objectreference.setObjects("hello", "world"); assert.doesNotThrow( () => { - binding.objectreference.unrefObjects("persistent"); + var rcount = binding.objectreference.unrefObjects("persistent"); + assert.equal(rcount, 0); + rcount = binding.objectreference.refObjects("persistent"); + assert.equal(rcount, 1); + rcount = binding.objectreference.unrefObjects("persistent"); + assert.equal(rcount, 0); + rcount = binding.objectreference.refObjects("persistent"); + assert.equal(rcount, 1); + rcount = binding.objectreference.unrefObjects("persistent"); + assert.equal(rcount, 0); }, Error ); @@ -173,13 +195,14 @@ function test(binding) { binding.objectreference.setObjects("hello", "world"); assert.doesNotThrow( () => { - binding.objectreference.unrefObjects("references"); - }, - Error - ); - assert.doesNotThrow( - () => { - binding.objectreference.unrefObjects("references"); + var rcount = binding.objectreference.unrefObjects("references"); + assert.equal(rcount, 1); + rcount = binding.objectreference.refObjects("references"); + assert.equal(rcount, 2); + rcount = binding.objectreference.unrefObjects("references"); + assert.equal(rcount, 1); + rcount = binding.objectreference.unrefObjects("references"); + assert.equal(rcount, 0); }, Error ); From 6e6ba3c72a8cfe636791cd60c7ffb34b6ff257ac Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Tue, 16 Jan 2018 22:28:43 -0500 Subject: [PATCH 4/7] added javascript string tests --- test/objectreference.js | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/test/objectreference.js b/test/objectreference.js index b48107b51..f222b245b 100644 --- a/test/objectreference.js +++ b/test/objectreference.js @@ -72,12 +72,21 @@ function test(binding) { assert.equal("world", test2); assert.equal(test["hello"], test2); }, + () => { + binding.objectreference.setObjects("hello", "world", "javascript"); + const test = binding.objectreference.getFromValue("weak"); + const test2 = binding.objectreference.getFromValue("weak", "hello"); + + assert.deepEqual({ hello: "world" }, test); + assert.deepEqual({ hello: "world" }, test2); + assert.equal(test, test2); + }, () => { binding.objectreference.setObjects(1, "hello world"); const test = binding.objectreference.getFromValue("weak"); const test2 = binding.objectreference.getFromGetter("weak", 1); - assert.deepEqual({ 1: "hello world"}, test); + assert.deepEqual({ 1: "hello world" }, test); assert.equal("hello world", test2); assert.equal(test[1], test2); }, @@ -88,7 +97,7 @@ function test(binding) { const test2 = binding.objectreference.getFromGetter("weak", 0); const test3 = binding.objectreference.getFromGetter("weak", 1); - assert.deepEqual({ 1: "world"}, test); + assert.deepEqual({ 1: "world" }, test); assert.equal(undefined, test2); assert.equal("world", test3); }, @@ -112,10 +121,19 @@ function test(binding) { const test = binding.objectreference.getFromValue("persistent"); const test2 = binding.objectreference.getFromGetter("persistent", "hello"); - assert.deepEqual({ hello: "world"}, test); + assert.deepEqual({ hello: "world" }, test); assert.equal("world", test2); assert.equal(test["hello"], test2); }, + () => { + binding.objectreference.setObjects("hello", "world", "javascript"); + const test = binding.objectreference.getFromValue("persistent"); + const test2 = binding.objectreference.getFromValue("persistent", "hello"); + + assert.deepEqual({ hello: "world" }, test); + assert.deepEqual({ hello: "world" }, test2); + assert.deepEqual(test, test2); + }, () => { binding.objectreference.setObjects(1, "hello world"); const test = binding.objectreference.getFromValue("persistent"); @@ -167,10 +185,19 @@ function test(binding) { const test = binding.objectreference.getFromValue(); const test2 = binding.objectreference.getFromGetter("hello"); - assert.deepEqual({ hello: "world"}, test); + assert.deepEqual({ hello: "world" }, test); assert.equal("world", test2); assert.equal(test["hello"], test2); }, + () => { + binding.objectreference.setObjects("hello", "world", "javascript"); + const test = binding.objectreference.getFromValue(); + const test2 = binding.objectreference.getFromValue("hello"); + + assert.deepEqual({ hello: "world" }, test); + assert.deepEqual({ hello: "world" }, test2); + assert.deepEqual(test, test2); + }, () => { binding.objectreference.setObjects(1, "hello world"); const test = binding.objectreference.getFromValue(); From df902608574aa028c942da3821408979fcc139af Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Tue, 16 Jan 2018 23:03:38 -0500 Subject: [PATCH 5/7] added comments to explain parameters and test cases --- test/objectreference.cc | 19 ++++++++++++++++++- test/objectreference.js | 11 +++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/test/objectreference.cc b/test/objectreference.cc index de09ba6bd..d7a315d9f 100644 --- a/test/objectreference.cc +++ b/test/objectreference.cc @@ -15,6 +15,10 @@ ObjectReference casted_weak; ObjectReference casted_persistent; ObjectReference casted_reference; +// info[0] is the key, which can be either a string or a number. +// info[1] is the value. +// info[2] is a flag that differentiates whether the key is a +// C string or a JavaScript string. void SetObjects(const CallbackInfo& info) { Env env = info.Env(); HandleScope scope(env); @@ -54,7 +58,8 @@ void SetCastedObjects(const CallbackInfo& info) { casted_reference = Reference::New(ex.As(), 2); } - +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. Value GetFromValue(const CallbackInfo& info) { Env env = info.Env(); @@ -71,6 +76,9 @@ Value GetFromValue(const CallbackInfo& info) { } } +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. +// info[1] is the key, and it be either a String or a Number. Value GetFromGetter(const CallbackInfo& info) { Env env = info.Env(); @@ -101,6 +109,8 @@ Value GetFromGetter(const CallbackInfo& info) { return String::New(env, "Error: Reached end of getter"); } +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. Value GetCastedFromValue(const CallbackInfo& info) { Env env = info.Env(); @@ -117,6 +127,9 @@ Value GetCastedFromValue(const CallbackInfo& info) { } } +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. +// info[1] is the key and it must be a Number. Value GetCastedFromGetter(const CallbackInfo& info) { Env env = info.Env(); @@ -133,6 +146,8 @@ Value GetCastedFromGetter(const CallbackInfo& info) { } } +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. Number UnrefObjects(const CallbackInfo& info) { Env env = info.Env(); uint32_t num; @@ -154,6 +169,8 @@ Number UnrefObjects(const CallbackInfo& info) { return Number::New(env, num); } +// info[0] is a flag to determine if the weak, persistent, or +// multiple reference ObjectReference is being requested. Number RefObjects(const CallbackInfo& info) { Env env = info.Env(); uint32_t num; diff --git a/test/objectreference.js b/test/objectreference.js index f222b245b..85d3d50ef 100644 --- a/test/objectreference.js +++ b/test/objectreference.js @@ -1,3 +1,14 @@ +/* + * First tests are for setting and getting the ObjectReference on the + * casted Array as Object. Then the tests are for the ObjectReference + * to an empty Object. They test setting the ObjectReference with a C + * string, a JavaScript string, and a JavaScript Number as the keys. + * Then getting the value of those keys through the Reference function + * Value() and through the ObjectReference getters. Finally, they test + * Unref() and Ref() to determine if the reference count is as + * expected and errors are thrown when expected. + */ + 'use strict'; const buildType = process.config.target_defaults.default_configuration; const assert = require('assert'); From 3f04b758245ebe011b6f9d6f5dccfea84850d6c3 Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Wed, 17 Jan 2018 22:58:15 -0500 Subject: [PATCH 6/7] Added an assert.doesNotThrow to separate assert statements --- test/objectreference.js | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/test/objectreference.js b/test/objectreference.js index 85d3d50ef..5041b5e4d 100644 --- a/test/objectreference.js +++ b/test/objectreference.js @@ -114,12 +114,17 @@ function test(binding) { }, () => { binding.objectreference.setObjects("hello", "world"); - assert.throws( + assert.doesNotThrow( () => { var rcount = binding.objectreference.refObjects("weak"); assert.equal(rcount, 1); rcount = binding.objectreference.unrefObjects("weak"); assert.equal(rcount, 0); + }, + Error + ); + assert.throws( + () => { binding.objectreference.unrefObjects("weak"); }, Error From cefbdd315dee36a91002f4c94b2c080a5e5fec0a Mon Sep 17 00:00:00 2001 From: Anisha Rohra Date: Thu, 19 Jul 2018 01:37:34 -0400 Subject: [PATCH 7/7] Added suppressdestruct in order to prevent segfault --- test/objectreference.cc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/test/objectreference.cc b/test/objectreference.cc index d7a315d9f..8fb571e92 100644 --- a/test/objectreference.cc +++ b/test/objectreference.cc @@ -24,8 +24,13 @@ void SetObjects(const CallbackInfo& info) { HandleScope scope(env); weak = Weak(Object::New(env)); + weak.SuppressDestruct(); + persistent = Persistent(Object::New(env)); + persistent.SuppressDestruct(); + reference = Reference::New(Object::New(env), 2); + reference.SuppressDestruct(); if (info[0].IsString()) { if (info[2].As() == String::New(env, "javascript")) { @@ -54,8 +59,13 @@ void SetCastedObjects(const CallbackInfo& info) { ex.Set(2, String::New(env, "!")); casted_weak = Weak(ex.As()); + casted_weak.SuppressDestruct(); + casted_persistent = Persistent(ex.As()); + casted_persistent.SuppressDestruct(); + casted_reference = Reference::New(ex.As(), 2); + casted_reference.SuppressDestruct(); } // info[0] is a flag to determine if the weak, persistent, or