3_functions.cpp
Go to the documentation of this file.
1/** @file 3_functions.cpp
2
3Tutorial, operations on genarators.
4
5This tutorial demonstrates the use of
6general purpose operations on generators.
7It also produces example output for the HTML
8documentation.
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
21using namespace faudes;
22
23
24
25/////////////////
26// main program
27/////////////////
28
29int 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.33k --- 2025.09.16 --- c++ api documentaion by doxygen

>>