tla-parser-s 0.1.0

data/spec/fixtures/resolver1/var_rec_except.tla

@@ -0,0 +1,4 @@
+var_rec_except = [ var5 EXCEPT ![id] = op1, ![uid] = @ ]
+
+
+

data/spec/fixtures/resolver1/var_rec_expr.tla

@@ -0,0 +1,3 @@
+var_rec_expr = var4.a[op1]
+
+

data/spec/fixtures/resolver1/var_record.tla

@@ -0,0 +1,2 @@
+var_record = [ id |-> var5 ]
+

data/spec/fixtures/resolver1/var_seq.tla

@@ -0,0 +1 @@
+var_seq = << op1, op2 >>

data/spec/fixtures/resolver1/var_set.tla

@@ -0,0 +1 @@
+var_set = { op1 }

data/spec/fixtures/resolver1/var_set_expr_map.tla

@@ -0,0 +1 @@
+var_set_expr_map = { x.id : x \in var4 }

data/spec/fixtures/resolver1/var_x.tla

@@ -0,0 +1 @@
+x = 1

data/spec/fixtures/resolver1/variables.tla

@@ -0,0 +1,4 @@
+var1 = op1
+
+var2 = {}
+

data/spec/parser/parser_fixtures_spec.rb

@@ -0,0 +1,117 @@
+require_relative "../spec_helper"
+
+describe  TlaParserS::Parser do
+
+  
+  let ( :parser ) { described_class.new }
+  
+  describe "Fixture 1: callables1.tla" do
+    
+    file = "#{FIXTURE_ROOT}/callables1.tla"
+    let ( :tree ) { parser.parse( File.new(file) ) }
+    
+
+    
+    it "#defines" do
+      # puts ""
+      # puts tree.inspect
+      expect( tree.defines.length ).to eql( 10 )
+    end # it
+
+    it "#callables" do
+      # puts ""
+      # puts tree.inspect
+      expect( tree.callables.length ).to eql( 7 )
+    end # it
+
+    context "variables" do
+      let (:variable_nodes) { tree.recursive_select( Sexp::VariableDef ) }
+
+      it "#number of variable definitions" do
+        expect( variable_nodes.length ).to eql( 3 )
+      end # it
+
+      it "#identifiers" do
+        expect( variable_nodes.map { |m| m.name } ).to eql( ["a", "b", "c" ] )
+      end # it
+      
+      
+    end
+
+    context "macros" do
+
+      let (:macro_nodes) { tree.recursive_select( Sexp::Macro ) }
+      
+      it "#number of macro definitions" do
+        expect( macro_nodes.length ).to eql( 2 )
+      end # it
+
+      it "#identifiers" do
+        expect( macro_nodes.map { |m| m.name } ).to eql( ["macroid1", "macroid2" ] )
+      end # it
+
+      context "first macro" do
+        let ( :macro_node )  { macro_nodes[0] }
+
+        it "Parameter identifiers" do
+          expect( macro_node.parameters_node.identifier_nodes.map{ |i| i.node_value }   ).to eql( ["m1_p1","m1_p2"] )
+        end # it
+        
+        
+      end
+
+      
+    end # context "macros" do
+
+    context "operators" do
+
+      let (:operator_nodes) { tree.recursive_select( Sexp::OperatorDef ) }
+
+      it "#number of operator definitions" do
+        expect( operator_nodes.length ).to eql( 2 )
+      end # it
+
+      it "#identifiers" do
+        expect( operator_nodes.map { |m| m.name } ).to eql( ["ItWorks", "ItCalls" ] )
+      end # it
+    end # context "operators" do
+
+    context "procedures" do
+
+      let (:procedure_nodes) { tree.recursive_select( Sexp::Procedure ) }
+
+      it "#number of operator definitions" do
+        expect( procedure_nodes.length ).to eql( 3 )
+      end # it
+
+      it "#identifiers" do
+        expect( procedure_nodes.map { |m| m.name } ).to eql( ["proc0", "proc1", "proc2" ] )
+      end # it
+    end # context "operators" do
+    
+    
+
+  end # describe "directives"
+
+  describe "Fixture 2: directives.tla" do
+    
+    file = "#{FIXTURE_ROOT}/directives.tla"
+    let ( :tree ) { parser.parse( File.new(file) ) }
+
+    it "#directives" do
+      # puts ""
+      # puts tree.inspect
+      expect( tree.directives.length ).to eql( 4 )
+    end # it
+    
+    it "#directive definitision" do
+      # puts ""
+      # puts tree.inspect
+      expect( tree.directive_definitions  ).to eql( ["Assume_Domains","a2", "a3", "i1", "i2", "i3" ] )
+    end # it
+    
+    
+  end  
+
+  
+end

data/spec/parser/parser_spec.rb

