pd_test_util.cpp
Go to the documentation of this file.
1 /** @file pd_test_util.cpp Creation of test classes */
2 
3 
4 /* Pushdown plugin for FAU Discrete Event Systems Library (libfaudes)
5 
6  Copyright (C) 2013 Stefan Jacobi, Sven Schneider, Anne-Kathrin Hess
7 
8 */
9 #include "pd_test_util.h"
10 
11 namespace faudes {
12 
13 
14 /* *****************
15  * TestGenerator1
16  * *****************/
18 
20 
21  g.InsState("s1");
22  g.InsState("s2");
23  g.InsState("s3");
24  g.InsState("s4");
25  g.InsState("s5");
27  g.InsStackSymbol("dot");
28  g.SetStackBottom("square");
29 
30 
32  g.InsControllableEvent("a");
33  g.InsControllableEvent("b");
34  g.InsEvent("u");
35  g.InsEvent("v");
36 
37 
38  std::vector<StackSymbol> vLambda;
39  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
40  std::vector<StackSymbol> vDot;
41  vDot.push_back(StackSymbol("dot"));
42  std::vector<StackSymbol> vSquare;
43  vSquare.push_back(StackSymbol("square"));
44  std::vector<StackSymbol> vSquareDot;
45  vSquareDot.push_back(StackSymbol("square"));
46  vSquareDot.push_back(StackSymbol("dot"));
47  std::vector<StackSymbol> vDotDot;
48  vDotDot.push_back(StackSymbol("dot"));
49  vDotDot.push_back(StackSymbol("dot"));
50  std::vector<StackSymbol> vDotSquare;
51  vDotSquare.push_back(StackSymbol("dot"));
52  vDotSquare.push_back(StackSymbol("square"));
53 
54  g.SetTransition("s1", "a", "s2",vLambda,vDotDot);
55  g.SetTransition("s2", "a", "s3",vDotDot,vDot);
56  g.SetTransition("s3", "b", "s2",vDot,vDotDot);
57  g.SetTransition("s1", "b", "s5",vLambda,vDotSquare);
58  g.SetTransition("s5", "a", "s4",vSquare,vLambda);
59  g.SetTransition("s4", "b", "s3",vLambda,vLambda);
60 
61  g.SetInitState("s1");
62  g.SetMarkedState("s3");
63  g.SetMarkedState("s5");
64 
65  return g;
66 }
67 
68 /* *****************
69  * TestGenerator2
70  * *****************/
72 
74 
75  g.InsState("s1");
76  g.InsState("s2");
77  g.InsState("s3");
79  g.InsStackSymbol("dot");
80  g.SetStackBottom("square");
81 
83  g.InsControllableEvent("a");
84  g.InsEvent("b");
85  g.InsEvent("d");
86 
87 
88  std::vector<StackSymbol> vLambda;
89  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
90 
91  std::vector<StackSymbol> vSquare;
92  vSquare.push_back(StackSymbol("square"));
93  std::vector<StackSymbol> vDotDot;
94  vDotDot.push_back(StackSymbol("dot"));
95  vDotDot.push_back(StackSymbol("dot"));
96  std::vector<StackSymbol> vDotSquare;
97  vDotSquare.push_back(StackSymbol("dot"));
98  vDotSquare.push_back(StackSymbol("square"));
99 
100  g.SetTransition("s1", "a", "s2",vLambda,vDotDot);
101  g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);
102  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDotDot,vSquare);
103  g.SetTransition("s3", "b", "s1",vSquare,vSquare);
104 
105  g.SetInitState("s1");
106  g.SetMarkedState("s2");
107 
108  return g;
109 }
110 /* *****************
111  * TestGenerator3
112  * *****************/
114 
116 
117  g.InsState("s1");
118  g.InsState("s2");
119  g.InsState("s3");
121  g.InsStackSymbol("dot");
122  g.InsStackSymbol("square");
123  g.SetStackBottom("square");
124 
125  g.InsControllableEvent("a");
126  g.InsEvent("b");
127 
128  std::vector<StackSymbol> vLambda;
129  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
130 
131  std::vector<StackSymbol> vSquare;
132  vSquare.push_back(StackSymbol("square"));
133  std::vector<StackSymbol> vDot;
134  vDot.push_back(StackSymbol("dot"));
135  std::vector<StackSymbol> vDotDot;
136  vDotDot.push_back(StackSymbol("dot"));
137  vDotDot.push_back(StackSymbol("dot"));
138  std::vector<StackSymbol> vDotSquare;
139  vDotSquare.push_back(StackSymbol("dot"));
140  vDotSquare.push_back(StackSymbol("square"));
141 
142  g.SetTransition("s1", "a", "s2",vDot,vDotDot);
143  g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);
144  g.SetTransition("s2", "a", "s3",vDot,vDot);
145  g.SetTransition("s3", "b", "s1",vDot,vDot);
146 
147  g.SetInitState("s1");
148  g.SetMarkedState("s2");
149 
150  return g;
151 }
152 
153 /* *****************
154  * TestGenerator4
155  * *****************/
157 
159 
160  g.InsState("s1");
161  g.InsState("s2");
162  g.InsState("s3");
164  g.InsStackSymbol("dot");
165  g.InsStackSymbol("square");
166  g.SetStackBottom("square");
167 
168  g.InsControllableEvent("a");
169  g.InsEvent("b");
170 
171  std::vector<StackSymbol> vLambda;
172  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
173  std::vector<StackSymbol> vSquare;
174  vSquare.push_back(StackSymbol("square"));
175  std::vector<StackSymbol> vDot;
176  vDot.push_back(StackSymbol("dot"));
177  std::vector<StackSymbol> vDotDot;
178  vDotDot.push_back(StackSymbol("dot"));
179  vDotDot.push_back(StackSymbol("dot"));
180  std::vector<StackSymbol> vDotDotDot;
181  vDotDotDot.push_back(StackSymbol("dot"));
182  vDotDotDot.push_back(StackSymbol("dot"));
183  vDotDotDot.push_back(StackSymbol("dot"));
184  std::vector<StackSymbol> vDotSquare;
185  vDotSquare.push_back(StackSymbol("dot"));
186  vDotSquare.push_back(StackSymbol("square"));
187 
188  g.SetTransition("s1", "a", "s2",vDotDotDot,vDotDot);
189  g.SetTransition("s1", "b", "s2",vDotSquare,vDotSquare);
190  g.SetTransition("s2", "a", "s3",vDotDot,vDot);
191  g.SetTransition("s3", "b", "s1",vDot,vDot);
192 
193  g.SetInitState("s1");
194  g.SetMarkedState("s2");
195 
196  return g;
197 }
198 
199 /* *****************
200  * TestGenerator5
201  * *****************/
203 
205 
207  Idx square = g.InsStackSymbol("square");
208  g.SetStackBottom("square");
209 
210  Idx s;
211  //insert heads and ears
212  s = g.InsState("s1");
213  MergeStateSplit mss(1);
214  g.SetMerge(s,mss);
215  g.SetDfaState(s,1);
216 
217  s = g.InsState("s11");
218  mss = MergeStateSplit(1,square);
219  g.SetMerge(s,mss);
220  g.SetDfaState(s,1);
221 
222  s = g.InsState("s2");
223  mss = MergeStateSplit(2);
224  g.SetMerge(s,mss);
225  g.SetDfaState(s,2);
226 
227  s = g.InsState("s21");
228  mss = MergeStateSplit(2,square);
229  g.SetMerge(s,mss);
230  g.SetDfaState(s,2);
231 
232  s = g.InsState("s3");
233  mss = MergeStateSplit(3);
234  g.SetMerge(s,mss);
235  g.SetDfaState(s,1);
236 
237  s = g.InsState("s31");
238  mss = MergeStateSplit(3,square);
239  g.SetMerge(s,mss);
240  g.SetDfaState(s,1);
241 
242  s = g.InsState("s4");
243  mss = MergeStateSplit(4);
244  g.SetMerge(s,mss);
245  g.SetDfaState(s,2);
246 
247  s = g.InsState("s41");
248  mss = MergeStateSplit(4,square);
249  g.SetMerge(s,mss);
250  g.SetDfaState(s,2);
251 
252  g.InsControllableEvent("a");
253  g.InsEvent("b");
255 
256  std::vector<StackSymbol> vSquare;
257  vSquare.push_back(StackSymbol("square"));
258 
259  //connect heads to ears
260  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s11",vSquare,vSquare);
261  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s21",vSquare,vSquare);
262  g.SetTransition("s3", FAUDES_PD_LAMBDA, "s31",vSquare,vSquare);
263  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s41",vSquare,vSquare);
264  //connect ears to head
265  g.SetTransition("s11", "a", "s4",vSquare,vSquare);
266  g.SetTransition("s11", "b", "s3",vSquare,vSquare);
267  g.SetTransition("s21", "a", "s4",vSquare,vSquare);
268  g.SetTransition("s21", "b", "s3",vSquare,vSquare);
269  g.SetTransition("s31", "a", "s2",vSquare,vSquare);
270  g.SetTransition("s41", "a", "s2",vSquare,vSquare);
271 
272  g.SetInitState("s1");
273  g.SetMarkedState("s21");
274  g.SetMarkedState("s41");
275 
276  return g;
277 }
278 
279 /* *****************
280  * TestGenerator6
281  * *****************/
283 
285 
286  g.InsState("s1");
287  g.InsState("s2");
288  g.InsState("s3");
290  g.InsStackSymbol("dot");
291  g.InsStackSymbol("square");
292  g.SetStackBottom("square");
293 
294  g.InsControllableEvent("a");
295  g.InsEvent("b");
297 
298  std::vector<StackSymbol> vLambda;
299  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
300  std::vector<StackSymbol> vSquare;
301  vSquare.push_back(StackSymbol("square"));
302  std::vector<StackSymbol> vDot;
303  vDot.push_back(StackSymbol("dot"));
304  std::vector<StackSymbol> vSquareDot;
305  vSquareDot.push_back(StackSymbol("square"));
306  vSquareDot.push_back(StackSymbol("dot"));
307  std::vector<StackSymbol> vSquareDotDot;
308  vSquareDotDot.push_back(StackSymbol("square"));
309  vSquareDotDot.push_back(StackSymbol("dot"));
310  vSquareDotDot.push_back(StackSymbol("dot"));
311 
312  g.SetTransition("s1", "a", "s2",vSquare,vSquare);
313  g.SetTransition("s1", "b", "s2",vDot,vSquare);
314  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDot,vDot);
315  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDot,vSquareDotDot);
316  g.SetTransition("s3", FAUDES_PD_LAMBDA, "s1",vSquare,vSquareDot);
317  g.SetTransition("s3", FAUDES_PD_LAMBDA, "s1",vSquare,vLambda);
318 
319  g.SetInitState("s1");
320  g.SetMarkedState("s2");
321 
322  return g;
323 }
324 
325 /* *****************
326  * TestGenerator7
327  * *****************/
329 
331 
332  g.InsState("s1");
333  g.InsState("s2");
334  g.InsState("s3");
335  g.InsState("s4");
337  g.InsStackSymbol("dot");
338  g.InsStackSymbol("square");
339  g.SetStackBottom("square");
340 
341  g.InsControllableEvent("a");
342  g.InsEvent("b");
344 
345  std::vector<StackSymbol> vLambda;
346  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
347  std::vector<StackSymbol> vSquare;
348  vSquare.push_back(StackSymbol("square"));
349  std::vector<StackSymbol> vDot;
350  vDot.push_back(StackSymbol("dot"));
351  std::vector<StackSymbol> vDotSquare;
352  vDotSquare.push_back(StackSymbol("dot"));
353  vDotSquare.push_back(StackSymbol("square"));
354 
355  g.SetTransition("s1", "a", "s2",vLambda,vLambda);
356  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s3",vSquare,vDotSquare);
357  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s4",vSquare,vDotSquare);
358  g.SetTransition("s3", FAUDES_PD_LAMBDA, "s2",vDot,vLambda);
359  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s3",vDot,vLambda);
360 
361  g.SetInitState("s1");
362  g.SetMarkedState("s2");
363  g.SetMarkedState("s4");
364 
365  return g;
366 }
367 
368 /* *****************
369  * TestGenerator8
370  * *****************/
372 
374 
375  g.InsState("s1");
376  g.InsState("s2");
378  g.InsStackSymbol("dot");
379  g.SetStackBottom("square");
380 
381  g.InsControllableEvent("a");
383 
384  std::vector<StackSymbol> vLambda;
385  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
386  std::vector<StackSymbol> vSquare;
387  vSquare.push_back(StackSymbol("square"));
388  std::vector<StackSymbol> vDotSquare;
389  std::vector<StackSymbol> vDot;
390  vDot.push_back(StackSymbol("dot"));
391  vDotSquare.push_back(StackSymbol("dot"));
392  vDotSquare.push_back(StackSymbol("square"));
393 
394  g.SetTransition("s2", "a", "s1",vDot,vDot);
395  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vSquare,vDotSquare);
396  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vDot,vLambda);
397 
398  g.SetInitState("s1");
399  g.SetMarkedState("s2");
400 
401  return g;
402 }
403 
404 /* *****************
405  * TestGenerator9
406  * *****************/
408 
410 
411  g.InsState("s1");
412  g.InsState("s1s");
413  g.InsState("s1d");
414  g.InsState("s2");
415  g.InsState("s2d");
416  g.InsState("s3");
417  g.InsState("s4");
418  g.InsState("s4s");
419  g.InsState("s4d");
421  g.InsStackSymbol("dot");
422  g.SetStackBottom("square");
423 
424  g.InsControllableEvent("a");
425  g.InsControllableEvent("b");
426  g.InsUncontrollableEvent("u");
428 
429  std::vector<StackSymbol> vLambda;
430  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
431  std::vector<StackSymbol> vSquare;
432  vSquare.push_back(StackSymbol("square"));
433  std::vector<StackSymbol> vDot;
434  vDot.push_back(StackSymbol("dot"));
435  std::vector<StackSymbol> vDotSquare;
436  vDotSquare.push_back(StackSymbol("dot"));
437  vDotSquare.push_back(StackSymbol("square"));
438  std::vector<StackSymbol> vSquareDot;
439  vSquareDot.push_back(StackSymbol("square"));
440  vSquareDot.push_back(StackSymbol("dot"));
441 
442  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
443  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
444  g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
445  g.SetTransition("s1d", "b", "s2",vDot,vDot);
446  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
447  g.SetTransition("s2d", "b", "s3",vDot,vLambda);
448  g.SetTransition("s2d", "u", "s4",vDot,vDot);
449  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4d",vDot,vDot);
450  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4s",vSquare,vSquare);
451  g.SetTransition("s4d", "u", "s4",vDot,vDot);
452  g.SetTransition("s4s", "u", "s4",vSquare,vSquare);
453 
454 
455  g.SetInitState("s1");
456  g.SetMarkedState("s1s");
457  g.SetMarkedState("s1d");
458  g.SetMarkedState("s4s");
459  g.SetMarkedState("s4d");
460 
461  return g;
462 }
463 
464 
465 /* *****************
466  * TestGenerator10
467  * *****************/
469 
471 
472  g.InsState("s1");
473  g.InsState("s1s");
474  g.InsState("s1d");
475  //g.InsState("3");
476  //g.InsState("4");
477 
479 
480  g.InsStackSymbol("dot");
481  g.SetStackBottom("square");
482  //g.SetStackBottom("fullsquare");
483 
484  g.InsControllableEvent("a");
485 
487 
488  std::vector<StackSymbol> vLambda;
489  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
490  std::vector<StackSymbol> vSquare;
491  vSquare.push_back(StackSymbol("square"));
492  std::vector<StackSymbol> vFullsquare;
493  vFullsquare.push_back(StackSymbol("fullsquare"));
494  std::vector<StackSymbol> vDot;
495  vDot.push_back(StackSymbol("dot"));
496  std::vector<StackSymbol> vSquareSquare;
497  vSquareSquare.push_back(StackSymbol("square"));
498  vSquareSquare.push_back(StackSymbol("square"));
499  std::vector<StackSymbol> vSquareFullsquare;
500  vSquareFullsquare.push_back(StackSymbol("square"));
501  vSquareFullsquare.push_back(StackSymbol("fullsquare"));
502  std::vector<StackSymbol> vDotSquare;
503  vDotSquare.push_back(StackSymbol("dot"));
504  vDotSquare.push_back(StackSymbol("square"));
505  std::vector<StackSymbol> vSquareDot;
506  vSquareDot.push_back(StackSymbol("square"));
507  vSquareDot.push_back(StackSymbol("dot"));
508 
509  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
510  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
511  g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
512  //g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
513  //g.SetTransition("s1d", "b", "s2",vDot,vDot);
514 
515  //g.SetTransition("s1", FAUDES_PD_LAMBDA, "3",vSquare,vLambda);
516  //g.SetTransition("3", FAUDES_PD_LAMBDA, "s1s",vFullsquare,vSquareFullsquare);
517  //g.SetTransition("s1s", "a", "s1",vDot,vSquareDot);
518  //g.SetTransition("4", FAUDES_PD_LAMBDA, "s1",vFullsquare,vSquareFullsquare);
519 
520 
521  g.SetInitState("s1");
522  g.SetMarkedState("s1s");
523  g.SetMarkedState("s1d");
524 
525 
526  return g;
527 }
528 
529 /* *****************
530  * TestGenerator11
531  * *****************/
533 
535 
536  g.InsState("s1");
537  g.InsState("s1s");
538  g.InsState("s1d");
539  g.InsState("s2");
540  g.InsState("s2d");
541  //g.InsState("s3");
542  g.InsState("s4");
543  g.InsState("s4s");
544  g.InsState("s4d");
546  g.InsStackSymbol("dot");
547  g.SetStackBottom("square");
548 
549  g.InsControllableEvent("a");
550  g.InsControllableEvent("b");
551  g.InsUncontrollableEvent("u");
553 
554  std::vector<StackSymbol> vLambda;
555  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
556  std::vector<StackSymbol> vSquare;
557  vSquare.push_back(StackSymbol("square"));
558  std::vector<StackSymbol> vDot;
559  vDot.push_back(StackSymbol("dot"));
560  std::vector<StackSymbol> vDotSquare;
561  vDotSquare.push_back(StackSymbol("dot"));
562  vDotSquare.push_back(StackSymbol("square"));
563  std::vector<StackSymbol> vSquareDot;
564  vSquareDot.push_back(StackSymbol("square"));
565  vSquareDot.push_back(StackSymbol("dot"));
566 
567  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
568  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
569  g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
570  g.SetTransition("s1d", "b", "s2",vDot,vDot);
571  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
572  //g.SetTransition("s2d", "b", "s3",vDot,vLambda);
573  g.SetTransition("s2d", "u", "s4",vDot,vDot);
574  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4d",vDot,vDot);
575 // g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4s",vSquare,vSquare);
576 // g.SetTransition("s4d", "u", "s4",vDot,vDot);
577 // g.SetTransition("s4s", "u", "s4",vSquare,vSquare);
578 
579 
580  g.SetInitState("s1");
581  g.SetMarkedState("s1s");
582  g.SetMarkedState("s1d");
583  g.SetMarkedState("s4s");
584  g.SetMarkedState("s4d");
585 
586  return g;
587 }
588 
589 /* *****************
590  * TestGenerator12
591  * *****************/
593 
595 
596  g.InsState("s1");
597  g.InsState("s2");
598  g.InsState("s3");
599  g.InsState("s4");
600 
602  g.InsStackSymbol("dot");
603  g.SetStackBottom("square");
604 
605  g.InsControllableEvent("a");
607 
608  std::vector<StackSymbol> vLambda;
609  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
610  std::vector<StackSymbol> vSquare;
611  vSquare.push_back(StackSymbol("square"));
612  std::vector<StackSymbol> vDot;
613  vDot.push_back(StackSymbol("dot"));
614  std::vector<StackSymbol> vDotSquare;
615  vDotSquare.push_back(StackSymbol("dot"));
616  vDotSquare.push_back(StackSymbol("square"));
617  std::vector<StackSymbol> vSquareDot;
618  vSquareDot.push_back(StackSymbol("square"));
619  vSquareDot.push_back(StackSymbol("dot"));
620 
621  g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
622  g.SetTransition("s1", "a", "s2",vDot,vDot);
623  g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
624 
625  g.SetInitState("s1");
626  g.SetMarkedState("s2");
627 
628  return g;
629 }
630 
631 /* *****************
632  * TestGenerator13
633  * *****************/
635 
637 
638  g.InsState("s1");
639  g.InsState("s2");
640  g.InsState("s3");
641  g.InsState("s4");
642 
644  g.InsStackSymbol("dot");
645  g.SetStackBottom("square");
646 
647  g.InsControllableEvent("a");
648  g.InsControllableEvent("b");
649  g.InsControllableEvent("c");
651 
652  std::vector<StackSymbol> vLambda;
653  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
654  std::vector<StackSymbol> vSquare;
655  vSquare.push_back(StackSymbol("square"));
656  std::vector<StackSymbol> vDot;
657  vDot.push_back(StackSymbol("dot"));
658  std::vector<StackSymbol> vDotSquare;
659  vDotSquare.push_back(StackSymbol("dot"));
660  vDotSquare.push_back(StackSymbol("square"));
661  std::vector<StackSymbol> vSquareDot;
662  vSquareDot.push_back(StackSymbol("square"));
663  vSquareDot.push_back(StackSymbol("dot"));
664 
665  g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
666  g.SetTransition("s1", "a", "s2",vDot,vDot);
667  g.SetTransition("s2", "b", "s2",vDot,vLambda);
668  g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
669  g.SetTransition("s2", "c", "s4",vLambda,vLambda);
670 
671  g.SetInitState("s1");
672  g.SetMarkedState("s2");
673 
674  return g;
675 }
676 
677 /* *****************
678  * TestGenerator14
679  * *****************/
681 
683 
684  Idx s1 = g.InsState("s1");
685  Idx s1s = g.InsState("s1s");
686  Idx s1d = g.InsState("s1d");
687  Idx s2 = g.InsState("s2");
688  Idx s2s = g.InsState("s2s");
689  Idx s2d = g.InsState("s2d");
690 
692  Idx dot = g.InsStackSymbol("dot");
693  Idx square = g.SetStackBottom("square");
694 
695  g.InsControllableEvent("a");
697 
698  std::vector<StackSymbol> vLambda;
699  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
700  std::vector<StackSymbol> vSquare;
701  vSquare.push_back(StackSymbol("square"));
702  std::vector<StackSymbol> vDot;
703  vDot.push_back(StackSymbol("dot"));
704  std::vector<StackSymbol> vDotSquare;
705  vDotSquare.push_back(StackSymbol("dot"));
706  vDotSquare.push_back(StackSymbol("square"));
707 
708  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
709  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
710  g.SetTransition("s1s", "a", "s2",vSquare,vDotSquare);
711  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2s",vSquare,vSquare);
712  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
713 
714  MergeStateSplit mss1(s1);
715  g.SetMerge(s1,mss1);
716  MergeStateSplit mss1s(s1s,square);
717  g.SetMerge(s1s,mss1s);
718  MergeStateSplit mss1d(s1d,dot);
719  g.SetMerge(s1d,mss1d);
720  MergeStateSplit mss2(s2);
721  g.SetMerge(s2,mss2);
722  MergeStateSplit mss2s(s2s,square);
723  g.SetMerge(s2s,mss2s);
724  MergeStateSplit mss2d(s2d,dot);
725  g.SetMerge(s2d,mss2d);
726 
727 
728  g.SetInitState("s1");
729  g.SetMarkedState("s1d");
730  g.SetMarkedState("s2d");
731 
732  return g;
733 }
734 
735 /* *****************
736  * TestGenerator15
737  * *****************/
739 
741 
742  g.InsState("s1");
743  g.InsState("s2");
744  g.InsState("s3");
745 
746 
748  g.InsStackSymbol("dot");
749  g.SetStackBottom("square");
750 
751  g.InsControllableEvent("a");
752  g.InsControllableEvent("b");
754 
755  std::vector<StackSymbol> vLambda;
756  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
757  std::vector<StackSymbol> vSquare;
758  vSquare.push_back(StackSymbol("square"));
759  std::vector<StackSymbol> vDot;
760  vDot.push_back(StackSymbol("dot"));
761  std::vector<StackSymbol> vDotSquare;
762  vDotSquare.push_back(StackSymbol("dot"));
763  vDotSquare.push_back(StackSymbol("square"));
764 
765  g.SetTransition("s1", "a", "s1",vDot,vDot);
766  g.SetTransition("s2", "b", "s3",vSquare,vDotSquare);
767 
768  g.SetInitState("s1");
769  g.SetMarkedState("s3");
770 
771  return g;
772 }
773 
774 /* *****************
775  * TestGenerator16
776  * *****************/
778 
780 
781  g.InsState("s1");
782  g.InsState("s2");
783  g.InsState("s3");
784 
785 
787  g.InsStackSymbol("dot");
788  g.SetStackBottom("square");
789 
790  g.InsControllableEvent("a");
791  g.InsControllableEvent("b");
793 
794  std::vector<StackSymbol> vLambda;
795  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
796  std::vector<StackSymbol> vSquare;
797  vSquare.push_back(StackSymbol("square"));
798  std::vector<StackSymbol> vDot;
799  vDot.push_back(StackSymbol("dot"));
800  std::vector<StackSymbol> vDotSquare;
801  vDotSquare.push_back(StackSymbol("dot"));
802  vDotSquare.push_back(StackSymbol("square"));
803 
804  g.SetTransition("s1", "a", "s1",vDot,vDot);
805  g.SetTransition("s2", "b", "s3",vSquare,vDotSquare);
806  g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
807  g.SetTransition("s1", "b", "s2",vSquare,vSquare);
808 
809  g.SetInitState("s1");
810  g.SetMarkedState("s3");
811 
812  return g;
813 }
814 
815 /* *****************
816  * TestGenerator17
817  * *****************/
819 
821 
822  g.InsState("s1");
823  g.InsState("s2");
824  g.InsState("s3");
825  g.InsState("s4");
826  g.InsState("s5");
827 
828 
830  g.InsStackSymbol("dot");
831  g.SetStackBottom("square");
832 
833  g.InsControllableEvent("a");
834  g.InsControllableEvent("b");
836 
837  std::vector<StackSymbol> vLambda;
838  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
839  std::vector<StackSymbol> vSquare;
840  vSquare.push_back(StackSymbol("square"));
841  std::vector<StackSymbol> vDot;
842  vDot.push_back(StackSymbol("dot"));
843  std::vector<StackSymbol> vDotSquare;
844 
845  g.SetTransition("s1", "a", "s1",vDot,vDot);
846  g.SetTransition("s1", "b", "s2",vSquare,vSquare);
847  g.SetTransition("s2", "b", "s3",vDot,vDot);
848  g.SetTransition("s2", "a", "s4",vSquare,vSquare);
849 
850  g.SetInitState("s1");
851  g.SetMarkedState("s3");
852  g.SetMarkedState("s4");
853 
854  return g;
855 }
856 
857 /* *****************
858  * TestGenerator18
859  * *****************/
861 
863 
864  g.InsState("s1");
865  g.InsState("s2");
866  g.InsState("s3");
867 
868 
870  g.InsStackSymbol("dot");
871  g.SetStackBottom("square");
872 
873  g.InsControllableEvent("a");
874  g.InsEvent("b");
876 
877  std::vector<StackSymbol> vLambda;
878  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
879  std::vector<StackSymbol> vSquare;
880  vSquare.push_back(StackSymbol("square"));
881  std::vector<StackSymbol> vDot;
882  vDot.push_back(StackSymbol("dot"));
883  std::vector<StackSymbol> vDotSquare;
884  vDotSquare.push_back(StackSymbol("dot"));
885  vDotSquare.push_back(StackSymbol("square"));
886 
887  g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);
888  g.SetTransition("s2", "b", "s3",vDot,vDot);
889 
890  g.SetInitState("s1");
891  g.SetMarkedState("s3");
892 
893  return g;
894 }
895 
896 /* *****************
897  * TestGenerator19
898  * *****************/
900 
902 
903  g.InsState("s1");
904  g.InsState("s2");
905  g.InsState("s3");
906 
907 
909  g.InsStackSymbol("dot");
910  g.SetStackBottom("square");
911 
912  g.InsControllableEvent("a");
913  g.InsEvent("b");
915 
916  std::vector<StackSymbol> vLambda;
917  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
918  std::vector<StackSymbol> vSquare;
919  vSquare.push_back(StackSymbol("square"));
920  std::vector<StackSymbol> vDot;
921  vDot.push_back(StackSymbol("dot"));
922  std::vector<StackSymbol> vDotSquare;
923  vDotSquare.push_back(StackSymbol("dot"));
924  vDotSquare.push_back(StackSymbol("square"));
925 
926  g.SetTransition("s1", "a", "s2",vSquare,vDotSquare);
927  g.SetTransition("s2", "b", "s3",vDot,vDot);
928 
929  g.SetInitState("s1");
930  g.SetMarkedState("s1");
931  g.SetMarkedState("s2");
932  g.SetMarkedState("s3");
933 
934  return g;
935 }
936 
937 /* *****************
938  * TestGenerator20
939  * *****************/
941 
943 
944  g.InsState("s1");
945  g.InsState("s2");
946  g.InsState("s3");
947  g.InsState("s4");
948 
949 
951  g.InsStackSymbol("dot");
952  g.SetStackBottom("square");
953 
954  g.InsControllableEvent("a");
955  g.InsControllableEvent("b");
956  g.InsEvent("u");
958 
959  std::vector<StackSymbol> vLambda;
960  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
961  std::vector<StackSymbol> vSquare;
962  vSquare.push_back(StackSymbol("square"));
963  std::vector<StackSymbol> vDot;
964  vDot.push_back(StackSymbol("dot"));
965  std::vector<StackSymbol> vDotSquare;
966  vDotSquare.push_back(StackSymbol("dot"));
967  vDotSquare.push_back(StackSymbol("square"));
968 
969  g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
970  g.SetTransition("s1", "b", "s2",vDot,vDot);
971  g.SetTransition("s2", "b", "s3",vDot,vLambda);
972  g.SetTransition("s2", "u", "s4",vDot,vDot);
973  g.SetTransition("s4", "u", "s4",vDot,vDot);
974 
975  g.SetInitState("s1");
976  g.SetMarkedState("s3");
977  g.SetMarkedState("s4");
978 
979  return g;
980 }
981 
982 /* *****************
983  * TestGenerator21
984  * *****************/
986 
988 
989  g.InsState("s1");
990  g.InsState("s2");
991  g.InsState("s3");
992  g.InsState("s4");
993 
994 
996  g.InsStackSymbol("dot");
997  g.SetStackBottom("square");
998 
999  g.InsControllableEvent("a");
1000  g.InsControllableEvent("b");
1002 
1003  std::vector<StackSymbol> vLambda;
1004  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
1005  std::vector<StackSymbol> vSquare;
1006  vSquare.push_back(StackSymbol("square"));
1007  std::vector<StackSymbol> vDot;
1008  vDot.push_back(StackSymbol("dot"));
1009  std::vector<StackSymbol> vDotDot;
1010  vDotDot.push_back(StackSymbol("dot"));
1011  vDotDot.push_back(StackSymbol("dot"));
1012  std::vector<StackSymbol> vDotSquare;
1013  vDotSquare.push_back(StackSymbol("dot"));
1014  vDotSquare.push_back(StackSymbol("square"));
1015 
1016  g.SetTransition("s1", "a", "s2",vSquare,vDotSquare);
1017  g.SetTransition("s1", "a", "s2",vDot,vDotDot);
1018  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s4",vSquare,vSquare);
1019  g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
1020  g.SetTransition("s2", "a", "s3",vDot,vDotDot);
1021  g.SetTransition("s2", "b", "s3",vLambda,vDot);
1022  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s3",vSquare,vDotSquare);
1023 
1024  g.SetInitState("s1");
1025  g.SetMarkedState("s3");
1026 
1027  return g;
1028 }
1029 
1030 /* *****************
1031  * TestGenerator22
1032  * *****************/
1034 
1036 
1037  g.InsState("s1");
1038  g.InsState("s2");
1039 
1040 
1042  g.SetStackBottom("square");
1043 
1044  g.InsControllableEvent("a");
1046 
1047  std::vector<StackSymbol> vLambda;
1048  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
1049  std::vector<StackSymbol> vSquare;
1050  vSquare.push_back(StackSymbol("square"));
1051  std::vector<StackSymbol> vDot;
1052  vDot.push_back(StackSymbol("dot"));
1053  std::vector<StackSymbol> vDotDot;
1054  vDotDot.push_back(StackSymbol("dot"));
1055  vDotDot.push_back(StackSymbol("dot"));
1056  std::vector<StackSymbol> vDotSquare;
1057  vDotSquare.push_back(StackSymbol("dot"));
1058  vDotSquare.push_back(StackSymbol("square"));
1059 
1060  g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vSquare,vSquare);
1061 
1062  g.SetInitState("s1");
1063  g.SetMarkedState("s2");
1064 
1065  return g;
1066 }
1067 
1068 /* *****************
1069  * TestGenerator23
1070  * *****************/
1072 
1074 
1075  g.InsState("s1");
1076  g.InsState("s2");
1077  g.InsState("s3");
1078 
1079  Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
1080  Idx dot = g.InsStackSymbol("dot");
1081  Idx heart= g.InsStackSymbol("heart");
1082  Idx diamond = g.InsStackSymbol("diamond");
1083  Idx square = g.SetStackBottom("square");
1084 
1085  g.InsControllableEvent("a");
1086  g.InsControllableEvent("b");
1088 
1089  std::vector<Idx> vLambda;
1090  vLambda.push_back(lambda);
1091  std::vector<Idx> vSquare;
1092  vSquare.push_back(square);
1093  std::vector<Idx> vDot;
1094  vDot.push_back(dot);
1095  std::vector<Idx> vDotDot;
1096  vDotDot.push_back(dot);
1097  vDotDot.push_back(dot);
1098  std::vector<Idx> vDiamond;
1099  vDiamond.push_back(diamond);
1100  std::vector<Idx> vHeart;
1101  vHeart.push_back(heart);
1102 
1103  g.SetTransition("s1", "b", "s1",vSquare,vSquare);
1104  g.SetTransition("s1", "a", "s2",vDot,vDotDot);
1105  g.SetTransition("s1", "b", "s2",vLambda,vLambda);
1106  g.SetTransition("s2", "a", "s2",vHeart,vHeart);
1107  g.SetTransition("s3", "a", "s1",vDiamond,vDiamond);
1108  g.SetTransition("s3", "a", "s3",vDiamond,vLambda);
1109 
1110  g.SetInitState("s1");
1111  g.SetMarkedState("s2");
1112 
1113  return g;
1114 }
1115 
1116 /* *****************
1117  * TestGenerator24
1118  * *****************/
1120 
1122 
1123  g.InsState("s0");
1124  g.InsState("s1");
1125  g.InsState("s2");
1126  g.InsState("s3");
1127  g.InsState("s4");
1128  g.InsState("s5");
1129  g.InsState("s6");
1130  g.InsState("s7");
1131  g.InsState("s8");
1132 
1133 
1135  g.SetStackBottom("square");
1136  g.InsStackSymbol("dot");
1137 
1138  g.InsControllableEvent("a");
1139  g.InsControllableEvent("b");
1140  g.InsUncontrollableEvent("u");
1141  g.InsUncontrollableEvent("v");
1143 
1144  std::vector<StackSymbol> vLambda;
1145  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
1146  std::vector<StackSymbol> vSquare;
1147  vSquare.push_back(StackSymbol("square"));
1148  std::vector<StackSymbol> vDot;
1149  vDot.push_back(StackSymbol("dot"));
1150  std::vector<StackSymbol> vDotDot;
1151  vDotDot.push_back(StackSymbol("dot"));
1152  vDotDot.push_back(StackSymbol("dot"));
1153  std::vector<StackSymbol> vDotSquare;
1154  vDotSquare.push_back(StackSymbol("dot"));
1155  vDotSquare.push_back(StackSymbol("square"));
1156  Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
1157 
1158  g.SetTransition("s0", "a", "s0",vSquare,vDotSquare);
1159  g.SetTransition("s0", "a", "s0",vDot,vDotDot);
1160  g.SetTransition("s0", "b", "s1",vDot,vDot);
1161  g.SetTransition("s0", "b", "s8",vSquare,vSquare);
1162  g.SetTransition("s1", "b", "s2",vDot,vLambda);
1163  g.SetTransition("s1", "u", "s7",vDot,vDot);
1164  g.SetTransition("s1", "v", "s7",vDot,vDot);
1165  g.SetTransition("s2", "b", "s1",vDot,vLambda);
1166  g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vSquare,vDot);
1167  g.SetTransition("s3", "b", "s3",vDot,vDotDot);
1168  g.SetTransition("s3", "u", "s4",vDot,vDotDot);
1169  g.SetTransition("s3", "v", "s5",vDot,vLambda);
1170  g.SetTransition("s3", "v", "s5",vSquare,vSquare);
1171  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s6",vDot,vLambda);
1172  g.SetTransition("s5", FAUDES_PD_LAMBDA, "s5",vDot,vLambda);
1173  g.SetTransition("s5", "u", "s7",vSquare,vSquare);
1174  g.SetTransition("s6", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
1175  g.SetTransition("s6", "u", "s7",vSquare,vSquare);
1176  g.SetTransition("s6", "v", "s7",vSquare,vSquare);
1177  g.SetTransition("s7", "u", "s7",vDot,vDot);
1178  g.SetTransition("s7", "v", "s7",vDot,vDot);
1179  g.SetTransition("s7", "u", "s7",vSquare,vSquare);
1180  g.SetTransition("s7", "v", "s7",vSquare,vSquare);
1181 
1182 
1183  g.SetInitState("s0");
1184  g.SetMarkedState("s2");
1185  g.SetMarkedState("s5");
1186  g.SetMarkedState("s6");
1187  g.SetMarkedState("s7");
1188  g.SetMarkedState("s8");
1189 
1190  return g;
1191 }
1192 
1193 /* *****************
1194  * TestGenerator25
1195  * *****************/
1197 
1199 
1200  g.InsState("s1");
1201  g.InsState("s2");
1202  g.InsState("s3");
1203  g.InsState("s4");
1204  g.InsState("s5");
1205 
1207  g.SetStackBottom("square");
1208  g.InsStackSymbol("dot");
1209 
1210  g.InsControllableEvent("a");
1211  g.InsControllableEvent("b");
1212  g.InsUncontrollableEvent("u");
1213  g.InsUncontrollableEvent("v");
1215 
1216  std::vector<StackSymbol> vLambda;
1217  vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
1218  std::vector<StackSymbol> vSquare;
1219  vSquare.push_back(StackSymbol("square"));
1220  std::vector<StackSymbol> vDot;
1221  vDot.push_back(StackSymbol("dot"));
1222  std::vector<StackSymbol> vDotDot;
1223  vDotDot.push_back(StackSymbol("dot"));
1224  vDotDot.push_back(StackSymbol("dot"));
1225  std::vector<StackSymbol> vDotSquare;
1226  vDotSquare.push_back(StackSymbol("dot"));
1227  vDotSquare.push_back(StackSymbol("square"));
1228  Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
1229 
1230  g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
1231  g.SetTransition("s1", "a", "s1",vDot,vDotDot);
1232  g.SetTransition("s1", "b", "s2",vDot,vLambda);
1233  g.SetTransition("s2", "b", "s2",vDot,vLambda);
1234  g.SetTransition("s2", "u", "s3",vDot,vDot);
1235  g.SetTransition("s2", "v", "s4",vDot,vLambda);
1236  g.SetTransition("s2", "v", "s4",vSquare,vSquare);
1237  g.SetTransition("s3", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
1238  g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
1239  g.SetTransition("s4", "u", "s5",vSquare,vSquare);
1240  g.SetTransition("s5", "u", "s5",vSquare,vSquare);
1241 
1242  g.SetInitState("s1");
1243  g.SetMarkedState("s5");
1244 
1245  return g;
1246 }
1247 
1248 /* *****************
1249  * TestSystem1
1250  * *****************/
1252 
1253  System s;
1254 
1255  s.InsState("s1");
1256  s.InsState("s2");
1257  s.InsState("s3");
1258 
1259  s.InsControllableEvent("a");
1260  s.InsEvent("b");
1261  s.InsControllableEvent("c");
1262 
1263  s.SetTransition("s1", "a", "s2");
1264  s.SetTransition("s1", "b", "s3");
1265  s.SetTransition("s1", "c", "s3");
1266  s.SetTransition("s2", "b", "s1");
1267  s.SetTransition("s3", "a", "s2");
1268 
1269  s.SetInitState("s1");
1270  s.SetMarkedState("s3");
1271 
1272  return s;
1273 }
1274 
1275 /* *****************
1276  * TestSystem2
1277  * *****************/
1279 
1280  System s;
1281 
1282  s.InsState("s1");
1283  s.InsState("s2");
1284 
1285  s.InsControllableEvent("a");
1286  s.InsEvent("b");
1287 
1288  s.SetTransition("s1", "a", "s2");
1289  s.SetTransition("s1", "b", "s1");
1290  s.SetTransition("s2", "a", "s2");
1291  s.SetTransition("s2", "b", "s1");
1292 
1293  s.SetInitState("s1");
1294  s.SetMarkedState("s2");
1295 
1296  return s;
1297 }
1298 
1299 /* *****************
1300  * TestSystem3
1301  * *****************/
1303 
1304  System s;
1305 
1306  s.InsState("s1");
1307 
1308  s.InsControllableEvent("a");
1309  s.InsEvent("b");
1310 
1311  s.SetTransition("s1", "a", "s1");
1312  s.SetTransition("s1", "b", "s1");
1313 
1314  s.SetInitState("s1");
1315  s.SetMarkedState("s1");
1316 
1317  return s;
1318 }
1319 
1320 /* *****************
1321  * TestSystem4
1322  * *****************/
1324 
1325  System s;
1326 
1327  s.InsState("s1");
1328  s.InsState("s2");
1329  s.InsState("s3");
1330 
1331  s.InsControllableEvent("a");
1332  s.InsEvent("b");
1333 
1334  s.SetTransition("s1", "a", "s1");
1335  s.SetTransition("s1", "a", "s2");
1336  s.SetTransition("s2", "b", "s3");
1337 
1338  s.SetInitState("s1");
1339  s.SetMarkedState("s3");
1340 
1341  return s;
1342 }
1343 
1344 /* *****************
1345  * TestSystem5
1346  * *****************/
1348 
1349  System s;
1350 
1351  s.InsState("s1");
1352  s.InsState("s2");
1353  s.InsState("s3");
1354 
1355  s.InsControllableEvent("a");
1356  s.InsControllableEvent("b");
1357  s.InsEvent("u");
1358  //s.InsEvent("v");
1359 
1360  s.SetTransition("s1", "a", "s1");
1361  s.SetTransition("s1", "b", "s2");
1362  s.SetTransition("s2", "b", "s2");
1363  s.SetTransition("s2", "u", "s3");
1364  //s.SetTransition("s2", "v", "s3");
1365  s.SetTransition("s3", "u", "s3");
1366  //s.SetTransition("s3", "v", "s3");
1367 
1368  s.SetInitState("s1");
1369  s.SetMarkedState("s2");
1370  s.SetMarkedState("s3");
1371 
1372  return s;
1373 }
1374 
1375 /* *****************
1376  * TestGrammar1
1377  * *****************/
1379 
1381 
1382  StackSymbolSet stackSymbols = g1.StackSymbols();
1383 
1384  std::vector<Idx> ssvDot;
1385  ssvDot.push_back(stackSymbols.Index("dot"));
1386  std::vector<Idx> ssvSquare;
1387  ssvSquare.push_back(stackSymbols.Index("square"));
1388 
1389  //construct Terminals
1390  Terminal* t1 = new Terminal(g1.Alphabet().Index("a"));
1391  GrammarSymbolPtr t1Ptr(t1);
1392  Terminal* t2 = new Terminal(g1.Alphabet().Index("b"));
1393  GrammarSymbolPtr t2Ptr(t2);
1394 
1395  //construct NonterminalEnd
1396 
1397  Nonterminal* nte1 = new Nonterminal(g1.StateIndex("s3"),ssvDot);
1398  GrammarSymbolPtr nte1Ptr(nte1);
1399  Nonterminal* nte2 = new Nonterminal(g1.StateIndex("s4"),ssvSquare);
1400  GrammarSymbolPtr nte2Ptr(nte2);
1401 
1402  //construct NonterminalMid
1403  Nonterminal* ntm3 = new Nonterminal(g1.StateIndex("s1"),ssvDot,g1.StateIndex("s2"));
1404  GrammarSymbolPtr ntm3Ptr(ntm3);
1405  Nonterminal* ntm4 = new Nonterminal(g1.StateIndex("s2"),ssvSquare,g1.StateIndex("s3"));
1406  GrammarSymbolPtr ntm4Ptr(ntm4);
1407  Nonterminal* ntm5 = new Nonterminal(g1.StateIndex("s5"),ssvSquare,g1.StateIndex("s1"));
1408  GrammarSymbolPtr ntm5Ptr(ntm5);
1409 
1410  //construct GrammarProduction
1412  v1.push_back(nte2Ptr);
1413  v1.push_back(t2Ptr);
1414  GrammarProduction gp1 = GrammarProduction(*nte1,v1);
1416  v2.push_back(t1Ptr);
1417  v2.push_back(ntm3Ptr);
1418  v2.push_back(t2Ptr);
1419  GrammarProduction gp2 = GrammarProduction(*nte2,v2);
1421  v3.push_back(ntm4Ptr);
1422  GrammarProduction gp3 = GrammarProduction(*ntm3,v3);
1424  v4.push_back(ntm5Ptr);
1425  GrammarProduction gp4 = GrammarProduction(*ntm3,v4);
1427  v5.push_back(t2Ptr);
1428  GrammarProduction gp5 = GrammarProduction(*ntm5,v5);
1429 
1430  //construct Grammar
1431  Grammar gr = Grammar(*nte1);
1432  gr.InsTerminal(*t1);
1433  gr.InsTerminal(*t2);
1434 
1435  gr.InsNonterminal(*nte1);
1436  gr.InsNonterminal(*nte2);
1437  gr.InsNonterminal(*ntm3);
1438  gr.InsNonterminal(*ntm4);
1439  gr.InsNonterminal(*ntm5);
1440 
1441  gr.InsGrammarProduction(gp1);
1442  gr.InsGrammarProduction(gp2);
1443  gr.InsGrammarProduction(gp3);
1444  gr.InsGrammarProduction(gp4);
1445  gr.InsGrammarProduction(gp5);
1446 
1447  return gr;
1448 }
1449 
1450 /* *****************
1451  * TestGrammar2
1452  * *****************/
1454 
1456 
1457  StackSymbolSet stackSymbols = g1.StackSymbols();
1458 
1459  std::vector<Idx> ssvDot;
1460  ssvDot.push_back(stackSymbols.Index("dot"));
1461  std::vector<Idx> ssvSquare;
1462  ssvSquare.push_back(stackSymbols.Index("square"));
1463 
1464  //construct Terminals
1465  Terminal* t1 = new Terminal(g1.Alphabet().Index("a"));
1466  GrammarSymbolPtr t1Ptr(t1);
1467  Terminal* t2 = new Terminal(g1.Alphabet().Index("b"));
1468  GrammarSymbolPtr t2Ptr(t2);
1469 
1470  //construct NonterminalEnd
1471  Nonterminal* nte1 = new Nonterminal(g1.StateIndex("s3"),ssvDot);
1472  GrammarSymbolPtr nte1Ptr(nte1);
1473  Nonterminal* nte2 = new Nonterminal(g1.StateIndex("s4"),ssvSquare);
1474  GrammarSymbolPtr nte2Ptr(nte2);
1475 
1476  //construct NonterminalMid
1477  Nonterminal* ntm3 = new Nonterminal(g1.StateIndex("s1"),ssvDot,g1.StateIndex("s2"));
1478  GrammarSymbolPtr ntm3Ptr(ntm3);
1479  Nonterminal* ntm4 = new Nonterminal(g1.StateIndex("s2"),ssvSquare,g1.StateIndex("s3"));
1480  GrammarSymbolPtr ntm4Ptr(ntm4);
1481  Nonterminal* ntm5 = new Nonterminal(g1.StateIndex("s5"),ssvSquare,g1.StateIndex("s1"));
1482  GrammarSymbolPtr ntm5Ptr(ntm5);
1483 
1484  //construct GrammarProduction
1486  v2.push_back(t1Ptr);
1487  v2.push_back(ntm3Ptr);
1488  v2.push_back(t2Ptr);
1489  GrammarProduction gp2 = GrammarProduction(*nte2,v2);
1491  v3.push_back(ntm4Ptr);
1492  GrammarProduction gp3 = GrammarProduction(*ntm3,v3);
1494  v4.push_back(ntm5Ptr);
1495  GrammarProduction gp4 = GrammarProduction(*ntm3,v4);
1497  v5.push_back(t2Ptr);
1498  GrammarProduction gp5 = GrammarProduction(*ntm5,v5);
1499 
1500  //construct Grammar
1501  Grammar gr = Grammar(*nte2);
1502  gr.InsTerminal(*t1);
1503  gr.InsTerminal(*t2);
1504 
1505  gr.InsNonterminal(*nte1);
1506  gr.InsNonterminal(*nte2);
1507  gr.InsNonterminal(*ntm3);
1508  gr.InsNonterminal(*ntm4);
1509  gr.InsNonterminal(*ntm5);
1510 
1511  gr.InsGrammarProduction(gp2);
1512  gr.InsGrammarProduction(gp3);
1513  gr.InsGrammarProduction(gp4);
1514  gr.InsGrammarProduction(gp5);
1515 
1516  return gr;
1517 }
1518 
1519 /* *****************
1520  * TestGrammar3
1521  * *****************/
1523 
1525 
1526  StackSymbolSet stackSymbols = g1.StackSymbols();
1527 
1528  std::vector<Idx> ssvDot;
1529  ssvDot.push_back(stackSymbols.Index("dot"));
1530  std::vector<Idx> ssvSquare;
1531  ssvSquare.push_back(stackSymbols.Index("square"));
1532 
1533  //construct Terminals
1534  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1535  GrammarSymbolPtr taPtr(ta);
1536  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1537  GrammarSymbolPtr tbPtr(tb);
1538  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1539  GrammarSymbolPtr tlambdaPtr(tlambda);
1540 
1541  //construct NonterminalEnd
1542  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1543  GrammarSymbolPtr nt1dotPtr(nt1dot);
1544  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
1545  GrammarSymbolPtr nt1squarePtr(nt1square);
1546  Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
1547  GrammarSymbolPtr nt2squarePtr(nt2square);
1548 
1549  //construct NonterminalMid
1550  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
1551  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
1552  Nonterminal* nt2square2 = new Nonterminal(2,ssvSquare,2);
1553  GrammarSymbolPtr nt2square2Ptr(nt2square2);
1554 
1555  //construct GrammarProduction
1557  v.push_back(taPtr);
1558  v.push_back(nt1dotPtr);
1559  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1560  v.clear();
1561  v.push_back(tbPtr);
1562  v.push_back(nt2squarePtr);
1563  GrammarProduction gp2 = GrammarProduction(*nt1dot,v);
1564  v.clear();
1565  v.push_back(nt1dot1Ptr);
1566  v.push_back(nt2squarePtr);
1567  GrammarProduction gp3 = GrammarProduction(*nt2square,v);
1568  v.clear();
1569  v.push_back(tlambdaPtr);
1570  GrammarProduction gp4 = GrammarProduction(*nt2square,v);
1571  v.clear();
1572  v.push_back(nt1squarePtr);
1573  GrammarProduction gp5 = GrammarProduction(*nt1dot1,v);
1574  v.clear();
1575  v.push_back(nt1dotPtr);
1576  GrammarProduction gp6 = GrammarProduction(*nt1dot1,v);
1577  v.clear();
1578  v.push_back(taPtr);
1579  v.push_back(nt1dotPtr);
1580  GrammarProduction gp7 = GrammarProduction(*nt2square2,v);
1581 
1582  //construct Grammar
1583  Grammar gr = Grammar();
1584  gr.InsTerminal(*ta);
1585  gr.InsTerminal(*tb);
1586  gr.InsTerminal(*tlambda);
1587 
1588  gr.SetStartSymbol(*nt1dot);
1589  gr.InsNonterminal(*nt1square);
1590  gr.InsNonterminal(*nt2square);
1591  gr.InsNonterminal(*nt1dot1);
1592  gr.InsNonterminal(*nt2square2);
1593 
1594  gr.InsGrammarProduction(gp1);
1595  gr.InsGrammarProduction(gp2);
1596  gr.InsGrammarProduction(gp3);
1597  gr.InsGrammarProduction(gp4);
1598  gr.InsGrammarProduction(gp5);
1599  gr.InsGrammarProduction(gp6);
1600  gr.InsGrammarProduction(gp7);
1601 
1602  return gr;
1603 }
1604 
1605 /* *****************
1606  * TestGrammar4
1607  * *****************/
1609 
1611 
1612  StackSymbolSet stackSymbols = g1.StackSymbols();
1613 
1614  std::vector<Idx> ssvDot;
1615  ssvDot.push_back(stackSymbols.Index("dot"));
1616  std::vector<Idx> ssvSquare;
1617  ssvSquare.push_back(stackSymbols.Index("square"));
1618 
1619  //construct Terminals
1620  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1621  GrammarSymbolPtr taPtr(ta);
1622  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1623  GrammarSymbolPtr tlambdaPtr(tlambda);
1624 
1625  //construct NonterminalEnd
1626  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1627  GrammarSymbolPtr nt1dotPtr(nt1dot);
1628  Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
1629  GrammarSymbolPtr nt2squarePtr(nt2square);
1630 
1631  //construct NonterminalMid
1632  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
1633  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
1634 
1635  //construct GrammarProduction
1637  v.push_back(taPtr);
1638  v.push_back(nt1dotPtr);
1639  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1640  v.clear();
1641  v.push_back(nt1dot1Ptr);
1642  v.push_back(taPtr);
1643  v.push_back(nt2squarePtr);
1644  GrammarProduction gp2 = GrammarProduction(*nt2square,v);
1645  v.clear();
1646  v.push_back(tlambdaPtr);
1647  GrammarProduction gp3 = GrammarProduction(*nt2square,v);
1648 
1649  //construct Grammar
1650  Grammar gr = Grammar();
1651  gr.InsTerminal(*ta);
1652  gr.InsTerminal(*tlambda);
1653 
1654  gr.SetStartSymbol(*nt1dot);
1655  gr.InsNonterminal(*nt2square);
1656  gr.InsNonterminal(*nt1dot1);
1657 
1658  gr.InsGrammarProduction(gp1);
1659  gr.InsGrammarProduction(gp2);
1660  gr.InsGrammarProduction(gp3);
1661 
1662  return gr;
1663 }
1664 
1665 /* *****************
1666  * TestGrammar5
1667  * *****************/
1669 
1671 
1672  StackSymbolSet stackSymbols = g1.StackSymbols();
1673 
1674  std::vector<Idx> ssvDot;
1675  ssvDot.push_back(stackSymbols.Index("dot"));
1676  std::vector<Idx> ssvSquare;
1677  ssvSquare.push_back(stackSymbols.Index("square"));
1678 
1679  //construct Terminals
1680  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1681  GrammarSymbolPtr taPtr(ta);
1682  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1683  GrammarSymbolPtr tbPtr(tb);
1684  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1685  GrammarSymbolPtr tlambdaPtr(tlambda);
1686 
1687  //construct NonterminalEnd
1688  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1689  GrammarSymbolPtr nt1dotPtr(nt1dot);
1690  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
1691  GrammarSymbolPtr nt1squarePtr(nt1square);
1692  Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
1693  GrammarSymbolPtr nt2squarePtr(nt2square);
1694 
1695  //construct NonterminalMid
1696  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
1697  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
1698 
1699  //construct GrammarProduction
1701  v.push_back(nt1dot1Ptr);
1702  v.push_back(taPtr);
1703  v.push_back(nt1squarePtr);
1704  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1705  v.clear();
1706  v.push_back(tlambdaPtr);
1707  GrammarProduction gp2 = GrammarProduction(*nt1square,v);
1708  v.clear();
1709  v.push_back(tbPtr);
1710  GrammarProduction gp3 = GrammarProduction(*nt1square,v);
1711  v.clear();
1712  v.push_back(nt1dotPtr);
1713  GrammarProduction gp4 = GrammarProduction(*nt1dot1,v);
1714  v.clear();
1715  v.push_back(taPtr);
1716  v.push_back(nt1squarePtr);
1717  GrammarProduction gp5 = GrammarProduction(*nt1dot1,v);
1718  v.clear();
1719  v.push_back(nt1squarePtr);
1720  v.push_back(nt1dotPtr);
1721  GrammarProduction gp6 = GrammarProduction(*nt2square,v);
1722 
1723  //construct Grammar
1724  Grammar gr = Grammar();
1725  gr.InsTerminal(*ta);
1726  gr.InsTerminal(*tb);
1727  gr.InsTerminal(*tlambda);
1728 
1729  gr.SetStartSymbol(*nt1dot);
1730  gr.InsNonterminal(*nt1square);
1731  gr.InsNonterminal(*nt2square);
1732  gr.InsNonterminal(*nt1dot1);
1733 
1734  gr.InsGrammarProduction(gp1);
1735  gr.InsGrammarProduction(gp2);
1736  gr.InsGrammarProduction(gp3);
1737  gr.InsGrammarProduction(gp4);
1738  gr.InsGrammarProduction(gp5);
1739  gr.InsGrammarProduction(gp6);
1740 
1741  return gr;
1742 }
1743 
1744 /* *****************
1745  * TestGrammar6
1746  * *****************/
1748 
1750 
1751  StackSymbolSet stackSymbols = g1.StackSymbols();
1752 
1753  std::vector<Idx> ssvDot;
1754  ssvDot.push_back(stackSymbols.Index("dot"));
1755  std::vector<Idx> ssvSquare;
1756  ssvSquare.push_back(stackSymbols.Index("square"));
1757 
1758  //construct Terminals
1759  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1760  GrammarSymbolPtr taPtr(ta);
1761  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1762  GrammarSymbolPtr tbPtr(tb);
1763  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1764  GrammarSymbolPtr tlambdaPtr(tlambda);
1765 
1766  //construct Nonterminals
1767  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1768  GrammarSymbolPtr nt1dotPtr(nt1dot);
1769  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
1770  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
1771  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
1772  GrammarSymbolPtr nt1squarePtr(nt1square);
1773  Nonterminal* nt1square1 = new Nonterminal(1,ssvSquare,1);
1774  GrammarSymbolPtr nt1square1Ptr(nt1square1);
1775 
1776  //construct GrammarProduction
1778  v.push_back(nt1dot1Ptr);
1779  v.push_back(taPtr);
1780  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1781  v.clear();
1782  v.push_back(tlambdaPtr);
1783  GrammarProduction gp2 = GrammarProduction(*nt1dot1,v);
1784  v.clear();
1785  v.push_back(tbPtr);
1786  v.push_back(nt1squarePtr);
1787  GrammarProduction gp3 = GrammarProduction(*nt1square1,v);
1788 
1789  //construct Grammar
1790  Grammar gr = Grammar();
1791  gr.InsTerminal(*ta);
1792  gr.InsTerminal(*tb);
1793  gr.InsTerminal(*tlambda);
1794 
1795  gr.SetStartSymbol(*nt1dot);
1796  gr.InsNonterminal(*nt1square);
1797  gr.InsNonterminal(*nt1square1);
1798  gr.InsNonterminal(*nt1dot1);
1799 
1800  gr.InsGrammarProduction(gp1);
1801  gr.InsGrammarProduction(gp2);
1802  gr.InsGrammarProduction(gp3);
1803 
1804  return gr;
1805 }
1806 
1807 /* *****************
1808  * TestGrammar7
1809  * *****************/
1811 
1813 
1814  StackSymbolSet stackSymbols = g1.StackSymbols();
1815 
1816  std::vector<Idx> ssvDot;
1817  ssvDot.push_back(stackSymbols.Index("dot"));
1818  std::vector<Idx> ssvSquare;
1819  ssvSquare.push_back(stackSymbols.Index("square"));
1820 
1821  g1.InsEvent("$");
1822 
1823  //construct Terminals
1824  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1825  GrammarSymbolPtr taPtr(ta);
1826  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1827  GrammarSymbolPtr tbPtr(tb);
1828  Terminal* tdollar = new Terminal(g1.Alphabet().Index("$"));
1829  GrammarSymbolPtr tdollarPtr(tdollar);
1830  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1831  GrammarSymbolPtr tlambdaPtr(tlambda);
1832 
1833  //construct Nonterminals
1834  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1835  GrammarSymbolPtr nt1dotPtr(nt1dot);
1836  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
1837  GrammarSymbolPtr nt1squarePtr(nt1square);
1838 
1839  //construct GrammarProduction
1841  v.push_back(tdollarPtr);
1842  v.push_back(nt1squarePtr);
1843  v.push_back(tdollarPtr);
1844  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1845  v.clear();
1846  v.push_back(taPtr);
1847  v.push_back(nt1squarePtr);
1848  GrammarProduction gp2 = GrammarProduction(*nt1square,v);
1849  v.clear();
1850  v.push_back(tbPtr);
1851  GrammarProduction gp3 = GrammarProduction(*nt1square,v);
1852 
1853  //construct Grammar
1854  Grammar gr = Grammar();
1855  gr.InsTerminal(*ta);
1856  gr.InsTerminal(*tb);
1857  gr.InsTerminal(*tdollar);
1858  gr.InsTerminal(*tlambda);
1859 
1860  gr.SetStartSymbol(*nt1dot);
1861  gr.InsNonterminal(*nt1square);
1862 
1863  gr.InsGrammarProduction(gp1);
1864  gr.InsGrammarProduction(gp2);
1865  gr.InsGrammarProduction(gp3);
1866 
1867  return gr;
1868 }
1869 
1870 /* *****************
1871  * TestGrammar8
1872  * *****************/
1874 
1876 
1877  StackSymbolSet stackSymbols = g1.StackSymbols();
1878 
1879  std::vector<Idx> ssvDot;
1880  ssvDot.push_back(stackSymbols.Index("dot"));
1881  std::vector<Idx> ssvSquare;
1882  ssvSquare.push_back(stackSymbols.Index("square"));
1883 
1884  g1.InsEvent("$");
1885  g1.InsEvent("d");
1886  g1.InsEvent("e");
1887 
1888  //construct Terminals
1889  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1890  GrammarSymbolPtr taPtr(ta);
1891  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1892  GrammarSymbolPtr tbPtr(tb);
1893  Terminal* td = new Terminal(g1.Alphabet().Index("d"));
1894  GrammarSymbolPtr tdPtr(td);
1895  Terminal* te = new Terminal(g1.Alphabet().Index("e"));
1896  GrammarSymbolPtr tePtr(te);
1897  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1898  GrammarSymbolPtr tlambdaPtr(tlambda);
1899  Terminal* tdollar = new Terminal(g1.Alphabet().Index("$"));
1900  GrammarSymbolPtr tdollarPtr(tdollar);
1901 
1902  //construct Nonterminals
1903  Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
1904  GrammarSymbolPtr nt1dotPtr(nt1dot);
1905  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
1906  GrammarSymbolPtr nt1squarePtr(nt1square);
1907  Nonterminal* nt2dot = new Nonterminal(2,ssvDot);
1908  GrammarSymbolPtr nt2dotPtr(nt2dot);
1909  Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
1910  GrammarSymbolPtr nt2squarePtr(nt2square);
1911  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
1912  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
1913 
1914  //construct GrammarProduction
1916  v.push_back(tdollarPtr);
1917  v.push_back(nt1squarePtr);
1918  v.push_back(tdollarPtr);
1919  GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
1920 
1921  v.clear();
1922  v.push_back(nt1dot1Ptr);
1923  GrammarProduction gp2 = GrammarProduction(*nt1square,v);
1924 
1925  v.clear();
1926  v.push_back(nt2dotPtr);
1927  GrammarProduction gp3 = GrammarProduction(*nt1square,v);
1928 
1929  v.clear();
1930  v.push_back(tlambdaPtr);
1931  GrammarProduction gp4 = GrammarProduction(*nt1dot1,v);
1932 
1933  v.clear();
1934  v.push_back(taPtr);
1935  GrammarProduction gp5 = GrammarProduction(*nt2dot,v);
1936 
1937  v.clear();
1938  v.push_back(tbPtr);
1939  v.push_back(nt1squarePtr);
1940  v.push_back(nt2squarePtr);
1941  v.push_back(tePtr);
1942  GrammarProduction gp6 = GrammarProduction(*nt2dot,v);
1943 
1944  v.clear();
1945  v.push_back(tlambdaPtr);
1946  GrammarProduction gp7 = GrammarProduction(*nt2square,v);
1947 
1948  v.clear();
1949  v.push_back(tdPtr);
1950  v.push_back(nt1squarePtr);
1951  v.push_back(nt2squarePtr);
1952  GrammarProduction gp8 = GrammarProduction(*nt2square,v);
1953 
1954  //construct Grammar
1955  Grammar gr = Grammar();
1956  gr.InsTerminal(*ta);
1957  gr.InsTerminal(*tb);
1958  gr.InsTerminal(*td);
1959  gr.InsTerminal(*te);
1960  gr.InsTerminal(*tdollar);
1961  gr.InsTerminal(*tlambda);
1962 
1963  gr.SetStartSymbol(*nt1dot);
1964  gr.InsNonterminal(*nt1square);
1965  gr.InsNonterminal(*nt2dot);
1966  gr.InsNonterminal(*nt2square);
1967  gr.InsNonterminal(*nt1dot1);
1968 
1969  gr.InsGrammarProduction(gp1);
1970  gr.InsGrammarProduction(gp2);
1971  gr.InsGrammarProduction(gp3);
1972  gr.InsGrammarProduction(gp4);
1973  gr.InsGrammarProduction(gp5);
1974  gr.InsGrammarProduction(gp6);
1975  gr.InsGrammarProduction(gp7);
1976  gr.InsGrammarProduction(gp8);
1977 
1978  return gr;
1979 }
1980 
1981 /* *****************
1982  * TestGrammar9
1983  * *****************/
1985 
1987 
1988  StackSymbolSet stackSymbols = g1.StackSymbols();
1989 
1990  std::vector<Idx> ssvSquare;
1991  ssvSquare.push_back(stackSymbols.Index("square"));
1992 
1993  //construct Terminals
1994  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
1995  GrammarSymbolPtr taPtr(ta);
1996  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
1997  GrammarSymbolPtr tbPtr(tb);
1998  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
1999  GrammarSymbolPtr tlambdaPtr(tlambda);
2000 
2001  //construct Nonterminals
2002  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
2003  GrammarSymbolPtr nt1squarePtr(nt1square);
2004 
2005  //construct GrammarProduction
2007  v.push_back(taPtr);
2008  v.push_back(nt1squarePtr);
2009  GrammarProduction gp1 = GrammarProduction(*nt1square,v);
2010  v.clear();
2011  v.push_back(tbPtr);
2012  GrammarProduction gp2 = GrammarProduction(*nt1square,v);
2013 
2014  //construct Grammar
2015  Grammar gr = Grammar();
2016  gr.InsTerminal(*ta);
2017  gr.InsTerminal(*tb);
2018  gr.InsTerminal(*tlambda);
2019 
2020  gr.SetStartSymbol(*nt1square);
2021 
2022  gr.InsGrammarProduction(gp1);
2023  gr.InsGrammarProduction(gp2);
2024 
2025  return gr;
2026 }
2027 
2028 /* *****************
2029  * TestGrammar10
2030  * *****************/
2032 
2034  g1.InsEvent("dollar");
2035 
2036  StackSymbolSet stackSymbols = g1.StackSymbols();
2037 
2038  std::vector<Idx> ssvSquare;
2039  ssvSquare.push_back(stackSymbols.Index("square"));
2040  std::vector<Idx> ssvDot;
2041  ssvDot.push_back(stackSymbols.Index("dot"));
2042 
2043  //construct Terminals
2044  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
2045  GrammarSymbolPtr taPtr(ta);
2046  Terminal* tdollar = new Terminal(g1.Alphabet().Index("dollar"));
2047  GrammarSymbolPtr tdollarPtr(tdollar);
2048  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
2049  GrammarSymbolPtr tlambdaPtr(tlambda);
2050 
2051  //construct Nonterminals
2052  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
2053  GrammarSymbolPtr nt1squarePtr(nt1square);
2054  Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
2055  GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
2056 
2057  //construct GrammarProduction
2059  v.push_back(nt1dot1Ptr);
2060  v.push_back(taPtr);
2061  GrammarProduction gp1 = GrammarProduction(*nt1square,v);
2062  v.clear();
2063  v.push_back(tlambdaPtr);
2064  GrammarProduction gp2 = GrammarProduction(*nt1dot1,v);
2065 
2066  //construct Grammar
2067  Grammar gr = Grammar();
2068  gr.InsTerminal(*ta);
2069  gr.InsTerminal(*tlambda);
2070 
2071  gr.InsNonterminal(*nt1square);
2072  gr.InsNonterminal(*nt1dot1);
2073 
2074  gr.SetStartSymbol(*nt1square);
2075 
2076  gr.InsGrammarProduction(gp1);
2077  gr.InsGrammarProduction(gp2);
2078 
2079  return gr;
2080 }
2081 
2082 /* *****************
2083  * TestGrammar11
2084  * *****************/
2086 
2088 
2089  StackSymbolSet stackSymbols = g1.StackSymbols();
2090 
2091  std::vector<Idx> ssvSquare;
2092  ssvSquare.push_back(stackSymbols.Index("square"));
2093 
2094  //construct Terminals
2095  Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
2096  GrammarSymbolPtr taPtr(ta);
2097  Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
2098  GrammarSymbolPtr tbPtr(tb);
2099  Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
2100  GrammarSymbolPtr tlambdaPtr(tlambda);
2101 
2102  //construct Nonterminals
2103  Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
2104  GrammarSymbolPtr nt1squarePtr(nt1square);
2105 
2106  //construct GrammarProduction
2108  v.push_back(taPtr);
2109  v.push_back(nt1squarePtr);
2110  v.push_back(tbPtr);
2111  GrammarProduction gp1 = GrammarProduction(*nt1square,v);
2112  v.clear();
2113  v.push_back(tlambdaPtr);
2114  GrammarProduction gp2 = GrammarProduction(*nt1square,v);
2115 
2116  //construct Grammar
2117  Grammar gr = Grammar();
2118  gr.InsTerminal(*ta);
2119  gr.InsTerminal(*tb);
2120  gr.InsTerminal(*tlambda);
2121 
2122  gr.InsNonterminal(*nt1square);
2123 
2124  gr.SetStartSymbol(*nt1square);
2125 
2126  gr.InsGrammarProduction(gp1);
2127  gr.InsGrammarProduction(gp2);
2128 
2129  return gr;
2130 }
2131 
2132 
2133 
2134 
2135 void TestStart(std::string name){
2136  std::cout << "Testing " << name << " ..." << std::endl;
2137 }
2138 
2139 void TestEnd(std::string name){
2140  std::cout << "Finished " << name << std::endl;
2141 }
2142 
2143 } // namespace faudes
2144 

libFAUDES 2.26g --- 2015.08.17 --- c++ api documentaion by doxygen