1#include <js_native_api.h>
2#include <string.h>
3#include "../common.h"
4#include "../entry_point.h"
5#include "test_null.h"
6
7static int test_value = 3;
8
9static napi_value Get(napi_env env, napi_callback_info info) {
10  size_t argc = 2;
11  napi_value args[2];
12  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
13
14  NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments");
15
16  napi_valuetype valuetype0;
17  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
18
19  NODE_API_ASSERT(env, valuetype0 == napi_object,
20      "Wrong type of arguments. Expects an object as first argument.");
21
22  napi_valuetype valuetype1;
23  NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1));
24
25  NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
26      "Wrong type of arguments. Expects a string or symbol as second.");
27
28  napi_value object = args[0];
29  napi_value output;
30  NODE_API_CALL(env, napi_get_property(env, object, args[1], &output));
31
32  return output;
33}
34
35static napi_value GetNamed(napi_env env, napi_callback_info info) {
36  size_t argc = 2;
37  napi_value args[2];
38  char key[256] = "";
39  size_t key_length;
40  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
41
42  NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments");
43
44  napi_valuetype value_type0;
45  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
46
47  NODE_API_ASSERT(env, value_type0 == napi_object,
48      "Wrong type of arguments. Expects an object as first argument.");
49
50  napi_valuetype value_type1;
51  NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1));
52
53  NODE_API_ASSERT(env, value_type1 == napi_string,
54      "Wrong type of arguments. Expects a string as second.");
55
56  napi_value object = args[0];
57  NODE_API_CALL(env,
58      napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
59  key[255] = 0;
60  NODE_API_ASSERT(env, key_length <= 255,
61      "Cannot accommodate keys longer than 255 bytes");
62  napi_value output;
63  NODE_API_CALL(env, napi_get_named_property(env, object, key, &output));
64
65  return output;
66}
67
68static napi_value GetPropertyNames(napi_env env, napi_callback_info info) {
69  size_t argc = 1;
70  napi_value args[1];
71  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
72
73  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
74
75  napi_valuetype value_type0;
76  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
77
78  NODE_API_ASSERT(env, value_type0 == napi_object,
79      "Wrong type of arguments. Expects an object as first argument.");
80
81  napi_value output;
82  NODE_API_CALL(env, napi_get_property_names(env, args[0], &output));
83
84  return output;
85}
86
87static napi_value GetSymbolNames(napi_env env, napi_callback_info info) {
88  size_t argc = 1;
89  napi_value args[1];
90  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
91
92  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
93
94  napi_valuetype value_type0;
95  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
96
97  NODE_API_ASSERT(env,
98              value_type0 == napi_object,
99              "Wrong type of arguments. Expects an object as first argument.");
100
101  napi_value output;
102  NODE_API_CALL(env,
103      napi_get_all_property_names(
104          env, args[0], napi_key_include_prototypes, napi_key_skip_strings,
105          napi_key_numbers_to_strings, &output));
106
107  return output;
108}
109
110static napi_value GetEnumerableWritableNames(napi_env env,
111                                             napi_callback_info info) {
112  size_t argc = 1;
113  napi_value args[1];
114  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
115
116  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
117
118  napi_valuetype value_type0;
119  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
120
121  NODE_API_ASSERT(
122      env,
123      value_type0 == napi_object,
124      "Wrong type of arguments. Expects an object as first argument.");
125
126  napi_value output;
127  NODE_API_CALL(
128      env,
129      napi_get_all_property_names(env,
130                                  args[0],
131                                  napi_key_include_prototypes,
132                                  napi_key_enumerable | napi_key_writable,
133                                  napi_key_numbers_to_strings,
134                                  &output));
135
136  return output;
137}
138
139static napi_value GetOwnWritableNames(napi_env env, napi_callback_info info) {
140  size_t argc = 1;
141  napi_value args[1];
142  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
143
144  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
145
146  napi_valuetype value_type0;
147  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
148
149  NODE_API_ASSERT(
150      env,
151      value_type0 == napi_object,
152      "Wrong type of arguments. Expects an object as first argument.");
153
154  napi_value output;
155  NODE_API_CALL(env,
156                napi_get_all_property_names(env,
157                                            args[0],
158                                            napi_key_own_only,
159                                            napi_key_writable,
160                                            napi_key_numbers_to_strings,
161                                            &output));
162
163  return output;
164}
165
166static napi_value GetEnumerableConfigurableNames(napi_env env,
167                                                 napi_callback_info info) {
168  size_t argc = 1;
169  napi_value args[1];
170  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
171
172  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
173
174  napi_valuetype value_type0;
175  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
176
177  NODE_API_ASSERT(
178      env,
179      value_type0 == napi_object,
180      "Wrong type of arguments. Expects an object as first argument.");
181
182  napi_value output;
183  NODE_API_CALL(
184      env,
185      napi_get_all_property_names(env,
186                                  args[0],
187                                  napi_key_include_prototypes,
188                                  napi_key_enumerable | napi_key_configurable,
189                                  napi_key_numbers_to_strings,
190                                  &output));
191
192  return output;
193}
194
195static napi_value GetOwnConfigurableNames(napi_env env,
196                                          napi_callback_info info) {
197  size_t argc = 1;
198  napi_value args[1];
199  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
200
201  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
202
203  napi_valuetype value_type0;
204  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
205
206  NODE_API_ASSERT(
207      env,
208      value_type0 == napi_object,
209      "Wrong type of arguments. Expects an object as first argument.");
210
211  napi_value output;
212  NODE_API_CALL(env,
213                napi_get_all_property_names(env,
214                                            args[0],
215                                            napi_key_own_only,
216                                            napi_key_configurable,
217                                            napi_key_numbers_to_strings,
218                                            &output));
219
220  return output;
221}
222
223static napi_value Set(napi_env env, napi_callback_info info) {
224  size_t argc = 3;
225  napi_value args[3];
226  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
227
228  NODE_API_ASSERT(env, argc >= 3, "Wrong number of arguments");
229
230  napi_valuetype valuetype0;
231  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
232
233  NODE_API_ASSERT(env, valuetype0 == napi_object,
234      "Wrong type of arguments. Expects an object as first argument.");
235
236  napi_valuetype valuetype1;
237  NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1));
238
239  NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
240      "Wrong type of arguments. Expects a string or symbol as second.");
241
242  NODE_API_CALL(env, napi_set_property(env, args[0], args[1], args[2]));
243
244  napi_value valuetrue;
245  NODE_API_CALL(env, napi_get_boolean(env, true, &valuetrue));
246
247  return valuetrue;
248}
249
250static napi_value SetNamed(napi_env env, napi_callback_info info) {
251  size_t argc = 3;
252  napi_value args[3];
253  char key[256] = "";
254  size_t key_length;
255  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
256
257  NODE_API_ASSERT(env, argc >= 3, "Wrong number of arguments");
258
259  napi_valuetype value_type0;
260  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
261
262  NODE_API_ASSERT(env, value_type0 == napi_object,
263      "Wrong type of arguments. Expects an object as first argument.");
264
265  napi_valuetype value_type1;
266  NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1));
267
268  NODE_API_ASSERT(env, value_type1 == napi_string,
269      "Wrong type of arguments. Expects a string as second.");
270
271  NODE_API_CALL(env,
272      napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
273  key[255] = 0;
274  NODE_API_ASSERT(env, key_length <= 255,
275      "Cannot accommodate keys longer than 255 bytes");
276
277  NODE_API_CALL(env, napi_set_named_property(env, args[0], key, args[2]));
278
279  napi_value value_true;
280  NODE_API_CALL(env, napi_get_boolean(env, true, &value_true));
281
282  return value_true;
283}
284
285static napi_value Has(napi_env env, napi_callback_info info) {
286  size_t argc = 2;
287  napi_value args[2];
288  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
289
290  NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments");
291
292  napi_valuetype valuetype0;
293  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
294
295  NODE_API_ASSERT(env, valuetype0 == napi_object,
296      "Wrong type of arguments. Expects an object as first argument.");
297
298  napi_valuetype valuetype1;
299  NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1));
300
301  NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
302      "Wrong type of arguments. Expects a string or symbol as second.");
303
304  bool has_property;
305  NODE_API_CALL(env, napi_has_property(env, args[0], args[1], &has_property));
306
307  napi_value ret;
308  NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret));
309
310  return ret;
311}
312
313static napi_value HasNamed(napi_env env, napi_callback_info info) {
314  size_t argc = 2;
315  napi_value args[2];
316  char key[256] = "";
317  size_t key_length;
318  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
319
320  NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments");
321
322  napi_valuetype value_type0;
323  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0));
324
325  NODE_API_ASSERT(env, value_type0 == napi_object,
326      "Wrong type of arguments. Expects an object as first argument.");
327
328  napi_valuetype value_type1;
329  NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1));
330
331  NODE_API_ASSERT(env, value_type1 == napi_string || value_type1 == napi_symbol,
332      "Wrong type of arguments. Expects a string as second.");
333
334  NODE_API_CALL(env,
335      napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
336  key[255] = 0;
337  NODE_API_ASSERT(env, key_length <= 255,
338      "Cannot accommodate keys longer than 255 bytes");
339
340  bool has_property;
341  NODE_API_CALL(env, napi_has_named_property(env, args[0], key, &has_property));
342
343  napi_value ret;
344  NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret));
345
346  return ret;
347}
348
349static napi_value HasOwn(napi_env env, napi_callback_info info) {
350  size_t argc = 2;
351  napi_value args[2];
352  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
353
354  NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments");
355
356  napi_valuetype valuetype0;
357  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
358
359  NODE_API_ASSERT(env, valuetype0 == napi_object,
360      "Wrong type of arguments. Expects an object as first argument.");
361
362  // napi_valuetype valuetype1;
363  // NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1));
364  //
365  // NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
366  //   "Wrong type of arguments. Expects a string or symbol as second.");
367
368  bool has_property;
369  NODE_API_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property));
370
371  napi_value ret;
372  NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret));
373
374  return ret;
375}
376
377static napi_value Delete(napi_env env, napi_callback_info info) {
378  size_t argc = 2;
379  napi_value args[2];
380
381  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
382  NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments");
383
384  napi_valuetype valuetype0;
385  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
386  NODE_API_ASSERT(env, valuetype0 == napi_object,
387      "Wrong type of arguments. Expects an object as first argument.");
388
389  napi_valuetype valuetype1;
390  NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1));
391  NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
392      "Wrong type of arguments. Expects a string or symbol as second.");
393
394  bool result;
395  napi_value ret;
396  NODE_API_CALL(env, napi_delete_property(env, args[0], args[1], &result));
397  NODE_API_CALL(env, napi_get_boolean(env, result, &ret));
398
399  return ret;
400}
401
402static napi_value New(napi_env env, napi_callback_info info) {
403  napi_value ret;
404  NODE_API_CALL(env, napi_create_object(env, &ret));
405
406  napi_value num;
407  NODE_API_CALL(env, napi_create_int32(env, 987654321, &num));
408
409  NODE_API_CALL(env, napi_set_named_property(env, ret, "test_number", num));
410
411  napi_value str;
412  const char* str_val = "test string";
413  size_t str_len = strlen(str_val);
414  NODE_API_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
415
416  NODE_API_CALL(env, napi_set_named_property(env, ret, "test_string", str));
417
418  return ret;
419}
420
421static napi_value Inflate(napi_env env, napi_callback_info info) {
422  size_t argc = 1;
423  napi_value args[1];
424  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
425
426  NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments");
427
428  napi_valuetype valuetype0;
429  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0));
430
431  NODE_API_ASSERT(env, valuetype0 == napi_object,
432      "Wrong type of arguments. Expects an object as first argument.");
433
434  napi_value obj = args[0];
435  napi_value propertynames;
436  NODE_API_CALL(env, napi_get_property_names(env, obj, &propertynames));
437
438  uint32_t i, length;
439  NODE_API_CALL(env, napi_get_array_length(env, propertynames, &length));
440
441  for (i = 0; i < length; i++) {
442    napi_value property_str;
443    NODE_API_CALL(env, napi_get_element(env, propertynames, i, &property_str));
444
445    napi_value value;
446    NODE_API_CALL(env, napi_get_property(env, obj, property_str, &value));
447
448    double double_val;
449    NODE_API_CALL(env, napi_get_value_double(env, value, &double_val));
450    NODE_API_CALL(env, napi_create_double(env, double_val + 1, &value));
451    NODE_API_CALL(env, napi_set_property(env, obj, property_str, value));
452  }
453
454  return obj;
455}
456
457static napi_value Wrap(napi_env env, napi_callback_info info) {
458  size_t argc = 1;
459  napi_value arg;
460  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
461
462  NODE_API_CALL(env, napi_wrap(env, arg, &test_value, NULL, NULL, NULL));
463  return NULL;
464}
465
466static napi_value Unwrap(napi_env env, napi_callback_info info) {
467  size_t argc = 1;
468  napi_value arg;
469  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
470
471  void* data;
472  NODE_API_CALL(env, napi_unwrap(env, arg, &data));
473
474  bool is_expected = (data != NULL && *(int*)data == 3);
475  napi_value result;
476  NODE_API_CALL(env, napi_get_boolean(env, is_expected, &result));
477  return result;
478}
479
480static napi_value TestSetProperty(napi_env env,
481                                  napi_callback_info info) {
482  napi_status status;
483  napi_value object, key, value;
484
485  NODE_API_CALL(env, napi_create_object(env, &object));
486
487  NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
488
489  NODE_API_CALL(env, napi_create_object(env, &value));
490
491  status = napi_set_property(NULL, object, key, value);
492
493  add_returned_status(env,
494                      "envIsNull",
495                      object,
496                      "Invalid argument",
497                      napi_invalid_arg,
498                      status);
499
500  napi_set_property(env, NULL, key, value);
501
502  add_last_status(env, "objectIsNull", object);
503
504  napi_set_property(env, object, NULL, value);
505
506  add_last_status(env, "keyIsNull", object);
507
508  napi_set_property(env, object, key, NULL);
509
510  add_last_status(env, "valueIsNull", object);
511
512  return object;
513}
514
515static napi_value TestHasProperty(napi_env env,
516                                  napi_callback_info info) {
517  napi_status status;
518  napi_value object, key;
519  bool result;
520
521  NODE_API_CALL(env, napi_create_object(env, &object));
522
523  NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
524
525  status = napi_has_property(NULL, object, key, &result);
526
527  add_returned_status(env,
528                      "envIsNull",
529                      object,
530                      "Invalid argument",
531                      napi_invalid_arg,
532                      status);
533
534  napi_has_property(env, NULL, key, &result);
535
536  add_last_status(env, "objectIsNull", object);
537
538  napi_has_property(env, object, NULL, &result);
539
540  add_last_status(env, "keyIsNull", object);
541
542  napi_has_property(env, object, key, NULL);
543
544  add_last_status(env, "resultIsNull", object);
545
546  return object;
547}
548
549static napi_value TestGetProperty(napi_env env,
550                                  napi_callback_info info) {
551  napi_status status;
552  napi_value object, key, result;
553
554  NODE_API_CALL(env, napi_create_object(env, &object));
555
556  NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
557
558  NODE_API_CALL(env, napi_create_object(env, &result));
559
560  status = napi_get_property(NULL, object, key, &result);
561
562  add_returned_status(env,
563                      "envIsNull",
564                      object,
565                      "Invalid argument",
566                      napi_invalid_arg,
567                      status);
568
569  napi_get_property(env, NULL, key, &result);
570
571  add_last_status(env, "objectIsNull", object);
572
573  napi_get_property(env, object, NULL, &result);
574
575  add_last_status(env, "keyIsNull", object);
576
577  napi_get_property(env, object, key, NULL);
578
579  add_last_status(env, "resultIsNull", object);
580
581  return object;
582}
583
584static napi_value TestFreeze(napi_env env,
585                             napi_callback_info info) {
586  size_t argc = 1;
587  napi_value args[1];
588  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
589
590  napi_value object = args[0];
591  NODE_API_CALL(env, napi_object_freeze(env, object));
592
593  return object;
594}
595
596static napi_value TestSeal(napi_env env,
597                           napi_callback_info info) {
598  size_t argc = 1;
599  napi_value args[1];
600  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
601
602  napi_value object = args[0];
603  NODE_API_CALL(env, napi_object_seal(env, object));
604
605  return object;
606}
607
608// We create two type tags. They are basically 128-bit UUIDs.
609#define TYPE_TAG_COUNT 5
610static const napi_type_tag type_tags[TYPE_TAG_COUNT] = {
611    {0xdaf987b3cc62481a, 0xb745b0497f299531},
612    {0xbb7936c374084d9b, 0xa9548d0762eeedb9},
613    {0xa5ed9ce2e4c00c38, 0},
614    {0, 0},
615    {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a},
616};
617#define VALIDATE_TYPE_INDEX(env, type_index)                                   \
618  do {                                                                         \
619    if ((type_index) >= TYPE_TAG_COUNT) {                                      \
620      NODE_API_CALL((env),                                                     \
621                    napi_throw_range_error((env),                              \
622                                           "NODE_API_TEST_INVALID_TYPE_INDEX", \
623                                           "Invalid type index"));             \
624    }                                                                          \
625  } while (0)
626
627static napi_value
628TypeTaggedInstance(napi_env env, napi_callback_info info) {
629  size_t argc = 1;
630  uint32_t type_index;
631  napi_value instance, which_type;
632
633  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &which_type, NULL, NULL));
634  NODE_API_CALL(env, napi_get_value_uint32(env, which_type, &type_index));
635  VALIDATE_TYPE_INDEX(env, type_index);
636  NODE_API_CALL(env, napi_create_object(env, &instance));
637  NODE_API_CALL(env, napi_type_tag_object(env, instance, &type_tags[type_index]));
638
639  return instance;
640}
641
642// V8 will not allowe us to construct an external with a NULL data value.
643#define IN_LIEU_OF_NULL ((void*)0x1)
644
645static napi_value PlainExternal(napi_env env, napi_callback_info info) {
646  napi_value instance;
647
648  NODE_API_CALL(
649      env, napi_create_external(env, IN_LIEU_OF_NULL, NULL, NULL, &instance));
650
651  return instance;
652}
653
654static napi_value TypeTaggedExternal(napi_env env, napi_callback_info info) {
655  size_t argc = 1;
656  uint32_t type_index;
657  napi_value instance, which_type;
658
659  NODE_API_CALL(env,
660                napi_get_cb_info(env, info, &argc, &which_type, NULL, NULL));
661  NODE_API_CALL(env, napi_get_value_uint32(env, which_type, &type_index));
662  VALIDATE_TYPE_INDEX(env, type_index);
663  NODE_API_CALL(
664      env, napi_create_external(env, IN_LIEU_OF_NULL, NULL, NULL, &instance));
665  NODE_API_CALL(env,
666                napi_type_tag_object(env, instance, &type_tags[type_index]));
667
668  return instance;
669}
670
671static napi_value
672CheckTypeTag(napi_env env, napi_callback_info info) {
673  size_t argc = 2;
674  bool result;
675  napi_value argv[2], js_result;
676  uint32_t type_index;
677
678  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
679  NODE_API_CALL(env, napi_get_value_uint32(env, argv[0], &type_index));
680  VALIDATE_TYPE_INDEX(env, type_index);
681  NODE_API_CALL(env, napi_check_object_type_tag(env,
682                                            argv[1],
683                                            &type_tags[type_index],
684                                            &result));
685  NODE_API_CALL(env, napi_get_boolean(env, result, &js_result));
686
687  return js_result;
688}
689
690EXTERN_C_START
691napi_value Init(napi_env env, napi_value exports) {
692  napi_property_descriptor descriptors[] = {
693      DECLARE_NODE_API_PROPERTY("Get", Get),
694      DECLARE_NODE_API_PROPERTY("GetNamed", GetNamed),
695      DECLARE_NODE_API_PROPERTY("GetPropertyNames", GetPropertyNames),
696      DECLARE_NODE_API_PROPERTY("GetSymbolNames", GetSymbolNames),
697      DECLARE_NODE_API_PROPERTY("GetEnumerableWritableNames",
698                                GetEnumerableWritableNames),
699      DECLARE_NODE_API_PROPERTY("GetOwnWritableNames", GetOwnWritableNames),
700      DECLARE_NODE_API_PROPERTY("GetEnumerableConfigurableNames",
701                                GetEnumerableConfigurableNames),
702      DECLARE_NODE_API_PROPERTY("GetOwnConfigurableNames",
703                                GetOwnConfigurableNames),
704      DECLARE_NODE_API_PROPERTY("Set", Set),
705      DECLARE_NODE_API_PROPERTY("SetNamed", SetNamed),
706      DECLARE_NODE_API_PROPERTY("Has", Has),
707      DECLARE_NODE_API_PROPERTY("HasNamed", HasNamed),
708      DECLARE_NODE_API_PROPERTY("HasOwn", HasOwn),
709      DECLARE_NODE_API_PROPERTY("Delete", Delete),
710      DECLARE_NODE_API_PROPERTY("New", New),
711      DECLARE_NODE_API_PROPERTY("Inflate", Inflate),
712      DECLARE_NODE_API_PROPERTY("Wrap", Wrap),
713      DECLARE_NODE_API_PROPERTY("Unwrap", Unwrap),
714      DECLARE_NODE_API_PROPERTY("TestSetProperty", TestSetProperty),
715      DECLARE_NODE_API_PROPERTY("TestHasProperty", TestHasProperty),
716      DECLARE_NODE_API_PROPERTY("TypeTaggedInstance", TypeTaggedInstance),
717      DECLARE_NODE_API_PROPERTY("TypeTaggedExternal", TypeTaggedExternal),
718      DECLARE_NODE_API_PROPERTY("PlainExternal", PlainExternal),
719      DECLARE_NODE_API_PROPERTY("CheckTypeTag", CheckTypeTag),
720      DECLARE_NODE_API_PROPERTY("TestGetProperty", TestGetProperty),
721      DECLARE_NODE_API_PROPERTY("TestFreeze", TestFreeze),
722      DECLARE_NODE_API_PROPERTY("TestSeal", TestSeal),
723  };
724
725  init_test_null(env, exports);
726
727  NODE_API_CALL(env, napi_define_properties(
728      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
729
730  return exports;
731}
732EXTERN_C_END
733