pg-verify 0.1.0 → 0.1.2

data/lib/pg-verify/nusmv/runner.rb

@@ -5,9 +5,17 @@ module PgVerify
         class Runner
 
             def run_specs(program_graph)
-                nusmv_s = Transform::NuSmvTransformation.new.transform_graph(program_graph)
-                output = eval_nusmv(nusmv_s)
+                transformer = Transform::NuSmvTransformation.new
+                nusmv_s = transformer.transform_graph(program_graph, include_specs: false)
+                commands = [ "go" ]
                 specs = program_graph.specification.flatten()
+                transform_map = specs.each { |spec|
+                    transformed_spec_expr = transformer.transform_expression(spec.expression, program_graph.all_variables)
+                    cmd = {  ltl: "check_ltlspec", ctl: "check_ctlspec" }[spec.expression.predict_type]
+                    commands << "#{cmd} -p \"#{transformed_spec_expr}\""
+                }
+                output = eval_nusmv(nusmv_s, commands: commands)
+
                 return parse_spec_results(program_graph, specs, output)
             end
 
@@ -20,8 +28,8 @@ module PgVerify
                 nusmv_output.split("\n").each { |line|
                     result = line[/-- specification .* is (true|false)/, 1]
                     if !result.nil?
-                        blocks << current_block unless current_block.nil?
-                        current_block = block.new(result == "true", [])
+                        blocks << current_block unless current_block.nil? # Complete the last block
+                        current_block = block.new(result == "true", [])   # Start a new block
                         next
                     end
                     current_block.lines << line unless current_block.nil?
@@ -41,10 +49,7 @@ module PgVerify
             # variable to the value of that variable in that state
             def run_simulation(program_graph, steps, random: false)
                 commands = []
-                commands << "read_model"
-                commands << "flatten_hierarchy"
-                commands << "encode_variables"
-                commands << "build_model"
+                commands << "go"
                 commands << "pick_state #{random ? '-r' : ''}"
                 commands << "simulate -k #{steps.to_s.to_i} -v #{random ? '-r' : ''}"
                 commands << "quit"
@@ -53,12 +58,48 @@ module PgVerify
                 return parse_trace(program_graph, output)
             end
 
+            def run_check!(program_graph)
+                deadlock_state = run_check(program_graph)
+                return if deadlock_state.nil?
+                raise Model::Validation::DeadlockInFSMError.new(program_graph, deadlock_state)
+            end
+
+            def run_check(program_graph)
+                commands = [ "go", "check_fsm", "quit" ]
+                nusmv_s = Transform::NuSmvTransformation.new.transform_graph(program_graph, include_specs: false)
+                output = eval_nusmv(nusmv_s, commands: commands)
+
+                # Return "ok" if the FSM has no deadlocks
+                return nil if output.include?("The transition relation is total: No deadlock state exists")
+
+                # Otherwise compute and return the deadlock state
+                lines = output.split("\n").drop_while { |str| 
+                    !(str.start_with?("A deadlock state is:") || str.start_with?("successors is:"))
+                }
+                lines = lines[1, lines.length - 1]
+
+                var_state = {}
+                lines.each { |line|
+                    key, val = parse_var_assignment_in_trace(line)
+                    next if key.nil? || val.nil?
+                    var_state[key] = val
+                }
+
+                return var_state
+            end
+
             def parse_trace(program_graph, nusmv_output)
                 var_states, current_var_state = [], nil
 
                 loop_index = -1
 
                 nusmv_output.split("\n").each { |line|
+                    # Mark a loop for the following state
+                    if line.include?("Loop starts here")
+                        loop_index = var_states.length
+                        next
+                    end
+
                     # Wait for heading of new state
                     if line.match(/\s*-> State: .+ <-/)
                         # Complete and store the old state if any
@@ -76,17 +117,28 @@ module PgVerify
                     # Skip lines before the first state
                     next if current_var_state.nil?
 
-                    if line.include?("Loop starts here")
-                        loop_index == var_states.length - 1
-                        next
-                    end
-
-                    key_val = line.split("=").map(&:strip)
-                    key = key_val[0].gsub("v.V_", "").to_sym
-                    val = key_val[1].gsub("L_", "")
+                    # Parse the variable state
+                    key, val = parse_var_assignment_in_trace(line)
+                    next if key.nil? || val.nil?
                     current_var_state[key] = val
                 }
-                return Model::Trace.new(program_graph, var_states)
+                # Finish up
+                unless current_var_state.nil?
+                    missing_keys = var_states.empty? ? [] :  var_states[-1].keys - current_var_state.keys
+                    missing_keys.each { |key|
+                        current_var_state[key] = var_states[-1][key]
+                    }  
+                    var_states << current_var_state
+                end
+                return Model::Trace.new(program_graph, var_states, loop_index: loop_index)
+            end
+
+            def parse_var_assignment_in_trace(line)
+                return nil, nil unless line.include?("=")
+                key_val = line.split("=").map(&:strip)
+                key = key_val[0].gsub("v.V_", "").to_sym
+                val = key_val[1].gsub("L_", "")
+                return key, val
             end
 
             def eval_nusmv(nusmv_string, commands: [])

data/lib/pg-verify/puml/puml.rb

@@ -15,6 +15,7 @@ module PgVerify
         end
 
         def self.convert_file(in_path, out_path)
+            # CALL WITH java -Djava.awt.headless=true -jar addon/plantuml-1.2023.13.jar --help
             # TODO: The PlantUML jar switches focus to the desktop is if it would
             # attempt to open a window each time it is invoked.
         end

data/lib/pg-verify/transform/hash_transformation.rb

@@ -4,16 +4,24 @@ module PgVerify
         class HashTransformation
 
             def transform_graph(graph)
-                return { graph.name.to_s => 
-                    graph.components.map { |c| transform_component(graph, c) }
-                }
+                components = graph.components.map { |c| transform_component(graph, c) }
+                hazards    = graph.hazards.map { |h| transform_hazard(h) }
+                sub_hash = {}
+                sub_hash["components"] = components
+                sub_hash["hazards"] = hazards unless hazards.empty?
+                sub_hash["specification"] = transform_specification(graph.specification)
+                return { graph.name.to_s => sub_hash }
             end
 
             def parse_graph(hash)
                 name = hash.keys.first.to_sym
                 graph = Model::Graph.new(name)
-                components = hash[hash.keys.first].map { |c| parse_component(graph, c) }
+                components = hash[hash.keys.first]["components"].map { |c| parse_component(graph, c) }
+                hazards = hash[hash.keys.first]["hazards"]&.map { |h| parse_hazard(h) } || []
+                specification = parse_specification(hash[hash.keys.first]["specification"])
                 graph.components = components
+                graph.hazards = hazards
+                graph.specification = specification
                 return graph
             end
 
@@ -22,6 +30,7 @@ module PgVerify
                 return { component.name.to_s => {
                     "states" => component.states.map(&:to_s),
                     "variables" => variables.map { |v| transform_variable(v) },
+                    "init" => transform_expression(component.init_expression),
                     "transitions" => component.transitions.map { |t| transform_transition(t) },
                     "represents_fault" => component.represents_fault
                 }}
@@ -31,13 +40,14 @@ module PgVerify
                 name = hash.keys.first
                 states = hash[name]["states"].map(&:to_sym)
                 variables = hash[name]["variables"].map { |v| parse_variable(name, v) }
+                init_expression = parse_expression(hash[name]["init"])
                 transitions = hash[name]["transitions"].map { |t| parse_transition(t) }
                 represents_fault = hash[name]["represents_fault"]
 
                 graph.variables += variables
 
                 return Model::Component.new(name: name.to_sym, states: states, 
-                    transitions: transitions, represents_fault: represents_fault)
+                    transitions: transitions, represents_fault: represents_fault, init_expression: init_expression)
             end
 
             def transform_variable(variable)
