Mercurial > code

comparison modules/js/test/main.cpp @ 612:18ec7f4fc3de

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Js: new style, closes #685
author David Demelier <markand@malikania.fr>
date Mon, 21 Aug 2017 11:08:49 +0200
parents f48bb09bccc7
children 266f32919d0a
comparison
equal deleted inserted replaced
611:beef249c796c 612:18ec7f4fc3de
1 /* 1 /*
2 * TestJsUnicode.cpp -- test irccd JS functions 2 * main.cpp -- test Duktape extras
3 * 3 *
4 * Copyright (c) 2016 David Demelier <markand@malikania.fr> 4 * Copyright (c) 2016 David Demelier <markand@malikania.fr>
5 * 5 *
6 * Permission to use, copy, modify, and/or distribute this software for any 6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above 7 * purpose with or without fee is hereby granted, provided that the above
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */ 17 */
18 18
19 #include <gtest/gtest.h> 19 #define BOOST_TEST_MODULE "Duktape"
20 #include <boost/test/unit_test.hpp>
20 21
21 #include <duktape.hpp> 22 #include <duktape.hpp>
22
23 TEST(Push, array)
24 {
25 UniqueContext ctx;
26
27 std::vector<int> v{1, 2, 3};
28
29 dukx_push_array(ctx, v, duk_push_int);
30 ASSERT_EQ(v, dukx_get_array(ctx, -1, duk_get_int));
31 }
32
33 TEST(Push, object)
34 {
35 UniqueContext ctx;
36
37 std::unordered_map<std::string, std::string> o{
38 { "file", "foo.txt" },
39 { "password", "test" }
40 };
41
42 dukx_push_object(ctx, o, dukx_push_std_string);
43 ASSERT_EQ(o, dukx_get_object(ctx, -1, dukx_get_std_string));
44 }
45
46 #if 0
47
48 TEST(Basics, enumerate)
49 {
50 duk::UniqueContext context;
51
52 ASSERT_EQ(0, duk::top(context));
53 duk::push(context, duk::Object{});
54 duk::putProperty(context, -1, "x", 123);
55 duk::putProperty(context, -1, "y", 456);
56 ASSERT_EQ(1, duk::top(context));
57 duk::enumerate(context, -1, 0, true, [] (duk::Context *ctx) {
58 ASSERT_EQ(DUK_TYPE_STRING, duk::type(ctx, -2));
59 ASSERT_EQ(DUK_TYPE_NUMBER, duk::type(ctx, -1));
60
61 if (duk::get<std::string>(ctx, -2) == "x")
62 ASSERT_EQ(123, duk::get<int>(ctx, -1));
63 if (duk::get<std::string>(ctx, -2) == "y")
64 ASSERT_EQ(456, duk::get<int>(ctx, -1));
65 });
66 ASSERT_EQ(1, duk::top(context));
67 }
68
69 /*
70 * Exception handling.
71 * ------------------------------------------------------------------
72 */
73
74 TEST(Exception, raise)
75 {
76 duk::UniqueContext context;
77
78 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t {
79 duk::raise(ctx, DUK_ERR_ERROR, "error thrown");
80
81 return 0;
82 }});
83 duk::evalString(context,
84 "try {"
85 " f();"
86 "} catch (ex) {"
87 " name = ex.name;"
88 " message = ex.message;"
89 " received = true;"
90 "}"
91 );
92
93 ASSERT_TRUE(duk::getGlobal<bool>(context, "received"));
94 ASSERT_EQ("Error", duk::getGlobal<std::string>(context, "name"));
95 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message"));
96 }
97 23
98 /* 24 /*
99 * Standard exceptions. 25 * Standard exceptions.
100 * -------------------------------------------------------- 26 * --------------------------------------------------------
101 */ 27 */
102 28
103 TEST(StandardExceptions, error) 29 BOOST_AUTO_TEST_SUITE(standard_exceptions)
30
31 BOOST_AUTO_TEST_CASE(error)
104 { 32 {
105 duk::UniqueContext context; 33 dukx_unique_context ctx;
106 34
107 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 35 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
108 duk::raise(ctx, duk::Error("error thrown")); 36 return dukx_throw(ctx, dukx_error("error thrown"));
109 37 }, 0);
110 return 0; 38 duk_put_global_string(ctx, "f");
111 }}); 39 duk_peval_string(ctx,
112 duk::evalString(context,
113 "try {" 40 "try {"
114 " f();" 41 " f();"
115 "} catch (ex) {" 42 "} catch (ex) {"
116 " name = ex.name;" 43 " name = ex.name;"
117 " message = ex.message;" 44 " message = ex.message;"
118 " received = true;" 45 " instance = (ex instanceof Error);"
119 " correct = (ex instanceof Error);"
120 "}" 46 "}"
121 ); 47 );
122 48
123 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 49 duk_get_global_string(ctx, "name");
124 ASSERT_EQ("Error", duk::getGlobal<std::string>(context, "name")); 50 BOOST_REQUIRE_EQUAL("Error", dukx_get_std_string(ctx, -1));
125 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 51 duk_get_global_string(ctx, "message");
126 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 52 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
53 duk_get_global_string(ctx, "instance");
54 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
127 } 55 }
128 56
129 TEST(StandardExceptions, evalError) 57 BOOST_AUTO_TEST_CASE(eval_error)
130 { 58 {
131 duk::UniqueContext context; 59 dukx_unique_context ctx;
132 60
133 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 61 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
134 duk::raise(ctx, duk::EvalError("error thrown")); 62 return dukx_throw(ctx, dukx_eval_error("error thrown"));
135 63 }, 0);
136 return 0; 64 duk_put_global_string(ctx, "f");
137 }}); 65 duk_peval_string(ctx,
138 duk::evalString(context,
139 "try {" 66 "try {"
140 " f();" 67 " f();"
141 "} catch (ex) {" 68 "} catch (ex) {"
142 " name = ex.name;" 69 " name = ex.name;"
143 " message = ex.message;" 70 " message = ex.message;"
144 " received = true;" 71 " instance = (ex instanceof EvalError);"
145 " correct = (ex instanceof EvalError);"
146 "}" 72 "}"
147 ); 73 );
148 74
149 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 75 duk_get_global_string(ctx, "name");
150 ASSERT_EQ("EvalError", duk::getGlobal<std::string>(context, "name")); 76 BOOST_REQUIRE_EQUAL("EvalError", dukx_get_std_string(ctx, -1));
151 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 77 duk_get_global_string(ctx, "message");
152 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 78 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
79 duk_get_global_string(ctx, "instance");
80 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
153 } 81 }
154 82
155 TEST(StandardExceptions, rangeError) 83 BOOST_AUTO_TEST_CASE(range_error)
156 { 84 {
157 duk::UniqueContext context; 85 dukx_unique_context ctx;
158 86
159 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 87 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
160 duk::raise(ctx, duk::RangeError("error thrown")); 88 return dukx_throw(ctx, dukx_range_error("error thrown"));
161 89 }, 0);
162 return 0; 90 duk_put_global_string(ctx, "f");
163 }}); 91 duk_peval_string(ctx,
164 duk::evalString(context,
165 "try {" 92 "try {"
166 " f();" 93 " f();"
167 "} catch (ex) {" 94 "} catch (ex) {"
168 " name = ex.name;" 95 " name = ex.name;"
169 " message = ex.message;" 96 " message = ex.message;"
170 " received = true;" 97 " instance = (ex instanceof RangeError);"
171 " correct = (ex instanceof RangeError);"
172 "}" 98 "}"
173 ); 99 );
174 100
175 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 101 duk_get_global_string(ctx, "name");
176 ASSERT_EQ("RangeError", duk::getGlobal<std::string>(context, "name")); 102 BOOST_REQUIRE_EQUAL("RangeError", dukx_get_std_string(ctx, -1));
177 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 103 duk_get_global_string(ctx, "message");
178 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 104 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
105 duk_get_global_string(ctx, "instance");
106 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
179 } 107 }
180 108
181 TEST(StandardExceptions, referenceError) 109 BOOST_AUTO_TEST_CASE(reference_error)
182 { 110 {
183 duk::UniqueContext context; 111 dukx_unique_context ctx;
184 112
185 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 113 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
186 duk::raise(ctx, duk::ReferenceError("error thrown")); 114 return dukx_throw(ctx, dukx_reference_error("error thrown"));
187 115 }, 0);
188 return 0; 116 duk_put_global_string(ctx, "f");
189 }}); 117 duk_peval_string(ctx,
190 duk::evalString(context,
191 "try {" 118 "try {"
192 " f();" 119 " f();"
193 "} catch (ex) {" 120 "} catch (ex) {"
194 " name = ex.name;" 121 " name = ex.name;"
195 " message = ex.message;" 122 " message = ex.message;"
196 " received = true;" 123 " instance = (ex instanceof ReferenceError);"
197 " correct = (ex instanceof ReferenceError);"
198 "}" 124 "}"
199 ); 125 );
200 126
201 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 127 duk_get_global_string(ctx, "name");
202 ASSERT_EQ("ReferenceError", duk::getGlobal<std::string>(context, "name")); 128 BOOST_REQUIRE_EQUAL("ReferenceError", dukx_get_std_string(ctx, -1));
203 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 129 duk_get_global_string(ctx, "message");
204 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 130 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
131 duk_get_global_string(ctx, "instance");
132 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
205 } 133 }
206 134
207 TEST(StandardExceptions, syntaxError) 135 BOOST_AUTO_TEST_CASE(syntax_error)
208 { 136 {
209 duk::UniqueContext context; 137 dukx_unique_context ctx;
210 138
211 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 139 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
212 duk::raise(ctx, duk::SyntaxError("error thrown")); 140 return dukx_throw(ctx, dukx_syntax_error("error thrown"));
213 141 }, 0);
214 return 0; 142 duk_put_global_string(ctx, "f");
215 }}); 143 duk_peval_string(ctx,
216 duk::evalString(context,
217 "try {" 144 "try {"
218 " f();" 145 " f();"
219 "} catch (ex) {" 146 "} catch (ex) {"
220 " name = ex.name;" 147 " name = ex.name;"
221 " message = ex.message;" 148 " message = ex.message;"
222 " received = true;" 149 " instance = (ex instanceof SyntaxError);"
223 " correct = (ex instanceof SyntaxError);"
224 "}" 150 "}"
225 ); 151 );
226 152
227 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 153 duk_get_global_string(ctx, "name");
228 ASSERT_EQ("SyntaxError", duk::getGlobal<std::string>(context, "name")); 154 BOOST_REQUIRE_EQUAL("SyntaxError", dukx_get_std_string(ctx, -1));
229 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 155 duk_get_global_string(ctx, "message");
230 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 156 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
157 duk_get_global_string(ctx, "instance");
158 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
231 } 159 }
232 160
233 TEST(StandardExceptions, typeError) 161 BOOST_AUTO_TEST_CASE(type_error)
234 { 162 {
235 duk::UniqueContext context; 163 dukx_unique_context ctx;
236 164
237 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t { 165 duk_push_c_function(ctx, [] (duk_context* ctx) -> duk_idx_t {
238 duk::raise(ctx, duk::TypeError("error thrown")); 166 return dukx_throw(ctx, dukx_type_error("error thrown"));
239 167 }, 0);
240 return 0; 168 duk_put_global_string(ctx, "f");
241 }}); 169 duk_peval_string(ctx,
242 duk::evalString(context,
243 "try {" 170 "try {"
244 " f();" 171 " f();"
245 "} catch (ex) {" 172 "} catch (ex) {"
246 " name = ex.name;" 173 " name = ex.name;"
247 " message = ex.message;" 174 " message = ex.message;"
248 " received = true;" 175 " instance = (ex instanceof TypeError);"
249 " correct = (ex instanceof TypeError);"
250 "}" 176 "}"
251 ); 177 );
252 178
253 ASSERT_TRUE(duk::getGlobal<bool>(context, "received")); 179 duk_get_global_string(ctx, "name");
254 ASSERT_EQ("TypeError", duk::getGlobal<std::string>(context, "name")); 180 BOOST_REQUIRE_EQUAL("TypeError", dukx_get_std_string(ctx, -1));
255 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message")); 181 duk_get_global_string(ctx, "message");
256 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct")); 182 BOOST_REQUIRE_EQUAL("error thrown", dukx_get_std_string(ctx, -1));
183 duk_get_global_string(ctx, "instance");
184 BOOST_REQUIRE(duk_get_boolean(ctx, -1));
257 } 185 }
258 186
259 TEST(StandardExceptions, uriError) 187 BOOST_AUTO_TEST_CASE(uriError)
260 { 188 {
261 duk::UniqueContext context;
262
263 duk::putGlobal(context, "f", duk::Function{[] (duk::Context *ctx) -> duk_idx_t {
264 duk::raise(ctx, duk::URIError("error thrown"));
265
266 return 0;
267 }});
268 duk::evalString(context,
269 "try {"
270 " f();"
271 "} catch (ex) {"
272 " name = ex.name;"
273 " message = ex.message;"
274 " received = true;"
275 " correct = (ex instanceof URIError);"
276 "}"
277 );
278
279 ASSERT_TRUE(duk::getGlobal<bool>(context, "received"));
280 ASSERT_EQ("URIError", duk::getGlobal<std::string>(context, "name"));
281 ASSERT_EQ("error thrown", duk::getGlobal<std::string>(context, "message"));
282 ASSERT_TRUE(duk::getGlobal<bool>(context, "correct"));
283 } 189 }
284 190
285 #endif 191 BOOST_AUTO_TEST_SUITE_END()
286
287 int main(int argc, char **argv)
288 {
289 testing::InitGoogleTest(&argc, argv);
290
291 return RUN_ALL_TESTS();
292 }