tla-trace-filter 0.0.3

data/spec/fixtures/trace.txt

@@ -0,0 +1,102 @@
+(export TLATOOLS=~/java/tla/tla2tools.jar; cd ~/work/tla-sbuilder; cd tmp/aruba; cd  gen/example/tla/; java -cp $TLATOOLS pcal.trans model;  java -cp $TLATOOLS tlc2.TLC setup -dump state | tee err.dump )
+pcal.trans Version 1.8 of 2 Apr 2013
+Parsing completed.
+Warning: symbols were renamed.
+Translation completed.
+New file model.tla written.
+New file model.cfg written.
+TLC2 Version 2.07 of 1 June 2015
+Running in Model-Checking mode.
+Parsing file setup.tla
+Parsing file model.tla
+Parsing file /tmp/TLC.tla
+Parsing file /tmp/FiniteSets.tla
+Parsing file /tmp/Sequences.tla
+Parsing file /tmp/Integers.tla
+Parsing file /tmp/Naturals.tla
+Semantic processing of module Naturals
+Semantic processing of module Sequences
+Semantic processing of module TLC
+Semantic processing of module FiniteSets
+Semantic processing of module Integers
+Semantic processing of module model
+Semantic processing of module setup
+Starting... (2017-10-02 10:29:22)
+Computing initial states...
+Finished computing initial states: 1 distinct state generated.
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+Error: Invariant Customers_ValidDomain is violated.
+Error: The behavior up to this point is:
+State 1: <Initial predicate>
+/\ tx_running = FALSE
+/\ steps = << { [ process |-> "p__customer_post_",
+       bindRule |-> WildCard,
+       bindSet |-> Nil,
+       ctx |-> Nil ] } >>
+/\ resume_context = Nil
+/\ dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+/\ now = 0
+/\ pc = ("Tail" :> "tail_wait" @@ "/customer(post)" :> "p__customer_post__enter")
+/\ step_parameter = {}
+/\ input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+/\ step = Nil
+/\ responses = Nil
+/\ customers = {}
+/\ stack = ("Tail" :> <<>> @@ "/customer(post)" :> <<>>)
+
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+<<"Default process p__customer_post_ for operation '/customer(post)',tick=", 0>>
+<<"/customer(post) called!!!">>
+State 2: <Action line 638, col 28 to line 653, col 78 of module model>
+/\ tx_running = TRUE
+/\ steps = << { [ process |-> "p__customer_post_",
+       bindRule |-> WildCard,
+       bindSet |-> Nil,
+       ctx |-> Nil ] } >>
+/\ resume_context = Nil
+/\ dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+/\ now = 1
+/\ pc = ("Tail" :> "tail_wait" @@ "/customer(post)" :> "p__customer_post__exit")
+/\ step_parameter = [ process |-> "p__customer_post_",
+  bindRule |-> WildCard,
+  bindSet |-> Nil,
+  ctx |-> Nil ]
+/\ input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+/\ step = "p__customer_post_"
+/\ responses = Nil
+/\ customers = {[customer |-> [id |-> Nil, type |-> Nil, name |-> Nil]]}
+/\ stack = ("Tail" :> <<>> @@ "/customer(post)" :> <<>>)
+
+9 states generated, 2 distinct states found, 1 states left on queue.
+The depth of the complete state graph search is 2.
+Finished. (2017-10-02 10:29:22)
+
+Compilation finished at Mon Oct  2 10:29:22

data/spec/parser/node_extensions_spec.rb

@@ -0,0 +1,9 @@
+require_relative "../spec_helper.rb"
+
+describe TlaTraceFilter::Parser::Grammar do
+
+  # Framework ok?
+  it { expect( 1 ).to eql 1 } 
+  
+  
+end 

data/spec/parser/parser_spec.rb

