origen_testers 0.21.0 → 0.30.0

data/lib/origen_testers/atp/flow_api.rb

@@ -0,0 +1,56 @@
+module OrigenTesters::ATP
+  module FlowAPI
+    def atp=(atp)
+      @atp = atp
+    end
+
+    def atp
+      @atp
+    end
+
+    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :set_flag, :set, :enable, :disable, :render,
+      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin, :loop] +
+      OrigenTesters::ATP::Flow::CONDITION_KEYS.keys + OrigenTesters::ATP::Flow::RELATIONAL_OPERATORS).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
+
+    def lo_limit(value, options)
+      {
+        value:    value,
+        rule:     options[:rule] || :gte,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
+
+    def hi_limit(value, options)
+      {
+        value:    value,
+        rule:     options[:rule] || :lte,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
+
+    def limit(value, options)
+      unless options[:rule]
+        fail 'You must supply option :rule (e.g. rule: :gt) when calling the limit helper'
+      end
+      {
+        value:    value,
+        rule:     options[:rule] || :lt,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
+  end
+end

data/lib/origen_testers/atp/formatter.rb

@@ -0,0 +1,25 @@
+module OrigenTesters::ATP
+  class Formatter < Processor
+    def format(node, options = {})
+      process(node)
+    end
+
+    def run_and_format(node, options = {})
+      ast = Runner.new.run(node, options)
+      format(ast, options)
+    end
+
+    def self.format(node, options = {})
+      new.format(node, options)
+    end
+
+    def self.run_and_format(node, options = {})
+      ast = Runner.new.run(node, options)
+      format(ast, options)
+    end
+
+    def self.run(*args)
+      run_and_format(*args)
+    end
+  end
+end

data/lib/origen_testers/atp/formatters/basic.rb

@@ -0,0 +1,32 @@
+module OrigenTesters::ATP
+  module Formatters
+    # Returns the executed flow as a string of test names. This
+    # is mainly intended to be used for testing the runner.
+    class Basic < Formatter
+      def format(node, options = {})
+        @output = ''
+        process(node)
+        @output
+      end
+
+      def on_test(node)
+        if node.find(:name)
+          @output += node.find(:name).value
+        else
+          obj = node.find(:object).value
+          obj = obj['Test'] unless obj.is_a?(String)
+          @output += obj
+        end
+        @output += ' F' if node.find(:failed)
+        @output += "\n"
+      end
+
+      def on_set_result(node)
+        @output += node.to_a[0].upcase
+        @output += " #{node.find(:bin).value}" if node.find(:bin)
+        @output += " #{node.find(:softbin).value}" if node.find(:softbin)
+        @output += "\n"
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/formatters/datalog.rb

@@ -0,0 +1,65 @@
+require 'colored'
+module OrigenTesters::ATP
+  module Formatters
+    # Outputs the given AST to something resembling an ATE datalog,
+    # this can optionally be rendered to a file or the console (the default).
+    class Datalog < Formatter
+      def on_flow(node)
+        str = 'Number'.ljust(15)
+        str += 'Result'.ljust(9)
+        str += 'Name'.ljust(55)
+        str += 'Pattern'.ljust(55)
+        str += 'ID'
+        puts str
+        process_all(node.children)
+      end
+
+      def on_test(node)
+        str = "#{node.find(:number).try(:value)}".ljust(15)
+        if node.find(:failed)
+          str += 'FAIL'.ljust(9).red
+        else
+          str += 'PASS'.ljust(9)
+        end
+        if n = node.find(:name)
+          name = n.value
+        else
+          name = node.find(:object).value['Test']
+        end
+        str += "#{name}".ljust(55)
+        str += "#{node.find(:object).value['Pattern']}".ljust(55)
+        str += "#{node.find(:id).value}"
+        puts str
+      end
+
+      def on_render(node)
+        puts '************ Directly rendered flow snippet ************'
+        puts node.value
+        puts '********************************************************'
+      end
+
+      def on_log(node)
+        puts "// #{node.value}"
+      end
+
+      def on_set_result(node)
+        bin = node.find(:bin).try(:value)
+        sbin = node.find(:softbin).try(:value)
+        desc = node.find(:description).try(:value)
+
+        if node.to_a[0] == 'pass'
+          str = "               PASS     #{bin}      #{sbin}"
+          color = :green
+        else
+          str = "               FAIL     #{bin}      #{sbin}"
+          color = :red
+        end
+        str += "      (#{desc})" if desc
+
+        puts '---------------------------------------------------------------------------------------------------------------------------------------------------------'
+        puts str.send(color)
+        puts '---------------------------------------------------------------------------------------------------------------------------------------------------------'
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/parser.rb

@@ -0,0 +1,26 @@
+require 'sexpistol'
+module OrigenTesters::ATP
+  class Parser < Sexpistol
+    def initialize
+      self.ruby_keyword_literals = true
+    end
+
+    def string_to_ast(string)
+      to_sexp(parse_string(string))
+    end
+
+    def to_sexp(ast_array)
+      children = ast_array.map do |item|
+        if  item.is_a?(Array)
+          to_sexp(item)
+        else
+          item
+        end
+      end
+      type = children.shift
+      return type if type.is_a?(OrigenTesters::ATP::AST::Node)
+      type = type.to_s.gsub('-', '_').to_sym
+      OrigenTesters::ATP::AST::Node.new(type, children)
+    end
+  end
+end

data/lib/origen_testers/atp/processor.rb

@@ -0,0 +1,73 @@
+require 'ast'
+module OrigenTesters::ATP
+  # The base processor, this provides a default handler for
+  # all node types and will not make any changes to the AST,
+  # i.e. an equivalent AST will be returned by the process method.
+  #
+  # Child classes of this should be used to implement additional
+  # processors to modify or otherwise work with the AST.
+  #
+  # @see http://www.rubydoc.info/gems/ast/2.0.0/AST/Processor
+  class Processor
+    include ::AST::Processor::Mixin
+
+    def run(node)
+      process(node)
+    end
+
+    def process(node)
+      if node.respond_to?(:to_ast)
+        super(node)
+      else
+        node
+      end
+    end
+
+    # Some of our processors remove a wrapping node from the AST, returning
+    # a node of type :inline containing the children which should be inlined.
+    # Here we override the default version of this method to deal with handlers
+    # that return an inline node in place of a regular node.
+    def process_all(nodes)
+      results = []
+      nodes.to_a.each do |node|
+        n = process(node)
+        if n.respond_to?(:type) && n.type == :inline
+          results += n.children
+        else
+          results << n unless n.respond_to?(:type) && n.type == :remove
+        end
+      end
+      results
+    end
+
+    def handler_missing(node)
+      node.updated(nil, process_all(node.children))
+    end
+
+    def extract_volatiles(flow)
+      @volatiles = {}
+      if v = flow.find(:volatile)
+        @volatiles[:flags] = Array(v.find_all(:flag)).map(&:value)
+      end
+    end
+
+    def volatile_flags
+      unless @volatiles
+        fail 'You must first call extract_volatiles(node) from your on_flow hander method'
+      end
+      @volatiles[:flags] || []
+    end
+
+    # Returns true if the given flag name has been marked as volatile
+    def volatile?(flag)
+      result = volatile_flags.any? { |f| clean_flag(f) == clean_flag(flag) }
+      result
+    end
+
+    def clean_flag(flag)
+      flag = flag.dup.to_s
+      flag[0] = '' if flag[0] == '$'
+      flag.downcase
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module OrigenTesters::ATP
+  module Processors
+    # Assigns an ID to all test nodes that don't have one
+    class AddIDs < Processor
+      def run(node)
+        @i = 0
+        @existing_ids = []
+        @add_ids = false
+        # First collect all existing IDs, this is required to make sure
+        # that a generated ID does not clash with an existing one
+        process(node)
+        # Now run again to fill in the blanks
+        @add_ids = true
+        process(node)
+      end
+
+      def on_test(node)
+        if @add_ids
+          node = node.ensure_node_present(:id)
+          node.updated(nil, process_all(node))
+        else
+          if id = node.find(:id)
+            @existing_ids << id.value
+          end
+          process_all(node)
+        end
+      end
+      alias_method :on_group, :on_test
+
+      def on_id(node)
+        if @add_ids
+          unless node.value
+            node.updated(nil, [next_id])
+          end
+        end
+      end
+
+      def next_id
+        @i += 1
+        @i += 1 while @existing_ids.include?("t#{@i}")
+        "t#{@i}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module OrigenTesters::ATP
+  module Processors
+    # Makes sure every test node has an on_fail/set_result node,
+    class AddSetResult < Processor
+      def run(node)
+        process(node)
+      end
+
+      def on_test(node)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, process_all(node))
+      end
+
+      def on_on_fail(node)
+        unless node.find(:continue)
+          node = node.ensure_node_present(:set_result, 'fail')
+        end
+        node.updated(nil, process_all(node))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module OrigenTesters::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 < OrigenTesters::ATP::Processor
+      class SetRunFlagFinder < OrigenTesters::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_named_collection(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+      alias_method :on_group, :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_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]) || (volatile?(node1.to_a[0]) && !node1.contains?(:test))) &&
+          !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
+      end
+    end
+  end
+end