pd_test_util.cpp

Go to the documentation of this file.
00001 /** @file pd_test_util.cpp  Creation of test classes */
00002 
00003 
00004 /* Pushdown plugin for FAU Discrete Event Systems Library (libfaudes)
00005 
00006    Copyright (C) 2013  Stefan Jacobi, Sven Schneider, Anne-Kathrin Hess
00007 
00008 */
00009 #include "pd_test_util.h"
00010 
00011 namespace faudes {
00012 
00013   
00014 /* *****************
00015  * TestGenerator1
00016  * *****************/
00017 PushdownGenerator TestGenerator1(){
00018   
00019   PushdownGenerator g;
00020   
00021   g.InsState("s1");
00022   g.InsState("s2");
00023   g.InsState("s3");
00024   g.InsState("s4");
00025   g.InsState("s5");
00026   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00027   g.InsStackSymbol("dot");
00028   g.SetStackBottom("square");
00029   
00030 
00031   g.InsEvent(FAUDES_PD_LAMBDA);
00032   g.InsControllableEvent("a");         
00033   g.InsControllableEvent("b");
00034   g.InsEvent("u");
00035   g.InsEvent("v");
00036   
00037   
00038   std::vector<StackSymbol> vLambda;
00039   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00040   std::vector<StackSymbol> vDot;
00041   vDot.push_back(StackSymbol("dot"));
00042   std::vector<StackSymbol> vSquare;
00043   vSquare.push_back(StackSymbol("square"));
00044   std::vector<StackSymbol> vSquareDot;
00045   vSquareDot.push_back(StackSymbol("square"));
00046   vSquareDot.push_back(StackSymbol("dot"));
00047   std::vector<StackSymbol> vDotDot;
00048   vDotDot.push_back(StackSymbol("dot"));
00049   vDotDot.push_back(StackSymbol("dot"));
00050   std::vector<StackSymbol> vDotSquare;
00051   vDotSquare.push_back(StackSymbol("dot"));
00052   vDotSquare.push_back(StackSymbol("square"));
00053   
00054   g.SetTransition("s1", "a", "s2",vLambda,vDotDot);
00055   g.SetTransition("s2", "a", "s3",vDotDot,vDot);  
00056   g.SetTransition("s3", "b", "s2",vDot,vDotDot);
00057   g.SetTransition("s1", "b", "s5",vLambda,vDotSquare);
00058   g.SetTransition("s5", "a", "s4",vSquare,vLambda);
00059   g.SetTransition("s4", "b", "s3",vLambda,vLambda);
00060   
00061   g.SetInitState("s1");              
00062   g.SetMarkedState("s3");
00063   g.SetMarkedState("s5");
00064   
00065   return g;
00066 }
00067 
00068 /* *****************
00069  * TestGenerator2
00070  * *****************/
00071 PushdownGenerator TestGenerator2(){
00072     
00073   PushdownGenerator g;
00074   
00075   g.InsState("s1");
00076   g.InsState("s2");
00077   g.InsState("s3");
00078   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00079   g.InsStackSymbol("dot");
00080   g.SetStackBottom("square");
00081 
00082   g.InsEvent(FAUDES_PD_LAMBDA);
00083   g.InsControllableEvent("a");         
00084   g.InsEvent("b");
00085   g.InsEvent("d");
00086   
00087   
00088   std::vector<StackSymbol> vLambda;
00089   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00090 
00091   std::vector<StackSymbol> vSquare;
00092   vSquare.push_back(StackSymbol("square"));
00093   std::vector<StackSymbol> vDotDot;
00094   vDotDot.push_back(StackSymbol("dot"));
00095   vDotDot.push_back(StackSymbol("dot"));
00096   std::vector<StackSymbol> vDotSquare;
00097   vDotSquare.push_back(StackSymbol("dot"));
00098   vDotSquare.push_back(StackSymbol("square"));
00099   
00100   g.SetTransition("s1", "a", "s2",vLambda,vDotDot);
00101   g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);  
00102   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDotDot,vSquare);
00103   g.SetTransition("s3", "b", "s1",vSquare,vSquare);
00104   
00105   g.SetInitState("s1");              
00106   g.SetMarkedState("s2");
00107   
00108   return g;
00109 }
00110 /* *****************
00111  * TestGenerator3
00112  * *****************/
00113 PushdownGenerator TestGenerator3(){
00114     
00115   PushdownGenerator g;
00116   
00117   g.InsState("s1");
00118   g.InsState("s2");
00119   g.InsState("s3");
00120   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00121   g.InsStackSymbol("dot");
00122   g.InsStackSymbol("square");
00123   g.SetStackBottom("square");
00124   
00125   g.InsControllableEvent("a");         
00126   g.InsEvent("b");
00127   
00128   std::vector<StackSymbol> vLambda;
00129   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00130 
00131   std::vector<StackSymbol> vSquare;
00132   vSquare.push_back(StackSymbol("square"));
00133   std::vector<StackSymbol> vDot;
00134   vDot.push_back(StackSymbol("dot"));
00135   std::vector<StackSymbol> vDotDot;
00136   vDotDot.push_back(StackSymbol("dot"));
00137   vDotDot.push_back(StackSymbol("dot"));
00138   std::vector<StackSymbol> vDotSquare;
00139   vDotSquare.push_back(StackSymbol("dot"));
00140   vDotSquare.push_back(StackSymbol("square"));
00141   
00142   g.SetTransition("s1", "a", "s2",vDot,vDotDot);
00143   g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);  
00144   g.SetTransition("s2", "a", "s3",vDot,vDot);
00145   g.SetTransition("s3", "b", "s1",vDot,vDot);
00146   
00147   g.SetInitState("s1");              
00148   g.SetMarkedState("s2");
00149   
00150   return g;
00151 }
00152 
00153 /* *****************
00154  * TestGenerator4
00155  * *****************/
00156 PushdownGenerator TestGenerator4(){
00157     
00158   PushdownGenerator g;
00159   
00160   g.InsState("s1");
00161   g.InsState("s2");
00162   g.InsState("s3");
00163   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00164   g.InsStackSymbol("dot");
00165   g.InsStackSymbol("square");
00166   g.SetStackBottom("square");
00167   
00168   g.InsControllableEvent("a");         
00169   g.InsEvent("b");
00170   
00171   std::vector<StackSymbol> vLambda;
00172   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00173   std::vector<StackSymbol> vSquare;
00174   vSquare.push_back(StackSymbol("square"));
00175   std::vector<StackSymbol> vDot;
00176   vDot.push_back(StackSymbol("dot"));
00177   std::vector<StackSymbol> vDotDot;
00178   vDotDot.push_back(StackSymbol("dot"));
00179   vDotDot.push_back(StackSymbol("dot"));
00180   std::vector<StackSymbol> vDotDotDot;
00181   vDotDotDot.push_back(StackSymbol("dot"));
00182   vDotDotDot.push_back(StackSymbol("dot"));
00183   vDotDotDot.push_back(StackSymbol("dot"));
00184   std::vector<StackSymbol> vDotSquare;
00185   vDotSquare.push_back(StackSymbol("dot"));
00186   vDotSquare.push_back(StackSymbol("square"));
00187   
00188   g.SetTransition("s1", "a", "s2",vDotDotDot,vDotDot);
00189   g.SetTransition("s1", "b", "s2",vDotSquare,vDotSquare);  
00190   g.SetTransition("s2", "a", "s3",vDotDot,vDot);
00191   g.SetTransition("s3", "b", "s1",vDot,vDot);
00192   
00193   g.SetInitState("s1");              
00194   g.SetMarkedState("s2");
00195   
00196   return g;
00197 }
00198 
00199 /* *****************
00200  * TestGenerator5
00201  * *****************/
00202 PushdownGenerator TestGenerator5(){
00203     
00204   PushdownGenerator g;
00205   
00206   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00207   Idx square = g.InsStackSymbol("square");
00208   g.SetStackBottom("square");
00209   
00210   Idx s;
00211   //insert heads and ears
00212   s = g.InsState("s1");
00213   MergeStateSplit mss(1);
00214   g.SetMerge(s,mss);
00215   g.SetDfaState(s,1);
00216   
00217   s = g.InsState("s11");
00218   mss = MergeStateSplit(1,square);
00219   g.SetMerge(s,mss);
00220   g.SetDfaState(s,1);
00221   
00222   s = g.InsState("s2");
00223   mss = MergeStateSplit(2);
00224   g.SetMerge(s,mss);
00225   g.SetDfaState(s,2);
00226   
00227   s = g.InsState("s21");
00228   mss = MergeStateSplit(2,square);
00229   g.SetMerge(s,mss);
00230   g.SetDfaState(s,2);
00231   
00232   s = g.InsState("s3");
00233   mss = MergeStateSplit(3);
00234   g.SetMerge(s,mss);
00235   g.SetDfaState(s,1);
00236   
00237   s = g.InsState("s31");
00238   mss = MergeStateSplit(3,square);
00239   g.SetMerge(s,mss);
00240   g.SetDfaState(s,1);
00241   
00242   s = g.InsState("s4");
00243   mss = MergeStateSplit(4);
00244   g.SetMerge(s,mss);
00245   g.SetDfaState(s,2);
00246   
00247   s = g.InsState("s41");
00248   mss = MergeStateSplit(4,square);
00249   g.SetMerge(s,mss);
00250   g.SetDfaState(s,2);
00251   
00252   g.InsControllableEvent("a");         
00253   g.InsEvent("b");
00254   g.InsEvent(FAUDES_PD_LAMBDA);
00255   
00256   std::vector<StackSymbol> vSquare;
00257   vSquare.push_back(StackSymbol("square"));
00258   
00259   //connect heads to ears
00260   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s11",vSquare,vSquare);
00261   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s21",vSquare,vSquare);
00262   g.SetTransition("s3", FAUDES_PD_LAMBDA, "s31",vSquare,vSquare);
00263   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s41",vSquare,vSquare);
00264   //connect ears to head
00265   g.SetTransition("s11", "a", "s4",vSquare,vSquare);
00266   g.SetTransition("s11", "b", "s3",vSquare,vSquare);
00267   g.SetTransition("s21", "a", "s4",vSquare,vSquare);
00268   g.SetTransition("s21", "b", "s3",vSquare,vSquare);
00269   g.SetTransition("s31", "a", "s2",vSquare,vSquare);
00270   g.SetTransition("s41", "a", "s2",vSquare,vSquare);
00271   
00272   g.SetInitState("s1");              
00273   g.SetMarkedState("s21");
00274   g.SetMarkedState("s41");
00275   
00276   return g;
00277 }
00278 
00279 /* *****************
00280  * TestGenerator6
00281  * *****************/
00282 PushdownGenerator TestGenerator6(){
00283     
00284   PushdownGenerator g;
00285   
00286   g.InsState("s1");
00287   g.InsState("s2");
00288   g.InsState("s3");
00289   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00290   g.InsStackSymbol("dot");
00291   g.InsStackSymbol("square");
00292   g.SetStackBottom("square");
00293   
00294   g.InsControllableEvent("a");         
00295   g.InsEvent("b");
00296   g.InsEvent(FAUDES_PD_LAMBDA);
00297   
00298   std::vector<StackSymbol> vLambda;
00299   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00300   std::vector<StackSymbol> vSquare;
00301   vSquare.push_back(StackSymbol("square"));
00302   std::vector<StackSymbol> vDot;
00303   vDot.push_back(StackSymbol("dot"));
00304   std::vector<StackSymbol> vSquareDot;
00305   vSquareDot.push_back(StackSymbol("square"));
00306   vSquareDot.push_back(StackSymbol("dot"));
00307   std::vector<StackSymbol> vSquareDotDot;
00308   vSquareDotDot.push_back(StackSymbol("square"));
00309   vSquareDotDot.push_back(StackSymbol("dot"));
00310   vSquareDotDot.push_back(StackSymbol("dot"));
00311   
00312   g.SetTransition("s1", "a", "s2",vSquare,vSquare);
00313   g.SetTransition("s1", "b", "s2",vDot,vSquare);
00314   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDot,vDot);
00315   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vDot,vSquareDotDot);
00316   g.SetTransition("s3", FAUDES_PD_LAMBDA, "s1",vSquare,vSquareDot);
00317   g.SetTransition("s3", FAUDES_PD_LAMBDA, "s1",vSquare,vLambda);
00318   
00319   g.SetInitState("s1");              
00320   g.SetMarkedState("s2");
00321   
00322   return g;
00323 }
00324 
00325 /* *****************
00326  * TestGenerator7
00327  * *****************/
00328 PushdownGenerator TestGenerator7(){
00329     
00330   PushdownGenerator g;
00331   
00332   g.InsState("s1");
00333   g.InsState("s2");
00334   g.InsState("s3");
00335   g.InsState("s4");
00336   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00337   g.InsStackSymbol("dot");
00338   g.InsStackSymbol("square");
00339   g.SetStackBottom("square");
00340   
00341   g.InsControllableEvent("a");         
00342   g.InsEvent("b");
00343   g.InsEvent(FAUDES_PD_LAMBDA);
00344   
00345   std::vector<StackSymbol> vLambda;
00346   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00347   std::vector<StackSymbol> vSquare;
00348   vSquare.push_back(StackSymbol("square"));
00349   std::vector<StackSymbol> vDot;
00350   vDot.push_back(StackSymbol("dot"));
00351   std::vector<StackSymbol> vDotSquare;
00352   vDotSquare.push_back(StackSymbol("dot"));
00353   vDotSquare.push_back(StackSymbol("square"));
00354   
00355   g.SetTransition("s1", "a", "s2",vLambda,vLambda);
00356   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s3",vSquare,vDotSquare);
00357   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s4",vSquare,vDotSquare);
00358   g.SetTransition("s3", FAUDES_PD_LAMBDA, "s2",vDot,vLambda);
00359   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s3",vDot,vLambda);
00360   
00361   g.SetInitState("s1");              
00362   g.SetMarkedState("s2");
00363   g.SetMarkedState("s4");
00364   
00365   return g;
00366 }
00367 
00368 /* *****************
00369  * TestGenerator8
00370  * *****************/
00371 PushdownGenerator TestGenerator8(){
00372     
00373   PushdownGenerator g;
00374   
00375   g.InsState("s1");
00376   g.InsState("s2");
00377   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00378   g.InsStackSymbol("dot");
00379   g.SetStackBottom("square");
00380   
00381   g.InsControllableEvent("a");         
00382   g.InsEvent(FAUDES_PD_LAMBDA);
00383   
00384   std::vector<StackSymbol> vLambda;
00385   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00386   std::vector<StackSymbol> vSquare;
00387   vSquare.push_back(StackSymbol("square"));
00388   std::vector<StackSymbol> vDotSquare;
00389   std::vector<StackSymbol> vDot;
00390   vDot.push_back(StackSymbol("dot"));
00391   vDotSquare.push_back(StackSymbol("dot"));
00392   vDotSquare.push_back(StackSymbol("square"));
00393   
00394   g.SetTransition("s2", "a", "s1",vDot,vDot);
00395   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vSquare,vDotSquare);
00396   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vDot,vLambda);
00397   
00398   g.SetInitState("s1");              
00399   g.SetMarkedState("s2");
00400   
00401   return g;
00402 }
00403 
00404 /* *****************
00405  * TestGenerator9
00406  * *****************/
00407 PushdownGenerator TestGenerator9(){
00408     
00409   PushdownGenerator g;
00410   
00411   g.InsState("s1");
00412   g.InsState("s1s");
00413   g.InsState("s1d");
00414   g.InsState("s2");
00415   g.InsState("s2d");
00416   g.InsState("s3");
00417   g.InsState("s4");
00418   g.InsState("s4s");
00419   g.InsState("s4d");
00420   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00421   g.InsStackSymbol("dot");
00422   g.SetStackBottom("square");
00423   
00424   g.InsControllableEvent("a");
00425   g.InsControllableEvent("b");
00426   g.InsUncontrollableEvent("u");
00427   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00428   
00429   std::vector<StackSymbol> vLambda;
00430   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00431   std::vector<StackSymbol> vSquare;
00432   vSquare.push_back(StackSymbol("square"));
00433   std::vector<StackSymbol> vDot;
00434   vDot.push_back(StackSymbol("dot"));
00435   std::vector<StackSymbol> vDotSquare;
00436   vDotSquare.push_back(StackSymbol("dot"));
00437   vDotSquare.push_back(StackSymbol("square"));
00438   std::vector<StackSymbol> vSquareDot;
00439   vSquareDot.push_back(StackSymbol("square"));
00440   vSquareDot.push_back(StackSymbol("dot"));
00441   
00442   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
00443   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
00444   g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
00445   g.SetTransition("s1d", "b", "s2",vDot,vDot);
00446   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
00447   g.SetTransition("s2d", "b", "s3",vDot,vLambda);
00448   g.SetTransition("s2d", "u", "s4",vDot,vDot);
00449   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4d",vDot,vDot);
00450   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4s",vSquare,vSquare);
00451   g.SetTransition("s4d", "u", "s4",vDot,vDot);
00452   g.SetTransition("s4s", "u", "s4",vSquare,vSquare);
00453 
00454   
00455   g.SetInitState("s1");
00456   g.SetMarkedState("s1s");
00457   g.SetMarkedState("s1d");
00458   g.SetMarkedState("s4s");
00459   g.SetMarkedState("s4d");
00460   
00461   return g;
00462 }
00463 
00464 
00465 /* *****************
00466  * TestGenerator10
00467  * *****************/
00468 PushdownGenerator TestGenerator10(){
00469     
00470   PushdownGenerator g;
00471   
00472   g.InsState("s1");
00473   g.InsState("s1s");
00474   g.InsState("s1d");
00475   //g.InsState("3");
00476   //g.InsState("4");
00477 
00478   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00479   
00480   g.InsStackSymbol("dot");
00481   g.SetStackBottom("square");
00482   //g.SetStackBottom("fullsquare");
00483   
00484   g.InsControllableEvent("a");
00485 
00486   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00487   
00488   std::vector<StackSymbol> vLambda;
00489   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00490   std::vector<StackSymbol> vSquare;
00491   vSquare.push_back(StackSymbol("square"));
00492   std::vector<StackSymbol> vFullsquare;
00493   vFullsquare.push_back(StackSymbol("fullsquare"));
00494   std::vector<StackSymbol> vDot;
00495   vDot.push_back(StackSymbol("dot"));
00496   std::vector<StackSymbol> vSquareSquare;
00497   vSquareSquare.push_back(StackSymbol("square"));
00498   vSquareSquare.push_back(StackSymbol("square"));
00499   std::vector<StackSymbol> vSquareFullsquare;
00500   vSquareFullsquare.push_back(StackSymbol("square"));
00501   vSquareFullsquare.push_back(StackSymbol("fullsquare"));
00502   std::vector<StackSymbol> vDotSquare;
00503   vDotSquare.push_back(StackSymbol("dot"));
00504   vDotSquare.push_back(StackSymbol("square"));
00505   std::vector<StackSymbol> vSquareDot;
00506   vSquareDot.push_back(StackSymbol("square"));
00507   vSquareDot.push_back(StackSymbol("dot"));
00508   
00509   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
00510   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
00511   g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
00512   //g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
00513   //g.SetTransition("s1d", "b", "s2",vDot,vDot);
00514   
00515   //g.SetTransition("s1", FAUDES_PD_LAMBDA, "3",vSquare,vLambda);
00516   //g.SetTransition("3", FAUDES_PD_LAMBDA, "s1s",vFullsquare,vSquareFullsquare);
00517   //g.SetTransition("s1s", "a", "s1",vDot,vSquareDot);
00518   //g.SetTransition("4", FAUDES_PD_LAMBDA, "s1",vFullsquare,vSquareFullsquare);
00519 
00520 
00521   g.SetInitState("s1");
00522   g.SetMarkedState("s1s");
00523   g.SetMarkedState("s1d");
00524 
00525   
00526   return g;
00527 }
00528 
00529 /* *****************
00530  * TestGenerator11
00531  * *****************/
00532 PushdownGenerator TestGenerator11(){
00533     
00534   PushdownGenerator g;
00535   
00536   g.InsState("s1");
00537   g.InsState("s1s");
00538   g.InsState("s1d");
00539   g.InsState("s2");
00540   g.InsState("s2d");
00541   //g.InsState("s3");
00542   g.InsState("s4");
00543   g.InsState("s4s");
00544   g.InsState("s4d");
00545   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00546   g.InsStackSymbol("dot");
00547   g.SetStackBottom("square");
00548   
00549   g.InsControllableEvent("a");
00550   g.InsControllableEvent("b");
00551   g.InsUncontrollableEvent("u");
00552   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00553   
00554   std::vector<StackSymbol> vLambda;
00555   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00556   std::vector<StackSymbol> vSquare;
00557   vSquare.push_back(StackSymbol("square"));
00558   std::vector<StackSymbol> vDot;
00559   vDot.push_back(StackSymbol("dot"));
00560   std::vector<StackSymbol> vDotSquare;
00561   vDotSquare.push_back(StackSymbol("dot"));
00562   vDotSquare.push_back(StackSymbol("square"));
00563   std::vector<StackSymbol> vSquareDot;
00564   vSquareDot.push_back(StackSymbol("square"));
00565   vSquareDot.push_back(StackSymbol("dot"));
00566   
00567   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
00568   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
00569   g.SetTransition("s1s", "a", "s1",vSquare,vDotSquare);
00570   g.SetTransition("s1d", "b", "s2",vDot,vDot);
00571   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
00572   //g.SetTransition("s2d", "b", "s3",vDot,vLambda);
00573   g.SetTransition("s2d", "u", "s4",vDot,vDot);
00574   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4d",vDot,vDot);
00575 //   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4s",vSquare,vSquare);
00576 //   g.SetTransition("s4d", "u", "s4",vDot,vDot);
00577 //   g.SetTransition("s4s", "u", "s4",vSquare,vSquare);
00578 
00579   
00580   g.SetInitState("s1");
00581   g.SetMarkedState("s1s");
00582   g.SetMarkedState("s1d");
00583   g.SetMarkedState("s4s");
00584   g.SetMarkedState("s4d");
00585   
00586   return g;
00587 }
00588 
00589 /* *****************
00590  * TestGenerator12
00591  * *****************/
00592 PushdownGenerator TestGenerator12(){
00593     
00594   PushdownGenerator g;
00595   
00596   g.InsState("s1");
00597   g.InsState("s2");
00598   g.InsState("s3");
00599   g.InsState("s4");
00600 
00601   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00602   g.InsStackSymbol("dot");
00603   g.SetStackBottom("square");
00604   
00605   g.InsControllableEvent("a");
00606   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00607   
00608   std::vector<StackSymbol> vLambda;
00609   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00610   std::vector<StackSymbol> vSquare;
00611   vSquare.push_back(StackSymbol("square"));
00612   std::vector<StackSymbol> vDot;
00613   vDot.push_back(StackSymbol("dot"));
00614   std::vector<StackSymbol> vDotSquare;
00615   vDotSquare.push_back(StackSymbol("dot"));
00616   vDotSquare.push_back(StackSymbol("square"));
00617   std::vector<StackSymbol> vSquareDot;
00618   vSquareDot.push_back(StackSymbol("square"));
00619   vSquareDot.push_back(StackSymbol("dot"));
00620   
00621   g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
00622   g.SetTransition("s1", "a", "s2",vDot,vDot);
00623   g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
00624 
00625   g.SetInitState("s1");
00626   g.SetMarkedState("s2");
00627   
00628   return g;
00629 }
00630 
00631 /* *****************
00632  * TestGenerator13
00633  * *****************/
00634 PushdownGenerator TestGenerator13(){
00635     
00636   PushdownGenerator g;
00637   
00638   g.InsState("s1");
00639   g.InsState("s2");
00640   g.InsState("s3");
00641   g.InsState("s4");
00642 
00643   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00644   g.InsStackSymbol("dot");
00645   g.SetStackBottom("square");
00646   
00647   g.InsControllableEvent("a");
00648   g.InsControllableEvent("b");
00649   g.InsControllableEvent("c");
00650   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00651   
00652   std::vector<StackSymbol> vLambda;
00653   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00654   std::vector<StackSymbol> vSquare;
00655   vSquare.push_back(StackSymbol("square"));
00656   std::vector<StackSymbol> vDot;
00657   vDot.push_back(StackSymbol("dot"));
00658   std::vector<StackSymbol> vDotSquare;
00659   vDotSquare.push_back(StackSymbol("dot"));
00660   vDotSquare.push_back(StackSymbol("square"));
00661   std::vector<StackSymbol> vSquareDot;
00662   vSquareDot.push_back(StackSymbol("square"));
00663   vSquareDot.push_back(StackSymbol("dot"));
00664   
00665   g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
00666   g.SetTransition("s1", "a", "s2",vDot,vDot);
00667   g.SetTransition("s2", "b", "s2",vDot,vLambda);
00668   g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
00669   g.SetTransition("s2", "c", "s4",vLambda,vLambda);
00670 
00671   g.SetInitState("s1");
00672   g.SetMarkedState("s2");
00673   
00674   return g;
00675 }
00676 
00677 /* *****************
00678  * TestGenerator14
00679  * *****************/
00680 PushdownGenerator TestGenerator14(){
00681     
00682   PushdownGenerator g;
00683   
00684   Idx s1 = g.InsState("s1");
00685   Idx s1s = g.InsState("s1s");
00686   Idx s1d = g.InsState("s1d");
00687   Idx s2 = g.InsState("s2");
00688   Idx s2s = g.InsState("s2s");
00689   Idx s2d = g.InsState("s2d");
00690 
00691   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00692   Idx dot = g.InsStackSymbol("dot");
00693   Idx square = g.SetStackBottom("square");
00694   
00695   g.InsControllableEvent("a");
00696   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00697   
00698   std::vector<StackSymbol> vLambda;
00699   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00700   std::vector<StackSymbol> vSquare;
00701   vSquare.push_back(StackSymbol("square"));
00702   std::vector<StackSymbol> vDot;
00703   vDot.push_back(StackSymbol("dot"));
00704   std::vector<StackSymbol> vDotSquare;
00705   vDotSquare.push_back(StackSymbol("dot"));
00706   vDotSquare.push_back(StackSymbol("square"));
00707   
00708   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1s",vSquare,vSquare);
00709   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s1d",vDot,vDot);
00710   g.SetTransition("s1s", "a", "s2",vSquare,vDotSquare);
00711   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2s",vSquare,vSquare);
00712   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s2d",vDot,vDot);
00713   
00714   MergeStateSplit mss1(s1);
00715   g.SetMerge(s1,mss1);
00716   MergeStateSplit mss1s(s1s,square);
00717   g.SetMerge(s1s,mss1s);
00718   MergeStateSplit mss1d(s1d,dot);
00719   g.SetMerge(s1d,mss1d);
00720   MergeStateSplit mss2(s2);
00721   g.SetMerge(s2,mss2);
00722   MergeStateSplit mss2s(s2s,square);
00723   g.SetMerge(s2s,mss2s);
00724   MergeStateSplit mss2d(s2d,dot);
00725   g.SetMerge(s2d,mss2d);
00726   
00727 
00728   g.SetInitState("s1");
00729   g.SetMarkedState("s1d");
00730   g.SetMarkedState("s2d");
00731   
00732   return g;
00733 }
00734 
00735 /* *****************
00736  * TestGenerator15
00737  * *****************/
00738 PushdownGenerator TestGenerator15(){
00739     
00740   PushdownGenerator g;
00741   
00742   g.InsState("s1");
00743   g.InsState("s2");
00744   g.InsState("s3");
00745 
00746 
00747   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00748   g.InsStackSymbol("dot");
00749   g.SetStackBottom("square");
00750   
00751   g.InsControllableEvent("a");
00752   g.InsControllableEvent("b");
00753   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00754   
00755   std::vector<StackSymbol> vLambda;
00756   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00757   std::vector<StackSymbol> vSquare;
00758   vSquare.push_back(StackSymbol("square"));
00759   std::vector<StackSymbol> vDot;
00760   vDot.push_back(StackSymbol("dot"));
00761   std::vector<StackSymbol> vDotSquare;
00762   vDotSquare.push_back(StackSymbol("dot"));
00763   vDotSquare.push_back(StackSymbol("square"));
00764   
00765   g.SetTransition("s1", "a", "s1",vDot,vDot);
00766   g.SetTransition("s2", "b", "s3",vSquare,vDotSquare);
00767   
00768   g.SetInitState("s1");
00769   g.SetMarkedState("s3");
00770   
00771   return g;
00772 }
00773 
00774 /* *****************
00775  * TestGenerator16
00776  * *****************/
00777 PushdownGenerator TestGenerator16(){
00778     
00779   PushdownGenerator g;
00780   
00781   g.InsState("s1");
00782   g.InsState("s2");
00783   g.InsState("s3");
00784 
00785 
00786   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00787   g.InsStackSymbol("dot");
00788   g.SetStackBottom("square");
00789   
00790   g.InsControllableEvent("a");
00791   g.InsControllableEvent("b");
00792   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00793   
00794   std::vector<StackSymbol> vLambda;
00795   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00796   std::vector<StackSymbol> vSquare;
00797   vSquare.push_back(StackSymbol("square"));
00798   std::vector<StackSymbol> vDot;
00799   vDot.push_back(StackSymbol("dot"));
00800   std::vector<StackSymbol> vDotSquare;
00801   vDotSquare.push_back(StackSymbol("dot"));
00802   vDotSquare.push_back(StackSymbol("square"));
00803   
00804   g.SetTransition("s1", "a", "s1",vDot,vDot);
00805   g.SetTransition("s2", "b", "s3",vSquare,vDotSquare);
00806   g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
00807   g.SetTransition("s1", "b", "s2",vSquare,vSquare);
00808   
00809   g.SetInitState("s1");
00810   g.SetMarkedState("s3");
00811   
00812   return g;
00813 }
00814 
00815 /* *****************
00816  * TestGenerator17
00817  * *****************/
00818 PushdownGenerator TestGenerator17(){
00819     
00820   PushdownGenerator g;
00821   
00822   g.InsState("s1");
00823   g.InsState("s2");
00824   g.InsState("s3");
00825   g.InsState("s4");
00826   g.InsState("s5");
00827 
00828 
00829   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00830   g.InsStackSymbol("dot");
00831   g.SetStackBottom("square");
00832   
00833   g.InsControllableEvent("a");
00834   g.InsControllableEvent("b");
00835   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00836   
00837   std::vector<StackSymbol> vLambda;
00838   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00839   std::vector<StackSymbol> vSquare;
00840   vSquare.push_back(StackSymbol("square"));
00841   std::vector<StackSymbol> vDot;
00842   vDot.push_back(StackSymbol("dot"));
00843   std::vector<StackSymbol> vDotSquare;
00844   
00845   g.SetTransition("s1", "a", "s1",vDot,vDot);
00846   g.SetTransition("s1", "b", "s2",vSquare,vSquare);
00847   g.SetTransition("s2", "b", "s3",vDot,vDot);
00848   g.SetTransition("s2", "a", "s4",vSquare,vSquare);
00849   
00850   g.SetInitState("s1");
00851   g.SetMarkedState("s3");
00852   g.SetMarkedState("s4");
00853   
00854   return g;
00855 }
00856 
00857 /* *****************
00858  * TestGenerator18
00859  * *****************/
00860 PushdownGenerator TestGenerator18(){
00861     
00862   PushdownGenerator g;
00863   
00864   g.InsState("s1");
00865   g.InsState("s2");
00866   g.InsState("s3");
00867 
00868 
00869   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00870   g.InsStackSymbol("dot");
00871   g.SetStackBottom("square");
00872   
00873   g.InsControllableEvent("a");
00874   g.InsEvent("b");
00875   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00876   
00877   std::vector<StackSymbol> vLambda;
00878   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00879   std::vector<StackSymbol> vSquare;
00880   vSquare.push_back(StackSymbol("square"));
00881   std::vector<StackSymbol> vDot;
00882   vDot.push_back(StackSymbol("dot"));
00883   std::vector<StackSymbol> vDotSquare;
00884   vDotSquare.push_back(StackSymbol("dot"));
00885   vDotSquare.push_back(StackSymbol("square"));
00886   
00887   g.SetTransition("s1", "b", "s2",vSquare,vDotSquare);
00888   g.SetTransition("s2", "b", "s3",vDot,vDot);
00889   
00890   g.SetInitState("s1");
00891   g.SetMarkedState("s3");
00892   
00893   return g;
00894 }
00895 
00896 /* *****************
00897  * TestGenerator19
00898  * *****************/
00899 PushdownGenerator TestGenerator19(){
00900     
00901   PushdownGenerator g;
00902   
00903   g.InsState("s1");
00904   g.InsState("s2");
00905   g.InsState("s3");
00906 
00907 
00908   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00909   g.InsStackSymbol("dot");
00910   g.SetStackBottom("square");
00911   
00912   g.InsControllableEvent("a");
00913   g.InsEvent("b");
00914   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00915   
00916   std::vector<StackSymbol> vLambda;
00917   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00918   std::vector<StackSymbol> vSquare;
00919   vSquare.push_back(StackSymbol("square"));
00920   std::vector<StackSymbol> vDot;
00921   vDot.push_back(StackSymbol("dot"));
00922   std::vector<StackSymbol> vDotSquare;
00923   vDotSquare.push_back(StackSymbol("dot"));
00924   vDotSquare.push_back(StackSymbol("square"));
00925   
00926   g.SetTransition("s1", "a", "s2",vSquare,vDotSquare);
00927   g.SetTransition("s2", "b", "s3",vDot,vDot);
00928   
00929   g.SetInitState("s1");
00930   g.SetMarkedState("s1");
00931   g.SetMarkedState("s2");
00932   g.SetMarkedState("s3");
00933   
00934   return g;
00935 }
00936 
00937 /* *****************
00938  * TestGenerator20
00939  * *****************/
00940 PushdownGenerator TestGenerator20(){
00941     
00942   PushdownGenerator g;
00943   
00944   g.InsState("s1");
00945   g.InsState("s2");
00946   g.InsState("s3");
00947   g.InsState("s4");
00948 
00949 
00950   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00951   g.InsStackSymbol("dot");
00952   g.SetStackBottom("square");
00953   
00954   g.InsControllableEvent("a");
00955   g.InsControllableEvent("b");
00956   g.InsEvent("u");
00957   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
00958   
00959   std::vector<StackSymbol> vLambda;
00960   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
00961   std::vector<StackSymbol> vSquare;
00962   vSquare.push_back(StackSymbol("square"));
00963   std::vector<StackSymbol> vDot;
00964   vDot.push_back(StackSymbol("dot"));
00965   std::vector<StackSymbol> vDotSquare;
00966   vDotSquare.push_back(StackSymbol("dot"));
00967   vDotSquare.push_back(StackSymbol("square"));
00968   
00969   g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
00970   g.SetTransition("s1", "b", "s2",vDot,vDot);
00971   g.SetTransition("s2", "b", "s3",vDot,vLambda);
00972   g.SetTransition("s2", "u", "s4",vDot,vDot);
00973   g.SetTransition("s4", "u", "s4",vDot,vDot);
00974   
00975   g.SetInitState("s1");
00976   g.SetMarkedState("s3");
00977   g.SetMarkedState("s4");
00978   
00979   return g;
00980 }
00981 
00982 /* *****************
00983  * TestGenerator21
00984  * *****************/
00985 PushdownGenerator TestGenerator21(){
00986     
00987   PushdownGenerator g;
00988   
00989   g.InsState("s1");
00990   g.InsState("s2");
00991   g.InsState("s3");
00992   g.InsState("s4");
00993 
00994 
00995   g.InsStackSymbol(FAUDES_PD_LAMBDA);
00996   g.InsStackSymbol("dot");
00997   g.SetStackBottom("square");
00998   
00999   g.InsControllableEvent("a");
01000   g.InsControllableEvent("b");
01001   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
01002   
01003   std::vector<StackSymbol> vLambda;
01004   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
01005   std::vector<StackSymbol> vSquare;
01006   vSquare.push_back(StackSymbol("square"));
01007   std::vector<StackSymbol> vDot;
01008   vDot.push_back(StackSymbol("dot"));
01009   std::vector<StackSymbol> vDotDot;
01010   vDotDot.push_back(StackSymbol("dot"));
01011   vDotDot.push_back(StackSymbol("dot"));
01012   std::vector<StackSymbol> vDotSquare;
01013   vDotSquare.push_back(StackSymbol("dot"));
01014   vDotSquare.push_back(StackSymbol("square"));
01015   
01016   g.SetTransition("s1", "a", "s2",vSquare,vDotSquare);
01017   g.SetTransition("s1", "a", "s2",vDot,vDotDot);
01018   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s4",vSquare,vSquare);
01019   g.SetTransition("s2", "a", "s3",vSquare,vDotSquare);
01020   g.SetTransition("s2", "a", "s3",vDot,vDotDot);
01021   g.SetTransition("s2", "b", "s3",vLambda,vDot);
01022   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s3",vSquare,vDotSquare);
01023   
01024   g.SetInitState("s1");
01025   g.SetMarkedState("s3");
01026   
01027   return g;
01028 }
01029 
01030 /* *****************
01031  * TestGenerator22
01032  * *****************/
01033 PushdownGenerator TestGenerator22(){
01034     
01035   PushdownGenerator g;
01036   
01037   g.InsState("s1");
01038   g.InsState("s2");
01039 
01040 
01041   g.InsStackSymbol(FAUDES_PD_LAMBDA);
01042   g.SetStackBottom("square");
01043   
01044   g.InsControllableEvent("a");
01045   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
01046   
01047   std::vector<StackSymbol> vLambda;
01048   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
01049   std::vector<StackSymbol> vSquare;
01050   vSquare.push_back(StackSymbol("square"));
01051   std::vector<StackSymbol> vDot;
01052   vDot.push_back(StackSymbol("dot"));
01053   std::vector<StackSymbol> vDotDot;
01054   vDotDot.push_back(StackSymbol("dot"));
01055   vDotDot.push_back(StackSymbol("dot"));
01056   std::vector<StackSymbol> vDotSquare;
01057   vDotSquare.push_back(StackSymbol("dot"));
01058   vDotSquare.push_back(StackSymbol("square"));
01059   
01060   g.SetTransition("s1", FAUDES_PD_LAMBDA, "s2",vSquare,vSquare);
01061   
01062   g.SetInitState("s1");
01063   g.SetMarkedState("s2");
01064   
01065   return g;
01066 }
01067 
01068 /* *****************
01069  * TestGenerator23
01070  * *****************/
01071 PushdownGenerator TestGenerator23(){
01072     
01073   PushdownGenerator g;
01074   
01075   g.InsState("s1");
01076   g.InsState("s2");
01077   g.InsState("s3");
01078 
01079   Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
01080   Idx dot = g.InsStackSymbol("dot");
01081   Idx heart= g.InsStackSymbol("heart");
01082   Idx diamond = g.InsStackSymbol("diamond");
01083   Idx square = g.SetStackBottom("square");
01084   
01085   g.InsControllableEvent("a");
01086   g.InsControllableEvent("b");
01087   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
01088   
01089   std::vector<Idx> vLambda;
01090   vLambda.push_back(lambda);
01091   std::vector<Idx> vSquare;
01092   vSquare.push_back(square);
01093   std::vector<Idx> vDot;
01094   vDot.push_back(dot);
01095   std::vector<Idx> vDotDot;
01096   vDotDot.push_back(dot);
01097   vDotDot.push_back(dot);
01098   std::vector<Idx> vDiamond;
01099   vDiamond.push_back(diamond);
01100   std::vector<Idx> vHeart;
01101   vHeart.push_back(heart);
01102   
01103   g.SetTransition("s1", "b", "s1",vSquare,vSquare);
01104   g.SetTransition("s1", "a", "s2",vDot,vDotDot);
01105   g.SetTransition("s1", "b", "s2",vLambda,vLambda);
01106   g.SetTransition("s2", "a", "s2",vHeart,vHeart);
01107   g.SetTransition("s3", "a", "s1",vDiamond,vDiamond);
01108   g.SetTransition("s3", "a", "s3",vDiamond,vLambda);
01109   
01110   g.SetInitState("s1");
01111   g.SetMarkedState("s2");
01112   
01113   return g;
01114 }
01115 
01116 /* *****************
01117  * TestGenerator24
01118  * *****************/
01119 PushdownGenerator TestGenerator24(){
01120     
01121   PushdownGenerator g;
01122   
01123   g.InsState("s0");
01124   g.InsState("s1");
01125   g.InsState("s2");
01126   g.InsState("s3");
01127   g.InsState("s4");
01128   g.InsState("s5");
01129   g.InsState("s6");
01130   g.InsState("s7");
01131   g.InsState("s8");
01132   
01133   
01134   g.InsStackSymbol(FAUDES_PD_LAMBDA);
01135   g.SetStackBottom("square");
01136   g.InsStackSymbol("dot");
01137   
01138   g.InsControllableEvent("a");
01139   g.InsControllableEvent("b");
01140   g.InsUncontrollableEvent("u");
01141   g.InsUncontrollableEvent("v");
01142   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
01143   
01144   std::vector<StackSymbol> vLambda;
01145   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
01146   std::vector<StackSymbol> vSquare;
01147   vSquare.push_back(StackSymbol("square"));
01148   std::vector<StackSymbol> vDot;
01149   vDot.push_back(StackSymbol("dot"));
01150   std::vector<StackSymbol> vDotDot;
01151   vDotDot.push_back(StackSymbol("dot"));
01152   vDotDot.push_back(StackSymbol("dot"));
01153   std::vector<StackSymbol> vDotSquare;
01154   vDotSquare.push_back(StackSymbol("dot"));
01155   vDotSquare.push_back(StackSymbol("square"));
01156   Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
01157   
01158   g.SetTransition("s0", "a", "s0",vSquare,vDotSquare);
01159   g.SetTransition("s0", "a", "s0",vDot,vDotDot);
01160   g.SetTransition("s0", "b", "s1",vDot,vDot);
01161   g.SetTransition("s0", "b", "s8",vSquare,vSquare);
01162   g.SetTransition("s1", "b", "s2",vDot,vLambda);
01163   g.SetTransition("s1", "u", "s7",vDot,vDot);
01164   g.SetTransition("s1", "v", "s7",vDot,vDot);
01165   g.SetTransition("s2", "b", "s1",vDot,vLambda);
01166   g.SetTransition("s2", FAUDES_PD_LAMBDA, "s3",vSquare,vDot);
01167   g.SetTransition("s3", "b", "s3",vDot,vDotDot);
01168   g.SetTransition("s3", "u", "s4",vDot,vDotDot);
01169   g.SetTransition("s3", "v", "s5",vDot,vLambda);
01170   g.SetTransition("s3", "v", "s5",vSquare,vSquare);
01171   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s6",vDot,vLambda);
01172   g.SetTransition("s5", FAUDES_PD_LAMBDA, "s5",vDot,vLambda);
01173   g.SetTransition("s5", "u", "s7",vSquare,vSquare);
01174   g.SetTransition("s6", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
01175   g.SetTransition("s6", "u", "s7",vSquare,vSquare);
01176   g.SetTransition("s6", "v", "s7",vSquare,vSquare);
01177   g.SetTransition("s7", "u", "s7",vDot,vDot);
01178   g.SetTransition("s7", "v", "s7",vDot,vDot);
01179   g.SetTransition("s7", "u", "s7",vSquare,vSquare);
01180   g.SetTransition("s7", "v", "s7",vSquare,vSquare);
01181   
01182   
01183   g.SetInitState("s0");
01184   g.SetMarkedState("s2");
01185   g.SetMarkedState("s5");
01186   g.SetMarkedState("s6");
01187   g.SetMarkedState("s7");
01188   g.SetMarkedState("s8");
01189   
01190   return g;
01191 }
01192 
01193 /* *****************
01194  * TestGenerator25
01195  * *****************/
01196 PushdownGenerator TestGenerator25(){
01197     
01198   PushdownGenerator g;
01199   
01200   g.InsState("s1");
01201   g.InsState("s2");
01202   g.InsState("s3");
01203   g.InsState("s4");
01204   g.InsState("s5");
01205   
01206   g.InsStackSymbol(FAUDES_PD_LAMBDA);
01207   g.SetStackBottom("square");
01208   g.InsStackSymbol("dot");
01209   
01210   g.InsControllableEvent("a");
01211   g.InsControllableEvent("b");
01212   g.InsUncontrollableEvent("u");
01213   g.InsUncontrollableEvent("v");
01214   g.InsUncontrollableEvent(FAUDES_PD_LAMBDA);
01215   
01216   std::vector<StackSymbol> vLambda;
01217   vLambda.push_back(StackSymbol(FAUDES_PD_LAMBDA));
01218   std::vector<StackSymbol> vSquare;
01219   vSquare.push_back(StackSymbol("square"));
01220   std::vector<StackSymbol> vDot;
01221   vDot.push_back(StackSymbol("dot"));
01222   std::vector<StackSymbol> vDotDot;
01223   vDotDot.push_back(StackSymbol("dot"));
01224   vDotDot.push_back(StackSymbol("dot"));
01225   std::vector<StackSymbol> vDotSquare;
01226   vDotSquare.push_back(StackSymbol("dot"));
01227   vDotSquare.push_back(StackSymbol("square"));
01228   Idx lambda = g.InsStackSymbol(FAUDES_PD_LAMBDA);
01229   
01230   g.SetTransition("s1", "a", "s1",vSquare,vDotSquare);
01231   g.SetTransition("s1", "a", "s1",vDot,vDotDot);
01232   g.SetTransition("s1", "b", "s2",vDot,vLambda);
01233   g.SetTransition("s2", "b", "s2",vDot,vLambda);
01234   g.SetTransition("s2", "u", "s3",vDot,vDot);
01235   g.SetTransition("s2", "v", "s4",vDot,vLambda);
01236   g.SetTransition("s2", "v", "s4",vSquare,vSquare);
01237   g.SetTransition("s3", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
01238   g.SetTransition("s4", FAUDES_PD_LAMBDA, "s4",vDot,vLambda);
01239   g.SetTransition("s4", "u", "s5",vSquare,vSquare);
01240   g.SetTransition("s5", "u", "s5",vSquare,vSquare);
01241   
01242   g.SetInitState("s1");
01243   g.SetMarkedState("s5");
01244   
01245   return g;
01246 }
01247 
01248 /* *****************
01249  * TestSystem1
01250  * *****************/
01251 System TestSystem1(){
01252     
01253   System s;
01254   
01255   s.InsState("s1");
01256   s.InsState("s2");
01257   s.InsState("s3");
01258   
01259   s.InsControllableEvent("a");         
01260   s.InsEvent("b");
01261   s.InsControllableEvent("c");
01262   
01263   s.SetTransition("s1", "a", "s2");
01264   s.SetTransition("s1", "b", "s3");
01265   s.SetTransition("s1", "c", "s3");
01266   s.SetTransition("s2", "b", "s1");
01267   s.SetTransition("s3", "a", "s2");
01268   
01269   s.SetInitState("s1");              
01270   s.SetMarkedState("s3");
01271   
01272   return s;
01273 }
01274 
01275 /* *****************
01276  * TestSystem2
01277  * *****************/
01278 System TestSystem2(){
01279     
01280   System s;
01281   
01282   s.InsState("s1");
01283   s.InsState("s2");
01284   
01285   s.InsControllableEvent("a");         
01286   s.InsEvent("b");
01287   
01288   s.SetTransition("s1", "a", "s2");
01289   s.SetTransition("s1", "b", "s1");
01290   s.SetTransition("s2", "a", "s2");
01291   s.SetTransition("s2", "b", "s1");
01292   
01293   s.SetInitState("s1");              
01294   s.SetMarkedState("s2");
01295   
01296   return s;
01297 }
01298 
01299 /* *****************
01300  * TestSystem3
01301  * *****************/
01302 System TestSystem3(){
01303     
01304   System s;
01305   
01306   s.InsState("s1");
01307   
01308   s.InsControllableEvent("a");         
01309   s.InsEvent("b");
01310   
01311   s.SetTransition("s1", "a", "s1");
01312   s.SetTransition("s1", "b", "s1");
01313   
01314   s.SetInitState("s1");              
01315   s.SetMarkedState("s1");
01316   
01317   return s;
01318 }
01319 
01320 /* *****************
01321  * TestSystem4
01322  * *****************/
01323 System TestSystem4(){
01324     
01325   System s;
01326   
01327   s.InsState("s1");
01328   s.InsState("s2");
01329   s.InsState("s3");
01330   
01331   s.InsControllableEvent("a");         
01332   s.InsEvent("b");
01333   
01334   s.SetTransition("s1", "a", "s1");
01335   s.SetTransition("s1", "a", "s2");
01336   s.SetTransition("s2", "b", "s3");
01337   
01338   s.SetInitState("s1");              
01339   s.SetMarkedState("s3");
01340   
01341   return s;
01342 }
01343 
01344 /* *****************
01345  * TestSystem5
01346  * *****************/
01347 System TestSystem5(){
01348     
01349   System s;
01350   
01351   s.InsState("s1");
01352   s.InsState("s2");
01353   s.InsState("s3");
01354   
01355   s.InsControllableEvent("a");
01356   s.InsControllableEvent("b");
01357   s.InsEvent("u");
01358   //s.InsEvent("v");
01359   
01360   s.SetTransition("s1", "a", "s1");
01361   s.SetTransition("s1", "b", "s2");
01362   s.SetTransition("s2", "b", "s2");
01363   s.SetTransition("s2", "u", "s3");
01364   //s.SetTransition("s2", "v", "s3");
01365   s.SetTransition("s3", "u", "s3");
01366   //s.SetTransition("s3", "v", "s3");
01367   
01368   s.SetInitState("s1");              
01369   s.SetMarkedState("s2");
01370   s.SetMarkedState("s3");
01371   
01372   return s;
01373 }
01374 
01375 /* *****************
01376  * TestGrammar1
01377  * *****************/
01378 Grammar TestGrammar1(){
01379   
01380   PushdownGenerator g1 = TestGenerator1();
01381   
01382   StackSymbolSet stackSymbols = g1.StackSymbols();
01383   
01384   std::vector<Idx> ssvDot;
01385   ssvDot.push_back(stackSymbols.Index("dot"));
01386   std::vector<Idx> ssvSquare;
01387   ssvSquare.push_back(stackSymbols.Index("square"));
01388 
01389   //construct Terminals
01390   Terminal* t1 = new Terminal(g1.Alphabet().Index("a"));
01391   GrammarSymbolPtr t1Ptr(t1);
01392   Terminal* t2 = new Terminal(g1.Alphabet().Index("b"));
01393   GrammarSymbolPtr t2Ptr(t2);
01394   
01395   //construct NonterminalEnd
01396   
01397   Nonterminal* nte1 = new Nonterminal(g1.StateIndex("s3"),ssvDot);
01398   GrammarSymbolPtr nte1Ptr(nte1);
01399   Nonterminal* nte2 = new Nonterminal(g1.StateIndex("s4"),ssvSquare);
01400   GrammarSymbolPtr nte2Ptr(nte2);
01401   
01402   //construct NonterminalMid
01403   Nonterminal* ntm3 = new Nonterminal(g1.StateIndex("s1"),ssvDot,g1.StateIndex("s2"));
01404   GrammarSymbolPtr ntm3Ptr(ntm3);
01405   Nonterminal* ntm4 = new Nonterminal(g1.StateIndex("s2"),ssvSquare,g1.StateIndex("s3"));
01406   GrammarSymbolPtr ntm4Ptr(ntm4);
01407   Nonterminal* ntm5 = new Nonterminal(g1.StateIndex("s5"),ssvSquare,g1.StateIndex("s1"));
01408   GrammarSymbolPtr ntm5Ptr(ntm5);
01409   
01410   //construct GrammarProduction
01411   GrammarSymbolVector v1;
01412   v1.push_back(nte2Ptr);
01413   v1.push_back(t2Ptr);
01414   GrammarProduction gp1 = GrammarProduction(*nte1,v1);
01415   GrammarSymbolVector v2;
01416   v2.push_back(t1Ptr);
01417   v2.push_back(ntm3Ptr);
01418   v2.push_back(t2Ptr);
01419   GrammarProduction gp2 = GrammarProduction(*nte2,v2);
01420   GrammarSymbolVector v3;
01421   v3.push_back(ntm4Ptr);
01422   GrammarProduction gp3 = GrammarProduction(*ntm3,v3);
01423   GrammarSymbolVector v4;
01424   v4.push_back(ntm5Ptr);
01425   GrammarProduction gp4 = GrammarProduction(*ntm3,v4);
01426   GrammarSymbolVector v5;
01427   v5.push_back(t2Ptr);
01428   GrammarProduction gp5 = GrammarProduction(*ntm5,v5);
01429 
01430   //construct Grammar
01431   Grammar gr = Grammar(*nte1);
01432   gr.InsTerminal(*t1);
01433   gr.InsTerminal(*t2);
01434   
01435   gr.InsNonterminal(*nte1);
01436   gr.InsNonterminal(*nte2);
01437   gr.InsNonterminal(*ntm3);
01438   gr.InsNonterminal(*ntm4);
01439   gr.InsNonterminal(*ntm5);
01440   
01441   gr.InsGrammarProduction(gp1);
01442   gr.InsGrammarProduction(gp2);
01443   gr.InsGrammarProduction(gp3);
01444   gr.InsGrammarProduction(gp4);
01445   gr.InsGrammarProduction(gp5);  
01446   
01447   return gr;
01448 }
01449 
01450 /* *****************
01451  * TestGrammar2
01452  * *****************/
01453 Grammar TestGrammar2(){
01454   
01455   PushdownGenerator g1 = TestGenerator1();
01456   
01457   StackSymbolSet stackSymbols = g1.StackSymbols();
01458 
01459   std::vector<Idx> ssvDot;
01460   ssvDot.push_back(stackSymbols.Index("dot"));
01461   std::vector<Idx> ssvSquare;
01462   ssvSquare.push_back(stackSymbols.Index("square"));
01463   
01464   //construct Terminals
01465   Terminal* t1 = new Terminal(g1.Alphabet().Index("a"));
01466   GrammarSymbolPtr t1Ptr(t1);
01467   Terminal* t2 = new Terminal(g1.Alphabet().Index("b"));
01468   GrammarSymbolPtr t2Ptr(t2);
01469   
01470   //construct NonterminalEnd
01471   Nonterminal* nte1 = new Nonterminal(g1.StateIndex("s3"),ssvDot);
01472   GrammarSymbolPtr nte1Ptr(nte1);
01473   Nonterminal* nte2 = new Nonterminal(g1.StateIndex("s4"),ssvSquare);
01474   GrammarSymbolPtr nte2Ptr(nte2);
01475   
01476   //construct NonterminalMid
01477   Nonterminal* ntm3 = new Nonterminal(g1.StateIndex("s1"),ssvDot,g1.StateIndex("s2"));
01478   GrammarSymbolPtr ntm3Ptr(ntm3);
01479   Nonterminal* ntm4 = new Nonterminal(g1.StateIndex("s2"),ssvSquare,g1.StateIndex("s3"));
01480   GrammarSymbolPtr ntm4Ptr(ntm4);
01481   Nonterminal* ntm5 = new Nonterminal(g1.StateIndex("s5"),ssvSquare,g1.StateIndex("s1"));
01482   GrammarSymbolPtr ntm5Ptr(ntm5);
01483   
01484   //construct GrammarProduction
01485   GrammarSymbolVector v2;
01486   v2.push_back(t1Ptr);
01487   v2.push_back(ntm3Ptr);
01488   v2.push_back(t2Ptr);
01489   GrammarProduction gp2 = GrammarProduction(*nte2,v2);
01490   GrammarSymbolVector v3;
01491   v3.push_back(ntm4Ptr);
01492   GrammarProduction gp3 = GrammarProduction(*ntm3,v3);
01493   GrammarSymbolVector v4;
01494   v4.push_back(ntm5Ptr);
01495   GrammarProduction gp4 = GrammarProduction(*ntm3,v4);
01496   GrammarSymbolVector v5;
01497   v5.push_back(t2Ptr);
01498   GrammarProduction gp5 = GrammarProduction(*ntm5,v5);
01499 
01500   //construct Grammar
01501   Grammar gr = Grammar(*nte2);
01502   gr.InsTerminal(*t1);
01503   gr.InsTerminal(*t2);
01504   
01505   gr.InsNonterminal(*nte1);
01506   gr.InsNonterminal(*nte2);
01507   gr.InsNonterminal(*ntm3);
01508   gr.InsNonterminal(*ntm4);
01509   gr.InsNonterminal(*ntm5);
01510   
01511   gr.InsGrammarProduction(gp2);
01512   gr.InsGrammarProduction(gp3);
01513   gr.InsGrammarProduction(gp4);
01514   gr.InsGrammarProduction(gp5);  
01515   
01516   return gr;
01517 }
01518 
01519 /* *****************
01520  * TestGrammar3
01521  * *****************/
01522 Grammar TestGrammar3(){
01523   
01524   PushdownGenerator g1 = TestGenerator1();
01525   
01526   StackSymbolSet stackSymbols = g1.StackSymbols();
01527 
01528   std::vector<Idx> ssvDot;
01529   ssvDot.push_back(stackSymbols.Index("dot"));
01530   std::vector<Idx> ssvSquare;
01531   ssvSquare.push_back(stackSymbols.Index("square"));
01532   
01533   //construct Terminals
01534   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01535   GrammarSymbolPtr taPtr(ta);
01536   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01537   GrammarSymbolPtr tbPtr(tb);
01538   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01539   GrammarSymbolPtr tlambdaPtr(tlambda);
01540   
01541   //construct NonterminalEnd
01542   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01543   GrammarSymbolPtr nt1dotPtr(nt1dot);
01544   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
01545   GrammarSymbolPtr nt1squarePtr(nt1square);
01546   Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
01547   GrammarSymbolPtr nt2squarePtr(nt2square);
01548   
01549   //construct NonterminalMid
01550   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
01551   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
01552   Nonterminal* nt2square2 = new Nonterminal(2,ssvSquare,2);
01553   GrammarSymbolPtr nt2square2Ptr(nt2square2);
01554   
01555   //construct GrammarProduction
01556   GrammarSymbolVector v;
01557   v.push_back(taPtr);
01558   v.push_back(nt1dotPtr);
01559   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01560   v.clear();
01561   v.push_back(tbPtr);
01562   v.push_back(nt2squarePtr);
01563   GrammarProduction gp2 = GrammarProduction(*nt1dot,v);
01564   v.clear();
01565   v.push_back(nt1dot1Ptr);
01566   v.push_back(nt2squarePtr);
01567   GrammarProduction gp3 = GrammarProduction(*nt2square,v);
01568   v.clear();
01569   v.push_back(tlambdaPtr);
01570   GrammarProduction gp4 = GrammarProduction(*nt2square,v);
01571   v.clear();
01572   v.push_back(nt1squarePtr);
01573   GrammarProduction gp5 = GrammarProduction(*nt1dot1,v);
01574   v.clear();
01575   v.push_back(nt1dotPtr);
01576   GrammarProduction gp6 = GrammarProduction(*nt1dot1,v);
01577   v.clear();
01578   v.push_back(taPtr);
01579   v.push_back(nt1dotPtr);
01580   GrammarProduction gp7 = GrammarProduction(*nt2square2,v);
01581 
01582   //construct Grammar
01583   Grammar gr = Grammar();
01584   gr.InsTerminal(*ta);
01585   gr.InsTerminal(*tb);
01586   gr.InsTerminal(*tlambda);
01587   
01588   gr.SetStartSymbol(*nt1dot);
01589   gr.InsNonterminal(*nt1square);
01590   gr.InsNonterminal(*nt2square);
01591   gr.InsNonterminal(*nt1dot1);
01592   gr.InsNonterminal(*nt2square2);
01593   
01594   gr.InsGrammarProduction(gp1);
01595   gr.InsGrammarProduction(gp2);
01596   gr.InsGrammarProduction(gp3);
01597   gr.InsGrammarProduction(gp4);
01598   gr.InsGrammarProduction(gp5);  
01599   gr.InsGrammarProduction(gp6);
01600   gr.InsGrammarProduction(gp7);
01601   
01602   return gr;
01603 }
01604 
01605 /* *****************
01606  * TestGrammar4
01607  * *****************/
01608 Grammar TestGrammar4(){
01609   
01610   PushdownGenerator g1 = TestGenerator1();
01611   
01612   StackSymbolSet stackSymbols = g1.StackSymbols();
01613 
01614   std::vector<Idx> ssvDot;
01615   ssvDot.push_back(stackSymbols.Index("dot"));
01616   std::vector<Idx> ssvSquare;
01617   ssvSquare.push_back(stackSymbols.Index("square"));
01618   
01619   //construct Terminals
01620   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01621   GrammarSymbolPtr taPtr(ta);
01622   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01623   GrammarSymbolPtr tlambdaPtr(tlambda);
01624   
01625   //construct NonterminalEnd
01626   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01627   GrammarSymbolPtr nt1dotPtr(nt1dot);
01628   Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
01629   GrammarSymbolPtr nt2squarePtr(nt2square);
01630   
01631   //construct NonterminalMid
01632   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
01633   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
01634   
01635   //construct GrammarProduction
01636   GrammarSymbolVector v;
01637   v.push_back(taPtr);
01638   v.push_back(nt1dotPtr);
01639   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01640   v.clear();
01641   v.push_back(nt1dot1Ptr);
01642   v.push_back(taPtr);
01643   v.push_back(nt2squarePtr);
01644   GrammarProduction gp2 = GrammarProduction(*nt2square,v);
01645   v.clear();
01646   v.push_back(tlambdaPtr);
01647   GrammarProduction gp3 = GrammarProduction(*nt2square,v);
01648 
01649   //construct Grammar
01650   Grammar gr = Grammar();
01651   gr.InsTerminal(*ta);
01652   gr.InsTerminal(*tlambda);
01653   
01654   gr.SetStartSymbol(*nt1dot);
01655   gr.InsNonterminal(*nt2square);
01656   gr.InsNonterminal(*nt1dot1);
01657   
01658   gr.InsGrammarProduction(gp1);
01659   gr.InsGrammarProduction(gp2);
01660   gr.InsGrammarProduction(gp3);
01661   
01662   return gr;
01663 }
01664 
01665 /* *****************
01666  * TestGrammar5
01667  * *****************/
01668 Grammar TestGrammar5(){
01669   
01670   PushdownGenerator g1 = TestGenerator1();
01671   
01672   StackSymbolSet stackSymbols = g1.StackSymbols();
01673 
01674   std::vector<Idx> ssvDot;
01675   ssvDot.push_back(stackSymbols.Index("dot"));
01676   std::vector<Idx> ssvSquare;
01677   ssvSquare.push_back(stackSymbols.Index("square"));
01678   
01679   //construct Terminals
01680   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01681   GrammarSymbolPtr taPtr(ta);
01682   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01683   GrammarSymbolPtr tbPtr(tb);
01684   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01685   GrammarSymbolPtr tlambdaPtr(tlambda);
01686   
01687   //construct NonterminalEnd
01688   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01689   GrammarSymbolPtr nt1dotPtr(nt1dot);
01690   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
01691   GrammarSymbolPtr nt1squarePtr(nt1square);
01692   Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
01693   GrammarSymbolPtr nt2squarePtr(nt2square);
01694   
01695   //construct NonterminalMid
01696   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
01697   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
01698   
01699   //construct GrammarProduction
01700   GrammarSymbolVector v;
01701   v.push_back(nt1dot1Ptr);
01702   v.push_back(taPtr);
01703   v.push_back(nt1squarePtr);
01704   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01705   v.clear();
01706   v.push_back(tlambdaPtr);
01707   GrammarProduction gp2 = GrammarProduction(*nt1square,v);
01708   v.clear();
01709   v.push_back(tbPtr);
01710   GrammarProduction gp3 = GrammarProduction(*nt1square,v);
01711   v.clear();
01712   v.push_back(nt1dotPtr);
01713   GrammarProduction gp4 = GrammarProduction(*nt1dot1,v);
01714   v.clear();
01715   v.push_back(taPtr);
01716   v.push_back(nt1squarePtr);
01717   GrammarProduction gp5 = GrammarProduction(*nt1dot1,v);
01718   v.clear();
01719   v.push_back(nt1squarePtr);
01720   v.push_back(nt1dotPtr);
01721   GrammarProduction gp6 = GrammarProduction(*nt2square,v);
01722 
01723   //construct Grammar
01724   Grammar gr = Grammar();
01725   gr.InsTerminal(*ta);
01726   gr.InsTerminal(*tb);
01727   gr.InsTerminal(*tlambda);
01728   
01729   gr.SetStartSymbol(*nt1dot);
01730   gr.InsNonterminal(*nt1square);
01731   gr.InsNonterminal(*nt2square);
01732   gr.InsNonterminal(*nt1dot1);
01733   
01734   gr.InsGrammarProduction(gp1);
01735   gr.InsGrammarProduction(gp2);
01736   gr.InsGrammarProduction(gp3);
01737   gr.InsGrammarProduction(gp4);
01738   gr.InsGrammarProduction(gp5);
01739   gr.InsGrammarProduction(gp6);
01740   
01741   return gr;
01742 }
01743 
01744 /* *****************
01745  * TestGrammar6
01746  * *****************/
01747 Grammar TestGrammar6(){
01748   
01749   PushdownGenerator g1 = TestGenerator1();
01750   
01751   StackSymbolSet stackSymbols = g1.StackSymbols();
01752 
01753   std::vector<Idx> ssvDot;
01754   ssvDot.push_back(stackSymbols.Index("dot"));
01755   std::vector<Idx> ssvSquare;
01756   ssvSquare.push_back(stackSymbols.Index("square"));
01757   
01758   //construct Terminals
01759   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01760   GrammarSymbolPtr taPtr(ta);
01761   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01762   GrammarSymbolPtr tbPtr(tb);
01763   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01764   GrammarSymbolPtr tlambdaPtr(tlambda);
01765   
01766   //construct Nonterminals
01767   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01768   GrammarSymbolPtr nt1dotPtr(nt1dot);
01769   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
01770   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
01771   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
01772   GrammarSymbolPtr nt1squarePtr(nt1square);
01773   Nonterminal* nt1square1 = new Nonterminal(1,ssvSquare,1);
01774   GrammarSymbolPtr nt1square1Ptr(nt1square1);
01775 
01776   //construct GrammarProduction
01777   GrammarSymbolVector v;
01778   v.push_back(nt1dot1Ptr);
01779   v.push_back(taPtr);
01780   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01781   v.clear();
01782   v.push_back(tlambdaPtr);
01783   GrammarProduction gp2 = GrammarProduction(*nt1dot1,v);
01784   v.clear();
01785   v.push_back(tbPtr);
01786   v.push_back(nt1squarePtr);
01787   GrammarProduction gp3 = GrammarProduction(*nt1square1,v);
01788   
01789   //construct Grammar
01790    Grammar gr = Grammar();
01791   gr.InsTerminal(*ta);
01792   gr.InsTerminal(*tb);
01793   gr.InsTerminal(*tlambda);
01794   
01795   gr.SetStartSymbol(*nt1dot);
01796   gr.InsNonterminal(*nt1square);
01797   gr.InsNonterminal(*nt1square1);
01798   gr.InsNonterminal(*nt1dot1);
01799  
01800   gr.InsGrammarProduction(gp1);
01801   gr.InsGrammarProduction(gp2);
01802   gr.InsGrammarProduction(gp3);
01803   
01804   return gr;
01805 }
01806 
01807 /* *****************
01808  * TestGrammar7
01809  * *****************/
01810 Grammar TestGrammar7(){
01811   
01812   PushdownGenerator g1 = TestGenerator1();
01813   
01814   StackSymbolSet stackSymbols = g1.StackSymbols();
01815 
01816   std::vector<Idx> ssvDot;
01817   ssvDot.push_back(stackSymbols.Index("dot"));
01818   std::vector<Idx> ssvSquare;
01819   ssvSquare.push_back(stackSymbols.Index("square"));
01820   
01821   g1.InsEvent("$");
01822   
01823   //construct Terminals
01824   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01825   GrammarSymbolPtr taPtr(ta);
01826   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01827   GrammarSymbolPtr tbPtr(tb);
01828   Terminal* tdollar = new Terminal(g1.Alphabet().Index("$"));
01829   GrammarSymbolPtr tdollarPtr(tdollar);
01830   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01831   GrammarSymbolPtr tlambdaPtr(tlambda);
01832   
01833   //construct Nonterminals
01834   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01835   GrammarSymbolPtr nt1dotPtr(nt1dot);
01836   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
01837   GrammarSymbolPtr nt1squarePtr(nt1square);
01838 
01839   //construct GrammarProduction
01840   GrammarSymbolVector v;
01841   v.push_back(tdollarPtr);
01842   v.push_back(nt1squarePtr);
01843   v.push_back(tdollarPtr);
01844   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01845   v.clear();
01846   v.push_back(taPtr);
01847   v.push_back(nt1squarePtr);
01848   GrammarProduction gp2 = GrammarProduction(*nt1square,v);
01849   v.clear();
01850   v.push_back(tbPtr);
01851   GrammarProduction gp3 = GrammarProduction(*nt1square,v);
01852   
01853   //construct Grammar
01854    Grammar gr = Grammar();
01855   gr.InsTerminal(*ta);
01856   gr.InsTerminal(*tb);
01857   gr.InsTerminal(*tdollar);
01858   gr.InsTerminal(*tlambda);
01859   
01860   gr.SetStartSymbol(*nt1dot);
01861   gr.InsNonterminal(*nt1square);
01862  
01863   gr.InsGrammarProduction(gp1);
01864   gr.InsGrammarProduction(gp2);
01865   gr.InsGrammarProduction(gp3);
01866   
01867   return gr;
01868 }
01869 
01870 /* *****************
01871  * TestGrammar8
01872  * *****************/
01873 Grammar TestGrammar8(){
01874   
01875   PushdownGenerator g1 = TestGenerator1();
01876   
01877   StackSymbolSet stackSymbols = g1.StackSymbols();
01878 
01879   std::vector<Idx> ssvDot;
01880   ssvDot.push_back(stackSymbols.Index("dot"));
01881   std::vector<Idx> ssvSquare;
01882   ssvSquare.push_back(stackSymbols.Index("square"));
01883   
01884   g1.InsEvent("$");
01885   g1.InsEvent("d");
01886   g1.InsEvent("e");
01887   
01888   //construct Terminals
01889   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01890   GrammarSymbolPtr taPtr(ta);
01891   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01892   GrammarSymbolPtr tbPtr(tb);
01893   Terminal* td = new Terminal(g1.Alphabet().Index("d"));
01894   GrammarSymbolPtr tdPtr(td);
01895   Terminal* te = new Terminal(g1.Alphabet().Index("e"));
01896   GrammarSymbolPtr tePtr(te);
01897   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01898   GrammarSymbolPtr tlambdaPtr(tlambda);
01899   Terminal* tdollar = new Terminal(g1.Alphabet().Index("$"));
01900   GrammarSymbolPtr tdollarPtr(tdollar);
01901   
01902   //construct Nonterminals
01903   Nonterminal* nt1dot = new Nonterminal(1,ssvDot);
01904   GrammarSymbolPtr nt1dotPtr(nt1dot);
01905   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
01906   GrammarSymbolPtr nt1squarePtr(nt1square);
01907   Nonterminal* nt2dot = new Nonterminal(2,ssvDot);
01908   GrammarSymbolPtr nt2dotPtr(nt2dot);
01909   Nonterminal* nt2square = new Nonterminal(2,ssvSquare);
01910   GrammarSymbolPtr nt2squarePtr(nt2square);
01911   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
01912   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
01913 
01914   //construct GrammarProduction
01915   GrammarSymbolVector v;
01916   v.push_back(tdollarPtr);
01917   v.push_back(nt1squarePtr);
01918   v.push_back(tdollarPtr);
01919   GrammarProduction gp1 = GrammarProduction(*nt1dot,v);
01920   
01921   v.clear();
01922   v.push_back(nt1dot1Ptr);
01923   GrammarProduction gp2 = GrammarProduction(*nt1square,v);
01924   
01925   v.clear();
01926   v.push_back(nt2dotPtr);
01927   GrammarProduction gp3 = GrammarProduction(*nt1square,v);
01928   
01929   v.clear();
01930   v.push_back(tlambdaPtr);
01931   GrammarProduction gp4 = GrammarProduction(*nt1dot1,v);
01932   
01933   v.clear();
01934   v.push_back(taPtr);
01935   GrammarProduction gp5 = GrammarProduction(*nt2dot,v);
01936   
01937   v.clear();
01938   v.push_back(tbPtr);
01939   v.push_back(nt1squarePtr);
01940   v.push_back(nt2squarePtr);
01941   v.push_back(tePtr);
01942   GrammarProduction gp6 = GrammarProduction(*nt2dot,v);
01943   
01944   v.clear();
01945   v.push_back(tlambdaPtr);
01946   GrammarProduction gp7 = GrammarProduction(*nt2square,v);
01947   
01948   v.clear();
01949   v.push_back(tdPtr);
01950   v.push_back(nt1squarePtr);
01951   v.push_back(nt2squarePtr);
01952   GrammarProduction gp8 = GrammarProduction(*nt2square,v);
01953   
01954   //construct Grammar
01955    Grammar gr = Grammar();
01956   gr.InsTerminal(*ta);
01957   gr.InsTerminal(*tb);
01958   gr.InsTerminal(*td);
01959   gr.InsTerminal(*te);
01960   gr.InsTerminal(*tdollar);
01961   gr.InsTerminal(*tlambda);
01962   
01963   gr.SetStartSymbol(*nt1dot);
01964   gr.InsNonterminal(*nt1square);
01965   gr.InsNonterminal(*nt2dot);
01966   gr.InsNonterminal(*nt2square);
01967   gr.InsNonterminal(*nt1dot1);
01968  
01969   gr.InsGrammarProduction(gp1);
01970   gr.InsGrammarProduction(gp2);
01971   gr.InsGrammarProduction(gp3);
01972   gr.InsGrammarProduction(gp4);
01973   gr.InsGrammarProduction(gp5);
01974   gr.InsGrammarProduction(gp6);
01975   gr.InsGrammarProduction(gp7);
01976   gr.InsGrammarProduction(gp8);
01977   
01978   return gr;
01979 }
01980 
01981 /* *****************
01982  * TestGrammar9
01983  * *****************/
01984 Grammar TestGrammar9(){
01985   
01986   PushdownGenerator g1 = TestGenerator1();
01987   
01988   StackSymbolSet stackSymbols = g1.StackSymbols();
01989 
01990   std::vector<Idx> ssvSquare;
01991   ssvSquare.push_back(stackSymbols.Index("square"));
01992   
01993   //construct Terminals
01994   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
01995   GrammarSymbolPtr taPtr(ta);
01996   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
01997   GrammarSymbolPtr tbPtr(tb);
01998   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
01999   GrammarSymbolPtr tlambdaPtr(tlambda);
02000   
02001   //construct Nonterminals
02002   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
02003   GrammarSymbolPtr nt1squarePtr(nt1square);
02004 
02005   //construct GrammarProduction
02006   GrammarSymbolVector v;
02007   v.push_back(taPtr);
02008   v.push_back(nt1squarePtr);
02009   GrammarProduction gp1 = GrammarProduction(*nt1square,v);
02010   v.clear();
02011   v.push_back(tbPtr);
02012   GrammarProduction gp2 = GrammarProduction(*nt1square,v);
02013   
02014   //construct Grammar
02015   Grammar gr = Grammar();
02016   gr.InsTerminal(*ta);
02017   gr.InsTerminal(*tb);
02018   gr.InsTerminal(*tlambda);
02019   
02020   gr.SetStartSymbol(*nt1square);
02021  
02022   gr.InsGrammarProduction(gp1);
02023   gr.InsGrammarProduction(gp2);
02024   
02025   return gr;
02026 }
02027 
02028 /* *****************
02029  * TestGrammar10
02030  * *****************/
02031 Grammar TestGrammar10(){
02032   
02033   PushdownGenerator g1 = TestGenerator1();
02034   g1.InsEvent("dollar");
02035   
02036   StackSymbolSet stackSymbols = g1.StackSymbols();
02037 
02038   std::vector<Idx> ssvSquare;
02039   ssvSquare.push_back(stackSymbols.Index("square"));
02040   std::vector<Idx> ssvDot;
02041   ssvDot.push_back(stackSymbols.Index("dot"));
02042   
02043   //construct Terminals
02044   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
02045   GrammarSymbolPtr taPtr(ta);
02046   Terminal* tdollar = new Terminal(g1.Alphabet().Index("dollar"));
02047   GrammarSymbolPtr tdollarPtr(tdollar);
02048   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
02049   GrammarSymbolPtr tlambdaPtr(tlambda);
02050   
02051   //construct Nonterminals
02052   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
02053   GrammarSymbolPtr nt1squarePtr(nt1square);
02054   Nonterminal* nt1dot1 = new Nonterminal(1,ssvDot,1);
02055   GrammarSymbolPtr nt1dot1Ptr(nt1dot1);
02056 
02057   //construct GrammarProduction
02058   GrammarSymbolVector v;
02059   v.push_back(nt1dot1Ptr);
02060   v.push_back(taPtr);
02061   GrammarProduction gp1 = GrammarProduction(*nt1square,v);
02062   v.clear();
02063   v.push_back(tlambdaPtr);
02064   GrammarProduction gp2 = GrammarProduction(*nt1dot1,v);
02065   
02066   //construct Grammar
02067   Grammar gr = Grammar();
02068   gr.InsTerminal(*ta);
02069   gr.InsTerminal(*tlambda);
02070   
02071   gr.InsNonterminal(*nt1square);
02072   gr.InsNonterminal(*nt1dot1);
02073   
02074   gr.SetStartSymbol(*nt1square);
02075  
02076   gr.InsGrammarProduction(gp1);
02077   gr.InsGrammarProduction(gp2);
02078   
02079   return gr;
02080 }
02081 
02082 /* *****************
02083  * TestGrammar11
02084  * *****************/
02085 Grammar TestGrammar11(){
02086   
02087   PushdownGenerator g1 = TestGenerator1();
02088   
02089   StackSymbolSet stackSymbols = g1.StackSymbols();
02090 
02091   std::vector<Idx> ssvSquare;
02092   ssvSquare.push_back(stackSymbols.Index("square"));
02093   
02094   //construct Terminals
02095   Terminal* ta = new Terminal(g1.Alphabet().Index("a"));
02096   GrammarSymbolPtr taPtr(ta);
02097   Terminal* tb = new Terminal(g1.Alphabet().Index("b"));
02098   GrammarSymbolPtr tbPtr(tb);
02099   Terminal* tlambda = new Terminal(g1.Alphabet().Index(FAUDES_PD_LAMBDA));
02100   GrammarSymbolPtr tlambdaPtr(tlambda);
02101   
02102   //construct Nonterminals
02103   Nonterminal* nt1square = new Nonterminal(1,ssvSquare);
02104   GrammarSymbolPtr nt1squarePtr(nt1square);
02105 
02106   //construct GrammarProduction
02107   GrammarSymbolVector v;
02108   v.push_back(taPtr);
02109   v.push_back(nt1squarePtr);
02110   v.push_back(tbPtr);
02111   GrammarProduction gp1 = GrammarProduction(*nt1square,v);
02112   v.clear();
02113   v.push_back(tlambdaPtr);
02114   GrammarProduction gp2 = GrammarProduction(*nt1square,v);
02115   
02116   //construct Grammar
02117   Grammar gr = Grammar();
02118   gr.InsTerminal(*ta);
02119   gr.InsTerminal(*tb);
02120   gr.InsTerminal(*tlambda);
02121   
02122   gr.InsNonterminal(*nt1square);
02123 
02124   gr.SetStartSymbol(*nt1square);
02125  
02126   gr.InsGrammarProduction(gp1);
02127   gr.InsGrammarProduction(gp2);
02128   
02129   return gr;
02130 }
02131 
02132 
02133 
02134 
02135 void TestStart(std::string name){
02136   std::cout << "Testing " << name << " ..." <<  std::endl;
02137 }
02138 
02139 void TestEnd(std::string name){
02140   std::cout << "Finished " << name << std::endl;  
02141 }
02142 
02143 } // namespace faudes
02144 

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen