1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * Copyright (C) 2008-2011 Kouhei Sutou <kou@clear-code.com>
4 *
5 * This library is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 */
19
20 #include <gcutter.h>
21 #include <cutter/cut-stream-parser.h>
22 #include <cutter/cut-backtrace-entry.h>
23 #include "../lib/cuttest-event-receiver.h"
24
25 void test_start_run (void);
26 void test_ready_test_suite (void);
27 void test_start_test_suite (void);
28 void test_ready_test_case (void);
29 void test_start_test_case (void);
30 void test_ready_test_iterator (void);
31 void test_start_test_iterator (void);
32 void test_start_test (void);
33 void test_start_test_with_multiple_option_names (void);
34 void test_start_iterated_test (void);
35 void test_result_error (void);
36 void test_result_iterated_test (void);
37 void test_result_test_iterator (void);
38 void test_result_test_case (void);
39 void test_pass_assertion_test (void);
40 void test_pass_assertion_iterated_test (void);
41 void test_fail_assertion_test (void);
42 void test_complete_iterated_test (void);
43 void test_complete_test (void);
44 void test_complete_test_iterator (void);
45 void test_complete_test_case (void);
46 void test_complete_test_suite (void);
47 void test_complete_run_without_success_tag (void);
48 void test_complete_run_with_success_true (void);
49 void test_complete_run_with_success_false (void);
50 void test_crash_test (void);
51
52 static CutStreamParser *parser;
53 static CutTestResult *result;
54 static CutRunContext *run_context;
55 static CuttestEventReceiver *receiver;
56
57 void
cut_setup(void)58 cut_setup (void)
59 {
60 run_context = cuttest_event_receiver_new();
61 receiver = CUTTEST_EVENT_RECEIVER(run_context);
62 parser = cut_stream_parser_new(run_context);
63 result = NULL;
64 }
65
66 void
cut_teardown(void)67 cut_teardown (void)
68 {
69 g_object_unref(receiver);
70 g_object_unref(parser);
71
72 if (result)
73 g_object_unref(result);
74 }
75
76 #define cut_assert_parse(string) do \
77 { \
78 GError *error = NULL; \
79 cut_stream_parser_parse(parser, (string), -1, &error); \
80 gcut_assert_error(error); \
81 } while (0)
82
83 #define cut_assert_parse_error(expected_message, string) do \
84 { \
85 GError *error = NULL; \
86 const GError *taken_error = NULL; \
87 cut_stream_parser_parse(parser, (string), -1, &error); \
88 cut_assert_not_null(error); \
89 taken_error = gcut_take_error(error); \
90 cut_assert_equal_string((expected_message), \
91 taken_error->message); \
92 } while (0)
93
94 static void
collect_result(CutStreamParser * parser,CutTestResult * test_result,gpointer user_data)95 collect_result (CutStreamParser *parser, CutTestResult *test_result,
96 gpointer user_data)
97 {
98 CutTestResult **data = (CutTestResult **)user_data;
99
100 g_object_ref(test_result);
101 *data = test_result;
102 }
103
104
105 void
test_start_run(void)106 test_start_run (void)
107 {
108 cut_assert_equal_int(0, receiver->n_start_runs);
109 cut_assert_true(cut_stream_parser_parse(parser, "<stream", -1, NULL));
110 cut_assert_equal_int(0, receiver->n_start_runs);
111 cut_assert_true(cut_stream_parser_parse(parser, ">", -1, NULL));
112 cut_assert_equal_int(1, receiver->n_start_runs);
113 }
114
115 void
test_ready_test_suite(void)116 test_ready_test_suite (void)
117 {
118 CuttestReadyTestSuiteInfo *info;
119 GTimeVal expected, actual;
120
121 cut_assert_parse("<stream>\n");
122 cut_assert_parse(" <ready-test-suite>\n");
123 cut_assert_parse(" <test-suite>\n");
124 cut_assert_parse(" <start-time>1970-01-01T00:00:00Z</start-time>\n");
125 cut_assert_parse(" </test-suite>\n");
126 cut_assert_parse(" <n-test-cases>3</n-test-cases>\n");
127 cut_assert_parse(" <n-tests>7</n-tests>\n");
128
129 cut_assert_null(receiver->ready_test_suites);
130 cut_assert_parse(" </ready-test-suite>");
131 cut_assert_equal_int(1, g_list_length(receiver->ready_test_suites));
132
133 info = receiver->ready_test_suites->data;
134
135 cut_assert_not_null(info->test_suite);
136 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(info->test_suite)));
137
138 expected.tv_sec = 0;
139 expected.tv_usec = 0;
140 cut_test_get_start_time(CUT_TEST(info->test_suite), &actual);
141 gcut_assert_equal_time_val(&expected, &actual);
142
143 cut_assert_equal_int(3, info->n_test_cases);
144 cut_assert_equal_int(7, info->n_tests);
145 }
146
147 void
test_start_test_suite(void)148 test_start_test_suite (void)
149 {
150 CutTestSuite *test_suite;
151 gchar header[] =
152 "<stream>\n"
153 " <ready-test-suite>\n"
154 " <test-suite>\n"
155 " </test-suite>\n"
156 " <n-test-cases>3</n-test-cases>\n"
157 " <n-tests>7</n-tests>\n"
158 " </ready-test-suite>\n";
159 gchar start_test_suite[] =
160 " <start-test-suite>\n"
161 " <test-suite>\n"
162 " </test-suite>\n"
163 " </start-test-suite>\n";
164
165 cut_assert_parse(header);
166 cut_assert_null(receiver->start_test_suites);
167
168 cut_assert_parse(start_test_suite);
169 cut_assert_equal_int(1, g_list_length(receiver->start_test_suites));
170
171 test_suite = receiver->start_test_suites->data;
172 cut_assert_not_null(test_suite);
173 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
174 }
175
176 void
test_ready_test_case(void)177 test_ready_test_case (void)
178 {
179 CuttestReadyTestCaseInfo *info;
180 gchar header[] =
181 "<stream>\n"
182 " <ready-test-suite>\n"
183 " <test-suite>\n"
184 " </test-suite>\n"
185 " <n-test-cases>3</n-test-cases>\n"
186 " <n-tests>7</n-tests>\n"
187 " </ready-test-suite>\n"
188 " <start-test-suite>\n"
189 " <test-suite>\n"
190 " </test-suite>\n"
191 " </start-test-suite>\n";
192 gchar ready_test_case[] =
193 " <ready-test-case>\n"
194 " <test-case>\n"
195 " <name>my test case</name>\n"
196 " </test-case>\n"
197 " <n-tests>2</n-tests>\n"
198 " </ready-test-case>\n";
199
200 cut_assert_parse(header);
201 cut_assert_null(receiver->ready_test_cases);
202
203 cut_assert_parse(ready_test_case);
204 cut_assert_equal_int(1, g_list_length(receiver->ready_test_cases));
205
206 info = receiver->ready_test_cases->data;
207 cut_assert_not_null(info->test_case);
208 cut_assert_equal_string("my test case",
209 cut_test_get_name(CUT_TEST(info->test_case)));
210 cut_assert_equal_int(2, info->n_tests);
211 }
212
213 void
test_start_test_case(void)214 test_start_test_case (void)
215 {
216 CutTestCase *test_case;
217 gchar header[] =
218 "<stream>\n"
219 " <ready-test-suite>\n"
220 " <test-suite>\n"
221 " </test-suite>\n"
222 " <n-test-cases>3</n-test-cases>\n"
223 " <n-tests>7</n-tests>\n"
224 " </ready-test-suite>\n"
225 " <start-test-suite>\n"
226 " <test-suite>\n"
227 " </test-suite>\n"
228 " </start-test-suite>\n"
229 " <ready-test-case>\n"
230 " <test-case>\n"
231 " <name>my test case</name>\n"
232 " </test-case>\n"
233 " <n-tests>2</n-tests>\n"
234 " </ready-test-case>\n";
235 gchar start_test_case[] =
236 " <start-test-case>\n"
237 " <test-case>\n"
238 " <name>my test case</name>\n"
239 " </test-case>\n"
240 " </start-test-case>\n";
241
242 cut_assert_parse(header);
243 cut_assert_null(receiver->start_test_cases);
244
245 cut_assert_parse(start_test_case);
246 cut_assert_equal_int(1, g_list_length(receiver->start_test_cases));
247
248 test_case = receiver->start_test_cases->data;
249 cut_assert_not_null(test_case);
250 cut_assert_equal_string("my test case",
251 cut_test_get_name(CUT_TEST(test_case)));
252 }
253
254 void
test_ready_test_iterator(void)255 test_ready_test_iterator (void)
256 {
257 CuttestReadyTestIteratorInfo *info;
258 gchar header[] =
259 "<stream>\n"
260 " <ready-test-suite>\n"
261 " <test-suite>\n"
262 " </test-suite>\n"
263 " <n-test-cases>3</n-test-cases>\n"
264 " <n-tests>7</n-tests>\n"
265 " </ready-test-suite>\n"
266 " <start-test-suite>\n"
267 " <test-suite>\n"
268 " </test-suite>\n"
269 " </start-test-suite>\n"
270 " <ready-test-case>\n"
271 " <test-case>\n"
272 " <name>my test case</name>\n"
273 " </test-case>\n"
274 " <n-tests>2</n-tests>\n"
275 " </ready-test-case>\n"
276 " <start-test-case>\n"
277 " <test-case>\n"
278 " <name>my test case</name>\n"
279 " </test-case>\n"
280 " </start-test-case>\n";
281 gchar ready_test_iterator[] =
282 " <ready-test-iterator>\n"
283 " <test-iterator>\n"
284 " <name>my test iterator</name>\n"
285 " </test-iterator>\n"
286 " <n-tests>5</n-tests>\n"
287 " </ready-test-iterator>\n";
288
289 cut_assert_parse(header);
290 cut_assert_null(receiver->ready_test_iterators);
291
292 cut_assert_parse(ready_test_iterator);
293 cut_assert_equal_int(1, g_list_length(receiver->ready_test_iterators));
294
295 info = receiver->ready_test_iterators->data;
296 cut_assert_not_null(info->test_iterator);
297 cut_assert_equal_string("my test iterator",
298 cut_test_get_name(CUT_TEST(info->test_iterator)));
299 cut_assert_equal_uint(5, info->n_tests);
300 }
301
302 void
test_start_test_iterator(void)303 test_start_test_iterator (void)
304 {
305 CutTestIterator *test_iterator;
306 gchar header[] =
307 "<stream>\n"
308 " <ready-test-suite>\n"
309 " <test-suite>\n"
310 " </test-suite>\n"
311 " <n-test-cases>3</n-test-cases>\n"
312 " <n-tests>7</n-tests>\n"
313 " </ready-test-suite>\n"
314 " <start-test-suite>\n"
315 " <test-suite>\n"
316 " </test-suite>\n"
317 " </start-test-suite>\n"
318 " <ready-test-case>\n"
319 " <test-case>\n"
320 " <name>my test case</name>\n"
321 " </test-case>\n"
322 " <n-tests>2</n-tests>\n"
323 " </ready-test-case>\n"
324 " <start-test-case>\n"
325 " <test-case>\n"
326 " <name>my test case</name>\n"
327 " </test-case>\n"
328 " </start-test-case>\n"
329 " <ready-test-iterator>\n"
330 " <test-iterator>\n"
331 " <name>my test iterator</name>\n"
332 " </test-iterator>\n"
333 " <n-tests>5</n-tests>\n"
334 " </ready-test-iterator>\n";
335 gchar start_test_iterator[] =
336 " <start-test-iterator>\n"
337 " <test-iterator>\n"
338 " <name>my test iterator</name>\n"
339 " </test-iterator>\n"
340 " </start-test-iterator>\n";
341
342 cut_assert_parse(header);
343 cut_assert_null(receiver->start_test_iterators);
344
345 cut_assert_parse(start_test_iterator);
346 cut_assert_equal_int(1, g_list_length(receiver->start_test_iterators));
347
348 test_iterator = receiver->start_test_iterators->data;
349 cut_assert_not_null(test_iterator);
350 cut_assert_equal_string("my test iterator",
351 cut_test_get_name(CUT_TEST(test_iterator)));
352 }
353
354 void
test_start_test(void)355 test_start_test (void)
356 {
357 CuttestStartTestInfo *info;
358 CutTestContext *context;
359 CutTestSuite *test_suite;
360 CutTestCase *test_case;
361 CutTest *test;
362 gchar header[] =
363 "<stream>\n"
364 " <ready-test-suite>\n"
365 " <test-suite>\n"
366 " </test-suite>\n"
367 " <n-test-cases>3</n-test-cases>\n"
368 " <n-tests>7</n-tests>\n"
369 " </ready-test-suite>\n"
370 " <start-test-suite>\n"
371 " <test-suite>\n"
372 " </test-suite>\n"
373 " </start-test-suite>\n"
374 " <ready-test-case>\n"
375 " <test-case>\n"
376 " <name>my test case</name>\n"
377 " </test-case>\n"
378 " <n-tests>2</n-tests>\n"
379 " </ready-test-case>\n"
380 " <start-test-case>\n"
381 " <test-case>\n"
382 " <name>my test case</name>\n"
383 " </test-case>\n"
384 " </start-test-case>\n";
385 gchar start_test[] =
386 " <start-test>\n"
387 " <test>\n"
388 " <name>my test</name>\n"
389 " </test>\n"
390 " <test-context>\n"
391 " <test-suite>\n"
392 " </test-suite>\n"
393 " <test-case>\n"
394 " <name>my test case</name>\n"
395 " </test-case>\n"
396 " <test>\n"
397 " <name>my test</name>\n"
398 " </test>\n"
399 " <failed>FALSE</failed>\n"
400 " </test-context>\n"
401 " </start-test>\n";
402
403 cut_assert_parse(header);
404 cut_assert_null(receiver->start_tests);
405
406 cut_assert_parse(start_test);
407 cut_assert_equal_int(1, g_list_length(receiver->start_tests));
408
409 info = receiver->start_tests->data;
410 cut_assert_not_null(info);
411
412 cut_assert_not_null(info->test);
413 cut_assert_equal_string("my test", cut_test_get_name(CUT_TEST(info->test)));
414
415 context = info->test_context;
416 cut_assert_not_null(context);
417 cut_assert_false(cut_test_context_is_failed(context));
418
419 test_suite = cut_test_context_get_test_suite(context);
420 cut_assert_not_null(test_suite);
421 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
422
423 test_case = cut_test_context_get_test_case(context);
424 cut_assert_not_null(test_case);
425 cut_assert_equal_string("my test case",
426 cut_test_get_name(CUT_TEST(test_case)));
427
428 test = cut_test_context_get_test(context);
429 cut_assert_not_null(test);
430 cut_assert_equal_string("my test", cut_test_get_name(test));
431
432 cut_assert_false(cut_test_context_have_data(context));
433 }
434
435 void
test_start_test_with_multiple_option_names(void)436 test_start_test_with_multiple_option_names (void)
437 {
438 gchar header[] =
439 "<stream>\n"
440 " <ready-test-suite>\n"
441 " <test-suite>\n"
442 " </test-suite>\n"
443 " <n-test-cases>3</n-test-cases>\n"
444 " <n-tests>7</n-tests>\n"
445 " </ready-test-suite>\n"
446 " <start-test-suite>\n"
447 " <test-suite>\n"
448 " </test-suite>\n"
449 " </start-test-suite>\n"
450 " <ready-test-case>\n"
451 " <test-case>\n"
452 " <name>my test case</name>\n"
453 " </test-case>\n"
454 " <n-tests>2</n-tests>\n"
455 " </ready-test-case>\n"
456 " <start-test-case>\n"
457 " <test-case>\n"
458 " <name>my test case</name>\n"
459 " </test-case>\n"
460 " </start-test-case>\n";
461 gchar start_test[] =
462 " <start-test>\n"
463 " <test>\n"
464 " <name>my test</name>\n"
465 " <option>\n"
466 " <name>name1</name>\n"
467 " <name>name2</name>\n"
468 " <value>value</value>\n"
469 " </option>\n"
470 " </test>\n"
471 " <test-context>\n"
472 " <test-suite>\n"
473 " </test-suite>\n"
474 " <test-case>\n"
475 " <name>my test case</name>\n"
476 " </test-case>\n"
477 " <test>\n"
478 " <name>my test</name>\n"
479 " </test>\n"
480 " <failed>FALSE</failed>\n"
481 " </test-context>\n"
482 " </start-test>\n";
483
484 cut_assert_parse(header);
485 cut_assert_null(receiver->start_tests);
486
487 cut_assert_parse_error("Error on line 28 char 21: "
488 "/stream/start-test/test/option/name: "
489 "multiple option name: name2",
490 start_test);
491 }
492
493 void
test_start_iterated_test(void)494 test_start_iterated_test (void)
495 {
496 CuttestStartIteratedTestInfo *info;
497 CutTestData *test_data;
498 CutTestContext *context;
499 CutTestSuite *test_suite;
500 CutTestCase *test_case;
501 CutTestIterator *test_iterator;
502 CutIteratedTest *iterated_test;
503 gchar header[] =
504 "<stream>\n"
505 " <ready-test-suite>\n"
506 " <test-suite>\n"
507 " </test-suite>\n"
508 " <n-test-cases>3</n-test-cases>\n"
509 " <n-tests>7</n-tests>\n"
510 " </ready-test-suite>\n"
511 " <start-test-suite>\n"
512 " <test-suite>\n"
513 " </test-suite>\n"
514 " </start-test-suite>\n"
515 " <ready-test-case>\n"
516 " <test-case>\n"
517 " <name>my test case</name>\n"
518 " </test-case>\n"
519 " <n-tests>2</n-tests>\n"
520 " </ready-test-case>\n"
521 " <start-test-case>\n"
522 " <test-case>\n"
523 " <name>my test case</name>\n"
524 " </test-case>\n"
525 " </start-test-case>\n"
526 " <ready-test-iterator>\n"
527 " <test-iterator>\n"
528 " <name>my test iterator</name>\n"
529 " </test-iterator>\n"
530 " <n-tests>5</n-tests>\n"
531 " </ready-test-iterator>\n"
532 " <start-test-iterator>\n"
533 " <test-iterator>\n"
534 " <name>my test iterator</name>\n"
535 " </test-iterator>\n"
536 " </start-test-iterator>\n";
537 gchar start_iterated_test[] =
538 " <start-iterated-test>\n"
539 " <iterated-test>\n"
540 " <name>my iterated test</name>\n"
541 " </iterated-test>\n"
542 " <test-context>\n"
543 " <test-suite>\n"
544 " </test-suite>\n"
545 " <test-case>\n"
546 " <name>my test case</name>\n"
547 " </test-case>\n"
548 " <test-iterator>\n"
549 " <name>my test iterator</name>\n"
550 " </test-iterator>\n"
551 " <iterated-test>\n"
552 " <name>my iterated test</name>\n"
553 " </iterated-test>\n"
554 " <test-data>\n"
555 " <name>the first test data</name>\n"
556 " </test-data>\n"
557 " <failed>FALSE</failed>\n"
558 " </test-context>\n"
559 " </start-iterated-test>\n";
560
561 cut_assert_parse(header);
562 cut_assert_null(receiver->start_iterated_tests);
563
564 cut_assert_parse(start_iterated_test);
565 cut_assert_equal_int(1, g_list_length(receiver->start_iterated_tests));
566
567 info = receiver->start_iterated_tests->data;
568 cut_assert_not_null(info);
569
570 cut_assert_not_null(info->iterated_test);
571 cut_assert_equal_string("my iterated test",
572 cut_test_get_name(CUT_TEST(info->iterated_test)));
573
574 context = info->test_context;
575 cut_assert_not_null(context);
576
577 test_suite = cut_test_context_get_test_suite(context);
578 cut_assert_not_null(test_suite);
579 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
580
581 test_case = cut_test_context_get_test_case(context);
582 cut_assert_not_null(test_case);
583 cut_assert_equal_string("my test case",
584 cut_test_get_name(CUT_TEST(test_case)));
585
586 test_iterator = cut_test_context_get_test_iterator(context);
587 cut_assert_not_null(test_iterator);
588 cut_assert_equal_string("my test iterator",
589 cut_test_get_name(CUT_TEST(test_iterator)));
590
591 iterated_test = CUT_ITERATED_TEST(cut_test_context_get_test(context));
592 cut_assert_not_null(iterated_test);
593 cut_assert_equal_string("my iterated test",
594 cut_test_get_name(CUT_TEST(iterated_test)));
595
596 cut_assert_false(cut_test_context_is_failed(context));
597 cut_assert_true(cut_test_context_have_data(context));
598
599 test_data = cut_test_context_get_current_data(context);
600 cut_assert_not_null(test_data);
601 cut_assert_equal_string("the first test data",
602 cut_test_data_get_name(test_data));
603 }
604
605 void
test_result_error(void)606 test_result_error (void)
607 {
608 GTimeVal expected_start_time, actual_start_time;
609 CutTest *test;
610 const GList *actual_backtrace;
611 CutBacktraceEntry *entry;
612 const gchar xml[] =
613 "<stream>\n"
614 " <test-result>\n"
615 " <test>\n"
616 " <name>stub-error-test</name>\n"
617 " <description>Error Test</description>\n"
618 " <option>\n"
619 " <name>bug</name>\n"
620 " <value>1234</value>\n"
621 " </option>\n"
622 " </test>\n"
623 " <test-context>\n"
624 " <test-case>\n"
625 " <name>stub test case</name>\n"
626 " </test-case>\n"
627 " <test>\n"
628 " <name>stub-error-test</name>\n"
629 " <description>Error Test</description>\n"
630 " <option>\n"
631 " <name>bug</name>\n"
632 " <value>1234</value>\n"
633 " </option>\n"
634 " </test>\n"
635 " <failed>TRUE</failed>\n"
636 " </test-context>\n"
637 " <result>\n"
638 " <test-case>\n"
639 " <name>stub test case</name>\n"
640 " </test-case>\n"
641 " <test>\n"
642 " <name>stub-error-test</name>\n"
643 " <description>Error Test</description>\n"
644 " <option>\n"
645 " <name>bug</name>\n"
646 " <value>1234</value>\n"
647 " </option>\n"
648 " </test>\n"
649 " <status>error</status>\n"
650 " <detail>This test should error</detail>\n"
651 " <backtrace>\n"
652 " <entry>\n"
653 " <file>test-cut-report-xml.c</file>\n"
654 " <line>31</line>\n"
655 " <info>stub_error_test()</info>\n"
656 " </entry>\n"
657 " </backtrace>\n"
658 " <start-time>2008-07-29T05:16:40Z</start-time>\n"
659 " <elapsed>0.000100</elapsed>\n"
660 " </result>\n"
661 " </test-result>\n"
662 "</stream>\n";
663
664 g_signal_connect(parser, "result",
665 G_CALLBACK(collect_result), (gpointer)&result);
666
667 cut_assert_parse(xml);
668 cut_assert_not_null(result);
669
670 test = cut_test_result_get_test(result);
671 cut_assert(test);
672
673 cut_assert_equal_string("stub test case",
674 cut_test_result_get_test_case_name(result));
675 cut_assert_equal_string("stub-error-test",
676 cut_test_result_get_test_name(result));
677 cut_assert_equal_int(CUT_TEST_RESULT_ERROR,
678 cut_test_result_get_status(result));
679
680 expected_start_time.tv_sec = 1217308600;
681 expected_start_time.tv_usec = 0;
682 cut_test_result_get_start_time(result, &actual_start_time);
683 gcut_assert_equal_time_val(&expected_start_time, &actual_start_time);
684 cut_assert_equal_double(0.0001, 0.0, cut_test_result_get_elapsed(result));
685
686 actual_backtrace = cut_test_result_get_backtrace(result);
687 cut_assert_not_null(actual_backtrace);
688 entry = actual_backtrace->data;
689 cut_assert_equal_string("test-cut-report-xml.c",
690 cut_backtrace_entry_get_file(entry));
691 cut_assert_equal_uint(31, cut_backtrace_entry_get_line(entry));
692 cut_assert_equal_string("stub_error_test()",
693 cut_backtrace_entry_get_function(entry));
694
695 cut_assert_equal_string("This test should error",
696 cut_test_result_get_message(result));
697
698 cut_assert_equal_string("1234",
699 cut_test_get_attribute(test, "bug"));
700 cut_assert_equal_string("Error Test",
701 cut_test_get_description(test));
702 }
703
704 void
test_result_iterated_test(void)705 test_result_iterated_test (void)
706 {
707 GTimeVal expected_start_time, actual_start_time;
708 CutTest *test;
709 CutTestData *test_data;
710 const gchar xml[] =
711 "<stream>\n"
712 " <test-result>\n"
713 " <iterated-test>\n"
714 " <name>test_count</name>\n"
715 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
716 " <elapsed>0.028738</elapsed>\n"
717 " </iterated-test>\n"
718 " <test-context>\n"
719 " <test-case>\n"
720 " <name>test_cut_pipeline</name>\n"
721 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
722 " <elapsed>0.028738</elapsed>\n"
723 " </test-case>\n"
724 " <test-iterator>\n"
725 " <name>test_count</name>\n"
726 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
727 " <elapsed>0.028738</elapsed>\n"
728 " </test-iterator>\n"
729 " <iterated-test>\n"
730 " <name>test_count</name>\n"
731 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
732 " <elapsed>0.028738</elapsed>\n"
733 " </iterated-test>\n"
734 " <test-data>\n"
735 " <name>success</name>\n"
736 " </test-data>\n"
737 " <failed>FALSE</failed>\n"
738 " </test-context>\n"
739 " <result>\n"
740 " <test-case>\n"
741 " <name>test_cut_pipeline</name>\n"
742 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
743 " <elapsed>0.028738</elapsed>\n"
744 " </test-case>\n"
745 " <test-iterator>\n"
746 " <name>test_count</name>\n"
747 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
748 " <elapsed>0.028738</elapsed>\n"
749 " </test-iterator>\n"
750 " <iterated-test>\n"
751 " <name>test_count</name>\n"
752 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
753 " <elapsed>0.028738</elapsed>\n"
754 " </iterated-test>\n"
755 " <test-data>\n"
756 " <name>first data</name>\n"
757 " </test-data>\n"
758 " <status>success</status>\n"
759 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
760 " <elapsed>0.028738</elapsed>\n"
761 " </result>\n"
762 " </test-result>\n"
763 "</stream>\n";
764
765 g_signal_connect(parser, "result",
766 G_CALLBACK(collect_result), (gpointer)&result);
767
768 cut_assert_parse(xml);
769 cut_assert_not_null(result);
770
771 test = cut_test_result_get_test(result);
772 cut_assert(test);
773
774 cut_assert_equal_string("test_cut_pipeline",
775 cut_test_result_get_test_case_name(result));
776 cut_assert_equal_string("test_count",
777 cut_test_result_get_test_iterator_name(result));
778 test_data = cut_test_result_get_test_data(result);
779 cut_assert_not_null(test_data);
780 cut_assert_equal_string("first data", cut_test_data_get_name(test_data));
781 cut_assert_equal_int(CUT_TEST_RESULT_SUCCESS,
782 cut_test_result_get_status(result));
783
784 expected_start_time.tv_sec = 1217373749;
785 expected_start_time.tv_usec = 0;
786 cut_test_result_get_start_time(result, &actual_start_time);
787 gcut_assert_equal_time_val(&expected_start_time, &actual_start_time);
788 cut_assert_equal_double(0.028, 0.001, cut_test_result_get_elapsed(result));
789 }
790
791 void
test_result_test_iterator(void)792 test_result_test_iterator (void)
793 {
794 GTimeVal expected_start_time, actual_start_time;
795 CutTestIterator *test_iterator;
796 const gchar xml[] =
797 "<stream>\n"
798 " <test-iterator-result>\n"
799 " <test-iterator>\n"
800 " <name>test_count</name>\n"
801 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
802 " <elapsed>0.152822</elapsed>\n"
803 " </test-iterator>\n"
804 " <result>\n"
805 " <test-case>\n"
806 " <name>test_cut_pipeline</name>\n"
807 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
808 " <elapsed>0.152822</elapsed>\n"
809 " </test-case>\n"
810 " <test-iterator>\n"
811 " <name>test_count</name>\n"
812 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
813 " <elapsed>0.152822</elapsed>\n"
814 " </test-iterator>\n"
815 " <status>success</status>\n"
816 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
817 " <elapsed>0.152822</elapsed>\n"
818 " </result>\n"
819 " </test-iterator-result>\n"
820 "</stream>\n";
821
822 g_signal_connect(parser, "result",
823 G_CALLBACK(collect_result), (gpointer)&result);
824
825 cut_assert_parse(xml);
826 cut_assert_not_null(result);
827
828 test_iterator = cut_test_result_get_test_iterator(result);
829 cut_assert_not_null(test_iterator);
830
831 cut_assert_equal_string("test_count",
832 cut_test_get_name(CUT_TEST(test_iterator)));
833 cut_assert_equal_string("test_count",
834 cut_test_result_get_test_iterator_name(result));
835 cut_assert_equal_string("test_cut_pipeline",
836 cut_test_result_get_test_case_name(result));
837 cut_assert_equal_int(CUT_TEST_RESULT_SUCCESS,
838 cut_test_result_get_status(result));
839
840 expected_start_time.tv_sec = 1217373749;
841 expected_start_time.tv_usec = 0;
842 cut_test_result_get_start_time(result, &actual_start_time);
843 gcut_assert_equal_time_val(&expected_start_time, &actual_start_time);
844 cut_assert_equal_double(0.15, 0.01, cut_test_result_get_elapsed(result));
845 }
846
847 void
test_result_test_case(void)848 test_result_test_case (void)
849 {
850 GTimeVal expected_start_time, actual_start_time;
851 CutTestCase *test_case;
852 const gchar xml[] =
853 "<stream>\n"
854 " <test-case-result>\n"
855 " <test-case>\n"
856 " <name>test_cut_test_iterator</name>\n"
857 " <start-time>2008-07-29T23:22:28Z</start-time>\n"
858 " <elapsed>0.010663</elapsed>\n"
859 " </test-case>\n"
860 " <result>\n"
861 " <test-case>\n"
862 " <name>test_cut_test_iterator</name>\n"
863 " <start-time>2008-07-29T23:22:28Z</start-time>\n"
864 " <elapsed>0.010663</elapsed>\n"
865 " </test-case>\n"
866 " <status>success</status>\n"
867 " <start-time>2008-07-29T23:22:28Z</start-time>\n"
868 " <elapsed>0.010663</elapsed>\n"
869 " </result>\n"
870 " </test-case-result>\n"
871 "</stream>\n";
872
873 g_signal_connect(parser, "result",
874 G_CALLBACK(collect_result), (gpointer)&result);
875
876 cut_assert_parse(xml);
877 cut_assert_not_null(result);
878
879 test_case = cut_test_result_get_test_case(result);
880 cut_assert_not_null(test_case);
881
882 cut_assert_equal_string("test_cut_test_iterator",
883 cut_test_get_name(CUT_TEST(test_case)));
884 cut_assert_equal_string("test_cut_test_iterator",
885 cut_test_result_get_test_case_name(result));
886 cut_assert_equal_int(CUT_TEST_RESULT_SUCCESS,
887 cut_test_result_get_status(result));
888
889 expected_start_time.tv_sec = 1217373748;
890 expected_start_time.tv_usec = 0;
891 cut_test_result_get_start_time(result, &actual_start_time);
892 gcut_assert_equal_time_val(&expected_start_time, &actual_start_time);
893 cut_assert_equal_double(0.01, 0.001, cut_test_result_get_elapsed(result));
894 }
895
896 void
test_pass_assertion_test(void)897 test_pass_assertion_test (void)
898 {
899 CuttestPassAssertionInfo *info;
900 CutTest *test;
901 CutTestCase *test_case;
902 CutTestContext *test_context;
903 const gchar xml[] =
904 "<stream>\n"
905 " <ready-test-suite>\n"
906 " <test-suite>\n"
907 " <elapsed>0.000000</elapsed>\n"
908 " </test-suite>\n"
909 " <n-test-cases>34</n-test-cases>\n"
910 " <n-tests>236</n-tests>\n"
911 " </ready-test-suite>\n"
912 " <start-test-suite>\n"
913 " <test-suite>\n"
914 " <elapsed>0.000000</elapsed>\n"
915 " </test-suite>\n"
916 " </start-test-suite>\n"
917 " <ready-test-case>\n"
918 " <test-case>\n"
919 " <name>test_cut_test</name>\n"
920 " <elapsed>0.000000</elapsed>\n"
921 " </test-case>\n"
922 " <n-tests>13</n-tests>\n"
923 " </ready-test-case>\n"
924 " <start-test-case>\n"
925 " <test-case>\n"
926 " <name>test_cut_test</name>\n"
927 " <elapsed>0.000000</elapsed>\n"
928 " </test-case>\n"
929 " </start-test-case>\n"
930 " <start-test>\n"
931 " <test>\n"
932 " <name>test_error_signal</name>\n"
933 " <elapsed>0.000000</elapsed>\n"
934 " </test>\n"
935 " <test-context>\n"
936 " <test-case>\n"
937 " <name>test_cut_test</name>\n"
938 " <elapsed>0.000000</elapsed>\n"
939 " </test-case>\n"
940 " <failed>FALSE</failed>\n"
941 " </test-context>\n"
942 " </start-test>\n"
943 " <pass-assertion>\n"
944 " <test>\n"
945 " <name>test_error_signal</name>\n"
946 " <elapsed>0.000039</elapsed>\n"
947 " </test>\n"
948 " <test-context>\n"
949 " <test-case>\n"
950 " <name>test_cut_test</name>\n"
951 " <elapsed>0.000062</elapsed>\n"
952 " </test-case>\n"
953 " <test>\n"
954 " <name>test_error_signal</name>\n"
955 " <elapsed>0.000077</elapsed>\n"
956 " </test>\n"
957 " <failed>FALSE</failed>\n"
958 " </test-context>\n"
959 " </pass-assertion>\n"
960 " <test-result>\n"
961 " <test>\n"
962 " <name>test_error_signal</name>\n"
963 " <elapsed>0.000895</elapsed>\n"
964 " </test>\n"
965 " <test-context>\n"
966 " <test-case>\n"
967 " <name>test_cut_test</name>\n"
968 " <elapsed>0.000895</elapsed>\n"
969 " </test-case>\n"
970 " <test>\n"
971 " <name>test_error_signal</name>\n"
972 " <elapsed>0.000895</elapsed>\n"
973 " </test>\n"
974 " <failed>FALSE</failed>\n"
975 " </test-context>\n"
976 " <result>\n"
977 " <test-case>\n"
978 " <name>test_cut_test</name>\n"
979 " <elapsed>0.000895</elapsed>\n"
980 " </test-case>\n"
981 " <test>\n"
982 " <name>test_error_signal</name>\n"
983 " <elapsed>0.000895</elapsed>\n"
984 " </test>\n"
985 " <status>success</status>\n"
986 " <elapsed>0.000895</elapsed>\n"
987 " </result>\n"
988 " </test-result>\n"
989 " <complete-test>\n"
990 " <test>\n"
991 " <name>test_error_signal</name>\n"
992 " <elapsed>0.000895</elapsed>\n"
993 " </test>\n"
994 " </complete-test>\n"
995 " <complete-test-case>\n"
996 " <test-case>\n"
997 " <name>test_cut_test</name>\n"
998 " <elapsed>0.003745</elapsed>\n"
999 " </test-case>\n"
1000 " </complete-test-case>\n"
1001 " <complete-test-suite>\n"
1002 " <test-suite>\n"
1003 " <elapsed>139.666143</elapsed>\n"
1004 " </test-suite>\n"
1005 " </complete-test-suite>\n"
1006 " <success>false</success>\n"
1007 "</stream>\n";
1008
1009 cut_assert_null(receiver->pass_assertions);
1010 cut_assert_parse(xml);
1011 cut_assert_not_null(receiver->pass_assertions);
1012
1013 cut_assert_equal_uint(1, g_list_length(receiver->pass_assertions));
1014 info = receiver->pass_assertions->data;
1015
1016 test = info->test;
1017 cut_assert_not_null(test);
1018 cut_assert_equal_string("test_error_signal", cut_test_get_name(test));
1019
1020 test_context = info->test_context;
1021 cut_assert_not_null(test_context);
1022
1023 test_case = cut_test_context_get_test_case(test_context);
1024 cut_assert_not_null(test_case);
1025 cut_assert_equal_string("test_cut_test",
1026 cut_test_get_name(CUT_TEST(test_case)));
1027
1028 test = cut_test_context_get_test(test_context);
1029 cut_assert_not_null(test);
1030 cut_assert_equal_string("test_error_signal", cut_test_get_name(test));
1031 }
1032
1033 void
test_pass_assertion_iterated_test(void)1034 test_pass_assertion_iterated_test (void)
1035 {
1036 CuttestPassAssertionInfo *info;
1037 CutTestData *test_data;
1038 CutTest *test;
1039 CutTestIterator *test_iterator;
1040 CutTestCase *test_case;
1041 CutTestContext *test_context;
1042 const gchar xml[] =
1043 "<stream>\n"
1044 " <ready-test-suite>\n"
1045 " <test-suite>\n"
1046 " <elapsed>0.000000</elapsed>\n"
1047 " </test-suite>\n"
1048 " <n-test-cases>34</n-test-cases>\n"
1049 " <n-tests>236</n-tests>\n"
1050 " </ready-test-suite>\n"
1051 " <start-test-suite>\n"
1052 " <test-suite>\n"
1053 " <elapsed>0.000000</elapsed>\n"
1054 " </test-suite>\n"
1055 " </start-test-suite>\n"
1056 " <ready-test-case>\n"
1057 " <test-case>\n"
1058 " <name>test_cut_test</name>\n"
1059 " <elapsed>0.000000</elapsed>\n"
1060 " </test-case>\n"
1061 " <n-tests>13</n-tests>\n"
1062 " </ready-test-case>\n"
1063 " <start-test-case>\n"
1064 " <test-case>\n"
1065 " <name>test_cut_test</name>\n"
1066 " <elapsed>0.000000</elapsed>\n"
1067 " </test-case>\n"
1068 " </start-test-case>\n"
1069 " <start-test>\n"
1070 " <test>\n"
1071 " <name>test_error_signal</name>\n"
1072 " <elapsed>0.000000</elapsed>\n"
1073 " </test>\n"
1074 " <test-context>\n"
1075 " <test-case>\n"
1076 " <name>test_cut_test</name>\n"
1077 " <elapsed>0.000000</elapsed>\n"
1078 " </test-case>\n"
1079 " <failed>FALSE</failed>\n"
1080 " </test-context>\n"
1081 " </start-test>\n"
1082 " <pass-assertion>\n"
1083 " <iterated-test>\n"
1084 " <name>test_count</name>\n"
1085 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
1086 " <elapsed>0.039929</elapsed>\n"
1087 " </iterated-test>\n"
1088 " <test-context>\n"
1089 " <test-case>\n"
1090 " <name>test_cut_pipeline</name>\n"
1091 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
1092 " <elapsed>0.068691</elapsed>\n"
1093 " </test-case>\n"
1094 " <test-iterator>\n"
1095 " <name>test_count</name>\n"
1096 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
1097 " <elapsed>0.068712</elapsed>\n"
1098 " </test-iterator>\n"
1099 " <iterated-test>\n"
1100 " <name>test_count</name>\n"
1101 " <start-time>2008-07-29T23:22:29Z</start-time>\n"
1102 " <elapsed>0.039995</elapsed>\n"
1103 " </iterated-test>\n"
1104 " <test-data>\n"
1105 " <name>failure</name>\n"
1106 " </test-data>\n"
1107 " <failed>FALSE</failed>\n"
1108 " </test-context>\n"
1109 " </pass-assertion>\n"
1110 " <test-result>\n"
1111 " <test>\n"
1112 " <name>test_error_signal</name>\n"
1113 " <elapsed>0.000895</elapsed>\n"
1114 " </test>\n"
1115 " <test-context>\n"
1116 " <test-case>\n"
1117 " <name>test_cut_test</name>\n"
1118 " <elapsed>0.000895</elapsed>\n"
1119 " </test-case>\n"
1120 " <test>\n"
1121 " <name>test_error_signal</name>\n"
1122 " <elapsed>0.000895</elapsed>\n"
1123 " </test>\n"
1124 " <failed>FALSE</failed>\n"
1125 " </test-context>\n"
1126 " <result>\n"
1127 " <test-case>\n"
1128 " <name>test_cut_test</name>\n"
1129 " <elapsed>0.000895</elapsed>\n"
1130 " </test-case>\n"
1131 " <test>\n"
1132 " <name>test_error_signal</name>\n"
1133 " <elapsed>0.000895</elapsed>\n"
1134 " </test>\n"
1135 " <status>success</status>\n"
1136 " <elapsed>0.000895</elapsed>\n"
1137 " </result>\n"
1138 " </test-result>\n"
1139 " <complete-test>\n"
1140 " <test>\n"
1141 " <name>test_error_signal</name>\n"
1142 " <elapsed>0.000895</elapsed>\n"
1143 " </test>\n"
1144 " </complete-test>\n"
1145 " <complete-test-case>\n"
1146 " <test-case>\n"
1147 " <name>test_cut_test</name>\n"
1148 " <elapsed>0.003745</elapsed>\n"
1149 " </test-case>\n"
1150 " </complete-test-case>\n"
1151 " <complete-test-suite>\n"
1152 " <test-suite>\n"
1153 " <elapsed>139.666143</elapsed>\n"
1154 " </test-suite>\n"
1155 " </complete-test-suite>\n"
1156 " <success>false</success>\n"
1157 "</stream>\n";
1158
1159 cut_assert_null(receiver->pass_assertions);
1160 cut_assert_parse(xml);
1161 cut_assert_not_null(receiver->pass_assertions);
1162
1163 cut_assert_equal_uint(1, g_list_length(receiver->pass_assertions));
1164 info = receiver->pass_assertions->data;
1165
1166 test = info->test;
1167 cut_assert_not_null(test);
1168 cut_assert_equal_string("test_count", cut_test_get_name(test));
1169
1170 test_context = info->test_context;
1171 cut_assert_not_null(test_context);
1172
1173 test_case = cut_test_context_get_test_case(test_context);
1174 cut_assert_not_null(test_case);
1175 cut_assert_equal_string("test_cut_pipeline",
1176 cut_test_get_name(CUT_TEST(test_case)));
1177
1178 test_iterator = cut_test_context_get_test_iterator(test_context);
1179 cut_assert_not_null(test_iterator);
1180 cut_assert_equal_string("test_count",
1181 cut_test_get_name(CUT_TEST(test_iterator)));
1182
1183 test_data = cut_test_context_get_current_data(test_context);
1184 cut_assert_not_null(test_data);
1185 cut_assert_equal_string("failure", cut_test_data_get_name(test_data));
1186
1187 cut_assert_false(cut_test_context_is_failed(test_context));
1188 }
1189
1190 void
test_fail_assertion_test(void)1191 test_fail_assertion_test (void)
1192 {
1193 CuttestFailureTestInfo *info;
1194 CutTestResult *test_result;
1195 const gchar xml[] =
1196 "<stream>\n"
1197 " <ready-test-suite>\n"
1198 " <test-suite>\n"
1199 " <start-time>1970-01-01T00:00:00Z</start-time>\n"
1200 " <elapsed>0.000000</elapsed>\n"
1201 " </test-suite>\n"
1202 " <n-test-cases>1</n-test-cases>\n"
1203 " <n-tests>1</n-tests>\n"
1204 " </ready-test-suite>\n"
1205 " <start-test-suite>\n"
1206 " <test-suite>\n"
1207 " <start-time>2011-02-20T04:31:27.561329Z</start-time>\n"
1208 " <elapsed>0.000000</elapsed>\n"
1209 " </test-suite>\n"
1210 " </start-test-suite>\n"
1211 " <ready-test-case>\n"
1212 " <test-case>\n"
1213 " <name>test-cut-assertions</name>\n"
1214 " <start-time>1970-01-01T00:00:00Z</start-time>\n"
1215 " <elapsed>0.000000</elapsed>\n"
1216 " </test-case>\n"
1217 " <n-tests>1</n-tests>\n"
1218 " </ready-test-case>\n"
1219 " <start-test-case>\n"
1220 " <test-case>\n"
1221 " <name>test-cut-assertions</name>\n"
1222 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1223 " <elapsed>0.000000</elapsed>\n"
1224 " </test-case>\n"
1225 " </start-test-case>\n"
1226 " <start-test>\n"
1227 " <test>\n"
1228 " <name>test_equal_string</name>\n"
1229 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1230 " <elapsed>0.000000</elapsed>\n"
1231 " </test>\n"
1232 " <test-context>\n"
1233 " <test-suite>\n"
1234 " <start-time>2011-02-20T04:31:27.561329Z</start-time>\n"
1235 " <elapsed>0.000000</elapsed>\n"
1236 " </test-suite>\n"
1237 " <test-case>\n"
1238 " <name>test-cut-assertions</name>\n"
1239 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1240 " <elapsed>0.000000</elapsed>\n"
1241 " </test-case>\n"
1242 " <test>\n"
1243 " <name>test_equal_string</name>\n"
1244 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1245 " <elapsed>0.000000</elapsed>\n"
1246 " </test>\n"
1247 " <failed>false</failed>\n"
1248 " </test-context>\n"
1249 " </start-test>\n"
1250 " <test-result>\n"
1251 " <test>\n"
1252 " <name>test_equal_string</name>\n"
1253 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1254 " <elapsed>0.000148</elapsed>\n"
1255 " </test>\n"
1256 " <test-context>\n"
1257 " <test-suite>\n"
1258 " <start-time>2011-02-20T04:31:27.561329Z</start-time>\n"
1259 " <elapsed>0.000184</elapsed>\n"
1260 " </test-suite>\n"
1261 " <test-case>\n"
1262 " <name>test-cut-assertions</name>\n"
1263 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1264 " <elapsed>0.000221</elapsed>\n"
1265 " </test-case>\n"
1266 " <test>\n"
1267 " <name>test_equal_string</name>\n"
1268 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1269 " <elapsed>0.000231</elapsed>\n"
1270 " </test>\n"
1271 " <failed>true</failed>\n"
1272 " </test-context>\n"
1273 " <result>\n"
1274 " <test-case>\n"
1275 " <name>test-cut-assertions</name>\n"
1276 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1277 " <elapsed>0.000250</elapsed>\n"
1278 " </test-case>\n"
1279 " <test>\n"
1280 " <name>test_equal_string</name>\n"
1281 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1282 " <elapsed>0.000261</elapsed>\n"
1283 " </test>\n"
1284 " <status>failure</status>\n"
1285 " <detail><"expected\n" "loooooooooooooooooooooooooooooooooooooooo" "ooooooooooooooooooooooooooooooooooooooong" "xxxxxxxxline" == "actual\n" "loooooooooooooooooooooooooooooooooooooooo" "ooooooooooooooooooooooooooooooooooooooong" "ooooooooline">\n"
1286 "expected: <"expected\n"
1287 "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongxxxxxxxxline">\n"
1288 " actual: <"actual\n"
1289 "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongooooooooline">\n"
1290 "\n"
1291 "diff:\n"
1292 "- "expected\n"
1293 "+ "actual\n"
1294 "- looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongxxxxxxxxline"\n"
1295 "? ^^^^^^^^\n"
1296 "+ looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongooooooooline"\n"
1297 "? ^^^^^^^^\n"
1298 "\n"
1299 "folded diff:\n"
1300 "- "expected\n"
1301 "+ "actual\n"
1302 " looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo\n"
1303 "- oongxxxxxxxxline"\n"
1304 "+ oongooooooooline"</detail>\n"
1305 " <backtrace>\n"
1306 " <entry>\n"
1307 " <file>test/cutter/test-cut-assertions.c</file>\n"
1308 " <line>1351</line>\n"
1309 " <info>test_equal_string(): cut_assert_equal_string("expected\n" "loooooooooooooooooooooooooooooooooooooooo" "ooooooooooooooooooooooooooooooooooooooong" "xxxxxxxxline", "actual\n" "loooooooooooooooooooooooooooooooooooooooo" "ooooooooooooooooooooooooooooooooooooooong" "ooooooooline", )</info>\n"
1310 " </entry>\n"
1311 " </backtrace>\n"
1312 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1313 " <elapsed>0.000103</elapsed>\n"
1314 " <expected>"expected\n"
1315 "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongxxxxxxxxline"</expected>\n"
1316 " <actual>"actual\n"
1317 "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongooooooooline"</actual>\n"
1318 " <diff>- "expected\n"
1319 "+ "actual\n"
1320 "- looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongxxxxxxxxline"\n"
1321 "? ^^^^^^^^\n"
1322 "+ looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongooooooooline"\n"
1323 "? ^^^^^^^^</diff>\n"
1324 " <folded-diff>- "expected\n"
1325 "+ "actual\n"
1326 " looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo\n"
1327 "- oongxxxxxxxxline"\n"
1328 "+ oongooooooooline"</folded-diff>\n"
1329 " </result>\n"
1330 " </test-result>\n"
1331 " <complete-test>\n"
1332 " <test>\n"
1333 " <name>test_equal_string</name>\n"
1334 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1335 " <elapsed>0.002108</elapsed>\n"
1336 " </test>\n"
1337 " <test-context>\n"
1338 " <test-suite>\n"
1339 " <start-time>2011-02-20T04:31:27.561329Z</start-time>\n"
1340 " <elapsed>0.002108</elapsed>\n"
1341 " </test-suite>\n"
1342 " <test-case>\n"
1343 " <name>test-cut-assertions</name>\n"
1344 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1345 " <elapsed>0.002108</elapsed>\n"
1346 " </test-case>\n"
1347 " <test>\n"
1348 " <name>test_equal_string</name>\n"
1349 " <start-time>2011-02-20T04:31:27.561628Z</start-time>\n"
1350 " <elapsed>0.002108</elapsed>\n"
1351 " </test>\n"
1352 " <failed>true</failed>\n"
1353 " </test-context>\n"
1354 " <success>false</success>\n"
1355 " </complete-test>\n"
1356 " <test-case-result>\n"
1357 " <test-case>\n"
1358 " <name>test-cut-assertions</name>\n"
1359 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1360 " <elapsed>0.002108</elapsed>\n"
1361 " </test-case>\n"
1362 " <result>\n"
1363 " <test-case>\n"
1364 " <name>test-cut-assertions</name>\n"
1365 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1366 " <elapsed>0.002108</elapsed>\n"
1367 " </test-case>\n"
1368 " <status>failure</status>\n"
1369 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1370 " <elapsed>0.002108</elapsed>\n"
1371 " </result>\n"
1372 " </test-case-result>\n"
1373 " <complete-test-case>\n"
1374 " <test-case>\n"
1375 " <name>test-cut-assertions</name>\n"
1376 " <start-time>2011-02-20T04:31:27.561548Z</start-time>\n"
1377 " <elapsed>0.002108</elapsed>\n"
1378 " </test-case>\n"
1379 " <success>false</success>\n"
1380 " </complete-test-case>\n"
1381 " <complete-test-suite>\n"
1382 " <test-suite>\n"
1383 " <start-time>2011-02-20T04:31:27.561329Z</start-time>\n"
1384 " <elapsed>0.002108</elapsed>\n"
1385 " </test-suite>\n"
1386 " <success>false</success>\n"
1387 " </complete-test-suite>\n"
1388 " <success>false</success>\n"
1389 "</stream>\n";
1390
1391 cut_assert_null(receiver->failure_tests);
1392 cut_assert_parse(xml);
1393 cut_assert_not_null(receiver->failure_tests);
1394
1395 cut_assert_equal_uint(1, g_list_length(receiver->failure_tests));
1396 info = receiver->failure_tests->data;
1397
1398 test_result = info->test_result;
1399 cut_assert_not_null(test_result);
1400 cut_assert_equal_string("\"expected\n"
1401 "loooooooooooooooooooooooooooooooooooooooo"
1402 "ooooooooooooooooooooooooooooooooooooooong"
1403 "xxxxxxxxline\"",
1404 cut_test_result_get_expected(test_result));
1405 cut_assert_equal_string("\"actual\n"
1406 "loooooooooooooooooooooooooooooooooooooooo"
1407 "ooooooooooooooooooooooooooooooooooooooong"
1408 "ooooooooline\"",
1409 cut_test_result_get_actual(test_result));
1410 cut_assert_equal_string("- \"expected\n"
1411 "+ \"actual\n"
1412 "- looooooooooooooooooooooooooooooooooooooo"
1413 "oooooooooooooooooooooooooooooooooooooooong"
1414 "xxxxxxxxline\"\n"
1415 "? "
1416 " "
1417 "^^^^^^^^\n"
1418 "+ looooooooooooooooooooooooooooooooooooooo"
1419 "oooooooooooooooooooooooooooooooooooooooong"
1420 "ooooooooline\"\n"
1421 "? "
1422 " "
1423 "^^^^^^^^",
1424 cut_test_result_get_diff(test_result));
1425 cut_assert_equal_string("- \"expected\n"
1426 "+ \"actual\n"
1427 " looooooooooooooooooooooooooooooooooooooo"
1428 "oooooooooooooooooooooooooooooooooooooo\n"
1429 "- oongxxxxxxxxline\"\n"
1430 "+ oongooooooooline\"",
1431 cut_test_result_get_folded_diff(test_result));
1432 }
1433
1434 void
test_complete_iterated_test(void)1435 test_complete_iterated_test (void)
1436 {
1437 CuttestCompleteIteratedTestInfo *info;
1438 CutTestContext *context;
1439 CutTestSuite *test_suite;
1440 CutTestCase *test_case;
1441 CutTestIterator *test_iterator;
1442 CutIteratedTest *iterated_test;
1443 CutTestData *test_data;
1444 gchar header[] =
1445 "<stream>\n"
1446 " <ready-test-suite>\n"
1447 " <test-suite>\n"
1448 " </test-suite>\n"
1449 " <n-test-cases>3</n-test-cases>\n"
1450 " <n-tests>7</n-tests>\n"
1451 " </ready-test-suite>\n"
1452 " <start-test-suite>\n"
1453 " <test-suite>\n"
1454 " </test-suite>\n"
1455 " </start-test-suite>\n"
1456 " <ready-test-case>\n"
1457 " <test-case>\n"
1458 " <name>my test case</name>\n"
1459 " </test-case>\n"
1460 " <n-tests>2</n-tests>\n"
1461 " </ready-test-case>\n"
1462 " <start-test-case>\n"
1463 " <test-case>\n"
1464 " <name>my test case</name>\n"
1465 " </test-case>\n"
1466 " </start-test-case>\n"
1467 " <ready-test-iterator>\n"
1468 " <test-iterator>\n"
1469 " <name>my test iterator</name>\n"
1470 " </test-iterator>\n"
1471 " <n-tests>5</n-tests>\n"
1472 " </ready-test-iterator>\n"
1473 " <start-test-iterator>\n"
1474 " <test-iterator>\n"
1475 " <name>my test iterator</name>\n"
1476 " </test-iterator>\n"
1477 " </start-test-iterator>\n"
1478 " <start-iterated-test>\n"
1479 " <iterated-test>\n"
1480 " <name>my iterated test</name>\n"
1481 " </iterated-test>\n"
1482 " <test-context>\n"
1483 " <test-suite>\n"
1484 " </test-suite>\n"
1485 " <test-case>\n"
1486 " <name>my test case</name>\n"
1487 " </test-case>\n"
1488 " <test-iterator>\n"
1489 " <name>my test iterator</name>\n"
1490 " </test-iterator>\n"
1491 " <iterated-test>\n"
1492 " <name>my iterated test</name>\n"
1493 " </iterated-test>\n"
1494 " <test-data>\n"
1495 " <name>the first test data</name>\n"
1496 " </test-data>\n"
1497 " <failed>FALSE</failed>\n"
1498 " </test-context>\n"
1499 " </start-iterated-test>\n";
1500 gchar complete_iterated_test[] =
1501 " <complete-iterated-test>\n"
1502 " <iterated-test>\n"
1503 " <name>my iterated test</name>\n"
1504 " </iterated-test>\n"
1505 " <test-context>\n"
1506 " <test-suite>\n"
1507 " </test-suite>\n"
1508 " <test-case>\n"
1509 " <name>my test case</name>\n"
1510 " </test-case>\n"
1511 " <test-iterator>\n"
1512 " <name>my test iterator</name>\n"
1513 " </test-iterator>\n"
1514 " <iterated-test>\n"
1515 " <name>my iterated test</name>\n"
1516 " </iterated-test>\n"
1517 " <test-data>\n"
1518 " <name>the first test data</name>\n"
1519 " </test-data>\n"
1520 " <failed>TRUE</failed>\n"
1521 " </test-context>\n"
1522 " </complete-iterated-test>\n";
1523
1524 cut_assert_parse(header);
1525 cut_assert_null(receiver->complete_iterated_tests);
1526
1527 cut_assert_parse(complete_iterated_test);
1528 cut_assert_equal_uint(1, g_list_length(receiver->complete_iterated_tests));
1529
1530 info = receiver->complete_iterated_tests->data;
1531 cut_assert_not_null(info);
1532
1533 cut_assert_not_null(info->iterated_test);
1534 cut_assert_equal_string("my iterated test",
1535 cut_test_get_name(CUT_TEST(info->iterated_test)));
1536
1537 context = info->test_context;
1538 cut_assert_not_null(context);
1539 cut_assert_true(cut_test_context_is_failed(context));
1540
1541 test_suite = cut_test_context_get_test_suite(context);
1542 cut_assert_not_null(test_suite);
1543 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
1544
1545 test_case = cut_test_context_get_test_case(context);
1546 cut_assert_not_null(test_case);
1547 cut_assert_equal_string("my test case",
1548 cut_test_get_name(CUT_TEST(test_case)));
1549
1550 test_iterator = cut_test_context_get_test_iterator(context);
1551 cut_assert_not_null(test_iterator);
1552 cut_assert_equal_string("my test iterator",
1553 cut_test_get_name(CUT_TEST(test_iterator)));
1554
1555 iterated_test = CUT_ITERATED_TEST(cut_test_context_get_test(context));
1556 cut_assert_not_null(iterated_test);
1557 cut_assert_equal_string("my iterated test",
1558 cut_test_get_name(CUT_TEST(iterated_test)));
1559
1560 cut_assert_true(cut_test_context_have_data(context));
1561 test_data = cut_test_context_get_current_data(context);
1562 cut_assert_not_null(test_data);
1563 cut_assert_equal_string("the first test data",
1564 cut_test_data_get_name(test_data));
1565 }
1566
1567 void
test_complete_test(void)1568 test_complete_test (void)
1569 {
1570 CuttestCompleteTestInfo *info;
1571 CutTestContext *context;
1572 CutTestSuite *test_suite;
1573 CutTestCase *test_case;
1574 CutTest *test;
1575 gchar header[] =
1576 "<stream>\n"
1577 " <ready-test-suite>\n"
1578 " <test-suite>\n"
1579 " </test-suite>\n"
1580 " <n-test-cases>3</n-test-cases>\n"
1581 " <n-tests>7</n-tests>\n"
1582 " </ready-test-suite>\n"
1583 " <start-test-suite>\n"
1584 " <test-suite>\n"
1585 " </test-suite>\n"
1586 " </start-test-suite>\n"
1587 " <ready-test-case>\n"
1588 " <test-case>\n"
1589 " <name>my test case</name>\n"
1590 " </test-case>\n"
1591 " <n-tests>2</n-tests>\n"
1592 " </ready-test-case>\n"
1593 " <start-test-case>\n"
1594 " <test-case>\n"
1595 " <name>my test case</name>\n"
1596 " </test-case>\n"
1597 " </start-test-case>\n"
1598 " <start-test>\n"
1599 " <test>\n"
1600 " <name>my test</name>\n"
1601 " </test>\n"
1602 " <test-context>\n"
1603 " <test-suite>\n"
1604 " </test-suite>\n"
1605 " <test-case>\n"
1606 " <name>my test case</name>\n"
1607 " </test-case>\n"
1608 " <test>\n"
1609 " <name>my test</name>\n"
1610 " </test>\n"
1611 " <failed>FALSE</failed>\n"
1612 " </test-context>\n"
1613 " </start-test>\n";
1614 gchar complete_test[] =
1615 " <complete-test>\n"
1616 " <test>\n"
1617 " <name>my test</name>\n"
1618 " </test>\n"
1619 " <test-context>\n"
1620 " <test-suite>\n"
1621 " </test-suite>\n"
1622 " <test-case>\n"
1623 " <name>my test case</name>\n"
1624 " </test-case>\n"
1625 " <test>\n"
1626 " <name>my test</name>\n"
1627 " </test>\n"
1628 " <failed>TRUE</failed>\n"
1629 " </test-context>\n"
1630 " </complete-test>\n";
1631
1632 cut_assert_parse(header);
1633 cut_assert_null(receiver->complete_tests);
1634
1635 cut_assert_parse(complete_test);
1636 cut_assert_equal_int(1, g_list_length(receiver->complete_tests));
1637
1638 info = receiver->complete_tests->data;
1639 cut_assert_not_null(info);
1640
1641 cut_assert_not_null(info->test);
1642 cut_assert_equal_string("my test", cut_test_get_name(CUT_TEST(info->test)));
1643
1644 context = info->test_context;
1645 cut_assert_not_null(context);
1646 cut_assert_true(cut_test_context_is_failed(context));
1647
1648 test_suite = cut_test_context_get_test_suite(context);
1649 cut_assert_not_null(test_suite);
1650 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
1651
1652 test_case = cut_test_context_get_test_case(context);
1653 cut_assert_not_null(test_case);
1654 cut_assert_equal_string("my test case",
1655 cut_test_get_name(CUT_TEST(test_case)));
1656
1657 test = cut_test_context_get_test(context);
1658 cut_assert_not_null(test);
1659 cut_assert_equal_string("my test", cut_test_get_name(test));
1660 }
1661
1662 void
test_complete_test_iterator(void)1663 test_complete_test_iterator (void)
1664 {
1665 CutTestIterator *test_iterator;
1666 gchar header[] =
1667 "<stream>\n"
1668 " <ready-test-suite>\n"
1669 " <test-suite>\n"
1670 " </test-suite>\n"
1671 " <n-test-cases>3</n-test-cases>\n"
1672 " <n-tests>7</n-tests>\n"
1673 " </ready-test-suite>\n"
1674 " <start-test-suite>\n"
1675 " <test-suite>\n"
1676 " </test-suite>\n"
1677 " </start-test-suite>\n"
1678 " <ready-test-case>\n"
1679 " <test-case>\n"
1680 " <name>my test case</name>\n"
1681 " </test-case>\n"
1682 " <n-tests>2</n-tests>\n"
1683 " </ready-test-case>\n"
1684 " <start-test-case>\n"
1685 " <test-case>\n"
1686 " <name>my test case</name>\n"
1687 " </test-case>\n"
1688 " </start-test-case>\n"
1689 " <ready-test-iterator>\n"
1690 " <test-iterator>\n"
1691 " <name>my test iterator</name>\n"
1692 " </test-iterator>\n"
1693 " <n-tests>5</n-tests>\n"
1694 " </ready-test-iterator>\n"
1695 " <start-test-iterator>\n"
1696 " <test-iterator>\n"
1697 " <name>my test iterator</name>\n"
1698 " </test-iterator>\n"
1699 " </start-test-iterator>\n"
1700 " <start-iterated-test>\n"
1701 " <iterated-test>\n"
1702 " <name>my iterated test</name>\n"
1703 " </iterated-test>\n"
1704 " <test-context>\n"
1705 " <test-suite>\n"
1706 " </test-suite>\n"
1707 " <test-case>\n"
1708 " <name>my test case</name>\n"
1709 " </test-case>\n"
1710 " <test-iterator>\n"
1711 " <name>my test iterator</name>\n"
1712 " </test-iterator>\n"
1713 " <iterated-test>\n"
1714 " <name>my iterated test</name>\n"
1715 " </iterated-test>\n"
1716 " <test-data>\n"
1717 " <name>the first test data</name>\n"
1718 " </test-data>\n"
1719 " <failed>FALSE</failed>\n"
1720 " </test-context>\n"
1721 " </start-iterated-test>\n"
1722 " <complete-iterated-test>\n"
1723 " <iterated-test>\n"
1724 " <name>my iterated test</name>\n"
1725 " </iterated-test>\n"
1726 " <test-context>\n"
1727 " <test-suite>\n"
1728 " </test-suite>\n"
1729 " <test-case>\n"
1730 " <name>my test case</name>\n"
1731 " </test-case>\n"
1732 " <test-iterator>\n"
1733 " <name>my test iterator</name>\n"
1734 " </test-iterator>\n"
1735 " <iterated-test>\n"
1736 " <name>my iterated test</name>\n"
1737 " </iterated-test>\n"
1738 " <test-data>\n"
1739 " <name>the first test data</name>\n"
1740 " </test-data>\n"
1741 " <failed>TRUE</failed>\n"
1742 " </test-context>\n"
1743 " </complete-iterated-test>\n";
1744 gchar complete_test_iterator[] =
1745 " <complete-test-iterator>\n"
1746 " <test-iterator>\n"
1747 " <name>my test iterator</name>\n"
1748 " </test-iterator>\n"
1749 " </complete-test-iterator>\n";
1750
1751 cut_assert_parse(header);
1752 cut_assert_null(receiver->complete_test_iterators);
1753
1754 cut_assert_parse(complete_test_iterator);
1755 cut_assert_equal_uint(1, g_list_length(receiver->complete_test_iterators));
1756
1757 test_iterator = receiver->complete_test_iterators->data;
1758 cut_assert_not_null(test_iterator);
1759 cut_assert_equal_string("my test iterator",
1760 cut_test_get_name(CUT_TEST(test_iterator)));
1761 }
1762
1763 void
test_complete_test_case(void)1764 test_complete_test_case (void)
1765 {
1766 CutTestCase *test_case;
1767 gchar header[] =
1768 "<stream>\n"
1769 " <ready-test-suite>\n"
1770 " <test-suite>\n"
1771 " </test-suite>\n"
1772 " <n-test-cases>3</n-test-cases>\n"
1773 " <n-tests>7</n-tests>\n"
1774 " </ready-test-suite>\n"
1775 " <start-test-suite>\n"
1776 " <test-suite>\n"
1777 " </test-suite>\n"
1778 " </start-test-suite>\n"
1779 " <ready-test-case>\n"
1780 " <test-case>\n"
1781 " <name>my test case</name>\n"
1782 " </test-case>\n"
1783 " <n-tests>2</n-tests>\n"
1784 " </ready-test-case>\n"
1785 " <start-test-case>\n"
1786 " <test-case>\n"
1787 " <name>my test case</name>\n"
1788 " </test-case>\n"
1789 " </start-test-case>\n"
1790 " <start-test>\n"
1791 " <test>\n"
1792 " <name>my test</name>\n"
1793 " </test>\n"
1794 " <test-context>\n"
1795 " <test-suite>\n"
1796 " </test-suite>\n"
1797 " <test-case>\n"
1798 " <name>my test case</name>\n"
1799 " </test-case>\n"
1800 " <test>\n"
1801 " <name>my test</name>\n"
1802 " </test>\n"
1803 " <failed>FALSE</failed>\n"
1804 " </test-context>\n"
1805 " </start-test>\n"
1806 " <complete-test>\n"
1807 " <test>\n"
1808 " <name>my test</name>\n"
1809 " </test>\n"
1810 " <test-context>\n"
1811 " <test-suite>\n"
1812 " </test-suite>\n"
1813 " <test-case>\n"
1814 " <name>my test case</name>\n"
1815 " </test-case>\n"
1816 " <test>\n"
1817 " <name>my test</name>\n"
1818 " </test>\n"
1819 " <failed>TRUE</failed>\n"
1820 " </test-context>\n"
1821 " </complete-test>\n";
1822 gchar complete_test_case[] =
1823 " <complete-test-case>\n"
1824 " <test-case>\n"
1825 " <name>my test case</name>\n"
1826 " </test-case>\n"
1827 " </complete-test-case>\n";
1828
1829 cut_assert_parse(header);
1830 cut_assert_null(receiver->complete_test_cases);
1831
1832 cut_assert_parse(complete_test_case);
1833 cut_assert_equal_int(1, g_list_length(receiver->complete_test_cases));
1834
1835 test_case = receiver->complete_test_cases->data;
1836 cut_assert_not_null(test_case);
1837 cut_assert_equal_string("my test case",
1838 cut_test_get_name(CUT_TEST(test_case)));
1839 }
1840
1841 void
test_complete_test_suite(void)1842 test_complete_test_suite (void)
1843 {
1844 CutTestSuite *test_suite;
1845 gchar header[] =
1846 "<stream>\n"
1847 " <ready-test-suite>\n"
1848 " <test-suite>\n"
1849 " </test-suite>\n"
1850 " <n-test-cases>3</n-test-cases>\n"
1851 " <n-tests>7</n-tests>\n"
1852 " </ready-test-suite>\n"
1853 " <start-test-suite>\n"
1854 " <test-suite>\n"
1855 " </test-suite>\n"
1856 " </start-test-suite>\n"
1857 " <ready-test-case>\n"
1858 " <test-case>\n"
1859 " <name>my test case</name>\n"
1860 " </test-case>\n"
1861 " <n-tests>2</n-tests>\n"
1862 " </ready-test-case>\n"
1863 " <start-test-case>\n"
1864 " <test-case>\n"
1865 " <name>my test case</name>\n"
1866 " </test-case>\n"
1867 " </start-test-case>\n"
1868 " <start-test>\n"
1869 " <test>\n"
1870 " <name>my test</name>\n"
1871 " </test>\n"
1872 " <test-context>\n"
1873 " <test-suite>\n"
1874 " </test-suite>\n"
1875 " <test-case>\n"
1876 " <name>my test case</name>\n"
1877 " </test-case>\n"
1878 " <test>\n"
1879 " <name>my test</name>\n"
1880 " </test>\n"
1881 " <failed>FALSE</failed>\n"
1882 " </test-context>\n"
1883 " </start-test>\n"
1884 " <complete-test>\n"
1885 " <test>\n"
1886 " <name>my test</name>\n"
1887 " </test>\n"
1888 " <test-context>\n"
1889 " <test-suite>\n"
1890 " </test-suite>\n"
1891 " <test-case>\n"
1892 " <name>my test case</name>\n"
1893 " </test-case>\n"
1894 " <test>\n"
1895 " <name>my test</name>\n"
1896 " </test>\n"
1897 " <failed>TRUE</failed>\n"
1898 " </test-context>\n"
1899 " </complete-test>\n"
1900 " <complete-test-case>\n"
1901 " <test-case>\n"
1902 " <name>my test case</name>\n"
1903 " </test-case>\n"
1904 " </complete-test-case>\n";
1905 gchar complete_test_suite[] =
1906 " <complete-test-suite>\n"
1907 " <test-suite>\n"
1908 " </test-suite>\n"
1909 " </complete-test-suite>\n";
1910
1911 cut_assert_parse(header);
1912 cut_assert_null(receiver->complete_test_suites);
1913
1914 cut_assert_parse(complete_test_suite);
1915 cut_assert_equal_int(1, g_list_length(receiver->complete_test_suites));
1916
1917 test_suite = receiver->complete_test_suites->data;
1918 cut_assert_not_null(test_suite);
1919 cut_assert_equal_string(NULL, cut_test_get_name(CUT_TEST(test_suite)));
1920 }
1921
1922 void
test_complete_run_without_success_tag(void)1923 test_complete_run_without_success_tag (void)
1924 {
1925 cut_assert_parse("<stream>\n");
1926 cut_assert_equal_int(1, receiver->n_start_runs);
1927
1928 cut_assert_null(receiver->complete_runs);
1929 cut_assert_parse("</stream>\n");
1930 cut_assert_equal_int(1, g_list_length(receiver->complete_runs));
1931 cut_assert_true(GPOINTER_TO_INT(receiver->complete_runs->data));
1932 }
1933
1934 void
test_complete_run_with_success_true(void)1935 test_complete_run_with_success_true (void)
1936 {
1937 cut_assert_parse("<stream>\n");
1938 cut_assert_equal_int(1, receiver->n_start_runs);
1939
1940 cut_assert_null(receiver->complete_runs);
1941 cut_assert_parse(" <success>TRUE</success>\n");
1942 cut_assert_null(receiver->complete_runs);
1943 cut_assert_parse("</stream>\n");
1944 cut_assert_equal_int(1, g_list_length(receiver->complete_runs));
1945 cut_assert_true(GPOINTER_TO_INT(receiver->complete_runs->data));
1946 }
1947
1948 void
test_complete_run_with_success_false(void)1949 test_complete_run_with_success_false (void)
1950 {
1951 cut_assert_parse("<stream>\n");
1952 cut_assert_equal_int(1, receiver->n_start_runs);
1953
1954 cut_assert_null(receiver->complete_runs);
1955 cut_assert_parse(" <success>FALSE</success>\n");
1956 cut_assert_null(receiver->complete_runs);
1957 cut_assert_parse("</stream>");
1958 cut_assert_equal_int(1, g_list_length(receiver->complete_runs));
1959 cut_assert_false(GPOINTER_TO_INT(receiver->complete_runs->data));
1960 }
1961
1962 void
test_crash_test(void)1963 test_crash_test (void)
1964 {
1965 gchar xml[] =
1966 "<stream>\n"
1967 " <test-result>\n"
1968 " <test>\n"
1969 " <name>stub-crash-test</name>\n"
1970 " <description>Crash Test</description>\n"
1971 " <option>\n"
1972 " <name>bug</name>\n"
1973 " <value>1234</value>\n"
1974 " </option>\n"
1975 " </test>\n"
1976 " <test-context>\n"
1977 " <test-case>\n"
1978 " <name>stub test case</name>\n"
1979 " </test-case>\n"
1980 " <test>\n"
1981 " <name>stub-crash-test</name>\n"
1982 " <description>Crash Test</description>\n"
1983 " <option>\n"
1984 " <name>bug</name>\n"
1985 " <value>1234</value>\n"
1986 " </option>\n"
1987 " </test>\n"
1988 " <failed>TRUE</failed>\n"
1989 " </test-context>\n"
1990 " <result>\n"
1991 " <test-case>\n"
1992 " <name>stub test case</name>\n"
1993 " </test-case>\n"
1994 " <test>\n"
1995 " <name>stub-crash-test</name>\n"
1996 " <description>Crash Test</description>\n"
1997 " <option>\n"
1998 " <name>bug</name>\n"
1999 " <value>1234</value>\n"
2000 " </option>\n"
2001 " </test>\n"
2002 " <status>crash</status>\n"
2003 " <detail>This test should crash</detail>\n"
2004 " <backtrace>\n"
2005 " <entry>\n"
2006 " <file>test-cut-stream-parser.c</file>\n"
2007 " <line>1099</line>\n"
2008 " <info>test_crash_test()</info>\n"
2009 " </entry>\n"
2010 " <entry>\n"
2011 " <info>cut_test_run()</info>\n"
2012 " </entry>\n"
2013 " <entry>\n"
2014 " <info>run()</info>\n"
2015 " </entry>\n"
2016 " <entry>\n"
2017 " <info>cut_test_case_run_with_filter()</info>\n"
2018 " </entry>\n"
2019 " <entry>\n"
2020 " <file>cut-test-suite.c</file>\n"
2021 " <line>129</line>\n"
2022 " <info>run()</info>\n"
2023 " </entry>\n"
2024 " <entry>\n"
2025 " <info>cut_test_suite_run_test_cases()</info>\n"
2026 " </entry>\n"
2027 " <entry>\n"
2028 " <info>cut_test_suite_run_with_filter()</info>\n"
2029 " </entry>\n"
2030 " <entry>\n"
2031 " <file>cut-runner.c</file>\n"
2032 " <line>67</line>\n"
2033 " <info>cut_runner_run()</info>\n"
2034 " </entry>\n"
2035 " <entry>\n"
2036 " <info>cut_run_context_start()</info>\n"
2037 " </entry>\n"
2038 " <entry>\n"
2039 " <info>cut_start_run_context()</info>\n"
2040 " </entry>\n"
2041 " <entry>\n"
2042 " <file>cut-main.c</file>\n"
2043 " <line>317</line>\n"
2044 " <info>cut_run()</info>\n"
2045 " </entry>\n"
2046 " </backtrace>\n"
2047 " <start-time>2008-07-29T05:16:40Z</start-time>\n"
2048 " <elapsed>0.000100</elapsed>\n"
2049 " </result>\n"
2050 " </test-result>\n"
2051 "</stream>\n";
2052 /*
2053 gchar crashed_backtrace[] =
2054 "#4 0x00007fd67b4fbfc5 in test_crash_test () at test-cut-stream-parser.c:1099\n"
2055 "#5 0x00007fd68285ea77 in cut_test_run (test=0xfc0e30, test_context=0xf90840, \n"
2056 "#6 0x00007fd682860cc4 in run (test_case=0xfb3400, test=0xfc0e30, \n"
2057 "#7 0x00007fd682860e9d in cut_test_case_run_with_filter (test_case=0xfb3400, \n"
2058 "#8 0x00007fd682862c66 in run (data=0xfc3560) at cut-test-suite.c:129\n"
2059 "#9 0x00007fd68286313e in cut_test_suite_run_test_cases (test_suite=0xf88c60, \n"
2060 "#10 0x00007fd6828631e0 in cut_test_suite_run_with_filter (test_suite=0xf88c60, \n"
2061 "#11 0x00007fd68285dbe8 in cut_runner_run (runner=0xf8d840) at cut-runner.c:67\n"
2062 "#12 0x00007fd68285bc7f in cut_run_context_start (context=0xf8d840)\n"
2063 "#13 0x00007fd68285e072 in cut_start_run_context (run_context=0xf8d840)\n"
2064 "#14 0x00007fd68285e1be in cut_run () at cut-main.c:317\n";
2065 */
2066
2067
2068 g_signal_connect(parser, "result",
2069 G_CALLBACK(collect_result), (gpointer)&result);
2070
2071 cut_assert_parse(xml);
2072
2073 cut_assert_equal_int(CUT_TEST_RESULT_CRASH,
2074 cut_test_result_get_status(result));
2075 }
2076
2077 /*
2078 vi:ts=4:nowrap:ai:expandtab:sw=4
2079 */
2080