origen_testers 0.21.0 → 0.30.0

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

@@ -0,0 +1,10 @@
+module OrigenTesters::ATP
+  module Processors
+    # Removes all :sub_flow nodes
+    class SubFlowRemover < Processor
+      def on_sub_flow(node)
+        node.updated(:remove, nil)
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/program.rb

@@ -0,0 +1,48 @@
+module OrigenTesters::ATP
+  # Program is the top-level container for a collection of test flows
+  class Program
+    # Load a program from a previously saved file
+    def self.load(file)
+      p = nil
+      File.open(file) do |f|
+        p = Marshal.load(f)
+      end
+      p
+    end
+
+    def flow(name, options = {})
+      flows[name] ||= Flow.new(self, name, options)
+    end
+
+    def flows
+      @flows ||= {}.with_indifferent_access
+      # To rescue previously created programs which have been loaded
+      unless @flows.is_a?(ActiveSupport::HashWithIndifferentAccess)
+        @flows = @flows.with_indifferent_access
+      end
+      @flows
+    end
+
+    # Save the program to a file
+    def save(file)
+      File.open(file, 'w') do |f|
+        Marshal.dump(self, f)
+      end
+    end
+
+    def respond_to?(*args)
+      flows.key?(args.first) || super
+    end
+
+    def method_missing(method, *args, &block) # :nodoc:
+      if f = flows[method]
+        define_singleton_method method do
+          f
+        end
+        f
+      else
+        super
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/runner.rb

@@ -0,0 +1,234 @@
+module OrigenTesters::ATP
+  # This class is responsible for executing the given test flow based on a given
+  # set of runtime conditions.
+  # A subset of the input AST will be returned containing only the nodes that would
+  # be hit when the flow is executed under the given conditions.
+  class Runner < Processor
+    def run(node, options = {})
+      options = {
+        evaluate_enables:    true,
+        evaluate_flags:      true,
+        evaluate_set_result: true
+      }.merge(options)
+      @options = options
+      @completed = false
+      @groups = []
+      @groups_on_fail = []
+      @groups_on_pass = []
+      node = Processors::AddIDs.new.run(node)
+      node = Processors::AddSetResult.new.run(node)
+      process(node)
+    end
+
+    def on_flow(node)
+      c = open_container do
+        process_all(node.children)
+      end
+      node.updated(nil, c)
+    end
+
+    def on_name(node)
+      container << node
+    end
+
+    def on_if_flag(node)
+      if @options[:evaluate_flags]
+        flag, *nodes = *node
+        flag = [flag].flatten
+        enabled = node.type == :if_flag
+        active = flag.any? { |f| set_flags.include?(f) }
+        if (enabled && active) || (!enabled && !active)
+          process_all(nodes)
+        end
+      else
+        c = open_container do
+          process_all(node.children)
+        end
+        container << node.updated(nil, node.children.take(1) + c)
+      end
+    end
+    alias_method :on_unless_flag, :on_if_flag
+
+    def on_if_enabled(node)
+      if @options[:evaluate_enables]
+        flag, *nodes = *node
+        flag = [flag].flatten
+        enabled = node.type == :if_enabled
+        active = flag.any? { |f| set_enables.include?(f) }
+        if (enabled && active) || (!enabled && !active)
+          process_all(nodes)
+        end
+      else
+        c = open_container do
+          process_all(node.children)
+        end
+        container << node.updated(nil, node.children.take(1) + c)
+      end
+    end
+    alias_method :on_unless_enabled, :on_if_enabled
+
+    def on_if_failed(node)
+      id, *nodes = *node
+      if failed_test_ids.include?(id)
+        process_all(nodes)
+      end
+    end
+
+    def on_if_passed(node)
+      id, *nodes = *node
+      unless failed_test_ids.include?(id)
+        process_all(nodes)
+      end
+    end
+
+    def on_test(node)
+      if id = node.find(:id)
+        id = id.to_a[0]
+        if failed_test_ids.include?(id)
+          node = node.add(node.updated(:failed, []))
+          failed = true
+          if n_on_fail = node.find(:on_fail)
+            node = node.remove(n_on_fail)
+          end
+        end
+      end
+      unless failed
+        if n_on_pass = node.find(:on_pass)
+          node = node.remove(n_on_pass)
+        end
+      end
+
+      unless completed?
+        container << node
+        process_all(n_on_fail) if n_on_fail
+        process_all(n_on_pass) if n_on_pass
+      end
+
+      if failed
+        # Give indication to the parent group that at least one test within it failed
+        if @groups.last
+          @groups.pop
+          @groups << false
+        end
+        if n = node.find(:on_fail)
+          # If it has been set by a parent group, don't clear it
+          orig = @continue
+          @continue ||= !!n.find(:continue)
+          process_all(n)
+          @continue = orig
+        end
+      else
+        if n = node.find(:on_pass)
+          process_all(n)
+        end
+      end
+    end
+
+    def on_group(node)
+      on_fail = node.find(:on_fail)
+      on_pass = node.find(:on_pass)
+      c = open_container do
+        @groups << true  # This will be set to false by any tests that fail within the group
+        @groups_on_fail << on_fail
+        @groups_on_pass << on_pass
+        if on_fail
+          orig = @continue
+          @continue = !!on_fail.find(:continue)
+          process_all(node.children - [on_fail, on_pass])
+          @continue = orig
+        else
+          process_all(node.children - [on_fail, on_pass])
+        end
+        if !@groups.pop # If failed
+          if on_fail
+            @continue = !!on_fail.find(:continue)
+            process_all(on_fail)
+            @continue = false
+          end
+        else
+          if on_pass
+            process_all(on_pass)
+          end
+        end
+        @groups_on_fail.pop
+        @groups_on_pass.pop
+      end
+      container << node.updated(nil, c)
+    end
+
+    def on_set_result(node)
+      unless @continue
+        container << node unless completed?
+        @completed = true if @options[:evaluate_set_result]
+      end
+    end
+
+    def on_set_flag(node)
+      set_flags << node.to_a[0]
+    end
+
+    def on_enable(node)
+      set_enables << node.value unless set_enables.include?(node.value)
+    end
+
+    def on_disable(node)
+      set_enables.delete(node.value)
+    end
+
+    def on_log(node)
+      container << node unless completed?
+    end
+    alias_method :on_render, :on_log
+
+    def on_if_job(node)
+      jobs, *nodes = *node
+      jobs = clean_job(jobs)
+      state = node.type == :if_job
+      unless job
+        fail 'Flow contains JOB-based conditions and no current JOB has been given!'
+      end
+      if state
+        process_all(node) if jobs.include?(job)
+      else
+        process_all(node) unless jobs.include?(job)
+      end
+    end
+    alias_method :on_unless_job, :on_if_job
+
+    def clean_job(job)
+      [job].flatten.map { |j| j.to_s.upcase }
+    end
+
+    def job
+      @options[:job].to_s.upcase if @options[:job]
+    end
+
+    def failed_test_ids
+      @failed_test_ids ||= [@options[:failed_test_id] || @options[:failed_test_ids]].flatten.compact
+    end
+
+    def set_flags
+      @set_flags ||= []
+    end
+
+    # Returns an array of enabled flow flags
+    def set_enables
+      @set_enables ||= [@options[:enable] || @options[:enables]].flatten.compact
+    end
+
+    def completed?
+      @completed
+    end
+
+    def open_container(c = [])
+      @containers ||= []
+      @containers << c
+      yield
+      @containers.pop
+    end
+
+    def container
+      @containers.last
+    end
+  end
+end

