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  // Test protocol
146  FAUDES_TEST_DUMP("parallel",parallel_g1g2);
147 
148 
149  ////////////////////////////
150  // boolean language operations
151  ////////////////////////////
152 
153 
154  // read generators
155  Generator boolean_g1("data/boolean_g1.gen");
156  Generator boolean_g2("data/boolean_g2.gen");
157  Generator lequal_g1("data/lequal_g1.gen");
158  Generator lequal_g2("data/lequal_g2.gen");
159 
160  // perform union
161  Generator boolean_union;
162  boolean_union.StateNamesEnabled(false);
163  LanguageUnion(boolean_g1, boolean_g2, boolean_union);
164 
165  // perform intersection
166  Generator boolean_intersection;
167  boolean_intersection.StateNamesEnabled(false);
168  LanguageIntersection(boolean_g1, boolean_g2, boolean_intersection);
169 
170  // perform complement twice
171  Generator boolean_complement_g1=boolean_g1;
172  boolean_complement_g1.StateNamesEnabled(false);
173  LanguageComplement(boolean_complement_g1);
174  Generator boolean_complement2_g1=boolean_complement_g1;
175  LanguageComplement(boolean_complement2_g1);
176 
177  // write results and operands for html docu
178  boolean_g1.Write("tmp_boolean_g1.gen");
179  boolean_g2.Write("tmp_boolean_g2.gen");
180  boolean_union.Write("tmp_union_g1g2.gen");
181  boolean_intersection.Write("tmp_intersection_g1g2.gen");
182  boolean_complement_g1.Write("tmp_complement_g1.gen");
183  boolean_complement2_g1.Write("tmp_complement2_g1.gen");
184 
185  // inspect on console
186  std::cout << "################################\n";
187  std::cout << "# boolean language operations\n";
188  boolean_union.DWrite();
189  boolean_intersection.DWrite();
190  boolean_complement_g1.DWrite();
191  std::cout << "################################\n";
192 
193  // compare languages
194  std::cout << "################################\n";
195  std::cout << "# boolean language operations\n";
196  if(LanguageInclusion(boolean_g1,boolean_union))
197  std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): OK\n";
198  else
199  std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): ERR\n";
200  if(LanguageDisjoint(boolean_complement_g1,boolean_g1))
201  std::cout << "Lm(g1) ^ ~Lm(g1) = empty: OK\n";
202  else
203  std::cout << "(Lm(g1) v Lm(g2)) ^ ~(Lm(g1) v Lm(g2)) != empty: ERR\n";
204  if(LanguageEquality(boolean_g1,boolean_complement2_g1))
205  std::cout << "Lm(g1) = ~~Lm(g1) : OK\n";
206  else
207  std::cout << "Lm(g1) != ~~Lm(g1) : ERR\n";
208  std::cout << "################################\n";
209 
210  // compare languages (track error report, thanks)
211  std::cout << "################################\n";
212  std::cout << "# boolean language operations for empty Lm(g1)\n";
213  if(LanguageInclusion(lequal_g1,lequal_g2))
214  std::cout << "Lm(g1) <= Lm(g2): OK\n";
215  else
216  std::cout << "Lm(g1) <= Lm(g2): ERR\n";
217  if(LanguageInclusion(lequal_g2,lequal_g1))
218  std::cout << "Lm(g2) <= Lm(g1): ERR\n";
219  else
220  std::cout << "~(Lm(g2) <= Lm(g1)): OK\n";
221  bool boolean_lequal = LanguageEquality(lequal_g1,lequal_g2);
222  if(boolean_lequal)
223  std::cout << "Lm(g1) == Lm(g2): ERR\n";
224  else
225  std::cout << "Lm(g1) != Lm(g2): OK\n";
226 
227  // Record test case
228  FAUDES_TEST_DUMP("boolean union",boolean_union);
229  FAUDES_TEST_DUMP("boolean inter",boolean_intersection);
230  FAUDES_TEST_DUMP("boolean compl",boolean_complement_g1);
231  FAUDES_TEST_DUMP("boolean equal",boolean_lequal);
232 
233 
234  ////////////////////////////
235  // language difference
236  ////////////////////////////
237 
238 
239  // read generator and write for html docu
240  Generator difference_g1("data/difference_g1.gen");
241  difference_g1.Write("tmp_difference_g1.gen");
242 
243  Generator difference_g2("data/difference_g2.gen");
244  difference_g2.Write("tmp_difference_g2.gen");
245 
246  // compute language difference Lm(g1)-Lm(g2)
247 
248  Generator difference_g1minusg2;
249  LanguageDifference(difference_g1,difference_g2,difference_g1minusg2);
250  difference_g1minusg2.Write("tmp_difference_g1minusg2.gen");
251 
252  // inspect on console
253  std::cout << "################################\n";
254  std::cout << "# language difference Lm(g1)-Lm(g2) \n";
255  difference_g1minusg2.DWrite();
256  std::cout << "################################\n";
257 
258  // Record test case
259  FAUDES_TEST_DUMP("difference",difference_g1minusg2);
260 
261 
262  ////////////////////////////
263  // convert to automaton
264  ////////////////////////////
265 
266 
267  // read generator and write for html docu
268  Generator automaton_g("data/automaton_g.gen");
269  automaton_g.Write("tmp_automaton_g.gen");
270 
271  // convert to automaton
272  Automaton(automaton_g);
273  automaton_g.Write("tmp_automaton_gRes.gen");
274 
275  // inspect on console
276  std::cout << "################################\n";
277  std::cout << "# automaton from generator \n";
278  automaton_g.DWrite();
279  std::cout << "################################\n";
280 
281  // Record test case
282  FAUDES_TEST_DUMP("automaton", automaton_g);
283 
284 
285  ////////////////////////////
286  // language concatenation
287  ////////////////////////////
288 
289 
290  // read generators and write for html docu
291  Generator concat_g1("data/concat_g1.gen");
292  Generator concat_g2("data/concat_g2.gen");
293  Generator concat_g3("data/concat_g3.gen");
294  Generator concat_g4("data/concat_g4.gen");
295  Generator concat_g5("data/concat_g5.gen");
296  Generator concat_g6("data/concat_g6.gen");
297  concat_g1.Write("tmp_concat_g1.gen");
298  concat_g2.Write("tmp_concat_g2.gen");
299  concat_g3.Write("tmp_concat_g3.gen");
300  concat_g4.Write("tmp_concat_g4.gen");
301  concat_g5.Write("tmp_concat_g5.gen");
302  concat_g6.Write("tmp_concat_g6.gen");
303 
304 
305  // perform language concatenations and inspect on console
306  std::cout << "################################\n";
307  std::cout << "# language concatenation\n";
308  Generator concat;
309  concat.StateNamesEnabled(false);
310  LanguageConcatenate(concat_g1,concat_g3,concat);
311  concat.Write("tmp_concat_g1g3.gen");
312  concat.DWrite();
313  LanguageConcatenate(concat_g1,concat_g4,concat);
314  concat.Write("tmp_concat_g1g4.gen");
315  concat.DWrite();
316  LanguageConcatenate(concat_g2,concat_g3,concat);
317  concat.Write("tmp_concat_g2g3.gen");
318  concat.DWrite();
319  LanguageConcatenate(concat_g2,concat_g4,concat);
320  concat.Write("tmp_concat_g2g4.gen");
321  concat.DWrite();
322  LanguageConcatenate(concat_g5,concat_g6,concat);
323  concat.Write("tmp_concat_g5g6.gen");
324  concat.DWrite();
325  std::cout << "################################\n";
326 
327  // Record test case
328  FAUDES_TEST_DUMP("concat ", concat);
329 
330 
331  ////////////////////////////
332  // full language, alphabet language, empty string language and empty language
333  ////////////////////////////
334 
335  // create alphabet={a,b}
336  EventSet languages_alphabet;
337  languages_alphabet.Insert("a");
338  languages_alphabet.Insert("b");
339 
340  // generator for result
341  Generator languages_g;
342 
343  // construct full language from alphabet
344  FullLanguage(languages_alphabet,languages_g);
345  languages_g.Write("tmp_languagesFull_result.gen");
346 
347  // inspect on console
348  std::cout << "################################\n";
349  std::cout << "# full language \n";
350  languages_g.DWrite();
351 
352  // construct alphabet language from alphabet
353  AlphabetLanguage(languages_alphabet,languages_g);
354  languages_g.Write("tmp_languagesAlphabet_result.gen");
355  std::cout << "# alphabet language \n";
356  languages_g.DWrite();
357 
358  // construct empty string language from alphabet
359  EmptyStringLanguage(languages_alphabet,languages_g);
360  languages_g.Write("tmp_languagesEmptyString_result.gen");
361  std::cout << "# empty string language \n";
362  languages_g.DWrite();
363 
364  // construct empty language from alphabet
365  EmptyLanguage(languages_alphabet,languages_g);
366  languages_g.Write("tmp_languagesEmpty_result.gen");
367  std::cout << "# empty language \n";
368  languages_g.DWrite();
369  std::cout << "################################\n";
370 
371 
372 
373  ////////////////////////////
374  // Kleene closure
375  ////////////////////////////
376 
377 
378  // read generator and write for html docu
379  Generator kleene_g1("data/kleene_g1.gen");
380  kleene_g1.Write("tmp_kleene_g1.gen");
381 
382  // compute Kleene closure
383  kleene_g1.StateNamesEnabled(false);
384  KleeneClosure(kleene_g1);
385  kleene_g1.Write("tmp_kleene_g1Res.gen");
386 
387  // inspect on console
388  std::cout << "################################\n";
389  std::cout << "# Kleene closure \n";
390  kleene_g1.DWrite();
391  std::cout << "################################\n";
392 
393  // Record test case
394  FAUDES_TEST_DUMP("kleene closure ", kleene_g1);
395 
396 
397  // read generator and write for html docu
398  Generator kleene_g2("data/kleene_g2.gen");
399  kleene_g2.Write("tmp_kleene_g2.gen");
400 
401  // compute Kleene closure
402  kleene_g2.StateNamesEnabled(false);
403  KleeneClosureNonDet(kleene_g2);
404  kleene_g2.Write("tmp_kleene_g2Res.gen");
405 
406  // inspect on console
407  std::cout << "################################\n";
408  std::cout << "# Kleene closure \n";
409  kleene_g2.DWrite();
410  std::cout << "################################\n";
411 
412  // Record test case
413  FAUDES_TEST_DUMP("kleene closure ", kleene_g2);
414 
415  ////////////////////////////
416  // prefix closure
417  ////////////////////////////
418 
419 
420  // read generator and write for html docu
421  Generator prefixclosure_g("data/prefixclosure_g.gen");
422  prefixclosure_g.Write("tmp_prefixclosure_g.gen");
423 
424  // test prefix closure
425  bool isprefixclosed_g = IsClosed(prefixclosure_g);
426 
427  // compute prefix closure
428  PrefixClosure(prefixclosure_g);
429  prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");
430 
431  // test prefix closure
432  bool isprefixclosed_gRes = IsClosed(prefixclosure_g);
433 
434  // inspect on console
435  std::cout << "################################\n";
436  std::cout << "# prefix closure \n";
437  if(isprefixclosed_g)
438  std::cout << "# argument was prefix closed (test case error!)\n";
439  else
440  std::cout << "# argument was not prefix closed (expected)\n";
441  if(isprefixclosed_gRes)
442  std::cout << "# result is prefix closed (expected)\n";
443  else
444  std::cout << "# result is not prefix closed (test case error!)\n";
445  prefixclosure_g.DWrite();
446  std::cout << "################################\n";
447 
448  // Record test case
449  FAUDES_TEST_DUMP("prefix closure", prefixclosure_g);
450 
451 
452  ////////////////////////////
453  // selfloop
454  ////////////////////////////
455 
456 
457  // read generator and write for html docu
458  Generator selfloop_g("data/selfloop_g.gen");
459  selfloop_g.Write("tmp_selfloop_g.gen");
460 
461  // create alphabet={e,f}
462  EventSet selfloop_alphabet;
463  selfloop_alphabet.Insert("e");
464  selfloop_alphabet.Insert("f");
465 
466  // generator for result
467  Generator selfloop_gRes=selfloop_g;
468 
469  // add selfloops in each state
470  SelfLoop(selfloop_gRes,selfloop_alphabet);
471  selfloop_gRes.Write("tmp_selfloop_gRes.gen");
472 
473  // inspect on console
474  std::cout << "################################\n";
475  std::cout << "# selfloop, each state \n";
476  selfloop_gRes.DWrite();
477 
478  // add selfloops in marked states
479  selfloop_gRes=selfloop_g;
480  SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
481  selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
482  std::cout << "# selfloop, marked states \n";
483  selfloop_gRes.DWrite();
484 
485  // add selfloops in inital state(s)
486  selfloop_gRes=selfloop_g;
487  SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
488  selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
489  std::cout << "# selfloop, init state(s) \n";
490  selfloop_gRes.DWrite();
491  std::cout << "################################\n";
492 
493 
494  ////////////////////////////
495  // nonconflicting
496  ////////////////////////////
497 
498  // under construction --
499 
500  std::cout << "################################\n";
501  std::cout << "# non-blocking test \n";
502 
503 
504  std::cout << "# conflict equiv. abstract test 1 \n";
505  Generator nonblocking_g;
506  EventSet silent;
507  silent.Insert("tau");
508  nonblocking_g.Read("data/noblo_gae2.gen");
509  ConflictEquivalentAbstraction(nonblocking_g,silent);
510  nonblocking_g.Write();
511 
512  FAUDES_TEST_DUMP("nonblocking 0", nonblocking_g);
513 
514  // test cases from Michael Meyer's thesis
515  // 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)
516  // Blocking: (3,4,5,6,7); (1,3,5,7)
517 
518  // read generators from file
519  GeneratorVector nonblocking_gv;
520  nonblocking_gv.PushBack("data/noblo_g2.gen");
521  nonblocking_gv.PushBack("data/noblo_g3.gen");
522  nonblocking_gv.PushBack("data/noblo_g4.gen");
523  nonblocking_gv.PushBack("data/noblo_g5.gen");
524  // test for conflicts
525  std::cout << "# non-blocking exec test 1\n";
526  bool nonblocking_ok1;
527  nonblocking_ok1=IsNonblocking(nonblocking_gv);
528  if(nonblocking_ok1)
529  std::cout << "# non-blocking test: passed (expected)\n";
530  else
531  std::cout << "# non-blocking test: failed (test case error!)\n";
532 
533  FAUDES_TEST_DUMP("nonblocking 1", nonblocking_ok1);
534 
535  // read generators from file
536  nonblocking_gv.Clear();
537  nonblocking_gv.PushBack("data/noblo_g5.gen");
538  nonblocking_gv.PushBack("data/noblo_g6.gen");
539  nonblocking_gv.PushBack("data/noblo_g7.gen");
540  nonblocking_gv.PushBack("data/noblo_g8.gen");
541  nonblocking_gv.PushBack("data/noblo_g9.gen");
542  // test for conflicts
543  std::cout << "# non-blocking exec test 2\n";
544  bool nonblocking_ok2;
545  nonblocking_ok2=IsNonblocking(nonblocking_gv);
546  if(nonblocking_ok2)
547  std::cout << "# non-blocking test: passed (expected)\n";
548  else
549  std::cout << "# non-blocking test: failed (test case error!)\n";
550 
551  FAUDES_TEST_DUMP("nonblocking 2", nonblocking_ok2);
552 
553  // read generators from file
554  nonblocking_gv.Clear();
555  nonblocking_gv.PushBack("data/noblo_g3.gen");
556  nonblocking_gv.PushBack("data/noblo_g4.gen");
557  nonblocking_gv.PushBack("data/noblo_g5.gen");
558  nonblocking_gv.PushBack("data/noblo_g6.gen");
559  nonblocking_gv.PushBack("data/noblo_g7.gen");
560  // test for conflicts
561  std::cout << "# non-blocking exec test 3\n";
562  bool nonblocking_ok3;
563  nonblocking_ok3=IsNonblocking(nonblocking_gv);
564  if(nonblocking_ok3)
565  std::cout << "# non-blocking test: passed (test case error!)\n";
566  else
567  std::cout << "# non-blocking test: failed (expected)\n";
568 
569  FAUDES_TEST_DUMP("nonblocking 3", nonblocking_ok3);
570 
571  // read generators from file
572  nonblocking_gv.Clear();
573  nonblocking_gv.PushBack("data/noblo_g1.gen");
574  nonblocking_gv.PushBack("data/noblo_g3.gen");
575  nonblocking_gv.PushBack("data/noblo_g5.gen");
576  nonblocking_gv.PushBack("data/noblo_g7.gen");
577  // test for conflicts
578  std::cout << "# non-blocking exec test 4\n";
579  bool nonblocking_ok4;
580  nonblocking_ok4=IsNonblocking(nonblocking_gv);
581  if(nonblocking_ok4)
582  std::cout << "# non-blocking test: passed (test case error!)\n";
583  else
584  std::cout << "# non-blocking test: failed (expected)\n";
585 
586  FAUDES_TEST_DUMP("nonblocking 4", nonblocking_ok4);
587 
588  // read generators from file
589  nonblocking_gv.Clear();
590  nonblocking_gv.PushBack("data/noblo_g1.gen");
591  nonblocking_gv.PushBack("data/noblo_g2.gen");
592  nonblocking_gv.PushBack("data/noblo_g3.gen");
593  nonblocking_gv.PushBack("data/noblo_g6.gen");
594  nonblocking_gv.PushBack("data/noblo_g7.gen");
595  // test for conflicts
596  std::cout << "# non-blocking exec test 5\n";
597  bool nonblocking_ok5;
598  nonblocking_ok5=IsNonblocking(nonblocking_gv);
599  if(nonblocking_ok5)
600  std::cout << "# non-blocking test: passed (expected)\n";
601  else
602  std::cout << "# non-blocking test: failed (test case error!)\n";
603 
604  // read generators from file
605  nonblocking_gv.Clear();
606  nonblocking_gv.PushBack("data/noblo_g1.gen");
607  nonblocking_gv.PushBack("data/noblo_g2.gen");
608  nonblocking_gv.PushBack("data/noblo_g3.gen");
609  nonblocking_gv.PushBack("data/noblo_g4.gen");
610  nonblocking_gv.PushBack("data/noblo_g5.gen");
611  nonblocking_gv.PushBack("data/noblo_g6.gen");
612  nonblocking_gv.PushBack("data/noblo_g7.gen");
613  // test for conflicts
614  std::cout << "# non-blocking exec test 6\n";
615  bool nonblocking_ok6;
616  nonblocking_ok6=IsNonblocking(nonblocking_gv);
617  if(nonblocking_ok6)
618  std::cout << "# non-blocking test: passed (expected)\n";
619  else
620  std::cout << "# non-blocking test: failed (test case error!)\n";
621 
622  // read generators from file
623  nonblocking_gv.Clear();
624  nonblocking_gv.PushBack("data/noblo_g1.gen");
625  nonblocking_gv.PushBack("data/noblo_g2.gen");
626  nonblocking_gv.PushBack("data/noblo_g3.gen");
627  nonblocking_gv.PushBack("data/noblo_g4.gen");
628  nonblocking_gv.PushBack("data/noblo_g5.gen");
629  nonblocking_gv.PushBack("data/noblo_g6.gen");
630  // test for conflicts
631  std::cout << "# non-blocking exec test 7\n";
632  bool nonblocking_ok7;
633  nonblocking_ok7=IsNonblocking(nonblocking_gv);
634  if(nonblocking_ok7)
635  std::cout << "# non-blocking test: passed (expected)\n";
636  else
637  std::cout << "# non-blocking test: failed (test case error!)\n";
638 
639  // read generators from file
640  nonblocking_gv.Clear();
641  nonblocking_gv.PushBack("data/noblo_g2.gen");
642  nonblocking_gv.PushBack("data/noblo_g4.gen");
643  nonblocking_gv.PushBack("data/noblo_g6.gen");
644  nonblocking_gv.PushBack("data/noblo_g8.gen");
645  // test for conflicts
646  std::cout << "# non-blocking exec test 8\n";
647  bool nonblocking_ok8;
648  nonblocking_ok8=IsNonblocking(nonblocking_gv);
649  if(nonblocking_ok8)
650  std::cout << "# non-blocking test: passed (expected)\n";
651  else
652  std::cout << "# non-blocking test: failed (test case error!)\n";
653 
654 
655  // test cases from Yiheng Tang (blocking)
656  nonblocking_gv.Clear();
657  nonblocking_gv.PushBack("data/noblo_yt1.gen");
658  nonblocking_gv.PushBack("data/noblo_yt2.gen");
659 
660  // test for conflicts A
661  std::cout << "# non-blocking exec test 9a\n";
662  Generator parallel12;
663  Parallel(nonblocking_gv.At(0),nonblocking_gv.At(1),parallel12);
664  bool nonblocking_ok9;
665  nonblocking_ok9=parallel12.BlockingStates().Size()==0;
666  if(nonblocking_ok9)
667  std::cout << "# non-blocking test: passed (test case error!)\n";
668  else
669  std::cout << "# non-blocking test: failed (expected)\n";
670 
671  FAUDES_TEST_DUMP("nonblocking 9a", nonblocking_ok9);
672 
673  // test for conflicts B
674  std::cout << "# non-blocking exec test 9b\n";
675  nonblocking_ok9=IsNonblocking(nonblocking_gv);
676  if(nonblocking_ok9)
677  std::cout << "# non-blocking test: passed (test case error!)\n";
678  else
679  std::cout << "# non-blocking test: failed (expected)\n";
680 
681  FAUDES_TEST_DUMP("nonblocking 9b", nonblocking_ok9);
682 
683 
684  FAUDES_TEST_DIFF()
685 
686  // say good bye
687  std::cout << "done.\n";
688  return 0;
689 }
690 
691 
692 
main
int main()
Definition: 3_functions.cpp:29
FAUDES_TEST_DIFF
#define FAUDES_TEST_DIFF()
Definition: cfl_utils.h:515
FAUDES_TEST_DUMP
#define FAUDES_TEST_DUMP(mes, dat)
Definition: cfl_utils.h:505
faudes::NameSet::Insert
bool Insert(const Idx &rIndex)
Definition: cfl_nameset.cpp:262
faudes::TBaseVector::At
virtual const T & At(const Position &pos) const
Definition: cfl_basevector.h:930
faudes::Type::DWrite
void DWrite(const Type *pContext=0) const
Definition: cfl_types.cpp:231
faudes::Type::Read
void Read(const std::string &rFileName, const std::string &rLabel="", const Type *pContext=0)
Definition: cfl_types.cpp:267
faudes::Type::Write
void Write(const Type *pContext=0) const
Definition: cfl_types.cpp:145
faudes::vBaseVector::PushBack
virtual void PushBack(const Type &rElem)
Definition: cfl_basevector.cpp:380
faudes::vBaseVector::Clear
virtual void Clear(void)
Definition: cfl_basevector.cpp:158
faudes::vGenerator::InitStates
const StateSet & InitStates(void) const
Definition: cfl_generator.cpp:1905
faudes::vGenerator::BlockingStates
StateSet BlockingStates(void) const
Definition: cfl_generator.cpp:2145
faudes::vGenerator::StateNamesEnabled
bool StateNamesEnabled(void) const
Definition: cfl_generator.cpp:996
faudes::TBaseSet::Size
Idx Size(void) const
Definition: cfl_baseset.h:1899
faudes::IsClosed
bool IsClosed(const Generator &rGen)
Definition: cfl_regular.cpp:1000
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:715
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:1034
faudes::Automaton
Idx Automaton(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:339
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:846
faudes::KleeneClosure
void KleeneClosure(Generator &rGen)
Definition: cfl_regular.cpp:869
faudes::PrefixClosure
void PrefixClosure(Generator &rGen)
Definition: cfl_regular.cpp:981
faudes::Deterministic
void Deterministic(const Generator &rGen, Generator &rResGen)
Definition: cfl_determin.cpp:68
faudes::AlphabetLanguage
void AlphabetLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:749
faudes::LanguageConcatenate
void LanguageConcatenate(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:694
faudes::LanguageEquality
bool LanguageEquality(const Generator &rGen1, const Generator &rGen2)
Definition: cfl_regular.cpp:860
faudes::LanguageDifference
void LanguageDifference(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:538
faudes::LanguageIntersection
void LanguageIntersection(const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
Definition: cfl_regular.cpp:188
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:820
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:492
faudes::EmptyStringLanguage
void EmptyStringLanguage(const EventSet &rAlphabet, Generator &rResGen)
Definition: cfl_regular.cpp:791
faudes::KleeneClosureNonDet
void KleeneClosureNonDet(Generator &rGen)
Definition: cfl_regular.cpp:923
faudes::SelfLoopMarkedStates
void SelfLoopMarkedStates(Generator &rGen, const EventSet &rAlphabet)
Definition: cfl_regular.cpp:1061
faudes::IsNonblocking
bool IsNonblocking(const GeneratorVector &rGvec)
Definition: cfl_conflequiv.cpp:705

libFAUDES 2.33l --- 2025.09.16 --- c++ api documentaion by doxygen

>>