1 : /*
2 : * This file is part of MIN Test Framework. Copyright © 2008 Nokia Corporation
3 : * and/or its subsidiary(-ies).
4 : * Contact: Konrad Marek Zapalowicz
5 : * Contact e-mail: DG.MIN-Support@nokia.com
6 : *
7 : * This program is free software: you can redistribute it and/or modify it
8 : * under the terms of the GNU General Public License as published by the Free
9 : * Software Foundation, version 2 of the License.
10 : *
11 : * This program is distributed in the hope that it will be useful, but WITHOUT
12 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 : * more details. You should have received a copy of the GNU General Public
15 : * License along with this program. If not, see
16 : * <http://www.gnu.org/licenses/>.
17 : */
18 :
19 :
20 : /**
21 : * @file parser.test
22 : * @version 0.1
23 : * @brief This file contains tests for MIN Parser
24 : */
25 :
26 : /* ------------------------------------------------------------------------- */
27 : /* INCLUDES */
28 : #include <check.h>
29 :
30 : /* ------------------------------------------------------------------------- */
31 : /* CONSTANTS */
32 : /* None */
33 :
34 : /* ------------------------------------------------------------------------- */
35 : /* MACROS */
36 : /* None */
37 :
38 : /* ------------------------------------------------------------------------- */
39 : /* DATA TYPES */
40 : /* None */
41 :
42 : /* ------------------------------------------------------------------------- */
43 : /* LOCAL FUNCTION PROTOTYPES */
44 : /* None */
45 :
46 : /* ------------------------------------------------------------------------- */
47 : /* FORWARD DECLARATIONS */
48 : /* None */
49 :
50 : /* ------------------------------------------------------------------------- */
51 : /* STRUCTURES */
52 : /* None */
53 :
54 : /* ------------------------------------------------------------------------- */
55 : /* ==================== LOCAL FUNCTIONS ==================================== */
56 : /* None */
57 :
58 : /* ------------------------------------------------------------------------- */
59 : /* ============================= TESTS ===================================== */
60 : /* ------------------------------------------------------------------------- */
61 1 : START_TEST(test_mp_create)
62 : {
63 1 : MinParser* sp = INITPTR;
64 :
65 1 : sp = mp_create( INITPTR
66 : , "file.cfg"
67 : , ENoComments );
68 :
69 1 : fail_unless( sp == INITPTR
70 : , "sp != INITPTR" );
71 : }
72 1 : END_TEST
73 : /* ------------------------------------------------------------------------- */
74 1 : START_TEST(test_mp_create2)
75 : {
76 1 : MinParser* sp = INITPTR;
77 :
78 1 : sp = mp_create( "/home/maemo/"
79 : , INITPTR
80 : , ENoComments );
81 :
82 1 : fail_unless( sp == INITPTR
83 : , "sp != INITPTR" );
84 : }
85 1 : END_TEST
86 : /* ------------------------------------------------------------------------- */
87 1 : START_TEST(test_mp_create3)
88 : {
89 1 : MinParser* sp = INITPTR;
90 :
91 1 : sp = mp_create( INITPTR
92 : , INITPTR
93 : , ENoComments );
94 :
95 1 : fail_unless( sp == INITPTR
96 : , "sp != INITPTR" );
97 : }
98 1 : END_TEST
99 : /* ------------------------------------------------------------------------- */
100 1 : START_TEST(test_mp_create4)
101 : {
102 1 : MinParser* sp = INITPTR;
103 :
104 1 : sp = mp_create( ""
105 : , ""
106 : , ENoComments );
107 :
108 1 : fail_unless( sp == INITPTR
109 : , "sp != INITPTR" );
110 : }
111 1 : END_TEST
112 : /* ------------------------------------------------------------------------- */
113 1 : START_TEST(test_mp_create5)
114 : {
115 1 : MinParser* sp = INITPTR;
116 :
117 1 : sp = mp_create( INITPTR
118 : , INITPTR
119 : , ENoComments );
120 :
121 1 : fail_unless( sp == INITPTR
122 : , "sp != INITPTR" );
123 : }
124 1 : END_TEST
125 : /* ------------------------------------------------------------------------- */
126 1 : START_TEST(test_mp_create6)
127 : {
128 1 : MinParser* sp = INITPTR;
129 :
130 1 : sp = mp_create( "/home/maemo/"
131 : , ""
132 : , ENoComments );
133 :
134 1 : fail_unless( sp == INITPTR
135 : , "sp != INITPTR" );
136 : }
137 1 : END_TEST
138 : /* ------------------------------------------------------------------------- */
139 1 : START_TEST(test_mp_create7)
140 : {
141 1 : MinParser* sp = INITPTR;
142 :
143 1 : sp = mp_create( ""
144 : , "file.cfg"
145 : , ENoComments );
146 :
147 1 : fail_unless( sp == INITPTR
148 : , "sp != INITPTR" );
149 : }
150 1 : END_TEST
151 : /* ------------------------------------------------------------------------- */
152 1 : START_TEST(test_mp_create8)
153 : {
154 1 : MinParser* sp = INITPTR;
155 :
156 : char path[4096];
157 1 : sprintf(path, "%s", getenv("PWD"));
158 :
159 1 : sp = mp_create( path
160 : , "filee.cfg"
161 : , ENoComments );
162 :
163 1 : fail_unless( sp == INITPTR
164 : , "sp != INITPTR" );
165 : }
166 1 : END_TEST
167 : /* ------------------------------------------------------------------------- */
168 1 : START_TEST(test_mp_create9)
169 : {
170 1 : MinParser* sp = INITPTR;
171 :
172 : char path[4096];
173 1 : sprintf(path, "%s", getenv("PWD"));
174 :
175 1 : sp = mp_create( path
176 : , "file.cfg"
177 : , ENoComments );
178 :
179 1 : fail_unless( sp != INITPTR
180 : , "sp == INITPTR" );
181 :
182 1 : fclose(sp->file_);
183 : }
184 1 : END_TEST
185 : /* ------------------------------------------------------------------------- */
186 1 : START_TEST(test_mp_create10)
187 : {
188 1 : MinParser* sp = INITPTR;
189 :
190 : char path[4096];
191 1 : sprintf(path, "%s", getenv("PWD"));
192 :
193 1 : sp = mp_create( path
194 : , "file.cfg"
195 : , ENoComments );
196 :
197 1 : fail_unless( sp != INITPTR
198 : , "sp == INITPTR" );
199 :
200 1 : fclose(sp->file_);
201 : }
202 1 : END_TEST
203 : /* ------------------------------------------------------------------------- */
204 1 : START_TEST(test_mp_create11)
205 : {
206 1 : MinParser* sp = INITPTR;
207 :
208 : char path[4096];
209 1 : sprintf(path, "%s", getenv("PWD"));
210 :
211 1 : sp = mp_create( path
212 : , "file.cfg"
213 : , ENoComments );
214 :
215 1 : fail_unless( sp->file_ != INITPTR
216 : , "sp->file_ == INITPTR" );
217 :
218 1 : fclose(sp->file_);
219 : }
220 1 : END_TEST
221 : /* ------------------------------------------------------------------------- */
222 1 : START_TEST(test_mp_create12)
223 : {
224 1 : MinParser* sp = INITPTR;
225 :
226 : char path[4096];
227 1 : sprintf(path, "%s", getenv("PWD"));
228 :
229 1 : sp = mp_create( path
230 : , "file.cfg"
231 : , ECStyleComments );
232 :
233 1 : fail_unless( sp->offset_ == 0
234 : , "sp->offset_ differs from expected [%d]"
235 : , sp->offset_ );
236 :
237 1 : fclose(sp->file_);
238 : }
239 1 : END_TEST
240 : /* ------------------------------------------------------------------------- */
241 1 : START_TEST(test_mp_create13)
242 : {
243 1 : MinParser* sp = INITPTR;
244 :
245 : char path[4096];
246 1 : sprintf(path, "%s", getenv("PWD"));
247 :
248 1 : sp = mp_create( path
249 : , "file.cfg"
250 : , ENoComments );
251 :
252 1 : fail_unless( sp->comment_type_ == ENoComments
253 : , "sp->comment_type_ differs from expected [%d]"
254 : , sp->comment_type_ );
255 :
256 1 : fclose(sp->file_);
257 : }
258 1 : END_TEST
259 : /* ------------------------------------------------------------------------- */
260 1 : START_TEST(test_mp_create14)
261 : {
262 1 : MinParser* sp = INITPTR;
263 :
264 : char path[4096];
265 1 : sprintf(path, "%s", getenv("PWD"));
266 :
267 1 : sp = mp_create( path
268 : , "file.cfg"
269 : , ECStyleComments );
270 :
271 1 : fail_unless( sp->comment_type_ == ECStyleComments
272 : , "sp->comment_type_ differs from expected [%d]"
273 : , sp->comment_type_ );
274 :
275 1 : fclose(sp->file_);
276 : }
277 1 : END_TEST
278 : /* ------------------------------------------------------------------------- */
279 1 : START_TEST(test_mp_create15)
280 : {
281 1 : MinParser* sp = INITPTR;
282 :
283 : char path[4096];
284 1 : sprintf(path, "%s", getenv("PWD"));
285 :
286 1 : sp = mp_create( path
287 : , "file.cfg"
288 : , ENoComments );
289 :
290 1 : fail_unless( sp->parsing_mode_ == EFileParsing
291 : , "sp->parsing_mode_ differs from expected [%d]"
292 : , sp->parsing_mode_ );
293 :
294 1 : fclose(sp->file_);
295 : }
296 1 : END_TEST
297 : /* ------------------------------------------------------------------------- */
298 1 : START_TEST(test_mp_create16)
299 : {
300 1 : MinParser* sp = INITPTR;
301 :
302 : char path[4096];
303 1 : sprintf(path, "%s", getenv("PWD"));
304 :
305 1 : sp = mp_create( path
306 : , "file.cfg"
307 : , ENoComments );
308 :
309 1 : fail_unless( sp->is_unicode_ == EFileNotUnicode
310 : , "sp->is_unicode_ differs from expected [%d]"
311 : , sp->parsing_mode_ );
312 :
313 1 : fclose(sp->file_);
314 : }
315 1 : END_TEST
316 : /* ------------------------------------------------------------------------- */
317 1 : START_TEST(test_mp_create17)
318 : {
319 1 : MinParser* sp = INITPTR;
320 :
321 : char path[4096];
322 1 : sprintf(path, "%s", getenv("PWD"));
323 :
324 1 : sp = mp_create( path
325 : , "file.cfg"
326 : , ENoComments );
327 :
328 1 : fail_unless( sp->file_parser_ != INITPTR
329 : , "sp->file_parser_ == INITPTR" );
330 :
331 1 : fclose(sp->file_);
332 : }
333 1 : END_TEST
334 : /* ------------------------------------------------------------------------- */
335 1 : START_TEST(test_mp_create_mem)
336 : {
337 1 : MinParser* sp = INITPTR;
338 :
339 1 : sp = mp_create_mem( INITPTR
340 : , ENoComments );
341 :
342 1 : fail_unless( sp == INITPTR
343 : , "sp != INITPTR" );
344 : }
345 1 : END_TEST
346 : /* ------------------------------------------------------------------------- */
347 1 : START_TEST(test_mp_create_mem2)
348 : {
349 1 : MinParser* sp = INITPTR;
350 1 : char buff[] = "END_TEST\n\
351 : [Engine_Defaults]\n\
352 : TestReportMode= FullReport\n\
353 : CreateTestReport= YES\n\
354 : [End_Defaults]\n";
355 :
356 1 : sp = mp_create_mem( buff
357 : , ENoComments );
358 :
359 1 : fail_unless( sp != INITPTR
360 : , "sp == INITPTR" );
361 : }
362 1 : END_TEST
363 : /* ------------------------------------------------------------------------- */
364 1 : START_TEST(test_mp_create_mem3)
365 : {
366 1 : MinParser* sp = INITPTR;
367 1 : char buff[] = "END_TEST\n\
368 : [Engine_Defaults]\n\
369 : TestReportMode= FullReport\n\
370 : CreateTestReport= YES\n\
371 : [End_Defaults]\n";
372 :
373 1 : sp = mp_create_mem( buff
374 : , ENoComments );
375 :
376 1 : fail_unless( sp->file_ == INITPTR
377 : , "sp->file_ != INITPTR" );
378 : }
379 1 : END_TEST
380 : /* ------------------------------------------------------------------------- */
381 1 : START_TEST(test_mp_create_mem4)
382 : {
383 1 : MinParser* sp = INITPTR;
384 1 : char buff[] = "END_TEST\n\
385 : [Engine_Defaults]\n\
386 : TestReportMode= FullReport\n\
387 : CreateTestReport= YES\n\
388 : [End_Defaults]\n";
389 1 : sp = mp_create_mem( buff
390 : , ENoComments );
391 :
392 1 : fail_unless( sp->offset_ == 0
393 : , "sp->offset_ differs from expected [%d]"
394 : , sp->offset_ );
395 : }
396 1 : END_TEST
397 : /* ------------------------------------------------------------------------- */
398 1 : START_TEST(test_mp_create_mem5)
399 : {
400 1 : MinParser* sp = INITPTR;
401 1 : char buff[] = "END_TEST\n\
402 : [Engine_Defaults]\n\
403 : TestReportMode= FullReport\n\
404 : CreateTestReport= YES\n\
405 : [End_Defaults]\n";
406 :
407 1 : sp = mp_create_mem( buff
408 : , ENoComments );
409 :
410 1 : fail_unless( sp->comment_type_ == ENoComments
411 : , "sp->comment_type_ differs from expected value [%d]"
412 : , sp->comment_type_ );
413 : }
414 1 : END_TEST
415 : /* ------------------------------------------------------------------------- */
416 1 : START_TEST(test_mp_create_mem6)
417 : {
418 1 : MinParser* sp = INITPTR;
419 1 : char buff[] = "END_TEST\n\
420 : [Engine_Defaults]\n\
421 : TestReportMode= FullReport\n\
422 : CreateTestReport= YES\n\
423 : [End_Defaults]\n";
424 :
425 1 : sp = mp_create_mem( buff
426 : , ECStyleComments );
427 :
428 1 : fail_unless( sp->comment_type_ == ECStyleComments
429 : , "sp->comment_type_ differs from expected value [%d]"
430 : , sp->comment_type_ );
431 : }
432 1 : END_TEST
433 : /* ------------------------------------------------------------------------- */
434 1 : START_TEST(test_mp_create_mem7)
435 : {
436 1 : MinParser* sp = INITPTR;
437 1 : char buff[] = "END_TEST\n\
438 : [Engine_Defaults]\n\
439 : TestReportMode= FullReport\n\
440 : CreateTestReport= YES\n\
441 : [End_Defaults]\n";
442 :
443 1 : sp = mp_create_mem( buff
444 : , ENoComments );
445 :
446 1 : fail_unless( sp->buffer_tmp_ != INITPTR
447 : , "sp->buffer_tmp_ == INITPTR" );
448 : }
449 1 : END_TEST
450 : /* ------------------------------------------------------------------------- */
451 1 : START_TEST(test_mp_create_mem8)
452 : {
453 1 : MinParser* sp = INITPTR;
454 1 : char buff[] = "END_TEST\n\
455 : [Engine_Defaults]\n\
456 : TestReportMode= FullReport\n\
457 : CreateTestReport= YES\n\
458 : [End_Defaults]\n";
459 :
460 1 : sp = mp_create_mem( buff
461 : , ENoComments );
462 :
463 1 : fail_unless( sp->buffer_ != INITPTR
464 : , "sp->buffer_ == INITPTR" );
465 : }
466 1 : END_TEST
467 : /* ------------------------------------------------------------------------- */
468 1 : START_TEST(test_mp_create_mem9)
469 : {
470 1 : MinParser* sp = INITPTR;
471 1 : char buff[] = "END_TEST\n\
472 : [Engine_Defaults]\n\
473 : TestReportMode= FullReport\n\
474 : CreateTestReport= YES\n\
475 : [End_Defaults]\n";
476 :
477 1 : sp = mp_create_mem( buff
478 : , ENoComments );
479 :
480 1 : fail_unless( sp->is_unicode_ == EFileNotUnicode
481 : , "sp->is_unicode_ differs from expected [%d]"
482 : , sp->is_unicode_ );
483 : }
484 1 : END_TEST
485 : /* ------------------------------------------------------------------------- */
486 1 : START_TEST(test_mp_create_mem10)
487 : {
488 1 : MinParser* sp = INITPTR;
489 1 : char buff[] = "END_TEST\n\
490 : [Engine_Defaults]\n\
491 : TestReportMode= FullReport\n\
492 : CreateTestReport= YES\n\
493 : [End_Defaults]\n";
494 :
495 1 : sp = mp_create_mem( buff
496 : , ENoComments );
497 :
498 1 : fail_unless( sp->file_parser_ == INITPTR
499 : , "sp->file_parser_ != INITPTR" );
500 : }
501 1 : END_TEST
502 : /* ------------------------------------------------------------------------- */
503 1 : START_TEST(test_mp_create_mem11)
504 : {
505 1 : MinParser* sp = INITPTR;
506 1 : char buff[] = "END_TEST\n\
507 : [Engine_Defaults]\n\
508 : TestReportMode= FullReport\n\
509 : CreateTestReport= YES\n\
510 : [End_Defaults]\n";
511 :
512 1 : sp = mp_create_mem( buff
513 : , ENoComments );
514 :
515 1 : fail_unless( strcmp(sp->buffer_tmp_,buff) == 0
516 : , "sp->buffer_tmp_ differs from expected [%s]"
517 : , sp->buffer_tmp_ );
518 : }
519 1 : END_TEST
520 : /* ------------------------------------------------------------------------- */
521 1 : START_TEST(test_mp_destroy)
522 : {
523 1 : MinParser* sp = INITPTR;
524 1 : mp_destroy(&sp);
525 : }
526 1 : END_TEST
527 : /* ------------------------------------------------------------------------- */
528 1 : START_TEST(test_mp_destroy2)
529 : {
530 1 : MinParser* sp = INITPTR;
531 1 : char buff[] = "END_TEST\n\
532 : [Engine_Defaults]\n\
533 : TestReportMode= FullReport\n\
534 : CreateTestReport= YES\n\
535 : [End_Defaults]\n";
536 :
537 1 : sp = mp_create_mem( buff
538 : , ENoComments );
539 1 : mp_destroy(&sp);
540 :
541 1 : fail_unless( sp == INITPTR, "sp != INITPTR" );
542 : }
543 1 : END_TEST
544 : /* ------------------------------------------------------------------------- */
545 1 : START_TEST(test_mp_destroy3)
546 : {
547 1 : MinParser* sp = INITPTR;
548 1 : sp = mp_create( "/home/maemo/work/min/debug/tests/"
549 : , "file.cfg"
550 : , ENoComments );
551 1 : mp_destroy(&sp);
552 1 : fail_unless( sp == INITPTR, "sp != INITPTR" );
553 : }
554 1 : END_TEST
555 : /* ------------------------------------------------------------------------- */
556 1 : START_TEST(test_mp_section)
557 : {
558 1 : MinParser* sp = INITPTR;
559 1 : MinSectionParser* msp = INITPTR;
560 :
561 1 : msp = mp_section( sp
562 : , "StartTag"
563 : , "EndTag"
564 : , 1 );
565 :
566 1 : fail_unless( msp == INITPTR
567 : , "msp != INITPTR" );
568 : }
569 1 : END_TEST
570 : /* ------------------------------------------------------------------------- */
571 1 : START_TEST(test_mp_section2)
572 : {
573 1 : MinParser* sp = INITPTR;
574 1 : MinSectionParser* msp = INITPTR;
575 :
576 : char path[4096];
577 1 : sprintf(path, "%s", getenv("PWD"));
578 :
579 1 : sp = mp_create( path
580 : , "file.cfg"
581 : , ENoComments );
582 :
583 1 : msp = mp_section( sp
584 : , INITPTR
585 : , "End_Defaults"
586 : , 1 );
587 :
588 1 : fail_unless( msp == INITPTR
589 : , "msp != INITPTR" );
590 1 : mp_destroy(&sp);
591 : }
592 1 : END_TEST
593 : /* ------------------------------------------------------------------------- */
594 1 : START_TEST(test_mp_section3)
595 : {
596 1 : MinParser* sp = INITPTR;
597 1 : MinSectionParser* msp = INITPTR;
598 :
599 : char path[4096];
600 1 : sprintf(path, "%s", getenv("PWD"));
601 :
602 1 : sp = mp_create( path
603 : , "file.cfg"
604 : , ENoComments );
605 :
606 1 : msp = mp_section( sp
607 : , "Engine_Defaults"
608 : , INITPTR
609 : , 1 );
610 :
611 1 : fail_unless( msp == INITPTR
612 : , "msp != INITPTR" );
613 1 : mp_destroy(&sp);
614 : }
615 1 : END_TEST
616 : /* ------------------------------------------------------------------------- */
617 1 : START_TEST(test_mp_section4)
618 : {
619 1 : MinParser* sp = INITPTR;
620 1 : MinSectionParser* msp = INITPTR;
621 :
622 : char path[4096];
623 1 : sprintf(path, "%s", getenv("PWD"));
624 :
625 1 : sp = mp_create( path
626 : , "file.cfg"
627 : , ENoComments );
628 :
629 1 : msp = mp_section( sp
630 : , "Engine_Defaults"
631 : , "End_Defaults"
632 : , -1 );
633 :
634 1 : fail_unless( msp == INITPTR
635 : , "msp != INITPTR" );
636 1 : mp_destroy(&sp);
637 : }
638 1 : END_TEST
639 : /* ------------------------------------------------------------------------- */
640 1 : START_TEST(test_mp_section5)
641 : {
642 1 : MinParser* sp = INITPTR;
643 1 : MinSectionParser* msp = INITPTR;
644 :
645 : char path[4096];
646 1 : sprintf(path, "%s", getenv("PWD"));
647 :
648 1 : sp = mp_create( path
649 : , "file.cfg"
650 : , ENoComments );
651 :
652 1 : msp = mp_section( sp
653 : , "Engine_Defaults"
654 : , "End_Defaults"
655 : , 0 );
656 :
657 1 : fail_unless( msp == INITPTR
658 : , "msp != INITPTR" );
659 1 : mp_destroy(&sp);
660 : }
661 1 : END_TEST
662 : /* ------------------------------------------------------------------------- */
663 1 : START_TEST(test_mp_section6)
664 : {
665 1 : MinParser* sp = INITPTR;
666 1 : MinSectionParser* msp = INITPTR;
667 1 : char buff[] = "END_TEST\n\
668 : [Engine_Defaults]\n\
669 : TestReportMode= FullReport\n\
670 : CreateTestReport= YES\n\
671 : [End_Defaults]\n";
672 :
673 1 : sp = mp_create_mem( buff
674 : , ENoComments );
675 :
676 1 : msp = mp_section( sp
677 : , INITPTR
678 : , "End_Defaults"
679 : , 1 );
680 :
681 1 : fail_unless( msp == INITPTR
682 : , "msp != INITPTR" );
683 1 : mp_destroy(&sp);
684 : }
685 1 : END_TEST
686 : /* ------------------------------------------------------------------------- */
687 1 : START_TEST(test_mp_section7)
688 : {
689 1 : MinParser* sp = INITPTR;
690 1 : MinSectionParser* msp = INITPTR;
691 1 : char buff[] = "END_TEST\n\
692 : [Engine_Defaults]\n\
693 : TestReportMode= FullReport\n\
694 : CreateTestReport= YES\n\
695 : [End_Defaults]\n";
696 :
697 1 : sp = mp_create_mem( buff
698 : , ENoComments );
699 :
700 1 : msp = mp_section( sp
701 : , "Engine_Defaults"
702 : , INITPTR
703 : , 1 );
704 :
705 1 : fail_unless( msp == INITPTR
706 : , "msp != INITPTR" );
707 1 : mp_destroy(&sp);
708 : }
709 1 : END_TEST
710 : /* ------------------------------------------------------------------------- */
711 1 : START_TEST(test_mp_section8)
712 : {
713 1 : MinParser* sp = INITPTR;
714 1 : MinSectionParser* msp = INITPTR;
715 1 : char buff[] = "END_TEST\n\
716 : [Engine_Defaults]\n\
717 : TestReportMode= FullReport\n\
718 : CreateTestReport= YES\n\
719 : [End_Defaults]\n";
720 :
721 1 : sp = mp_create_mem( buff
722 : , ENoComments );
723 :
724 1 : msp = mp_section( sp
725 : , "Engine_Defaults"
726 : , "End_Defaults"
727 : , -1 );
728 :
729 1 : fail_unless( msp == INITPTR
730 : , "msp != INITPTR" );
731 1 : mp_destroy(&sp);
732 : }
733 1 : END_TEST
734 : /* ------------------------------------------------------------------------- */
735 1 : START_TEST(test_mp_section9)
736 : {
737 1 : MinParser* sp = INITPTR;
738 1 : MinSectionParser* msp = INITPTR;
739 1 : char buff[] = "END_TEST\n\
740 : [Engine_Defaults]\n\
741 : TestReportMode= FullReport\n\
742 : CreateTestReport= YES\n\
743 : [End_Defaults]\n";
744 :
745 1 : sp = mp_create_mem( buff
746 : , ENoComments );
747 :
748 1 : msp = mp_section( sp
749 : , "Engine_Defaults"
750 : , "End_Defaults"
751 : , 0 );
752 :
753 1 : fail_unless( msp == INITPTR
754 : , "msp != INITPTR" );
755 1 : mp_destroy(&sp);
756 : }
757 1 : END_TEST
758 : /* ------------------------------------------------------------------------- */
759 1 : START_TEST(test_mp_section10)
760 : {
761 1 : MinParser* sp = INITPTR;
762 1 : MinSectionParser* msp = INITPTR;
763 1 : char buff[] ="[Engine_Defaults]\n\
764 : TestReportMode= FullReport\n\
765 : CreateTestReport= YES\n\
766 : [End_Defaults]";
767 :
768 1 : sp = mp_create_mem( buff
769 : , ENoComments );
770 :
771 1 : msp = mp_section( sp
772 : , "[Engine_Defaults]"
773 : , "[End_Defaults]"
774 : , 1 );
775 :
776 1 : fail_unless( msp != INITPTR
777 : , "msp == INITPTR" );
778 1 : mmp_destroy(&msp);
779 1 : mp_destroy(&sp);
780 : }
781 1 : END_TEST
782 : /* ------------------------------------------------------------------------- */
783 1 : START_TEST(test_mp_section11)
784 : {
785 1 : MinParser* sp = INITPTR;
786 1 : MinSectionParser* msp = INITPTR;
787 1 : char buff[] ="[Engine_Defaults]\n\
788 : TestReportMode= FullReport\n\
789 : [End_Defaults]";
790 :
791 1 : sp = mp_create_mem( buff
792 : , ENoComments );
793 :
794 1 : msp = mp_section( sp
795 : , "[Engine_Defaults]"
796 : , "[End_Defaults]"
797 : , 1 );
798 :
799 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n ") == 0
800 : , "Result differs from expected [%s]"
801 : , msp->section_ );
802 1 : mmp_destroy(&msp);
803 1 : mp_destroy(&sp);
804 : }
805 1 : END_TEST
806 : /* ------------------------------------------------------------------------- */
807 1 : START_TEST(test_mp_section12)
808 : {
809 1 : MinParser* sp = INITPTR;
810 1 : MinSectionParser* msp = INITPTR;
811 1 : char buff[] ="\n\n\n[Engine_Defaults]\n\
812 : TestReportMode= FullReport\n\
813 : [End_Defaults]";
814 :
815 1 : sp = mp_create_mem( buff
816 : , ENoComments );
817 :
818 1 : msp = mp_section( sp
819 : , "[Engine_Defaults]"
820 : , "[End_Defaults]"
821 : , 1 );
822 :
823 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n ") == 0
824 : , "Result differs from expected [%s]"
825 : , msp->section_ );
826 1 : mmp_destroy(&msp);
827 1 : mp_destroy(&sp);
828 : }
829 1 : END_TEST
830 : /* ------------------------------------------------------------------------- */
831 1 : START_TEST(test_mp_section13)
832 : {
833 1 : MinParser* sp = INITPTR;
834 1 : MinSectionParser* msp = INITPTR;
835 1 : char buff[] =" [Engine_Defaults]\n\
836 : TestReportMode= FullReport\n\
837 : [End_Defaults] \n";
838 :
839 1 : sp = mp_create_mem( buff
840 : , ENoComments );
841 :
842 1 : msp = mp_section( sp
843 : , "[Engine_Defaults]"
844 : , "[End_Defaults]"
845 : , 1 );
846 :
847 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n ") == 0
848 : , "Result differs from expected [%s]"
849 : , msp->section_ );
850 1 : mmp_destroy(&msp);
851 1 : mp_destroy(&sp);
852 : }
853 1 : END_TEST
854 : /* ------------------------------------------------------------------------- */
855 1 : START_TEST(test_mp_section14)
856 : {
857 1 : MinParser* sp = INITPTR;
858 1 : MinSectionParser* msp = INITPTR;
859 1 : char buff[] ="[Engine_Defaults]\nTestReportMode= FullReport\n[End_Defaults]";
860 :
861 1 : sp = mp_create_mem( buff
862 : , ENoComments );
863 :
864 1 : msp = mp_section( sp
865 : , "[Engine_Defaults]"
866 : , "[End_Defaults]"
867 : , 1 );
868 :
869 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n") == 0
870 : , "Result differs from expected [%s]"
871 : , msp->section_ );
872 1 : mmp_destroy(&msp);
873 1 : mp_destroy(&sp);
874 : }
875 1 : END_TEST
876 : /* ------------------------------------------------------------------------- */
877 1 : START_TEST(test_mp_section15)
878 : {
879 1 : MinParser* sp = INITPTR;
880 1 : MinSectionParser* msp = INITPTR;
881 1 : char buff[] ="[Engine_Defaults]\nTestReportMode= FullReport\n[End_Defaults] \n\n\n\n";
882 :
883 1 : sp = mp_create_mem( buff
884 : , ENoComments );
885 :
886 1 : msp = mp_section( sp
887 : , "[Engine_Defaults]"
888 : , "[End_Defaults]"
889 : , 1 );
890 :
891 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n") == 0
892 : , "Result differs from expected [%s]"
893 : , msp->section_ );
894 1 : mmp_destroy(&msp);
895 1 : mp_destroy(&sp);
896 : }
897 1 : END_TEST
898 : /* ------------------------------------------------------------------------- */
899 1 : START_TEST(test_mp_section16)
900 : {
901 1 : MinParser* sp = INITPTR;
902 1 : MinSectionParser* msp = INITPTR;
903 1 : char buff[] ="\n\n\n[Engine_Defaults]\nTestReportMode= FullReport\n[End_Defaults]\n\n\n";
904 :
905 1 : sp = mp_create_mem( buff
906 : , ENoComments );
907 :
908 1 : msp = mp_section( sp
909 : , "[Engine_Defaults]"
910 : , "[End_Defaults]"
911 : , 1 );
912 :
913 1 : fail_unless( strcmp(msp->section_,"TestReportMode= FullReport\n") == 0
914 : , "Result differs from expected [%s]"
915 : , msp->section_ );
916 1 : mmp_destroy(&msp);
917 1 : mp_destroy(&sp);
918 : }
919 1 : END_TEST
920 : /* ------------------------------------------------------------------------- */
921 0 : START_TEST(test_mp_section17)
922 : {
923 0 : MinParser* sp = INITPTR;
924 0 : MinSectionParser* msp = INITPTR;
925 :
926 : char path[4096];
927 0 : sprintf(path, "%s", getenv("PWD"));
928 :
929 0 : sp = mp_create( path
930 : , "Example.cfg"
931 : , ENoComments );
932 :
933 0 : msp = mp_section( sp
934 : , "[Test]"
935 : , "[Endtest]"
936 : , 1 );
937 :
938 0 : fail_unless( strcmp(msp->section_,"title ExampleExample\ncreate KahdeksanTestModule.so foobar\nfoobar Example kaks pa ra me ters\ndelete foobar \n") == 0
939 : , "Result differs from expected [%s]"
940 : , msp->section_ );
941 0 : mmp_destroy(&msp);
942 0 : mp_destroy(&sp);
943 : }
944 0 : END_TEST
945 : /* ------------------------------------------------------------------------- */
946 1 : START_TEST(test_mp_next_section)
947 : {
948 1 : MinParser* sp = INITPTR;
949 1 : MinSectionParser* msp = INITPTR;
950 :
951 1 : msp = mp_next_section( sp
952 : , "StartTag"
953 : , "EndTag"
954 : , 1 );
955 :
956 1 : fail_unless( msp == INITPTR
957 : , "msp != INITPTR" );
958 : }
959 1 : END_TEST
960 : /* ------------------------------------------------------------------------- */
961 1 : START_TEST(test_mp_next_section2)
962 : {
963 1 : MinParser* sp = INITPTR;
964 1 : MinSectionParser* msp = INITPTR;
965 :
966 : char path[4096];
967 1 : sprintf(path, "%s", getenv("PWD"));
968 :
969 1 : sp = mp_create( path
970 : , "file.cfg"
971 : , ENoComments );
972 :
973 1 : msp = mp_next_section( sp
974 : , INITPTR
975 : , "End_Defaults"
976 : , 1 );
977 :
978 1 : fail_unless( msp == INITPTR
979 : , "msp != INITPTR" );
980 1 : mp_destroy(&sp);
981 : }
982 1 : END_TEST
983 : /* ------------------------------------------------------------------------- */
984 1 : START_TEST(test_mp_next_section3)
985 : {
986 1 : MinParser* sp = INITPTR;
987 1 : MinSectionParser* msp = INITPTR;
988 :
989 : char path[4096];
990 1 : sprintf(path, "%s", getenv("PWD"));
991 :
992 1 : sp = mp_create( path
993 : , "file.cfg"
994 : , ENoComments );
995 :
996 1 : msp = mp_next_section( sp
997 : , "Engine_Defaults"
998 : , INITPTR
999 : , 1 );
1000 :
1001 1 : fail_unless( msp == INITPTR
1002 : , "msp != INITPTR" );
1003 1 : mp_destroy(&sp);
1004 : }
1005 1 : END_TEST
1006 : /* ------------------------------------------------------------------------- */
1007 1 : START_TEST(test_mp_next_section4)
1008 : {
1009 1 : MinParser* sp = INITPTR;
1010 1 : MinSectionParser* msp = INITPTR;
1011 :
1012 : char path[4096];
1013 1 : sprintf(path, "%s", getenv("PWD"));
1014 :
1015 1 : sp = mp_create( path
1016 : , "file.cfg"
1017 : , ENoComments );
1018 :
1019 1 : msp = mp_next_section( sp
1020 : , "Engine_Defaults"
1021 : , "End_Defaults"
1022 : , -1 );
1023 :
1024 1 : fail_unless( msp == INITPTR
1025 : , "msp != INITPTR" );
1026 1 : mp_destroy(&sp);
1027 : }
1028 1 : END_TEST
1029 : /* ------------------------------------------------------------------------- */
1030 1 : START_TEST(test_mp_next_section5)
1031 : {
1032 1 : MinParser* sp = INITPTR;
1033 1 : MinSectionParser* msp = INITPTR;
1034 :
1035 : char path[4096];
1036 1 : sprintf(path, "%s", getenv("PWD"));
1037 :
1038 1 : sp = mp_create( path
1039 : , "file.cfg"
1040 : , ENoComments );
1041 :
1042 1 : msp = mp_next_section( sp
1043 : , "Engine_Defaults"
1044 : , "End_Defaults"
1045 : , 0 );
1046 :
1047 1 : fail_unless( msp == INITPTR
1048 : , "msp != INITPTR" );
1049 1 : mp_destroy(&sp);
1050 : }
1051 1 : END_TEST
1052 : /* ------------------------------------------------------------------------- */
1053 1 : START_TEST(test_mp_next_section6)
1054 : {
1055 1 : MinParser* sp = INITPTR;
1056 1 : MinSectionParser* msp = INITPTR;
1057 1 : char buff[] = "END_TEST\n\
1058 : [Engine_Defaults]\n\
1059 : TestReportMode= FullReport\n\
1060 : CreateTestReport= YES\n\
1061 : [End_Defaults]\n";
1062 :
1063 1 : sp = mp_create_mem( buff
1064 : , ENoComments );
1065 :
1066 1 : msp = mp_next_section( sp
1067 : , INITPTR
1068 : , "End_Defaults"
1069 : , 1 );
1070 :
1071 1 : fail_unless( msp == INITPTR
1072 : , "msp != INITPTR" );
1073 1 : mp_destroy(&sp);
1074 : }
1075 1 : END_TEST
1076 : /* ------------------------------------------------------------------------- */
1077 1 : START_TEST(test_mp_next_section7)
1078 : {
1079 1 : MinParser* sp = INITPTR;
1080 1 : MinSectionParser* msp = INITPTR;
1081 1 : char buff[] = "END_TEST\n\
1082 : [Engine_Defaults]\n\
1083 : TestReportMode= FullReport\n\
1084 : CreateTestReport= YES\n\
1085 : [End_Defaults]\n";
1086 :
1087 1 : sp = mp_create_mem( buff
1088 : , ENoComments );
1089 :
1090 1 : msp = mp_next_section( sp
1091 : , "Engine_Defaults"
1092 : , INITPTR
1093 : , 1 );
1094 :
1095 1 : fail_unless( msp == INITPTR
1096 : , "msp != INITPTR" );
1097 1 : mp_destroy(&sp);
1098 : }
1099 1 : END_TEST
1100 : /* ------------------------------------------------------------------------- */
1101 1 : START_TEST(test_mp_next_section8)
1102 : {
1103 1 : MinParser* sp = INITPTR;
1104 1 : MinSectionParser* msp = INITPTR;
1105 1 : char buff[] = "END_TEST\n\
1106 : [Engine_Defaults]\n\
1107 : TestReportMode= FullReport\n\
1108 : CreateTestReport= YES\n\
1109 : [End_Defaults]\n";
1110 :
1111 1 : sp = mp_create_mem( buff
1112 : , ENoComments );
1113 :
1114 1 : msp = mp_next_section( sp
1115 : , "Engine_Defaults"
1116 : , "End_Defaults"
1117 : , -1 );
1118 :
1119 1 : fail_unless( msp == INITPTR
1120 : , "msp != INITPTR" );
1121 1 : mp_destroy(&sp);
1122 : }
1123 1 : END_TEST
1124 : /* ------------------------------------------------------------------------- */
1125 1 : START_TEST(test_mp_next_section9)
1126 : {
1127 1 : MinParser* sp = INITPTR;
1128 1 : MinSectionParser* msp = INITPTR;
1129 1 : char buff[] = "END_TEST\n\
1130 : [Engine_Defaults]\n\
1131 : TestReportMode= FullReport\n\
1132 : CreateTestReport= YES\n\
1133 : [End_Defaults]\n";
1134 :
1135 1 : sp = mp_create_mem( buff
1136 : , ENoComments );
1137 :
1138 1 : msp = mp_next_section( sp
1139 : , "Engine_Defaults"
1140 : , "End_Defaults"
1141 : , 0 );
1142 :
1143 1 : fail_unless( msp == INITPTR
1144 : , "msp != INITPTR" );
1145 1 : mp_destroy(&sp);
1146 : }
1147 1 : END_TEST
1148 : /* ------------------------------------------------------------------------- */
1149 1 : START_TEST(test_mp_next_section10)
1150 : {
1151 1 : MinParser* sp = INITPTR;
1152 1 : MinSectionParser* msp = INITPTR;
1153 1 : char buff[] = "[New_Module]\n\
1154 : ModuleName= demomodule\n\
1155 : [End_Module]\n\
1156 : \n\
1157 : [New_Module]\n\
1158 : ModuleName= demomodule2\n\
1159 : [End_Module]\n\
1160 : \n\
1161 : [New_Module]\n\
1162 : ModuleName= demomodule3\n\
1163 : [End_Module]\n\
1164 : \n\
1165 : [New_Module]\n\
1166 : ModuleName= demomodule4\n\
1167 : [End_Module]\n";
1168 :
1169 : char path[4096];
1170 1 : sprintf(path, "%s", getenv("PWD"));
1171 :
1172 1 : sp = mp_create( path
1173 : , "module.cfg"
1174 : , ENoComments );
1175 :
1176 1 : msp = mp_next_section( sp
1177 : , "[New_Module]"
1178 : , "[End_Module]"
1179 : , 1 );
1180 :
1181 1 : fail_unless( msp != INITPTR
1182 : , "msp == INITPTR" );
1183 1 : mp_destroy(&sp);
1184 : }
1185 1 : END_TEST
1186 : /* ------------------------------------------------------------------------- */
1187 1 : START_TEST(test_mp_next_section11)
1188 : {
1189 1 : MinParser* sp = INITPTR;
1190 1 : MinSectionParser* msp = INITPTR;
1191 1 : char buff[] = "[New_Module]\n\
1192 : ModuleName= demomodule\n\
1193 : [End_Module]\n\
1194 : \n\
1195 : [New_Module]\n\
1196 : ModuleName= demomodule2\n\
1197 : [End_Module]\n\
1198 : \n\
1199 : [New_Module]\n\
1200 : ModuleName= demomodule3\n\
1201 : [End_Module]\n\
1202 : \n\
1203 : [New_Module]\n\
1204 : ModuleName= demomodule4\n\
1205 : [End_Module]\n";
1206 :
1207 : char path[4096];
1208 1 : sprintf(path, "%s", getenv("PWD"));
1209 :
1210 1 : sp = mp_create( path
1211 : , "module.cfg"
1212 : , ENoComments );
1213 :
1214 1 : msp = mp_next_section( sp
1215 : , "[New_Module]"
1216 : , "[End_Module]"
1217 : , 1 );
1218 :
1219 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule\n") == 0
1220 : , "Result differs from expected [%s]"
1221 : , msp->section_ );
1222 1 : mp_destroy(&sp);
1223 : }
1224 1 : END_TEST
1225 : /* ------------------------------------------------------------------------- */
1226 1 : START_TEST(test_mp_next_section12)
1227 : {
1228 1 : MinParser* sp = INITPTR;
1229 1 : MinSectionParser* msp = INITPTR;
1230 1 : char buff[] = "[New_Module]\n\
1231 : ModuleName= demomodule\n\
1232 : [End_Module]\n\
1233 : \n\
1234 : [New_Module]\n\
1235 : ModuleName= demomodule2\n\
1236 : [End_Module]\n\
1237 : \n\
1238 : [New_Module]\n\
1239 : ModuleName= demomodule3\n\
1240 : [End_Module]\n\
1241 : \n\
1242 : [New_Module]\n\
1243 : ModuleName= demomodule4\n\
1244 : [End_Module]\n";
1245 :
1246 : char path[4096];
1247 1 : sprintf(path, "%s", getenv("PWD"));
1248 :
1249 1 : sp = mp_create( path
1250 : , "module.cfg"
1251 : , ENoComments );
1252 :
1253 1 : msp = mp_next_section( sp
1254 : , "[New_Module]"
1255 : , "[End_Module]"
1256 : , 2 );
1257 :
1258 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule2\n") == 0
1259 : , "Result differs from expected [%s]"
1260 : , msp->section_ );
1261 1 : mp_destroy(&sp);
1262 : }
1263 1 : END_TEST
1264 : /* ------------------------------------------------------------------------- */
1265 1 : START_TEST(test_mp_next_section_file)
1266 : {
1267 1 : MinParser* sp = INITPTR;
1268 1 : MinSectionParser* msp = INITPTR;
1269 :
1270 1 : msp = mp_next_section_file( sp
1271 : , "StartTag"
1272 : , "EndTag"
1273 : , 1 );
1274 1 : fail_unless( msp == INITPTR
1275 : , "msp != INITPTR" );
1276 : }
1277 1 : END_TEST
1278 : /* ------------------------------------------------------------------------- */
1279 1 : START_TEST(test_mp_next_section_file2)
1280 : {
1281 1 : MinParser* sp = INITPTR;
1282 1 : MinSectionParser* msp = INITPTR;
1283 :
1284 : char path[4096];
1285 1 : sprintf(path, "%s", getenv("PWD"));
1286 :
1287 1 : sp = mp_create( path
1288 : , "file.cfg"
1289 : , ENoComments );
1290 1 : msp = mp_next_section_file( sp
1291 : , INITPTR
1292 : , "EndTag"
1293 : , 1 );
1294 1 : fail_unless( msp == INITPTR
1295 : , "msp != INITPTR" );
1296 :
1297 1 : mp_destroy(&sp);
1298 : }
1299 1 : END_TEST
1300 : /* ------------------------------------------------------------------------- */
1301 1 : START_TEST(test_mp_next_section_file3)
1302 : {
1303 1 : MinParser* sp = INITPTR;
1304 1 : MinSectionParser* msp = INITPTR;
1305 :
1306 : char path[4096];
1307 1 : sprintf(path, "%s", getenv("PWD"));
1308 :
1309 1 : sp = mp_create( path
1310 : , "file.cfg"
1311 : , ENoComments );
1312 1 : msp = mp_next_section_file( sp
1313 : , "StartTag"
1314 : , INITPTR
1315 : , 1 );
1316 1 : fail_unless( msp == INITPTR
1317 : , "msp != INITPTR" );
1318 :
1319 1 : mp_destroy(&sp);
1320 : }
1321 1 : END_TEST
1322 : /* ------------------------------------------------------------------------- */
1323 1 : START_TEST(test_mp_next_section_file4)
1324 : {
1325 1 : MinParser* sp = INITPTR;
1326 1 : MinSectionParser* msp = INITPTR;
1327 :
1328 : char path[4096];
1329 1 : sprintf(path, "%s", getenv("PWD"));
1330 :
1331 1 : sp = mp_create( path
1332 : , "file.cfg"
1333 : , ENoComments );
1334 1 : msp = mp_next_section_file( sp
1335 : , "StartTag"
1336 : , "EndTag"
1337 : , -1 );
1338 1 : fail_unless( msp == INITPTR
1339 : , "msp != INITPTR" );
1340 :
1341 1 : mp_destroy(&sp);
1342 : }
1343 1 : END_TEST
1344 : /* ------------------------------------------------------------------------- */
1345 1 : START_TEST(test_mp_next_section_file5)
1346 : {
1347 1 : MinParser* sp = INITPTR;
1348 1 : MinSectionParser* msp = INITPTR;
1349 :
1350 : char path[4096];
1351 1 : sprintf(path, "%s", getenv("PWD"));
1352 :
1353 1 : sp = mp_create( path
1354 : , "file.cfg"
1355 : , ENoComments );
1356 1 : msp = mp_next_section_file( sp
1357 : , "StartTag"
1358 : , "EndTag"
1359 : , 0 );
1360 1 : fail_unless( msp == INITPTR
1361 : , "msp != INITPTR" );
1362 :
1363 1 : mp_destroy(&sp);
1364 : }
1365 1 : END_TEST
1366 : /* ------------------------------------------------------------------------- */
1367 1 : START_TEST(test_mp_next_section_file6)
1368 : {
1369 1 : MinParser* sp = INITPTR;
1370 1 : MinSectionParser* msp = INITPTR;
1371 :
1372 : char path[4096];
1373 1 : sprintf(path, "%s", getenv("PWD"));
1374 :
1375 1 : sp = mp_create( path
1376 : , "file.cfg"
1377 : , ENoComments );
1378 1 : msp = mp_next_section_file( sp
1379 : , "[Engine_Defaults]"
1380 : , "[End_Defaults]"
1381 : , 1 );
1382 :
1383 1 : fail_unless( msp != INITPTR
1384 : , "msp == INITPTR" );
1385 :
1386 1 : mmp_destroy(&msp);
1387 1 : mp_destroy(&sp);
1388 : }
1389 1 : END_TEST
1390 : /* ------------------------------------------------------------------------- */
1391 1 : START_TEST(test_mp_next_section_file7)
1392 : {
1393 1 : MinParser* sp = INITPTR;
1394 1 : MinSectionParser* msp = INITPTR;
1395 :
1396 : char path[4096];
1397 1 : sprintf(path, "%s", getenv("PWD"));
1398 :
1399 1 : sp = mp_create( path
1400 : , "min.cfg"
1401 : , ENoComments );
1402 1 : msp = mp_next_section_file( sp
1403 : , "[New_Module]"
1404 : , "[End_Module]"
1405 : , 1 );
1406 :
1407 1 : fail_unless( msp != INITPTR
1408 : , "msp == INITPTR" );
1409 :
1410 1 : mmp_destroy(&msp);
1411 1 : mp_destroy(&sp);
1412 : }
1413 1 : END_TEST
1414 : /* ------------------------------------------------------------------------- */
1415 1 : START_TEST(test_mp_next_section_file8)
1416 : {
1417 1 : MinParser* sp = INITPTR;
1418 1 : MinSectionParser* msp = INITPTR;
1419 1 : char* exp = "ModuleName= demomodule\n";
1420 :
1421 : char path[4096];
1422 1 : sprintf(path, "%s", getenv("PWD"));
1423 :
1424 1 : sp = mp_create( path
1425 : , "min.cfg"
1426 : , ENoComments );
1427 :
1428 1 : msp = mp_next_section_file( sp
1429 : , "[New_Module]"
1430 : , "[End_Module]"
1431 : , 1 );
1432 1 : fail_unless( strcmp(msp->buffer_section_,exp) == 0
1433 : , "Returned value differs from expected [%s]"
1434 : , msp->buffer_section_ );
1435 :
1436 1 : mmp_destroy(&msp);
1437 1 : mp_destroy(&sp);
1438 : }
1439 1 : END_TEST
1440 : /* ------------------------------------------------------------------------- */
1441 1 : START_TEST(test_mp_next_section_memory)
1442 : {
1443 1 : MinParser* sp = INITPTR;
1444 1 : MinSectionParser* msp = INITPTR;
1445 :
1446 1 : msp = mp_next_section_memory( sp
1447 : , "StartTag"
1448 : , "EndTag"
1449 : , 1 );
1450 1 : fail_unless( msp == INITPTR
1451 : , "msp != INITPTR" );
1452 : }
1453 1 : END_TEST
1454 : /* ------------------------------------------------------------------------- */
1455 1 : START_TEST(test_mp_next_section_memory2)
1456 : {
1457 1 : MinParser* sp = INITPTR;
1458 1 : MinSectionParser* msp = INITPTR;
1459 1 : char buff[] = "[New_Module]\n\
1460 : ModuleName= demomodule\n\
1461 : [End_Module]\n\
1462 : \n\
1463 : [New_Module]\n\
1464 : ModuleName= demomodule2\n\
1465 : [End_Module]\n\
1466 : \n\
1467 : [New_Module]\n\
1468 : ModuleName= demomodule3\n\
1469 : [End_Module]\n\
1470 : \n\
1471 : [New_Module]\n\
1472 : ModuleName= demomodule4\n\
1473 : [End_Module]\n";
1474 :
1475 1 : sp = mp_create_mem( buff
1476 : , ENoComments );
1477 1 : msp = mp_next_section_memory( sp
1478 : , INITPTR
1479 : , "EndTag"
1480 : , 1 );
1481 1 : fail_unless( msp == INITPTR
1482 : , "msp != INITPTR" );
1483 :
1484 1 : mp_destroy(&sp);
1485 : }
1486 1 : END_TEST
1487 : /* ------------------------------------------------------------------------- */
1488 1 : START_TEST(test_mp_next_section_memory3)
1489 : {
1490 1 : MinParser* sp = INITPTR;
1491 1 : MinSectionParser* msp = INITPTR;
1492 1 : char buff[] = "[New_Module]\n\
1493 : ModuleName= demomodule\n\
1494 : [End_Module]\n\
1495 : \n\
1496 : [New_Module]\n\
1497 : ModuleName= demomodule2\n\
1498 : [End_Module]\n\
1499 : \n\
1500 : [New_Module]\n\
1501 : ModuleName= demomodule3\n\
1502 : [End_Module]\n\
1503 : \n\
1504 : [New_Module]\n\
1505 : ModuleName= demomodule4\n\
1506 : [End_Module]\n";
1507 :
1508 1 : sp = mp_create_mem( buff
1509 : , ENoComments );
1510 1 : msp = mp_next_section_memory( sp
1511 : , "StartTag"
1512 : , INITPTR
1513 : , 1 );
1514 1 : fail_unless( msp == INITPTR
1515 : , "msp != INITPTR" );
1516 :
1517 1 : mp_destroy(&sp);
1518 : }
1519 1 : END_TEST
1520 : /* ------------------------------------------------------------------------- */
1521 1 : START_TEST(test_mp_next_section_memory4)
1522 : {
1523 1 : MinParser* sp = INITPTR;
1524 1 : MinSectionParser* msp = INITPTR;
1525 1 : char buff[] = "[New_Module]\n\
1526 : ModuleName= demomodule\n\
1527 : [End_Module]\n\
1528 : \n\
1529 : [New_Module]\n\
1530 : ModuleName= demomodule2\n\
1531 : [End_Module]\n\
1532 : \n\
1533 : [New_Module]\n\
1534 : ModuleName= demomodule3\n\
1535 : [End_Module]\n\
1536 : \n\
1537 : [New_Module]\n\
1538 : ModuleName= demomodule4\n\
1539 : [End_Module]\n";
1540 :
1541 1 : sp = mp_create_mem( buff
1542 : , ENoComments );
1543 1 : msp = mp_next_section_memory( sp
1544 : , "StartTag"
1545 : , "EndTag"
1546 : , -1 );
1547 1 : fail_unless( msp == INITPTR
1548 : , "msp != INITPTR" );
1549 :
1550 1 : mp_destroy(&sp);
1551 : }
1552 1 : END_TEST
1553 : /* ------------------------------------------------------------------------- */
1554 1 : START_TEST(test_mp_next_section_memory5)
1555 : {
1556 1 : MinParser* sp = INITPTR;
1557 1 : MinSectionParser* msp = INITPTR;
1558 1 : char buff[] = "[New_Module]\n\
1559 : ModuleName= demomodule\n\
1560 : [End_Module]\n\
1561 : \n\
1562 : [New_Module]\n\
1563 : ModuleName= demomodule2\n\
1564 : [End_Module]\n\
1565 : \n\
1566 : [New_Module]\n\
1567 : ModuleName= demomodule3\n\
1568 : [End_Module]\n\
1569 : \n\
1570 : [New_Module]\n\
1571 : ModuleName= demomodule4\n\
1572 : [End_Module]\n";
1573 :
1574 1 : sp = mp_create_mem( buff
1575 : , ENoComments );
1576 1 : msp = mp_next_section_memory( sp
1577 : , "StartTag"
1578 : , "EndTag"
1579 : , 0 );
1580 1 : fail_unless( msp == INITPTR
1581 : , "msp != INITPTR" );
1582 :
1583 1 : mp_destroy(&sp);
1584 : }
1585 1 : END_TEST
1586 : /* ------------------------------------------------------------------------- */
1587 1 : START_TEST(test_mp_next_section_memory6)
1588 : {
1589 1 : MinParser* sp = INITPTR;
1590 1 : MinSectionParser* msp = INITPTR;
1591 1 : char buff[] = "[New_Module]\n\
1592 : ModuleName= demomodule\n\
1593 : [End_Module]\n\
1594 : \n\
1595 : [New_Module]\n\
1596 : ModuleName= demomodule2\n\
1597 : [End_Module]\n\
1598 : \n\
1599 : [New_Module]\n\
1600 : ModuleName= demomodule3\n\
1601 : [End_Module]\n\
1602 : \n\
1603 : [New_Module]\n\
1604 : ModuleName= demomodule4\n\
1605 : [End_Module]\n";
1606 :
1607 1 : sp = mp_create_mem( buff
1608 : , ENoComments );
1609 1 : msp = mp_next_section_memory( sp
1610 : , "[New_Module]"
1611 : , "[End_Module]"
1612 : , 1 );
1613 1 : fail_unless( msp != INITPTR
1614 : , "msp == INITPTR" );
1615 :
1616 1 : mmp_destroy(&msp);
1617 1 : mp_destroy(&sp);
1618 : }
1619 1 : END_TEST
1620 : /* ------------------------------------------------------------------------- */
1621 1 : START_TEST(test_mp_next_section_memory7)
1622 : {
1623 1 : MinParser* sp = INITPTR;
1624 1 : MinSectionParser* msp = INITPTR;
1625 1 : char buff[] = "[New_Module]\n\
1626 : ModuleName= demomodule\n\
1627 : [End_Module]\n\
1628 : \n\
1629 : [New_Module]\n\
1630 : ModuleName= demomodule2\n\
1631 : [End_Module]\n\
1632 : \n\
1633 : [New_Module]\n\
1634 : ModuleName= demomodule3\n\
1635 : [End_Module]\n\
1636 : \n\
1637 : [New_Module]\n\
1638 : ModuleName= demomodule4\n\
1639 : [End_Module]\n";
1640 :
1641 1 : sp = mp_create_mem( buff
1642 : , ENoComments );
1643 1 : msp = mp_next_section_memory( sp
1644 : , ""
1645 : , ""
1646 : , 1 );
1647 1 : fail_unless( msp != INITPTR
1648 : , "msp == INITPTR" );
1649 :
1650 1 : mmp_destroy(&msp);
1651 1 : mp_destroy(&sp);
1652 : }
1653 1 : END_TEST
1654 : /* ------------------------------------------------------------------------- */
1655 1 : START_TEST(test_mp_next_section_memory8)
1656 : {
1657 1 : MinParser* sp = INITPTR;
1658 1 : MinSectionParser* msp = INITPTR;
1659 1 : char buff[] = "[New_Module]\n\
1660 : ModuleName= demomodule\n\
1661 : [End_Module]\n\
1662 : \n\
1663 : [New_Module]\n\
1664 : ModuleName= demomodule2\n\
1665 : [End_Module]\n\
1666 : \n\
1667 : [New_Module]\n\
1668 : ModuleName= demomodule3\n\
1669 : [End_Module]\n\
1670 : \n\
1671 : [New_Module]\n\
1672 : ModuleName= demomodule4\n\
1673 : [End_Module]\n";
1674 :
1675 1 : sp = mp_create_mem( buff
1676 : , ENoComments );
1677 1 : msp = mp_next_section_memory( sp
1678 : , "[New_Module]"
1679 : , "[End_Module]"
1680 : , 2 );
1681 1 : fail_unless( msp != INITPTR
1682 : , "msp == INITPTR" );
1683 :
1684 1 : mmp_destroy(&msp);
1685 1 : mp_destroy(&sp);
1686 : }
1687 1 : END_TEST
1688 : /* ------------------------------------------------------------------------- */
1689 1 : START_TEST(test_mp_next_section_memory9)
1690 : {
1691 1 : MinParser* sp = INITPTR;
1692 1 : MinSectionParser* msp = INITPTR;
1693 1 : char buff[] = "[New_Module]\n\
1694 : ModuleName= demomodule\n\
1695 : [End_Module]\n\
1696 : \n\
1697 : [New_Module]\n\
1698 : ModuleName= demomodule2\n\
1699 : [End_Module]\n\
1700 : \n\
1701 : [New_Module]\n\
1702 : ModuleName= demomodule3\n\
1703 : [End_Module]\n\
1704 : \n\
1705 : [New_Module]\n\
1706 : ModuleName= demomodule4\n\
1707 : [End_Module]\n";
1708 :
1709 1 : sp = mp_create_mem( buff
1710 : , ENoComments );
1711 1 : msp = mp_next_section_memory( sp
1712 : , "[New_Module]"
1713 : , "[End_Module]"
1714 : , 3 );
1715 1 : fail_unless( msp != INITPTR
1716 : , "msp == INITPTR" );
1717 :
1718 1 : mmp_destroy(&msp);
1719 1 : mp_destroy(&sp);
1720 : }
1721 1 : END_TEST
1722 : /* ------------------------------------------------------------------------- */
1723 1 : START_TEST(test_mp_next_section_memory10)
1724 : {
1725 1 : MinParser* sp = INITPTR;
1726 1 : MinSectionParser* msp = INITPTR;
1727 1 : char buff[] = "[New_Module]\n\
1728 : ModuleName= demomodule\n\
1729 : [End_Module]\n\
1730 : \n\
1731 : [New_Module]\n\
1732 : ModuleName= demomodule2\n\
1733 : [End_Module]\n\
1734 : \n\
1735 : [New_Module]\n\
1736 : ModuleName= demomodule3\n\
1737 : [End_Module]\n\
1738 : \n\
1739 : [New_Module]\n\
1740 : ModuleName= demomodule4\n\
1741 : [End_Module]\n";
1742 :
1743 1 : sp = mp_create_mem( buff
1744 : , ENoComments );
1745 1 : msp = mp_next_section_memory( sp
1746 : , "[New_Module]"
1747 : , "[End_Module]"
1748 : , 4 );
1749 1 : fail_unless( msp != INITPTR
1750 : , "msp == INITPTR" );
1751 :
1752 1 : mmp_destroy(&msp);
1753 1 : mp_destroy(&sp);
1754 : }
1755 1 : END_TEST
1756 : /* ------------------------------------------------------------------------- */
1757 1 : START_TEST(test_mp_next_section_memory11)
1758 : {
1759 1 : MinParser* sp = INITPTR;
1760 1 : MinSectionParser* msp = INITPTR;
1761 1 : char buff[] = "[New_Module]\n\
1762 : ModuleName= demomodule\n\
1763 : [End_Module]\n\
1764 : \n\
1765 : [New_Module]\n\
1766 : ModuleName= demomodule2\n\
1767 : [End_Module]\n\
1768 : \n\
1769 : [New_Module]\n\
1770 : ModuleName= demomodule3\n\
1771 : [End_Module]\n\
1772 : \n\
1773 : [New_Module]\n\
1774 : ModuleName= demomodule4\n\
1775 : [End_Module]\n";
1776 :
1777 1 : sp = mp_create_mem( buff
1778 : , ENoComments );
1779 1 : msp = mp_next_section_memory( sp
1780 : , "[New_Module]"
1781 : , "[End_Module]"
1782 : , 5 );
1783 1 : fail_unless( msp == INITPTR
1784 : , "msp != INITPTR" );
1785 :
1786 1 : mmp_destroy(&msp);
1787 1 : mp_destroy(&sp);
1788 : }
1789 1 : END_TEST
1790 : /* ------------------------------------------------------------------------- */
1791 1 : START_TEST(test_mp_next_section_memory12)
1792 : {
1793 1 : MinParser* sp = INITPTR;
1794 1 : MinSectionParser* msp = INITPTR;
1795 1 : char buff[] = "[New_Module]\n\
1796 : ModuleName= demomodule\n\
1797 : [End_Module]\n\
1798 : \n\
1799 : [New_Module]\n\
1800 : ModuleName= demomodule2\n\
1801 : [End_Module]\n\
1802 : \n\
1803 : [New_Module]\n\
1804 : ModuleName= demomodule3\n\
1805 : [End_Module]\n\
1806 : \n\
1807 : [New_Module]\n\
1808 : ModuleName= demomodule4\n\
1809 : [End_Module]\n";
1810 :
1811 1 : sp = mp_create_mem( buff
1812 : , ENoComments );
1813 1 : msp = mp_next_section_memory( sp
1814 : , "[Old_Module]"
1815 : , "[End_Module]"
1816 : , 1 );
1817 1 : fail_unless( msp == INITPTR
1818 : , "msp != INITPTR" );
1819 :
1820 1 : mmp_destroy(&msp);
1821 1 : mp_destroy(&sp);
1822 : }
1823 1 : END_TEST
1824 : /* ------------------------------------------------------------------------- */
1825 1 : START_TEST(test_mp_next_section_memory13)
1826 : {
1827 1 : MinParser* sp = INITPTR;
1828 1 : MinSectionParser* msp = INITPTR;
1829 1 : char buff[] = "[New_Module]\n\
1830 : ModuleName= demomodule\n\
1831 : [End_Module]\n\
1832 : \n\
1833 : [New_Module]\n\
1834 : ModuleName= demomodule2\n\
1835 : [End_Module]\n\
1836 : \n\
1837 : [New_Module]\n\
1838 : ModuleName= demomodule3\n\
1839 : [End_Module]\n\
1840 : \n\
1841 : [New_Module]\n\
1842 : ModuleName= demomodule4\n\
1843 : [End_Module]\n";
1844 :
1845 1 : sp = mp_create_mem( buff
1846 : , ENoComments );
1847 1 : msp = mp_next_section_memory( sp
1848 : , "[Old_Module]"
1849 : , "[EndOld_Module]"
1850 : , 1 );
1851 1 : fail_unless( msp == INITPTR
1852 : , "msp != INITPTR" );
1853 :
1854 1 : mmp_destroy(&msp);
1855 1 : mp_destroy(&sp);
1856 : }
1857 1 : END_TEST
1858 : /* ------------------------------------------------------------------------- */
1859 1 : START_TEST(test_mp_next_section_memory14)
1860 : {
1861 1 : MinParser* sp = INITPTR;
1862 1 : MinSectionParser* msp = INITPTR;
1863 1 : char buff[] = "[New_Module]\n\
1864 : ModuleName= demomodule\n\
1865 : [End_Module]\n\
1866 : \n\
1867 : [New_Module]\n\
1868 : ModuleName= demomodule2\n\
1869 : [End_Module]\n\
1870 : \n\
1871 : [New_Module]\n\
1872 : ModuleName= demomodule3\n\
1873 : [End_Module]\n\
1874 : \n\
1875 : [New_Module]\n\
1876 : ModuleName= demomodule4\n\
1877 : [End_Module]\n";
1878 :
1879 1 : sp = mp_create_mem( buff
1880 : , ENoComments );
1881 1 : msp = mp_next_section_memory( sp
1882 : , "[New_Module]"
1883 : , "[End_Module]"
1884 : , 1 );
1885 :
1886 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule\n") == 0
1887 : , "Result differs from expected [%s]"
1888 : , msp->section_ );
1889 :
1890 :
1891 1 : mmp_destroy(&msp);
1892 1 : mp_destroy(&sp);
1893 : }
1894 1 : END_TEST
1895 : /* ------------------------------------------------------------------------- */
1896 1 : START_TEST(test_mp_next_section_memory15)
1897 : {
1898 1 : MinParser* sp = INITPTR;
1899 1 : MinSectionParser* msp = INITPTR;
1900 1 : char buff[] = "[New_Module]\n\
1901 : ModuleName= demomodule\n\
1902 : [End_Module]\n\
1903 : \n\
1904 : [New_Module]\n\
1905 : ModuleName= demomodule2\n\
1906 : [End_Module]\n\
1907 : \n\
1908 : [New_Module]\n\
1909 : ModuleName= demomodule3\n\
1910 : [End_Module]\n\
1911 : \n\
1912 : [New_Module]\n\
1913 : ModuleName= demomodule4\n\
1914 : [End_Module]\n";
1915 :
1916 1 : sp = mp_create_mem( buff
1917 : , ENoComments );
1918 1 : msp = mp_next_section_memory( sp
1919 : , "[New_Module]"
1920 : , "[End_Module]"
1921 : , 2 );
1922 :
1923 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule2\n") == 0
1924 : , "Result differs from expected [%s]"
1925 : , msp->section_ );
1926 :
1927 :
1928 1 : mmp_destroy(&msp);
1929 1 : mp_destroy(&sp);
1930 : }
1931 1 : END_TEST
1932 : /* ------------------------------------------------------------------------- */
1933 1 : START_TEST(test_mp_next_section_memory16)
1934 : {
1935 1 : MinParser* sp = INITPTR;
1936 1 : MinSectionParser* msp = INITPTR;
1937 1 : char buff[] = "[New_Module]\n\
1938 : ModuleName= demomodule\n\
1939 : [End_Module]\n\
1940 : \n\
1941 : [New_Module]\n\
1942 : ModuleName= demomodule2\n\
1943 : [End_Module]\n\
1944 : \n\
1945 : [New_Module]\n\
1946 : ModuleName= demomodule3\n\
1947 : [End_Module]\n\
1948 : \n\
1949 : [New_Module]\n\
1950 : ModuleName= demomodule4\n\
1951 : [End_Module]\n";
1952 :
1953 1 : sp = mp_create_mem( buff
1954 : , ENoComments );
1955 1 : msp = mp_next_section_memory( sp
1956 : , "[New_Module]"
1957 : , "[End_Module]"
1958 : , 3 );
1959 :
1960 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule3\n") == 0
1961 : , "Result differs from expected [%s]"
1962 : , msp->section_ );
1963 :
1964 :
1965 1 : mmp_destroy(&msp);
1966 1 : mp_destroy(&sp);
1967 : }
1968 1 : END_TEST
1969 : /* ------------------------------------------------------------------------- */
1970 1 : START_TEST(test_mp_next_section_memory17)
1971 : {
1972 1 : MinParser* sp = INITPTR;
1973 1 : MinSectionParser* msp = INITPTR;
1974 1 : char buff[] = "[New_Module]\n\
1975 : ModuleName= demomodule\n\
1976 : [End_Module]\n\
1977 : \n\
1978 : [New_Module]\n\
1979 : ModuleName= demomodule2\n\
1980 : [End_Module]\n\
1981 : \n\
1982 : [New_Module]\n\
1983 : ModuleName= demomodule3\n\
1984 : [End_Module]\n\
1985 : \n\
1986 : [New_Module]\n\
1987 : ModuleName= demomodule4\n\
1988 : [End_Module]\n";
1989 :
1990 1 : sp = mp_create_mem( buff
1991 : , ENoComments );
1992 1 : msp = mp_next_section_memory( sp
1993 : , "[New_Module]"
1994 : , "[End_Module]"
1995 : , 4 );
1996 :
1997 1 : fail_unless( strcmp(msp->section_,"ModuleName= demomodule4\n") == 0
1998 : , "Result differs from expected [%s]"
1999 : , msp->section_ );
2000 :
2001 :
2002 1 : mmp_destroy(&msp);
2003 1 : mp_destroy(&sp);
2004 : }
2005 1 : END_TEST
2006 : /* ------------------------------------------------------------------------- */
2007 1 : START_TEST(test_mp_parse_comments_off)
2008 : {
2009 1 : char* buff = INITPTR;
2010 1 : mp_parse_comments_off( buff );
2011 1 : fail_unless( buff == INITPTR
2012 : , "buff != INITPTR" );
2013 : }
2014 1 : END_TEST
2015 : /* ------------------------------------------------------------------------- */
2016 1 : START_TEST(test_mp_parse_comments_off2)
2017 : {
2018 1 : char buff[] = "Ala ma kota";
2019 1 : mp_parse_comments_off( buff );
2020 1 : fail_unless( strcmp(buff,"Ala ma kota") == 0
2021 : , "Result differs from expected [%s]"
2022 : , buff );
2023 : }
2024 1 : END_TEST
2025 : /* ------------------------------------------------------------------------- */
2026 1 : START_TEST(test_mp_parse_comments_off3)
2027 : {
2028 1 : char bu[] = "Ala ma//kota\n";
2029 1 : mp_parse_comments_off( bu );
2030 1 : fail_unless( strcmp(bu,"Ala ma\n") == 0
2031 : , "Result differs from expected [%s]"
2032 : , bu );
2033 : }
2034 1 : END_TEST
2035 : /* ------------------------------------------------------------------------- */
2036 1 : START_TEST(test_mp_parse_comments_off4)
2037 : {
2038 1 : char buff[] = "Ala/* ma*/ kota";
2039 1 : mp_parse_comments_off( buff );
2040 1 : fail_unless( strcmp(buff,"Ala kota") == 0
2041 : , "Result differs from expected [%s]"
2042 : , buff );
2043 : }
2044 1 : END_TEST
2045 : /* ------------------------------------------------------------------------- */
2046 1 : START_TEST(test_mp_parse_comments_off5)
2047 : {
2048 1 : char buff[] = "Ala/* ma*/ ko//ta";
2049 1 : mp_parse_comments_off( buff );
2050 1 : fail_unless( strcmp(buff,"Ala ko") == 0
2051 : , "Result differs from expected [%s]"
2052 : , buff );
2053 : }
2054 1 : END_TEST
2055 : /* ------------------------------------------------------------------------- */
2056 1 : START_TEST(test_mp_parse_comments_off6)
2057 : {
2058 1 : char buff[] = "Ala/* ma*/ kota ko/t *ma \\a//le";
2059 1 : mp_parse_comments_off( buff );
2060 1 : fail_unless( strcmp(buff,"Ala kota ko/t *ma \\a") == 0
2061 : , "Result differs from expected [%s]"
2062 : , buff );
2063 : }
2064 1 : END_TEST
2065 : /* ------------------------------------------------------------------------- */
2066 1 : START_TEST(test_mp_handle_special_marks)
2067 : {
2068 1 : char * buff = INITPTR;
2069 1 : mp_handle_special_marks( buff );
2070 1 : fail_unless( buff == INITPTR
2071 : , "buff != INITPTR" );
2072 : }
2073 1 : END_TEST
2074 : /* ------------------------------------------------------------------------- */
2075 1 : START_TEST(test_mp_handle_special_marks2)
2076 : {
2077 1 : char buff[] = "Ala ma kota";
2078 1 : mp_handle_special_marks( buff );
2079 1 : fail_unless( buff != INITPTR
2080 : , "buff == INITPTR" );
2081 : }
2082 1 : END_TEST
2083 : /* ------------------------------------------------------------------------- */
2084 1 : START_TEST(test_mp_handle_special_marks3)
2085 : {
2086 1 : char buff[] = "Ala ma kota";
2087 1 : mp_handle_special_marks( buff );
2088 1 : fail_unless( strcmp(buff,"Ala ma kota") == 0
2089 : , "Result differs from expected [%s]"
2090 : , buff );
2091 : }
2092 1 : END_TEST
2093 : /* ------------------------------------------------------------------------- */
2094 1 : START_TEST(test_mp_handle_special_marks4)
2095 : {
2096 1 : char buff[] = "Ala m\/\/a kota";
2097 1 : mp_handle_special_marks( buff );
2098 1 : fail_unless( strcmp(buff,"Ala m//a kota") == 0
2099 : , "Result differs from expected [%s]"
2100 : , buff );
2101 : }
2102 1 : END_TEST
2103 : /* ------------------------------------------------------------------------- */
2104 1 : START_TEST(test_mp_handle_special_marks5)
2105 : {
2106 1 : char buff[] = "Ala m\/\*a kota";
2107 1 : mp_handle_special_marks( buff );
2108 1 : fail_unless( strcmp(buff,"Ala m/*a kota") == 0
2109 : , "Result differs from expected [%s]"
2110 : , buff );
2111 : }
2112 1 : END_TEST
2113 : /* ------------------------------------------------------------------------- */
2114 1 : START_TEST(test_mp_handle_special_marks6)
2115 : {
2116 1 : char buff[] = "Ala m*\/\/a kota";
2117 1 : mp_handle_special_marks( buff );
2118 1 : fail_unless( strcmp(buff,"Ala m*//a kota") == 0
2119 : , "Result differs from expected [%s]"
2120 : , buff );
2121 : }
2122 1 : END_TEST
2123 : /* ------------------------------------------------------------------------- */
2124 : /* ========================== FUNCTIONS ==================================== */
2125 : /* ------------------------------------------------------------------------- */
2126 : Suite* parser_suite()
2127 277 : {
2128 277 : Suite * s = suite_create ("Min Parser");
2129 :
2130 : /* Core test case */
2131 277 : TCase *tc_core = tcase_create ("Core");
2132 :
2133 : /* mp_create */
2134 277 : tcase_add_test (tc_core, test_mp_create);
2135 277 : tcase_add_test (tc_core, test_mp_create2);
2136 277 : tcase_add_test (tc_core, test_mp_create3);
2137 277 : tcase_add_test (tc_core, test_mp_create4);
2138 277 : tcase_add_test (tc_core, test_mp_create5);
2139 277 : tcase_add_test (tc_core, test_mp_create6);
2140 277 : tcase_add_test (tc_core, test_mp_create7);
2141 277 : tcase_add_test (tc_core, test_mp_create8);
2142 277 : tcase_add_test (tc_core, test_mp_create9);
2143 277 : tcase_add_test (tc_core, test_mp_create10);
2144 277 : tcase_add_test (tc_core, test_mp_create11);
2145 277 : tcase_add_test (tc_core, test_mp_create12);
2146 277 : tcase_add_test (tc_core, test_mp_create13);
2147 277 : tcase_add_test (tc_core, test_mp_create14);
2148 277 : tcase_add_test (tc_core, test_mp_create15);
2149 277 : tcase_add_test (tc_core, test_mp_create16);
2150 277 : tcase_add_test (tc_core, test_mp_create17);
2151 :
2152 : /* mp_create_mem */
2153 277 : tcase_add_test (tc_core, test_mp_create_mem);
2154 277 : tcase_add_test (tc_core, test_mp_create_mem2);
2155 277 : tcase_add_test (tc_core, test_mp_create_mem3);
2156 277 : tcase_add_test (tc_core, test_mp_create_mem4);
2157 277 : tcase_add_test (tc_core, test_mp_create_mem5);
2158 277 : tcase_add_test (tc_core, test_mp_create_mem6);
2159 277 : tcase_add_test (tc_core, test_mp_create_mem7);
2160 277 : tcase_add_test (tc_core, test_mp_create_mem8);
2161 277 : tcase_add_test (tc_core, test_mp_create_mem9);
2162 277 : tcase_add_test (tc_core, test_mp_create_mem10);
2163 277 : tcase_add_test (tc_core, test_mp_create_mem11);
2164 :
2165 : /* mp_destroy */
2166 277 : tcase_add_test (tc_core, test_mp_destroy);
2167 277 : tcase_add_test (tc_core, test_mp_destroy2);
2168 277 : tcase_add_test (tc_core, test_mp_destroy3);
2169 :
2170 : /* mp_section */
2171 277 : tcase_add_test (tc_core, test_mp_section);
2172 277 : tcase_add_test (tc_core, test_mp_section2);
2173 277 : tcase_add_test (tc_core, test_mp_section3);
2174 277 : tcase_add_test (tc_core, test_mp_section4);
2175 277 : tcase_add_test (tc_core, test_mp_section5);
2176 277 : tcase_add_test (tc_core, test_mp_section6);
2177 277 : tcase_add_test (tc_core, test_mp_section7);
2178 277 : tcase_add_test (tc_core, test_mp_section8);
2179 277 : tcase_add_test (tc_core, test_mp_section9);
2180 277 : tcase_add_test (tc_core, test_mp_section10);
2181 277 : tcase_add_test (tc_core, test_mp_section11);
2182 277 : tcase_add_test (tc_core, test_mp_section12);
2183 277 : tcase_add_test (tc_core, test_mp_section13);
2184 277 : tcase_add_test (tc_core, test_mp_section14);
2185 277 : tcase_add_test (tc_core, test_mp_section15);
2186 277 : tcase_add_test (tc_core, test_mp_section16);
2187 : /* tcase_add_test (tc_core, test_mp_section17);*/
2188 :
2189 : /* mp_next_section */
2190 277 : tcase_add_test (tc_core, test_mp_next_section);
2191 277 : tcase_add_test (tc_core, test_mp_next_section2);
2192 277 : tcase_add_test (tc_core, test_mp_next_section3);
2193 277 : tcase_add_test (tc_core, test_mp_next_section4);
2194 277 : tcase_add_test (tc_core, test_mp_next_section5);
2195 277 : tcase_add_test (tc_core, test_mp_next_section6);
2196 277 : tcase_add_test (tc_core, test_mp_next_section7);
2197 277 : tcase_add_test (tc_core, test_mp_next_section8);
2198 277 : tcase_add_test (tc_core, test_mp_next_section9);
2199 277 : tcase_add_test (tc_core, test_mp_next_section10);
2200 277 : tcase_add_test (tc_core, test_mp_next_section11);
2201 277 : tcase_add_test (tc_core, test_mp_next_section12);
2202 :
2203 : /* mp_next_section_file */
2204 277 : tcase_add_test (tc_core, test_mp_next_section_file);
2205 277 : tcase_add_test (tc_core, test_mp_next_section_file2);
2206 277 : tcase_add_test (tc_core, test_mp_next_section_file3);
2207 277 : tcase_add_test (tc_core, test_mp_next_section_file4);
2208 277 : tcase_add_test (tc_core, test_mp_next_section_file5);
2209 277 : tcase_add_test (tc_core, test_mp_next_section_file6);
2210 277 : tcase_add_test (tc_core, test_mp_next_section_file7);
2211 277 : tcase_add_test (tc_core, test_mp_next_section_file8);
2212 :
2213 : /* mp_next_section_memory */
2214 277 : tcase_add_test (tc_core, test_mp_next_section_memory);
2215 277 : tcase_add_test (tc_core, test_mp_next_section_memory2);
2216 277 : tcase_add_test (tc_core, test_mp_next_section_memory3);
2217 277 : tcase_add_test (tc_core, test_mp_next_section_memory4);
2218 277 : tcase_add_test (tc_core, test_mp_next_section_memory5);
2219 277 : tcase_add_test (tc_core, test_mp_next_section_memory6);
2220 277 : tcase_add_test (tc_core, test_mp_next_section_memory7);
2221 277 : tcase_add_test (tc_core, test_mp_next_section_memory8);
2222 277 : tcase_add_test (tc_core, test_mp_next_section_memory9);
2223 277 : tcase_add_test (tc_core, test_mp_next_section_memory10);
2224 277 : tcase_add_test (tc_core, test_mp_next_section_memory11);
2225 277 : tcase_add_test (tc_core, test_mp_next_section_memory12);
2226 277 : tcase_add_test (tc_core, test_mp_next_section_memory13);
2227 277 : tcase_add_test (tc_core, test_mp_next_section_memory14);
2228 277 : tcase_add_test (tc_core, test_mp_next_section_memory15);
2229 277 : tcase_add_test (tc_core, test_mp_next_section_memory16);
2230 277 : tcase_add_test (tc_core, test_mp_next_section_memory17);
2231 :
2232 : /* mp_parse_comments_off */
2233 277 : tcase_add_test (tc_core, test_mp_parse_comments_off);
2234 277 : tcase_add_test (tc_core, test_mp_parse_comments_off2);
2235 277 : tcase_add_test (tc_core, test_mp_parse_comments_off3);
2236 277 : tcase_add_test (tc_core, test_mp_parse_comments_off4);
2237 277 : tcase_add_test (tc_core, test_mp_parse_comments_off5);
2238 277 : tcase_add_test (tc_core, test_mp_parse_comments_off6);
2239 :
2240 : /* mp_handle_special_marks */
2241 277 : tcase_add_test (tc_core, test_mp_handle_special_marks);
2242 277 : tcase_add_test (tc_core, test_mp_handle_special_marks2);
2243 277 : tcase_add_test (tc_core, test_mp_handle_special_marks3);
2244 277 : tcase_add_test (tc_core, test_mp_handle_special_marks4);
2245 277 : tcase_add_test (tc_core, test_mp_handle_special_marks5);
2246 277 : tcase_add_test (tc_core, test_mp_handle_special_marks6);
2247 :
2248 277 : suite_add_tcase (s, tc_core);
2249 :
2250 277 : return s;
2251 : }
2252 : /* ------------------------------------------------------------------------- */
2253 : int min_parser_tests()
2254 277 : {
2255 277 : int number_failed = 0;
2256 277 : Suite * s = parser_suite ();
2257 277 : SRunner * sr = srunner_create (s);
2258 :
2259 : /*srunner_set_fork_status (sr, CK_NOFORK);*/
2260 :
2261 277 : srunner_run_all(sr, CK_NORMAL);
2262 181 : number_failed = srunner_ntests_failed(sr);
2263 181 : srunner_free(sr);
2264 181 : return number_failed;
2265 : }
2266 : /* ------------------------------------------------------------------------- */
2267 : /* End of file */
|
