origen_testers 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a52647531345037e756ea1413fad9e55af38d5e
-  data.tar.gz: d2f632b5f8fc173a407a367e44f76f11bff71a9a
+  metadata.gz: e3d1a042fabeba96ae6e0c3e49a4448412f5e086
+  data.tar.gz: 8afd5f06c2fdded1afb0158c10e416d39e5c1d17
 SHA512:
-  metadata.gz: 37665c194131cff9784e4eb867750aa1d44dc1f50fe899348696f6872ed5f3d8d096ca1b636ade17aaaf5a268af3be0380e4be7882b51d915c9123982581e4fe
-  data.tar.gz: 74af03290ef3057d9347294c75a028ff18d3784f9b1d9585e7c9ab5de6d93e6d508aa51b7e5a799ea5183aaf8d7d82bcfbd3eaf67ef12638fb68fc8a2ee8f747
+  metadata.gz: 854aaa61e835e0ef0753cac4572a0851cc036273fd7f9e7c7c246b6cf3ac3862a1c08f2416fd03b5d561589e112d39ce47e52d19898c559e5cef141bb648f1cb
+  data.tar.gz: 7087d2fcb8ffc06b0680bab06b20c7daa45329894573895630758377792f5686aaa30d5c542afab5a4f7ec4df104b37a2d2f491f4d73f266497e8c5c8b7661d1

data/config/shared_commands.rb

@@ -41,7 +41,13 @@ case @command
    require "#{Origen.root!}/lib/commands/build"
     exit 0
 
+  when "testers:run"
+   require "#{Origen.root!}/lib/commands/run"
+    exit 0
+
+
   else
   @plugin_commands << " testers:build   Build a test program from a collection of sub-programs"
+  @plugin_commands << " testers:run     Run the last test program generated for the current target"
 
 end 

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 5
-  BUGFIX = 7
+  MINOR = 6
+  BUGFIX = 0
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/commands/run.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+require 'pathname'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Run (execute a flow) of the last test program generated for the given target.
+
+Usage: origen testers:run FLOW [options]
+  EOT
+  opts.on('--enable FLAG,FLAG', Array, 'Comma-separated list of flow flags to enable') { |flags| options[:flow_flags] = flags }
+  opts.on('--job NAME', String, 'Job name to enable') { |job| options[:job] = job }
+  opts.on('--fail ID,ID', Array, 'Comma-separated list of test IDs to fail') { |ids| options[:failed_test_ids] = ids }
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+# Origen.app.load_target!
+
+program =  OrigenTesters.program
+
+unless program
+  puts 'Sorry, but there is no program model available for the current target, generate the program then retry'
+  exit 1
+end
+
+flow = ARGV.first
+
+unless flow
+  puts 'You must supply the name of the flow to execute, the current program has these flows'
+  puts OrigenTesters.program.flows.keys
+  exit 1
+end
+
+OrigenTesters.program.flows[flow.to_sym].run(options)

data/lib/origen_testers.rb

@@ -1,9 +1,13 @@
 require 'origen'
 require 'active_support/concern'
 require 'require_all'
+require 'atp'
+require 'origen_testers/origen_ext/generator/flow'
+require 'origen_testers/origen_ext/generator/resources'
+require 'origen_testers/origen_ext/application/runner'
+require 'origen_testers/origen_ext/generator'
 
 module OrigenTesters
-  autoload :Doc,                'origen_testers/doc'
   autoload :CommandBasedTester, 'origen_testers/command_based_tester'
   autoload :VectorBasedTester,  'origen_testers/vector_based_tester'
   autoload :Vector,             'origen_testers/vector'
@@ -13,8 +17,22 @@ module OrigenTesters
   autoload :Parser,             'origen_testers/parser'
   autoload :BasicTestSetups,    'origen_testers/basic_test_setups'
   autoload :ProgramGenerators,  'origen_testers/program_generators'
+  autoload :Flow,               'origen_testers/flow'
+  autoload :NoInterface,        'origen_testers/no_interface'
 
   # not yet autoload :Time,     'origen_testers/time'
+
+  # The documentation tester model has been removed, but this keeps some
+  # legacy code working e.g. $tester.is_a?(OrigenTesters::Doc)
+  class Doc
+  end
+
+  def self.program
+    f = "#{Flow::PROGRAM_MODELS_DIR}/#{Origen.target.name}"
+    if File.exist?(f)
+      ATP::Program.load(f)
+    end
+  end
 end
 
 require 'origen_testers/igxl_based_tester'

data/lib/origen_testers/flow.rb

