origen_testers 0.21.0 → 0.30.0

data/lib/origen_testers/atp/processors/flattener.rb

@@ -0,0 +1,58 @@
+module OrigenTesters::ATP
+  module Processors
+    # Gives every node their own individual wrapping of condition nodes. No attempt is made
+    # to identify or remove duplicate conditions in the wrapping, that will be done later by
+    # the RedundantConditionRemover.
+    class Flattener < Processor
+      def run(node)
+        @results = [[]]
+        @conditions = []
+        process(node)
+        node.updated(:flow, results)
+      end
+
+      def on_flow(node)
+        process_all(node.children)
+      end
+
+      # Handles the top-level flow nodes
+      def on_volatile(node)
+        results << node
+      end
+      alias_method :on_name, :on_volatile
+      alias_method :on_id, :on_volatile
+
+      def on_group(node)
+        @results << []
+        process_all(node.children)
+        nodes = @results.pop
+        results << node.updated(nil, nodes)
+      end
+
+      def on_condition_node(node)
+        flag, *nodes = *node
+        @conditions << node.updated(node.type, [flag])
+        process_all(nodes)
+        @conditions.pop
+      end
+      OrigenTesters::ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
+      end
+
+      def handler_missing(node)
+        results << wrap_with_current_conditions(node)
+      end
+
+      def wrap_with_current_conditions(node)
+        @conditions.reverse_each do |condition|
+          node = condition.updated(nil, condition.children + [node])
+        end
+        node
+      end
+
+      def results
+        @results.last
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/flow_id.rb

@@ -0,0 +1,46 @@
+module OrigenTesters::ATP
+  module Processors
+    # Adds the flow ID to all ids and label names
+    class FlowID < Processor
+      attr_reader :id
+
+      def run(node, id)
+        @id = id
+        process(node)
+      end
+
+      def on_id(node)
+        if node.value =~ /^extern/
+          node
+        else
+          node.updated(nil, ["#{node.value}_#{id}"])
+        end
+      end
+
+      def on_if_failed(node)
+        tid, *nodes = *node
+        if tid.is_a?(Array)
+          tid = tid.map do |tid|
+            if tid =~ /^extern/
+              tid
+            else
+              "#{tid}_#{id}"
+            end
+          end
+        else
+          if tid !~ /^extern/
+            tid = "#{tid}_#{id}"
+          end
+        end
+        node.updated(nil, [tid] + process_all(nodes))
+      end
+      alias_method :on_if_any_failed, :on_if_failed
+      alias_method :on_if_all_failed, :on_if_failed
+      alias_method :on_if_passed, :on_if_failed
+      alias_method :on_if_any_passed, :on_if_failed
+      alias_method :on_if_all_passed, :on_if_failed
+      alias_method :on_if_ran, :on_if_failed
+      alias_method :on_unless_ran, :on_if_failed
+    end
+  end
+end

data/lib/origen_testers/atp/processors/marshal.rb

@@ -0,0 +1,33 @@
+module OrigenTesters::ATP
+  module Processors
+    # Makes the AST safe for Marshaling
+    class Marshal < Processor
+      def on_object(node)
+        o = node.value
+        if o.is_a?(String)
+          meta = { 'Test' => o }
+        elsif o.is_a?(Hash)
+          meta = o
+        elsif o.respond_to?(:to_meta) && o.to_meta && !o.to_meta.empty?
+          meta = o.to_meta
+        else
+          meta = {}
+        end
+        # The test suite / test instance name
+        meta['Test'] ||= o.try(:name)
+        meta['Pattern'] ||= o.try(:pattern)
+        # The test name column on IG-XL, or the name of a specific instance of a test which shares a common
+        # 'Test' name with other tests
+        meta['Test Name'] ||= o.try(:test_name) || o.try(:_test_name) || o.try('TestName') || meta['Test']
+        # The name of the primary test that is logged by the test instance / test method, if it logs more
+        # than one then this is represented by sub_test nodes
+        meta['Sub Test Name'] ||= o.try(:sub_test_name) || o.try('SubTestName') || meta['Test']
+        node.updated(nil, [meta])
+      end
+
+      def on_render(node)
+        node.updated(nil, [node.value.to_s])
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/on_pass_fail_remover.rb

