• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 Shenzhen Kaihong Digital.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 package parse;
17 
18 import grammar.*;
19 import org.antlr.v4.runtime.CharStreams;
20 import org.antlr.v4.runtime.CodePointCharStream;
21 import org.junit.jupiter.api.AfterEach;
22 import org.junit.jupiter.api.BeforeEach;
23 import org.junit.jupiter.api.Test;
24 
25 import java.util.List;
26 
27 import static org.junit.jupiter.api.Assertions.*;
28 
29 /**
30  * <h3>类名：该类用于xxx</h3>
31  * description
32  *
33  * @author Administrator
34  *         date 2025-02-28
35  * @version 1.0
36  * @since 2025-02-28
37  */
38 class ParseCppTest {
39 
40     private final String testCStreamFile1 = "#ifndef COAP_ADDRESS_H_\n" +
41             "#define COAP_ADDRESS_H_\n" +
42             "\n" +
43             "#include <assert.h>\n" +
44             "#include <stdint.h>\n" +
45             "#include <string.h>\n" +
46             "#include <sys/types.h>\n" +
47             "#include \"libcoap.h\"\n" +
48             "\n" +
49             "#include \"coap3/coap_pdu.h\"\n" +
50             "\n" +
51             "#if defined(WITH_LWIP)\n" +
52             "\n" +
53             "#include <lwip/ip_addr.h>\n" +
54             "\n" +
55             "struct coap_address_t {\n" +
56             "  uint16_t port;\n" +
57             "  ip_addr_t addr;\n" +
58             "};\n" +
59             "\n" +
60             "/**\n" +
61             " * Returns the port from @p addr in host byte order.\n" +
62             " */\n" +
63             "COAP_STATIC_INLINE uint16_t\n" +
64             "coap_address_get_port(const coap_address_t *addr) {\n" +
65             "  return addr->port;\n" +
66             "}\n" +
67             "\n" +
68             "/**\n" +
69             " * Sets the port field of @p addr to @p port (in host byte order).\n" +
70             " */\n" +
71             "COAP_STATIC_INLINE void\n" +
72             "coap_address_set_port(coap_address_t *addr, uint16_t port) {\n" +
73             "  addr->port = port;\n" +
74             "}\n" +
75             "\n" +
76             "#define _coap_address_equals_impl(A, B) \\\n" +
77             "  ((A)->port == (B)->port &&        \\\n" +
78             "   (!!ip_addr_cmp(&(A)->addr,&(B)->addr)))\n" +
79             "\n" +
80             "#define _coap_address_isany_impl(A)  ip_addr_isany(&(A)->addr)\n" +
81             "\n" +
82             "#define _coap_is_mcast_impl(Address) ip_addr_ismulticast(&(Address)->addr)\n" +
83             "\n" +
84             "#ifdef COAP_SUPPORT_SOCKET_BROADCAST\n" +
85             "#define _coap_is_bcast_impl(Address) ip_addr_isbroadcast(&(Address)->addr)\n" +
86             "#endif\n" +
87             "\n" +
88             "#elif defined(WITH_CONTIKI)\n" +
89             "\n" +
90             "#include \"uip.h\"\n" +
91             "\n" +
92             "struct coap_address_t {\n" +
93             "  uip_ipaddr_t addr;\n" +
94             "  uint16_t port;\n" +
95             "};";
96 
97     private final String testCStreamFile2 = "/*---------------------------------------\n" +
98             " * dEQP glslang integration\n" +
99             " * ------------------------\n" +
100             " *\n" +
101             " *\n" +
102             " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" +
103             " * you may not use this file except in compliance with the License.\n" +
104             " * You may obtain a copy of the License at\n" +
105             " *\n" +
106             " *      http://www.apache.org/licenses/LICENSE-2.0\n" +
107             " *\n" +
108             " * Unless required by applicable law or agreed to in writing, software\n" +
109             " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" +
110             " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" +
111             " * See the License for the specific language governing permissions and\n" +
112             " * limitations under the License.\n" +
113             " *\n" +
114             " *//*!\n" +
115             " * \\file\n" +
116             " * \\brief glslang OS interface.\n" +
117             " *//*--------------------------------------------------------------------*/\n" +
118             "\n" +
119             "#include \"osinclude.h\"\n" +
120             "\n" +
121             "#include \"deThread.h\"\n" +
122             "#include \"deThreadLocal.h\"\n" +
123             "#include \"deMutex.h\"\n" +
124             "\n" +
125             "namespace glslang\n" +
126             "{\n" +
127             "\n" +
128             "DE_STATIC_ASSERT(sizeof(deThreadLocal)\t== sizeof(OS_TLSIndex));\n" +
129             "DE_STATIC_ASSERT(sizeof(deThread)\t\t== sizeof(void*));\n" +
130             "\n" +
131             "// Thread-local\n" +
132             "\n" +
133             "OS_TLSIndex OS_AllocTLSIndex (void)\n" +
134             "{\n" +
135             "\treturn (OS_TLSIndex)deThreadLocal_create();\n" +
136             "}\n" +
137             "\n" +
138             "bool OS_SetTLSValue (OS_TLSIndex nIndex, void* lpvValue)\n" +
139             "{\n" +
140             "\tdeThreadLocal_set((deThreadLocal)nIndex, lpvValue);\n" +
141             "\treturn true;\n" +
142             "}\n" +
143             "\n" +
144             "bool OS_FreeTLSIndex (OS_TLSIndex nIndex)\n" +
145             "{\n" +
146             "\tdeThreadLocal_destroy((deThreadLocal)nIndex);\n" +
147             "\treturn true;\n" +
148             "}\n" +
149             "\n" +
150             "void* OS_GetTLSValue (OS_TLSIndex nIndex)\n" +
151             "{\n" +
152             "\treturn deThreadLocal_get((deThreadLocal)nIndex);\n" +
153             "}\n" +
154             "\n" +
155             "// Global lock\n" +
156             "\n" +
157             "static deMutex s_globalLock = 0;\n" +
158             "\n" +
159             "void InitGlobalLock (void)\n" +
160             "{\n" +
161             "\tDE_ASSERT(s_globalLock == 0);\n" +
162             "\ts_globalLock = deMutex_create(DE_NULL);\n" +
163             "}\n" +
164             "\n" +
165             "void GetGlobalLock (void)\n" +
166             "{\n" +
167             "\tdeMutex_lock(s_globalLock);\n" +
168             "}\n" +
169             "\n" +
170             "void ReleaseGlobalLock (void)\n" +
171             "{\n" +
172             "\tdeMutex_unlock(s_globalLock);\n" +
173             "}\n" +
174             "\n" +
175             "// Threading\n" +
176             "\n" +
177             "DE_STATIC_ASSERT(sizeof(void*) >= sizeof(deThread));\n" +
178             "\n" +
179             "static void EnterGenericThread (void* entry)\n" +
180             "{\n" +
181             "\t((TThreadEntrypoint)entry)(DE_NULL);\n" +
182             "}\n" +
183             "\n" +
184             "void* OS_CreateThread (TThreadEntrypoint entry)\n" +
185             "{\n" +
186             "\treturn (void*)(deUintptr)deThread_create(EnterGenericThread, (void*)entry, DE_NULL);\n" +
187             "}\n" +
188             "\n" +
189             "void OS_WaitForAllThreads (void* threads, int numThreads)\n" +
190             "{\n" +
191             "\tfor (int ndx = 0; ndx < numThreads; ndx++)\n" +
192             "\t{\n" +
193             "\t\tconst deThread thread = (deThread)(deUintptr)((void**)threads)[ndx];\n" +
194             "\t\tdeThread_join(thread);\n" +
195             "\t\tdeThread_destroy(thread);\n" +
196             "\t}\n" +
197             "}\n" +
198             "\n" +
199             "void OS_Sleep (int milliseconds)\n" +
200             "{\n" +
201             "\tdeSleep(milliseconds);\n" +
202             "}\n" +
203             "\n" +
204             "void OS_DumpMemoryCounters (void)\n" +
205             "{\n" +
206             "\t// Not used\n" +
207             "}\n" +
208             "\n" +
209             "} // glslang\n";
210 
211     @BeforeEach
setUp()212     void setUp() {
213     }
214 
215     @AfterEach
tearDown()216     void tearDown() {
217     }
218 
219     @Test
parseFile()220     void parseFile() {
221     }
222 
223     @Test
parseContent()224     void parseContent() {
225     }
226 
227     @Test
parseCStreamEnum1()228     void parseCStreamEnum1() {
229         ParseBase parser = ParseFactory.getParser("h2dts");
230         String testEnum = "enum Colors {\n" +
231                 "  Red = 1,\n" +
232                 "  Green = 2,\n" +
233                 "  Blue = 3\n" +
234                 "};";
235         CodePointCharStream cStream = CharStreams.fromString(testEnum);
236         ParseObj po = parser.parseCStream(cStream);
237         List<EnumObj> eol = po.getEnumList();
238         assertEquals(1, eol.size());
239         EnumObj eo = eol.get(0);
240         assertEquals("Colors", eo.getName());
241         List<String> ml = eo.getMemberList();
242         assertEquals(3, ml.size());
243         assertEquals("Red", ml.get(0));
244         assertEquals("Green", ml.get(1));
245         assertEquals("Blue", ml.get(2));
246         List<String> vl = eo.getValueList();
247         assertEquals(3, vl.size());
248         assertEquals("1", vl.get(0));
249         assertEquals("2", vl.get(1));
250         assertEquals("3", vl.get(2));
251     }
252 
253     @Test
parseCStreamEnum2()254     void parseCStreamEnum2() {
255         ParseBase parser = ParseFactory.getParser("h2dts");
256         String testEnum = "enum {\n" +
257                 "  Red = 1,\n" +
258                 "  Green = 2,\n" +
259                 "  Blue = 3\n" +
260                 "};";
261         CodePointCharStream cStream = CharStreams.fromString(testEnum);
262         ParseObj po = parser.parseCStream(cStream);
263         List<EnumObj> eol = po.getEnumList();
264         assertEquals(1, eol.size());
265         EnumObj eo = eol.get(0);
266         assertEquals("", eo.getName());
267         List<String> ml = eo.getMemberList();
268         assertEquals(3, ml.size());
269         assertEquals("Red", ml.get(0));
270         assertEquals("Green", ml.get(1));
271         assertEquals("Blue", ml.get(2));
272         List<String> vl = eo.getValueList();
273         assertEquals(3, vl.size());
274         assertEquals("1", vl.get(0));
275         assertEquals("2", vl.get(1));
276         assertEquals("3", vl.get(2));
277     }
278 
279     @Test
parseCStreamEnum3()280     void parseCStreamEnum3() {
281         ParseBase parser = ParseFactory.getParser("h2dts");
282         String testEnum = "typedef enum {\n" +
283                 "  Red = 1,\n" +
284                 "  Green = 2,\n" +
285                 "  Blue = 3\n" +
286                 "} Colors_T;";
287         CodePointCharStream cStream = CharStreams.fromString(testEnum);
288         ParseObj po = parser.parseCStream(cStream);
289         List<EnumObj> eol = po.getEnumList();
290         assertEquals(1, eol.size());
291         EnumObj eo = eol.get(0);
292         assertEquals("", eo.getName());
293         assertEquals("Colors_T", eo.getAlias());
294         List<String> ml = eo.getMemberList();
295         assertEquals(3, ml.size());
296         assertEquals("Red", ml.get(0));
297         assertEquals("Green", ml.get(1));
298         assertEquals("Blue", ml.get(2));
299         List<String> vl = eo.getValueList();
300         assertEquals(3, vl.size());
301         assertEquals("1", vl.get(0));
302         assertEquals("2", vl.get(1));
303         assertEquals("3", vl.get(2));
304     }
305 
306     @Test
parseCStreamEnum4()307     void parseCStreamEnum4() {
308         ParseBase parser = ParseFactory.getParser("h2dts");
309         String testEnum = "typedef enum Colors {\n" +
310                 "  Red = 1,\n" +
311                 "  Green = 2,\n" +
312                 "  Blue = 3\n" +
313                 "} Colors_T;";
314         CodePointCharStream cStream = CharStreams.fromString(testEnum);
315         ParseObj po = parser.parseCStream(cStream);
316         List<EnumObj> eol = po.getEnumList();
317         assertEquals(1, eol.size());
318         EnumObj eo = eol.get(0);
319         assertEquals("Colors", eo.getName());
320         assertEquals("Colors_T", eo.getAlias());
321         List<String> ml = eo.getMemberList();
322         assertEquals(3, ml.size());
323         assertEquals("Red", ml.get(0));
324         assertEquals("Green", ml.get(1));
325         assertEquals("Blue", ml.get(2));
326         List<String> vl = eo.getValueList();
327         assertEquals(3, vl.size());
328         assertEquals("1", vl.get(0));
329         assertEquals("2", vl.get(1));
330         assertEquals("3", vl.get(2));
331     }
332 
333     @Test
parseCStreamStruct1()334     void parseCStreamStruct1() {
335         ParseBase parser = ParseFactory.getParser("h2dts");
336         String testEnum = "struct tree_el {\n" +
337                 "   int val;\n" +
338                 "   struct tree_el * right, * left;\n" +
339                 "};";
340         CodePointCharStream cStream = CharStreams.fromString(testEnum);
341         ParseObj po = parser.parseCStream(cStream);
342         List<StructObj> sol = po.getStructList();
343         assertEquals(1, sol.size());
344         StructObj so = sol.get(0);
345         assertEquals("tree_el", so.getName());
346 
347         List<ParamObj> ml = so.getMemberList();
348         assertEquals(3, ml.size());
349         assertEquals("val", ml.get(0).getName());
350         assertEquals("int", ml.get(0).getType());
351         assertEquals("struct tree_el", ml.get(1).getType());
352         assertEquals("*right", ml.get(1).getName());
353         assertEquals("struct tree_el", ml.get(2).getType());
354         assertEquals("*left", ml.get(2).getName());
355 
356     }
357 
358     @Test
parseCStreamStruct2()359     void parseCStreamStruct2() {
360         ParseBase parser = ParseFactory.getParser("h2dts");
361         String testEnum = "struct {\n" +
362                 "   int val;\n" +
363                 "   Tree_el_T * right, * left;\n" +
364                 "};";
365         CodePointCharStream cStream = CharStreams.fromString(testEnum);
366         ParseObj po = parser.parseCStream(cStream);
367         List<StructObj> sol = po.getStructList();
368         assertEquals(1, sol.size());
369         StructObj so = sol.get(0);
370         assertEquals("", so.getName());
371 
372         List<ParamObj> ml = so.getMemberList();
373         assertEquals(3, ml.size());
374         assertEquals("val", ml.get(0).getName());
375         assertEquals("int", ml.get(0).getType());
376         assertEquals("Tree_el_T", ml.get(1).getType());
377         assertEquals("*right", ml.get(1).getName());
378         assertEquals("Tree_el_T", ml.get(2).getType());
379         assertEquals("*left", ml.get(2).getName());
380 
381     }
382 
383     @Test
parseCStreamStruct3()384     void parseCStreamStruct3() {
385         ParseBase parser = ParseFactory.getParser("h2dts");
386         String testEnum = "typedef struct {\n" +
387                 "   int val;\n" +
388                 "   Tree_el_T * right, * left;\n" +
389                 "} Tree_el_T;";
390         CodePointCharStream cStream = CharStreams.fromString(testEnum);
391         ParseObj po = parser.parseCStream(cStream);
392         List<StructObj> sol = po.getStructList();
393         assertEquals(1, sol.size());
394         StructObj so = sol.get(0);
395         assertEquals("", so.getName());
396         assertEquals("Tree_el_T", so.getAlias());
397 
398         List<ParamObj> ml = so.getMemberList();
399         assertEquals(3, ml.size());
400         assertEquals("val", ml.get(0).getName());
401         assertEquals("int", ml.get(0).getType());
402         assertEquals("Tree_el_T", ml.get(1).getType());
403         assertEquals("*right", ml.get(1).getName());
404         assertEquals("Tree_el_T", ml.get(2).getType());
405         assertEquals("*left", ml.get(2).getName());
406 
407     }
408 
409     @Test
parseCStreamStruct4()410     void parseCStreamStruct4() {
411         ParseBase parser = ParseFactory.getParser("h2dts");
412         String testEnum = "typedef struct tree_el {\n" +
413                 "   int val;\n" +
414                 "   struct tree_el * right, * left;\n" +
415                 "} Tree_el_T;";
416         CodePointCharStream cStream = CharStreams.fromString(testEnum);
417         ParseObj po = parser.parseCStream(cStream);
418         List<StructObj> sol = po.getStructList();
419         assertEquals(1, sol.size());
420         StructObj so = sol.get(0);
421         assertEquals("tree_el", so.getName());
422         assertEquals("Tree_el_T", so.getAlias());
423 
424         List<ParamObj> ml = so.getMemberList();
425         assertEquals(3, ml.size());
426         assertEquals("val", ml.get(0).getName());
427         assertEquals("int", ml.get(0).getType());
428         assertEquals("struct tree_el", ml.get(1).getType());
429         assertEquals("*right", ml.get(1).getName());
430         assertEquals("struct tree_el", ml.get(2).getType());
431         assertEquals("*left", ml.get(2).getName());
432 
433     }
434 
435     @Test
parseCStreamUnion1()436     void parseCStreamUnion1() {
437         ParseBase parser = ParseFactory.getParser("h2dts");
438         String testEnum = "union tree_el {\n" +
439                 "   int val;\n" +
440                 "   struct tree_el * right, * left;\n" +
441                 "};";
442         CodePointCharStream cStream = CharStreams.fromString(testEnum);
443         ParseObj po = parser.parseCStream(cStream);
444         List<UnionObj> sol = po.getUnionList();
445         assertEquals(1, sol.size());
446         UnionObj so = sol.get(0);
447         assertEquals("tree_el", so.getName());
448 
449         List<ParamObj> ml = so.getMemList();
450         assertEquals(3, ml.size());
451         assertEquals("val", ml.get(0).getName());
452         assertEquals("int", ml.get(0).getType());
453         assertEquals("struct tree_el", ml.get(1).getType());
454         assertEquals("*right", ml.get(1).getName());
455         assertEquals("struct tree_el", ml.get(2).getType());
456         assertEquals("*left", ml.get(2).getName());
457 
458     }
459 
460     @Test
parseCStreamUnion2()461     void parseCStreamUnion2() {
462         ParseBase parser = ParseFactory.getParser("h2dts");
463         String testEnum = "union {\n" +
464                 "   int val;\n" +
465                 "   struct tree_el * right, * left;\n" +
466                 "};";
467         CodePointCharStream cStream = CharStreams.fromString(testEnum);
468         ParseObj po = parser.parseCStream(cStream);
469         List<UnionObj> sol = po.getUnionList();
470         assertEquals(1, sol.size());
471         UnionObj so = sol.get(0);
472 
473         List<ParamObj> ml = so.getMemList();
474         assertEquals(3, ml.size());
475         assertEquals("val", ml.get(0).getName());
476         assertEquals("int", ml.get(0).getType());
477         assertEquals("struct tree_el", ml.get(1).getType());
478         assertEquals("*right", ml.get(1).getName());
479         assertEquals("struct tree_el", ml.get(2).getType());
480         assertEquals("*left", ml.get(2).getName());
481 
482     }
483 
484     @Test
parseCStreamUnion3()485     void parseCStreamUnion3() {
486         ParseBase parser = ParseFactory.getParser("h2dts");
487         String testEnum = "typedef union {\n" +
488                 "   int val;\n" +
489                 "   Tree_el_T * right, * left;\n" +
490                 "} Tree_el_T;";
491         CodePointCharStream cStream = CharStreams.fromString(testEnum);
492         ParseObj po = parser.parseCStream(cStream);
493         List<UnionObj> sol = po.getUnionList();
494         assertEquals(1, sol.size());
495         UnionObj so = sol.get(0);
496         assertEquals("", so.getName());
497         assertEquals("Tree_el_T", so.getAlias());
498 
499         List<ParamObj> ml = so.getMemList();
500         assertEquals(3, ml.size());
501         assertEquals("val", ml.get(0).getName());
502         assertEquals("int", ml.get(0).getType());
503         assertEquals("Tree_el_T", ml.get(1).getType());
504         assertEquals("*right", ml.get(1).getName());
505         assertEquals("Tree_el_T", ml.get(2).getType());
506         assertEquals("*left", ml.get(2).getName());
507 
508     }
509 
510     @Test
parseCStreamUnion4()511     void parseCStreamUnion4() {
512         ParseBase parser = ParseFactory.getParser("h2dts");
513         String testEnum = "typedef union tree_el {\n" +
514                 "   int val;\n" +
515                 "   struct tree_el * right, * left;\n" +
516                 "} Tree_el_T;";
517         CodePointCharStream cStream = CharStreams.fromString(testEnum);
518         ParseObj po = parser.parseCStream(cStream);
519         List<UnionObj> sol = po.getUnionList();
520         assertEquals(1, sol.size());
521         UnionObj so = sol.get(0);
522         assertEquals("tree_el", so.getName());
523         assertEquals("Tree_el_T", so.getAlias());
524 
525         List<ParamObj> ml = so.getMemList();
526         assertEquals(3, ml.size());
527         assertEquals("val", ml.get(0).getName());
528         assertEquals("int", ml.get(0).getType());
529         assertEquals("struct tree_el", ml.get(1).getType());
530         assertEquals("*right", ml.get(1).getName());
531         assertEquals("struct tree_el", ml.get(2).getType());
532         assertEquals("*left", ml.get(2).getName());
533 
534     }
535 
536     @Test
parseCStreamClass1()537     void parseCStreamClass1() {
538         ParseBase parser = ParseFactory.getParser("h2dts");
539         String testEnum = "class tree_el {\n" +
540                 "   int val;\n" +
541                 "   struct tree_el * right, * left;\n" +
542                 "};";
543         CodePointCharStream cStream = CharStreams.fromString(testEnum);
544         ParseObj po = parser.parseCStream(cStream);
545         List<ClassObj> col = po.getClassList();
546         assertEquals(1, col.size());
547         ClassObj co = col.get(0);
548         assertEquals("tree_el", co.getName());
549 
550         List<ParamObj> pl = co.getParamList();
551         assertEquals(3, pl.size());
552         assertEquals("val", pl.get(0).getName());
553         assertEquals("int", pl.get(0).getType());
554         assertEquals("struct tree_el", pl.get(1).getType());
555         assertEquals("*right", pl.get(1).getName());
556         assertEquals("struct tree_el", pl.get(2).getType());
557         assertEquals("*left", pl.get(2).getName());
558 
559     }
560 
561     @Test
parseCStreamClass2()562     void parseCStreamClass2() {
563         ParseBase parser = ParseFactory.getParser("h2dts");
564         String testEnum = "class {\n" +
565                 "   int val;\n" +
566                 "   struct tree_el * right, * left;\n" +
567                 "};";
568         CodePointCharStream cStream = CharStreams.fromString(testEnum);
569         ParseObj po = parser.parseCStream(cStream);
570         List<ClassObj> col = po.getClassList();
571         assertEquals(1, col.size());
572         ClassObj co = col.get(0);
573 
574         List<ParamObj> pl = co.getParamList();
575         assertEquals(3, pl.size());
576         assertEquals("val", pl.get(0).getName());
577         assertEquals("int", pl.get(0).getType());
578         assertEquals("struct tree_el", pl.get(1).getType());
579         assertEquals("*right", pl.get(1).getName());
580         assertEquals("struct tree_el", pl.get(2).getType());
581         assertEquals("*left", pl.get(2).getName());
582 
583     }
584     @Test
parseCStreamClass3()585     void parseCStreamClass3() {
586         ParseBase parser = ParseFactory.getParser("h2dts");
587         String testEnum = "typedef class {\n" +
588                 "   int val;\n" +
589                 "   struct tree_el * right, * left;\n" +
590                 "} tree_el_T;";
591         CodePointCharStream cStream = CharStreams.fromString(testEnum);
592         ParseObj po = parser.parseCStream(cStream);
593         List<ClassObj> col = po.getClassList();
594         assertEquals(1, col.size());
595         ClassObj co = col.get(0);
596         assertEquals("tree_el_T", co.getAlias());
597 
598         List<ParamObj> pl = co.getParamList();
599         assertEquals(3, pl.size());
600         assertEquals("val", pl.get(0).getName());
601         assertEquals("int", pl.get(0).getType());
602         assertEquals("struct tree_el", pl.get(1).getType());
603         assertEquals("*right", pl.get(1).getName());
604         assertEquals("struct tree_el", pl.get(2).getType());
605         assertEquals("*left", pl.get(2).getName());
606 
607     }
608 
609     @Test
parseCStreamClass4()610     void parseCStreamClass4() {
611         ParseBase parser = ParseFactory.getParser("h2dts");
612         String testEnum = "typedef class tree_el {\n" +
613                 "   int val;\n" +
614                 "   struct tree_el * right, * left;\n" +
615                 "} tree_el_T;";
616         CodePointCharStream cStream = CharStreams.fromString(testEnum);
617         ParseObj po = parser.parseCStream(cStream);
618         List<ClassObj> col = po.getClassList();
619         assertEquals(1, col.size());
620         ClassObj co = col.get(0);
621         assertEquals("tree_el", co.getName());
622         assertEquals("tree_el_T", co.getAlias());
623 
624         List<ParamObj> pl = co.getParamList();
625         assertEquals(3, pl.size());
626         assertEquals("val", pl.get(0).getName());
627         assertEquals("int", pl.get(0).getType());
628         assertEquals("struct tree_el", pl.get(1).getType());
629         assertEquals("*right", pl.get(1).getName());
630         assertEquals("struct tree_el", pl.get(2).getType());
631         assertEquals("*left", pl.get(2).getName());
632 
633     }
634 
635     @Test
parseCStreamFunction1()636     void parseCStreamFunction1() {
637         ParseBase parser = ParseFactory.getParser("h2dts");
638         String testEnum = "int foo();";
639         CodePointCharStream cStream = CharStreams.fromString(testEnum);
640         ParseObj po = parser.parseCStream(cStream);
641         List<FuncObj> fol = po.getFuncList();
642         assertEquals(1, fol.size());
643         FuncObj fo = fol.get(0);
644         assertEquals("foo", fo.getName());
645 
646     }
647 
648     @Test
parseCStreamFunction2()649     void parseCStreamFunction2() {
650         ParseBase parser = ParseFactory.getParser("h2dts");
651         String testEnum = "int foo( short s );";
652         CodePointCharStream cStream = CharStreams.fromString(testEnum);
653         ParseObj po = parser.parseCStream(cStream);
654         List<FuncObj> fol = po.getFuncList();
655         assertEquals(1, fol.size());
656         FuncObj fo = fol.get(0);
657         assertEquals("foo", fo.getName());
658 
659         List<ParamObj> pl = fo.getParamList();
660         assertEquals(1, pl.size());
661         assertEquals("s", pl.get(0).getName());
662         assertEquals("short", pl.get(0).getType());
663     }
664 
665     @Test
parseCStreamFunction3()666     void parseCStreamFunction3() {
667         ParseBase parser = ParseFactory.getParser("h2dts");
668         String testEnum = "int foo( short int si );";
669         CodePointCharStream cStream = CharStreams.fromString(testEnum);
670         ParseObj po = parser.parseCStream(cStream);
671         List<FuncObj> fol = po.getFuncList();
672         assertEquals(1, fol.size());
673         FuncObj fo = fol.get(0);
674         assertEquals("foo", fo.getName());
675 
676         List<ParamObj> pl = fo.getParamList();
677         assertEquals(1, pl.size());
678         assertEquals("si", pl.get(0).getName());
679         assertEquals("short int", pl.get(0).getType());
680     }
681 
682     @Test
parseCStreamFunction4()683     void parseCStreamFunction4() {
684         ParseBase parser = ParseFactory.getParser("h2dts");
685         String testEnum = "int foo( signed short ss );";
686         CodePointCharStream cStream = CharStreams.fromString(testEnum);
687         ParseObj po = parser.parseCStream(cStream);
688         List<FuncObj> fol = po.getFuncList();
689         assertEquals(1, fol.size());
690         FuncObj fo = fol.get(0);
691         assertEquals("foo", fo.getName());
692 
693         List<ParamObj> pl = fo.getParamList();
694         assertEquals(1, pl.size());
695         assertEquals("ss", pl.get(0).getName());
696         assertEquals("signed short", pl.get(0).getType());
697     }
698 
699     @Test
parseCStreamFunction5()700     void parseCStreamFunction5() {
701         ParseBase parser = ParseFactory.getParser("h2dts");
702         String testEnum = "int foo( signed short int ssi);";
703         CodePointCharStream cStream = CharStreams.fromString(testEnum);
704         ParseObj po = parser.parseCStream(cStream);
705         List<FuncObj> fol = po.getFuncList();
706         assertEquals(1, fol.size());
707         FuncObj fo = fol.get(0);
708         assertEquals("foo", fo.getName());
709 
710         List<ParamObj> pl = fo.getParamList();
711         assertEquals(1, pl.size());
712         assertEquals("ssi", pl.get(0).getName());
713         assertEquals("signed short int", pl.get(0).getType());
714     }
715 
716     @Test
parseCStreamFunction6()717     void parseCStreamFunction6() {
718         ParseBase parser = ParseFactory.getParser("h2dts");
719         String testEnum = "int foo( unsigned short us );";
720         CodePointCharStream cStream = CharStreams.fromString(testEnum);
721         ParseObj po = parser.parseCStream(cStream);
722         List<FuncObj> fol = po.getFuncList();
723         assertEquals(1, fol.size());
724         FuncObj fo = fol.get(0);
725         assertEquals("foo", fo.getName());
726 
727         List<ParamObj> pl = fo.getParamList();
728         assertEquals(1, pl.size());
729         assertEquals("us", pl.get(0).getName());
730         assertEquals("unsigned short", pl.get(0).getType());
731     }
732 
733     @Test
parseCStreamFunction7()734     void parseCStreamFunction7() {
735         ParseBase parser = ParseFactory.getParser("h2dts");
736         String testEnum = "int foo( unsigned short int usi );";
737         CodePointCharStream cStream = CharStreams.fromString(testEnum);
738         ParseObj po = parser.parseCStream(cStream);
739         List<FuncObj> fol = po.getFuncList();
740         assertEquals(1, fol.size());
741         FuncObj fo = fol.get(0);
742         assertEquals("foo", fo.getName());
743 
744         List<ParamObj> pl = fo.getParamList();
745         assertEquals(1, pl.size());
746         assertEquals("usi", pl.get(0).getName());
747         assertEquals("unsigned short int", pl.get(0).getType());
748     }
749 
750     @Test
parseCStreamFunction8()751     void parseCStreamFunction8() {
752         ParseBase parser = ParseFactory.getParser("h2dts");
753         String testEnum = "int foo( int i);";
754         CodePointCharStream cStream = CharStreams.fromString(testEnum);
755         ParseObj po = parser.parseCStream(cStream);
756         List<FuncObj> fol = po.getFuncList();
757         assertEquals(1, fol.size());
758         FuncObj fo = fol.get(0);
759         assertEquals("foo", fo.getName());
760 
761         List<ParamObj> pl = fo.getParamList();
762         assertEquals(1, pl.size());
763         assertEquals("i", pl.get(0).getName());
764         assertEquals("int", pl.get(0).getType());
765     }
766 
767     @Test
parseCStreamFunction9()768     void parseCStreamFunction9() {
769         ParseBase parser = ParseFactory.getParser("h2dts");
770         String testEnum = "int foo( signed s );";
771         CodePointCharStream cStream = CharStreams.fromString(testEnum);
772         ParseObj po = parser.parseCStream(cStream);
773         List<FuncObj> fol = po.getFuncList();
774         assertEquals(1, fol.size());
775         FuncObj fo = fol.get(0);
776         assertEquals("foo", fo.getName());
777 
778         List<ParamObj> pl = fo.getParamList();
779         assertEquals(1, pl.size());
780         assertEquals("s", pl.get(0).getName());
781         assertEquals("signed", pl.get(0).getType());
782     }
783 
784     @Test
parseCStreamFunction10()785     void parseCStreamFunction10() {
786         ParseBase parser = ParseFactory.getParser("h2dts");
787         String testEnum = "int foo( signed int si );";
788         CodePointCharStream cStream = CharStreams.fromString(testEnum);
789         ParseObj po = parser.parseCStream(cStream);
790         List<FuncObj> fol = po.getFuncList();
791         assertEquals(1, fol.size());
792         FuncObj fo = fol.get(0);
793         assertEquals("foo", fo.getName());
794 
795         List<ParamObj> pl = fo.getParamList();
796         assertEquals(1, pl.size());
797         assertEquals("si", pl.get(0).getName());
798         assertEquals("signed int", pl.get(0).getType());
799     }
800 
801     @Test
parseCStreamFunction11()802     void parseCStreamFunction11() {
803         ParseBase parser = ParseFactory.getParser("h2dts");
804         String testEnum = "int foo( unsigned u );";
805         CodePointCharStream cStream = CharStreams.fromString(testEnum);
806         ParseObj po = parser.parseCStream(cStream);
807         List<FuncObj> fol = po.getFuncList();
808         assertEquals(1, fol.size());
809         FuncObj fo = fol.get(0);
810         assertEquals("foo", fo.getName());
811 
812         List<ParamObj> pl = fo.getParamList();
813         assertEquals(1, pl.size());
814         assertEquals("u", pl.get(0).getName());
815         assertEquals("unsigned", pl.get(0).getType());
816     }
817 
818     @Test
parseCStreamFunction12()819     void parseCStreamFunction12() {
820         ParseBase parser = ParseFactory.getParser("h2dts");
821         String testEnum = "int foo( unsigned int ui );";
822         CodePointCharStream cStream = CharStreams.fromString(testEnum);
823         ParseObj po = parser.parseCStream(cStream);
824         List<FuncObj> fol = po.getFuncList();
825         assertEquals(1, fol.size());
826         FuncObj fo = fol.get(0);
827         assertEquals("foo", fo.getName());
828 
829         List<ParamObj> pl = fo.getParamList();
830         assertEquals(1, pl.size());
831         assertEquals("ui", pl.get(0).getName());
832         assertEquals("unsigned int", pl.get(0).getType());
833     }
834 
835     @Test
parseCStreamFunction13()836     void parseCStreamFunction13() {
837         ParseBase parser = ParseFactory.getParser("h2dts");
838         String testEnum = "int foo( long l );";
839         CodePointCharStream cStream = CharStreams.fromString(testEnum);
840         ParseObj po = parser.parseCStream(cStream);
841         List<FuncObj> fol = po.getFuncList();
842         assertEquals(1, fol.size());
843         FuncObj fo = fol.get(0);
844         assertEquals("foo", fo.getName());
845 
846         List<ParamObj> pl = fo.getParamList();
847         assertEquals(1, pl.size());
848         assertEquals("l", pl.get(0).getName());
849         assertEquals("long", pl.get(0).getType());
850     }
851 
852     @Test
parseCStreamFunction14()853     void parseCStreamFunction14() {
854         ParseBase parser = ParseFactory.getParser("h2dts");
855         String testEnum = "int foo( long int li );";
856         CodePointCharStream cStream = CharStreams.fromString(testEnum);
857         ParseObj po = parser.parseCStream(cStream);
858         List<FuncObj> fol = po.getFuncList();
859         assertEquals(1, fol.size());
860         FuncObj fo = fol.get(0);
861         assertEquals("foo", fo.getName());
862 
863         List<ParamObj> pl = fo.getParamList();
864         assertEquals(1, pl.size());
865         assertEquals("li", pl.get(0).getName());
866         assertEquals("long int", pl.get(0).getType());
867     }
868 
869     @Test
parseCStreamFunction15()870     void parseCStreamFunction15() {
871         ParseBase parser = ParseFactory.getParser("h2dts");
872         String testEnum = "int foo( signed long sl );";
873         CodePointCharStream cStream = CharStreams.fromString(testEnum);
874         ParseObj po = parser.parseCStream(cStream);
875         List<FuncObj> fol = po.getFuncList();
876         assertEquals(1, fol.size());
877         FuncObj fo = fol.get(0);
878         assertEquals("foo", fo.getName());
879 
880         List<ParamObj> pl = fo.getParamList();
881         assertEquals(1, pl.size());
882         assertEquals("sl", pl.get(0).getName());
883         assertEquals("signed long", pl.get(0).getType());
884     }
885 
886     @Test
parseCStreamFunction16()887     void parseCStreamFunction16() {
888         ParseBase parser = ParseFactory.getParser("h2dts");
889         String testEnum = "int foo( signed long int sli );";
890         CodePointCharStream cStream = CharStreams.fromString(testEnum);
891         ParseObj po = parser.parseCStream(cStream);
892         List<FuncObj> fol = po.getFuncList();
893         assertEquals(1, fol.size());
894         FuncObj fo = fol.get(0);
895         assertEquals("foo", fo.getName());
896 
897         List<ParamObj> pl = fo.getParamList();
898         assertEquals(1, pl.size());
899         assertEquals("sli", pl.get(0).getName());
900         assertEquals("signed long int", pl.get(0).getType());
901     }
902 
903     @Test
parseCStreamFunction17()904     void parseCStreamFunction17() {
905         ParseBase parser = ParseFactory.getParser("h2dts");
906         String testEnum = "int foo( unsigned long ul );";
907         CodePointCharStream cStream = CharStreams.fromString(testEnum);
908         ParseObj po = parser.parseCStream(cStream);
909         List<FuncObj> fol = po.getFuncList();
910         assertEquals(1, fol.size());
911         FuncObj fo = fol.get(0);
912         assertEquals("foo", fo.getName());
913 
914         List<ParamObj> pl = fo.getParamList();
915         assertEquals(1, pl.size());
916         assertEquals("ul", pl.get(0).getName());
917         assertEquals("unsigned long", pl.get(0).getType());
918     }
919 
920     @Test
parseCStreamFunction18()921     void parseCStreamFunction18() {
922         ParseBase parser = ParseFactory.getParser("h2dts");
923         String testEnum = "int foo( unsigned long int uli );";
924         CodePointCharStream cStream = CharStreams.fromString(testEnum);
925         ParseObj po = parser.parseCStream(cStream);
926         List<FuncObj> fol = po.getFuncList();
927         assertEquals(1, fol.size());
928         FuncObj fo = fol.get(0);
929         assertEquals("foo", fo.getName());
930 
931         List<ParamObj> pl = fo.getParamList();
932         assertEquals(1, pl.size());
933         assertEquals("uli", pl.get(0).getName());
934         assertEquals("unsigned long int", pl.get(0).getType());
935     }
936 
937     @Test
parseCStreamFunction19()938     void parseCStreamFunction19() {
939         ParseBase parser = ParseFactory.getParser("h2dts");
940         String testEnum = "int foo( long long ll );";
941         CodePointCharStream cStream = CharStreams.fromString(testEnum);
942         ParseObj po = parser.parseCStream(cStream);
943         List<FuncObj> fol = po.getFuncList();
944         assertEquals(1, fol.size());
945         FuncObj fo = fol.get(0);
946         assertEquals("foo", fo.getName());
947 
948         List<ParamObj> pl = fo.getParamList();
949         assertEquals(1, pl.size());
950         assertEquals("ll", pl.get(0).getName());
951         assertEquals("long long", pl.get(0).getType());
952     }
953 
954     @Test
parseCStreamFunction20()955     void parseCStreamFunction20() {
956         ParseBase parser = ParseFactory.getParser("h2dts");
957         String testEnum = "int foo( long long int lli );";
958         CodePointCharStream cStream = CharStreams.fromString(testEnum);
959         ParseObj po = parser.parseCStream(cStream);
960         List<FuncObj> fol = po.getFuncList();
961         assertEquals(1, fol.size());
962         FuncObj fo = fol.get(0);
963         assertEquals("foo", fo.getName());
964 
965         List<ParamObj> pl = fo.getParamList();
966         assertEquals(1, pl.size());
967         assertEquals("lli", pl.get(0).getName());
968         assertEquals("long long int", pl.get(0).getType());
969     }
970 
971     @Test
parseCStreamFunction21()972     void parseCStreamFunction21() {
973         ParseBase parser = ParseFactory.getParser("h2dts");
974         String testEnum = "int foo( signed long long sll );";
975         CodePointCharStream cStream = CharStreams.fromString(testEnum);
976         ParseObj po = parser.parseCStream(cStream);
977         List<FuncObj> fol = po.getFuncList();
978         assertEquals(1, fol.size());
979         FuncObj fo = fol.get(0);
980         assertEquals("foo", fo.getName());
981 
982         List<ParamObj> pl = fo.getParamList();
983         assertEquals(1, pl.size());
984         assertEquals("sll", pl.get(0).getName());
985         assertEquals("signed long long", pl.get(0).getType());
986     }
987 
988     @Test
parseCStreamFunction22()989     void parseCStreamFunction22() {
990         ParseBase parser = ParseFactory.getParser("h2dts");
991         String testEnum = "int foo( signed long long int slli );";
992         CodePointCharStream cStream = CharStreams.fromString(testEnum);
993         ParseObj po = parser.parseCStream(cStream);
994         List<FuncObj> fol = po.getFuncList();
995         assertEquals(1, fol.size());
996         FuncObj fo = fol.get(0);
997         assertEquals("foo", fo.getName());
998 
999         List<ParamObj> pl = fo.getParamList();
1000         assertEquals(1, pl.size());
1001         assertEquals("slli", pl.get(0).getName());
1002         assertEquals("signed long long int", pl.get(0).getType());
1003     }
1004 
1005     @Test
parseCStreamFunction23()1006     void parseCStreamFunction23() {
1007         ParseBase parser = ParseFactory.getParser("h2dts");
1008         String testEnum = "int foo( unsigned long long ull );";
1009         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1010         ParseObj po = parser.parseCStream(cStream);
1011         List<FuncObj> fol = po.getFuncList();
1012         assertEquals(1, fol.size());
1013         FuncObj fo = fol.get(0);
1014         assertEquals("foo", fo.getName());
1015 
1016         List<ParamObj> pl = fo.getParamList();
1017         assertEquals(1, pl.size());
1018         assertEquals("ull", pl.get(0).getName());
1019         assertEquals("unsigned long long", pl.get(0).getType());
1020     }
1021 
1022     @Test
parseCStreamFunction24()1023     void parseCStreamFunction24() {
1024         ParseBase parser = ParseFactory.getParser("h2dts");
1025         String testEnum = "int foo( unsigned long long int ulli );";
1026         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1027         ParseObj po = parser.parseCStream(cStream);
1028         List<FuncObj> fol = po.getFuncList();
1029         assertEquals(1, fol.size());
1030         FuncObj fo = fol.get(0);
1031         assertEquals("foo", fo.getName());
1032 
1033         List<ParamObj> pl = fo.getParamList();
1034         assertEquals(1, pl.size());
1035         assertEquals("ulli", pl.get(0).getName());
1036         assertEquals("unsigned long long int", pl.get(0).getType());
1037     }
1038 
1039     @Test
parseCStreamFunction25()1040     void parseCStreamFunction25() {
1041         ParseBase parser = ParseFactory.getParser("h2dts");
1042         String testEnum = "int foo( double d );";
1043         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1044         ParseObj po = parser.parseCStream(cStream);
1045         List<FuncObj> fol = po.getFuncList();
1046         assertEquals(1, fol.size());
1047         FuncObj fo = fol.get(0);
1048         assertEquals("foo", fo.getName());
1049 
1050         List<ParamObj> pl = fo.getParamList();
1051         assertEquals(1, pl.size());
1052         assertEquals("d", pl.get(0).getName());
1053         assertEquals("double", pl.get(0).getType());
1054     }
1055 
1056     @Test
parseCStreamFunction26()1057     void parseCStreamFunction26() {
1058         ParseBase parser = ParseFactory.getParser("h2dts");
1059         String testEnum = "int foo( long double ld );";
1060         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1061         ParseObj po = parser.parseCStream(cStream);
1062         List<FuncObj> fol = po.getFuncList();
1063         assertEquals(1, fol.size());
1064         FuncObj fo = fol.get(0);
1065         assertEquals("foo", fo.getName());
1066 
1067         List<ParamObj> pl = fo.getParamList();
1068         assertEquals(1, pl.size());
1069         assertEquals("ld", pl.get(0).getName());
1070         assertEquals("long double", pl.get(0).getType());
1071     }
1072 
1073     @Test
parseCStreamFunction27()1074     void parseCStreamFunction27() {
1075         ParseBase parser = ParseFactory.getParser("h2dts");
1076         String testEnum = "int foo( unsigned long );";
1077         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1078         ParseObj po = parser.parseCStream(cStream);
1079         List<FuncObj> fol = po.getFuncList();
1080         assertEquals(1, fol.size());
1081         FuncObj fo = fol.get(0);
1082         assertEquals("foo", fo.getName());
1083 
1084         List<ParamObj> pl = fo.getParamList();
1085         assertEquals(1, pl.size());
1086         assertEquals("", pl.get(0).getName());
1087         assertEquals("unsigned long", pl.get(0).getType());
1088     }
1089 
1090     @Test
parseCStreamFunction28()1091     void parseCStreamFunction28() {
1092         ParseBase parser = ParseFactory.getParser("h2dts");
1093         String testEnum = "int foo( unsigned long int );";
1094         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1095         ParseObj po = parser.parseCStream(cStream);
1096         List<FuncObj> fol = po.getFuncList();
1097         assertEquals(1, fol.size());
1098         FuncObj fo = fol.get(0);
1099         assertEquals("foo", fo.getName());
1100 
1101         List<ParamObj> pl = fo.getParamList();
1102         assertEquals(1, pl.size());
1103         assertEquals("", pl.get(0).getName());
1104         assertEquals("unsigned long int", pl.get(0).getType());
1105     }
1106 
1107     @Test
parseCStreamFunction29()1108     void parseCStreamFunction29() {
1109         ParseBase parser = ParseFactory.getParser("h2dts");
1110         String testEnum = "int foo( long long );";
1111         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1112         ParseObj po = parser.parseCStream(cStream);
1113         List<FuncObj> fol = po.getFuncList();
1114         assertEquals(1, fol.size());
1115         FuncObj fo = fol.get(0);
1116         assertEquals("foo", fo.getName());
1117 
1118         List<ParamObj> pl = fo.getParamList();
1119         assertEquals(1, pl.size());
1120         assertEquals("", pl.get(0).getName());
1121         assertEquals("long long", pl.get(0).getType());
1122     }
1123 
1124     @Test
parseCStreamFunction30()1125     void parseCStreamFunction30() {
1126         ParseBase parser = ParseFactory.getParser("h2dts");
1127         String testEnum = "int foo( long long int );";
1128         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1129         ParseObj po = parser.parseCStream(cStream);
1130         List<FuncObj> fol = po.getFuncList();
1131         assertEquals(1, fol.size());
1132         FuncObj fo = fol.get(0);
1133         assertEquals("foo", fo.getName());
1134 
1135         List<ParamObj> pl = fo.getParamList();
1136         assertEquals(1, pl.size());
1137         assertEquals("", pl.get(0).getName());
1138         assertEquals("long long int", pl.get(0).getType());
1139     }
1140 
1141     @Test
parseCStreamFile1()1142     void parseCStreamFile1() {
1143         ParseBase parser = ParseFactory.getParser("h2dts");
1144         String testEnum = testCStreamFile1;
1145         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1146         ParseObj po = parser.parseCStream(cStream);
1147         List<FuncObj> fol = po.getFuncList();
1148         assertEquals(2, fol.size());
1149 
1150         FuncObj fo = fol.get(0);
1151         assertEquals("coap_address_get_port", fo.getName());
1152         assertEquals("COAP_STATIC_INLINE uint16_t", fo.getRetValue());
1153         List<ParamObj> pol = fo.getParamList();
1154         ParamObj poItem = pol.get(0);
1155         assertEquals("constcoap_address_t", poItem.getType());
1156         assertEquals("*addr", poItem.getName());
1157 
1158         fo = fol.get(1);
1159         assertEquals("coap_address_set_port", fo.getName());
1160         assertEquals("COAP_STATIC_INLINE void", fo.getRetValue());
1161         pol = fo.getParamList();
1162         poItem = pol.get(0);
1163         assertEquals("coap_address_t", poItem.getType());
1164         assertEquals("*addr", poItem.getName());
1165         poItem = pol.get(1);
1166         assertEquals("uint16_t", poItem.getType());
1167         assertEquals("port", poItem.getName());
1168 
1169         List<StructObj> sol = po.getStructList();
1170         assertEquals(2, sol.size());
1171 
1172         StructObj soItem = sol.get(0);
1173         assertEquals("coap_address_t", soItem.getName());
1174         pol = soItem.getMemberList();
1175         poItem = pol.get(0);
1176         assertEquals("uint16_t", poItem.getType());
1177         assertEquals("port", poItem.getName());
1178         poItem = pol.get(1);
1179         assertEquals("ip_addr_t", poItem.getType());
1180         assertEquals("addr", poItem.getName());
1181 
1182         soItem = sol.get(1);
1183         assertEquals("coap_address_t", soItem.getName());
1184         pol = soItem.getMemberList();
1185         poItem = pol.get(0);
1186         assertEquals("uip_ipaddr_t", poItem.getType());
1187         assertEquals("addr", poItem.getName());
1188         poItem = pol.get(1);
1189         assertEquals("uint16_t", poItem.getType());
1190         assertEquals("port", poItem.getName());
1191 
1192     }
1193 
1194     @Test
parseCStreamFile2()1195     void parseCStreamFile2() {
1196         ParseBase parser = ParseFactory.getParser("h2dts");
1197         String testEnum = testCStreamFile2;
1198         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1199         ParseObj po = parser.parseCStream(cStream);
1200         List<FuncObj> fol = po.getFuncList();
1201         assertEquals(12, fol.size());
1202         FuncObj fo = fol.get(0);
1203         assertEquals("OS_AllocTLSIndex", fo.getName());
1204         assertEquals("OS_TLSIndex", fo.getRetValue());
1205 
1206         List<ParamObj> pl = fo.getParamList();
1207         assertEquals(1, pl.size());
1208         assertEquals("", pl.get(0).getName());
1209         assertEquals("void", pl.get(0).getType());
1210 
1211         fo = fol.get(1);
1212         assertEquals("OS_SetTLSValue", fo.getName());
1213         assertEquals("bool", fo.getRetValue());
1214 
1215         pl = fo.getParamList();
1216         assertEquals(2, pl.size());
1217         assertEquals("nIndex", pl.get(0).getName());
1218         assertEquals("OS_TLSIndex", pl.get(0).getType());
1219         assertEquals("*lpvValue", pl.get(1).getName());
1220         assertEquals("void", pl.get(1).getType());
1221 
1222         fo = fol.get(2);
1223         assertEquals("OS_FreeTLSIndex", fo.getName());
1224         assertEquals("bool", fo.getRetValue());
1225 
1226         pl = fo.getParamList();
1227         assertEquals(1, pl.size());
1228         assertEquals("nIndex", pl.get(0).getName());
1229         assertEquals("OS_TLSIndex", pl.get(0).getType());
1230 
1231         fo = fol.get(3);
1232         assertEquals("OS_GetTLSValue", fo.getName());
1233         assertEquals("void", fo.getRetValue());
1234 
1235         pl = fo.getParamList();
1236         assertEquals(1, pl.size());
1237         assertEquals("nIndex", pl.get(0).getName());
1238         assertEquals("OS_TLSIndex", pl.get(0).getType());
1239 
1240         fo = fol.get(4);
1241         assertEquals("InitGlobalLock", fo.getName());
1242         assertEquals("void", fo.getRetValue());
1243 
1244         pl = fo.getParamList();
1245         assertEquals(1, pl.size());
1246         assertEquals("", pl.get(0).getName());
1247         assertEquals("void", pl.get(0).getType());
1248 
1249 
1250     }
1251 
1252     @Test
parseCStreamFile3()1253     void parseCStreamFile3() {
1254         ParseBase parser = ParseFactory.getParser("h2dts");
1255         String testEnum = testCStreamFile2;
1256         CodePointCharStream cStream = CharStreams.fromString(testEnum);
1257         ParseObj po = parser.parseCStream(cStream);
1258         List<FuncObj> fol = po.getFuncList();
1259         assertEquals(12, fol.size());
1260 
1261         FuncObj fo = fol.get(5);
1262         assertEquals("GetGlobalLock", fo.getName());
1263         assertEquals("void", fo.getRetValue());
1264 
1265         List<ParamObj> pl = fo.getParamList();
1266         assertEquals(1, pl.size());
1267         assertEquals("", pl.get(0).getName());
1268         assertEquals("void", pl.get(0).getType());
1269 
1270         fo = fol.get(8);
1271         assertEquals("OS_CreateThread", fo.getName());
1272         assertEquals("void", fo.getRetValue());
1273 
1274         pl = fo.getParamList();
1275         assertEquals(1, pl.size());
1276         assertEquals("entry", pl.get(0).getName());
1277         assertEquals("TThreadEntrypoint", pl.get(0).getType());
1278 
1279         fo = fol.get(9);
1280         assertEquals("OS_WaitForAllThreads", fo.getName());
1281         assertEquals("void", fo.getRetValue());
1282 
1283         pl = fo.getParamList();
1284         assertEquals(2, pl.size());
1285         assertEquals("*threads", pl.get(0).getName());
1286         assertEquals("void", pl.get(0).getType());
1287         assertEquals("numThreads", pl.get(1).getName());
1288         assertEquals("int", pl.get(1).getType());
1289 
1290         fo = fol.get(10);
1291         assertEquals("OS_Sleep", fo.getName());
1292         assertEquals("void", fo.getRetValue());
1293 
1294         pl = fo.getParamList();
1295         assertEquals(1, pl.size());
1296         assertEquals("milliseconds", pl.get(0).getName());
1297         assertEquals("int", pl.get(0).getType());
1298 
1299         fo = fol.get(11);
1300         assertEquals("OS_DumpMemoryCounters", fo.getName());
1301         assertEquals("void", fo.getRetValue());
1302 
1303         pl = fo.getParamList();
1304         assertEquals(1, pl.size());
1305         assertEquals("", pl.get(0).getName());
1306         assertEquals("void", pl.get(0).getType());
1307     }
1308 
1309     @Test
genParseResult()1310     void genParseResult() {
1311     }
1312 
1313     @Test
parseEnum()1314     void parseEnum() {
1315     }
1316 
1317     @Test
parseUnion()1318     void parseUnion() {
1319     }
1320 
1321     @Test
parseStruct()1322     void parseStruct() {
1323     }
1324 
1325     @Test
parseClass()1326     void parseClass() {
1327     }
1328 
1329     @Test
parseFunc()1330     void parseFunc() {
1331     }
1332 
1333     @Test
parseType()1334     void parseType() {
1335     }
1336 }