origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/basic_test_setups.rb

@@ -1,105 +1,105 @@
-module OrigenTesters
-  # Including this module in a class will create a basic test program interface that
-  # can generate programs for all ATE platforms supported by the Testers plugin.
-  #
-  # It provides a number of methods that can be called from a test program flow file
-  # to do basic things like a functional test.
-  #
-  # @example How to setup and use
-  #   # lib/myapp/program_interface.rb
-  #   module MyApp
-  #     class Interface
-  #       include OrigenTesters::BasicTestSetups
-  #     end
-  #   end
-  #
-  #   # program/prb1.rb
-  #   Flow.create interface: 'MyApp::Interface' do
-  #
-  #     functional :my_pattern_1, bin: 10
-  #     functional :my_pattern_2, bin: 11
-  #
-  #   end
-  module BasicTestSetups
-    include OrigenTesters::ProgramGenerators
-
-    # Execute a functional test
-    #
-    # @param [Symbol, String] name the name of the test.
-    # @param [Hash] options the options to customize the test.
-    # @option options [Integer] :bin The bin number
-    # @option options [Integer] :sbin The soft bin number
-    # @option options [String] :pattern The pattern name, if not specified the test
-    #   name will be used
-    # @option options [String] :pin_levels ('Lvl') The name of the pin levels
-    # @option options [String] :time_set ('Tim') The name of the time set
-    #
-    # @see http://origen.freescale.net/origen/latest/guides/program/flowapi/ The options associated with the flow control API are fully supported
-    #
-    # @example Customizing a test from the flow
-    #   functional :erase, pattern: 'erase_all_nosrc', sbin: 150
-    #
-    # @example Applying global customization from the interface
-    #   include OrigenTesters::BasicTestSetups
-    #
-    #   def functional(name, options = {})
-    #     # Apply custom defaults before calling
-    #     options = {
-    #       bin: 3,
-    #       levels: 'nvm',
-    #     }.merge(options)
-    #     # Now call the generator
-    #     super
-    #   end
-    #
-    # @return [Hash] all generated components of the test will be returned. The key
-    #   naming will depend on what platform the test has been generated for, but for
-    #   example this will contain :flow_line, :test_instance and :patset objects in
-    #   the case of an IG-XL-based platform.
-    #
-    # @example Adding a custom interpose function for J750
-    #   include OrigenTesters::BasicTestSetups
-    #
-    #   # Override the default J750 test instance to add an interpose function
-    #   def functional(name, options = {})
-    #     components = super
-    #     if tester.j750?
-    #       components[:test_instance].post_test_func = 'delayedBinning'
-    #     end
-    #   end
-    def functional(name, options = {})
-      options = {
-        pin_levels: 'Lvl',
-        time_set:   'Tim'
-      }.merge(options)
-      pattern = extract_pattern(name, options)
-      if tester.j750? || tester.j750_hpt? || tester.ultraflex?
-        ins = test_instances.functional(name, options)
-        pname = "#{pattern}_pset"
-        pset = patsets.add(pname, [{ pattern: "#{pattern}.PAT" }])
-        ins.pattern = pname
-        line = flow.test(ins, options)
-        { test_instance: ins, flow_line: line, patset: pset }
-      elsif tester.v93k?
-        tm = test_methods.ac_tml.ac_test.functional_test
-        ts = test_suites.run(name, options)
-        ts.test_method = tm
-        ts.pattern = pattern
-        node = flow.test(ts, options)
-        { test_method: tm, test_suite: ts, node: node }
-      else
-        fail "Unsupported tester: #{tester.class}"
-      end
-    end
-
-    # Extract the pattern name from the given options, falling back to the given
-    # test name if a :pattern option is not present.
-    #
-    # It will also strip any extension if one is present.
-    def extract_pattern(name, options = {})
-      p = options[:pattern] || name
-      p = p.to_s.sub(/\..*$/, '')
-      p
-    end
-  end
-end
+module OrigenTesters
+  # Including this module in a class will create a basic test program interface that
+  # can generate programs for all ATE platforms supported by the Testers plugin.
+  #
+  # It provides a number of methods that can be called from a test program flow file
+  # to do basic things like a functional test.
+  #
+  # @example How to setup and use
+  #   # lib/myapp/program_interface.rb
+  #   module MyApp
+  #     class Interface
+  #       include OrigenTesters::BasicTestSetups
+  #     end
+  #   end
+  #
+  #   # program/prb1.rb
+  #   Flow.create interface: 'MyApp::Interface' do
+  #
+  #     functional :my_pattern_1, bin: 10
+  #     functional :my_pattern_2, bin: 11
+  #
+  #   end
+  module BasicTestSetups
+    include OrigenTesters::ProgramGenerators
+
+    # Execute a functional test
+    #
+    # @param [Symbol, String] name the name of the test.
+    # @param [Hash] options the options to customize the test.
+    # @option options [Integer] :bin The bin number
+    # @option options [Integer] :sbin The soft bin number
+    # @option options [String] :pattern The pattern name, if not specified the test
+    #   name will be used
+    # @option options [String] :pin_levels ('Lvl') The name of the pin levels
+    # @option options [String] :time_set ('Tim') The name of the time set
+    #
+    # @see http://origen.freescale.net/origen/latest/guides/program/flowapi/ The options associated with the flow control API are fully supported
+    #
+    # @example Customizing a test from the flow
+    #   functional :erase, pattern: 'erase_all_nosrc', sbin: 150
+    #
+    # @example Applying global customization from the interface
+    #   include OrigenTesters::BasicTestSetups
+    #
+    #   def functional(name, options = {})
+    #     # Apply custom defaults before calling
+    #     options = {
+    #       bin: 3,
+    #       levels: 'nvm',
+    #     }.merge(options)
+    #     # Now call the generator
+    #     super
+    #   end
+    #
+    # @return [Hash] all generated components of the test will be returned. The key
+    #   naming will depend on what platform the test has been generated for, but for
+    #   example this will contain :flow_line, :test_instance and :patset objects in
+    #   the case of an IG-XL-based platform.
+    #
+    # @example Adding a custom interpose function for J750
+    #   include OrigenTesters::BasicTestSetups
+    #
+    #   # Override the default J750 test instance to add an interpose function
+    #   def functional(name, options = {})
+    #     components = super
+    #     if tester.j750?
+    #       components[:test_instance].post_test_func = 'delayedBinning'
+    #     end
+    #   end
+    def functional(name, options = {})
+      options = {
+        pin_levels: 'Lvl',
+        time_set:   'Tim'
+      }.merge(options)
+      pattern = extract_pattern(name, options)
+      if tester.j750? || tester.j750_hpt? || tester.ultraflex?
+        ins = test_instances.functional(name, options)
+        pname = "#{pattern}_pset"
+        pset = patsets.add(pname, [{ pattern: "#{pattern}.PAT" }])
+        ins.pattern = pname
+        line = flow.test(ins, options)
+        { test_instance: ins, flow_line: line, patset: pset }
+      elsif tester.v93k?
+        tm = test_methods.ac_tml.ac_test.functional_test
+        ts = test_suites.run(name, options)
+        ts.test_method = tm
+        ts.pattern = pattern
+        node = flow.test(ts, options)
+        { test_method: tm, test_suite: ts, node: node }
+      else
+        fail "Unsupported tester: #{tester.class}"
+      end
+    end
+
+    # Extract the pattern name from the given options, falling back to the given
+    # test name if a :pattern option is not present.
+    #
+    # It will also strip any extension if one is present.
+    def extract_pattern(name, options = {})
+      p = options[:pattern] || name
+      p = p.to_s.sub(/\..*$/, '')
+      p
+    end
+  end
+end