@@ -0,0 +1,392 @@
+require_relative ("../spec_helper.rb")
+
+describe TlaTraceFilter::Parser::Parser do
+
+  it { expect( described_class ).to be_a Class }
+
+  let( :parser ) { described_class.new  }
+  let( :grammar_module ) { TlaTraceFilter::Parser::Grammar  }  
+
+  # ------------------------------------------------------------------
+  # Interface
+  describe "module interface" do
+    describe "class-methods" do
+      subject { described_class }
+      %i[ parser_instance ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+
+    describe "instance-methods" do
+      subject { described_class.new }
+      %i[  parse ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+  end
+
+
+  describe ".parser_instance" do
+    let( :parser_instance ) { described_class.parser_instance  }
+    it { expect( parser_instance ).to be_a TlaTraceFilter::Parser::GrammarParser }
+  end
+
+  # ------------------------------------------------------------------
+  # parse rules
+  
+  describe "#parse" do
+    let( :parse ) { parser.parse( data, start)  }
+    context "start==nil" do
+      let( :start ) { nil  }
+    end
+    
+    context "start:string" do
+      let( :start ) { :string  }
+      context "data:string" do
+        let( :data ) { '"string"'  }
+        it { expect( parse ).to be_a grammar_module::SyntaxNode  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # start:string
+
+    context "start:integer" do
+      let( :start ) { :integer  }
+      context "data:123" do
+        let( :data ) { '123' }
+        it { expect( parse ).to be_a grammar_module::SyntaxNode  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # start:string
+
+    context "start:name" do
+      let( :start ) { :name  }
+      context "data:name" do
+        let( :data ) { 'name_123asAA'  }
+        it { expect( parse ).to be_a grammar_module::SyntaxNode  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context "data:_name" do
+        let( :data ) { '_name_123asAA'  }
+        it { expect( parse ).to be_a grammar_module::SyntaxNode  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # start:string
+
+    context "start:resered_word" do
+      let( :start ) { :reserved_word  }
+      %w[ Nil FALSE TRUE ].each do |word|
+        context "word=#{word}" do
+          let( :data ) { word  }
+          it { expect( parse.text_value ).to eql data  }         
+        end 
+      end
+    end 
+    
+    context "start:whitespace" do
+      let( :start ) { :whitespace  }
+      context "one space character" do
+        let( :data ) { " "  }
+        it { expect( parse ).to be_a grammar_module::SyntaxNode  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+      context "data:string" do
+        let( :data ) { '"string"'  }
+        it { expect{ parse }.to raise_error TlaTraceFilter::Parser::ParseException, /Expected/ }
+      end
+    end # start:whipeace
+
+    context "start:sequence_value" do
+      let( :start ) { :sequence_value  }
+      context "{}" do
+        let( :data ) { "<< >>"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context "{Nil}" do
+        let( :data ) { "<< >>"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # sequence
+
+    context "start:record_value" do
+      let( :start ) { :record_value  }
+      context "[]" do
+        let( :data ) { "[]"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context '[ process |-> "p__customer_post_" ]' do
+        let( :data ) { '[ process |-> "p__customer_post_" ]'  }
+        it { expect( parse.text_value ).to eql data  }
+        # it { puts parse.inspect }
+        it { expect( parse ).to be_a grammar_module::RecordValue}
+        it { expect( parse.record_elements.length ).to eql 1 }
+        it { expect( parse.record_elements ).to be_a Array }
+        describe "expectRecor" do
+          let( :expectRecord ) {  { "process" => "p__customer_post_"}  }
+          it { expect( parse.value ).to eql  expectRecord }        
+          it { expect( parse.record_elements.map{ |e| { e.element_name.value =>e.element_value.value } } ).to eql [ expectRecord ]  }
+          it { expect( parse.record_elements.map{ |e|  e.value  } ).to eql [ expectRecord ]  }                        
+        end 
+      end 
+      context '[ process |-> "p__customer_post_", key |-> 2 ]' do
+        let( :data ) { '[ process |-> "p__customer_post_", key |-> 2 ]'  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # sequence
+
+    context "start:function_value" do
+      let( :start ) { :function_value  }
+      context "()" do
+        let( :data ) { "()"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+      context "()" do
+        let( :data ) { "( )"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+    end # function_value
+
+    context "start:state_variable" do
+      let( :start ) { :state_variable  }
+      let( :state_variable ) { parse.state_variable  }
+      let( :name ) { parse.name  }      
+      context "responses = Nil" do
+        let( :data ) { 'responses = Nil'  }
+        it { expect( parse.text_value ).to eql data  }
+        it { expect( parse ).to be_a grammar_module::StateVariable  }
+        # it { puts parse.inspect }
+        # it { puts parse.to_s }
+        it { expect( state_variable.text_value ).to eql "responses" }
+        it { expect( name ).to eql "responses" }        
+      end
+      context 'dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)' do
+        let( :data ) { 'dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)'  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+      context 'multi  line record' do
+        let( :data ) { 'steps = << { [ process |-> "p__customer_post_",
+       bindRule |-> WildCard,
+       bindSet |-> Nil,
+       ctx |-> Nil ] } >>'  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+    end # function_value
+    
+
+    context "start:composite_value" do
+      let( :start ) { :composite_value  }
+      context "{ << >> }" do
+        let( :data ) { "{ << >> }"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+      context '("Tail" :> <<>> @@ "/customer(post)" :> <<>>)' do
+        let( :data ) { '("Tail" :> <<>> @@ "/customer(post)" :> <<>>)'  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # composite value
+
+    context "start:set_value" do
+      let( :start ) { :set_value  }
+      context "{}" do
+        let( :data ) { "{}"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context "{ <space>}" do
+        let( :data ) { "{ }"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end
+      context "{ 1 }" do
+        let( :data ) { "{ 1 }"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context "{ 1,2 }" do
+        let( :data ) { "{ 1,2 }"  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+      context "{ 1,'aa' }" do
+        let( :data ) { '{ 1,"aa"}'  }
+        it { expect( parse.text_value ).to eql data  }         
+      end 
+    end # context "start:set_value" do
+
+    context "start:stace_space" do
+      let( :start ) { :state_space  }
+      context "trace.rb" do
+        let( :data ) {
+          <<~EOS
+          /\\ tx_running = TRUE
+          /\\ steps = << { [ process |-> "p__customer_post_",
+                 bindRule |-> WildCard,
+                 bindSet |-> Nil,
+                 ctx |-> Nil ] } >>
+          /\\ resume_context = Nil
+          /\\ dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+          /\\ now = 1
+          /\\ pc = ("Tail" :> "tail_wait" @@ "/customer(post)" :> "p__customer_post__exit")
+          /\\ step_parameter = [ process |-> "p__customer_post_",
+            bindRule |-> WildCard,
+            bindSet |-> Nil,
+            ctx |-> Nil ]
+          /\\ input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+          /\\ step = "p__customer_post_"
+          /\\ responses = Nil
+          /\\ customers = {[customer |-> [id |-> Nil, type |-> Nil, name |-> Nil]]}
+          /\\ stack = ("Tail" :> <<>> @@ "/customer(post)" :> <<>>)
+          EOS
+        }
+        # it { puts parse.inspect}
+        it { expect( parse.text_value ).to eql data  }         
+        
+      end # context "trace" do
+      
+    end  # context "start:stace_space" do
+
+  end  # parse
+
+  # ------------------------------------------------------------------
+  # Value
+
+  describe ":state_space#value" do
+    let( :parse ) { parser.parse( data, start)  }
+    let( :start ) { nil  }
+    context "trace" do
+        let( :data ) {
+          <<~EOS
+          /\\ tx_running = TRUE
+          /\\ steps = << { [ process |-> "p__customer_post_",
+                 bindRule |-> WildCard,
+                 bindSet |-> Nil,
+                 ctx |-> Nil ] } >>
+          /\\ resume_context = Nil
+          /\\ dummy_input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+          /\\ now = 1
+          /\\ pc = ("Tail" :> "tail_wait" @@ "/customer(post)" :> "p__customer_post__exit")
+          /\\ step_parameter = [ process |-> "p__customer_post_",
+            bindRule |-> WildCard,
+            bindSet |-> Nil,
+            ctx |-> Nil ]
+          /\\ input = ("Tail" :> Nil @@ "/customer(post)" :> Nil)
+          /\\ empty_seq = << >>
+          /\\ empty_rec = [ ]
+          /\\ nil_rec = [ test |-> Nil ]          
+          /\\ one_seq = << 1 >>
+          /\\ one_seq_seq = << 1, << >>  >>                        
+          /\\ dummy_set = {}
+          /\\ empty_function = ()
+          /\\ simple_function = ( "Tail" :> TRUE )
+          /\\ single_set = { 1 }
+          /\\ step = "p__customer_post_"
+          /\\ responses = Nil
+          /\\ customers = {[customer |-> [id |-> Nil, type |-> Nil, name |-> Nil]]}
+          /\\ stack = ("Tail" :> <<>> @@ "/customer(post)" :> <<1, FALSE >>)
+          EOS
+        }
+        it { expect( parse ).to be_a TlaTraceFilter::Parser::Grammar::StateSpace }
+        describe "#state_space" do
+          let ( :state_space ) { parse.state_space }
+          it { expect( state_space ).to be_a Hash }
+          # it { puts "parse =#{parse.inspect}" }
+          it { expect( state_space.keys ).to include( :now, :pc, :step ) }
+
+          describe "simple values" do
+            describe ":now" do
+              let ( :now ) { state_space[:now] }
+              # it { puts "now =#{now.inspect}" }
+              # it { puts "now.value =#{now.variable_value.inspect}" }            
+              it { expect( now.variable_value.value ).to eql 1 } 
+            end
+            describe ":tx_running" do
+              let ( :tx_running ) { state_space[:tx_running] }
+              # it { puts "now =#{now.inspect}" }
+              # it { puts "tx_running.value =#{tx_running.variable_value.inspect}" }            
+              it { expect( tx_running.variable_value.value ).to eql true } 
+            end
+            describe ":step" do
+              let ( :step ) { state_space[:step] }
+              # it { puts "now =#{now.inspect}" }
+              # it { puts "step.variable_value =#{step.variable_value.inspect}" }
+              # it { puts "step.variable_value.value. =#{step.variable_value.value.class}" }
+              it { expect( step.variable_value.value ).to eql "p__customer_post_" }
+            end
+            
+          end # smple values
+          describe "records" do
+            describe ":empty_rec" do
+              let ( :empty_rec ) { state_space[:empty_rec] }
+              # it { puts "empty_rec =#{empty_rec.inspect}" }
+              it { expect( empty_rec.variable_value.value ).to eql( {}  ) }
+            end
+            describe ":nil_rec" do
+              let ( :nil_rec ) { state_space[:nil_rec] }
+              # it { puts "nil_rec =#{nil_rec.inspect}" }
+              it { expect( nil_rec.variable_value.value ).to eql( { "test" => nil }  ) }
+            end
+          end # recrods
+          
+          describe "sequence" do
+            describe ":empty_seq" do
+              let ( :empty_seq ) { state_space[:empty_seq] }
+              # it { puts "empty_seq =#{empty_seq.inspect}" }
+              it { expect( empty_seq.variable_value.value ).to eql( []  ) }
+            end
+            
+            describe ":one_seq" do
+              let ( :one_seq ) { state_space[:one_seq] }
+              # it { puts "empty_seq =#{one_seq.inspect}" }
+              it { expect( one_seq.variable_value.value ).to eql( [ 1 ]  ) }
+            end
+            describe ":one_seq_seq" do
+              let ( :one_seq_seq ) { state_space[:one_seq_seq] }
+              # it { puts "empty_seq =#{one_seq_seq.inspect}" }
+              it { expect( one_seq_seq.variable_value.value ).to eql( [ 1, [] ]  ) }
+            end
+
+            describe ":steps" do
+              let ( :steps ) { state_space[:steps] }
+              # it { puts "stepsc =#{steps.inspect}" }
+              it { expect( steps.variable_value.value ).to eql( [ Set.new([{"process"=>"p__customer_post_", "bindRule"=>"*", "bindSet"=>nil, "ctx"=>nil}])] ) }
+            end
+            
+          end  # sequence
+
+          describe "function" do
+            describe ":empty_function" do
+              let( :function ) { state_space[:empty_function]  }
+              # it { puts "function =#{function.inspect}" }
+              it { expect( function.variable_value.value ).to eql({}) }
+            end 
+            describe ":simple_function" do
+              let( :function ) { state_space[:simple_function]  }
+              # it { puts "function =#{function.inspect}" }
+              it { expect( function.variable_value.value ).to eql({ "Tail" => true }) }
+            end 
+            describe ":stack" do
+              let( :function ) { state_space[:stack]  }
+              # it { puts "function =#{function.inspect}" }
+              it { expect( function.variable_value.value ).to eql({ "Tail" => [], "/customer(post)" => [1, false] }) }
+            end 
+          end
+
+          
+          describe "set" do
+            describe ":dummy_set" do
+              let ( :dummy_set ) { state_space[:dummy_set] }
+              # it { puts "dummy_set =#{dummy_set.inspect}" }
+              it { expect( dummy_set.variable_value.value ).to eql( Set.new( [] )) }
+            end
+
+            describe ":single_set" do
+              let ( :single_set ) { state_space[:single_set] }
+              # it { puts "single_set =#{single_set.inspect}" }
+              it { expect( single_set.variable_value.value ).to eql( Set.new [ 1 ] ) }
+            end
+          end # set
+
+          describe "state_space" do
+            # it { puts "state_space=#{state_space.inspect}" }
+            it { expect( parse.value.keys ).to include( :tx_running, :stack, :step, :now ) }
+          end 
+        end 
+    end
+    
+  end 
+end