Mercurial > malikania

comparison tests/libclient/js-rectangle/main.cpp @ 44:f30c84b4b9ed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: switch from GoogleTest to Boost.Unit, closes #588
author David Demelier <markand@malikania.fr>
date Wed, 30 Nov 2016 21:15:53 +0100
parents fabbe1759cec
children fe7e3524e571
comparison
equal deleted inserted replaced
43:fabbe1759cec 44:f30c84b4b9ed
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 "Javascript Rectangle"
20 #include <boost/test/unit_test.hpp>
20 21
21 #include <malikania/js_rectangle.hpp> 22 #include <malikania/js_rectangle.hpp>
22 23
23 class TestRectangle : public testing::Test { 24 class test_rectangle {
24 protected: 25 protected:
25 UniqueContext m_ctx; 26 UniqueContext m_ctx;
26 27
27 public: 28 public:
28 TestRectangle() 29 test_rectangle()
29 { 30 {
30 duk_push_object(m_ctx); 31 duk_push_object(m_ctx);
31 duk_put_global_string(m_ctx, "Malikania"); 32 duk_put_global_string(m_ctx, "Malikania");
32 mlk::dukx_load_rect(m_ctx); 33 mlk::dukx_load_rect(m_ctx);
33 } 34 }
34 }; 35 };
35 36
37 BOOST_FIXTURE_TEST_SUITE(test_rectangle_suite, test_rectangle)
38
36 /* 39 /*
37 * Valid constructors 40 * Valid constructors
38 * ------------------------------------------------------------------ 41 * ------------------------------------------------------------------
39 */ 42 */
40 43
41 TEST_F(TestRectangle, ConstructorNoArgs) 44 BOOST_AUTO_TEST_CASE(ConstructorNoArgs)
42 { 45 {
43 try { 46 try {
44 auto ret = duk_peval_string(m_ctx, 47 auto ret = duk_peval_string(m_ctx,
45 "r = Malikania.Rectangle();" 48 "r = Malikania.Rectangle();"
46 "x = r.x;" 49 "x = r.x;"
52 if (ret != 0) { 55 if (ret != 0) {
53 throw dukx_exception(m_ctx, -1); 56 throw dukx_exception(m_ctx, -1);
54 } 57 }
55 58
56 duk_get_global_string(m_ctx, "x"); 59 duk_get_global_string(m_ctx, "x");
57 ASSERT_EQ(0, duk_to_int(m_ctx, -1)); 60 BOOST_REQUIRE_EQUAL(0, duk_to_int(m_ctx, -1));
58 duk_pop(m_ctx); 61 duk_pop(m_ctx);
59 duk_get_global_string(m_ctx, "y"); 62 duk_get_global_string(m_ctx, "y");
60 ASSERT_EQ(0, duk_to_int(m_ctx, -1)); 63 BOOST_REQUIRE_EQUAL(0, duk_to_int(m_ctx, -1));
61 duk_pop(m_ctx); 64 duk_pop(m_ctx);
62 duk_get_global_string(m_ctx, "w"); 65 duk_get_global_string(m_ctx, "w");
63 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1)); 66 BOOST_REQUIRE_EQUAL(0U, duk_to_uint(m_ctx, -1));
64 duk_pop(m_ctx); 67 duk_pop(m_ctx);
65 duk_get_global_string(m_ctx, "h"); 68 duk_get_global_string(m_ctx, "h");
66 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1)); 69 BOOST_REQUIRE_EQUAL(0U, duk_to_uint(m_ctx, -1));
67 duk_pop(m_ctx); 70 duk_pop(m_ctx);
68 } catch (const std::exception &ex) { 71 } catch (const std::exception &ex) {
69 FAIL() << ex.what(); 72 BOOST_FAIL(ex.what());
70 } 73 }
71 } 74 }
72 75
73 TEST_F(TestRectangle, Constructor4Args) 76 BOOST_AUTO_TEST_CASE(Constructor4Args)
74 { 77 {
75 try { 78 try {
76 auto ret = duk_peval_string(m_ctx, 79 auto ret = duk_peval_string(m_ctx,
77 "r = Malikania.Rectangle(10, 20, 30, 40);" 80 "r = Malikania.Rectangle(10, 20, 30, 40);"
78 "x = r.x;" 81 "x = r.x;"
84 if (ret != 0) { 87 if (ret != 0) {
85 throw dukx_exception(m_ctx, -1); 88 throw dukx_exception(m_ctx, -1);
86 } 89 }
87 90
88 duk_get_global_string(m_ctx, "x"); 91 duk_get_global_string(m_ctx, "x");
89 ASSERT_EQ(10, duk_to_int(m_ctx, -1)); 92 BOOST_REQUIRE_EQUAL(10, duk_to_int(m_ctx, -1));
90 duk_pop(m_ctx); 93 duk_pop(m_ctx);
91 duk_get_global_string(m_ctx, "y"); 94 duk_get_global_string(m_ctx, "y");
92 ASSERT_EQ(20, duk_to_int(m_ctx, -1)); 95 BOOST_REQUIRE_EQUAL(20, duk_to_int(m_ctx, -1));
93 duk_pop(m_ctx); 96 duk_pop(m_ctx);
94 duk_get_global_string(m_ctx, "w"); 97 duk_get_global_string(m_ctx, "w");
95 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1)); 98 BOOST_REQUIRE_EQUAL(30U, duk_to_uint(m_ctx, -1));
96 duk_pop(m_ctx); 99 duk_pop(m_ctx);
97 duk_get_global_string(m_ctx, "h"); 100 duk_get_global_string(m_ctx, "h");
98 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1)); 101 BOOST_REQUIRE_EQUAL(40U, duk_to_uint(m_ctx, -1));
99 duk_pop(m_ctx); 102 duk_pop(m_ctx);
100 } catch (const std::exception &ex) { 103 } catch (const std::exception &ex) {
101 FAIL() << ex.what(); 104 BOOST_FAIL(ex.what());
102 } 105 }
103 } 106 }
104 107
105 TEST_F(TestRectangle, ConstructorObject) 108 BOOST_AUTO_TEST_CASE(ConstructorObject)
106 { 109 {
107 try { 110 try {
108 auto ret = duk_peval_string(m_ctx, 111 auto ret = duk_peval_string(m_ctx,
109 "r = Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });" 112 "r = Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });"
110 "x = r.x;" 113 "x = r.x;"
116 if (ret != 0) { 119 if (ret != 0) {
117 throw dukx_exception(m_ctx, -1); 120 throw dukx_exception(m_ctx, -1);
118 } 121 }
119 122
120 duk_get_global_string(m_ctx, "x"); 123 duk_get_global_string(m_ctx, "x");
121 ASSERT_EQ(10, duk_to_int(m_ctx, -1)); 124 BOOST_REQUIRE_EQUAL(10, duk_to_int(m_ctx, -1));
122 duk_pop(m_ctx); 125 duk_pop(m_ctx);
123 duk_get_global_string(m_ctx, "y"); 126 duk_get_global_string(m_ctx, "y");
124 ASSERT_EQ(20, duk_to_int(m_ctx, -1)); 127 BOOST_REQUIRE_EQUAL(20, duk_to_int(m_ctx, -1));
125 duk_pop(m_ctx); 128 duk_pop(m_ctx);
126 duk_get_global_string(m_ctx, "w"); 129 duk_get_global_string(m_ctx, "w");
127 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1)); 130 BOOST_REQUIRE_EQUAL(30U, duk_to_uint(m_ctx, -1));
128 duk_pop(m_ctx); 131 duk_pop(m_ctx);
129 duk_get_global_string(m_ctx, "h"); 132 duk_get_global_string(m_ctx, "h");
130 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1)); 133 BOOST_REQUIRE_EQUAL(40U, duk_to_uint(m_ctx, -1));
131 duk_pop(m_ctx); 134 duk_pop(m_ctx);
132 } catch (const std::exception &ex) { 135 } catch (const std::exception &ex) {
133 FAIL() << ex.what(); 136 BOOST_FAIL(ex.what());
134 } 137 }
135 } 138 }
136 139
137 TEST_F(TestRectangle, ConstructorNew) 140 BOOST_AUTO_TEST_CASE(ConstructorNew)
138 { 141 {
139 try { 142 try {
140 auto ret = duk_peval_string(m_ctx, 143 auto ret = duk_peval_string(m_ctx,
141 "r = new Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });" 144 "r = new Malikania.Rectangle({ x: 10, y: 20, width: 30, height: 40 });"
142 "x = r.x;" 145 "x = r.x;"
148 if (ret != 0) { 151 if (ret != 0) {
149 throw dukx_exception(m_ctx, -1); 152 throw dukx_exception(m_ctx, -1);
150 } 153 }
151 154
152 duk_get_global_string(m_ctx, "x"); 155 duk_get_global_string(m_ctx, "x");
153 ASSERT_EQ(10, duk_to_int(m_ctx, -1)); 156 BOOST_REQUIRE_EQUAL(10, duk_to_int(m_ctx, -1));
154 duk_pop(m_ctx); 157 duk_pop(m_ctx);
155 duk_get_global_string(m_ctx, "y"); 158 duk_get_global_string(m_ctx, "y");
156 ASSERT_EQ(20, duk_to_int(m_ctx, -1)); 159 BOOST_REQUIRE_EQUAL(20, duk_to_int(m_ctx, -1));
157 duk_pop(m_ctx); 160 duk_pop(m_ctx);
158 duk_get_global_string(m_ctx, "w"); 161 duk_get_global_string(m_ctx, "w");
159 ASSERT_EQ(30U, duk_to_uint(m_ctx, -1)); 162 BOOST_REQUIRE_EQUAL(30U, duk_to_uint(m_ctx, -1));
160 duk_pop(m_ctx); 163 duk_pop(m_ctx);
161 duk_get_global_string(m_ctx, "h"); 164 duk_get_global_string(m_ctx, "h");
162 ASSERT_EQ(40U, duk_to_uint(m_ctx, -1)); 165 BOOST_REQUIRE_EQUAL(40U, duk_to_uint(m_ctx, -1));
163 duk_pop(m_ctx); 166 duk_pop(m_ctx);
164 } catch (const std::exception &ex) { 167 } catch (const std::exception &ex) {
165 FAIL() << ex.what(); 168 BOOST_FAIL(ex.what());
166 } 169 }
167 } 170 }
168 171
169 /* 172 /*
170 * Invalid constructors 173 * Invalid constructors
171 * ------------------------------------------------------------------ 174 * ------------------------------------------------------------------
172 */ 175 */
173 176
174 TEST_F(TestRectangle, InvalidConstructorArg1) 177 BOOST_AUTO_TEST_CASE(InvalidConstructorArg1)
175 { 178 {
176 try { 179 try {
177 auto ret = duk_peval_string(m_ctx, 180 auto ret = duk_peval_string(m_ctx,
178 "try {" 181 "try {"
179 " Malikania.Rectangle(null);" 182 " Malikania.Rectangle(null);"
186 if (ret != 0) { 189 if (ret != 0) {
187 throw dukx_exception(m_ctx, -1); 190 throw dukx_exception(m_ctx, -1);
188 } 191 }
189 192
190 duk_get_global_string(m_ctx, "name"); 193 duk_get_global_string(m_ctx, "name");
191 ASSERT_STREQ("TypeError", duk_to_string(m_ctx, -1)); 194 BOOST_REQUIRE_EQUAL("TypeError", duk_to_string(m_ctx, -1));
192 duk_pop(m_ctx); 195 duk_pop(m_ctx);
193 duk_get_global_string(m_ctx, "correct"); 196 duk_get_global_string(m_ctx, "correct");
194 ASSERT_TRUE(duk_to_boolean(m_ctx, -1)); 197 BOOST_REQUIRE(duk_to_boolean(m_ctx, -1));
195 duk_pop(m_ctx); 198 duk_pop(m_ctx);
196 } catch (const std::exception &ex) { 199 } catch (const std::exception &ex) {
197 FAIL() << ex.what(); 200 BOOST_FAIL(ex.what());
198 } 201 }
199 } 202 }
200 203
201 TEST_F(TestRectangle, InvalidConstructorRange1) 204 BOOST_AUTO_TEST_CASE(InvalidConstructorRange1)
202 { 205 {
203 try { 206 try {
204 auto ret = duk_peval_string(m_ctx, 207 auto ret = duk_peval_string(m_ctx,
205 "try {" 208 "try {"
206 " Malikania.Rectangle(0, 0, -10, -10);" 209 " Malikania.Rectangle(0, 0, -10, -10);"
213 if (ret != 0) { 216 if (ret != 0) {
214 throw dukx_exception(m_ctx, -1); 217 throw dukx_exception(m_ctx, -1);
215 } 218 }
216 219
217 duk_get_global_string(m_ctx, "name"); 220 duk_get_global_string(m_ctx, "name");
218 ASSERT_STREQ("RangeError", duk_to_string(m_ctx, -1)); 221 BOOST_REQUIRE_EQUAL("RangeError", duk_to_string(m_ctx, -1));
219 duk_pop(m_ctx); 222 duk_pop(m_ctx);
220 duk_get_global_string(m_ctx, "correct"); 223 duk_get_global_string(m_ctx, "correct");
221 ASSERT_TRUE(duk_to_boolean(m_ctx, -1)); 224 BOOST_REQUIRE(duk_to_boolean(m_ctx, -1));
222 duk_pop(m_ctx); 225 duk_pop(m_ctx);
223 } catch (const std::exception &ex) { 226 } catch (const std::exception &ex) {
224 FAIL() << ex.what(); 227 BOOST_FAIL(ex.what());
225 } 228 }
226 } 229 }
227 230
228 /* 231 /*
229 * Require. 232 * Require.
230 * ------------------------------------------------------------------ 233 * ------------------------------------------------------------------
231 */ 234 */
232 235
233 TEST_F(TestRectangle, requireSuccess) 236 BOOST_AUTO_TEST_CASE(requireSuccess)
234 { 237 {
235 try { 238 try {
236 duk_push_c_function(m_ctx, [] (auto ctx) { 239 duk_push_c_function(m_ctx, [] (auto ctx) {
237 auto rect = mlk::dukx_require_rect(ctx, 0); 240 auto rect = mlk::dukx_require_rect(ctx, 0);
238 241
254 if (ret != 0) { 257 if (ret != 0) {
255 throw dukx_exception(m_ctx, -1); 258 throw dukx_exception(m_ctx, -1);
256 } 259 }
257 260
258 duk_get_global_string(m_ctx, "x"); 261 duk_get_global_string(m_ctx, "x");
259 ASSERT_EQ(50, duk_to_int(m_ctx, -1)); 262 BOOST_REQUIRE_EQUAL(50, duk_to_int(m_ctx, -1));
260 duk_pop(m_ctx); 263 duk_pop(m_ctx);
261 duk_get_global_string(m_ctx, "y"); 264 duk_get_global_string(m_ctx, "y");
262 ASSERT_EQ(80, duk_to_int(m_ctx, -1)); 265 BOOST_REQUIRE_EQUAL(80, duk_to_int(m_ctx, -1));
263 duk_pop(m_ctx); 266 duk_pop(m_ctx);
264 duk_get_global_string(m_ctx, "w"); 267 duk_get_global_string(m_ctx, "w");
265 ASSERT_EQ(100U, duk_to_uint(m_ctx, -1)); 268 BOOST_REQUIRE_EQUAL(100U, duk_to_uint(m_ctx, -1));
266 duk_pop(m_ctx); 269 duk_pop(m_ctx);
267 duk_get_global_string(m_ctx, "h"); 270 duk_get_global_string(m_ctx, "h");
268 ASSERT_EQ(200U, duk_to_uint(m_ctx, -1)); 271 BOOST_REQUIRE_EQUAL(200U, duk_to_uint(m_ctx, -1));
269 duk_pop(m_ctx); 272 duk_pop(m_ctx);
270 } catch (const std::exception &ex) { 273 } catch (const std::exception &ex) {
271 FAIL() << ex.what(); 274 BOOST_FAIL(ex.what());
272 } 275 }
273 } 276 }
274 277
275 TEST_F(TestRectangle, requireFail) 278 BOOST_AUTO_TEST_CASE(requireFail)
276 { 279 {
277 try { 280 try {
278 duk_push_c_function(m_ctx, [] (auto ctx) { 281 duk_push_c_function(m_ctx, [] (auto ctx) {
279 mlk::dukx_require_rect(ctx, 0); 282 mlk::dukx_require_rect(ctx, 0);
280 283
294 if (ret != 0) { 297 if (ret != 0) {
295 throw dukx_exception(m_ctx, -1); 298 throw dukx_exception(m_ctx, -1);
296 } 299 }
297 300
298 duk_get_global_string(m_ctx, "name"); 301 duk_get_global_string(m_ctx, "name");
299 ASSERT_STREQ("Error", duk_to_string(m_ctx, -1)); 302 BOOST_REQUIRE_EQUAL("Error", duk_to_string(m_ctx, -1));
300 duk_pop(m_ctx); 303 duk_pop(m_ctx);
301 duk_get_global_string(m_ctx, "correct"); 304 duk_get_global_string(m_ctx, "correct");
302 ASSERT_TRUE(duk_to_boolean(m_ctx, -1)); 305 BOOST_REQUIRE(duk_to_boolean(m_ctx, -1));
303 duk_pop(m_ctx); 306 duk_pop(m_ctx);
304 } catch (const std::exception &ex) { 307 } catch (const std::exception &ex) {
305 FAIL() << ex.what(); 308 BOOST_FAIL(ex.what());
306 } 309 }
307 } 310 }
308 311
309 /* 312 /*
310 * Get. 313 * Get.
311 * ------------------------------------------------------------------ 314 * ------------------------------------------------------------------
312 */ 315 */
313 316
314 TEST_F(TestRectangle, getAdjustAll) 317 BOOST_AUTO_TEST_CASE(getAdjustAll)
315 { 318 {
316 try { 319 try {
317 duk_push_c_function(m_ctx, [] (auto ctx) { 320 duk_push_c_function(m_ctx, [] (auto ctx) {
318 auto rect = mlk::dukx_get_rect(ctx, 0); 321 auto rect = mlk::dukx_get_rect(ctx, 0);
319 322
334 if (ret != 0) { 337 if (ret != 0) {
335 throw dukx_exception(m_ctx, -1); 338 throw dukx_exception(m_ctx, -1);
336 } 339 }
337 340
338 duk_get_global_string(m_ctx, "x"); 341 duk_get_global_string(m_ctx, "x");
339 ASSERT_EQ(0, duk_to_int(m_ctx, -1)); 342 BOOST_REQUIRE_EQUAL(0, duk_to_int(m_ctx, -1));
340 duk_pop(m_ctx); 343 duk_pop(m_ctx);
341 duk_get_global_string(m_ctx, "y"); 344 duk_get_global_string(m_ctx, "y");
342 ASSERT_EQ(0, duk_to_int(m_ctx, -1)); 345 BOOST_REQUIRE_EQUAL(0, duk_to_int(m_ctx, -1));
343 duk_pop(m_ctx); 346 duk_pop(m_ctx);
344 duk_get_global_string(m_ctx, "w"); 347 duk_get_global_string(m_ctx, "w");
345 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1)); 348 BOOST_REQUIRE_EQUAL(0U, duk_to_uint(m_ctx, -1));
346 duk_pop(m_ctx); 349 duk_pop(m_ctx);
347 duk_get_global_string(m_ctx, "h"); 350 duk_get_global_string(m_ctx, "h");
348 ASSERT_EQ(0U, duk_to_uint(m_ctx, -1)); 351 BOOST_REQUIRE_EQUAL(0U, duk_to_uint(m_ctx, -1));
349 duk_pop(m_ctx); 352 duk_pop(m_ctx);
350 } catch (const std::exception &ex) { 353 } catch (const std::exception &ex) {
351 FAIL() << ex.what(); 354 BOOST_FAIL(ex.what());
352 } 355 }
353 } 356 }
354 357
355 int main(int argc, char **argv) 358 BOOST_AUTO_TEST_SUITE_END()
356 {
357 testing::InitGoogleTest(&argc, argv);
358
359 return RUN_ALL_TESTS();
360 }