Merge branch 'pars' into 'dev'

adot_to_cpp.py

+import unittest
+from copy import deepcopy
+import subprocess
+import os
+import random
+import sys
+from test_funcs.simplest import * 
+import comsdk.parser as pars
+from comsdk.graph import *
+from comsdk.edge import Edge
+
+prsr = pars.Parser(tocpp=True)
+data = {"a":10, "b":0}
+gr = prsr.parse_file(sys.argv[1])
+if sys.argv[2] !="":
+    prsr.generate_cpp(sys.argv[2])
+else:
+    prsr.generate_cpp()

comsdk/communication.py

@@ -8,7 +8,7 @@ import json
 from stat import S_ISDIR
 from abc import ABCMeta, abstractmethod
 
-from comsdk.aux import load_function_from_module
+from comsdk.comaux import load_function_from_module
 
 class Host(object):
     '''

comsdk/distributed_storage.py

-from comsdk.aux import find_dir_by_named_regexp
+from comsdk.comaux import find_dir_by_named_regexp
 from functools import partial
 import os
 

comsdk/edge.py

-import comsdk.aux as aux
+import comsdk.comaux as aux
 from comsdk.communication import CommunicationError
+from comsdk.graph import Func
 
 from mako.template import Template
 import os
@@ -26,43 +27,53 @@ class InOutMapping(object):
 
 class Edge(object):
     __slots__ = [
-        '_predicate', 
-        '_morphism',
+        'pred_f',
+        'morph_f',
         '_io_mapping',
         'preprocess',
         'postprocess',
-        ]
+        'order',
+        'comment'
+    ]
     def __init__(self, predicate, morphism, 
                  io_mapping=InOutMapping(),
+                 order=0, 
+                 comment=""
                  ):
-        self._predicate = predicate
-        self._morphism = morphism
+        self.pred_f = predicate
+        self.morph_f = morphism
         self._io_mapping = io_mapping
         self.preprocess = lambda pd: None
         self.postprocess = lambda pd: None
+        self.order = int(0 if order is None else order)
+        self.comment = comment
 
     def predicate(self, data, dynamic_keys_mapping={}):
         proxy_data = self._io_mapping.build_proxy_data(data, dynamic_keys_mapping)
-        return self._predicate(proxy_data)
+        return self.pred_f.func(proxy_data)
 
     def morph(self, data, dynamic_keys_mapping={}):
-        #print(dynamic_keys_mapping)
+        # print(self.pred_name, self.morph_name, self.order)
         proxy_data = self._io_mapping.build_proxy_data(data, dynamic_keys_mapping)
-        #print(proxy_data)
+        # print(proxy_data)
         self.preprocess(data)
-        self._morphism(proxy_data)
+        self.morph_f.func(proxy_data)
         self.postprocess(data)
+    
 
-class DummyEdge(Edge):
-    def __init__(self):
-        super().__init__(None, None)
+# class DummyEdge(Edge):
+    # def __init__(self):
+        # super().__init__(None, None)
+# 
+    # def predicate(self, data, dynamic_keys_mapping={}):
+        # return True
+# 
+    # def morph(self, data, dynamic_keys_mapping={}):
+        # self.preprocess(data)
+        # self.postprocess(data)
 
-    def predicate(self, data, dynamic_keys_mapping={}):
-        return True
-
-    def morph(self, data, dynamic_keys_mapping={}):
-        self.preprocess(data)
-        self.postprocess(data)
+def DummyEdge():
+    return Edge(Func(), Func())
 
 class ExecutableProgramEdge(Edge):
     '''

comsdk/research.py

@@ -2,7 +2,7 @@ import os
 import pickle
 import shutil
 from datetime import datetime, date
-from comsdk.aux import *
+from comsdk.comaux import *
 from comsdk.communication import *
 from comsdk.distributed_storage import *
 from comsdk.edge import Edge, dummy_predicate

comsdk/test.adot