data/lib/origen_testers/callback_handlers.rb

@@ -1,59 +1,59 @@
-module OrigenTesters
-  class CallbackHandlers
-    include Origen::PersistentCallbacks
-
-    # Snoop the pattern path that was just created and then compile it
-    # if the compiler was passed on the command line
-    def pattern_generated(path_to_generated_pattern)
-      current_compiler = select_compiler
-      run_compiler(current_compiler, path_to_generated_pattern)
-    end
-
-    # Listen for a pattern with .atp or .atp.gz extension.  If found then compile the fileand kill the 'origen g' command
-    def before_pattern_lookup(requested_pattern)
-      path = Pathname.new(requested_pattern)
-      patname = path.basename
-      dir = path.dirname
-      if patname.to_s.match(/.atp/)
-        if patname.extname == '.atp' || patname.extname == '.gz'
-          # Found a .atp or .atp.gz file so we should compile it
-          matches = Dir.glob("#{Origen.root}/**/#{patname}")
-          fail "Found multiple locations for #{patname}, exiting...\n\t#{matches}" if matches.size > 1
-          pattern = matches.first.to_s
-          current_compiler = select_compiler
-          run_compiler(current_compiler, pattern)
-          $compile = true
-        end
-        # Return false so the Origen generate command stops
-        return false
-      end
-      true
-    end
-
-    private
-
-    def select_compiler
-      current_compiler = nil
-      if $compiler == :use_app_default
-        current_compiler = $dut.compiler
-        fail "DUT compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
-      elsif $compiler.is_a? Symbol
-        current_compiler = $compiler
-        fail "Command line compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
-      end
-      current_compiler
-    end
-
-    def run_compiler(current_compiler, pattern)
-      unless current_compiler.nil?
-        debug "Compiling pattern #{pattern} with compiler '#{current_compiler}'..."
-        $dut.pattern_compilers[current_compiler].find_jobs(pattern)
-        $dut.pattern_compilers[current_compiler].run
-      end
-    end
-  end
-
-  # Instantiate an instance of this class immediately when this file is required, this object will
-  # then listen for the remainder of the Origen thread
-  CallbackHandlers.new
-end
+module OrigenTesters
+  class CallbackHandlers
+    include Origen::PersistentCallbacks
+
+    # Snoop the pattern path that was just created and then compile it
+    # if the compiler was passed on the command line
+    def pattern_generated(path_to_generated_pattern)
+      current_compiler = select_compiler
+      run_compiler(current_compiler, path_to_generated_pattern)
+    end
+
+    # Listen for a pattern with .atp or .atp.gz extension.  If found then compile the fileand kill the 'origen g' command
+    def before_pattern_lookup(requested_pattern)
+      path = Pathname.new(requested_pattern)
+      patname = path.basename
+      dir = path.dirname
+      if patname.to_s.match(/.atp/)
+        if patname.extname == '.atp' || patname.extname == '.gz'
+          # Found a .atp or .atp.gz file so we should compile it
+          matches = Dir.glob("#{Origen.root}/**/#{patname}")
+          fail "Found multiple locations for #{patname}, exiting...\n\t#{matches}" if matches.size > 1
+          pattern = matches.first.to_s
+          current_compiler = select_compiler
+          run_compiler(current_compiler, pattern)
+          $compile = true
+        end
+        # Return false so the Origen generate command stops
+        return false
+      end
+      true
+    end
+
+    private
+
+    def select_compiler
+      current_compiler = nil
+      if $compiler == :use_app_default
+        current_compiler = $dut.compiler
+        fail "DUT compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
+      elsif $compiler.is_a? Symbol
+        current_compiler = $compiler
+        fail "Command line compiler '#{current_compiler}' is not instantiated" if $dut.pattern_compilers[current_compiler].nil?
+      end
+      current_compiler
+    end
+
+    def run_compiler(current_compiler, pattern)
+      unless current_compiler.nil?
+        debug "Compiling pattern #{pattern} with compiler '#{current_compiler}'..."
+        $dut.pattern_compilers[current_compiler].find_jobs(pattern)
+        $dut.pattern_compilers[current_compiler].run
+      end
+    end
+  end
+
+  # Instantiate an instance of this class immediately when this file is required, this object will
+  # then listen for the remainder of the Origen thread
+  CallbackHandlers.new
+end

