origen_testers 0.21.0 → 0.30.0

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

@@ -0,0 +1,27 @@
+module OrigenTesters::ATP
+  module Processors
+    # Appends the given node to the node with the given ID, if it exists
+    # somewhere within the given parent node
+    class AppendTo < Processor
+      def run(parent, node, id, options = {})
+        @to_be_appended = node
+        @id_of_to_be_appended_to = id
+        @found = false
+        process(parent)
+      end
+
+      def succeeded?
+        @found
+      end
+
+      def handler_missing(node)
+        if node.id == @id_of_to_be_appended_to
+          @found = true
+          node.updated(nil, node.children + [@to_be_appended])
+        else
+          node.updated(nil, process_all(node.children))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module OrigenTesters::ATP
+  module Processors
+    # This removes on_pass/fail operations from groups and applies them to all
+    # contained tests
+    class ApplyPostGroupActions < Processor
+      def run(node)
+        @on_pass = []
+        @on_fail = []
+        process(node)
+      end
+
+      def on_group(node)
+        on_pass = node.find(:on_pass)
+        on_fail = node.find(:on_fail)
+        @on_pass << on_pass
+        @on_fail << on_fail
+        node = node.remove(on_pass) if on_pass
+        node = node.remove(on_fail) if on_fail
+        node = node.updated(nil, process_all(node.children))
+        @on_fail.pop
+        @on_pass.pop
+        node
+      end
+
+      def on_test(node)
+        node = node.ensure_node_present(:on_pass) if @on_pass.any? { |n| n }
+        node = node.ensure_node_present(:on_fail) if @on_fail.any? { |n| n }
+        node.updated(nil, process_all(node.children))
+      end
+
+      def on_on_pass(node)
+        @on_pass.each do |on_pass|
+          if on_pass
+            node = node.updated(nil, node.children + process_all(on_pass.children))
+          end
+        end
+        node
+      end
+
+      def on_on_fail(node)
+        @on_fail.each do |on_fail|
+          if on_fail
+            node = node.updated(nil, node.children + process_all(on_fail.children))
+          end
+        end
+        node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+module OrigenTesters::ATP
+  module Processors
+    # This optimizes the condition nodes such that any adjacent flow nodes that
+    # have the same condition, will be grouped together under a single condition
+    # wrapper.
+    #
+    # For example this AST:
+    #
+    #   (flow
+    #     (group
+    #       (name "g1")
+    #       (test
+    #         (name "test1"))
+    #       (flow-flag "bitmap" true
+    #         (test
+    #           (name "test2"))))
+    #     (flow-flag "bitmap" true
+    #       (group
+    #         (name "g1")
+    #         (flow-flag "x" true
+    #           (test
+    #             (name "test3")))
+    #         (flow-flag "y" true
+    #           (flow-flag "x" true
+    #             (test
+    #               (name "test4")))))))
+    #
+    # Will be optimized to this:
+    #
+    #   (flow
+    #     (group
+    #       (name "g1")
+    #       (test
+    #         (name "test1"))
+    #       (flow-flag "bitmap" true
+    #         (test
+    #           (name "test2"))
+    #         (flow-flag "x" true
+    #           (test
+    #             (name "test3"))
+    #           (flow-flag "y" true
+    #             (test
+    #               (name "test4")))))))
+    #
+    class Condition < Processor
+      def on_flow(node)
+        extract_volatiles(node)
+        node.updated(nil, optimize(process_all(node.children)))
+      end
+
+      def on_sub_flow(node)
+        node.updated(nil, optimize(process_all(node.children)))
+      end
+
+      def on_group(node)
+        name, *nodes = *node
+        if conditions_to_remove.any? { |c| node.type == c.type && c.to_a == [name] }
+          conditions_to_remove << node.updated(nil, [name])
+          result = node.updated(:inline, optimize(process_all(nodes)))
+          conditions_to_remove.pop
+        else
+          conditions_to_remove << node.updated(nil, [name])
+          result = node.updated(nil, [name] + optimize(process_all(nodes)))
+          conditions_to_remove.pop
+        end
+        result
+      end
+
+      def on_condition_node(node)
+        flag, *nodes = *node
+        if conditions_to_remove.any? { |c| node.type == c.type && c.to_a == [flag] }
+          if volatile?(flag)
+            result = node.updated(:inline, optimize(process_all(nodes)))
+          else
+            # This ensures any duplicate conditions matching the current one get removed
+            conditions_to_remove << node.updated(nil, [flag])
+            result = node.updated(:inline, optimize(process_all(nodes)))
+            conditions_to_remove.pop
+          end
+        else
+          if volatile?(flag)
+            result = node.updated(nil, [flag] + optimize(process_all(nodes)))
+          else
+            conditions_to_remove << node.updated(nil, [flag])
+            result = node.updated(nil, [flag] + optimize(process_all(nodes)))
+            conditions_to_remove.pop
+          end
+        end
+        result
+      end
+      OrigenTesters::ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
+      end
+
+      def optimize(nodes)
+        results = []
+        node1 = nil
+        nodes.each do |node2|
+          if node1
+            if can_be_combined?(node1, node2)
+              node1 = process(combine(node1, node2))
+            else
+              results << node1
+              node1 = node2
+            end
+          else
+            node1 = node2
+          end
+        end
+        results << node1 if node1
+        results
+      end
+
+      def can_be_combined?(node1, node2)
+        if condition_node?(node1) && condition_node?(node2)
+          !(conditions(node1) & conditions(node2)).empty?
+        else
+          false
+        end
+      end
+
+      def condition_node?(node)
+        # [:flow_flag, :run_flag, :test_result, :group, :job, :test_executed].include?(node.type)
+        node.respond_to?(:type) && OrigenTesters::ATP::Flow::CONDITION_KEYS[node.type]
+      end
+
+      def combine(node1, node2)
+        common = conditions(node1) & conditions(node2)
+        common.each { |condition| conditions_to_remove << condition }
+        node1 = process(node1)
+        node1 = [node1] unless node1.is_a?(Array)
+        node2 = process(node2)
+        node2 = [node2] unless node2.is_a?(Array)
+        common.size.times { conditions_to_remove.pop }
+
+        node = nil
+        common.reverse_each do |condition|
+          if node
+            node = condition.updated(nil, condition.children + [node])
+          else
+            node = condition.updated(nil, condition.children + node1 + node2)
+          end
+        end
+        node
+      end
+
+      def conditions(node)
+        result = []
+        # if [:flow_flag, :run_flag].include?(node.type)
+        if [:if_enabled, :unless_enabled, :if_flag, :unless_flag].include?(node.type)
+          flag, *children = *node
+          unless volatile?(flag)
+            result << node.updated(nil, [flag])
+          end
+          result += conditions(children.first) if children.first && children.size == 1
+        # elsif [:test_result, :job, :test_executed].include?(node.type)
+        elsif node.type == :group
+          name, *children = *node
+          # Sometimes a group can have an ID
+          if children.first.try(:type) == :id
+            result << node.updated(nil, [name, children.shift])
+          else
+            result << node.updated(nil, [name])
+          end
+          result += conditions(children.first) if children.first && children.size == 1
+        elsif OrigenTesters::ATP::Flow::CONDITION_NODE_TYPES.include?(node.type)
+          flag, *children = *node
+          result << node.updated(nil, [flag])
+          result += conditions(children.first) if children.first && children.size == 1
+        end
+        result
+      end
+
+      def conditions_to_remove
+        @conditions_to_remove ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module OrigenTesters::ATP
+  module Processors
+    # Implements continue on a fail branch for V93K by removing any bin nodes that are
+    # siblings of continue nodes. The continue nodes are also removed in the process since
+    # they have now served their function.
+    class ContinueImplementer < OrigenTesters::ATP::Processor
+      # Delete any on-fail child if it's 'empty'
+      def on_on_fail(node)
+        if cont = node.find(:continue) || @continue
+          node = node.updated(nil, node.children - [cont] - node.find_all(:set_result))
+        end
+        node.updated(nil, process_all(node.children))
+      end
+
+      def on_group(node)
+        f = node.find(:on_fail)
+        if f && f.find(:continue)
+          with_continue do
+            node = node.updated(nil, process_all(node.children))
+          end
+          node
+        else
+          node.updated(nil, process_all(node.children))
+        end
+      end
+
+      def with_continue
+        orig = @continue
+        @continue = true
+        yield
+        @continue = orig
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module OrigenTesters::ATP
+  module Processors
+    # Removes embedded else nodes and converts them to the equivalent inverse condition
+    # node at the same level as the parent node
+    class ElseRemover < Processor
+      def run(node)
+        process(node)
+      end
+
+      def on_condition_node(node)
+        if e = node.find(:else)
+          n1 = node.remove(e)
+          if node.type.to_s =~ /if_/
+            type = node.type.to_s.sub('if_', 'unless_').to_sym
+          elsif node.type.to_s =~ /unless_/
+            type = node.type.to_s.sub('unless_', 'if_').to_sym
+          else
+            fail "Don't know how to inverse: #{node.type}"
+          end
+          n2 = e.updated(type, [n1.to_a[0]] + e.children)
+          node.updated(:inline, [n1, n2])
+        else
+          node.updated(nil, process_all(node.children))
+        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/empty_branch_remover.rb