+digraph CODEOBJECT_GENERATOR
+{
+// ??????????? ???????-????????????
+	FUNC_1 [module=case_gen_funcs, entry_func=function_1]
+	FUNC_2 [module=case_gen_funcs, entry_func=function_2]
+	FUNC_3 [module=case_gen_funcs, entry_func=function_3]
+	SAVE_TO_DB [module=case_gen_funcs, entry_func=save_to_db]
+	SAVE_TO_FILE [module=case_gen_funcs, entry_func=save_to_file]
+	REPEAT [module=case_gen_funcs, entry_func=repeat]
+	EXIT [module=case_gen_funcs, entry_func=exit]
+	CREATE_DUMP [module=case_gen_funcs, entry_func=create_dump]
+// ??????????? ???????-??????????
+	PREDICATE_X [module=predicate_funcs, entry_func=predicate_x]
+	PREDICATE_Y [module=predicate_funcs, entry_func=predicate_y]
+	SELECTOR [module=predicate_funcs, entry_func=selector]
+// ??????????? ??????? ???????? (????????)
+	EDGE_1 [predicate=PREDICATE_X, function=FUNC_1]
+	EDGE_2 [predicate=PREDICATE_Y, function=FUNC_2]
+	EDGE_3 [predicate=PREDICATE_X, function=FUNC_3]
+	EDGE_4 [predicate=PREDICATE_Y, function=SAVE_TO_DB]
+	EDGE_5 [predicate=PREDICATE_X, function=SAVE_TO_FILE]
+	EDGE_6 [predicate=PREDICATE_Y, function=REPEAT]
+	EDGE_7 [predicate=PREDICATE_X, function=EXIT]
+	EDGE_8 [function=EXIT]
+	EDGE_9 [predicate=CHECK_DUMP, function=EXIT]
+	EDGE_10 [function=CREATE_DUMP]
+// ? ???? ??????? ????????? ????????????????? 	
+	CONTENT_SUBSTITUTED [parallelism=threading]
+// ??????????? ???????? ??????
+	__BEGIN__ -> INPUT_READY
+	INPUT_READY -> TEPMLATE_COPIED [morphism=EDGE_1]
+	TEPMLATE_COPIED -> NAMES_SUBSTITUTED [morphism=EDGE_2]
+	NAMES_SUBSTITUTED -> CONTENT_SUBSTITUTED [morphism=EDGE_3]
+	CONTENT_SUBSTITUTED => DUMP_CREATED [morphism=EDGE_10]
+	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_4]
+	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_5]
+// ? ??????????? ?? ?????? ?????????? SELECTOR ?????????????? ??????? ?? ??????? ??? ??????? ?????
+	RESULT_SAVED -> INPUT_READY, __END__ [selector=SELECTOR, morphism=(EDGE_6, EDGE_7)]
+	RESULT_SAVED, DUMP_CREATED -> __END__ [morphism=(EDGE_8, EDGE_9)]
+}
\ No newline at end of file

cpp/printers.cpp

+#include <iostream>
+#include <anymap.h>
+
+extern "C" {
+    int PrintHello(com::Anymap) {
+        std::cout<<"Hello!" << std::endl;
+        return 0;
+    }
+
+    int PrintBye(com::Anymap) {
+        std::cout<<"Bye!" << std::endl;
+        return 0;
+    }
+
+    int PrintA(com::Anymap) {
+        std::cout<<"A" << std::endl;
+        return 0;
+    }
+
+    int PrintB(com::Anymap) {
+        std::cout<<"B" << std::endl;
+        return 0;
+    }
+
+    bool ReturnTrue(){
+        return true;
+    }
+
+    bool ReturnFalse(){
+        return false;
+    }
+
+    std::list<bool> ThreeTrue(){
+        return false;
+    }
+}
\ No newline at end of file

cpp/run.sh

+g++ -c -fPIC ./dev/core/anymap.cpp -o anymap.o -I./dev;
+g++ -c -fPIC  tests.cpp -o tests.o -I./dev;
+# g++ -c -fPIC ./dev/iniparser/iniparser.cpp -o iniparser.o -I./dev;
+g++ tests.o anymap.o -shared -o libtest.so; rm tests.o anymap.o;
+if g++ $1 -o graph.out -I./dev ./dev/core/anymap.cpp -ldl; then
+./graph.out;
+else 
+ echo "Not Compiled!";
+fi;
\ No newline at end of file

cpp/template.cpp