@@ -49,7 +59,7 @@ module PgVerify
 
             def parse_variable(owner_name, hash)
                 name = hash.keys.first
-                range = hash[name]["range"]
+                range = parse_variable_range(hash[name]["range"])
                 init_expression = parse_expression(hash[name]["init"])
                 return Model::Variable.new(name.to_sym, range, owner_name.to_sym, nil, init: init_expression)
             end
@@ -60,9 +70,10 @@ module PgVerify
             end
 
             def parse_variable_range(range)
-                if range.is_a?(String) && range.match(/\A\d+\.\.\d+\z/)
+                # Matches ranges like 1..12 or -1..23
+                if range.is_a?(String) && range.match(/\A\-?\d+\.\.\-?\d+\z/)
                     first, last = range.split("..")[0], range.split("..")[-1]
-                    return Range.new(first, last)
+                    return Range.new(first.to_i, last.to_i)
                 end
                 return range
             end
@@ -85,20 +96,41 @@ module PgVerify
             def transform_transition(transition)
                 name = "#{transition.src_state} -> #{transition.tgt_state}"
                 return { name => {
-                    "precon" => transition.precon&.to_s,
-                    "guard" => transition.guard&.to_s,
-                    "action" => transition.action&.to_s,
+                    "precon" => transform_expression(transition.precon),
+                    "guard" => transform_expression(transition.guard),
+                    "action" => transform_expression(transition.action),
                 }}
             end
 
             def parse_transition(hash)
                 src_state, tgt_state = hash.keys.first.split("->").map(&:strip).map(&:to_sym)
