forked from emscripten-core/emscripten
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathtest_i64_binding.cpp
More file actions
120 lines (98 loc) · 3.19 KB
/
test_i64_binding.cpp
File metadata and controls
120 lines (98 loc) · 3.19 KB
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
// Copyright 2021 The Emscripten Authors. All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License. Both these licenses can be
// found in the LICENSE file.
#include <stdio.h>
#include <iostream>
#include <cmath>
#include <emscripten/bind.h>
#include <emscripten/emscripten.h>
#include <emscripten/val.h>
using namespace emscripten;
using namespace std;
#define assert_js(X) assert(run_js(X))
void test(string message)
{
cout << "test:\n" << message << "\n";
}
void execute_js(string js_code)
{
js_code.append(";");
const char* js_code_pointer = js_code.c_str();
EM_ASM_INT({
var js_code = UTF8ToString($0);
return eval(js_code);
}, js_code_pointer);
}
int run_js(string js_code)
{
js_code.append(";");
const char* js_code_pointer = js_code.c_str();
return EM_ASM_INT({
var js_code = UTF8ToString($0);
return eval(js_code);
}, js_code_pointer);
}
void ensure_js_throws(string js_code, string error_type)
{
js_code.append(";");
const char* js_code_pointer = js_code.c_str();
const char* error_type_pointer = error_type.c_str();
assert(EM_ASM_INT({
var js_code = UTF8ToString($0);
var error_type = UTF8ToString($1);
try {
eval(js_code);
}
catch(error_thrown)
{
return error_thrown.name === error_type;
}
return false;
}, js_code_pointer, error_type_pointer));
}
EMSCRIPTEN_BINDINGS(tests) {
register_vector<int64_t>("Int64Vector");
register_vector<uint64_t>("UInt64Vector");
}
int main()
{
const int64_t max_int64_t = numeric_limits<int64_t>::max();
const int64_t min_int64_t = numeric_limits<int64_t>::min();
const uint64_t max_uint64_t = numeric_limits<uint64_t>::max();
printf("start\n");
test("vector<int64_t>");
val myval(std::vector<int64_t>{1, 2, 3, -4});
val::global().set("v64", myval);
assert_js("v64.get(0) === 1n");
assert_js("v64.get(1) === 2n");
assert_js("v64.get(2) === 3n");
assert_js("v64.get(3) === -4n");
execute_js("v64.push_back(1234n)");
assert_js("v64.size() === 5");
assert_js("v64.get(4) === 1234n");
test("vector<int64_t> Cannot convert number to int64_t");
ensure_js_throws("v64.push_back(1234)", "TypeError");
test("vector<int64_t> Cannot convert bigint that is too big");
ensure_js_throws("v64.push_back(12345678901234567890123456n)", "TypeError");
test("vector<uint64_t>");
val myval2(vector<uint64_t>{1, 2, 3, 4});
val::global().set("vU64", myval2);
assert_js("vU64.get(0) === 1n");
assert_js("vU64.get(1) === 2n");
assert_js("vU64.get(2) === 3n");
assert_js("vU64.get(3) === 4n");
execute_js("vU64.push_back(1234n)");
assert_js("vU64.size() === 5");
assert_js("vU64.get(4) === 1234n");
test("vector<uint64_t> Cannot convert number to uint64_t");
ensure_js_throws("vU64.push_back(1234)", "TypeError");
test("vector<uint64_t> Cannot convert bigint that is too big");
ensure_js_throws("vU64.push_back(12345678901234567890123456n)", "TypeError");
test("vector<uint64_t> Cannot convert bigint that is negative");
ensure_js_throws("vU64.push_back(-1n)", "TypeError");
myval.call<void>("delete");
myval2.call<void>("delete");
printf("end\n");
return 0;
}