+#include <libtools.h>
+#include <anymap.h>
+#include <iniparser.h>
+
+typedef std::function<int(com::Anymap*)> IntFunc;
+typedef std::function<bool(com::Anymap*)> BoolFunc;
+typedef std::function<bool*(com::Anymap*)> BoolArrFunc;  
+
+IntFunc LoadEntry(std::string lib, std::string func) {
+    DllHandle handler;
+    return com::lib::loadFunction<int (com::Anymap*), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+BoolFunc LoadPred(std::string lib, std::string func) {
+    DllHandle handler;
+    return com::lib::loadFunction<int (com::Anymap*), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+BoolArrFunc LoadSelector(std::string lib, std::string func){
+    DllHandle handler;
+    return com::lib::loadFunction<bool* (com::Anymap*), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+void check_pred(bool predval, std::string predname) {
+    if (!predval) {
+        std::cout<<"Predicate "<<predname<<" returned FALSE!"<<std::endl;
+        exit(-1);
+    }   
+}
+
+int main(int argc, char const *argv[])
+{   
+    auto data = com::Anymap();
+    //Predicates
+% for pred in preds:
+    auto ${pred} = LoadPred("${pred.module}", "${pred.name}"); 
+% endfor
+    //Entry functions
+% for morph in morphs:
+    auto ${str(morph)} = LoadEntry("${morph.module}", "${morph.name}"); 
+% endfor
+    //Selectors
+% for sel in sels:
+    auto ${str(sel)} = LoadSelector("${sel.module}", "${sel.name}"); 
+% endfor
+    //Branch tokens
+    bool* SEL_${states[0].name} = new bool[${len(states[0].transfers)}];
+    std::fill_n(SEL_${states[0].name}, ${len(states[0].transfers)}, true);
+% for st in states[1:]:
+    bool* SEL_${st.name} = new bool[${len(st.transfers)}];
+    std::fill_n(SEL_${st.name}, ${len(st.transfers)}, false);
+% endfor
+
+${body}
+
+TERM:
+    std::cout<<"Termination!\n"; 
+    return 0;
+}
\ No newline at end of file

test_funcs/simplest.py

+def dummy_edge(data):
+    pass
+
+def increment_a_edge(data):
+    data['a'] += 1
+
+def increment_a_array_edge(data):
+    for i in range(len(data['a'])):
+        data['a'][i] += 1
+
+def increment_b_edge(data):
+    data['b'] += 1
+
+def decrement_a_edge(data):
+    data['a'] -= 1
+
+def nonzero_predicate(data):
+    return data['a'] != 0 
+
+def positiveness_predicate(data):
+    return data['a'] > 0 
+
+def nonpositiveness_predicate(data):
+    return data['a'] <= 0 
+
+def copy_to_c(data):
+    data['c'] = data['a']
+
+def selector_a_nonpositive(data):
+    res = data['a'] <= 0
+    return [res, not res]
+
+def true_predicate(data):
+    return True

tests/adot/add.adot

+digraph ADD {
+    FUNC [module=test_funcs.simplest, entry_func=increment_b_edge]
+    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    MORPH [predicate=PRED, function=FUNC, comment="ADD"]
+    
+    __BEGIN__ ->  ST [morphism = MORPH]
+    ST -> __END__ 
+}
\ No newline at end of file

tests/adot/branching.adot

+digraph SIMPLEST {
+    FUNCA [module=test_funcs.simplest, entry_func=increment_a_edge]
+    FUNCB [module=test_funcs.simplest, entry_func=increment_b_edge]
+    PRED [module=test_funcs.simplest, entry_func=true_predicate]
+    
+    INCR_A [predicate=PRED, function=FUNCA]
+    INCR_B [predicate=PRED, function=FUNCB]
+    
+    __BEGIN__ -> ROOT
+    ROOT ->  BR1, BR2 [morphism=(INCR_A, INCR_B)]
+    BR1 -> BR1_ST [morphism=INCR_A]
+    BR2 -> BR2_ST [morphism=INCR_B]
+    BR1_ST, BR2_ST -> MERGE [morphism=(INCR_A, INCR_B)]
+    MERGE -> __END__
+} 
\ No newline at end of file

tests/adot/complex.adot

+digraph SIMPLEST {
+    FUNCA [module=test_funcs.simplest, entry_func=increment_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=true_predicate]
+    
+    INCR_A [predicate=PRED, function=FUNCA]
+    
+    ST1 [subgraph=tests/adot/trivial.adot]
+    ST2 [subgraph=tests/adot/cycled.adot]
+    ST3 [subgraph=tests/adot/branching.adot]
+
+    __BEGIN__ -> ST1 
+    ST1 -> ST2 [morphism=INCR_A]
+    ST2 -> ST3 [morphism=INCR_A]
+    ST3 -> __END__ 
+} 
\ No newline at end of file

tests/adot/cppbranching.adot

+digraph SIMPLEST {
+    FUNCA [module=libtest, entry_func=IncA]
+    FUNCB [module=libtest, entry_func=IncB]
+    
+    CHECKA [module=libtest, entry_func=CheckAEq4]
+    CHECKB [module=libtest, entry_func=CheckBEq4]
+    
+    SETA [module=libtest, entry_func=SetAEq1]
+    SETB [module=libtest, entry_func=SetBEq1]
+
+    PASS [module=libtest, entry_func=PassFunc]
+    PRED [module=libtest, entry_func=PassPred]
+
+    INCR_A [predicate=PRED, function=FUNCA]
+    INCR_B [predicate=PRED, function=FUNCB]
+    CH_A [predicate=CHECKA, function = PASS]
+    SET_A [predicate=PRED, function=SETA]
+    SET_B [predicate=PRED, function=SETB]
+    CH_B [predicate=CHECKB, function = PASS]
+    
+    __BEGIN__ -> ROT [morphism=SET_A]
+    ROT -> ROOT[morphism=SET_B]
+    ROOT ->  BR1, BR2 [morphism=(INCR_A, INCR_B)]
+    BR1 -> BR1_ST [morphism=INCR_A]
+    BR2 -> BR2_ST [morphism=INCR_B]
+    BR1_ST, BR2_ST -> MERGE [morphism=(INCR_A, INCR_B)]
+    MERGE -> __END__, __END__ [morphism=(CH_A, CH_B)]
+} 
\ No newline at end of file

tests/adot/cppcomplex.adot

+digraph SIMPLEST {
+    FUNCA [module=test_funcs.simplest, entry_func=increment_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=true_predicate]
+    
+    INCR_A [predicate=PRED, function=FUNCA]
+    
+    ST1 [subgraph=tests/adot/cpptrivial.adot]
+    ST2 [subgraph=tests/adot/cppcycled.adot]
+    ST3 [subgraph=tests/adot/cppbranching.adot]
+
+    __BEGIN__ -> ST1 
+    ST1 -> ST2 
+    ST2 -> ST3 
+    ST3 -> __END__ 
+} 
\ No newline at end of file

tests/adot/cppcycled.adot

+digraph CYCLED {
+
+    SETA [module=libtest, entry_func=SetAEq10]
+    FUNC [module=libtest, entry_func=DecA]
+    PRED [module=libtest, entry_func=PassPred]
+
+    SET [predicate=PRED, function=SETA]
+    MORPH [predicate=PRED, function=FUNC]
+
+    SEL [module = libtest, entry_func=SelectorA]
+
+    ST2 [selector = SEL]
+    
+    __BEGIN__ -> ST1 [morphism=SET]
+    ST1 -> ST2 [morphism=MORPH]
+    ST2 -> ST1 [order=1]
+    ST2 -> __END__ [order = 2]
+}
\ No newline at end of file

tests/adot/cpptrivial.adot

+digraph SIMPLE {
+    FUNC [module=libtest, entry_func=IncA]
+    PRED [module=libtest, entry_func=PassPred]
+    MORPH [predicate=PRED, function=FUNC]
+
+        __BEGIN__ -> ST1 [morphism = MORPH]
+    ST1 -> ST2 [morphism = MORPH]
+    ST2 -> __END__ [morphism = MORPH]
+}
\ No newline at end of file

tests/adot/cycled.adot

+digraph CYCLED {
+    FUNC [module=test_funcs.simplest, entry_func=decrement_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=true_predicate]
+    MORPH [predicate=PRED, function=FUNC]
+
+    SEL [module = test_funcs.simplest, entry_func = selector_a_nonpositive]
+
+    ST2 [selector = SEL]
+    
+    __BEGIN__ -> ST1 
+    ST1 -> ST2 [morphism=MORPH]
+    ST2 -> ST1 [order=2]
+    ST2 -> __END__ [order = 1]
+}
\ No newline at end of file

tests/adot/file.adot

+digraph gcdhom_inverted_model_pso
+{
+// Определение функций-обработчиков
+	PASS_PROCESSOR [module=libcomsdk, entry_func=pass_processor]
+	CHECK_PSO_AGENT_REINIT [module=libgcdfes, entry_func=check_pso_agent_reinit, comment="Проверка о необходимости реинициализации отдельной частицы (смещение частицы) в рое в рамках метода роя частиц."]
+	CHECK_PSO_SWARM_REINIT [module=libgcdfes, entry_func=check_pso_swarm_reinit, comment="Проверка о необходимости реинициализации всего роя частиц в рамках метода роя частиц."]
+
+	PSO_AGENT_REINIT [module=libgcdfes, entry_func=pso_agent_reinit, comment="Реинициализация отдельной частицы (смещение частицы) в рое в рамках метода роя частиц."]
+	PSO_SWARM_REINIT [module=libgcdfes, entry_func=pso_swarm_reinit, comment="Реинициализация всего роя частиц в рамках метода роя частиц."]
+	
+	PSO_SWARM_ANALYSING [module=libgcdfes, entry_func=pso_swarm_analysing, comment="Анализ всего роя частиц в рамках метода роя частиц."]
+	
+	PSO_HOM_AGENT_POSTPROC [module=libgcdfes, entry_func=pso_hom_agent_postproc, comment="Постпроцессинг после решения отдельной задачи методом асимптотического осреднения."]
+	
+	PSO_TASK_DATA_REINIT [module=libgcdfes, entry_func=pso_task_data_reinit, comment="Реинициализация постановки задачи анализа эффективных характеристик КМ методом асимптотического осреднения."]
+	
+	PSO_AGENT_INIT [module=libgcdfes, entry_func=pso_agent_init, comment="Инициализация отдельной частицы в рамках метода роя частиц."]
+
+	PSO_SWARM_INIT [module=libgcdfes, entry_func=pso_swarm_init, comment="Инициализация роя частиц."]
+	
+	PSO_INIT [module=libgcdfes, entry_func=pso_swarm_init, comment="Инициализация метода роя частиц."]
+
+// Определение функций-предикатов
+	PASS_PREDICATE [module=libcomsdk, entry_func=pass_predicate]
+	
+// Определение морфизмов
+	PASS_MORPHISM [predicate=PASS_PREDICATE, function=PASS_PROCESSOR, comment="ПАСС, морфизм."]
+	
+	PSO_AGENT_REINIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_AGENT_REINIT]
+	PSO_SWARM_REINIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_SWARM_REINIT]
+	PSO_SWARM_ANALYSING_MORPHISM [predicate=PASS_PREDICATE, function=PSO_SWARM_ANALYSING]
+	PSO_HOM_AGENT_POSTPROC_MORPHISM [predicate=PASS_PREDICATE, function=PSO_HOM_AGENT_POSTPROC] 
+	PSO_TASK_DATA_REINIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_TASK_DATA_REINIT] 
+	PSO_AGENT_INIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_AGENT_INIT] 
+	PSO_SWARM_INIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_SWARM_INIT] 
+	PSO_INIT_MORPHISM [predicate=PASS_PREDICATE, function=PSO_INIT] 
+	
+// Определение атрибутов узлов	
+	S_1 [subgraph=gcdhom_preprocessor.adot]
+	S_5 [subgraph=gcdhom_processor.adot]
+	S_6 [selector=CHECK_PSO_AGENT_REINIT]
+	S_7 [selector=CHECK_PSO_SWARM_REINIT]
+
+// Определение топологии графовой модели метода конечных элементов
+	__BEGIN__ -> S_1
+	S_1 -> S_2 [morphism=PSO_INIT_MORPHISM]
+	S_2 -> S_3 [morphism=PSO_SWARM_INIT_MORPHISM]
+	S_3 -> S_4 [morphism=PSO_AGENT_INIT_MORPHISM]
+	S_4 -> S_5 [morphism=PSO_TASK_DATA_REINIT_MORPHISM]
+	S_5 -> S_6 [morphism=PSO_HOM_AGENT_POSTPROC_MORPHISM]
+	S_6 -> S_4, S_7 [morphism=(PSO_AGENT_REINIT_MORPHISM, PSO_SWARM_ANALYSING_MORPHISM), order=(10,20)]
+	S_7 -> S_4, S_8 [morphism=(PSO_SWARM_REINIT_MORPHISM, PASS_MORPHISM), order=(30,40)]
+	S_8 -> __END__ [comment = "Расчет завершён."]
+}

