Skip to content

Commit 8a1147b

Browse files
mhdawsonmhdawson
committed
revert: src: add additional tests for Function
This reverts commit 3b8bdda.
1 parent bb56ffa commit 8a1147b

File tree

2 files changed

+9
-168
lines changed

2 files changed

+9
-168
lines changed

‎test/function.cc‎

Lines changed: 2 additions & 124 deletions
Original file line numberDiff line numberDiff line change
@@ -6,13 +6,6 @@ namespace {
66

77
int testData = 1;
88

9-
Boolean EmptyConstructor(const CallbackInfo& info) {
10-
auto env = info.Env();
11-
bool isEmpty = info[0].As<Boolean>();
12-
Function function = isEmpty ? Function() : Function(env, Object::New(env));
13-
return Boolean::New(env, function.IsEmpty());
14-
}
15-
169
void VoidCallback(const CallbackInfo& info) {
1710
auto env = info.Env();
1811
Object obj = info[0].As<Object>();
@@ -52,9 +45,8 @@ Value ValueCallbackWithData(const CallbackInfo& info) {
5245
}
5346

5447
Value CallWithArgs(const CallbackInfo& info) {
55-
Function func = info[0].As<Function>();
56-
return func.Call(
57-
std::initializer_list<napi_value>{info[1], info[2], info[3]});
48+
Function func = info[0].As<Function>();
49+
return func({ info[1], info[2], info[3] });
5850
}
5951

6052
Value CallWithVector(const CallbackInfo& info) {
@@ -67,27 +59,6 @@ Value CallWithVector(const CallbackInfo& info) {
6759
return func.Call(args);
6860
}
6961

70-
Value CallWithCStyleArray(const CallbackInfo& info) {
71-
Function func = info[0].As<Function>();
72-
std::vector<napi_value> args;
73-
args.reserve(3);
74-
args.push_back(info[1]);
75-
args.push_back(info[2]);
76-
args.push_back(info[3]);
77-
return func.Call(args.size(), args.data());
78-
}
79-
80-
Value CallWithReceiverAndCStyleArray(const CallbackInfo& info) {
81-
Function func = info[0].As<Function>();
82-
Value receiver = info[1];
83-
std::vector<napi_value> args;
84-
args.reserve(3);
85-
args.push_back(info[2]);
86-
args.push_back(info[3]);
87-
args.push_back(info[4]);
88-
return func.Call(receiver, args.size(), args.data());
89-
}
90-
9162
Value CallWithReceiverAndArgs(const CallbackInfo& info) {
9263
Function func = info[0].As<Function>();
9364
Value receiver = info[1];
@@ -125,81 +96,17 @@ Value CallConstructorWithVector(const CallbackInfo& info) {
12596
return func.New(args);
12697
}
12798

128-
Value CallConstructorWithCStyleArray(const CallbackInfo& info) {
129-
Function func = info[0].As<Function>();
130-
std::vector<napi_value> args;
131-
args.reserve(3);
132-
args.push_back(info[1]);
133-
args.push_back(info[2]);
134-
args.push_back(info[3]);
135-
return func.New(args.size(), args.data());
136-
}
137-
13899
void IsConstructCall(const CallbackInfo& info) {
139100
Function callback = info[0].As<Function>();
140101
bool isConstructCall = info.IsConstructCall();
141102
callback({Napi::Boolean::New(info.Env(), isConstructCall)});
142103
}
143104

144-
void MakeCallbackWithArgs(const CallbackInfo& info) {
145-
Env env = info.Env();
146-
Function callback = info[0].As<Function>();
147-
Object resource = info[1].As<Object>();
148-
149-
AsyncContext context(env, "async_context_test", resource);
150-
151-
callback.MakeCallback(
152-
resource,
153-
std::initializer_list<napi_value>{info[2], info[3], info[4]},
154-
context);
155-
}
156-
157-
void MakeCallbackWithVector(const CallbackInfo& info) {
158-
Env env = info.Env();
159-
Function callback = info[0].As<Function>();
160-
Object resource = info[1].As<Object>();
161-
162-
AsyncContext context(env, "async_context_test", resource);
163-
164-
std::vector<napi_value> args;
165-
args.reserve(3);
166-
args.push_back(info[2]);
167-
args.push_back(info[3]);
168-
args.push_back(info[4]);
169-
callback.MakeCallback(resource, args, context);
170-
}
171-
172-
void MakeCallbackWithCStyleArray(const CallbackInfo& info) {
173-
Env env = info.Env();
174-
Function callback = info[0].As<Function>();
175-
Object resource = info[1].As<Object>();
176-
177-
AsyncContext context(env, "async_context_test", resource);
178-
179-
std::vector<napi_value> args;
180-
args.reserve(3);
181-
args.push_back(info[2]);
182-
args.push_back(info[3]);
183-
args.push_back(info[4]);
184-
callback.MakeCallback(resource, args.size(), args.data(), context);
185-
}
186-
187-
void MakeCallbackWithInvalidReceiver(const CallbackInfo& info) {
188-
Function callback = info[0].As<Function>();
189-
callback.MakeCallback(Value(), std::initializer_list<napi_value>{});
190-
}
191-
192-
Value CallWithFunctionOperator(const CallbackInfo& info) {
193-
Function func = info[0].As<Function>();
194-
return func({info[1], info[2], info[3]});
195-
}
196-
197105
} // end anonymous namespace
198106

199107
Object InitFunction(Env env) {
200108
Object result = Object::New(env);
201109
Object exports = Object::New(env);
202-
exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
203110
exports["voidCallback"] = Function::New(env, VoidCallback, "voidCallback");
204111
exports["valueCallback"] = Function::New(env, ValueCallback, std::string("valueCallback"));
205112
exports["voidCallbackWithData"] =
@@ -208,30 +115,15 @@ Object InitFunction(Env env) {
208115
Function::New(env, ValueCallbackWithData, nullptr, &testData);
209116
exports["callWithArgs"] = Function::New(env, CallWithArgs);
210117
exports["callWithVector"] = Function::New(env, CallWithVector);
211-
exports["callWithCStyleArray"] = Function::New(env, CallWithCStyleArray);
212-
exports["callWithReceiverAndCStyleArray"] =
213-
Function::New(env, CallWithReceiverAndCStyleArray);
214118
exports["callWithReceiverAndArgs"] = Function::New(env, CallWithReceiverAndArgs);
215119
exports["callWithReceiverAndVector"] = Function::New(env, CallWithReceiverAndVector);
216120
exports["callWithInvalidReceiver"] = Function::New(env, CallWithInvalidReceiver);
217121
exports["callConstructorWithArgs"] = Function::New(env, CallConstructorWithArgs);
218122
exports["callConstructorWithVector"] = Function::New(env, CallConstructorWithVector);
219-
exports["callConstructorWithCStyleArray"] =
220-
Function::New(env, CallConstructorWithCStyleArray);
221123
exports["isConstructCall"] = Function::New(env, IsConstructCall);
222-
exports["makeCallbackWithArgs"] = Function::New(env, MakeCallbackWithArgs);
223-
exports["makeCallbackWithVector"] =
224-
Function::New(env, MakeCallbackWithVector);
225-
exports["makeCallbackWithCStyleArray"] =
226-
Function::New(env, MakeCallbackWithCStyleArray);
227-
exports["makeCallbackWithInvalidReceiver"] =
228-
Function::New(env, MakeCallbackWithInvalidReceiver);
229-
exports["callWithFunctionOperator"] =
230-
Function::New(env, CallWithFunctionOperator);
231124
result["plain"] = exports;
232125

233126
exports = Object::New(env);
234-
exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
235127
exports["voidCallback"] = Function::New<VoidCallback>(env, "voidCallback");
236128
exports["valueCallback"] =
237129
Function::New<ValueCallback>(env, std::string("valueCallback"));
@@ -241,9 +133,6 @@ Object InitFunction(Env env) {
241133
Function::New<ValueCallbackWithData>(env, nullptr, &testData);
242134
exports["callWithArgs"] = Function::New<CallWithArgs>(env);
243135
exports["callWithVector"] = Function::New<CallWithVector>(env);
244-
exports["callWithCStyleArray"] = Function::New<CallWithCStyleArray>(env);
245-
exports["callWithReceiverAndCStyleArray"] =
246-
Function::New<CallWithReceiverAndCStyleArray>(env);
247136
exports["callWithReceiverAndArgs"] =
248137
Function::New<CallWithReceiverAndArgs>(env);
249138
exports["callWithReceiverAndVector"] =
@@ -254,18 +143,7 @@ Object InitFunction(Env env) {
254143
Function::New<CallConstructorWithArgs>(env);
255144
exports["callConstructorWithVector"] =
256145
Function::New<CallConstructorWithVector>(env);
257-
exports["callConstructorWithCStyleArray"] =
258-
Function::New<CallConstructorWithCStyleArray>(env);
259146
exports["isConstructCall"] = Function::New<IsConstructCall>(env);
260-
exports["makeCallbackWithArgs"] = Function::New<MakeCallbackWithArgs>(env);
261-
exports["makeCallbackWithVector"] =
262-
Function::New<MakeCallbackWithVector>(env);
263-
exports["makeCallbackWithCStyleArray"] =
264-
Function::New<MakeCallbackWithCStyleArray>(env);
265-
exports["makeCallbackWithInvalidReceiver"] =
266-
Function::New<MakeCallbackWithInvalidReceiver>(env);
267-
exports["callWithFunctionOperator"] =
268-
Function::New<CallWithFunctionOperator>(env);
269147
result["templated"] = exports;
270148
return result;
271149
}

‎test/function.js‎

Lines changed: 7 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,6 @@ test(require(`./build/${buildType}/binding.node`).function.templated);
88
test(require(`./build/${buildType}/binding_noexcept.node`).function.templated);
99

1010
function test(binding) {
11-
assert.strictEqual(binding.emptyConstructor(true), true);
12-
assert.strictEqual(binding.emptyConstructor(false), false);
13-
1411
let obj = {};
1512
assert.deepStrictEqual(binding.voidCallback(obj), undefined);
1613
assert.deepStrictEqual(obj, { "foo": "bar" });
@@ -29,50 +26,26 @@ function test(binding) {
2926
args = [].slice.call(arguments);
3027
}
3128

32-
function makeCallbackTestFunction(receiver, expectedOne, expectedTwo, expectedThree) {
33-
return function callback(one, two, three) {
34-
assert.strictEqual(this, receiver);
35-
assert.strictEqual(one, expectedOne);
36-
assert.strictEqual(two, expectedTwo);
37-
assert.strictEqual(three, expectedThree);
38-
}
39-
}
40-
4129
ret = 4;
42-
assert.strictEqual(binding.callWithArgs(testFunction, 1, 2, 3), 4);
30+
assert.equal(binding.callWithArgs(testFunction, 1, 2, 3), 4);
4331
assert.strictEqual(receiver, undefined);
4432
assert.deepStrictEqual(args, [ 1, 2, 3 ]);
4533

4634
ret = 5;
47-
assert.strictEqual(binding.callWithVector(testFunction, 2, 3, 4), 5);
35+
assert.equal(binding.callWithVector(testFunction, 2, 3, 4), 5);
4836
assert.strictEqual(receiver, undefined);
4937
assert.deepStrictEqual(args, [ 2, 3, 4 ]);
5038

5139
ret = 6;
52-
assert.strictEqual(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
40+
assert.equal(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
5341
assert.deepStrictEqual(receiver, obj);
5442
assert.deepStrictEqual(args, [ 3, 4, 5 ]);
5543

5644
ret = 7;
57-
assert.strictEqual(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
45+
assert.equal(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
5846
assert.deepStrictEqual(receiver, obj);
5947
assert.deepStrictEqual(args, [ 4, 5, 6 ]);
6048

61-
ret = 8;
62-
assert.strictEqual(binding.callWithCStyleArray(testFunction, 5, 6, 7), ret);
63-
assert.deepStrictEqual(receiver, undefined);
64-
assert.deepStrictEqual(args, [ 5, 6, 7 ]);
65-
66-
ret = 9;
67-
assert.strictEqual(binding.callWithReceiverAndCStyleArray(testFunction, obj, 6, 7, 8), ret);
68-
assert.deepStrictEqual(receiver, obj);
69-
assert.deepStrictEqual(args, [ 6, 7, 8 ]);
70-
71-
ret = 10;
72-
assert.strictEqual(binding.callWithFunctionOperator(testFunction, 7, 8, 9), ret);
73-
assert.strictEqual(receiver, undefined);
74-
assert.deepStrictEqual(args, [ 7, 8, 9 ]);
75-
7649
assert.throws(() => {
7750
binding.callWithInvalidReceiver();
7851
}, /Invalid (pointer passed as )?argument/);
@@ -85,30 +58,20 @@ function test(binding) {
8558
assert(obj instanceof testConstructor);
8659
assert.deepStrictEqual(args, [ 6, 7, 8 ]);
8760

88-
obj = binding.callConstructorWithCStyleArray(testConstructor, 7, 8, 9);
89-
assert(obj instanceof testConstructor);
90-
assert.deepStrictEqual(args, [ 7, 8, 9 ]);
91-
9261
obj = {};
9362
assert.deepStrictEqual(binding.voidCallbackWithData(obj), undefined);
9463
assert.deepStrictEqual(obj, { "foo": "bar", "data": 1 });
9564

9665
assert.deepStrictEqual(binding.valueCallbackWithData(), { "foo": "bar", "data": 1 });
9766

98-
assert.strictEqual(binding.voidCallback.name, 'voidCallback');
99-
assert.strictEqual(binding.valueCallback.name, 'valueCallback');
67+
assert.equal(binding.voidCallback.name, 'voidCallback');
68+
assert.equal(binding.valueCallback.name, 'valueCallback');
10069

10170
let testConstructCall = undefined;
10271
binding.isConstructCall((result) => { testConstructCall = result; });
10372
assert.ok(!testConstructCall);
10473
new binding.isConstructCall((result) => { testConstructCall = result; });
10574
assert.ok(testConstructCall);
10675

107-
obj = {};
108-
binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, "1", "2", "3"), obj, "1", "2", "3");
109-
binding.makeCallbackWithVector(makeCallbackTestFunction(obj, 4, 5, 6), obj, 4, 5, 6);
110-
binding.makeCallbackWithCStyleArray(makeCallbackTestFunction(obj, 7, 8, 9), obj, 7, 8, 9);
111-
assert.throws(() => {
112-
binding.makeCallbackWithInvalidReceiver(() => {});
113-
});
76+
// TODO: Function::MakeCallback tests
11477
}

0 commit comments

Comments
 (0)