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 
292 
293  ////////////////////////////
294  // language concatenation
295  ////////////////////////////
296 
297 
298  // read generators and write for html docu
299  Generator concat_g1("data/concat_g1.gen");
300  Generator concat_g2("data/concat_g2.gen");
301  Generator concat_g3("data/concat_g3.gen");
302  Generator concat_g4("data/concat_g4.gen");
303  Generator concat_g5("data/concat_g5.gen");
304  Generator concat_g6("data/concat_g6.gen");
305  concat_g1.Write("tmp_concat_g1.gen");
306  concat_g2.Write("tmp_concat_g2.gen");
307  concat_g3.Write("tmp_concat_g3.gen");
308  concat_g4.Write("tmp_concat_g4.gen");
309  concat_g5.Write("tmp_concat_g5.gen");
310  concat_g6.Write("tmp_concat_g6.gen");
311 
312 
313  // perform language concatenations and inspect on console
314  std::cout << "################################\n";
315  std::cout << "# language concatenation\n";
316  Generator concat;
317  concat.StateNamesEnabled(false);
318  LanguageConcatenate(concat_g1,concat_g3,concat);
319  concat.Write("tmp_concat_g1g3.gen");
320  concat.DWrite();
321  LanguageConcatenate(concat_g1,concat_g4,concat);
322  concat.Write("tmp_concat_g1g4.gen");
323  concat.DWrite();
324  LanguageConcatenate(concat_g2,concat_g3,concat);
325  concat.Write("tmp_concat_g2g3.gen");
326  concat.DWrite();
327  LanguageConcatenate(concat_g2,concat_g4,concat);
328  concat.Write("tmp_concat_g2g4.gen");
329  concat.DWrite();
330  LanguageConcatenate(concat_g5,concat_g6,concat);
331  concat.Write("tmp_concat_g5g6.gen");
332  concat.DWrite();
333  std::cout << "################################\n";
334 
335  // Record test case
336  FAUDES_TEST_DUMP("concat ", concat);
337 
338 
339  ////////////////////////////
340  // full language, alphabet language, empty string language and empty language
341  ////////////////////////////
342 
343  // create alphabet={a,b}
344  EventSet languages_alphabet;
345  languages_alphabet.Insert("a");
346  languages_alphabet.Insert("b");
347 
348  // generator for result
349  Generator languages_g;
350 
351  // construct full language from alphabet
352  FullLanguage(languages_alphabet,languages_g);
353  languages_g.Write("tmp_languagesFull_result.gen");
354 
355  // inspect on console
356  std::cout << "################################\n";
357  std::cout << "# full language \n";
358  languages_g.DWrite();
359 
360  // construct alphabet language from alphabet
361  AlphabetLanguage(languages_alphabet,languages_g);
362  languages_g.Write("tmp_languagesAlphabet_result.gen");
363  std::cout << "# alphabet language \n";
364  languages_g.DWrite();
365 
366  // construct empty string language from alphabet
367  EmptyStringLanguage(languages_alphabet,languages_g);
368  languages_g.Write("tmp_languagesEmptyString_result.gen");
369  std::cout << "# empty string language \n";
370  languages_g.DWrite();
371 
372  // construct empty language from alphabet
373  EmptyLanguage(languages_alphabet,languages_g);
374  languages_g.Write("tmp_languagesEmpty_result.gen");
375  std::cout << "# empty language \n";
376  languages_g.DWrite();
377  std::cout << "################################\n";
378 
379 
380 
381  ////////////////////////////
382  // Kleene closure
383  ////////////////////////////
384 
385 
386  // read generator and write for html docu
387  Generator kleene_g("data/kleene_g.gen");
388  kleene_g.Write("tmp_kleene_g.gen");
389 
390  // compute Kleene closure
391  kleene_g.StateNamesEnabled(false);
392  KleeneClosure(kleene_g);
393  kleene_g.Write("tmp_kleene_gRes.gen");
394 
395  // inspect on console
396  std::cout << "################################\n";
397  std::cout << "# Kleene closure \n";
398  kleene_g.DWrite();
399  std::cout << "################################\n";
400 
401  // Record test case
402  FAUDES_TEST_DUMP("kleene closure ", kleene_g);
403 
404 
405  ////////////////////////////
406  // prefix closure
407  ////////////////////////////
408 
409 
410  // read generator and write for html docu
411  Generator prefixclosure_g("data/prefixclosure_g.gen");
412  prefixclosure_g.Write("tmp_prefixclosure_g.gen");
413 
414  // test prefix closure
415  bool isprefixclosed_g = IsPrefixClosed(prefixclosure_g);
416 
417  // compute prefix closure
418  PrefixClosure(prefixclosure_g);
419  prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");
420 
421  // test prefix closure
422  bool isprefixclosed_gRes = IsPrefixClosed(prefixclosure_g);
423 
424  // inspect on console
425  std::cout << "################################\n";
426  std::cout << "# prefix closure \n";
427  if(isprefixclosed_g)
428  std::cout << "# argument was prefix closed (test case error!)\n";
429  else
430  std::cout << "# argument was not prefix closed (expected)\n";
431  if(isprefixclosed_gRes)
432  std::cout << "# result is prefix closed (expected)\n";
433  else
434  std::cout << "# result is not prefix closed (test case error!)\n";
435  prefixclosure_g.DWrite();
436  std::cout << "################################\n";
437 
438  // Record test case
439  FAUDES_TEST_DUMP("prefix closure", prefixclosure_g);
440 
441 
442  ////////////////////////////
443  // omega closure
444  ////////////////////////////
445 
446 
447  // read generator and write for html docu
448  Generator omegaclosure_g("data/omegaclosure_g.gen");
449  omegaclosure_g.Write("tmp_omegaclosure_g.gen");
450 
451  // test omega closure
452  bool isomegaclosed_g = IsOmegaClosed(omegaclosure_g);
453 
454  // compute omega closure
455  OmegaClosure(omegaclosure_g);
456  omegaclosure_g.Write("tmp_omegaclosure_gRes.gen");
457 
458  // test omega closure
459  bool isomegaclosed_gRes = IsOmegaClosed(omegaclosure_g);
460 
461  // inspect on console
462  std::cout << "################################\n";
463  std::cout << "# omega closure \n";
464  if(isomegaclosed_g)
465  std::cout << "# argument was omega closed (test case error!)\n";
466  else
467  std::cout << "# argument was not omega closed (expected)\n";
468  if(isomegaclosed_gRes)
469  std::cout << "# result is omega closed (expected)\n";
470  else
471  std::cout << "# result is not omega closed (test case error!)\n";
472  omegaclosure_g.DWrite();
473  std::cout << "################################\n";
474 
475  // Record test case
476  FAUDES_TEST_DUMP("omega closure", omegaclosure_g);
477 
478 
479  ////////////////////////////
480  // selfloop
481  ////////////////////////////
482 
483 
484  // read generator and write for html docu
485  Generator selfloop_g("data/selfloop_g.gen");
486  selfloop_g.Write("tmp_selfloop_g.gen");
487 
488  // create alphabet={e,f}
489  EventSet selfloop_alphabet;
490  selfloop_alphabet.Insert("e");
491  selfloop_alphabet.Insert("f");
492 
493  // generator for result
494  Generator selfloop_gRes=selfloop_g;
495 
496  // add selfloops in each state
497  SelfLoop(selfloop_gRes,selfloop_alphabet);
498  selfloop_gRes.Write("tmp_selfloop_gRes.gen");
499 
500  // inspect on console
501  std::cout << "################################\n";
502  std::cout << "# selfloop, each state \n";
503  selfloop_gRes.DWrite();
504 
505  // add selfloops in marked states
506  selfloop_gRes=selfloop_g;
507  SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
508  selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
509  std::cout << "# selfloop, marked states \n";
510  selfloop_gRes.DWrite();
511 
512  // add selfloops in inital state(s)
513  selfloop_gRes=selfloop_g;
514  SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
515  selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
516  std::cout << "# selfloop, init state(s) \n";
517  selfloop_gRes.DWrite();
518  std::cout << "################################\n";
519 
520 
521  ////////////////////////////
522  // nonconflicting
523  ////////////////////////////
524 
525  // under construction --
526 
527  std::cout << "################################\n";
528  std::cout << "# non-blocking test \n";
529 
530 
531  std::cout << "# conflict equiv. abstract test 1 \n";
532  Generator nonblocking_g;
533  EventSet silent;
534  silent.Insert("tau");
535  nonblocking_g.Read("data/noblo_gae2.gen");
536  ConflictEquivalentAbstraction(nonblocking_g,silent);
537  nonblocking_g.Write();
538 
539  FAUDES_TEST_DUMP("nonblocking 0", nonblocking_g);
540 
541  // test cases from Michael Meyer's thesis
542  // 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)
543  // Blocking: (3,4,5,6,7); (1,3,5,7)
544 
545  // read generators from file
546  GeneratorVector nonblocking_gv;
547  nonblocking_gv.PushBack("data/noblo_g2.gen");
548  nonblocking_gv.PushBack("data/noblo_g3.gen");
549  nonblocking_gv.PushBack("data/noblo_g4.gen");
550  nonblocking_gv.PushBack("data/noblo_g5.gen");
551  // test for conflicts
552  std::cout << "# non-blocking exec test 1\n";
553  bool nonblocking_ok1;
554  nonblocking_ok1=IsNonblocking(nonblocking_gv);
555  if(nonblocking_ok1)
556  std::cout << "# non-blocking test: passed (expected)\n";
557  else
558  std::cout << "# non-blocking test: failed (test case error!)\n";
559 
560  FAUDES_TEST_DUMP("nonblocking 1", nonblocking_ok1);
561 
562  // read generators from file
563  nonblocking_gv.Clear();
564  nonblocking_gv.PushBack("data/noblo_g5.gen");
565  nonblocking_gv.PushBack("data/noblo_g6.gen");
566  nonblocking_gv.PushBack("data/noblo_g7.gen");
567  nonblocking_gv.PushBack("data/noblo_g8.gen");
568  nonblocking_gv.PushBack("data/noblo_g9.gen");
569  // test for conflicts
570  std::cout << "# non-blocking exec test 2\n";
571  bool nonblocking_ok2;
572  nonblocking_ok2=IsNonblocking(nonblocking_gv);
573  if(nonblocking_ok2)
574  std::cout << "# non-blocking test: passed (expected)\n";
575  else
576  std::cout << "# non-blocking test: failed (test case error!)\n";
577 
578  FAUDES_TEST_DUMP("nonblocking 2", nonblocking_ok2);
579 
580  // read generators from file
581  nonblocking_gv.Clear();
582  nonblocking_gv.PushBack("data/noblo_g3.gen");
583  nonblocking_gv.PushBack("data/noblo_g4.gen");
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  // test for conflicts
588  std::cout << "# non-blocking exec test 3\n";
589  bool nonblocking_ok3;
590  nonblocking_ok3=IsNonblocking(nonblocking_gv);
591  if(nonblocking_ok3)
592  std::cout << "# non-blocking test: passed (test case error!)\n";
593  else
594  std::cout << "# non-blocking test: failed (expected)\n";
595 
596  FAUDES_TEST_DUMP("nonblocking 3", nonblocking_ok3);
597 
598  // read generators from file
599  nonblocking_gv.Clear();
600  nonblocking_gv.PushBack("data/noblo_g1.gen");
601  nonblocking_gv.PushBack("data/noblo_g3.gen");
602  nonblocking_gv.PushBack("data/noblo_g5.gen");
603  nonblocking_gv.PushBack("data/noblo_g7.gen");
604  // test for conflicts
605  std::cout << "# non-blocking exec test 4\n";
606  bool nonblocking_ok4;
607  nonblocking_ok4=IsNonblocking(nonblocking_gv);
608  if(nonblocking_ok4)
609  std::cout << "# non-blocking test: passed (test case error!)\n";
610  else
611  std::cout << "# non-blocking test: failed (expected)\n";
612 
613  FAUDES_TEST_DUMP("nonblocking 4", nonblocking_ok4);
614 
615  /*
616  // read generators from file
617  nonblocking_gv.Clear();
618  nonblocking_gv.PushBack("data/noblo_g1.gen");
619  nonblocking_gv.PushBack("data/noblo_g2.gen");
620  nonblocking_gv.PushBack("data/noblo_g3.gen");
621  nonblocking_gv.PushBack("data/noblo_g6.gen");
622  nonblocking_gv.PushBack("data/noblo_g7.gen");
623  // test for conflicts
624  std::cout << "# non-blocking exec test 5\n";
625  bool nonblocking_ok5;
626  nonblocking_ok5=IsNonblocking(nonblocking_gv);
627  if(nonblocking_ok5)
628  std::cout << "# non-blocking test: passed (expected)\n";
629  else
630  std::cout << "# non-blocking test: failed (test case error!)\n";
631 
632  // read generators from file
633  nonblocking_gv.Clear();
634  nonblocking_gv.PushBack("data/noblo_g1.gen");
635  nonblocking_gv.PushBack("data/noblo_g2.gen");
636  nonblocking_gv.PushBack("data/noblo_g3.gen");
637  nonblocking_gv.PushBack("data/noblo_g4.gen");
638  nonblocking_gv.PushBack("data/noblo_g5.gen");
639  nonblocking_gv.PushBack("data/noblo_g6.gen");
640  nonblocking_gv.PushBack("data/noblo_g7.gen");
641  // test for conflicts
642  std::cout << "# non-blocking exec test 6\n";
643  bool nonblocking_ok6;
644  nonblocking_ok6=IsNonblocking(nonblocking_gv);
645  if(nonblocking_ok6)
646  std::cout << "# non-blocking test: passed (expected)\n";
647  else
648  std::cout << "# non-blocking test: failed (test case error!)\n";
649 
650  // read generators from file
651  nonblocking_gv.Clear();
652  nonblocking_gv.PushBack("data/noblo_g1.gen");
653  nonblocking_gv.PushBack("data/noblo_g2.gen");
654  nonblocking_gv.PushBack("data/noblo_g3.gen");
655  nonblocking_gv.PushBack("data/noblo_g4.gen");
656  nonblocking_gv.PushBack("data/noblo_g5.gen");
657  nonblocking_gv.PushBack("data/noblo_g6.gen");
658  // test for conflicts
659  std::cout << "# non-blocking exec test 7\n";
660  bool nonblocking_ok7;
661  nonblocking_ok7=IsNonblocking(nonblocking_gv);
662  if(nonblocking_ok7)
663  std::cout << "# non-blocking test: passed (expected)\n";
664  else
665  std::cout << "# non-blocking test: failed (test case error!)\n";
666 
667  // read generators from file
668  nonblocking_gv.Clear();
669  nonblocking_gv.PushBack("data/noblo_g2.gen");
670  nonblocking_gv.PushBack("data/noblo_g4.gen");
671  nonblocking_gv.PushBack("data/noblo_g6.gen");
672  nonblocking_gv.PushBack("data/noblo_g8.gen");
673  // test for conflicts
674  std::cout << "# non-blocking exec test 8\n";
675  bool nonblocking_ok8;
676  nonblocking_ok8=IsNonblocking(nonblocking_gv);
677  if(nonblocking_ok8)
678  std::cout << "# non-blocking test: passed (expected)\n";
679  else
680  std::cout << "# non-blocking test: failed (test case error!)\n";
681 
682  */
683 
685 
686  // say good bye
687  std::cout << "done.\n";
688  return 0;
689 }
690 
691 
692 

libFAUDES 2.28a --- 2016.09.13 --- c++ api documentaion by doxygen