tests/adot/testparal.adot

+digraph SIMPLEST {
+    FUNCA [module=test_funcs.simplest, entry_func=increment_a_edge]
+    FUNCB [module=test_funcs.simplest, entry_func=increment_b_edge]
+    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    INCR_A [predicate=PRED, function=FUNCA]
+    INCR_B [predicate=PRED, function=FUNCB]
+    
+
+    __BEGIN__ -> ROOT
+    ROOT ->  BR1, BR2, BR3 [morphism=(INCR_A, INCR_A, INCR_A)]
+    //BR3 -> SIBL3_BR1, SIBL3_BR2 [morphism=(INCR_A, INCR_A)]
+    //BR2 -> SIBL2_BR1, SIBL2_BR2 [morphism=(INCR_A, INCR_A)]
+    //SIBL3_BR1 -> SIBL3_BR1_1,  SIBL3_BR1_2 [morphism=(INCR_A, INCR_A)]
+    //SIBL3_BR1_1,  SIBL3_BR1_2 -> TERM  [morphism=(INCR_A, INCR_A)]
+    //BR1,  SIBL2_BR1, SIBL2_BR2, TERM, SIBL3_BR2 ->  __END__ [morphism=(INCR_A, INCR_A, INCR_A, INCR_A, INCR_A)]
+    BR1, BR2, BR3 -> __END__ [morphism=(INCR_A, INCR_A, INCR_A)]
+} 
\ No newline at end of file

