atp 0.8.0 → 1.0.0

data/lib/atp/flow_api.rb

@@ -0,0 +1,26 @@
+module ATP
+  module FlowAPI
+    def atp=(atp)
+      @atp = atp
+    end
+
+    def atp
+      @atp
+    end
+
+    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :set_flag, :enable, :disable, :render,
+      :context_changed?] +
+      ATP::Flow::CONDITION_KEYS.keys).each do |method|
+      define_method method do |*args, &block|
+        options = args.pop if args.last.is_a?(Hash)
+        options ||= {}
+        add_meta!(options) if respond_to?(:add_meta!, true)
+        add_description!(options) if respond_to?(:add_description!, true)
+        args << options
+        atp.send(method, *args, &block)
+      end
+    end
+
+    alias_method :logprint, :log
+  end
+end

data/lib/atp/formatters/basic.rb

@@ -13,7 +13,9 @@ module ATP
         if node.find(:name)
           @output += node.find(:name).value
         else
-          @output += node.find(:object).value['Test']
+          obj = node.find(:object).value
+          obj = obj['Test'] unless obj.is_a?(String)
+          @output += obj
         end
         @output += ' F' if node.find(:failed)
         @output += "\n"

data/lib/atp/processor.rb

@@ -44,22 +44,6 @@ module ATP
       node.updated(nil, process_all(node.children))
     end
 
-    def n(type, children)
-      ATP::AST::Node.new(type, children)
-    end
-
-    def n0(type)
-      n(type, [])
-    end
-
-    def n1(type, arg)
-      n(type, [arg])
-    end
-
-    def n2(type, arg1, arg2)
-      n(type, [arg1, arg2])
-    end
-
     def extract_volatiles(flow)
       @volatiles = {}
       if v = flow.find(:volatile)

data/lib/atp/processors/add_ids.rb

@@ -25,6 +25,7 @@ module ATP
           process_all(node)
         end
       end
+      alias_method :on_group, :on_test
 
       def on_id(node)
         if @add_ids

data/lib/atp/processors/adjacent_if_combiner.rb

@@ -0,0 +1,97 @@
+module ATP
+  module Processors
+    # This combines adjacent if flag nodes where the flag is in the opposite state
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:if_flag, "SOME_FLAG",
+    #       s(:test,
+    #         s(:name, "test1"))),
+    #     s(:unless_flag, "SOME_FLAG",
+    #       s(:test,
+    #         s(:name, "test2"))))
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:if_flag, "SOME_FLAG",
+    #       s(:test,
+    #         s(:name, "test1"))),
+    #       s(:else,
+    #         s(:test,
+    #           s(:name, "test2"))))
+    #
+    # See here for an example of the kind of flow level effect it has:
+    # https://github.com/Origen-SDK/origen_testers/issues/43
+    class AdjacentIfCombiner < ATP::Processor
+      class SetRunFlagFinder < ATP::Processor
+        def contains?(node, flag_name)
+          @result = false
+          @flag_name = flag_name
+          process_all(node)
+          @result
+        end
+
+        def on_set_flag(node)
+          if node.to_a[0] == @flag_name
+            @result = true
+          end
+        end
+        alias_method :on_enable, :on_set_flag
+        alias_method :on_disable, :on_set_flag
+      end
+
+      def on_flow(node)
+        extract_volatiles(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+
+      def on_group(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+
+      def on_unnamed_collection(node)
+        node.updated(nil, optimize(process_all(node.children)))
+      end
+      alias_method :on_on_fail, :on_unnamed_collection
+      alias_method :on_on_pass, :on_unnamed_collection
+
+      def optimize(nodes)
+        results = []
+        node1 = nil
+        nodes.each do |node2|
+          if node1
+            if opposite_flag_states?(node1, node2) && safe_to_combine?(node1, node2)
+              results << combine(node1, node2)
+              node1 = nil
+            else
+              results << node1
+              node1 = node2
+            end
+          else
+            node1 = node2
+          end
+        end
+        results << node1 if node1
+        results
+      end
+
+      def combine(node1, node2)
+        node1.updated(nil, process_all(node1.children) + [node2.updated(:else, process_all(node2.to_a[1..-1]))])
+      end
+
+      def opposite_flag_states?(node1, node2)
+        ((node1.type == :if_flag && node2.type == :unless_flag) || (node1.type == :unless_flag && node2.type == :if_flag) ||
+         (node1.type == :if_enabled && node2.type == :unless_enabled) || (node1.type == :unless_enabled && node2.type == :if_enabled)) &&
+          node1.to_a[0] == node2.to_a[0]
+      end
+
+      def safe_to_combine?(node1, node2)
+        # Nodes won't be collapsed if node1 touches the shared run flag, i.e. if there is any chance
+        # that by the time it would naturally execute node2, the flag could have been changed by node1
+        !volatile?(node1.to_a[0]) && !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
+      end
+    end
+  end
+end

data/lib/atp/processors/append_to.rb

@@ -0,0 +1,27 @@
+module 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/atp/processors/apply_post_group_actions.rb

@@ -0,0 +1,50 @@
+module 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/atp/processors/condition.rb

@@ -48,45 +48,44 @@ module ATP
         node.updated(nil, optimize(process_all(node.children)))
       end
 
-      def on_flow_flag(node)
-        flag, state, *nodes = *node
-        if conditions_to_remove.any? { |c| node.type == c.type && c.to_a == [flag, state] }
+      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 = n(:inline, optimize(process_all(nodes)))
+            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, state])
-            result = n(:inline, optimize(process_all(nodes)))
+            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, state] + optimize(process_all(nodes)))
+            result = node.updated(nil, [flag] + optimize(process_all(nodes)))
           else