@@ -0,0 +1,17 @@
+module OrigenTesters::ATP
+  module Processors
+    # Removes any empty on_pass and on_fail branches
+    class EmptyBranchRemover < Processor
+      # Delete any on-fail child if it's 'empty'
+      def on_test(node)
+        if on_pass = node.find(:on_pass)
+          node = node.remove(on_pass) if on_pass.children.empty?
+        end
+        if on_fail = node.find(:on_fail)
+          node = node.remove(on_fail) if on_fail.children.empty?
+        end
+        node = node.updated(nil, process_all(node.children))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module OrigenTesters::ATP
+  module Processors
+    # Extracts all flags which are set within the given flow, returning
+    # them in an array
+    class ExtractSetFlags < OrigenTesters::ATP::Processor
+      def run(nodes)
+        @results = []
+        process_all(nodes)
+        @results.uniq
+      end
+
+      def on_set_flag(node)
+        flag = node.value
+        @results << flag
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+module OrigenTesters::ATP
+  module Processors
+    # This processor eliminates the use of run flags between adjacent tests:
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:test,
+    #       s(:name, "test1"),
+    #       s(:id, "t1"),
+    #       s(:on_fail,
+    #         s(:set_flag, "t1_FAILED", "auto_generated"),
+    #         s(:continue))),
+    #     s(:if_flag, "t1_FAILED",
+    #       s(:test,
+    #         s(:name, "test2"))))
+    #
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:test,
+    #       s(:name, "test1"),
+    #       s(:id, "t1"),
+    #       s(:on_fail,
+    #         s(:test,
+    #           s(:name, "test2")))))
+    #
+    class FlagOptimizer < Processor
+      attr_reader :run_flag_table, :optimize_when_continue
+
+      class ExtractRunFlagTable < Processor
+        # Hash table of run_flag name with number of times used
+        attr_reader :run_flag_table
+
+        # Reset hash table
+        def initialize
+          @run_flag_table = {}.with_indifferent_access
+        end
+
+        # For run_flag nodes, increment # of occurrences for specified flag
+        def on_if_flag(node)
+          children = node.children.dup
+          names = children.shift
+          state = node.type == :if_flag
+          Array(names).each do |name|
+            if @run_flag_table[name.to_sym].nil?
+              @run_flag_table[name.to_sym] = 1
+            else
+              @run_flag_table[name.to_sym] += 1
+            end
+          end
+          process_all(node.children)
+        end
+        alias_method :on_unless_flag, :on_if_flag
+      end
+
+      def run(node, options = {})
+        options = {
+          optimize_when_continue: true
+        }.merge(options)
+        @optimize_when_continue = options[:optimize_when_continue]
+        # Pre-process the AST for # of occurrences of each run-flag used
+        t = ExtractRunFlagTable.new
+        t.process(node)
+        @run_flag_table = t.run_flag_table
+        extract_volatiles(node)
+        process(node)
+      end
+
+      def on_named_collection(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+      alias_method :on_flow, :on_named_collection
+      alias_method :on_group, :on_named_collection
+      alias_method :on_unless_flag, :on_named_collection
+      alias_method :on_sub_flow, :on_named_collection
+
+      def on_unnamed_collection(node)
+        node.updated(nil, optimize(process_all(node.children)))
+      end
+      alias_method :on_else, :on_unnamed_collection
+
+      def on_whenever(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+      alias_method :on_whenever_all, :on_whenever
+      alias_method :on_whenever_any, :on_whenever
+
+      def on_if_flag(node)
+        name, *nodes = *node
+        # Remove this node and return its children if required
+        if if_run_flag_to_remove.last == node.to_a[0]
+          node.updated(:inline, optimize(process_all(node.to_a[1..-1])))
+        else
+          node.updated(nil, [name] + optimize(process_all(nodes)))
+        end
+      end
+
+      def on_on_fail(node)
+        if to_inline = nodes_to_inline_on_pass_or_fail.last
+          # If this node sets the flag that gates the node to be inlined
+          set_flag = node.find(:set_flag)
+          if set_flag && gated_by_set?(set_flag.to_a[0], to_inline)
+            # Remove the sub-node that sets the flag if there are no further references to it
+
+            if @run_flag_table[set_flag.to_a[0]] == 1 || !@run_flag_table[set_flag.to_a[0]]
+              node = node.updated(nil, node.children - [set_flag])
+            end
+
+            # And append the content of the node to be in_lined at the end of this on pass/fail node
+            append = reorder_nested_run_flags(set_flag.to_a[0], to_inline).to_a[1..-1]
+
+            # Belt and braces approach to make sure this node to be inlined does
+            # not get picked up anywhere else
+            nodes_to_inline_on_pass_or_fail.pop
+            nodes_to_inline_on_pass_or_fail << nil
+          end
+        end
+        node.updated(nil, optimize(process_all(node.children + Array(append))))
+      end
+      alias_method :on_on_pass, :on_on_fail
+
+      def optimize(nodes)
+        results = []
+        node1 = nil
+        nodes.each do |node2|
+          if node1
+            if can_be_combined?(node1, node2)
+              node1 = combine(node1, node2)
+            else
+              results << node1
+              node1 = node2
+            end
+          else
+            node1 = node2
+          end
+        end
+        results << node1 if node1
+        results
+      end
+
+      def can_be_combined?(node1, node2)
+        if (node1.type == :test || node1.type == :sub_flow) && (node2.type == :if_flag || node2.type == :unless_flag) &&
+           # Don't optimize tests which are marked as continue if told not to
+           !(node1.find(:on_fail) && node1.find(:on_fail).find(:continue) && !optimize_when_continue)
+
+          if node1.find_all(:on_fail, :on_pass).any? do |node|
+            if n = node.find(:set_flag)
+              # Inline instead of setting a flag if...
+              gated_by_set?(n.to_a[0], node2) && # The flag set by node1 is gating node2
+              n.to_a[1] == 'auto_generated' && # The flag has been generated and not specified by the user
+              n.to_a[0] !~ /_RAN$/ && # And don't compress RAN flags because they can be set by both on_fail and on_pass
+              !volatile?(n.to_a[0]) # And make sure the flag has not been marked as volatile
+            end
+          end
+            return true
+          end
+        end
+        false
+      end
+
+      def combine(node1, node2)
+        nodes_to_inline_on_pass_or_fail << node2 # .updated(nil, process_all(node2.children))
+        node1 = node1.updated(nil, process_all(node1.children))
+        nodes_to_inline_on_pass_or_fail.pop
+        node1
+      end
+
+      # node will always be an if_flag or unless_flag type node, guaranteed by the caller
+      #
+      # Returns true if flag matches the one supplied
+      #
+      #   s(:if_flag, flag,
+      #     s(:test, ...
+      #
+      # Also returns true if flag matches the one supplied, but it is nested within other flag conditions:
+      #
+      #   s(:unless_flag, other_flag,
+      #     s(:if_flag, other_flag2,
+      #       s(:if_flag, flag,
+      #         s(:test, ...
+      def gated_by_set?(flag, node)
+        (flag == node.to_a[0] && node.type == :if_flag) ||
+          (node.to_a.size == 2 && (node.to_a.last.type == :if_flag || node.to_a.last.type == :unless_flag) && gated_by_set?(flag, node.to_a.last))
+      end
+
+      # Returns the node with the run_flag clauses re-ordered to have the given flag of interest at the top.
+      #
+      # The caller guarantees the run_flag clause containing the given flag is present.
+      #
+      # For example, given this node:
+      #
+      #   s(:unless_flag, "flag1",
+      #     s(:if_flag, "ot_BEA7F3B_FAILED",
+      #       s(:test,
+      #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+      #         s(:name, "inner_test1_BEA7F3B"),
+      #         s(:number, 0),
+      #         s(:id, "it1_BEA7F3B"),
+      #         s(:on_fail,
+      #           s(:render, "multi_bin;")))))
+      #
+      # Then this node would be returned when the flag of interest is ot_BEA7F3B_FAILED:
+      #
+      #   s(:if_flag, "ot_BEA7F3B_FAILED",
+      #     s(:unless_flag, "flag1",
+      #       s(:test,
+      #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+      #         s(:name, "inner_test1_BEA7F3B"),
+      #         s(:number, 0),
+      #         s(:id, "it1_BEA7F3B"),
+      #         s(:on_fail,
+      #           s(:render, "multi_bin;")))))
+      def reorder_nested_run_flags(flag, node)
+        # If the run_flag we care about is already at the top, just return node
+        unless node.to_a[0] == flag && node.type == :if_flag
+          if_run_flag_to_remove << flag
+          node = node.updated(:if_flag, [flag] + [process(node)])
+          if_run_flag_to_remove.pop
+        end
+        node
+      end
+
+      def if_run_flag_to_remove
+        @if_run_flag_to_remove ||= []
+      end
+
+      def nodes_to_inline_on_pass_or_fail
+        @nodes_to_inline_on_pass_or_fail ||= []
+      end
+    end
+  end
+end