@@ -0,0 +1,382 @@
+require 'digest/md5'
+module OrigenTesters
+  # Provides a common API to add tests to a flow that is supported by all testers.
+  #
+  # This builds up a flow model using the Abstract Test Program (ATP) gem, which
+  # now deals with implementing the flow control API.
+  #
+  # Individual tester drivers in this plugin are then responsible at the end to
+  # render the abstract flow to their specific format and conventions.
+  module Flow
+    include OrigenTesters::Generator
+
+    PROGRAM_MODELS_DIR = "#{Origen.root}/tmp/program_models"
+
+    def self.callstack
+      @callstack ||= []
+    end
+
+    def self.comment_stack
+      @comment_stack ||= []
+    end
+
+    def self.flow_comments
+      @flow_comments
+    end
+
+    def self.flow_comments=(val)
+      @flow_comments = val
+    end
+
+    def self.unique_ids
+      @unique_ids
+    end
+
+    def self.unique_ids=(val)
+      @unique_ids = val
+    end
+
+    def lines
+      @lines
+    end
+
+    # Returns the abstract test program model, this is shared by all
+    # flow created together in a generation run
+    def program
+      @@program ||= ATP::Program.new
+    end
+
+    def save_program
+      FileUtils.mkdir_p(PROGRAM_MODELS_DIR) unless File.exist?(PROGRAM_MODELS_DIR)
+      program.save("#{PROGRAM_MODELS_DIR}/#{Origen.target.name}")
+    end
+
+    def model
+      if Origen.interface.resources_mode?
+        @throwaway ||= ATP::Flow.new(self)
+      else
+        @model ||= begin
+          f = program.flow(id, description: OrigenTesters::Flow.flow_comments)
+          @sig = flow_sig(id)
+          f.id = @sig if OrigenTesters::Flow.unique_ids
+          f
+        end
+      end
+    end
+
+    def enable(var, options = {})
+      add_meta!(options)
+      model.enable(var, clean_options(options))
+    end
+
+    def disable(var, options = {})
+      add_meta!(options)
+      model.disable(var, clean_options(options))
+    end
+
+    def bin(number, options = {})
+      options[:bin_description] ||= options.delete(:description)
+      if number.is_a?(Hash)
+        fail 'The bin number must be passed as the first argument'
+      end
+      add_meta!(options)
+      options[:type] ||= :fail
+      model.bin(number, clean_options(options))
+    end
+
+    def pass(number, options = {})
+      if number.is_a?(Hash)
+        fail 'The bin number must be passed as the first argument'
+      end
+      options[:type] = :pass
+      bin(number, clean_options(options))
+    end
+
+    def test(instance, options = {})
+      add_meta_and_description!(options)
+      model.test(instance, clean_options(options))
+    end
+
+    def render(file, options = {})
+      add_meta!(options)
+      begin
+        text = super
+      rescue
+        text = file
+      end
+      model.render(text)
+    end
+
+    def cz(instance, cz_setup, options = {})
+      add_meta_and_description!(options)
+      model.cz(instance, cz_setup, clean_options(options))
+    end
+    alias_method :characterize, :cz
+
+    def log(message, options = {})
+      add_meta!(options)
+      model.log(message, clean_options(options))
+    end
+    alias_method :logprint, :log
+
+    def group(name, options = {})
+      add_meta!(options)
+      model.group(name, clean_options(options)) do
+        yield
+      end
+    end
+
+    def nop(options = {})
+    end
+
+    # @api private
+    # This fires between target loads
+    def at_run_start
+      @@program = nil
+    end
+
+    # @api private
+    # This fires between flows
+    def at_flow_start
+      @labels = {}
+    end
+
+    def if_job(*jobs)
+      options = jobs.last.is_a?(Hash) ? jobs.pop : {}
+      options[:if_job] = jobs.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+    alias_method :if_jobs, :if_job
+
+    def unless_job(*jobs)
+      options = jobs.last.is_a?(Hash) ? jobs.pop : {}
+      options[:unless_job] = jobs.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+    alias_method :unless_jobs, :unless_job
+
+    def if_enable(word, options = {})
+      if options[:or]
+        yield
+      else
+        options = { enable: word }
+        add_meta!(options)
+        model.with_conditions(options) do
+          yield
+        end
+      end
+    end
+    alias_method :if_enabled, :if_enable
+
+    def unless_enable(word, options = {})
+      if options[:or]
+        yield
+      else
+        options = { unless_enable: word }
+        add_meta!(options)
+        model.with_conditions(options) do
+          yield
+        end
+      end
+    end
+    alias_method :unless_enabled, :unless_enable
+
+    def if_passed(test_id, options = {})
+      if test_id.is_a?(Array)
+        fail 'if_passed only accepts one ID, use if_any_passed or if_all_passed for multiple IDs'
+      end
+      options = { if_passed: test_id }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+    alias_method :unless_failed, :if_passed
+
+    def if_failed(test_id, options = {})
+      if test_id.is_a?(Array)
+        fail 'if_failed only accepts one ID, use if_any_failed or if_all_failed for multiple IDs'
+      end
+      options = { if_failed: test_id }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+    alias_method :unless_passed, :if_failed
+
+    def if_ran(test_id, options = {})
+      options = { if_ran: test_id }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def unless_ran(test_id, options = {})
+      options = { unless_ran: test_id }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def if_any_failed(*ids)
+      options = ids.last.is_a?(Hash) ? ids.pop : {}
+      options[:if_any_failed] = ids.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def if_all_failed(*ids)
+      options = ids.last.is_a?(Hash) ? ids.pop : {}
+      options[:if_all_failed] = ids.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def if_any_passed(*ids)
+      options = ids.last.is_a?(Hash) ? ids.pop : {}
+      options[:if_any_passed] = ids.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def if_all_passed(*ids)
+      options = ids.last.is_a?(Hash) ? ids.pop : {}
+      options[:if_all_passed] = ids.flatten
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def if_flag(flag, options = {})
+      options = { if_flag: flag }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    def unless_flag(flag, options = {})
+      options = { unless_flag: flag }
+      add_meta!(options)
+      model.with_conditions(options) do
+        yield
+      end
+    end
+
+    # @api private
+    def is_the_flow?
+      true
+    end
+
+    # Returns true if the test context generated from the supplied options + existing condition
+    # wrappers is different from that which was applied to the previous test.
+    def context_changed?(options)
+      options = clean_options(options)
+      model.context_changed?(options)
+    end
+
+    def generate_unique_label(name = nil)
+      name = 'label' if !name || name == ''
+      name.gsub!(' ', '_')
+      name.upcase!
+      @labels ||= {}
+      @labels[name] ||= 0
+      @labels[name] += 1
+      "#{name}_#{@labels[name]}_#{sig}"
+    end
+
+    # Returns a unique signature that has been generated for the current flow, this can be appended
+    # to named references to avoid naming collisions with any other flow
+    def sig
+      @sig
+    end
+    alias_method :signature, :sig
+
+    private
+
+    # Make a unique signature for the flow based on the flow name and the name of
+    # the plugin/app that owns it
+    def flow_sig(id)
+      s = Digest::MD5.new
+      # These guarantee uniqueness within a plugin/app
+      s << id.to_s
+      s << filename
+      # This will add the required plugin uniqueness in the case of a top-level app
+      # that has multiple plugins that can generate test program snippets
+      if file = OrigenTesters::Flow.callstack.first
+        s << get_app(file).name.to_s
+      end
+      s.to_s[0..6].upcase
+    end
+
+    def get_app(file)
+      path = Pathname.new(file).dirname
+      until File.exist?(File.join(path, 'config/application.rb')) || path.root?
+        path = path.parent
+      end
+      if path.root?
+        fail 'Something went wrong resoving the app root in OrigenTesters'
+      end
+      Origen.find_app_by_root(path)
+    end
+
+    def add_meta!(options)
+      flow_file = OrigenTesters::Flow.callstack.last
+      called_from = caller.find { |l| l =~ /^#{flow_file}:.*/ }
+      if called_from
+        called_from = called_from.split(':')
+        options[:source_file] = called_from[0]
+        options[:source_line_number] = called_from[1].to_i
+      end
+    end
+
+    def add_meta_and_description!(options)
+      add_meta!(options)
+      # Can be useful if an app generates additional tests on the fly for a single test in the flow,
+      # e.g. a POR, in that case they will not want the description to be attached to the POR, but to
+      # the test that follows it
+      unless options[:inhibit_description_consumption]
+        comments = OrigenTesters::Flow.comment_stack.last
+        if options[:source_line_number]
+          while comments.first && comments.first.first < options[:source_line_number]
+            options[:description] ||= []
+            c = comments.shift
+            if c[0] + c[1].size == options[:source_line_number]
+              options[:description] += c[1]
+            end
+          end
+        end
+      end
+    end
+
+    def clean_options(options)
+      ATP::AST::Builder::CONDITION_KEYS.each do |key|
+        if v = options.delete(key)
+          options[:conditions] ||= {}
+          if options[:conditions][key]
+            fail "Multiple values assigned to flow condition #{key}"
+          else
+            options[:conditions][key] = v
+          end
+        end
+      end
+      options
+    end
+  end
+end