Mercurial > malikania

comparison tests/libclient/js-size/main.cpp @ 53:fe7e3524e571

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: various style fixes
author David Demelier <markand@malikania.fr>
date Fri, 16 Dec 2016 13:07:44 +0100
parents f30c84b4b9ed
children 96ba0c5cf893
comparison
equal deleted inserted replaced
52:4bc4732fa1dd 53:fe7e3524e571
37 }; 37 };
38 38
39 BOOST_FIXTURE_TEST_SUITE(test_size_suite, test_size) 39 BOOST_FIXTURE_TEST_SUITE(test_size_suite, test_size)
40 40
41 /* 41 /*
42 * Valid constructors 42 * Valid constructors.
43 * ------------------------------------------------------------------ 43 * ------------------------------------------------------------------
44 */ 44 */
45 45
46 BOOST_AUTO_TEST_CASE(ConstructorNoArgs) 46 BOOST_AUTO_TEST_SUITE(constructors)
47
48 BOOST_AUTO_TEST_CASE(constructor_default)
47 { 49 {
48 try { 50 try {
49 auto ret = duk_peval_string(m_ctx, 51 auto ret = duk_peval_string(m_ctx,
50 "s = Malikania.Size();" 52 "s = Malikania.Size();"
51 "w = s.width;" 53 "w = s.width;"
65 } catch (const std::exception &ex) { 67 } catch (const std::exception &ex) {
66 BOOST_FAIL(ex.what()); 68 BOOST_FAIL(ex.what());
67 } 69 }
68 } 70 }
69 71
70 BOOST_AUTO_TEST_CASE(Constructor2Args) 72 BOOST_AUTO_TEST_CASE(constructor_2_args)
71 { 73 {
72 try { 74 try {
73 auto ret = duk_peval_string(m_ctx, 75 auto ret = duk_peval_string(m_ctx,
74 "s = Malikania.Size(100, 200);" 76 "s = Malikania.Size(100, 200);"
75 "w = s.width;" 77 "w = s.width;"
89 } catch (const std::exception &ex) { 91 } catch (const std::exception &ex) {
90 BOOST_FAIL(ex.what()); 92 BOOST_FAIL(ex.what());
91 } 93 }
92 } 94 }
93 95
94 BOOST_AUTO_TEST_CASE(ConstructorObject) 96 BOOST_AUTO_TEST_CASE(constructor_object)
95 { 97 {
96 try { 98 try {
97 auto ret = duk_peval_string(m_ctx, 99 auto ret = duk_peval_string(m_ctx,
98 "s = Malikania.Size({ width: 100, height: 200 });" 100 "s = Malikania.Size({ width: 100, height: 200 });"
99 "w = s.width;" 101 "w = s.width;"
113 } catch (const std::exception &ex) { 115 } catch (const std::exception &ex) {
114 BOOST_FAIL(ex.what()); 116 BOOST_FAIL(ex.what());
115 } 117 }
116 } 118 }
117 119
118 BOOST_AUTO_TEST_CASE(ConstructorNew) 120 BOOST_AUTO_TEST_CASE(constructor_new)
119 { 121 {
120 try { 122 try {
121 auto ret = duk_peval_string(m_ctx, 123 auto ret = duk_peval_string(m_ctx,
122 "s = new Malikania.Size({ width: 100, height: 200 });" 124 "s = new Malikania.Size({ width: 100, height: 200 });"
123 "w = s.width;" 125 "w = s.width;"
137 } catch (const std::exception &ex) { 139 } catch (const std::exception &ex) {
138 BOOST_FAIL(ex.what()); 140 BOOST_FAIL(ex.what());
139 } 141 }
140 } 142 }
141 143
144 BOOST_AUTO_TEST_SUITE_END()
145
142 /* 146 /*
143 * Invalid constructors 147 * Invalid constructors.
144 * ------------------------------------------------------------------ 148 * ------------------------------------------------------------------
145 */ 149 */
146 150
147 BOOST_AUTO_TEST_CASE(InvalidConstructorArg1) 151 BOOST_AUTO_TEST_SUITE(invalid_constructors)
152
153 BOOST_AUTO_TEST_CASE(constructor_arg_1)
148 { 154 {
149 try { 155 try {
150 auto ret = duk_peval_string(m_ctx, 156 auto ret = duk_peval_string(m_ctx,
151 "try {" 157 "try {"
152 " Malikania.Size(null);" 158 " Malikania.Size(null);"
169 } catch (const std::exception &ex) { 175 } catch (const std::exception &ex) {
170 BOOST_FAIL(ex.what()); 176 BOOST_FAIL(ex.what());
171 } 177 }
172 } 178 }
173 179
174 BOOST_AUTO_TEST_CASE(InvalidConstructorRange1) 180 BOOST_AUTO_TEST_CASE(constructor_range_1)
175 { 181 {
176 try { 182 try {
177 auto ret = duk_peval_string(m_ctx, 183 auto ret = duk_peval_string(m_ctx,
178 "try {" 184 "try {"
179 " Malikania.Size(-1, 200);" 185 " Malikania.Size(-1, 200);"
196 } catch (const std::exception &ex) { 202 } catch (const std::exception &ex) {
197 BOOST_FAIL(ex.what()); 203 BOOST_FAIL(ex.what());
198 } 204 }
199 } 205 }
200 206
201 BOOST_AUTO_TEST_CASE(InvalidConstructorRange2) 207 BOOST_AUTO_TEST_CASE(constructor_range_2)
202 { 208 {
203 try { 209 try {
204 auto ret = duk_peval_string(m_ctx, 210 auto ret = duk_peval_string(m_ctx,
205 "try {" 211 "try {"
206 " Malikania.Size(100, -1);" 212 " Malikania.Size(100, -1);"
223 } catch (const std::exception &ex) { 229 } catch (const std::exception &ex) {
224 BOOST_FAIL(ex.what()); 230 BOOST_FAIL(ex.what());
225 } 231 }
226 } 232 }
227 233
228 BOOST_AUTO_TEST_CASE(InvalidConstructorRange3) 234 BOOST_AUTO_TEST_CASE(constructor_range_3)
229 { 235 {
230 try { 236 try {
231 auto ret = duk_peval_string(m_ctx, 237 auto ret = duk_peval_string(m_ctx,
232 "try {" 238 "try {"
233 " Malikania.Size({ width: -1, height: 200 });" 239 " Malikania.Size({ width: -1, height: 200 });"
250 } catch (const std::exception &ex) { 256 } catch (const std::exception &ex) {
251 BOOST_FAIL(ex.what()); 257 BOOST_FAIL(ex.what());
252 } 258 }
253 } 259 }
254 260
255 BOOST_AUTO_TEST_CASE(InvalidConstructorRange4) 261 BOOST_AUTO_TEST_CASE(constructor_range_4)
256 { 262 {
257 try { 263 try {
258 auto ret = duk_peval_string(m_ctx, 264 auto ret = duk_peval_string(m_ctx,
259 "try {" 265 "try {"
260 " Malikania.Size({ width: 100, height: -1 });" 266 " Malikania.Size({ width: 100, height: -1 });"
276 duk_pop(m_ctx); 282 duk_pop(m_ctx);
277 } catch (const std::exception &ex) { 283 } catch (const std::exception &ex) {
278 BOOST_FAIL(ex.what()); 284 BOOST_FAIL(ex.what());
279 } 285 }
280 } 286 }
287
288 BOOST_AUTO_TEST_SUITE_END()
281 289
282 /* 290 /*
283 * Require. 291 * Require.
284 * ------------------------------------------------------------------ 292 * ------------------------------------------------------------------
285 */ 293 */
286 294
287 BOOST_AUTO_TEST_CASE(requireSuccess) 295 BOOST_AUTO_TEST_SUITE(require)
296
297 BOOST_AUTO_TEST_CASE(success)
288 { 298 {
289 try { 299 try {
290 duk_push_c_function(m_ctx, [] (auto ctx) { 300 duk_push_c_function(m_ctx, [] (auto ctx) {
291 auto size = dukx_require_size(ctx, 0); 301 auto size = dukx_require_size(ctx, 0);
292 302
314 } catch (const std::exception &ex) { 324 } catch (const std::exception &ex) {
315 BOOST_FAIL(ex.what()); 325 BOOST_FAIL(ex.what());
316 } 326 }
317 } 327 }
318 328
319 BOOST_AUTO_TEST_CASE(requireFail) 329 BOOST_AUTO_TEST_CASE(fail)
320 { 330 {
321 try { 331 try {
322 duk_push_c_function(m_ctx, [] (auto ctx) { 332 duk_push_c_function(m_ctx, [] (auto ctx) {
323 dukx_require_size(ctx, 0); 333 dukx_require_size(ctx, 0);
324 334
347 duk_pop(m_ctx); 357 duk_pop(m_ctx);
348 } catch (const std::exception &ex) { 358 } catch (const std::exception &ex) {
349 BOOST_FAIL(ex.what()); 359 BOOST_FAIL(ex.what());
350 } 360 }
351 } 361 }
362
363 BOOST_AUTO_TEST_SUITE_END()
352 364
353 /* 365 /*
354 * Get. 366 * Get.
355 * ------------------------------------------------------------------ 367 * ------------------------------------------------------------------
356 */ 368 */
357 369
358 BOOST_AUTO_TEST_CASE(getAdjustAll) 370 BOOST_AUTO_TEST_SUITE(get)
371
372 BOOST_AUTO_TEST_CASE(adjust_all)
359 { 373 {
360 try { 374 try {
361 duk_push_c_function(m_ctx, [] (auto ctx) { 375 duk_push_c_function(m_ctx, [] (auto ctx) {
362 auto size = dukx_get_size(ctx, 0); 376 auto size = dukx_get_size(ctx, 0);
363 377
386 BOOST_FAIL(ex.what()); 400 BOOST_FAIL(ex.what());
387 } 401 }
388 } 402 }
389 403
390 BOOST_AUTO_TEST_SUITE_END() 404 BOOST_AUTO_TEST_SUITE_END()
405
406 BOOST_AUTO_TEST_SUITE_END()