1 //
2 // Parse.c
3 //
4 // $Author$
5 // $Date$
6 //
7 // Copyright (C) 2003 why the lucky stiff
8 //
9
10 #include <string.h>
11 #include "syck.h"
12 #include "CuTest.h"
13
14 //
15 // 1. Test the buffering -- read 4 bytes at a time
16 //
17 void
TestSyckReadString(CuTest * tc)18 TestSyckReadString( CuTest *tc )
19 {
20 SyckParser *parser;
21 char *tmp;
22 int len = 0;
23
24 parser = syck_new_parser();
25 syck_parser_str_auto( parser, "test: 1\nand: 2\nalso: 3", syck_io_str_read );
26
27 len = syck_parser_readlen( parser, 4 );
28 CuAssert( tc, "Wrong length, line 1.", 4 == len );
29 parser->token = parser->buffer + 4;
30 tmp = syck_strndup( parser->buffer, len );
31 CuAssertStrEquals( tc, "test", tmp );
32 free( tmp );
33
34 len = syck_parser_readlen( parser, 4 );
35 CuAssert( tc, "Wrong length, line 2.", 4 == len );
36 parser->token = parser->buffer + 4;
37 tmp = syck_strndup( parser->buffer, len );
38 CuAssertStrEquals( tc, ": 1\n", tmp );
39 free( tmp );
40
41 len = syck_parser_readlen( parser, 4 );
42 CuAssert( tc, "Wrong length, line 3.", 4 == len );
43 parser->token = parser->buffer + 4;
44 tmp = syck_strndup( parser->buffer, len );
45 CuAssertStrEquals( tc, "and:", tmp );
46 free( tmp );
47
48 len = syck_parser_readlen( parser, 4 );
49 CuAssert( tc, "Wrong length, line 4.", 4 == len );
50 parser->token = parser->buffer + 4;
51 tmp = syck_strndup( parser->buffer, len );
52 CuAssertStrEquals( tc, " 2\na", tmp );
53 free( tmp );
54
55 len = syck_parser_readlen( parser, 4 );
56 CuAssert( tc, "Wrong length, line 5.", 4 == len );
57 parser->token = parser->buffer + 4;
58 tmp = syck_strndup( parser->buffer, len );
59 CuAssertStrEquals( tc, "lso:", tmp );
60 free( tmp );
61
62 len = syck_parser_readlen( parser, 4 );
63 CuAssert( tc, "Wrong length, line 6.", 2 == len );
64 parser->token = parser->buffer + 4;
65 tmp = syck_strndup( parser->buffer, len );
66 CuAssertStrEquals( tc, " 3", tmp );
67 free( tmp );
68
69 free_any_io( parser );
70 syck_free_parser( parser );
71 }
72
73 //
74 // 2. Test parsing a simple string and handler
75 //
76 SYMID
SyckParseStringHandler(SyckParser * p,SyckNode * n)77 SyckParseStringHandler( SyckParser *p, SyckNode *n )
78 {
79 if ( n->kind != syck_str_kind )
80 return 100;
81
82 if ( strcmp( syck_str_read( n ), "a_test_string" ) != 0 )
83 return 200;
84
85 return 1112;
86 }
87
88 void
TestSyckParseString(CuTest * tc)89 TestSyckParseString( CuTest *tc )
90 {
91 SyckParser *parser;
92 SYMID id;
93
94 parser = syck_new_parser();
95 syck_parser_handler( parser, SyckParseStringHandler );
96 syck_parser_str_auto( parser, "--- a_test_string", NULL );
97
98 id = syck_parse( parser );
99 CuAssert( tc, "Handler returned incorrect value.", 1112 == id );
100
101 syck_free_parser( parser );
102 }
103
104 //
105 // 3.
106 //
107 SYMID
SyckParseString2Handler(SyckParser * p,SyckNode * n)108 SyckParseString2Handler( SyckParser *p, SyckNode *n )
109 {
110 if ( n->kind != syck_str_kind )
111 return 100;
112
113 if ( strcmp( syck_str_read( n ), "a_test_string" ) != 0 )
114 return 200;
115
116 return 1112;
117 }
118
119 enum st_retval
ListAnchors(char * key,SyckNode * n,CuTest * tc)120 ListAnchors( char *key, SyckNode *n, CuTest *tc )
121 {
122 char *sd = syck_strndup( n->data.str->ptr, n->data.str->len );
123 CuAssertStrEquals( tc, "test", key );
124 CuAssertStrEquals( tc, "13", sd );
125 free( sd );
126 return ST_CONTINUE;
127 }
128
129 void
TestSyckParseString2(CuTest * tc)130 TestSyckParseString2( CuTest *tc )
131 {
132 SyckParser *parser;
133 parser = syck_new_parser();
134 syck_parser_handler( parser, SyckParseStringHandler );
135 syck_parser_str_auto( parser, "--- {test: 1, and: 2, or: &test 13}", NULL );
136 syckparse( parser );
137 st_foreach( parser->anchors, ListAnchors, tc );
138 syck_free_parser( parser );
139 }
140
141 void
TestSyckParseMap(CuTest * tc)142 TestSyckParseMap( CuTest *tc )
143 {
144 SyckParser *parser;
145 parser = syck_new_parser();
146 syck_parser_handler( parser, SyckParseStringHandler );
147 syck_parser_str_auto( parser, "\ntest: 1\nand: 2\nor:\n test: 1\n and: 2\n fourdepth:\n deep: 1\nlast: end", NULL );
148 syck_parse( parser );
149 syck_free_parser( parser );
150 }
151
152 void
TestSyckParseFold(CuTest * tc)153 TestSyckParseFold( CuTest *tc )
154 {
155 SyckParser *parser;
156 parser = syck_new_parser();
157 syck_parser_handler( parser, SyckParseStringHandler );
158 syck_parser_str_auto( parser, "\ntest: |\n deep: 1\nlast: end\n \n", NULL );
159 syck_parse( parser );
160 syck_free_parser( parser );
161 }
162
163 void
TestSyckParseMultidoc(CuTest * tc)164 TestSyckParseMultidoc( CuTest *tc )
165 {
166 SyckParser *parser;
167 parser = syck_new_parser();
168 syck_parser_handler( parser, SyckParseStringHandler );
169 syck_parser_str_auto( parser, "---\ntest: |\n deep: 1\n---\nlast: end\n \n", NULL );
170 syck_parse( parser );
171 syck_parse( parser );
172 syck_free_parser( parser );
173 }
174
175 CuSuite *
SyckGetSuite()176 SyckGetSuite()
177 {
178 CuSuite *suite = CuSuiteNew();
179 SUITE_ADD_TEST( suite, TestSyckReadString );
180 SUITE_ADD_TEST( suite, TestSyckParseString );
181 SUITE_ADD_TEST( suite, TestSyckParseString2 );
182 SUITE_ADD_TEST( suite, TestSyckParseMap );
183 SUITE_ADD_TEST( suite, TestSyckParseFold );
184 SUITE_ADD_TEST( suite, TestSyckParseMultidoc );
185 return suite;
186 }
187
main(void)188 int main(void)
189 {
190 CuString *output = CuStringNew();
191 CuSuite* suite = SyckGetSuite();
192 int count;
193
194 CuSuiteRun(suite);
195 CuSuiteSummary(suite, output);
196 CuSuiteDetails(suite, output);
197
198 printf("%s\n", output->buffer);
199 count = suite->failCount;
200
201 CuStringFree( output );
202 CuSuiteFree( suite );
203
204 return count;
205 }
206