tests without cpp

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/graph.py

@@ -234,7 +234,7 @@ class State:
         selected_transfers = [self.transfers[i] for i, _ in enumerate(selected_edges) if selected_edges[i]==True]
         for transf in selected_transfers:
             if not transf.edge.predicate(data, dynamic_keys_mapping):
-                raise Exception("\tERROR: predicate {} returns {} running from STATE {}".format(transf.edge.pred_name,transf.edge.predicate(data, dynamic_keys_mapping), self.name))
+                raise Exception("\tERROR: predicate {} returns {} running from state {}\n data{}".format(transf.edge.pred_f.name,transf.edge.predicate(data, dynamic_keys_mapping), self.name, data))
         return self.parallelization_policy.make_transfer_func(selected_transfers,
                                                          array_keys_mapping=self.array_keys_mapping,
                                                          implicit_parallelization_info=implicit_parallelization_info, state=self), \

comsdk/parser.py

@@ -165,7 +165,6 @@ class Parser():
         expstr= "Brackets or quotes do not match! Missing closing brackets on lines: "
         fl = False
         for c in br:
-            print("br:",br[c]["count"])
             if br[c]["count"] != 0:
                 fl= True
                 expstr+=str(br[c]["line"])+" "
@@ -198,14 +197,14 @@ class Parser():
         if props =="":
             return parm
         props = props.replace("]", '')
-        if '(' in props:
-            mchs = [m for m in re.finditer(r'\((\w+,)*\w+\)', props)]
-            for m in mchs:
-                props=props[:m.span()[0]]+(props[m.span()[0]:m.span()[1]]).replace(',','\0')+props[m.span()[1]:]
         if '\"' in props:
             m = [m for m in re.finditer(r'\".*\"', props)][0]
             comment = props[m.span()[0]+1:m.span()[1]-1]
             props=props[:m.span()[0]]+props[m.span()[1]:]
+        if '(' in props:
+            mchs = [m for m in re.finditer(r'\((\w+,)*\w+\)', props)]
+            for m in mchs:
+                props=props[:m.span()[0]]+(props[m.span()[0]:m.span()[1]]).replace(',','\0')+props[m.span()[1]:]
         props = props.replace("(","")
         props = props.replace(")","")
         rs =props.split(r",") #.split(r", ")
@@ -307,7 +306,7 @@ class Parser():
     checked=[]
     bushes = {}
     selectorends = {}
-    def generate_cpp(self, filename):
+    def generate_cpp(self, filename=None):
         self.fact.graph.init_state.input_edges_number =0
         states_to_check = [self.fact.graph.init_state]
         while len(states_to_check)!=0:
@@ -323,7 +322,10 @@ class Parser():
         send_token(self.fact.graph.init_state, self.bushes, [])
         preds, morphs, sels, st, body = print_graph(self.fact.graph.init_state, self.fact.entities, self.bushes)
         from mako.template import Template
+        if filename is not None:
             f = open(filename, "w")
+        else:
+            f= open(self.fact.name + ".cpp", "w")
         print(Template(filename="./cpp/template.cpp").render(preds=preds, morphs = morphs, sels = sels, states=st, body=body), file=f)
 
 def print_graph(cur_state, entities, bushes):

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=positiveness_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/testcycl.adot → tests/adot/cycled.adot

@@ -9,6 +9,6 @@ digraph CYCLED {
     
     __BEGIN__ -> ST1 
     ST1 -> ST2 [morphism=MORPH]
-    ST2 -> ST1 
-    ST2 -> __END__
+    ST2 -> ST1 [order=2]
+    ST2 -> __END__ [order = 1]
 }
\ No newline at end of file

tests/adot/testsimple.adot

-digraph SIMPLE {
-    FUNC [module=libprinters, entry_func=PrintHello]
-    PRED [module=libprinters, entry_func=ReturnTrue]
-    MORPH [predicate=PRED, function=FUNC]
-
-    FUNC1 [module=libprinters, entry_func=PrintHello1]
-    PRED1 [module=libprinters, entry_func=ReturnTrue1]
-    MORPH1 [predicate=PRED1, function=FUNC1]
-
-    FUNC2 [module=libprinters, entry_func=PrintHello2]
-    PRED2 [module=libprinters, entry_func=ReturnTrue2]
-    MORPH2 [predicate=PRED2, function=FUNC2]
-
-    __BEGIN__ ->  ST1 [morphism = MORPH]
-    ST1 -> ST2, ST3, ST4 [morphism = (MORPH, MORPH1, MORPH2)]
-    ST2 -> ST3, ST5 [morphism = (MORPH1,MORPH2)]
-    ST4 -> ST5 [morphism = MORPH]
-    ST3 -> ST5 [morphism = MORPH]
-    //ST21 -> ST31, ST312[morphism =(MORPH1,MORPH2)]
-    //ST3, ST31, ST312 -> ST4[morphism = (MORPH,MORPH1,MORPH2) ]
-    ST5 ->  __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=positiveness_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/adot/trivialcpp.adot

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

tests/test_parser.py

+import unittest
+
+from comsdk.graph import *
+from comsdk.parser import Parser
+
+path_to_comsdk = "/home/lbstr/bmstu/comsdk"
+
+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):
+        pass
+    
+    def test_cpp_branching_graph(self):
+        pass
+
+    def test_cpp_cycled_graph(self):
+        pass
+
+    def test_cpp_complex_graph(self):
+        pass
+
+
+
+if __name__ == '__main__':
+    unittest.main()
+