wasmer-napi 0.701.0

NAPI library for Wasmer WebAssembly runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#include <math.h>
#include <stdint.h>
#include <stdio.h>

#include "napi_test_helpers.h"

int main(void) {
  napi_env env = napi_wasm_init_env();
  CHECK_OR_FAIL(env != NULL, "napi_wasm_init_env returned NULL");

  // ---- int32: basic values ----
  {
    napi_value val;
    int32_t result;

    NAPI_CALL(env, napi_create_int32(env, 42, &val));
    NAPI_CALL(env, napi_get_value_int32(env, val, &result));
    CHECK_OR_FAIL(result == 42, "int32: expected 42");

    NAPI_CALL(env, napi_create_int32(env, 0, &val));
    NAPI_CALL(env, napi_get_value_int32(env, val, &result));
    CHECK_OR_FAIL(result == 0, "int32: expected 0");

    NAPI_CALL(env, napi_create_int32(env, -1, &val));
    NAPI_CALL(env, napi_get_value_int32(env, val, &result));
    CHECK_OR_FAIL(result == -1, "int32: expected -1");
  }

  // ---- int32: edge cases ----
  {
    napi_value val;
    int32_t result;

    NAPI_CALL(env, napi_create_int32(env, INT32_MIN, &val));
    NAPI_CALL(env, napi_get_value_int32(env, val, &result));
    CHECK_OR_FAIL(result == INT32_MIN, "int32: expected INT32_MIN");

    NAPI_CALL(env, napi_create_int32(env, INT32_MAX, &val));
    NAPI_CALL(env, napi_get_value_int32(env, val, &result));
    CHECK_OR_FAIL(result == INT32_MAX, "int32: expected INT32_MAX");
  }

  // ---- uint32: basic and edge cases ----
  {
    napi_value val;
    uint32_t result;

    NAPI_CALL(env, napi_create_uint32(env, 0, &val));
    NAPI_CALL(env, napi_get_value_uint32(env, val, &result));
    CHECK_OR_FAIL(result == 0, "uint32: expected 0");

    NAPI_CALL(env, napi_create_uint32(env, 100, &val));
    NAPI_CALL(env, napi_get_value_uint32(env, val, &result));
    CHECK_OR_FAIL(result == 100, "uint32: expected 100");

    NAPI_CALL(env, napi_create_uint32(env, UINT32_MAX, &val));
    NAPI_CALL(env, napi_get_value_uint32(env, val, &result));
    CHECK_OR_FAIL(result == UINT32_MAX, "uint32: expected UINT32_MAX");
  }

  // ---- double: basic precision ----
  {
    napi_value val;
    double result;

    NAPI_CALL(env, napi_create_double(env, 3.14159, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    CHECK_OR_FAIL(result > 3.14158 && result < 3.14160,
                  "double: expected ~3.14159");

    NAPI_CALL(env, napi_create_double(env, 0.0, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    CHECK_OR_FAIL(result == 0.0, "double: expected 0.0");

    NAPI_CALL(env, napi_create_double(env, -1.5, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    CHECK_OR_FAIL(result == -1.5, "double: expected -1.5");
  }

  // ---- double: negative zero ----
  {
    napi_value val;
    double result;

    NAPI_CALL(env, napi_create_double(env, -0.0, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    // -0.0 == 0.0 is true in C, but 1/-0.0 == -Inf
    CHECK_OR_FAIL(result == 0.0, "double: -0.0 should equal 0.0");
    CHECK_OR_FAIL(1.0 / result < 0.0,
                  "double: expected negative zero (1/-0.0 should be -Inf)");
  }

  // ---- double: large values ----
  {
    napi_value val;
    double result;

    NAPI_CALL(env, napi_create_double(env, 1e300, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    CHECK_OR_FAIL(result == 1e300, "double: expected 1e300");

    NAPI_CALL(env, napi_create_double(env, -1e300, &val));
    NAPI_CALL(env, napi_get_value_double(env, val, &result));
    CHECK_OR_FAIL(result == -1e300, "double: expected -1e300");
  }

  // ---- int64: basic and large values ----
  {
    napi_value val;
    int64_t result;

    NAPI_CALL(env, napi_create_int64(env, 0, &val));
    NAPI_CALL(env, napi_get_value_int64(env, val, &result));
    CHECK_OR_FAIL(result == 0, "int64: expected 0");

    NAPI_CALL(env, napi_create_int64(env, -1, &val));
    NAPI_CALL(env, napi_get_value_int64(env, val, &result));
    CHECK_OR_FAIL(result == -1, "int64: expected -1");

    // Large int64 value within safe integer range
    NAPI_CALL(env, napi_create_int64(env, 9007199254740991LL, &val));
    NAPI_CALL(env, napi_get_value_int64(env, val, &result));
    CHECK_OR_FAIL(result == 9007199254740991LL,
                  "int64: expected 2^53 - 1 (MAX_SAFE_INTEGER)");

    NAPI_CALL(env, napi_create_int64(env, -9007199254740991LL, &val));
    NAPI_CALL(env, napi_get_value_int64(env, val, &result));
    CHECK_OR_FAIL(result == -9007199254740991LL,
                  "int64: expected -(2^53 - 1) (MIN_SAFE_INTEGER)");
  }

  // ---- typeof number values ----
  {
    napi_valuetype vtype;
    napi_value val;

    NAPI_CALL(env, napi_create_int32(env, 7, &val));
    NAPI_CALL(env, napi_typeof(env, val, &vtype));
    CHECK_OR_FAIL(vtype == napi_number, "typeof int32: expected napi_number");

    NAPI_CALL(env, napi_create_double(env, 1.5, &val));
    NAPI_CALL(env, napi_typeof(env, val, &vtype));
    CHECK_OR_FAIL(vtype == napi_number, "typeof double: expected napi_number");

    NAPI_CALL(env, napi_create_uint32(env, 10, &val));
    NAPI_CALL(env, napi_typeof(env, val, &vtype));
    CHECK_OR_FAIL(vtype == napi_number, "typeof uint32: expected napi_number");

    NAPI_CALL(env, napi_create_int64(env, 100, &val));
    NAPI_CALL(env, napi_typeof(env, val, &vtype));
    CHECK_OR_FAIL(vtype == napi_number, "typeof int64: expected napi_number");
  }

  return PrintSuccess("TEST_NUMBER");
}