data/lib/origen_testers/command_based_tester.rb

@@ -1,45 +1,45 @@
-
-module OrigenTesters
-  # A base class that can be used to model command-based, rather than
-  # vector-based testers.
-  class CommandBasedTester
-    include VectorBasedTester
-
-    def initialize
-      @vector_based = false
-    end
-
-    # Write a string directly to the output file without being processed
-    # or modified in any way
-    def direct_write(str)
-      microcode str
-    end
-    alias_method :dw, :direct_write
-
-    # Concept of a cycle not supported, print out an error to the output
-    # file to alert the user that execution has hit code that is not
-    # compatible with a command based tester.
-    def cycle(*_args)
-      microcode '*** Cycle called ***'
-    end
-
-    # Concept of a subroutine not supported, print out an error to the output
-    # file to alert the user that execution has hit code that is not
-    # compatible with a command based tester.
-    def call_subroutine(sub)
-      microcode "Call_subroutine called to #{sub}"
-    end
-
-    def format_vector(vec)
-      vec.microcode
-    end
-
-    # Loop the content embedded in the supplied block
-    def loop(_name = nil, number_of_loops)
-      number_of_loops.times do
-        yield
-      end
-    end
-    alias_method :loop_vector, :loop
-  end
-end
+
+module OrigenTesters
+  # A base class that can be used to model command-based, rather than
+  # vector-based testers.
+  class CommandBasedTester
+    include VectorBasedTester
+
+    def initialize
+      @vector_based = false
+    end
+
+    # Write a string directly to the output file without being processed
+    # or modified in any way
+    def direct_write(str)
+      microcode str
+    end
+    alias_method :dw, :direct_write
+
+    # Concept of a cycle not supported, print out an error to the output
+    # file to alert the user that execution has hit code that is not
+    # compatible with a command based tester.
+    def cycle(*_args)
+      microcode '*** Cycle called ***'
+    end
+
+    # Concept of a subroutine not supported, print out an error to the output
+    # file to alert the user that execution has hit code that is not
+    # compatible with a command based tester.
+    def call_subroutine(sub)
+      microcode "Call_subroutine called to #{sub}"
+    end
+
+    def format_vector(vec)
+      vec.microcode
+    end
+
+    # Loop the content embedded in the supplied block
+    def loop(_name = nil, number_of_loops)
+      number_of_loops.times do
+        yield
+      end
+    end
+    alias_method :loop_vector, :loop
+  end
+end

data/lib/origen_testers/flow.rb

@@ -1,382 +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, clean_options(options))
-    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 (unless overridden by the ATE specific flow class)
-    def at_run_start
-      @@program = nil
-    end
-
-    # @api private
-    # This fires between flows (unless overridden by the ATE specific flow class)
-    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
+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, clean_options(options))
+    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 (unless overridden by the ATE specific flow class)
+    def at_run_start
+      @@program = nil
+    end
+
+    # @api private
+    # This fires between flows (unless overridden by the ATE specific flow class)
+    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