-            conditions_to_remove << node.updated(nil, [flag, state])
-            result = node.updated(nil, [flag, state] + optimize(process_all(nodes)))
+            conditions_to_remove << node.updated(nil, [flag])
+            result = node.updated(nil, [flag] + optimize(process_all(nodes)))
             conditions_to_remove.pop
           end
         end
         result
       end
-      alias_method :on_test_result, :on_flow_flag
-      alias_method :on_job, :on_flow_flag
-      alias_method :on_run_flag, :on_flow_flag
-      alias_method :on_test_executed, :on_flow_flag
-
-      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 = n(: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
+      ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
       end
 
       def optimize(nodes)
@@ -117,8 +116,8 @@ module ATP
       end
 
       def condition_node?(node)
-        node.respond_to?(:type) &&
-          [:flow_flag, :run_flag, :test_result, :group, :job, :test_executed].include?(node.type)
+        # [:flow_flag, :run_flag, :test_result, :group, :job, :test_executed].include?(node.type)
+        node.respond_to?(:type) && ATP::Flow::CONDITION_KEYS[node.type]
       end
 
       def combine(node1, node2)
@@ -143,16 +142,14 @@ module ATP
 
       def conditions(node)
         result = []
-        if [:flow_flag, :run_flag].include?(node.type)
-          flag, state, *children = *node
+        # 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, state])
+            result << node.updated(nil, [flag])
           end
-          result += conditions(children.first) if children.first
-        elsif [:test_result, :job, :test_executed].include?(node.type)
-          flag, state, *children = *node
-          result << node.updated(nil, [flag, state])
-          result += conditions(children.first) if children.first
+          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
@@ -161,7 +158,11 @@ module ATP
           else
             result << node.updated(nil, [name])
           end
-          result += conditions(children.first) if children.first
+          result += conditions(children.first) if children.first && children.size == 1
+        elsif 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

data/lib/atp/processors/continue_implementer.rb

@@ -0,0 +1,35 @@
+module 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 < 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/atp/processors/else_remover.rb

@@ -0,0 +1,31 @@
+module 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
+      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/atp/processors/empty_branch_remover.rb

@@ -0,0 +1,17 @@
+module 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