Skip to content

Commit 464610b

Browse files
JckXiamhdawson
JckXia
authored and
mhdawson
committed
test: complete objectRefs tests
PR-URL: #1274 Reviewed-By: Michael Dawson <[email protected]>
1 parent b16c762 commit 464610b

File tree

2 files changed

+303
-102
lines changed

2 files changed

+303
-102
lines changed

‎test/object_reference.cc

Lines changed: 220 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
are not Objects by creating a blank Object and setting Values to
33
it. Subclasses of Objects can only be set using an ObjectReference
44
by first casting it as an Object. */
5-
5+
#include "assert.h"
66
#include "napi.h"
77
#include "test_helper.h"
88

@@ -16,11 +16,146 @@ ObjectReference casted_weak;
1616
ObjectReference casted_persistent;
1717
ObjectReference casted_reference;
1818

19-
// info[0] is the key, which can be either a string or a number.
20-
// info[1] is the value.
21-
// info[2] is a flag that differentiates whether the key is a
22-
// C string or a JavaScript string.
23-
void SetObjects(const CallbackInfo& info) {
19+
// Set keys can be one of:
20+
// C style string, std::string& utf8, and const char *
21+
22+
// Set values can be one of:
23+
// Napi::Value
24+
// napi_value (req static_cast)
25+
// const char* (c style string)
26+
// boolean
27+
// double
28+
29+
enum VAL_TYPES { JS = 0, C_STR, CPP_STR, BOOL, INT, DOUBLE, JS_CAST };
30+
31+
void MoveOperatorsTest(const Napi::CallbackInfo& info) {
32+
Napi::ObjectReference existingRef;
33+
Napi::ObjectReference existingRef2;
34+
Napi::Object testObject = Napi::Object::New(info.Env());
35+
testObject.Set("testProp", "tProp");
36+
37+
// ObjectReference(Reference<Object>&& other);
38+
Napi::Reference<Napi::Object> refObj =
39+
Napi::Reference<Napi::Object>::New(testObject);
40+
Napi::ObjectReference objRef = std::move(refObj);
41+
std::string prop = MaybeUnwrap(objRef.Get("testProp")).As<Napi::String>();
42+
assert(prop == "tProp");
43+
44+
// ObjectReference& operator=(Reference<Object>&& other);
45+
Napi::Reference<Napi::Object> refObj2 =
46+
Napi::Reference<Napi::Object>::New(testObject);
47+
existingRef = std::move(refObj2);
48+
prop = MaybeUnwrap(existingRef.Get("testProp")).As<Napi::String>();
49+
assert(prop == "tProp");
50+
51+
// ObjectReference(ObjectReference&& other);
52+
Napi::ObjectReference objRef3 = std::move(existingRef);
53+
prop = MaybeUnwrap(objRef3.Get("testProp")).As<Napi::String>();
54+
assert(prop == "tProp");
55+
56+
// ObjectReference& operator=(ObjectReference&& other);
57+
existingRef2 = std::move(objRef3);
58+
prop = MaybeUnwrap(objRef.Get("testProp")).As<Napi::String>();
59+
assert(prop == "tProp");
60+
}
61+
62+
void SetObjectWithCStringKey(Napi::ObjectReference& obj,
63+
Napi::Value key,
64+
Napi::Value val,
65+
int valType) {
66+
std::string c_key = key.As<Napi::String>().Utf8Value();
67+
switch (valType) {
68+
case JS:
69+
obj.Set(c_key.c_str(), val);
70+
break;
71+
72+
case JS_CAST:
73+
obj.Set(c_key.c_str(), static_cast<napi_value>(val));
74+
break;
75+
76+
case C_STR: {
77+
std::string c_val = val.As<Napi::String>().Utf8Value();
78+
obj.Set(c_key.c_str(), c_val.c_str());
79+
break;
80+
}
81+
82+
case BOOL:
83+
obj.Set(c_key.c_str(), val.As<Napi::Boolean>().Value());
84+
break;
85+
86+
case DOUBLE:
87+
obj.Set(c_key.c_str(), val.As<Napi::Number>().DoubleValue());
88+
break;
89+
}
90+
}
91+
92+
void SetObjectWithCppStringKey(Napi::ObjectReference& obj,
93+
Napi::Value key,
94+
Napi::Value val,
95+
int valType) {
96+
std::string c_key = key.As<Napi::String>();
97+
switch (valType) {
98+
case JS:
99+
obj.Set(c_key, val);
100+
break;
101+
102+
case JS_CAST:
103+
obj.Set(c_key, static_cast<napi_value>(val));
104+
break;
105+
106+
case CPP_STR: {
107+
std::string c_val = val.As<Napi::String>();
108+
obj.Set(c_key, c_val);
109+
break;
110+
}
111+
112+
case BOOL:
113+
obj.Set(c_key, val.As<Napi::Boolean>().Value());
114+
break;
115+
116+
case DOUBLE:
117+
obj.Set(c_key, val.As<Napi::Number>().DoubleValue());
118+
break;
119+
}
120+
}
121+
122+
void SetObjectWithIntKey(Napi::ObjectReference& obj,
123+
Napi::Value key,
124+
Napi::Value val,
125+
int valType) {
126+
uint32_t c_key = key.As<Napi::Number>().Uint32Value();
127+
switch (valType) {
128+
case JS:
129+
obj.Set(c_key, val);
130+
break;
131+
132+
case JS_CAST:
133+
obj.Set(c_key, static_cast<napi_value>(val));
134+
break;
135+
136+
case C_STR: {
137+
std::string c_val = val.As<Napi::String>();
138+
obj.Set(c_key, c_val.c_str());
139+
break;
140+
}
141+
142+
case CPP_STR: {
143+
std::string cpp_val = val.As<Napi::String>();
144+
obj.Set(c_key, cpp_val);
145+
break;
146+
}
147+
148+
case BOOL:
149+
obj.Set(c_key, val.As<Napi::Boolean>().Value());
150+
break;
151+
152+
case DOUBLE:
153+
obj.Set(c_key, val.As<Napi::Number>().DoubleValue());
154+
break;
155+
}
156+
}
157+
158+
void SetObject(const Napi::CallbackInfo& info) {
24159
Env env = info.Env();
25160
HandleScope scope(env);
26161

@@ -33,20 +168,35 @@ void SetObjects(const CallbackInfo& info) {
33168
reference = Reference<Object>::New(Object::New(env), 2);
34169
reference.SuppressDestruct();
35170

36-
if (info[0].IsString()) {
37-
if (info[2].As<String>() == String::New(env, "javascript")) {
38-
weak.Set(info[0].As<String>(), info[1]);
39-
persistent.Set(info[0].As<String>(), info[1]);
40-
reference.Set(info[0].As<String>(), info[1]);
41-
} else {
42-
weak.Set(info[0].As<String>().Utf8Value(), info[1]);
43-
persistent.Set(info[0].As<String>().Utf8Value(), info[1]);
44-
reference.Set(info[0].As<String>().Utf8Value(), info[1]);
45-
}
46-
} else if (info[0].IsNumber()) {
47-
weak.Set(info[0].As<Number>(), info[1]);
48-
persistent.Set(info[0].As<Number>(), info[1]);
49-
reference.Set(info[0].As<Number>(), info[1]);
171+
Napi::Object configObject = info[0].As<Napi::Object>();
172+
173+
int keyType =
174+
MaybeUnwrap(configObject.Get("keyType")).As<Napi::Number>().Uint32Value();
175+
int valType =
176+
MaybeUnwrap(configObject.Get("valType")).As<Napi::Number>().Uint32Value();
177+
Napi::Value key = MaybeUnwrap(configObject.Get("key"));
178+
Napi::Value val = MaybeUnwrap(configObject.Get("val"));
179+
180+
switch (keyType) {
181+
case CPP_STR:
182+
SetObjectWithCppStringKey(weak, key, val, valType);
183+
SetObjectWithCppStringKey(persistent, key, val, valType);
184+
SetObjectWithCppStringKey(reference, key, val, valType);
185+
break;
186+
187+
case C_STR:
188+
SetObjectWithCStringKey(weak, key, val, valType);
189+
SetObjectWithCStringKey(persistent, key, val, valType);
190+
SetObjectWithCStringKey(reference, key, val, valType);
191+
break;
192+
193+
case INT:
194+
SetObjectWithIntKey(weak, key, val, valType);
195+
SetObjectWithIntKey(persistent, key, val, valType);
196+
SetObjectWithIntKey(reference, key, val, valType);
197+
198+
default:
199+
break;
50200
}
51201
}
52202

@@ -87,6 +237,53 @@ Value GetFromValue(const CallbackInfo& info) {
87237
}
88238
}
89239

240+
Value GetHelper(ObjectReference& ref,
241+
Object& configObject,
242+
const Napi::Env& env) {
243+
int keyType =
244+
MaybeUnwrap(configObject.Get("keyType")).As<Napi::Number>().Uint32Value();
245+
if (ref.IsEmpty()) {
246+
return String::New(env, "No referenced Value");
247+
}
248+
249+
switch (keyType) {
250+
case C_STR: {
251+
std::string c_key =
252+
MaybeUnwrap(configObject.Get("key")).As<String>().Utf8Value();
253+
return MaybeUnwrap(ref.Get(c_key.c_str()));
254+
break;
255+
}
256+
case CPP_STR: {
257+
std::string cpp_key =
258+
MaybeUnwrap(configObject.Get("key")).As<String>().Utf8Value();
259+
return MaybeUnwrap(ref.Get(cpp_key));
260+
break;
261+
}
262+
case INT: {
263+
uint32_t key =
264+
MaybeUnwrap(configObject.Get("key")).As<Number>().Uint32Value();
265+
return MaybeUnwrap(ref.Get(key));
266+
break;
267+
}
268+
269+
default:
270+
return String::New(env, "Error: Reached end of getter");
271+
break;
272+
}
273+
}
274+
275+
Value GetFromGetters(const CallbackInfo& info) {
276+
std::string object_req = info[0].As<String>();
277+
Object configObject = info[1].As<Object>();
278+
if (object_req == "weak") {
279+
return GetHelper(weak, configObject, info.Env());
280+
} else if (object_req == "persistent") {
281+
return GetHelper(persistent, configObject, info.Env());
282+
}
283+
284+
return GetHelper(reference, configObject, info.Env());
285+
}
286+
90287
// info[0] is a flag to determine if the weak, persistent, or
91288
// multiple reference ObjectReference is being requested.
92289
// info[1] is the key, and it be either a String or a Number.
@@ -207,13 +404,14 @@ Object InitObjectReference(Env env) {
207404
Object exports = Object::New(env);
208405

209406
exports["setCastedObjects"] = Function::New(env, SetCastedObjects);
210-
exports["setObjects"] = Function::New(env, SetObjects);
407+
exports["setObject"] = Function::New(env, SetObject);
211408
exports["getCastedFromValue"] = Function::New(env, GetCastedFromValue);
212-
exports["getFromGetter"] = Function::New(env, GetFromGetter);
409+
exports["getFromGetters"] = Function::New(env, GetFromGetters);
213410
exports["getCastedFromGetter"] = Function::New(env, GetCastedFromGetter);
214411
exports["getFromValue"] = Function::New(env, GetFromValue);
215412
exports["unrefObjects"] = Function::New(env, UnrefObjects);
216413
exports["refObjects"] = Function::New(env, RefObjects);
414+
exports["moveOpTest"] = Function::New(env, MoveOperatorsTest);
217415

218416
return exports;
219417
}

0 commit comments

Comments
 (0)