@@ -0,0 +1,39 @@
+module OrigenTesters::ATP
+  module Processors
+    # Removes most things from embedded on_pass/fail nodes and converts them to the equivalent
+    # on_passed/failed condition at the same level as the parent node
+    class OnPassFailRemover < Processor
+      def run(node)
+        process(node)
+      end
+
+      def on_test(node)
+        on_pass = node.find(:on_pass)
+        on_fail = node.find(:on_fail)
+        if on_pass || on_fail
+          id = node.find(:id)
+          unless id
+            fail 'Something has gone wrong, all nodes should have IDs by this point'
+          end
+          id = id.value
+          nodes = [node]
+          if on_fail && contains_anything_interesting?(on_fail)
+            nodes << node.updated(:if_failed, [id] + on_fail.children)
+            nodes[0] = nodes[0].remove(on_fail)
+          end
+          if on_pass && contains_anything_interesting?(on_pass)
+            nodes << node.updated(:if_passed, [id] + on_pass.children)
+            nodes[0] = nodes[0].remove(on_pass)
+          end
+          node.updated(:inline, nodes)
+        else
+          node.updated(nil, process_all(node.children))
+        end
+      end
+
+      def contains_anything_interesting?(node)
+        node.children.any? { |n| n.type != :set_result && n.type != :continue && n.type != :set_flag }
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/one_flag_per_test.rb