tests/adot/testsub.adot

+digraph TEST_SUB {
+    FUNC [module=test_funcs.simplest, entry_func=increment_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    MORPH [predicate=PRED, function=FUNC]
+    SEL [module=test_funcs.simplest, entry_func=selector_a_nonpositive]
+    
+    ST2 [subgraph = tests/adot/file.adot]
+    ST3 [selector = SEL]
+
+    __BEGIN__ -> ST1 [morphism = MORPH]
+    ST1 -> ST2 
+    ST2 -> ST3 
+    ST3 -> __END__ 
+}
\ No newline at end of file

tests/adot/trivial.adot

+digraph TRIVIAL {
+    FUNC [module=test_funcs.simplest, entry_func=increment_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=true_predicate]
+    MORPH [predicate=PRED, function=FUNC, comment="ADD"]
+
+    __BEGIN__ -> ST1 [morphism = MORPH]
+    ST1 -> ST2 [morphism = MORPH]
+    ST2 -> __END__ [morphism = MORPH]
+}
\ No newline at end of file

tests/test_graph.py

@@ -230,24 +230,30 @@ class GraphGoodCheck(unittest.TestCase):
 
     def _get_trivial_parallel_graph(self, initial_conditions):
         '''
-        s_1 -> s_2 -> s_3 -> s_6
-            -> s_4 -> s_5 ->
+        s_1 -> s_2 -> s_3 ---------> s6s
+            -> s_4 -> s_4_1 -> s_5 
+                   -> s_4_2            
         p_12 = p_24 = p_13 = p_34 := a not 0
         f_12 = f_24 := a + 1
         f_13 = f_34 := b + 1
         '''
 
-        s_1 = State('nonparallel_s_1', selection_policy=AllSelectionPolicy())
+        s_1 = State('nonparallel_s_1')
         s_2 = State('parallel_s_2')
         s_3 = State('parallel_s_3')
         s_4 = State('parallel_s_4')
+        s_4_1 = State('parallel_s_4_1')
+        s_4_2 = State('parallel_s_4_2')
         s_5 = State('parallel_s_5')
         s_6 = State('nonparallel_s_6')
         s_1.connect_to(s_2, edge=Edge(nonzero_predicate, increment_a_edge))
         s_2.connect_to(s_3, edge=Edge(nonzero_predicate, increment_a_edge))
         s_3.connect_to(s_6, edge=Edge(nonzero_predicate, increment_a_edge))
         s_1.connect_to(s_4, edge=Edge(nonzero_predicate, increment_b_edge))
-        s_4.connect_to(s_5, edge=Edge(nonzero_predicate, increment_b_edge))
+        s_4.connect_to(s_4_1, edge=Edge(nonzero_predicate, increment_b_edge))
+        s_4.connect_to(s_4_2, edge=Edge(nonzero_predicate, increment_b_edge))
+        s_4_1.connect_to(s_5,  edge=Edge(nonzero_predicate, increment_b_edge))
+        s_4_2.connect_to(s_6,  edge=Edge(nonzero_predicate, increment_b_edge))
         s_5.connect_to(s_6, edge=Edge(nonzero_predicate, increment_b_edge))
         correct_outputs = []
         for ic in initial_conditions:
@@ -433,15 +439,17 @@ class GraphGoodCheck(unittest.TestCase):
         p_12 = p_23 := dummy
         f_12 := a + 1
         '''
-
+        
+        pred = Func(func=dummy_predicate)
+        morph = Func(func=increment_a_edge)
         s_1 = State('s_1')
         s_2 = State('s_2')
         s_3 = State('s_3')
-        s_1.connect_to(s_2, edge=Edge(dummy_predicate, increment_a_edge))
-        s_2.connect_to(s_3, edge=Edge(dummy_predicate, increment_a_edge))
+        s_1.connect_to(s_2, edge=Edge(pred, morph))
+        s_2.connect_to(s_3, edge=Edge(pred, morph))
         sub_s_1 = State('sub_s_1')
         sub_s_2 = State('sub_s_2')
-        sub_s_1.connect_to(sub_s_2, edge=Edge(dummy_predicate, increment_a_edge))
+        sub_s_1.connect_to(sub_s_2, edge=Edge(pred, morph))
         s_2.replace_with_graph(Graph(sub_s_1, sub_s_2))
         correct_outputs = []
         for ic in initial_conditions:

tests/test_parser.py

+import unittest
+import subprocess
+
+from comsdk.graph import *
+from comsdk.parser import Parser
+
+path_to_comsdk = "/home/lbstr/bmstu/comsdk"
+path_to_pycomsdk = "/home/lbstr/bmstu/pycomsdk"
+
+class ParserGoodCheck(unittest.TestCase):
+
+    def test_trivial_graph(self):
+        parsr = Parser()
+        gr = parsr.parse_file("./tests/adot/trivial.adot")
+        data = {"a": 1}
+        gr.run(data)
+        self.assertEqual(data["a"], 4)
+
+    def test_branching_graph(self):
+        parsr = Parser()
+        gr = parsr.parse_file("./tests/adot/branching.adot")
+        data = {"a": 1, "b": 1}
+        gr.run(data)
+        self.assertEqual(data["a"], 4)
+        self.assertEqual(data["b"], 4)
+
+    def test_cycled_graph(self):
+        parsr = Parser()
+        gr = parsr.parse_file("./tests/adot/cycled.adot")
+        data = {"a": 10}
+        gr.run(data)
+        self.assertEqual(data["a"], 0)
+
+    def test_complex_graph(self):
+        parsr = Parser()
+        gr = parsr.parse_file("./tests/adot/complex.adot")
+        data = {"a": 1, "b": 1}
+        gr.run(data)
+        self.assertEqual(data["a"], 4)
+        self.assertEqual(data["b"], 4)
+
+    def test_cpp_trivial_graph(self):
+        parsr = Parser(tocpp=True)
+        gr = parsr.parse_file("./tests/adot/cpptrivial.adot")
+        parsr.generate_cpp(path_to_comsdk+"res.cpp")
+        command = "cd "+path_to_comsdk+"; "+path_to_pycomsdk+"/cpp/run.sh "+path_to_comsdk+"res.cpp"
+        subprocess.check_output(["bash", "-c", command])
+    
+    def test_cpp_branching_graph(self):
+        parsr = Parser(tocpp=True)
+        gr = parsr.parse_file("./tests/adot/cppbranching.adot")
+        parsr.generate_cpp(path_to_comsdk+"res.cpp")
+        command = "cd "+path_to_comsdk+"; "+path_to_pycomsdk+"/cpp/run.sh "+path_to_comsdk+"res.cpp"
+        subprocess.check_output(["bash", "-c", command])
+
+    def test_cpp_cycled_graph(self):
+        parsr = Parser(tocpp=True)
+        gr = parsr.parse_file("./tests/adot/cppcycled.adot")
+        parsr.generate_cpp(path_to_comsdk+"res.cpp")
+        command = "cd "+path_to_comsdk+"; "+path_to_pycomsdk+"/cpp/run.sh "+path_to_comsdk+"res.cpp"
+        subprocess.check_output(["bash", "-c", command])
+
+    def test_cpp_complex_graph(self):
+        parsr = Parser(tocpp=True)
+        gr = parsr.parse_file("./tests/adot/cppcomplex.adot")
+        parsr.generate_cpp(path_to_comsdk+"res.cpp")
+        command = "cd "+path_to_comsdk+"; "+path_to_pycomsdk+"/cpp/run.sh "+path_to_comsdk+"res.cpp"
+        subprocess.check_output(["bash", "-c", command])
+
+if __name__ == '__main__':
+    unittest.main()
+