exip  Alpha 0.5.4
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
check_grammar.c
Go to the documentation of this file.
1 /*==================================================================*\
2 | EXIP - Embeddable EXI Processor in C |
3 |--------------------------------------------------------------------|
4 | This work is licensed under BSD 3-Clause License |
5 | The full license terms and conditions are located in LICENSE.txt |
6 \===================================================================*/
7 
18 #include <stdlib.h>
19 #include <check.h>
20 #include "grammars.h"
21 #include "bodyDecode.h"
22 #include "memManagement.h"
23 
24 /* BEGIN: grammars tests */
25 
26 START_TEST (test_createDocGrammar)
27 {
29  EXIPSchema schema;
30  EXIStream testStream;
31  char buf[2];
32  buf[0] = (char) 0xD4; /* 0b11010100 */
33  buf[1] = (char) 0x60; /* 0b01100000 */
34 
35  initAllocList(&schema.memList);
36 
37  testStream.context.bitPointer = 0;
38  makeDefaultOpts(&testStream.header.opts);
39  testStream.buffer.buf = buf;
40  testStream.buffer.bufLen = 2;
41  testStream.buffer.bufContent = 2;
42  testStream.buffer.ioStrm.readWriteToStream = NULL;
43  testStream.buffer.ioStrm.stream = NULL;
44  testStream.context.bufferIndx = 0;
45  initAllocList(&testStream.memList);
46 
47  err = createDocGrammar(&schema, NULL, 0);
48 
49  fail_unless (err == EXIP_OK, "createDocGrammar returns an error code %d", err);
50 
51  freeAllocList(&schema.memList);
52 }
54 
55 START_TEST (test_processNextProduction)
56 {
58  EXIStream strm;
59  SmallIndex nonTermID_out;
60  ContentHandler handler;
61  EXIPSchema schema;
62  QNameID emptyQnameID = {URI_MAX, LN_MAX};
63 
64  initAllocList(&strm.memList);
65  initAllocList(&schema.memList);
66 
67  err = createDocGrammar(&schema, NULL, 0);
68  fail_unless (err == EXIP_OK, "createDocGrammar returns an error code %d", err);
69 
70  err = pushGrammar(&strm.gStack, emptyQnameID, &schema.docGrammar);
71  fail_unless (err == EXIP_OK, "pushGrammar returns an error code %d", err);
72 
73  strm.gStack->currNonTermID = 4;
74  err = processNextProduction(&strm, &nonTermID_out, &handler, NULL);
75  fail_unless (err == EXIP_INCONSISTENT_PROC_STATE, "processNextProduction does not return the correct error code");
76 
77  freeAllocList(&strm.memList);
78  freeAllocList(&schema.memList);
79 }
81 
82 START_TEST (test_pushGrammar)
83 {
85  EXIGrammarStack* testGrStack = NULL;
86  EXIStream strm;
87  EXIGrammar testElementGrammar;
88  EXIGrammar testElementGrammar1;
89  QNameID emptyQnameID = {URI_MAX, LN_MAX};
90 
92  initAllocList(&strm.memList);
93 
94 #if BUILD_IN_GRAMMARS_USE
95  err = createBuiltInElementGrammar(&testElementGrammar1, &strm);
96  fail_if(err != EXIP_OK);
97 
98  err = createBuiltInElementGrammar(&testElementGrammar, &strm);
99  fail_if(err != EXIP_OK);
100 #endif
101 
102  err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar1);
103  fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
104  fail_if(testGrStack->nextInStack != NULL);
105 
106  err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar);
107  fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
108  fail_if(testGrStack->nextInStack == NULL);
109  fail_if(testGrStack->nextInStack->grammar != &testElementGrammar1);
110 
111  freeAllocList(&strm.memList);
112 }
113 END_TEST
114 
115 START_TEST (test_popGrammar)
116 {
118  EXIGrammarStack* testGrStack = NULL;
119  EXIGrammar testElementGrammar1;
120  EXIStream strm;
121  EXIGrammar testElementGrammar;
122  QNameID emptyQnameID = {URI_MAX, LN_MAX};
123 
124  makeDefaultOpts(&strm.header.opts);
125  initAllocList(&strm.memList);
126 
127 #if BUILD_IN_GRAMMARS_USE
128  err = createBuiltInElementGrammar(&testElementGrammar1, &strm);
129  fail_if(err != EXIP_OK);
130 
131  err = createBuiltInElementGrammar(&testElementGrammar, &strm);
132  fail_if(err != EXIP_OK);
133 #endif
134 
135  err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar1);
136  fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
137 
138  err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar);
139  fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
140  fail_if(testGrStack->nextInStack == NULL);
141 
142  popGrammar(&testGrStack);
143  fail_if(testGrStack->nextInStack != NULL);
144 }
145 END_TEST
146 
147 #if BUILD_IN_GRAMMARS_USE
148 START_TEST (test_createBuiltInElementGrammar)
149 {
151  EXIGrammar testElementGrammar;
152  EXIStream strm;
153 
154  makeDefaultOpts(&strm.header.opts);
155  initAllocList(&strm.memList);
156 
157  err = createBuiltInElementGrammar(&testElementGrammar, &strm);
158  fail_unless (err == EXIP_OK, "createBuildInElementGrammar returns error code %d", err);
159 
160 }
161 END_TEST
162 #endif
163 
164 /* END: grammars tests */
165 
166 
167 /* BEGIN: events tests */
168 
169 /* END: events tests */
170 
171 
172 /* BEGIN: rules tests */
173 
174 #if BUILD_IN_GRAMMARS_USE
175 START_TEST (test_insertZeroProduction)
176 {
177  DynGrammarRule rule;
178  errorCode tmp_err_code = EXIP_UNEXPECTED_ERROR;
179  Production prod0Arr[2];
180  QNameID qname = {0,0};
181 
182  rule.pCount = 0;
183  rule.prodDim = 1;
184  rule.production = prod0Arr;
185 
186  tmp_err_code = insertZeroProduction(&rule, EVENT_CH, 5, &qname, FALSE);
187  fail_unless (tmp_err_code == EXIP_OK, "insertZeroProduction returns an error code %d", tmp_err_code);
188  fail_unless (rule.pCount == 1);
189 }
190 END_TEST
191 #endif
192 /* END: rules tests */
193 
194 
196 {
197  Suite *s = suite_create ("Grammar");
198 
199  {
200  /* Grammars test case */
201  TCase *tc_gGrammars = tcase_create ("Grammars");
202  tcase_add_test (tc_gGrammars, test_createDocGrammar);
203  tcase_add_test (tc_gGrammars, test_processNextProduction);
204  tcase_add_test (tc_gGrammars, test_pushGrammar);
205  tcase_add_test (tc_gGrammars, test_popGrammar);
206 #if BUILD_IN_GRAMMARS_USE
207  tcase_add_test (tc_gGrammars, test_createBuiltInElementGrammar);
208 #endif
209  suite_add_tcase (s, tc_gGrammars);
210  }
211 
212  {
213  /* Events test case */
214  TCase *tc_gEvents = tcase_create ("Events");
215  suite_add_tcase (s, tc_gEvents);
216  }
217 
218  {
219  /* Rules test case */
220  TCase *tc_gRules = tcase_create ("Rules");
221 #if BUILD_IN_GRAMMARS_USE
222  tcase_add_test (tc_gRules, test_insertZeroProduction);
223 #endif
224  suite_add_tcase (s, tc_gRules);
225  }
226 
227  return s;
228 }
229 
230 int main (void)
231 {
232  int number_failed;
233  Suite *s = grammar_suite();
234  SRunner *sr = srunner_create (s);
235 #ifdef _MSC_VER
237 #endif
239  number_failed = srunner_ntests_failed (sr);
240  srunner_free (sr);
241  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
242 }