@@ -0,0 +1,79 @@
+module OrigenTesters::ATP
+  module Processors
+    # Ensures that all test nodes only ever set a flag once
+    class OneFlagPerTest < Processor
+      def run(node)
+        @build_table = true
+        @pass_table = {}
+        @fail_table = {}
+        process(node)
+        @counters = {}
+        @pass_table.each { |f, v| @counters[f] = 0 }
+        @fail_table.each { |f, v| @counters[f] = 0 }
+        @build_table = false
+        process(node)
+      end
+
+      def on_test(node)
+        on_pass = node.find(:on_pass)
+        on_fail = node.find(:on_fail)
+        if @build_table
+          if on_fail
+            on_fail.find_all(:set_flag).each do |n|
+              @fail_table[n.to_a[0]] ||= 0
+              @fail_table[n.to_a[0]] += 1
+            end
+          end
+          if on_pass
+            on_pass.find_all(:set_flag).each do |n|
+              @pass_table[n.to_a[0]] ||= 0
+              @pass_table[n.to_a[0]] += 1
+            end
+          end
+        else
+          to_be_set = {}
+          if on_fail
+            node = node.remove(on_fail)
+            on_fail.find_all(:set_flag).each do |set_flag|
+              old_flag = set_flag.to_a[0]
+              if @fail_table[old_flag] > 1
+                on_fail = on_fail.remove(set_flag)
+                new_flag = "#{old_flag}_#{@counters[old_flag]}"
+                @counters[old_flag] += 1
+                to_be_set[old_flag] = new_flag
+                c = set_flag.children.dup
+                c[0] = new_flag
+                set_flag = set_flag.updated(nil, c)
+                on_fail = on_fail.updated(nil, on_fail.children + [set_flag])
+              end
+            end
+            node = node.updated(nil, node.children + [on_fail])
+          end
+          if on_pass
+            node = node.remove(on_pass)
+            on_pass.find_all(:set_flag).each do |set_flag|
+              old_flag = set_flag.to_a[0]
+              if @pass_table[old_flag] > 1
+                on_pass = on_pass.remove(set_flag)
+                new_flag = "#{old_flag}_#{@counters[old_flag]}"
+                @counters[old_flag] += 1
+                to_be_set[old_flag] = new_flag
+                c = set_flag.children.dup
+                c[0] = new_flag
+                set_flag = set_flag.updated(nil, c)
+                on_pass = on_pass.updated(nil, on_pass.children + [set_flag])
+              end
+            end
+            node = node.updated(nil, node.children + [on_pass])
+          end
+          if to_be_set.empty?
+            node
+          else
+            nodes = to_be_set.map { |old, new| node.updated(:if_flag, [new, node.updated(:set_flag, [old, 'auto_generated'])]) }
+            node.updated(:inline, [node] + nodes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/pre_cleaner.rb

@@ -0,0 +1,65 @@
+module OrigenTesters::ATP
+  module Processors
+    # Modifies the AST by performing some basic clean up, mainly to sanitize
+    # user input. For example it will ensure that all IDs and references are underscored
+    # and lower cased.
+    class PreCleaner < Processor
+      def initialize
+        @group_ids = []
+      end
+
+      # Make all IDs lower cased symbols
+      def on_id(node)
+        id = node.to_a[0]
+        node.updated(nil, [clean(id)])
+      end
+
+      # Make all ID references use the lower case symbols
+      def on_if_failed(node)
+        id, *children = *node
+        node.updated(nil, [clean(id)] + process_all(children))
+      end
+      alias_method :on_if_passed, :on_if_failed
+      alias_method :on_if_any_failed, :on_if_failed
+      alias_method :on_if_all_failed, :on_if_failed
+      alias_method :on_if_any_passed, :on_if_failed
+      alias_method :on_if_all_passed, :on_if_failed
+      alias_method :on_if_ran, :on_if_failed
+      alias_method :on_unless_ran, :on_if_failed
+
+      def on_group(node)
+        if id = node.children.find { |n| n.type == :id }
+          @group_ids << process(id).value
+        else
+          @group_ids << nil
+        end
+        group = node.updated(nil, process_all(node.children))
+        @group_ids.pop
+        group
+      end
+      alias_method :on_sub_flow, :on_group
+
+      def on_test(node)
+        # Remove IDs nodes from test nodes if they refer to the ID of a parent group
+        if @group_ids.last
+          children = node.children.reject do |n|
+            if n.type == :id
+              @group_ids.last == process(n).value
+            end
+          end
+        else
+          children = node.children
+        end
+        node.updated(nil, process_all(children))
+      end
+
+      def clean(id)
+        if id.is_a?(Array)
+          id.map { |i| clean(i) }
+        else
+          id.to_s.symbolize.to_s
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/redundant_condition_remover.rb

@@ -0,0 +1,28 @@
+module OrigenTesters::ATP
+  module Processors
+    # Removes any conditions nodes that are nested within other condition
+    # nodes that specify the same condition
+    class RedundantConditionRemover < Processor
+      def run(node)
+        @conditions = []
+        process(node)
+      end
+
+      def on_condition_node(node)
+        sig = [node.type, node.to_a[0]]
+        if @conditions.include?(sig)
+          flag, *nodes = *node
+          node.updated(:inline, process_all(nodes))
+        else
+          @conditions << sig
+          node = node.updated(nil, process_all(node.children))
+          @conditions.pop
+          node
+        end
+      end
+      OrigenTesters::ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/processors/relationship.rb

@@ -0,0 +1,199 @@
+module OrigenTesters::ATP
+  module Processors
+    # This processor will apply the relationships between tests, e.g. if testB should only
+    # execute if testA passes, then this processor will update the AST to make testA set
+    # a flag on pass, and then update testB to only run if that flag is set.
+    class Relationship < Processor
+      # Returns a hash containing the IDs of all tests that have dependents
+      attr_reader :test_results
+
+      # Extracts all test-result nodes from the given AST
+      class ExtractTestResults < Processor
+        attr_reader :results
+
+        def on_if_failed(node)
+          ids, *children = *node
+          unless ids.is_a?(Array)
+            ids = [ids]
+          end
+          ids.each do |id|
+            results[id] ||= {}
+            results[id][:failed] = true
+          end
+          process_all(children)
+        end
+        alias_method :on_if_any_failed, :on_if_failed
+        alias_method :on_if_all_failed, :on_if_failed
+
+        def on_if_passed(node)
+          ids, *children = *node
+          unless ids.is_a?(Array)
+            ids = [ids]
+          end
+          ids.each do |id|
+            results[id] ||= {}
+            results[id][:passed] = true
+          end
+          process_all(children)
+        end
+        alias_method :on_if_any_passed, :on_if_passed
+        alias_method :on_if_all_passed, :on_if_passed
+
+        def on_if_ran(node)
+          id, *children = *node
+          results[id] ||= {}
+          results[id][:ran] = true
+          process_all(children)
+        end
+        alias_method :on_unless_ran, :on_if_ran
+
+        def results
+          @results ||= {}.with_indifferent_access
+        end
+      end
+
+      def run(node)
+        t = ExtractTestResults.new
+        t.process(node)
+        @test_results = t.results || {}
+        process(node)
+      end
+
+      def add_pass_flag(id, node)
+        node = node.ensure_node_present(:on_pass)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, node.children.map do |n|
+          if n.type == :on_pass
+            n = n.add node.updated(:set_flag, ["#{id}_PASSED", :auto_generated])
+          elsif n.type == :on_fail
+            delayed = n.find(:delayed)
+            if delayed && delayed.to_a[0]
+              n
+            else
+              n.ensure_node_present(:continue)
+            end
+          else
+            n
+          end
+        end)
+      end
+
+      def add_fail_flag(id, node)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, node.children.map do |n|
+          if n.type == :on_fail
+            n = n.add node.updated(:set_flag, ["#{id}_FAILED", :auto_generated])
+            delayed = n.find(:delayed)
+            if delayed && delayed.to_a[0]
+              n
+            else
+              n.ensure_node_present(:continue)
+            end
+          else
+            n
+          end
+        end)
+      end
+
+      def add_ran_flags(id, node)
+        set_flag = node.updated(:set_flag, ["#{id}_RAN", :auto_generated])
+        # For a group, set a flag immediately upon entry to the group to signal that
+        # it ran to later tests, this is better than doing it immediately after the group
+        # in case it was bypassed
+        if node.type == :group || node.type == :sub_flow
+          nodes = node.to_a.dup
+          pre_nodes = []
+          while [:name, :id, :path].include?(nodes.first.try(:type))
+            pre_nodes << nodes.shift
+          end
+          node.updated(nil, pre_nodes + [set_flag] + nodes)
+
+        # For a test, set a flag immediately after the referenced test has executed
+        # but don't change its pass/fail handling
+        elsif node.type == :test
+          node.updated(:inline, [node, set_flag])
+        else
+          fail "Don't know how to add ran flag to #{node.type}"
+        end
+      end
+
+      # Set flags depending on the result on tests which have dependents later
+      # in the flow
+      def on_test(node)
+        node = node.updated(nil, process_all(node.children))
+        nid = id(node)
+        # If this test has a dependent
+        if test_results[nid]
+          node = add_pass_flag(nid, node) if test_results[nid][:passed]
+          node = add_fail_flag(nid, node) if test_results[nid][:failed]
+          node = add_ran_flags(nid, node) if test_results[nid][:ran]
+        end
+        node
+      end
+      alias_method :on_group, :on_test
+      alias_method :on_sub_flow, :on_test
+
+      def on_if_failed(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'FAILED')] + process_all(children))
+      end
+      alias_method :on_if_any_failed, :on_if_failed
+
+      def on_if_all_failed(node)
+        ids, *children = *node
+        ids.reverse_each.with_index do |id, i|
+          if i == 0
+            node = node.updated(:if_flag, [id_to_flag(id, 'FAILED')] + process_all(children))
+          else
+            node = node.updated(:if_flag, [id_to_flag(id, 'FAILED'), node])
+          end
+        end
+        node
+      end
+
+      def on_if_passed(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'PASSED')] + process_all(children))
+      end
+      alias_method :on_if_any_passed, :on_if_passed
+
+      def on_if_all_passed(node)
+        ids, *children = *node
+        ids.reverse_each.with_index do |id, i|
+          if i == 0
+            node = node.updated(:if_flag, [id_to_flag(id, 'PASSED')] + process_all(children))
+          else
+            node = node.updated(:if_flag, [id_to_flag(id, 'PASSED'), node])
+          end
+        end
+        node
+      end
+
+      def on_if_ran(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'RAN')] + process_all(children))
+      end
+
+      def on_unless_ran(node)
+        id, *children = *node
+        node.updated(:unless_flag, [id_to_flag(id, 'RAN')] + process_all(children))
+      end
+
+      # Returns the ID of the give test node (if any), caller is responsible
+      # for only passing test nodes
+      def id(node)
+        if n = node.children.find { |c| c.type == :id }
+          n.children.first
+        end
+      end
+
+      def id_to_flag(id, type)
+        if id.is_a?(Array)
+          id.map { |i| "#{i}_#{type}" }
+        else
+          "#{id}_#{type}"
+        end
+      end
+    end
+  end
+end