-                precon = hash.values.first["precon"]
-                guard  = hash.values.first["guard"] 
-                action = hash.values.first["action"]
+                precon = parse_expression(hash.values.first["precon"])
+                guard  = parse_expression(hash.values.first["guard"] )
+                action = parse_expression(hash.values.first["action"])
                 return Model::Transition.new(src_state, tgt_state, precon: precon, guard: guard, action: action)
             end
 
+            def transform_hazard(hazard)
+                return { "label" => hazard.text, "expression" => hazard.expression }
+            end
+
+            def parse_hazard(hash)
+                return Model::Hazard.new(hash["label"], hash["expression"])
+            end
+
+            def transform_specification(specification)
+                return specification.flatten().map { |spec|
+                    { "label" => spec.text.strip, "expression" => transform_expression(spec.expression) }
+                }
+            end
+
+            def parse_specification(array)
+                specs = array.map { |hash|
+                    Model::Spec.new(hash["label"], parse_expression(hash["expression"]), nil)
+                }
+                return  Model::Specification.new([Model::SpecSet.wrap(specs)])
+            end
+
         end
     end
 end

data/lib/pg-verify/transform/nusmv_transformation.rb

@@ -3,7 +3,7 @@ module PgVerify
 
         class NuSmvTransformation
 
-            def transform_graph(program_graph)
+            def transform_graph(program_graph, include_specs: true)
                 variables  = program_graph.all_variables
                 components = program_graph.components
 
@@ -11,7 +11,7 @@ module PgVerify
                 cmp_s  = transform_components(components, variables)
                 main_s = transform_main_module(components)
 
-                specs = transform_specification(program_graph.specification, variables)
+                specs = transform_specification(program_graph.specification, variables) if include_specs
 
                 return "#{var_s}\n\n#{cmp_s}\n\n#{main_s}\n\n#{specs}\n"
             end
@@ -251,7 +251,8 @@ module PgVerify
             def transform_spec(spec, varset)
                 expression_s  = "-- #{spec.text}\n"
                 expression_s += "-- Defined in: #{spec.source_location.to_s}\n"
-                expression_s += "LTLSPEC " + transform_expression(spec.expression, varset)
+                keyword = {  ltl: "LTLSPEC", ctl: "CTLSPEC" }[spec.expression.predict_type]
+                expression_s += keyword + " " + transform_expression(spec.expression, varset)
                 return expression_s
             end
 

data/lib/pg-verify/transform/puml_transformation.rb

@@ -5,13 +5,25 @@ module PgVerify
 
         class PumlTransformation
 