@@ -0,0 +1,1649 @@
+require_relative "../spec_helper"
+
+describe  TlaParserS::Parser do
+
+  let ( :parser ) { described_class.new }
+
+  # parse 'str' and extract array of node value  of type 'klass'
+  # @param str [String] to parse
+  # @param start [symbol] treep grammar non-terminal to start iwth
+  def parse_nodes( str, start )
+    # parser.parse( str, start ).recursive_select( klass ).map { |n| n.value }
+    # parser.parse( str, start ).map { |n| n.value }
+    parser.parse( str, start ).value
+  end
+
+  # ------------------------------------------------------------------
+  # Visitor for statements
+
+  def statement_value( node_type, node )
+
+    case node_type
+    when "Statement"
+      "#{node.statement_label}: "
+      
+    when "Skip"
+      "skip"
+    when "Return"
+      "return"
+      
+    when "Goto"
+      "goto #{node.goto_label}"
+
+    when "Conditional"
+      # eval confition
+      condition = node.condition.traverse { |m, node_type, enode, node_val  | m.concat( expression_value(node_type, enode, node_val)) }
+
+      # eval if -branch
+      true_stmts = node.if_true.traverse do |memo,node_type, node|
+        memo.concat( statement_value( node_type, node ))
+      end
+
+      # default else empty 
+      else_stmts = nil
+      else_stmts = node.if_not_true.traverse do |memo,node_type, node|
+        memo.concat( statement_value( node_type, node )) 
+      end if node.if_not_true
+      
+      
+      "if ( #{condition} ) #{true_stmts}#{ else_stmts ? ' else ' + else_stmts : '' }"
+      
+    when "Either"
+
+      statements = []
+      # iterate all statemens in and collect an rray
+      node.choices.each do |s|
+        statements << s.traverse do |memo,node_type, node|
+          memo.concat( statement_value( node_type, node ))
+        end
+      end
+      
+      "either #{statements.first} or #{statements[1..-1].join( " or " )}"
+    when "Print"
+      print_expression = node.print_expression && node.print_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val)) }
+      "print #{print_expression}"
+    when "Assert"
+      assertion = node.assertion.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val)) }
+      "assert( #{assertion} )"
+
+    when "Assignment"
+      lvalue = node.lvalue.recurse_lvalue()
+      rvalue = node.rvalue.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val)) }
+      "#{lvalue}:=#{rvalue}"
+    when "CompoundStatement"
+      statements = []
+      # iterate all statemens in and collect an rray
+      node.statements.each do |s|
+        statements << s.traverse(""){ |memo,node_type, node|
+          memo.concat( statement_value( node_type, node ))
+        }
+      end
+      "{#{statements.map {|s| s + ";\n" }.join }}"
+    when "Call", "MacroCall"
+      # evaluate expression to collect actual parameters
+      actual_paramters = []
+      node.actual_parameters.each do |expr_node|
+        actual_paramters << expr_node.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val)) }
+      end
+      "#{node_type == 'Call' ? 'call ' : '' }#{node.called}(#{actual_paramters.join(',')})"
+    else
+      raise "Unknwon expression node type #{node_type} for node #{node}" 
+    end
+  end
+
+  # ------------------------------------------------------------------
+  # Visitor for expresssion
+
+  # @param node_type [String] AST node type
+  # @param node [SyntaxNode] current AST node being traversed
+  # @param node_val [String] prefix,infix, postfix value overridded in `AbstactExpression`
+  # @return [String] value for traversing the node
+  def expression_value( node_type, node, node_val )
+    # puts( "#{__method__} entered node_type=#{node_type}, node_val=#{node_val}, parent=#{node.parent.node_type}"  )
+    case node_type
+    when "AdditiveExpression", "MultitiveExpression", "UnaryExpression", "ParenthesisExpression",
+         "Identifier", "RecordField", "StringValue", "OriginalValue"
+      node_val
+    when "PrimaryExpression"
+      accessors=[]
+      node.attribute_accessors && node.attribute_accessors.each do |identfier|
+        attribute = identfier.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        accessors << attribute
+      end
+      ret = accessors.join('')
+      ret
+    when "FieldByName"
+      ".#{node_val}"
+    when "FieldByValue"      
+      ret = "[#{node_val}]"
+      # puts "FieldByValue=>#{ret}"
+      ret
+    when "RecordExcept"
+      elements=[]
+      node.record_field_definitions && node.record_field_definitions.each_with_index do |field_node,i|
+        lvalue_expression = field_node.lvalue_expression.recurse_lvalue
+        rvalue_expression = field_node.rvalue_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        elements << "#{lvalue_expression}=#{rvalue_expression}"
+      end
+      ret = "[#{node.record_identifier} EXCEPT #{elements.join(',')}]"
+      # puts "RecordExcept=>#{ret}"
+      ret
+    when "RecordDefinition"
+      elements=[]
+      node.record_fields.each do |field|
+        element_name = field.element_name.node_value
+        element_value = field.element_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        elements << "#{element_name}|->#{element_value}"
+      end
+      "[#{elements.join(',')}]"
+    when "SetExpressionMap"
+      "#{node_val}"
+      
+      bind_var = nil
+      bind_set = nil
+      
+      set_expression = node.set_expression && node.set_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      
+      bind_set = node.binds_node && node.binds_node.bind_set.traverse { |m, node_type, enode, node_val | m.concat( expression_value(node_type, enode, node_val)) } 
+      bind_var = node.binds_node && node.binds_node.bind_var.node_value
+      # puts "SetExpression: bind_var=#{bind_var}"
+      
+      return "{#{set_expression}: #{bind_var} \\in #{bind_set}}"
+      
+    when "SetExpression"
+      set_expression = nil
+      bind_var = nil
+      bind_set = nil
+      
+      if node.set_expression then
+        set_expression = node.set_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        # puts "SetExpression: set_expression=#{set_expression}"
+      end
+
+      if node.binds_node then
+        bind_set = node.binds_node.bind_set.traverse { |m, node_type, enode, node_val | m.concat( expression_value(node_type, enode, node_val)) } 
+        # puts "SetExpression: bind_set=#{bind_set}"
+        bind_var = node.binds_node.bind_var.node_value
+        # puts "SetExpression: bind_var=#{bind_var}"
+      end
+      
+      if  bind_var && set_expression
+        return "{ #{bind_var} \\in #{bind_set} : #{ set_expression} }"
+      elsif set_expression
+        return "{#{ set_expression}}"
+      else
+        "{}"
+      end
+    when "SequenceExpression"
+      tuples=[]
+      node.tuples.each { |tuple|
+        tuples << tuple.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      }
+      
+      "<<#{tuples.join(',')}>>"
+    when "OperatorExpression"
+
+      arguments=[]
+      node.arguments.each { |arg|
+        arguments << arg.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      }
+      record_field = node.record_field
+      
+      "#{node_val}(#{arguments.join(',')})#{ record_field ? "." + record_field : ''}"
+
+    when "ChooseExpression"
+        bind_set = node.binds_node.bind_set.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        bind_var = node.binds_node.bind_var.node_value
+        choose_expression = node.choose_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      
+        "CHOOSE #{bind_var} \\in #{bind_set}: #{choose_expression}"
+    when "QuantifyExpression"
+      binds = []
+      node.binds_nodes.each { |b|
+        bind_set = b.bind_set.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+        bind_var = b.bind_var.node_value
+        binds << "#{bind_var} \\in #{bind_set}"
+      }
+      # manually traverse quantified expression
+      quantified_expression = node.quantified_expression.traverse { |m, node_type, enode, node_val| m.concat( expression_value(node_type, enode, node_val )) }
+      "#{node_val} #{binds.join(', ')} : #{quantified_expression}"
+    when "IntegerValue"
+      "#{node_val}"
+    else
+      raise "Unknwon expression node type #{node_type} with value #{node_val}" 
+    end
+  end
+
+
+  # ------------------------------------------------------------------
+  # interface
+  describe "interface" do
+
+    describe "static" do
+      
+      it "#version" do
+        expect( described_class ).to respond_to( :version )
+      end
+    end # static
+    
+  end
+
+  # ------------------------------------------------------------------
+  # parse
+  describe "parse" do
+
+    
+    
+    context "egde-case" do
+      
+      it "#returns nil for nil input" do
+        expect( parser.parse( nil )).to eql( nil )
+      end
+      
+    end
+
+
+    # ---------------------------------
+    # ReservedWords
+    
+    describe "ReservedWord" do
+
+      [
+        "ASSUME", "ELSE", "LOCAL", "UNION", "ASSUMPTION", "ENABLED",
+        "MODULE", "VARIABLE", "AXIOM", "EXCEPT", "OTHER",
+        "VARIABLES", "CASE", "EXTENDS", "SF_", "WF_", "CHOOSE",
+        "IF", "SUBSET", "WITH", "CONSTANT", "IN", "THEN",
+        "CONSTANTS" , "INSTANCE", "THEOREM", "COROLLARY", "DOMAIN",
+        "LET", "UNCHANGED", "BY", "HAVE", "QED", "TAKE", "DEF",
+        "HIDE", "RECURSIVE", "USE", "DEFINE", "PROOF", "WITNESS",
+        "PICK", "DEFS", "PROVE", "SUFFICES", "NEW", "LAMBDA",
+        "STATE", "ACTION", "TEMPORAL", "OBVIOUS", "OMITTED",
+        "ONLY",
+        "LEMMA", "PROPOSITION",
+      ].each do |word|
+        it "#ReservedWord #{word}" do
+          expect( parse_nodes( word, :reserved_word ) ).to eql( { :node_type => "ReservedWord", :value => word } )
+        end
+      end # each
+      
+    end # describe reservedWord
+
+    # ------------------------------------------------------------------
+    # Common cases
+    
+    describe "Common" do
+      [
+
+        # ------------------------------------------------------------------
+        # String
+        {
+          :str => '"string value"',
+          :desc => "String value in double quotes",                    
+          :start => :string,
+          :exception => nil,
+          :expect => { :node_type => "StringValue", :value =>  '"string value"' },
+        },
+        
+        # ------------------------------------------------------------------
+        # Integer
+        
+        {
+          :str => "139",
+          :desc => "Positive integer",
+          :start => :integer,
+          :expect => { :node_type => "IntegerValue", :value =>  139 },
+        },
+        {
+          :str => "+140",
+          :desc => "Positive integer, prefix +",
+          :start => :integer,
+          :expect => { :node_type => "IntegerValue", :value =>  140 },
+        },
+        {
+          :str => "-141",
+          :desc => "Negative integer, prefix -",
+          :start => :integer,
+          :expect => { :node_type => "IntegerValue", :value =>  -141 },
+        },
+        
+        # ------------------------------------------------------------------
+        # Identifiers
+        
+        {
+          :str => "tst",
+          :desc => "Simple case for identifier",
+          :start => :identifier,
+          :expect => { :node_type => "Identifier", :value => "tst" },
+        },
+        {
+          :str => "id1, 
+                   id2",
+          :desc => "Identifier list",                    
+          :start => :identifier_list,
+          :expect => {
+            :node_type => "IdentifierList",
+            :value => [{ :node_type => "Identifier", :value => "id1" }, { :node_type => "Identifier", :value => "id2" }] }
+        },
+
+        # ------------------------------------------------------------------
+        # Keywords
+        
+        
+        {
+          :str => "OTHER",
+          :desc => "Reserved word is not an identifier",                    
+          :start => :identifier,
+          :exception => "Expected one of",
+          :expect => nil,
+        },
+        {
+          :str => "OTHER",
+          :desc => "Reserved word parse",                    
+          :start => :reserved_word,
+          :expect => { :node_type => "ReservedWord", :value => "OTHER" },          
+        },
+        
+        
+      ].each_with_index do |testCase,i|
+
+
+        it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+          if ( testCase[:debug] )
+            tree = parser.parse( testCase[:str], testCase[:start] )
+            puts ""
+            puts tree.inspect
+          end
+          
+          if testCase[:exception] then
+            expect { parse_nodes( testCase[:str], testCase[:start] ) }.to raise_exception TlaParserS::ParseException, %r<#{testCase[:exception]}>
+          else
+            expect( parse_nodes( testCase[:str], testCase[:start] ) ).to eql( testCase[:expect] )
+          end
+        end
+
+        
+      end # each 
+      
+    end # common
+
+    
+    
+  end # describe "parse" do
+
+  
+  # ------------------------------------------------------------------
+  # Version
+  describe "version" do
+    it "#is string" do
+      expect( described_class.version ).to be_a( String )
+    end
+    
+  end
+
+  # ------------------------------------------------------------------
+  # statement
+
+  describe "Statements" do
+
+    [
+      {
+        :str => "skip",
+        :desc => "Skip",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "skip", 
+      },
+
+      
+      {
+        :str => "l1: skip",
+        :desc => "Skip with label",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "l1: skip", 
+      },
+
+      
+      {
+        :str => "goto goto_label",
+        :desc => "Unlabeled goto",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "goto goto_label", 
+      },
+
+      {
+        :str => "assert TRUE",
+        :desc => "Assert expression",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "assert( TRUE )", 
+      },
+
+      {
+        :str => "l1: goto leibel",
+        :desc => "Labeled goto",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "l1: goto leibel", 
+      },
+
+      {
+        :str => "call proc(  )",
+        :desc => "Call procedure, no paramters",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "call proc()", 
+      },
+      
+      {
+        :str => "call proc( 1  )",
+        :desc => "Call procedure, 1 integer",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "call proc(1)", 
+      },
+
+      
+      {
+        :str => "call proc( 2 , 3 )",
+        :desc => "Call procedure, 2 integers",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "call proc(2,3)", 
+      },
+      
+      {
+        :str => "call proc( 2 , 3+c * 4, (  1*8) )",
+        :desc => "Call procedure, three expressions",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "call proc(2,3+c*4,(1*8))", 
+      },
+
+      {
+        :str => "{}",
+        :desc => "Empty Compound statement",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{}", 
+      },
+      
+      {
+        :str => "{ skip; }",
+        :desc => "Compound statement with skip",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{skip;\n}", 
+      },
+      
+      {
+        :str => "{ l1: skip; }",
+        :desc => "Compound statement with label",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{l1: skip;\n}", 
+      },
+      
+      {
+        :str => "{ l1before_comment: 
+                   (* This is a comment *) 
+                    skip; 
+                 }",
+        :desc => "Comment after a label",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{l1before_comment: skip;\n}", 
+      },
+      
+      {
+        :str => '{ l2before_comment: 
+
+                   \* Comment
+
+                    skip; 
+                }',
+        :desc => "Comment after a label",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{l2before_comment: skip;\n}", 
+      },
+      
+      {
+        :str => '{ skip;
+
+                   (* comment*) 
+
+                   \* Comment
+
+                    skip; 
+                }',
+        :desc => "Two comments",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{skip;\nskip;\n}", 
+      },
+      
+      {
+        :str => "{ return; }",
+        :desc => "Return statement",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{return;\n}", 
+      },
+      
+      
+      {
+        :str => '{ l0: skip;
+                  l1: goto l0;}',
+        :desc => "Compound statement with two statemenets",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{l0: skip;\nl1: goto l0;\n}", 
+      },
+      {
+        :str => '{ 
+                   if ( TRUE )
+                       skip;
+                   return; 
+         }',
+        :desc => "if-no else within compound",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{if ( TRUE ) skip;\nreturn;\n}", 
+      },
+
+      
+
+      {
+        :str => '{ 
+                   if ( TRUE ) { 
+                        skip; 
+                   };
+                   return; 
+         }',
+        :desc => "Compound statement with if-no else",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "{if ( TRUE ) {skip;\n};\nreturn;\n}", 
+      },
+
+
+      {
+        :str => "either     skip   or     goto l1",
+        :desc => "Either or (simple)",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "either skip or goto l1", 
+      },
+      
+      {
+        :str => "either { skip; goto l1;}  or   goto l8",
+        :desc => "Either or (compouund)",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "either {skip;\ngoto l1;\n} or goto l8", 
+      },
+      
+      {
+        :str => "if (TRUE)  skip",
+        :desc => "Simplest if-then",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "if ( TRUE ) skip", 
+      },
+      
+      {
+        :str => "if (TRUE)  { skip; skip; } else    goto muualle  ",
+        :desc => "Simplest if-then-else",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "if ( TRUE ) {skip;\nskip;\n} else goto muualle", 
+      },
+
+      {
+        :str => 'if ( TRUE )  { skip; } else { skip; }',
+        :desc => "If-then(single)-else(compound)",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "if ( TRUE ) {skip;\n} else {skip;\n}", 
+      },
+
+
+      {
+        :str => "macro1(  )",
+        :desc => "macro call",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "macro1()", 
+      },
+      
+      {
+        :str => "macro2(  1,A )",
+        :desc => "macro call with actual parameters",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "macro2(1,A)", 
+      },
+      
+      {
+        :str => "print   1",
+        :desc => "Print expression",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "print 1", 
+      },
+      
+      
+      {
+        :str => "a := 1",
+        :desc => "Assignment statement",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "a:=1", 
+      },
+      
+      {
+        :str => "A.b := 43",
+        :desc => "Assignment rec.field",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "A.b:=43", 
+      },
+      
+      {
+        :str => "Apu[beetta] := 44",
+        :desc => "Assignment rec[name]",
+        :debug => false,
+        :start => :statement,
+        :exception => nil,
+        :expect => "Apu[beetta]:=44", 
+      },
+      
+    ].each_with_index do |testCase,i|
+        
+      it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+
+        tree = parser.parse( testCase[:str], testCase[:start] )          
+        if ( testCase[:debug] )
+          puts ""
+          puts tree.inspect
+        end
+
+        result = tree.traverse( "" ) do |memo, node_type, node |
+          # memo collect the string 
+          memo.concat( statement_value( node_type, node ))
+        end
+        
+        expect( result ).to eql( testCase[:expect] )
+      end
+    end      
+
+  end  # statement
+  
+
+  describe "Misc" do
+
+    describe "Newline" do 
+    
+      it "#newline" do
+        str = "\n"
+        expect = {:node_type=>"SyntaxNode", :value =>"\n" }
+        tree = parser.parse( str, :newline )
+        # puts
+        # puts tree.inspect
+        expect( tree.value ).to eql( expect ) 
+      end
+      
+    end
+
+    describe "comments" do
+      
+      it "#line comment without newline" do      
+        str = '\* comment '
+        expect = {:node_type=>"SyntaxNode", :value=> str }
+        tree = parser.parse( str, :comment )
+        # puts
+        # puts tree.inspect
+        expect( tree.value ).to eql( expect ) 
+      end
+      it "#line comment with newline" do      
+        str = "\\* commentti \n"
+        expect = {:node_type=>"SyntaxNode", :value=> str  }
+        tree = parser.parse( str, :comment )
+        # puts
+        # puts tree.inspect
+        expect( tree.value ).to eql( expect ) 
+      end
+      it "#block comment without newline" do      
+        str = '(* comment *) '
+        expect = {:node_type=>"SyntaxNode", :value=> str }
+        tree = parser.parse( str, :comment )
+        # puts
+        # puts tree.inspect
+        expect( tree.value ).to eql( expect ) 
+      end
+      
+      it "#block comment with newline" do      
+        str = "(* comment \n line 2 *)"
+        expect = {:node_type=>"SyntaxNode", :value=> str }
+        tree = parser.parse( str, :comment )
+        # puts
+        # puts tree.inspect
+        expect( tree.value ).to eql( expect ) 
+      end
+      
+    end
+    
+  end    # misc
+
+  # ------------------------------------------------------------------
+  # Macro
+  
+  describe "macro" do
+
+        context "testCases" do
+
+      [
+        {
+          :str => "macro id(){}",
+          :desc => "Macro 1 ",
+          :start => :macro,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+
+        {
+          :str => "macro id () {}",
+          :desc => "Macro 1 ",
+          :start => :macro,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+
+        {
+          :str => "macro id (a) {}",
+          :desc => "Macro 1 ",
+          :start => :macro,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+
+      ].each_with_index do |testCase,i|
+        
+        it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+
+          tree = parser.parse( testCase[:str], testCase[:start] )          
+          if ( testCase[:debug] )
+            puts ""
+            puts tree.inspect
+          end
+          expect( tree ).not_to eql( nil ) if testCase[:expect]
+
+        end # it
+      end # each
+      
+    end # testCases
+        
+
+
+    str = "macro id(a, b){skip;}"
+    let ( :tree ) { parser.parse( str, :macro ) }
+    
+    it "#name" do
+      expect = {}
+      # puts
+      # puts tree.inspect
+      expect( tree.name ).to eql( "id" ) 
+    end
+
+    it "#parameters" do
+      expect = {:node_type=>"Parameters", :value=>[{:node_type=>"Identifier", :value=>"a"}, {:node_type=>"Identifier", :value=>"b"}]}
+      # puts
+      # puts tree.inspect
+      expect( tree ).to respond_to( :parameters )
+      expect( tree.parameters ).to eql( expect ) 
+    end
+
+    it "#symbol_definitions" do
+      parameters = tree.parameters[:value]
+      symbol_definitions = tree.symbol_definitions
+      # TODO add local parameters here
+      expect( symbol_definitions ).to eql( parameters ) 
+    end
+
+    it "#body" do
+      expect = "{skip;\n}"
+      # puts
+      # puts tree.inspect
+      result = tree.body_node.traverse do |memo, node_type, node |
+        # memo collect the string
+        memo.concat( statement_value( node_type, node ))
+      end
+      expect( result ).to eql( expect )
+    end
+  end   # macro
+
+  # ------------------------------------------------------------------
+  # expression
+  
+  describe "expression" do
+
+    [
+      {
+        :str => "1  ",
+        :desc => "Integer value",
+        :start => :expression,
+        :debug => false,
+        :expect => "1",
+      },
+
+      {
+        :str => "+ 1",
+        :desc => "Unary operator ",
+        :start => :expression,
+        :debug => false,
+        :expect => "+1",
+      },
+      
+      {
+        :str => "~ TRUE",
+        :desc => "Not operator ",
+        :start => :expression,
+        :debug => false,
+        :expect => "~TRUE",
+      },
+
+      {
+        :str => "~TRUE",
+        :desc => "Not operator no spaces",
+        :start => :expression,
+        :debug => false,
+        :expect => "~TRUE",
+      },
+
+      {
+        :str => "- 1",
+        :desc => "Unary operator ",
+        :start => :expression,
+        :debug => false,
+        :expect => "-1",
+      },
+
+      {
+        :str => "A  ",
+        :desc => "Simple indentifier",
+        :start => :expression,
+        :debug => false,
+        :expect => "A",
+      },
+
+      {
+        :str => "1 + 3 ",
+        :desc => "Addition",
+        :start => :expression,
+        :debug => false,
+        :expect => "1+3",
+      },
+
+      {
+        :str => "1 \\/ 3 ",
+        :desc => "TLA or",
+        :start => :expression,
+        :debug => false,
+        :expect => '1\/3',
+      },
+
+      {
+        :str => 'A /\\    B \\/ C',
+        :desc => "TLA or",
+        :start => :expression,
+        :debug => false,
+        :expect => 'A/\B\/C',
+      },
+      
+      {
+        :str => "1 - 3 ",
+        :desc => "Minus",
+        :start => :expression,
+        :debug => false,
+        :expect => "1-3",
+      },
+
+      {
+        :str => "1 / 3 ",
+        :desc => "Divide",
+        :start => :expression,
+        :debug => false,
+        :expect => "1/3",
+      },
+
+      {
+        :str => "1 *6 ",
+        :desc => "Multiplication",
+        :start => :expression,
+        :debug => false,
+        :expect => "1*6",
+      },
+
+      {
+        :str => "-1 * +6 ",
+        :desc => "Unary operators in expression" ,
+        :start => :expression,
+        :debug => false,
+        :expect => "-1*+6",
+      },
+
+      {
+        :str => "1 + 2 * 3",
+        :desc => "Plus-multiplication",
+        :start => :expression,
+        :debug => false,
+        :expect => "1+2*3",
+      },
+
+      {
+        :str => "11 +  12 * 13",
+        :desc => "Mult plus",
+        :start => :expression,
+        :debug => false,
+        :expect => "11+12*13",
+      },
+
+      {
+        :str => "(111 +  112 ) * 113",
+        :desc => "Parentehesis",
+        :start => :expression,
+        :debug => false,
+        :expect => "(111+112)*113",
+      },
+
+      {
+        :str => "(111 +  112 ) * (113 * A)",
+        :desc => "Parentehesis",
+        :start => :expression,
+        :debug => false,
+        :expect => "(111+112)*(113*A)",
+      },
+
+
+      {
+        :str => '\A a \in   Set1   , b \in Set2: TRUE',        
+        :desc => "Quatification for-all",
+        :start => :expression,
+        :debug => false,
+        :expect => '\A a \in Set1, b \in Set2 : TRUE',
+      },
+      
+      {
+        :str => '\E b \in   Set1:  b \/ TRUE',        
+        :desc => "Quatification for-all",
+        :start => :expression,
+        :debug => false,
+        :expect => '\E b \in Set1 : b\/TRUE',
+      },
+
+      {
+        :str => '<< >>',        
+        :desc => "Empty sequence 0-tuple",
+        :start => :expression,
+        :debug => false,
+        :expect => '<<>>',
+      },
+
+      {
+        :str => '<< 1 >>',        
+        :desc => "Sequence one 1-tuple",
+        :start => :expression,
+        :debug => false,
+        :expect => '<<1>>',
+      },
+
+      {
+        :str => '<< 1, 2+A >>',        
+        :desc => "Sequence one 2-tuple",
+        :start => :expression,
+        :debug => false,
+        :expect => '<<1,2+A>>',
+      },
+
+      
+      {
+        :str => '{  }',        
+        :desc => "Empty set expression",
+        :start => :expression,
+        :debug => false,
+        :expect => '{}',
+      },
+
+      {
+        :str => '{ 1 }',        
+        :desc => "Set with expression",
+        :start => :expression,
+        :debug => false,
+        :expect => '{1}',
+      },
+      
+      
+      {
+        :str => '{ x  \in Set: TRUE }',        
+        :desc => "Set contruction using select expression",
+        :start => :expression,
+        :debug => false,
+        :expect => '{ x \in Set : TRUE }',
+      },
+      
+      {
+        :str => '{ x.id :    x  \in Set }',        
+        :desc => "Set contruction using element mapper",
+        :start => :expression,
+        :debug => false,
+        :expect => '{x.id: x \in Set}',
+      },
+      
+      {
+        :str => 'op()',        
+        :desc => "Operator expression - no parameters",
+        :start => :expression,
+        :debug => false,
+        :expect => 'op()',
+      },
+      
+      {
+        :str => 'op( ).kentta',        
+        :desc => "Operator expression - field",
+        :start => :expression,
+        :debug => false,
+        :expect => 'op().kentta',
+      },
+      
+      {
+        :str => 'op( ).k1.k2',        
+        :desc => "Operator expression - fields",
+        :start => :expression,
+        :debug => false,
+        :expect => 'op().k1.k2',
+      },
+      
+      {
+        :str => 'op ( 1, TRUE )',        
+        :desc => "Operator expression - with parametes",
+        :start => :expression,
+        :debug => false,
+        :expect => 'op(1,TRUE)',
+      },
+
+
+      {
+        :str => 'A = B',        
+        :desc => "Equal as expression",
+        :start => :expression,
+        :debug => false,
+        :expect => 'A=B',
+      },
+
+      {
+        :str => '1 # 2',        
+        :desc => "Inqueality",
+        :start => :expression,
+        :debug => false,
+        :expect => '1#2',
+      },
+
+      {
+        :str => '1 = 2 + 3',        
+        :desc => "Equal as expression",
+        :start => :expression,
+        :debug => false,
+        :expect => '1=2+3',
+      },
+
+      {
+        :str => '1 > 2',        
+        :desc => "Greater than operator",
+        :start => :expression,
+        :debug => false,
+        :expect => '1>2',
+      },
+
+      {
+        :str => '1 >= 2',        
+        :desc => "Greater than or equal operator",
+        :start => :expression,
+        :debug => false,
+        :expect => '1>=2',
+      },
+
+
+      {
+        :str => '1 <= 2',        
+        :desc => "Less than or equal operator",
+        :start => :expression,
+        :debug => false,
+        :expect => '1<=2',
+      },
+
+      
+      {
+        :str => '[ ]',        
+        :desc => "Empty record",
+        :start => :expression,
+        :debug => false,
+        :expect => '[]',
+      },
+      
+      {
+        :str => '[ a|->b]',        
+        :desc => "One record field",
+        :start => :expression,
+        :debug => false,
+        :expect => '[a|->b]',
+      },
+      
+      {
+        :str => 'FALSE => TRUE',        
+        :desc => "Implication",
+        :start => :expression,
+        :debug => false,
+        :expect => 'FALSE=>TRUE',
+      },
+      
+
+      {
+        :str => '1 = 2  => 3 = 4',        
+        :desc => "Implication w. association",
+        :start => :expression,
+        :debug => false,
+        :expect => '1=2=>3=4',
+      },
+
+      {
+        :str => "A.id  ",
+        :desc => "Record field by name",
+        :start => :expression,
+        :debug => false,
+        :expect => "A.id",
+      },
+
+      {
+        :str => "A.id1.id2  ",
+        :desc => "Record field by names",
+        :start => :expression,
+        :debug => false,
+        :expect => "A.id1.id2",
+      },
+
+      {
+        :str => "A.id1.id2.id3  ",
+        :desc => "Record field by three names",
+        :start => :expression,
+        :debug => false,
+        :expect => "A.id1.id2.id3",
+      },
+
+      
+      {
+        :str => 'rec[key] ',        
+        :desc => "Record access by value",
+        :start => :expression,
+        :debug => false,
+        :expect => 'rec[key]',
+      },
+      
+      {
+        :str => '[ name |-> name, address |-> address ]',        
+        :desc => "Record as an expression",
+        :start => :expression,
+        :debug => false,
+        :expect => '[name|->name,address|->address]',
+      },
+      
+      # v_ids := [  v_ids EXCEPT ![id_type] = @ \ { Next_id( id_type ) } ] ;      
+
+      {
+        :str => '[  v_ids EXCEPT ![id] = a ] ',        
+        :desc => "Record except, one field using a (indetifier)",
+        :start => :expression,
+        :debug => false,
+        :expect => '[v_ids EXCEPT ![id]=a]',
+      },
+
+      {
+        :str => '[  v_ids EXCEPT ![id] = a ] . fiildi [ aa ] ',        
+        :desc => "Record except with record access)",
+        :start => :expression,
+        :debug => false,
+        :expect => '[v_ids EXCEPT ![id]=a].fiildi[aa]',
+      },
+
+      {
+        :str => '[  v_ids EXCEPT ![id] = @ ] ',        
+        :desc => "Record except, one field using @ (original value)",
+        :start => :expression,
+        :debug => false,
+        :expect => '[v_ids EXCEPT ![id]=@]',
+      },
+
+      
+      {
+        :str => '[  v_ids EXCEPT ![id] = 0, ![uid] = 1+2 ] ',        
+        :desc => "Record except",
+        :start => :expression,
+        :debug => false,
+        :expect => '[v_ids EXCEPT ![id]=0,![uid]=1+2]',
+      },
+
+      {
+        :str => '[  v_ids EXCEPT ![id] = A*a ] ',        
+        :desc => "Record except, one field",
+        :start => :expression,
+        :debug => false,
+        :expect => '[v_ids EXCEPT ![id]=A*a]',
+      },
+
+
+      {
+        :str => 'A \ B \cup C \union D \cap E \intersect F \/ TRUE /\ FALSE',        
+        :desc => "Set operators",
+        :start => :expression,
+        :debug => false,
+        :expect => 'A\B\cupC\unionD\capE\intersectF\/TRUE/\FALSE',
+      },
+
+      {
+        :str => 'CHOOSE    x \in  t_Owner  : 1+2',        
+        :desc => "CHOOSE expression",
+        :start => :expression,
+        :debug => false,
+        :expect => 'CHOOSE x \in t_Owner: 1+2',
+      },
+
+      {
+        :str => 'elementti \in Set',        
+        :desc => "Expr in setup ",
+        :start => :expression,
+        :debug => false,
+        :expect => 'elementti\inSet',
+      },
+      
+
+      
+    ].each_with_index do |testCase,i|
+
+      it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+        tree = parser.parse( testCase[:str], testCase[:start] )
+        if ( testCase[:debug] )
+          puts ""
+          puts tree.inspect
+        end
+        
+        expect( tree.traverse( "" ) { |memo, node_type, enode, node_val|
+                  # memo collect the string 
+                  memo.concat( expression_value( node_type, enode, node_val  ))
+                } ).to eql( testCase[:expect] )
+      end # it
+      
+    end # each 
+    
+  end # expression
+
+  # ------------------------------------------------------------------
+  # Directives
+  
+  describe "Directive" do
+
+    [
+      {
+        :str => "ASSUME Assume_Domains",
+        :desc => "Singe asssume",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [ "Assume_Domains" ],
+      },
+
+      {
+        :str => "ASSUME a1 a2",
+        :desc => "Two asssumes",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [ "a1", "a2" ],
+      },
+
+      {
+        :str => "INVARIANT i1",
+        :desc => "Singe asssume",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [ "i1" ],
+      },
+      
+      {
+        :str => "INVARIANT i2 i3",
+        :desc => "Two invaints",
+        :start => :directive,
+        :exception => nil,
+        :debug => false,
+        :expect => [ "i2", "i3" ],
+      },
+      
+
+    ].each_with_index do |testCase,i|
+        
+      it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+
+        tree = parser.parse( testCase[:str], testCase[:start] )          
+        if ( testCase[:debug] )
+          puts ""
+          puts tree.inspect
+        end
+
+        result = tree.directives
+        
+        expect( result ).to eql( testCase[:expect] )
+      end
+    end # each testCases
+  end # 
+      
+  
+
+  # ------------------------------------------------------------------
+  # Operator definition
+  
+  describe "Operator definition" do
+
+    [
+      {
+        :str => "operator == TRUE",
+        :desc => "Simple constant operator without parameters",
+        :start => :operator,
+        :exception => nil,
+        :debug => false,
+        :expect => {
+          :parameters=>nil,
+          :expression => "TRUE"
+        },
+      },
+
+      {
+        :str => "itWork( param1 )  == TRUE",
+        :desc => "Simple constant operator with parameters",
+        :start => :operator,
+        :exception => nil,
+        :debug => false,
+        :expect => {
+          :parameters=>{:node_type=>"Parameters", :value=>[{:node_type=>"Identifier", :value=>"param1"}]},
+          :expression => "TRUE"
+        },
+      },
+      
+      {
+        :str => 'itCalls == itWorks( param1 ) \/ TRUE',
+        :desc => "Constant operator defining operator expression with parameter",
+        :start => :operator,
+        :exception => nil,
+        :debug => false,
+        :expect => {
+          :expression => 'itWorks(param1)\/TRUE'
+        },
+      },
+      
+    ].each_with_index do |testCase,i|
+
+      it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+        tree = parser.parse( testCase[:str], testCase[:start] )
+        
+        if ( testCase[:debug] )
+          puts ""
+          puts tree.inspect
+        end
+        
+        
+        if testCase[:exception] then
+          expect { parse_nodes( testCase[:str], testCase[:start] ) }.to raise_exception TlaParserS::ParseException, %r<#{testCase[:exception]}>
+        else
+          result = {}
+          testCase[:expect].each  do |k,v|
+            case k
+            when :parameters
+              result[k] = tree.parameters
+            when :expression
+              result[k] = tree.body_node.traverse( "" ) { |memo, node_type, enode, node_val|
+                # memo collect the string 
+                memo.concat( expression_value( node_type, enode, node_val ))
+              }
+            else
+                raise "Unknow expection type #{k} in #{testCase[:expect]}"
+            end
+          end
+          expect( result ).to eql( testCase[:expect] )
+
+        end
+      end # it
+      
+    end # each 
+
+    
+  end # operator
+
+  # ------------------------------------------------------------------
+  # operator
+
+  describe "operator" do
+
+    str = "A( id ) == 1"
+    let ( :tree ) { parser.parse( str, :operator ) }
+
+    it "#parameters" do
+      expect( tree.parameters[:value].length ).to eql( 1 ) 
+    end
+    
+
+    it "#symbol_definitions" do
+      parameters = tree.parameters[:value]
+      symbol_definitions = tree.symbol_definitions
+      expect( symbol_definitions ).to eql( parameters ) 
+    end
+
+  end
+  
+  # ------------------------------------------------------------------
+  # Variable definition
+  
+  describe "variables" do
+
+    context "testCases" do
+
+      [
+        {
+          :str => "a= {}",
+          :desc => "Init to emty set",
+          :start => :variable,
+          :exception => nil,
+          :debug => false,
+          :expect => "{}",
+        },
+
+        {
+          :str => "a= {} ;",
+          :desc => "Init to emty set optional semicolnon",
+          :start => :variable,
+          :exception => nil,
+          :debug => false,
+          :expect => "{}",
+        },
+
+        
+        {
+          :str => "a = {}",
+          :desc => "Init to emty set",
+          :start => :variable,
+          :exception => nil,
+          :debug => false,
+          :expect => "{}",
+        },
+        
+        {
+          :str => "a = 1",
+          :desc => "Init to integerer",
+          :start => :variable,
+          :exception => nil,
+          :debug => false,
+          :expect => "1",
+        },
+        
+      ].each_with_index do |testCase,i|
+        
+        it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+          tree = parser.parse( testCase[:str], testCase[:start] )          
+          if ( testCase[:debug] )
+            puts ""
+            puts tree.inspect
+          end
+          expect( tree ).not_to eql( nil ) unless testCase[:exception]
+          expect( tree.init.traverse { |memo, node_type, enode, node_val|
+                  memo.concat( expression_value( node_type, enode, node_val  ))
+                  } ).to eql( testCase[:expect] )
+          
+
+        end # it
+      end # each
+      
+    end # testCases
+
+  end # describe "variables" do
+  
+
+  # ------------------------------------------------------------------
+  # Procedure definition
+  
+  describe "procedure" do
+
+    context "testCases" do
+
+      [
+        {
+          :str => "procedure id(a){}",
+          :desc => "Procedure ",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+        {
+          :str => "procedure id(){}",
+          :desc => "Procedure ",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+        {
+          :str => "procedure id( a ) {} ;",
+          :desc => "Procedure ",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+        {
+          :str => "procedure id( a,b ){}",
+          :desc => "Procedure ",
+          :start => :procedure,
+          :exception => nil,
+          :debug => false,
+          :expect => true,
+        },
+      ].each_with_index do |testCase,i|
+        
+        it "#Case #{i}: #{testCase[:desc]} - parse '#{testCase[:str]}' starting '#{testCase[:start]}'" do
+
+
+          tree = parser.parse( testCase[:str], testCase[:start] )          
+          if ( testCase[:debug] )
+            puts ""
+            puts tree.inspect
+          end
+          expect( tree ).not_to eql( nil ) if testCase[:expect]
+
+        end # it
+      end # each
+      
+    end # testCases
+
+    str = "procedure id(a,b){ goto l88; skip; }"
+    let ( :tree ) { parser.parse( str, :procedure ) }
+    
+    it "#name" do
+      expect = {}
+      expect( tree.name ).to eql( "id" ) 
+    end
+
+    it "#parameters" do
+      expect = {:node_type=>"Parameters", :value=>[{:node_type=>"Identifier", :value=>"a"}, {:node_type=>"Identifier", :value=>"b"}]}
+      expect( tree.parameters ).to eql( expect ) 
+    end
+
+    it "#symbol_definitions" do
+      parameters = tree.parameters[:value]
+      symbol_definitions = tree.symbol_definitions
+      # TODO add local parameters here
+      expect( symbol_definitions ).to eql( parameters ) 
+    end
+    
+    it "#body" do
+      expect = "{goto l88;\nskip;\n}"
+      # puts
+      # puts tree.inspect
+      result = tree.body_node.traverse do |memo, node_type, node |
+        # memo collect the string
+        memo.concat( statement_value( node_type, node ))
+      end
+      expect( result ).to eql( expect )
+      
+    end
+    
+  end  # procedure
+  
+  
+end