Mercurial > malikania

comparison tests/libclient/js-rectangle/main.cpp @ 36:9af360f34c7d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Misc: use raw duktape API
author David Demelier <markand@malikania.fr>
date Wed, 10 Aug 2016 14:30:51 +0200
parents d4f5f7231b84
children a47a4477f347
comparison
equal deleted inserted replaced
35:8e1241156034 36:9af360f34c7d
22 22
23 using namespace malikania; 23 using namespace malikania;
24 24
25 class TestRectangle : public testing::Test { 25 class TestRectangle : public testing::Test {
26 protected: 26 protected:
27 duk::Context m_ctx; 27 UniqueContext m_ctx;
28 28
29 public: 29 public:
30 TestRectangle() 30 TestRectangle()
31 { 31 {
32 duk::putGlobal(m_ctx, "Malikania", duk::Object()); 32 duk_push_object(m_ctx);
33 33 duk_put_global_string(m_ctx, "Malikania");
34 loadMalikaniaRectangle(m_ctx); 34 dukx_load_rect(m_ctx);
35 } 35 }
36 }; 36 };
37 37
38 /* 38 /*
39 * Valid constructors 39 * Valid constructors
41 */ 41 */
42 42
43 TEST_F(TestRectangle, ConstructorNoArgs) 43 TEST_F(TestRectangle, ConstructorNoArgs)
44 { 44 {
45 try { 45 try {
46 auto ret = duk::pevalString(m_ctx, 46 auto ret = duk_peval_string(m_ctx,
47 "r = Malikania.Rectangle();" 47 "r = Malikania.Rectangle();"
48 "x = r.x;" 48 "x = r.x;"
49 "y = r.y;" 49 "y = r.y;"
50 "w = r.width;" 50 "w = r.width;"
51 "h = r.height;" 51 "h = r.height;"
52 ); 52 );
53 53
54 if (ret != 0) { 54 if (ret != 0)
55 throw duk::exception(m_ctx, -1); 55 throw dukx_exception(m_ctx, -1);
56 } 56
57 57 duk_get_global_string(m_ctx, "x");
58 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "x")); 58 ASSERT_EQ(0, duk_to_int(m_ctx, -1));
59 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "y")); 59 duk_pop(m_ctx);
60 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "w")); 60 duk_get_global_string(m_ctx, "y");
61 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "h")); 61 ASSERT_EQ(0, duk_to_int(m_ctx, -1));
62 duk_pop(m_ctx);
63 duk_get_global_string(m_ctx, "w");
64 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1));
65 duk_pop(m_ctx);
66 duk_get_global_string(m_ctx, "h");
67 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1));
68 duk_pop(m_ctx);
62 } catch (const std::exception &ex) { 69 } catch (const std::exception &ex) {
63 FAIL() << ex.what(); 70 FAIL() << ex.what();
64 } 71 }
65 } 72 }
66 73
67 TEST_F(TestRectangle, Constructor4Args) 74 TEST_F(TestRectangle, Constructor4Args)
68 { 75 {
69 try { 76 try {
70 auto ret = duk::pevalString(m_ctx, 77 auto ret = duk_peval_string(m_ctx,
71 "r = Malikania.Rectangle(10, 20, 30, 40);" 78 "r = Malikania.Rectangle(10, 20, 30, 40);"
72 "x = r.x;" 79 "x = r.x;"
73 "y = r.y;" 80 "y = r.y;"
74 "w = r.width;" 81 "w = r.width;"
75 "h = r.height;" 82 "h = r.height;"
76 ); 83 );
77 84
78 if (ret != 0) { 85 if (ret != 0)
79 throw duk::exception(m_ctx, -1); 86 throw dukx_exception(m_ctx, -1);
80 } 87
81 88 duk_get_global_string(m_ctx, "x");
82 ASSERT_EQ(10, duk::getGlobal<int>(m_ctx, "x")); 89 ASSERT_EQ(10, duk_to_int(m_ctx, -1));
83 ASSERT_EQ(20, duk::getGlobal<int>(m_ctx, "y")); 90 duk_pop(m_ctx);
84 ASSERT_EQ(30, duk::getGlobal<int>(m_ctx, "w")); 91 duk_get_global_string(m_ctx, "y");
85 ASSERT_EQ(40, duk::getGlobal<int>(m_ctx, "h")); 92 ASSERT_EQ(20, duk_to_int(m_ctx, -1));
93 duk_pop(m_ctx);
94 duk_get_global_string(m_ctx, "w");
95 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1));
96 duk_pop(m_ctx);
97 duk_get_global_string(m_ctx, "h");
98 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1));
99 duk_pop(m_ctx);
86 } catch (const std::exception &ex) { 100 } catch (const std::exception &ex) {
87 FAIL() << ex.what(); 101 FAIL() << ex.what();
88 } 102 }
89 } 103 }
90 104
91 TEST_F(TestRectangle, ConstructorObject) 105 TEST_F(TestRectangle, ConstructorObject)
92 { 106 {
93 try { 107 try {
94 auto ret = duk::pevalString(m_ctx, 108 auto ret = duk_peval_string(m_ctx,
95 "r = Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });" 109 "r = Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });"
96 "x = r.x;" 110 "x = r.x;"
97 "y = r.y;" 111 "y = r.y;"
98 "w = r.width;" 112 "w = r.width;"
99 "h = r.height;" 113 "h = r.height;"
100 ); 114 );
101 115
102 if (ret != 0) { 116 if (ret != 0)
103 throw duk::exception(m_ctx, -1); 117 throw dukx_exception(m_ctx, -1);
104 } 118
105 119 duk_get_global_string(m_ctx, "x");
106 ASSERT_EQ(10, duk::getGlobal<int>(m_ctx, "x")); 120 ASSERT_EQ(10, duk_to_int(m_ctx, -1));
107 ASSERT_EQ(20, duk::getGlobal<int>(m_ctx, "y")); 121 duk_pop(m_ctx);
108 ASSERT_EQ(30, duk::getGlobal<int>(m_ctx, "w")); 122 duk_get_global_string(m_ctx, "y");
109 ASSERT_EQ(40, duk::getGlobal<int>(m_ctx, "h")); 123 ASSERT_EQ(20, duk_to_int(m_ctx, -1));
124 duk_pop(m_ctx);
125 duk_get_global_string(m_ctx, "w");
126 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1));
127 duk_pop(m_ctx);
128 duk_get_global_string(m_ctx, "h");
129 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1));
130 duk_pop(m_ctx);
110 } catch (const std::exception &ex) { 131 } catch (const std::exception &ex) {
111 FAIL() << ex.what(); 132 FAIL() << ex.what();
112 } 133 }
113 } 134 }
114 135
115 TEST_F(TestRectangle, ConstructorNew) 136 TEST_F(TestRectangle, ConstructorNew)
116 { 137 {
117 try { 138 try {
118 auto ret = duk::pevalString(m_ctx, 139 auto ret = duk_peval_string(m_ctx,
119 "r = new Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });" 140 "r = new Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });"
120 "x = r.x;" 141 "x = r.x;"
121 "y = r.y;" 142 "y = r.y;"
122 "w = r.width;" 143 "w = r.width;"
123 "h = r.height;" 144 "h = r.height;"
124 ); 145 );
125 146
126 if (ret != 0) { 147 if (ret != 0)
127 throw duk::exception(m_ctx, -1); 148 throw dukx_exception(m_ctx, -1);
128 } 149
129 150 duk_get_global_string(m_ctx, "x");
130 ASSERT_EQ(10, duk::getGlobal<int>(m_ctx, "x")); 151 ASSERT_EQ(10, duk_to_int(m_ctx, -1));
131 ASSERT_EQ(20, duk::getGlobal<int>(m_ctx, "y")); 152 duk_pop(m_ctx);
132 ASSERT_EQ(30, duk::getGlobal<int>(m_ctx, "w")); 153 duk_get_global_string(m_ctx, "y");
133 ASSERT_EQ(40, duk::getGlobal<int>(m_ctx, "h")); 154 ASSERT_EQ(20, duk_to_int(m_ctx, -1));
155 duk_pop(m_ctx);
156 duk_get_global_string(m_ctx, "w");
157 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1));
158 duk_pop(m_ctx);
159 duk_get_global_string(m_ctx, "h");
160 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1));
161 duk_pop(m_ctx);
134 } catch (const std::exception &ex) { 162 } catch (const std::exception &ex) {
135 FAIL() << ex.what(); 163 FAIL() << ex.what();
136 } 164 }
137 } 165 }
138 166
142 */ 170 */
143 171
144 TEST_F(TestRectangle, InvalidConstructorArg1) 172 TEST_F(TestRectangle, InvalidConstructorArg1)
145 { 173 {
146 try { 174 try {
147 auto ret = duk::pevalString(m_ctx, 175 auto ret = duk_peval_string(m_ctx,
148 "try {" 176 "try {"
149 " Malikania.Rectangle(null);" 177 " Malikania.Rectangle(null);"
150 "} catch (e) {" 178 "} catch (e) {"
151 " name = e.name;" 179 " name = e.name;"
152 " correct = (e instanceof TypeError);" 180 " correct = (e instanceof TypeError);"
153 "}" 181 "}"
154 ); 182 );
155 183
156 if (ret != 0) { 184 if (ret != 0)
157 throw duk::exception(m_ctx, -1); 185 throw dukx_exception(m_ctx, -1);
158 } 186
159 187 duk_get_global_string(m_ctx, "name");
160 ASSERT_EQ("TypeError", duk::getGlobal<std::string>(m_ctx, "name")); 188 ASSERT_STREQ("TypeError", duk_to_string(m_ctx, -1));
161 ASSERT_TRUE(duk::getGlobal<bool>(m_ctx, "correct")); 189 duk_pop(m_ctx);
190 duk_get_global_string(m_ctx, "correct");
191 ASSERT_TRUE(duk_to_boolean(m_ctx, -1));
192 duk_pop(m_ctx);
162 } catch (const std::exception &ex) { 193 } catch (const std::exception &ex) {
163 FAIL() << ex.what(); 194 FAIL() << ex.what();
164 } 195 }
165 } 196 }
166 197
167 TEST_F(TestRectangle, InvalidConstructorRange1) 198 TEST_F(TestRectangle, InvalidConstructorRange1)
168 { 199 {
169 try { 200 try {
170 auto ret = duk::pevalString(m_ctx, 201 auto ret = duk_peval_string(m_ctx,
171 "try {" 202 "try {"
172 " Malikania.Rectangle(0, 0, -10, -10);" 203 " Malikania.Rectangle(0, 0, -10, -10);"
173 "} catch (e) {" 204 "} catch (e) {"
174 " name = e.name;" 205 " name = e.name;"
175 " correct = (e instanceof RangeError);" 206 " correct = (e instanceof RangeError);"
176 "}" 207 "}"
177 ); 208 );
178 209
179 if (ret != 0) { 210 if (ret != 0)
180 throw duk::exception(m_ctx, -1); 211 throw dukx_exception(m_ctx, -1);
181 } 212
182 213 duk_get_global_string(m_ctx, "name");
183 ASSERT_EQ("RangeError", duk::getGlobal<std::string>(m_ctx, "name")); 214 ASSERT_STREQ("RangeError", duk_to_string(m_ctx, -1));
184 ASSERT_TRUE(duk::getGlobal<bool>(m_ctx, "correct")); 215 duk_pop(m_ctx);
216 duk_get_global_string(m_ctx, "correct");
217 ASSERT_TRUE(duk_to_boolean(m_ctx, -1));
218 duk_pop(m_ctx);
185 } catch (const std::exception &ex) { 219 } catch (const std::exception &ex) {
186 FAIL() << ex.what(); 220 FAIL() << ex.what();
187 } 221 }
188 } 222 }
189 223
193 */ 227 */
194 228
195 TEST_F(TestRectangle, requireSuccess) 229 TEST_F(TestRectangle, requireSuccess)
196 { 230 {
197 try { 231 try {
198 duk::putGlobal(m_ctx, "build", duk::Function{[] (duk::ContextPtr ctx) -> duk::Ret { 232 duk_push_c_function(m_ctx, [] (auto ctx) {
199 Rectangle rect = duk::require<Rectangle>(ctx, 0); 233 Rectangle rect = dukx_require_rect(ctx, 0);
200 234
201 duk::putGlobal(ctx, "x", rect.x()); 235 duk_push_int(ctx, rect.x());
202 duk::putGlobal(ctx, "y", rect.y()); 236 duk_put_global_string(ctx, "x");
203 duk::putGlobal(ctx, "w", static_cast<int>(rect.width())); 237 duk_push_int(ctx, rect.y());
204 duk::putGlobal(ctx, "h", static_cast<int>(rect.height())); 238 duk_put_global_string(ctx, "y");
239 duk_push_uint(ctx, rect.width());
240 duk_put_global_string(ctx, "w");
241 duk_push_uint(ctx, rect.height());
242 duk_put_global_string(ctx, "h");
205 243
206 return 0; 244 return 0;
207 }, 1}); 245 }, 1);
208 246 duk_put_global_string(m_ctx, "build");
209 auto ret = duk::pevalString(m_ctx, "build({ x: 50, y: 80, width: 100, height: 200 });"); 247
210 248 auto ret = duk_peval_string(m_ctx, "build({ x: 50, y: 80, width: 100, height: 200 });");
211 if (ret != 0) { 249
212 throw duk::exception(m_ctx, -1); 250 if (ret != 0)
213 } 251 throw dukx_exception(m_ctx, -1);
214 252
215 ASSERT_EQ(50, duk::getGlobal<int>(m_ctx, "x")); 253 duk_get_global_string(m_ctx, "x");
216 ASSERT_EQ(80, duk::getGlobal<int>(m_ctx, "y")); 254 ASSERT_EQ(50, duk_to_int(m_ctx, -1));
217 ASSERT_EQ(100, duk::getGlobal<int>(m_ctx, "w")); 255 duk_pop(m_ctx);
218 ASSERT_EQ(200, duk::getGlobal<int>(m_ctx, "h")); 256 duk_get_global_string(m_ctx, "y");
257 ASSERT_EQ(80, duk_to_int(m_ctx, -1));
258 duk_pop(m_ctx);
259 duk_get_global_string(m_ctx, "w");
260 ASSERT_EQ(100U, duk_to_uint(m_ctx, -1));
261 duk_pop(m_ctx);
262 duk_get_global_string(m_ctx, "h");
263 ASSERT_EQ(200U, duk_to_uint(m_ctx, -1));
264 duk_pop(m_ctx);
219 } catch (const std::exception &ex) { 265 } catch (const std::exception &ex) {
220 FAIL() << ex.what(); 266 FAIL() << ex.what();
221 } 267 }
222 } 268 }
223 269
224 TEST_F(TestRectangle, requireFail) 270 TEST_F(TestRectangle, requireFail)
225 { 271 {
226 try { 272 try {
227 duk::putGlobal(m_ctx, "build", duk::Function{[] (duk::ContextPtr ctx) -> duk::Ret { 273 duk_push_c_function(m_ctx, [] (auto ctx) {
228 duk::require<Rectangle>(ctx, 0); 274 dukx_require_rect(ctx, 0);
229 275
230 return 0; 276 return 0;
231 }, 1}); 277 }, 1);
232 278 duk_put_global_string(m_ctx, "build");
233 auto ret = duk::pevalString(m_ctx, 279
280 auto ret = duk_peval_string(m_ctx,
234 "try {" 281 "try {"
235 " build({});" 282 " build({});"
236 "} catch (e) {" 283 "} catch (e) {"
237 " name = e.name;" 284 " name = e.name;"
238 " correct = (e instanceof Error);" 285 " correct = (e instanceof Error);"
239 "}" 286 "}"
240 ); 287 );
241 288
242 if (ret != 0) { 289 if (ret != 0)
243 throw duk::exception(m_ctx, -1); 290 throw dukx_exception(m_ctx, -1);
244 } 291
245 292 duk_get_global_string(m_ctx, "name");
246 ASSERT_EQ("Error", duk::getGlobal<std::string>(m_ctx, "name")); 293 ASSERT_STREQ("Error", duk_to_string(m_ctx, -1));
247 ASSERT_TRUE(duk::getGlobal<bool>(m_ctx, "correct")); 294 duk_pop(m_ctx);
295 duk_get_global_string(m_ctx, "correct");
296 ASSERT_TRUE(duk_to_boolean(m_ctx, -1));
297 duk_pop(m_ctx);
248 } catch (const std::exception &ex) { 298 } catch (const std::exception &ex) {
249 FAIL() << ex.what(); 299 FAIL() << ex.what();
250 } 300 }
251 } 301 }
252 302
256 */ 306 */
257 307
258 TEST_F(TestRectangle, getAdjustAll) 308 TEST_F(TestRectangle, getAdjustAll)
259 { 309 {
260 try { 310 try {
261 duk::putGlobal(m_ctx, "build", duk::Function{[] (duk::ContextPtr ctx) -> duk::Ret { 311 duk_push_c_function(m_ctx, [] (auto ctx) {
262 Rectangle rect = duk::get<Rectangle>(ctx, 0); 312 Rectangle rect = dukx_get_rect(ctx, 0);
263 313
264 duk::putGlobal(ctx, "x", rect.x()); 314 duk_push_int(ctx, rect.x());
265 duk::putGlobal(ctx, "y", rect.y()); 315 duk_put_global_string(ctx, "x");
266 duk::putGlobal(ctx, "w", static_cast<int>(rect.width())); 316 duk_push_int(ctx, rect.y());
267 duk::putGlobal(ctx, "h", static_cast<int>(rect.height())); 317 duk_put_global_string(ctx, "y");
318 duk_push_uint(ctx, rect.width());
319 duk_put_global_string(ctx, "w");
320 duk_push_uint(ctx, rect.height());
268 321
269 return 0; 322 return 0;
270 }, 1}); 323 }, 1);
271 324 duk_put_global_string(m_ctx, "build");
272 auto ret = duk::pevalString(m_ctx, "build({});"); 325
273 326 auto ret = duk_peval_string(m_ctx, "build({});");
274 if (ret != 0) { 327
275 throw duk::exception(m_ctx, -1); 328 if (ret != 0)
276 } 329 throw dukx_exception(m_ctx, -1);
277 330
278 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "x")); 331 duk_get_global_string(m_ctx, "x");
279 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "y")); 332 ASSERT_EQ(0, duk_to_int(m_ctx, -1));
280 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "w")); 333 duk_pop(m_ctx);
281 ASSERT_EQ(0, duk::getGlobal<int>(m_ctx, "h")); 334 duk_get_global_string(m_ctx, "y");
335 ASSERT_EQ(0, duk_to_int(m_ctx, -1));
336 duk_pop(m_ctx);
337 duk_get_global_string(m_ctx, "w");
338 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1));
339 duk_pop(m_ctx);
340 duk_get_global_string(m_ctx, "h");
341 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1));
342 duk_pop(m_ctx);
282 } catch (const std::exception &ex) { 343 } catch (const std::exception &ex) {
283 FAIL() << ex.what(); 344 FAIL() << ex.what();
284 } 345 }
285 } 346 }
286 347