+            attr_accessor :render_labels
+            attr_accessor :render_precons
+            attr_accessor :render_guards
+            attr_accessor :render_actions
+
+            def initialize(render_options = {})
+                @render_labels = render_options[:render_labels].nil? ? true : render_options[:render_labels]
+                @render_precons = render_options[:render_precons].nil? ? true : render_options[:render_precons]
+                @render_guards = render_options[:render_guards].nil? ? true : render_options[:render_guards]
+                @render_actions = render_options[:render_actions].nil? ? true : render_options[:render_actions]
+            end
+
             def transform_graph(graph, variable_state: nil, only: nil)
 
                 components = graph.components
                 components = components.select { |c| only.map(&:to_s).include?(c.name.to_s) } unless only.nil?
 
                 parts = []
-                parts << components.map { |c| transform_component(graph, c) }.join("\n\n")
+                parts << components.map { |c| transform_component(graph, c, variable_state) }.join("\n\n")
                 parts << transform_variable_state(graph, variable_state) unless variable_state.nil?
                 parts = parts.compact.join("\n\n")
                 return "@startuml Programmgraph\n#{parts}\n@enduml\n"
@@ -25,14 +37,14 @@ module PgVerify
                 }.join("\n")
             end
         
-            def transform_component(graph, component)
+            def transform_component(graph, component, variable_state)
                 # Transform component states
                 states_s  = component.states.map { |s| transform_state(component, s) }.join("\n")
                 # Transform component transitions
                 trans_s   = component.transitions.map { |t| transform_transition(component, t) }.join("\n")
                 # Transform component variables
                 vars = graph.variables.select_by_owner(component.name)
-                vars_s    = transform_variables(component, vars)
+                vars_s    = transform_variables(component, vars, variable_state)
                 # Transform the initial state 
                 initial_s = transform_initial(graph, component)
 
@@ -59,10 +71,14 @@ module PgVerify
             end
         
             def transform_transition(component, transition)
-                label = [ transition.precon, transition.guard ].map(&:to_s).reject(&:empty?).join(" && ")
-                label += "/ " + transition.action.to_s unless transition.action.nil?
+                precon = @render_precons ? transition.precon : nil
+                guard  = @render_guards  ? transition.guard : nil
+                action = @render_actions ? transition.action : nil
 
+                label = [ precon, guard ].map(&:to_s).reject(&:empty?).join(" && ")
+                label += " / " + action.to_s unless action.nil?
                 label = ": #{label}" unless label.strip.empty?
+                label = "" unless @render_labels
                 return "#{component.name}_#{transition.src_state} --> #{component.name}_#{transition.tgt_state} #{label}"
             end
         
@@ -70,9 +86,12 @@ module PgVerify
                 str.split("\n").map { |s| "\t#{s}" }.join("\n")
             end
         
-            def transform_variables(component, variables)
-                return nil if variables.empty? 
-                body =  variables.map { |v| "#{v.name} => #{transform_range(v.range)}" }.join("\n")
+            def transform_variables(component, variables, variable_state)
+                return nil if variables.empty?
+                body =  variables.map { |var| 
+                    value = variable_state.nil? ? transform_range(var.range) : variable_state[var.name]
+                    "#{var.name} => #{value}"
+                }.join("\n")
                 return "map #{component.name}Variables {\n#{body}\n}"
             end
         

data/lib/pg-verify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgVerify
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/pg-verify.gemspec

@@ -30,7 +30,6 @@ Gem::Specification.new do |spec|
 
   # Gem dependencies
   spec.add_dependency "thor", "~> 1.2.1"
-  spec.add_dependency "ebnf", "~> 2.3.4"
   spec.add_dependency "rainbow", "~> 3.0.0"
   spec.add_dependency "config", "~> 4.2.1"
   spec.add_dependency "plantuml_builder", "~> 0.3.0"

data/vscript.rb

