3_functions.cpp
Go to the documentation of this file.
1 /** @file 3_functions.cpp
2 
3 Tutorial, operations on genarators.
4 
5 This tutorial demonstrates the use of
6 general purpose operations on generators.
7 It also produces example output for the HTML
8 documentation.
9 
10 @ingroup Tutorials
11 
12 @include 3_functions.cpp
13 */
14 
15 
16 #include "libfaudes.h"
17 
18 
19 // make the faudes namespace available to our program
20 
21 using namespace faudes;
22 
23 
24 
25 /////////////////
26 // main program
27 /////////////////
28 
29 int main() {
30 
31 
32 
33  ////////////////////////////
34  // make deterministic
35  ////////////////////////////
36 
37 
38  // read nondeterministic generator and perform operation
39  Generator deter_nondet("data/deterministic_nondet.gen");
40  Generator deter_det;
41  Deterministic(deter_nondet, deter_det);
42  deter_det.Write("tmp_deterministic_det.gen");
43  deter_nondet.Write("tmp_deterministic_nondet.gen");
44 
45  // report result to console
46  std::cout << "################################\n";
47  std::cout << "# deterministic generator \n";
48  deter_det.DWrite();
49  std::cout << "################################\n";
50 
51 
52  // Test protocol
53  FAUDES_TEST_DUMP("deterministic",deter_det);
54 
55 
56  ////////////////////////////
57  // make minimal
58  ////////////////////////////
59 
60 
61  // read nonminimal generator and perform operation
62  Generator minimal_nonmin("data/minimal_nonmin.gen");
63  Generator minimal_min;
64  StateMin(minimal_nonmin, minimal_min);
65  minimal_nonmin.Write("tmp_minimal_nonmin.gen");
66  minimal_min.Write("tmp_minimal_min.gen");
67 
68  // report result to console
69  std::cout << "################################\n";
70  std::cout << "# minimal generator \n";
71  minimal_min.DWrite();
72  std::cout << "################################\n";
73 
74 
75  // Test protocol
76  FAUDES_TEST_DUMP("minimal",minimal_min);
77 
78  ////////////////////////////
79  // project
80  ////////////////////////////
81 
82 
83  // read generator to project
84  Generator project_g("data/project_g.gen");
85  Generator project_prog;
86  EventSet alph_proj;
87  alph_proj.Insert("a");
88  alph_proj.Insert("c");
89  alph_proj.Insert("e");
90  alph_proj.Insert("g");
91  Project(project_g, alph_proj, project_prog);
92  project_g.Write("tmp_project_g.gen");
93 
94  // tmoor 201308: minimize stateset (for html docu, purely cosmetic)
95  Generator project_prog_min;
96  project_prog_min.StateNamesEnabled(false);
97  StateMin(project_prog,project_prog_min);
98  project_prog_min.Write("tmp_project_prog.gen");
99 
100  // report result to console
101  std::cout << "################################\n";
102  std::cout << "# projected generator \n";
103  project_prog_min.DWrite();
104  std::cout << "################################\n";
105 
106  // Test protocol
107  FAUDES_TEST_DUMP("project",project_prog_min);
108 
109 
110  ////////////////////////////
111  // synchronous composition
112  ////////////////////////////
113 
114 
115  // read generators
116  Generator parallel_g1("data/parallel_g1.gen");
117  Generator parallel_g2("data/parallel_g2.gen");
118 
119  // perform composition
120  Generator parallel_g1g2;
121  Parallel(parallel_g1, parallel_g2, parallel_g1g2);
122 
123  // write result and operands for html docu
124  parallel_g1.Write("tmp_parallel_g1.gen");
125  parallel_g2.Write("tmp_parallel_g2.gen");
126  parallel_g1g2.Write("tmp_parallel_g1g2.gen");
127 
128  // read generators
129  Generator parallel_m1("data/wparallel_g1.gen");
130  Generator parallel_m2("data/wparallel_g2.gen");
131 
132  // perform composition
133  Generator parallel_m1m2;
134  Parallel(parallel_m1, parallel_m2, parallel_m1m2);
135 
136  // write result and operands for html docu
137  parallel_m1.Write("tmp_parallel_m1.gen");
138  parallel_m2.Write("tmp_parallel_m2.gen");
139  parallel_m1m2.Write("tmp_parallel_m1m2.gen");
140 
141  // read generators
142  Generator wparallel_g1("data/wparallel_g1.gen");
143  Generator wparallel_g2("data/wparallel_g2.gen");
144 
145  // perform composition
146  Generator wparallel_g1g2;
147  OmegaParallel(wparallel_g1, wparallel_g2, wparallel_g1g2);
148 
149  // write result and operands for html docu
150  wparallel_g1.Write("tmp_wparallel_g1.gen");
151  wparallel_g2.Write("tmp_wparallel_g2.gen");
152  wparallel_g1g2.Write("tmp_wparallel_g1g2.gen");
153 
154  // Test protocol
155  FAUDES_TEST_DUMP("parallel",parallel_g1g2);
156  FAUDES_TEST_DUMP("wparallel",wparallel_g1g2);
157 
158 
159  ////////////////////////////
160  // boolean language operations
161  ////////////////////////////
162 
163 
164  // read generators
165  Generator boolean_g1("data/boolean_g1.gen");
166  Generator boolean_g2("data/boolean_g2.gen");
167  Generator lequal_g1("data/lequal_g1.gen");
168  Generator lequal_g2("data/lequal_g2.gen");
169 
170  // perform union
171  Generator boolean_union;
172  boolean_union.StateNamesEnabled(false);
173  LanguageUnion(boolean_g1, boolean_g2, boolean_union);
174 
175  // perform intersection
176  Generator boolean_intersection;
177  boolean_intersection.StateNamesEnabled(false);
178  LanguageIntersection(boolean_g1, boolean_g2, boolean_intersection);
179 
180  // perform complement twice
181  Generator boolean_complement_g1=boolean_g1;
182  boolean_complement_g1.StateNamesEnabled(false);
183  LanguageComplement(boolean_complement_g1);
184  Generator boolean_complement2_g1=boolean_complement_g1;
185  LanguageComplement(boolean_complement2_g1);
186 
187  // write results and operands for html docu
188  boolean_g1.Write("tmp_boolean_g1.gen");
189  boolean_g2.Write("tmp_boolean_g2.gen");
190  boolean_union.Write("tmp_union_g1g2.gen");
191  boolean_intersection.Write("tmp_intersection_g1g2.gen");
192  boolean_complement_g1.Write("tmp_complement_g1.gen");
193  boolean_complement2_g1.Write("tmp_complement2_g1.gen");
194 
195  // inspect on console
196  std::cout << "################################\n";
197  std::cout << "# boolean language operations\n";
198  boolean_union.DWrite();
199  boolean_intersection.DWrite();
200  boolean_complement_g1.DWrite();
201  std::cout << "################################\n";
202 
203  // compare languages
204  std::cout << "################################\n";
205  std::cout << "# boolean language operations\n";
206  if(LanguageInclusion(boolean_g1,boolean_union))
207  std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): OK\n";
208  else
209  std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): ERR\n";
210  if(LanguageDisjoint(boolean_complement_g1,boolean_g1))
211  std::cout << "Lm(g1) ^ ~Lm(g1) = empty: OK\n";
212  else
213  std::cout << "(Lm(g1) v Lm(g2)) ^ ~(Lm(g1) v Lm(g2)) != empty: ERR\n";
214  if(LanguageEquality(boolean_g1,boolean_complement2_g1))
215  std::cout << "Lm(g1) = ~~Lm(g1) : OK\n";
216  else
217  std::cout << "Lm(g1) != ~~Lm(g1) : ERR\n";
218  std::cout << "################################\n";
219 
220  // compare languages (track error report, thanks)
221  std::cout << "################################\n";
222  std::cout << "# boolean language operations for empty Lm(g1)\n";
223  if(LanguageInclusion(lequal_g1,lequal_g2))
224  std::cout << "Lm(g1) <= Lm(g2): OK\n";
225  else
226  std::cout << "Lm(g1) <= Lm(g2): ERR\n";
227  if(LanguageInclusion(lequal_g2,lequal_g1))
228  std::cout << "Lm(g2) <= Lm(g1): ERR\n";
229  else
230  std::cout << "~(Lm(g2) <= Lm(g1)): OK\n";
231  bool boolean_lequal = LanguageEquality(lequal_g1,lequal_g2);
232  if(boolean_lequal)
233  std::cout << "Lm(g1) == Lm(g2): ERR\n";
234  else
235  std::cout << "Lm(g1) != Lm(g2): OK\n";
236 
237  // Record test case
238  FAUDES_TEST_DUMP("boolean union",boolean_union);
239  FAUDES_TEST_DUMP("boolean inter",boolean_intersection);
240  FAUDES_TEST_DUMP("boolean compl",boolean_complement_g1);
241  FAUDES_TEST_DUMP("boolean equal",boolean_lequal);
242 
243 
244  ////////////////////////////
245  // language difference
246  ////////////////////////////
247 
248 
249  // read generator and write for html docu
250  Generator difference_g1("data/difference_g1.gen");
251  difference_g1.Write("tmp_difference_g1.gen");
252 
253  Generator difference_g2("data/difference_g2.gen");
254  difference_g2.Write("tmp_difference_g2.gen");
255 
256  // compute language difference Lm(g1)-Lm(g2)
257 
258  Generator difference_g1minusg2;
259  LanguageDifference(difference_g1,difference_g2,difference_g1minusg2);
260  difference_g1minusg2.Write("tmp_difference_g1minusg2.gen");
261 
262  // inspect on console
263  std::cout << "################################\n";
264  std::cout << "# language difference Lm(g1)-Lm(g2) \n";
265  difference_g1minusg2.DWrite();
266  std::cout << "################################\n";
267 
268  // Record test case
269  FAUDES_TEST_DUMP("difference",difference_g1minusg2);
270 
271 
272  ////////////////////////////
273  // convert to automaton
274  ////////////////////////////
275 
276 
277  // read generator and write for html docu
278  Generator automaton_g("data/automaton_g.gen");
279  automaton_g.Write("tmp_automaton_g.gen");
280 
281  // convert to automaton
282  Automaton(automaton_g);
283  automaton_g.Write("tmp_automaton_gRes.gen");
284 
285  // inspect on console
286  std::cout << "################################\n";
287  std::cout << "# automaton from generator \n";
288  automaton_g.DWrite();
289  std::cout << "################################\n";
290 
291  // Record test case
292  FAUDES_TEST_DUMP("automaton", automaton_g);
293 
294 
295  ////////////////////////////
296  // language concatenation
297  ////////////////////////////
298 
299 
300  // read generators and write for html docu
301  Generator concat_g1("data/concat_g1.gen");
302  Generator concat_g2("data/concat_g2.gen");
303  Generator concat_g3("data/concat_g3.gen");
304  Generator concat_g4("data/concat_g4.gen");
305  Generator concat_g5("data/concat_g5.gen");
306  Generator concat_g6("data/concat_g6.gen");
307  concat_g1.Write("tmp_concat_g1.gen");
308  concat_g2.Write("tmp_concat_g2.gen");
309  concat_g3.Write("tmp_concat_g3.gen");
310  concat_g4.Write("tmp_concat_g4.gen");
311  concat_g5.Write("tmp_concat_g5.gen");
312  concat_g6.Write("tmp_concat_g6.gen");
313 
314 
315  // perform language concatenations and inspect on console
316  std::cout << "################################\n";
317  std::cout << "# language concatenation\n";
318  Generator concat;
319  concat.StateNamesEnabled(false);
320  LanguageConcatenate(concat_g1,concat_g3,concat);
321  concat.Write("tmp_concat_g1g3.gen");
322  concat.DWrite();
323  LanguageConcatenate(concat_g1,concat_g4,concat);
324  concat.Write("tmp_concat_g1g4.gen");
325  concat.DWrite();
326  LanguageConcatenate(concat_g2,concat_g3,concat);
327  concat.Write("tmp_concat_g2g3.gen");
328  concat.DWrite();
329  LanguageConcatenate(concat_g2,concat_g4,concat);
330  concat.Write("tmp_concat_g2g4.gen");
331  concat.DWrite();
332  LanguageConcatenate(concat_g5,concat_g6,concat);
333  concat.Write("tmp_concat_g5g6.gen");
334  concat.DWrite();
335  std::cout << "################################\n";
336 
337  // Record test case
338  FAUDES_TEST_DUMP("concat ", concat);
339 
340 
341  ////////////////////////////
342  // full language, alphabet language, empty string language and empty language
343  ////////////////////////////
344 
345  // create alphabet={a,b}
346  EventSet languages_alphabet;
347  languages_alphabet.Insert("a");
348  languages_alphabet.Insert("b");
349 
350  // generator for result
351  Generator languages_g;
352 
353  // construct full language from alphabet
354  FullLanguage(languages_alphabet,languages_g);
355  languages_g.Write("tmp_languagesFull_result.gen");
356 
357  // inspect on console
358  std::cout << "################################\n";
359  std::cout << "# full language \n";
360  languages_g.DWrite();
361 
362  // construct alphabet language from alphabet
363  AlphabetLanguage(languages_alphabet,languages_g);
364  languages_g.Write("tmp_languagesAlphabet_result.gen");
365  std::cout << "# alphabet language \n";
366  languages_g.DWrite();
367 
368  // construct empty string language from alphabet
369  EmptyStringLanguage(languages_alphabet,languages_g);
370  languages_g.Write("tmp_languagesEmptyString_result.gen");
371  std::cout << "# empty string language \n";
372  languages_g.DWrite();
373 
374  // construct empty language from alphabet
375  EmptyLanguage(languages_alphabet,languages_g);
376  languages_g.Write("tmp_languagesEmpty_result.gen");
377  std::cout << "# empty language \n";
378  languages_g.DWrite();
379  std::cout << "################################\n";
380 
381 
382 
383  ////////////////////////////
384  // Kleene closure
385  ////////////////////////////
386 
387 
388  // read generator and write for html docu
389  Generator kleene_g1("data/kleene_g1.gen");
390  kleene_g1.Write("tmp_kleene_g1.gen");
391 
392  // compute Kleene closure
393  kleene_g1.StateNamesEnabled(false);
394  KleeneClosure(kleene_g1);
395  kleene_g1.Write("tmp_kleene_g1Res.gen");
396 
397  // inspect on console
398  std::cout << "################################\n";
399  std::cout << "# Kleene closure \n";
400  kleene_g1.DWrite();
401  std::cout << "################################\n";
402 
403  // Record test case
404  FAUDES_TEST_DUMP("kleene closure ", kleene_g1);
405 
406 
407  // read generator and write for html docu
408  Generator kleene_g2("data/kleene_g2.gen");
409  kleene_g2.Write("tmp_kleene_g2.gen");
410 
411  // compute Kleene closure
412  kleene_g2.StateNamesEnabled(false);
413  KleeneClosureNonDet(kleene_g2);
414  kleene_g2.Write("tmp_kleene_g2Res.gen");
415 
416  // inspect on console
417  std::cout << "################################\n";
418  std::cout << "# Kleene closure \n";
419  kleene_g2.DWrite();
420  std::cout << "################################\n";
421 
422  // Record test case
423  FAUDES_TEST_DUMP("kleene closure ", kleene_g2);
424 
425  ////////////////////////////
426  // prefix closure
427  ////////////////////////////
428 
429 
430  // read generator and write for html docu
431  Generator prefixclosure_g("data/prefixclosure_g.gen");
432  prefixclosure_g.Write("tmp_prefixclosure_g.gen");
433 
434  // test prefix closure
435  bool isprefixclosed_g = IsPrefixClosed(prefixclosure_g);
436 
437  // compute prefix closure
438  PrefixClosure(prefixclosure_g);
439  prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");
440 
441  // test prefix closure
442  bool isprefixclosed_gRes = IsPrefixClosed(prefixclosure_g);
443 
444  // inspect on console
445  std::cout << "################################\n";
446  std::cout << "# prefix closure \n";
447  if(isprefixclosed_g)
448  std::cout << "# argument was prefix closed (test case error!)\n";
449  else
450  std::cout << "# argument was not prefix closed (expected)\n";
451  if(isprefixclosed_gRes)
452  std::cout << "# result is prefix closed (expected)\n";
453  else
454  std::cout << "# result is not prefix closed (test case error!)\n";
455  prefixclosure_g.DWrite();
456  std::cout << "################################\n";
457 
458  // Record test case
459  FAUDES_TEST_DUMP("prefix closure", prefixclosure_g);
460 
461 
462  ////////////////////////////
463  // omega closure
464  ////////////////////////////
465 
466 
467  // read generator and write for html docu
468  Generator omegaclosure_g("data/omegaclosure_g.gen");
469  omegaclosure_g.Write("tmp_omegaclosure_g.gen");
470 
471  // test omega closure
472  bool isomegaclosed_g = IsOmegaClosed(omegaclosure_g);
473 
474  // compute omega closure
475  OmegaClosure(omegaclosure_g);
476  omegaclosure_g.Write("tmp_omegaclosure_gRes.gen");
477 
478  // test omega closure
479  bool isomegaclosed_gRes = IsOmegaClosed(omegaclosure_g);
480 
481  // inspect on console
482  std::cout << "################################\n";
483  std::cout << "# omega closure \n";
484  if(isomegaclosed_g)
485  std::cout << "# argument was omega closed (test case error!)\n";
486  else
487  std::cout << "# argument was not omega closed (expected)\n";
488  if(isomegaclosed_gRes)
489  std::cout << "# result is omega closed (expected)\n";
490  else
491  std::cout << "# result is not omega closed (test case error!)\n";
492  omegaclosure_g.DWrite();
493  std::cout << "################################\n";
494 
495  // Record test case
496  FAUDES_TEST_DUMP("omega closure", omegaclosure_g);
497 
498 
499  ////////////////////////////
500  // selfloop
501  ////////////////////////////
502 
503 
504  // read generator and write for html docu
505  Generator selfloop_g("data/selfloop_g.gen");
506  selfloop_g.Write("tmp_selfloop_g.gen");
507 
508  // create alphabet={e,f}
509  EventSet selfloop_alphabet;
510  selfloop_alphabet.Insert("e");
511  selfloop_alphabet.Insert("f");
512 
513  // generator for result
514  Generator selfloop_gRes=selfloop_g;
515 
516  // add selfloops in each state
517  SelfLoop(selfloop_gRes,selfloop_alphabet);
518  selfloop_gRes.Write("tmp_selfloop_gRes.gen");
519 
520  // inspect on console
521  std::cout << "################################\n";
522  std::cout << "# selfloop, each state \n";
523  selfloop_gRes.DWrite();
524 
525  // add selfloops in marked states
526  selfloop_gRes=selfloop_g;
527  SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
528  selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
529  std::cout << "# selfloop, marked states \n";
530  selfloop_gRes.DWrite();
531 
532  // add selfloops in inital state(s)
533  selfloop_gRes=selfloop_g;
534  SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
535  selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
536  std::cout << "# selfloop, init state(s) \n";
537  selfloop_gRes.DWrite();
538  std::cout << "################################\n";
539 
540 
541  ////////////////////////////
542  // nonconflicting
543  ////////////////////////////
544 
545  // under construction --
546 
547  std::cout << "################################\n";
548  std::cout << "# non-blocking test \n";
549 
550 
551  std::cout << "# conflict equiv. abstract test 1 \n";
552  Generator nonblocking_g;
553  EventSet silent;
554  silent.Insert("tau");
555  nonblocking_g.Read("data/noblo_gae2.gen");
556  ConflictEquivalentAbstraction(nonblocking_g,silent);
557  nonblocking_g.Write();
558 
559  FAUDES_TEST_DUMP("nonblocking 0", nonblocking_g);
560 
561  // test cases from Michael Meyer's thesis
562  // Nonblocking: (1,2,3,6,7); (1,2,3,4,5,6,7); (1,2,3,4,5,6); (2,4,6,8); (2,3,4,5); (5,6,7,8,9)
563  // Blocking: (3,4,5,6,7); (1,3,5,7)
564 
565  // read generators from file
566  GeneratorVector nonblocking_gv;
567  nonblocking_gv.PushBack("data/noblo_g2.gen");
568  nonblocking_gv.PushBack("data/noblo_g3.gen");
569  nonblocking_gv.PushBack("data/noblo_g4.gen");
570  nonblocking_gv.PushBack("data/noblo_g5.gen");
571  // test for conflicts
572  std::cout << "# non-blocking exec test 1\n";
573  bool nonblocking_ok1;
574  nonblocking_ok1=IsNonblocking(nonblocking_gv);
575  if(nonblocking_ok1)
576  std::cout << "# non-blocking test: passed (expected)\n";
577  else
578  std::cout << "# non-blocking test: failed (test case error!)\n";
579 
580  FAUDES_TEST_DUMP("nonblocking 1", nonblocking_ok1);
581 
582  // read generators from file
583  nonblocking_gv.Clear();
584  nonblocking_gv.PushBack("data/noblo_g5.gen");
585  nonblocking_gv.PushBack("data/noblo_g6.gen");
586  nonblocking_gv.PushBack("data/noblo_g7.gen");
587  nonblocking_gv.PushBack("data/noblo_g8.gen");
588  nonblocking_gv.PushBack("data/noblo_g9.gen");
589  // test for conflicts
590  std::cout << "# non-blocking exec test 2\n";
591  bool nonblocking_ok2;
592  nonblocking_ok2=IsNonblocking(nonblocking_gv);
593  if(nonblocking_ok2)
594  std::cout << "# non-blocking test: passed (expected)\n";
595  else
596  std::cout << "# non-blocking test: failed (test case error!)\n";
597 
598  FAUDES_TEST_DUMP("nonblocking 2", nonblocking_ok2);
599 
600  // read generators from file
601  nonblocking_gv.Clear();
602  nonblocking_gv.PushBack("data/noblo_g3.gen");
603  nonblocking_gv.PushBack("data/noblo_g4.gen");
604  nonblocking_gv.PushBack("data/noblo_g5.gen");
605  nonblocking_gv.PushBack("data/noblo_g6.gen");
606  nonblocking_gv.PushBack("data/noblo_g7.gen");
607  // test for conflicts
608  std::cout << "# non-blocking exec test 3\n";
609  bool nonblocking_ok3;
610  nonblocking_ok3=IsNonblocking(nonblocking_gv);
611  if(nonblocking_ok3)
612  std::cout << "# non-blocking test: passed (test case error!)\n";
613  else
614  std::cout << "# non-blocking test: failed (expected)\n";
615 
616  FAUDES_TEST_DUMP("nonblocking 3", nonblocking_ok3);
617 
618  // read generators from file
619  nonblocking_gv.Clear();
620  nonblocking_gv.PushBack("data/noblo_g1.gen");
621  nonblocking_gv.PushBack("data/noblo_g3.gen");
622  nonblocking_gv.PushBack("data/noblo_g5.gen");
623  nonblocking_gv.PushBack("data/noblo_g7.gen");
624  // test for conflicts
625  std::cout << "# non-blocking exec test 4\n";
626  bool nonblocking_ok4;
627  nonblocking_ok4=IsNonblocking(nonblocking_gv);
628  if(nonblocking_ok4)
629  std::cout << "# non-blocking test: passed (test case error!)\n";
630  else
631  std::cout << "# non-blocking test: failed (expected)\n";
632 
633  FAUDES_TEST_DUMP("nonblocking 4", nonblocking_ok4);
634 
635  // read generators from file
636  nonblocking_gv.Clear();
637  nonblocking_gv.PushBack("data/noblo_g1.gen");
638  nonblocking_gv.PushBack("data/noblo_g2.gen");
639  nonblocking_gv.PushBack("data/noblo_g3.gen");
640  nonblocking_gv.PushBack("data/noblo_g6.gen");
641  nonblocking_gv.PushBack("data/noblo_g7.gen");
642  // test for conflicts
643  std::cout << "# non-blocking exec test 5\n";
644  bool nonblocking_ok5;
645  nonblocking_ok5=IsNonblocking(nonblocking_gv);
646  if(nonblocking_ok5)
647  std::cout << "# non-blocking test: passed (expected)\n";
648  else
649  std::cout << "# non-blocking test: failed (test case error!)\n";
650 
651  // read generators from file
652  nonblocking_gv.Clear();
653  nonblocking_gv.PushBack("data/noblo_g1.gen");
654  nonblocking_gv.PushBack("data/noblo_g2.gen");
655  nonblocking_gv.PushBack("data/noblo_g3.gen");
656  nonblocking_gv.PushBack("data/noblo_g4.gen");
657  nonblocking_gv.PushBack("data/noblo_g5.gen");
658  nonblocking_gv.PushBack("data/noblo_g6.gen");
659  nonblocking_gv.PushBack("data/noblo_g7.gen");
660  // test for conflicts
661  std::cout << "# non-blocking exec test 6\n";
662  bool nonblocking_ok6;
663  nonblocking_ok6=IsNonblocking(nonblocking_gv);
664  if(nonblocking_ok6)
665  std::cout << "# non-blocking test: passed (expected)\n";
666  else
667  std::cout << "# non-blocking test: failed (test case error!)\n";
668 
669  // read generators from file
670  nonblocking_gv.Clear();
671  nonblocking_gv.PushBack("data/noblo_g1.gen");
672  nonblocking_gv.PushBack("data/noblo_g2.gen");
673  nonblocking_gv.PushBack("data/noblo_g3.gen");
674  nonblocking_gv.PushBack("data/noblo_g4.gen");
675  nonblocking_gv.PushBack("data/noblo_g5.gen");
676  nonblocking_gv.PushBack("data/noblo_g6.gen");
677  // test for conflicts
678  std::cout << "# non-blocking exec test 7\n";
679  bool nonblocking_ok7;
680  nonblocking_ok7=IsNonblocking(nonblocking_gv);
681  if(nonblocking_ok7)
682  std::cout << "# non-blocking test: passed (expected)\n";
683  else
684  std::cout << "# non-blocking test: failed (test case error!)\n";
685 
686  // read generators from file
687  nonblocking_gv.Clear();
688  nonblocking_gv.PushBack("data/noblo_g2.gen");
689  nonblocking_gv.PushBack("data/noblo_g4.gen");
690  nonblocking_gv.PushBack("data/noblo_g6.gen");
691  nonblocking_gv.PushBack("data/noblo_g8.gen");
692  // test for conflicts
693  std::cout << "# non-blocking exec test 8\n";
694  bool nonblocking_ok8;
695  nonblocking_ok8=IsNonblocking(nonblocking_gv);
696  if(nonblocking_ok8)
697  std::cout << "# non-blocking test: passed (expected)\n";
698  else
699  std::cout << "# non-blocking test: failed (test case error!)\n";
700 
701 
702  // test cases from Yiheng Tang (blocking)
703  nonblocking_gv.Clear();
704  nonblocking_gv.PushBack("data/noblo_yt1.gen");
705  nonblocking_gv.PushBack("data/noblo_yt2.gen");
706 
707  // test for conflicts A
708  std::cout << "# non-blocking exec test 9a\n";
709  Generator parallel12;
710  Parallel(nonblocking_gv.At(0),nonblocking_gv.At(1),parallel12);
711  bool nonblocking_ok9;
712  nonblocking_ok9=parallel12.BlockingStates().Size()==0;
713  if(nonblocking_ok9)
714  std::cout << "# non-blocking test: passed (test case error!)\n";
715  else
716  std::cout << "# non-blocking test: failed (expected)\n";
717 
718  FAUDES_TEST_DUMP("nonblocking 9a", nonblocking_ok9);
719 
720  // test for conflicts B
721  std::cout << "# non-blocking exec test 9b\n";
722  nonblocking_ok9=IsNonblocking(nonblocking_gv);
723  if(nonblocking_ok9)
724  std::cout << "# non-blocking test: passed (test case error!)\n";
725  else
726  std::cout << "# non-blocking test: failed (expected)\n";
727 
728  FAUDES_TEST_DUMP("nonblocking 9b", nonblocking_ok9);
729 
730 
731  FAUDES_TEST_DIFF()
732 
733  // say good bye
734  std::cout << "done.\n";
735  return 0;
736 }
737 
738 
739 
main
int main()
Definition: 3_functions.cpp:29
FAUDES_TEST_DIFF
#define FAUDES_TEST_DIFF()
Definition: cfl_utils.h:495
FAUDES_TEST_DUMP
#define FAUDES_TEST_DUMP(mes, dat)
Definition: cfl_utils.h:485
faudes::NameSet::Insert
bool Insert(const Idx &rIndex)
Definition: cfl_nameset.cpp:259
faudes::TBaseVector::At
virtual const T & At(const Position &pos) const
Definition: cfl_basevector.h:769
faudes::Type::DWrite
void DWrite(const Type *pContext=0) const
Definition: cfl_types.cpp:226
faudes::Type::Read
void Read(const std::string &rFileName, const std::string &rLabel="", const Type *pContext=0)
Definition: cfl_types.cpp:262
faudes::Type::Write
void Write(const Type *pContext=0) const
Definition: cfl_types.cpp:140
faudes::vBaseVector::PushBack
virtual void PushBack(const Type &rElem)
Definition: cfl_basevector.cpp:343
faudes::vBaseVector::Clear
virtual void Clear(void)
Definition: cfl_basevector.cpp:127
faudes::vGenerator::InitStates
const StateSet & InitStates(void) const
Definition: cfl_generator.cpp:1908
faudes::vGenerator::BlockingStates
StateSet BlockingStates(void) const
Definition: cfl_generator.cpp:2148
faudes::vGenerator::StateNamesEnabled
bool StateNamesEnabled(void) const
Definition: cfl_generator.cpp:999
faudes::TBaseSet::Size
Idx Size(void) const
Definition: cfl_baseset.h:1836
faudes::ConflictEquivalentAbstraction
void ConflictEquivalentAbstraction(vGenerator &rGen, EventSet &rSilentEvents)
Definition: cfl_conflequiv.cpp:611
faudes::StateMin
void StateMin(const Generator &rGen, Generator &rResGen)
Definition: cfl_statemin.cpp:625
faudes::FullLanguage
void FullLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:699
faudes::LanguageUnion
void LanguageUnion(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:127
faudes::SelfLoop
void SelfLoop(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:1018
faudes::LanguageDisjoint
bool LanguageDisjoint(const Generator &rGen1, const Generator &rGen2)
Definition: cfl_regular.cpp:332
faudes::LanguageInclusion
bool LanguageInclusion(const Generator &rGen1, const Generator &rGen2)
Definition: cfl_regular.cpp:830
faudes::KleeneClosure
void KleeneClosure(Generator &rGen)
Definition: cfl_regular.cpp:853
faudes::PrefixClosure
void PrefixClosure(Generator &rGen)
Definition: cfl_regular.cpp:965
faudes::Deterministic
void Deterministic(const Generator &rGen, Generator &rResGen)
Definition: cfl_determin.cpp:68
faudes::Automaton
void Automaton(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:339
faudes::IsOmegaClosed
bool IsOmegaClosed(const Generator &rGen)
Definition: cfl_omega.cpp:488
faudes::AlphabetLanguage
void AlphabetLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:733
faudes::OmegaParallel
void OmegaParallel(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_omega.cpp:261
faudes::OmegaClosure
void OmegaClosure(Generator &rGen)
Definition: cfl_omega.cpp:470
faudes::LanguageConcatenate
void LanguageConcatenate(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:678
faudes::LanguageEquality
bool LanguageEquality(const Generator &rGen1, const Generator &rGen2)
Definition: cfl_regular.cpp:844
faudes::LanguageDifference
void LanguageDifference(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:522
faudes::LanguageIntersection
void LanguageIntersection(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:188
faudes::IsPrefixClosed
bool IsPrefixClosed(const Generator &rGen)
Definition: cfl_regular.cpp:984
faudes::Project
void Project(const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
Definition: cfl_project.cpp:1349
faudes::EmptyLanguage
void EmptyLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:804
faudes::Parallel
void Parallel(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_parallel.cpp:33
faudes::LanguageComplement
void LanguageComplement(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:477
faudes::EmptyStringLanguage
void EmptyStringLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:775
faudes::KleeneClosureNonDet
void KleeneClosureNonDet(Generator &rGen)
Definition: cfl_regular.cpp:907
faudes::SelfLoopMarkedStates
void SelfLoopMarkedStates(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:1045
faudes::IsNonblocking
bool IsNonblocking(const GeneratorVector &rGvec)
Definition: cfl_conflequiv.cpp:705

libFAUDES 2.33b --- 2025.05.07 --- c++ api documentaion by doxygen

>>