data/lib/origen_testers/atp/validator.rb

@@ -0,0 +1,53 @@
+require 'ast'
+module OrigenTesters::ATP
+  class Validator < Processor
+    attr_reader :flow
+
+    def self.testing=(value)
+      @testing = value
+    end
+
+    def self.testing
+      @testing
+    end
+
+    def initialize(flow)
+      @flow = flow
+    end
+
+    def process(node)
+      if @top_level_called
+        super
+      else
+        @top_level_called = true
+        setup
+        super(node)
+        unless @testing
+          exit 1 if on_completion
+        end
+      end
+    end
+
+    # For test purposes, returns true if validation failed rather
+    # than exiting the process
+    def test_process(node)
+      @testing = true
+      process(node)
+      on_completion
+    end
+
+    def setup
+    end
+
+    def error(message)
+      # This is a hack to make the specs pass, for some reason RSpec
+      # seems to be swallowing the Origen log output after the first
+      # test that generates an error
+      if Validator.testing
+        puts message
+      else
+        Origen.log.error(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+module OrigenTesters::ATP
+  module Validators
+  end
+end

data/lib/origen_testers/atp/validators/duplicate_ids.rb

@@ -0,0 +1,32 @@
+module OrigenTesters::ATP
+  module Validators
+    class DuplicateIDs < Validator
+      def on_completion
+        if @duplicate_ids
+          @duplicate_ids.each do |id, nodes|
+            error "Test ID #{id} is defined more than once in flow #{flow.name}:"
+            nodes.each do |node|
+              error "  #{node.source}"
+            end
+          end
+          true
+        end
+      end
+
+      def on_id(node)
+        @existing_ids ||= {}
+        id = node.value
+        if @existing_ids[id]
+          @duplicate_ids ||= {}
+          if @duplicate_ids[id]
+            @duplicate_ids[id] << node
+          else
+            @duplicate_ids[id] = [@existing_ids[id], node]
+          end
+        else
+          @existing_ids[id] = node
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/atp/validators/flags.rb

@@ -0,0 +1,59 @@
+module OrigenTesters::ATP
+  module Validators
+    class Flags < Validator
+      def setup
+        @open_if_nodes = []
+        @open_unless_nodes = []
+        @conflicting = []
+      end
+
+      def on_completion
+        failed = false
+        unless @conflicting.empty?
+          error 'if_flag and unless_flag conditions cannot be nested and refer to the same flag unless it is declared as volatile'
+          error "The following conflicts were found in flow #{flow.name}:"
+          @conflicting.each do |a, b|
+            a_condition = a.to_a[1] ? 'if_job:    ' : 'unless_job:'
+            b_condition = b.to_a[1] ? 'if_job:    ' : 'unless_job:'
+            error "  #{a.type}(#{a.to_a[0]}) #{a.source}"
+            error "  #{b.type}(#{b.to_a[0]}) #{b.source}"
+            error ''
+          end
+          failed = true
+        end
+        failed
+      end
+
+      def on_flow(node)
+        extract_volatiles(node)
+        process_all(node.children)
+      end
+
+      def on_if_flag(node)
+        if volatile?(node.to_a[0])
+          process_all(node.children)
+        else
+          if n = @open_unless_nodes.find { |n| n.to_a[0] == node.to_a[0] }
+            @conflicting << [n, node]
+          end
+          @open_if_nodes << node
+          process_all(node.children)
+          @open_if_nodes.pop
+        end
+      end
+
+      def on_unless_flag(node)
+        if volatile?(node.to_a[0])
+          process_all(node.children)
+        else
+          if n = @open_if_nodes.find { |n| n.to_a[0] == node.to_a[0] }
+            @conflicting << [n, node]
+          end
+          @open_unless_nodes << node
+          process_all(node.children)
+          @open_unless_nodes.pop
+        end
+      end
+    end
+  end
+end