@@ -0,0 +1,64 @@
+
+task :gen_examples do
+    files = Dir["integration_tests/ruby_dsl/*.rb"].select(&:file?)
+
+    target_dir = "examples"
+    FileUtils.rm_rf(target_dir); FileUtils.mkdir(target_dir)
+
+    files.each { |file|
+        json = x "./devpg show json --script #{file}", verbose: false
+        yaml = x "./devpg show yaml --script #{file}", verbose: false
+        json_file = File.join(target_dir, File.basename(file, '.rb') + ".json")
+        yaml_file = File.join(target_dir, File.basename(file, '.rb') + ".yaml")
+        FileUtils.cp(file, File.join(target_dir, File.basename(file)))
+        File.write(json_file, json)
+        File.write(yaml_file, yaml)
+
+        x "tar -czf examples.tar.gz examples/"
+    }
+    FileUtils.rm_rf(target_dir)
+
+    done "Generated examples.tar.gz"
+end
+
+task :integration_test do
+
+    work_dir = ".pg-work"
+    FileUtils.rm_rf(work_dir); FileUtils.mkdir(work_dir)
+
+    test_files = Dir["integration_tests/ruby_dsl/*.rb"].sort.select(&:file?)
+
+
+    # Create json files for all tests
+    test_files.each { |source|
+        log "JSON #{File.basename(source)}"
+        target = File.join(work_dir, File.basename(source, '.rb') + ".json")
+        content = x "./devpg show json --script #{source}", verbose: false
+        File.write(target, content)
+    }
+
+    # Create json files for all tests
+    test_files.each { |source|
+        log "YAML #{File.basename(source)}"
+        target = File.join(work_dir, File.basename(source, '.rb') + ".yaml")
+        content = x "./devpg show yaml --script #{source}", verbose: false
+        File.write(target, content)
+    }
+
+    # Run tests for all files
+    test_files.each { |source|
+        args = {
+            "script" => source,
+            "json-file" => File.join(work_dir, File.basename(source, '.rb') + ".json"),
+        }
+        commands = [ "show puml", "test", "dcca", "show png", "simulate" ]
+        args.each { |argument, file|
+            commands.each { |command|
+                log "pgv #{command} #{argument} | #{File.basename(file)}"
+                x "./devpg #{command} --#{argument} #{file}", verbose: false
+            }
+        }
+    }
+
+    done "Great success!"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg-verify
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Arian Weber
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-12 00:00:00.000000000 Z
+date: 2024-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.1
-- !ruby/object:Gem::Dependency
-  name: ebnf
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.4
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -97,16 +83,19 @@ files:
 - bin/pg-verify.rb
 - bin/setup
 - calc.ebnf
+- data/banner.txt
 - data/config/pg-verify.yml
 - data/nusmv.sample.smv
 - data/project-template/.gitignore.resource
-- data/project-template/.pg-verify.yml
 - data/project-template/README.md
 - data/project-template/addon/.keep
-- data/project-template/program-graph.rb.resource
 - devpg
 - doc/examples/railroad_crossing.rb
 - doc/examples/train-tree.rb
+- doc/examples/vending_machine/checkpoint_1.rb
+- doc/examples/vending_machine/checkpoint_2.rb
+- doc/examples/vending_machine/checkpoint_3.rb
+- doc/examples/vending_machine/checkpoint_4.rb
 - doc/examples/weidezaun.rb
 - doc/examples/weidezaun.txt
 - doc/expose/definition.png
@@ -130,8 +119,13 @@ files:
 - integration_tests/ruby_dsl/014_tau_transitions.rb
 - integration_tests/ruby_dsl/015_basic_dcca.rb
 - integration_tests/ruby_dsl/016_pressure_tank.rb
+- integration_tests/ruby_dsl/017_ctl_specifications.rb
+- integration_tests/ruby_dsl/018_non_atomic_hazard.rb
+- integration_tests/ruby_dsl/019_multiple_actions.rb
+- integration_tests/ruby_dsl/020_vending_machine.rb
 - lib/pg-verify.rb
 - lib/pg-verify/cli/cli.rb
+- lib/pg-verify/cli/cli_utils.rb
 - lib/pg-verify/core/cmd_runner.rb
 - lib/pg-verify/core/core.rb
 - lib/pg-verify/core/extensions/array_extensions.rb
@@ -185,6 +179,7 @@ files:
 - lib/pg-verify/nusmv/nusmv.rb
 - lib/pg-verify/nusmv/runner.rb
 - lib/pg-verify/puml/puml.rb
+- lib/pg-verify/puml/runner.rb
 - lib/pg-verify/shell/loading/line_animation.rb
 - lib/pg-verify/shell/loading/loading_animation.rb
 - lib/pg-verify/shell/loading/loading_prompt.rb
@@ -200,6 +195,7 @@ files:
 - lib/pg-verify/version.rb
 - pg-verify.gemspec
 - sig/pg-verify.rbs
+- vscript.rb
 homepage: https://github.com/ArianWeber/pg-verify
 licenses: []
 metadata:

data/data/project-template/program-graph.rb.resource

@@ -1,103 +0,0 @@
-####################################################################
-# Model definition
-####################################################################
-
-model :FeelThePain do
-
-    # Define a graph called 'Hand'.
-    graph :Hand do
-        # The hand can be touching the fence or be somewhere else
-        # It starts in 'somewhere' as that state is listed first
-        states :somewhere, :at_fence
-
-        # Transition non-deterministically between those states
-        transition :somewhere => :somewhere
-        transition :somewhere => :at_fence
-        transition :at_fence => :somewhere
-        transition :at_fence => :at_fence
-    end
-
-    # Define another graph called 'PowerSwitch', which also
-    # transitions non-deterministically.
-    graph :PowerSwitch do
-        states :off, :on
-        transition :off => :off
-        transition :off => :on
-        transition :on  => :off
-        transition :on  => :on
-    end
-
-    graph :Fence do
-        # The fence has no states we are interested in
-        states :exists
-
-        # The fence has a voltage which can go up to 15
-        var :voltage => (0..12), init: 0
-
-        # The voltage increases when the power switch is on
-        transition :exists => :exists do
-            guard "PowerSwitch == on"
-            action "voltage := voltage + 1"
-        end
-        # ..and instantly stops when the switch is off
-        transition :exists => :exists do
-            guard "PowerSwitch == off"
-            action "voltage := 0"
-        end
-
-    end
-
-    graph :Pain do
-        # We can either be in pain or not
-        states :No, :Yes
-        # Using regular variables with string interpolation
-        pain_threshold = 7
-        transition :No => :Yes do
-            # action "voltage := 2"
-            guard "Hand == at_fence && voltage >= #{pain_threshold}"
-        end
-        transition :Yes => :No do
-            guard "Hand == somewhere || voltage < #{pain_threshold}"
-        end
-    end
-
-    ####################################################################
-    # Validity tests
-    ####################################################################
-
-    # Specification of validity characteristics regarding the hand.
-    # The 'specify' block serves as a namespace/container for the contained specifications
-    specify "The Hand" do
-        # Define some simple specs using a description text and an LTL expression
-        it "isn't always touching the fence"  => :"F Hand == somewhere"
-        it "isn't always away form the fence" => :"F Hand == at_fence"
-    end
-
-    # Specification of validity characteristics regarding the pain
-    specify "The pain" do
-        # Use a regular LTL Formula as the expression
-        it "is felt at some point" => :"F Pain == Yes"
-        # Use a more declarative syntax. This becomes useful for complex expressions
-        # as LTL patterns can be used very easily
-        it "is always felt at some point" => ltl.globally.exists(:"Pain == Yes")
-
-        # Pattern: 'Universality', range: 'after q'
-        it "is felt after the switch is activated" => ltl.after(:"PowerSwitch == on").exists(:"Pain == Yes")
-        # Pattern: 'Absence', range: 'before q'
-        it "is never felt before the switch is activated" => ltl.before(:"PowerSwitch == on").never(:"Pain == Yes")
-        # Pattern: 'Reaction', range: 'global'
-        it "always reacts to the switch being activated"  => ltl.globally.reacts(:"PowerSwitch == on", :"Pain == Yes")
-
-        # Define an assumption. That assumption must be true for all contained specs
-        assuming "the switch is never activated" => :"G PowerSwitch == off" do
-            it "is never felt " => :"G Pain == No"
-        end
-
-        # Assumptions can be nested and used with the declarative syntax.
-        assuming "the switch is activated" => ltl.globally.exists(:"PowerSwitch == No") do
-            assuming "the hand never touches the fence" => :"G Hand != at_fence" do
-                it "is never felt " => :"G Pain == No"
-            end
-        end
-    end
-end