origen_testers 0.4.0

data/lib/origen_testers/basic_test_setups.rb

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

data/lib/origen_testers/callback_handlers.rb

@@ -0,0 +1,58 @@
+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
+    # 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
+
+    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
+end

data/lib/origen_testers/generator.rb

@@ -0,0 +1,279 @@
+require 'active_support/concern'
+require 'erb'
+require 'yaml'
+
+module OrigenTesters
+  # This module should be included in all test program component generators and provides the required
+  # integration with the Flow.create and Resources.create methods
+  module Generator
+    autoload :Placeholder,   'origen_testers/generator/placeholder'
+    autoload :IdentityMap,   'origen_testers/generator/identity_map'
+    autoload :FlowControlAPI, 'origen_testers/generator/flow_control_api'
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Origen::Generator::Comparator
+    end
+
+    # The program source files are executed by eval to allow the tester to filter the
+    # source contents before executing. For examples the doc tester replaces all comments
+    # with a method call containing each comment so that they can be captured.
+    def self.execute_source(file)
+      if Origen.interface.respond_to?(:filter_source)
+        File.open(file) do |f|
+          src = f.read
+          src = Origen.interface.filter_source(src)
+          eval(src, global_binding)
+        end
+      else
+        load file
+      end
+    end
+
+    # When called on a generator no output files will be created from it
+    def inhibit_output
+      @inhibit_output = true
+    end
+
+    # Returns true if the output files from this generator will be inhibited
+    def output_inhibited?
+      @inhibit_output
+    end
+
+    # Expands and inserts all render statements that have been encountered
+    def close(options = {})
+      Origen.profile "closing #{filename}" do
+        base_collection = collection
+        base_collection.each_with_index do |item, i|
+          if item.is_a? Placeholder
+            if item.type == :render
+              txt = ''
+              Origen.file_handler.preserve_current_file do
+                Origen.file_handler.default_extension = file_extension
+                placeholder = compiler.render(item.file, item.options)
+                txt = compiler.insert(placeholder).chomp
+              end
+              base_collection[i] = txt
+            else
+              fail 'Unknown placeholder encountered!'
+            end
+          end
+        end
+        @collection = base_collection.flatten.compact
+        on_close(options)
+      end
+    end
+
+    def file_pipeline
+      @@file_pipeline ||= []
+    end
+
+    # Returns the directory of the current source file being generated
+    def current_dir
+      if file_pipeline.empty?
+        Origen.file_handler.base_directory
+      else
+        Pathname.new(file_pipeline.last).dirname
+      end
+    end
+
+    # Redefine this in the parent which includes this module if you want anything to
+    # occur after closing the generator (expanding all render/import statements) but
+    # before writing to a file.
+    def on_close(options = {})
+    end
+
+    # Redefine this in the parent which includes this module if you want anything to
+    # occur after all tests have been generated but before file writing starts.
+    def finalize(options = {})
+    end
+
+    def compiler
+      Origen.generator.compiler
+    end
+
+    def filename=(name)
+      @filename = name
+    end
+
+    def filename(options = {})
+      options = {
+        include_extension: true
+      }.merge(options)
+      name = (@filename || Origen.file_handler.current_file.basename('.rb')).to_s
+      if Origen.config.program_prefix
+        unless name =~ /^#{Origen.config.program_prefix}/i
+          name = "#{Origen.config.program_prefix}_#{name}"
+        end
+      end
+      f = Pathname.new(name).basename
+      ext = f.extname.empty? ? file_extension : f.extname
+      body = f.basename(".#{ext}").to_s
+      body.gsub!('_resources', '')
+      if defined? self.class::OUTPUT_POSTFIX
+        # Unless the postfix is already in the name
+        unless body =~ /#{self.class::OUTPUT_POSTFIX}$/i
+          body = "#{body}_#{self.class::OUTPUT_POSTFIX}"
+        end
+      end
+      ext = ".#{ext}" unless ext =~ /^\./
+      if options[:include_extension]
+        "#{body}#{ext}"
+      else
+        "#{body}"
+      end
+    end
+
+    def dont_diff=(val)
+      @dont_diff = val
+    end
+
+    # All generators must implement a collection method that returns an
+    # array containing the generated items
+    def collection
+      @collection ||= []
+    end
+
+    def collection=(array)
+      @collection = array
+    end
+
+    def file_extension
+      if defined? self.class::OUTPUT_EXTENSION
+        self.class::OUTPUT_EXTENSION
+      elsif defined? self.class::TEMPLATE
+        p = Pathname.new(self.class::TEMPLATE)
+        ext = p.basename('.erb').extname
+        ext.empty? ? 'txt' : ext
+      else
+        'txt'
+      end
+    end
+
+    def write_to_file(options = {})
+      c = caller[0]
+      unless output_inhibited?
+        if defined? self.class::TEMPLATE || Origen.tester.is_a?(Origen::Tester::Doc)
+          write_from_template(options)
+        else
+          fail "Don't know hot to write without a template!"
+        end
+        stats.completed_files += 1
+      end
+    end
+
+    def write_from_template(options = {})
+      options = {
+        quiet:     false,
+        skip_diff: false
+      }.merge(options)
+      unless output_inhibited?
+        # If this is not the first time we have written to the current output file
+        # then append to it, otherwise clear it and start from scratch.
+        # The use of a class variable to store the opened files means that it will be
+        # shared by all generators in this run.
+        @@opened_files ||= []
+        if @@opened_files.include?(output_file) && !Origen.tester.is_a?(Origen::Tester::Doc)
+          @append = true
+          Origen.file_handler.preserve_state do
+            File.open(output_file, 'a') do |out|
+              content = compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
+              out.puts content unless content.empty?
+            end
+          end
+          Origen.log.info "Appending... #{output_file.basename}" unless options[:quiet]
+        else
+          @append = false
+          Origen.file_handler.preserve_state do
+            if Origen.tester.is_a?(Origen::Tester::Doc)
+              if options[:return_model]
+                Origen::Tester::Doc.model.add_flow(filename(include_extension: false), to_yaml)
+              else
+                Origen.file_handler.open_for_write(output_file) do |f|
+                  f.puts YAML.dump(to_yaml(include_descriptions: false))
+                end
+              end
+            else
+              File.open(output_file, 'w') do |out|
+                out.puts compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
+              end
+            end
+          end
+          @@opened_files << output_file
+          Origen.log.info "Writing... #{output_file.basename}" unless options[:quiet]
+        end
+        if !@dont_diff && !options[:skip_diff] && !options[:quiet]
+          check_for_changes(output_file, reference_file,
+                            compile_job:  true,
+                            comment_char: Origen.app.tester.program_comment_char)
+        end
+      end
+    end
+
+    def output_file
+      if respond_to? :subdirectory
+        p = Pathname.new("#{Origen.file_handler.output_directory}/#{subdirectory}/#{filename}")
+        FileUtils.mkdir_p p.dirname.to_s unless p.dirname.exist?
+        p
+      else
+        Pathname.new("#{Origen.file_handler.output_directory}/#{filename}")
+      end
+    end
+
+    def reference_file
+      Pathname.new("#{Origen.file_handler.reference_directory}/#{filename}")
+    end
+
+    def import(file, options = {})
+      file = Pathname.new(file).absolute? ? file : "#{current_dir}/#{file}"
+      file = Origen.file_handler.clean_path_to_sub_program(file)
+      base_collection = collection
+      @collection = []
+      Origen.generator.option_pipeline << options
+      file_pipeline << file
+      ::OrigenTesters::Generator.execute_source(file)
+      file_pipeline.pop
+      base_collection << @collection
+      @collection = base_collection.flatten
+    end
+
+    def render(file, options = {})
+      if options.delete(:_inline)
+        super Origen.file_handler.clean_path_to_sub_template(file), options
+      else
+        collection << Placeholder.new(:render, file, options)
+      end
+    end
+
+    def stats
+      Origen.app.stats
+    end
+
+    def to_be_written?
+      true
+    end
+
+    def set_flow_description(desc)
+      Origen.interface.descriptions.add_for_flow(output_file, desc)
+    end
+
+    def identity_map # :nodoc:
+      Origen.interface.identity_map
+    end
+
+    def platform
+      Origen.interface.platform
+    end
+
+    module ClassMethods
+      def new(*args, &block) # :nodoc:
+        options = (args.last && args.last.is_a?(Hash)) ? args.last : {}
+        x = allocate
+        x.send(:initialize, *args, &block)
+        Origen.interface.sheet_generators << x unless options[:manually_register]
+        x
+      end
+    end
+  end
+end

data/lib/origen_testers/generator/flow_control_api.rb

@@ -0,0 +1,611 @@
+module OrigenTesters
+  module Generator
+    module FlowControlAPI
+      # Flow control methods related to flow context
+      FLOW_METHODS = [
+        # Methods in arrays are aliases, the primary name is the first one
+        [:if_enable, :if_enabled, :enable, :enabled],
+        [:unless_enable, :unless_enabled],
+        [:if_job, :if_jobs],
+        [:unless_job, :unless_jobs]
+      ]
+
+      # Flow control methods related to a relationship with another test
+      RELATION_METHODS = [
+        # Methods in arrays are aliases, the primary name is the first one
+        :if_ran,
+        :unless_ran,
+        [:if_failed, :unless_passed],
+        [:if_passed, :unless_failed],
+        [:if_any_passed, :unless_all_failed],
+        [:if_all_passed, :unless_any_failed],
+        [:if_any_failed, :unless_all_passed],
+        [:if_all_failed, :unless_any_passed]
+      ]
+
+      # Returns true if the test context generated from the supplied options + existing context
+      # wrappers is different from that which was applied to the previous test.
+      def context_changed?(options = {})
+        current_context[:hash_code] != summarize_context(options)[:hash_code]
+      end
+
+      # @api private
+      def save_context(options = {})
+        # If the test has requested to use the current context...
+        if options[:context] == :current
+          replace_context_with_current(options)
+        else
+          @current_context = summarize_context(options)
+          options.merge(@current_context[:context])
+        end
+      end
+
+      # Returns a hash representing the current context, that is the context that was applied
+      # to the last test.
+      #
+      # The hash contains two items:
+      #
+      # * :context contains a hash that summarises the flow control options that have been
+      #   used, for example it may contain something like: :if_enable => "data_collection"
+      # * :hash_code returns a hash-code for the values contained in the :context arrary. Any
+      #   two equivalent contexts will have the same :hash_code, therefore this can be used
+      #   to easily check the equivalence of any two contexts.
+      def current_context
+        @current_context ||= save_context
+      end
+
+      # @api private
+      #
+      # Removes any context options from the given options hash and merges in the current
+      # context
+      def replace_context_with_current(options)
+        options = options.merge({})
+        [FLOW_METHODS, RELATION_METHODS].flatten.each do |m|
+          options.delete(m)
+        end
+        options.merge(current_context[:context])
+      end
+
+      # Returns a hash like that returned by current_context based on the given set of options +
+      # existing context wrappers.
+      def summarize_context(options = {})
+        code = []
+        context = {}
+        (FLOW_METHODS + RELATION_METHODS).each do |m|
+          primary = m.is_a?(Array) ? m.first : m
+          val = false
+          [m].flatten.each do |m|
+            if options[m]
+              val = options[m]
+            elsif instance_variable_get("@#{m}_block")
+              val = instance_variable_get("@#{m}_block")
+            end
+          end
+          if val
+            code << primary
+            code << val
+            context[primary] = val
+          end
+        end
+        { hash_code: code.flatten.hash, context: context }
+      end
+
+      # All tests generated within the given block will be assigned the given enable word.
+      #
+      # If a test encountered within the block already has another enable word assigned to it then
+      # an error will be raised.
+      def if_enable(word, options = {})
+        @if_enable_block = word
+        yield word
+        @if_enable_block = nil
+      end
+      alias_method :if_enabled, :if_enable
+
+      # All tests generated will not run unless the given enable word is asserted.
+      def unless_enable(word, options = {})
+        @unless_enable_block = word unless options[:or]
+        yield word
+        @unless_enable_block = nil
+      end
+      alias_method :unless_enabled, :unless_enable
+
+      # All tests generated within the given block will be enabled only for the given jobs.
+      def if_job(*jobs)
+        jobs = jobs.flatten
+        @if_job_block = @if_job_block ? @if_job_block + jobs : jobs
+        yield
+        @if_job_block = nil
+      end
+      alias_method :if_jobs, :if_job
+
+      # All tests generated within the given block will be enabled only for the given jobs.
+      def unless_job(*jobs)
+        jobs = jobs.flatten
+        @unless_job_block = @unless_job_block ? @unless_job_block + jobs : jobs
+        yield
+        @unless_job_block = nil
+      end
+      alias_method :unless_jobs, :unless_job
+
+      # All tests generated within the given block will only run if the given test id has also
+      # run earlier in the flow
+      def if_ran(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if options.key?(:if) && !options[:if]
+        return if options.key?(:unless) && options[:unless]
+        if @if_ran_block
+          fail 'Sorry but nesting of if_ran is not currently supported!'
+        end
+        @if_ran_block = test_id
+        yield
+        @if_ran_block = nil
+      end
+
+      # All tests generated within the given block will only run if the given test id has not
+      # run earlier in the flow
+      def unless_ran(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if options.key?(:if) && !options[:if]
+        return if options.key?(:unless) && options[:unless]
+        if @unless_ran_block
+          fail 'Sorry but nesting of unless_ran is not currently supported!'
+        end
+        @unless_ran_block = test_id
+        yield
+        @unless_ran_block = nil
+      end
+
+      # All tests generated within the given block will only run if the given test id has
+      # failed earlier in the flow
+      def if_failed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if options.key?(:if) && !options[:if]
+        return if options.key?(:unless) && options[:unless]
+        if @if_failed_block
+          fail 'Sorry but nesting of if_failed is not currently supported!'
+        end
+        @if_failed_block = test_id
+        yield
+        @if_failed_block = nil
+      end
+      alias_method :unless_passed, :if_failed
+
+      # All tests generated within the given block will only run if the given test id has
+      # passed earlier in the flow
+      def if_passed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if options.key?(:if) && !options[:if]
+        return if options.key?(:unless) && options[:unless]
+        if @if_passed_block
+          fail 'Sorry but nesting of if_passed is not currently supported!'
+        end
+        @if_passed_block = test_id
+        yield
+        @if_passed_block = nil
+      end
+      alias_method :unless_failed, :if_passed
+
+      # All tests generated within the given block will only run if the given test id has
+      # passed ON ANY SITE earlier in the flow
+      def if_any_passed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if conditionally_deactivated?(options)
+        if @if_any_passed_block
+          fail 'Sorry but nesting of if_any_passed is not currently supported!'
+        end
+        @if_any_passed_block = test_id
+        yield
+        @if_any_passed_block = nil
+      end
+      alias_method :unless_all_failed, :if_any_passed
+
+      # All tests generated within the given block will only run if the given test id has
+      # passed ON ALL SITES earlier in the flow
+      def if_all_passed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if conditionally_deactivated?(options)
+        if @if_all_passed_block
+          fail 'Sorry but nesting of if_all_passed is not currently supported!'
+        end
+        @if_all_passed_block = test_id
+        yield
+        @if_all_passed_block = nil
+      end
+      alias_method :unless_any_failed, :if_all_passed
+
+      # All tests generated within the given block will only run if the given test id has
+      # failed ON ANY SITE earlier in the flow
+      def if_any_failed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if conditionally_deactivated?(options)
+        if @if_any_failed_block
+          fail 'Sorry but nesting of if_any_failed is not currently supported!'
+        end
+        @if_any_failed_block = test_id
+        yield
+        @if_any_failed_block = nil
+      end
+      alias_method :unless_all_passed, :if_any_failed
+
+      # All tests generated within the given block will only run if the given test id has
+      # failed ON ALL SITES earlier in the flow
+      def if_all_failed(test_id, options = {})
+        test_id = Origen.interface.filter_id(test_id, options)
+        return if conditionally_deactivated?(options)
+        if @if_all_failed_block
+          fail 'Sorry but nesting of if_all_failed is not currently supported!'
+        end
+        @if_all_failed_block = test_id
+        yield
+        @if_all_failed_block = nil
+      end
+      alias_method :unless_any_passed, :if_all_failed
+
+      def conditionally_deactivated?(options)
+        (options.key?(:if) && !options[:if]) ||
+          (options.key?(:unless) && options[:unless])
+      end
+
+      def find_by_id(id, options = {}) # :nodoc:
+        options = {
+          search_other_flows: true
+        }.merge(options)
+        # Look within the current flow for a match first
+        t = identity_map[id.to_sym]
+        return t if t
+        # If no match then look across other flow modules for a match
+        # This currently returns the first match, should it raise an error on multiple?
+        if options[:search_other_flows]
+          Origen.interface.flow_generators.any? do |flow|
+            t = flow.find_by_id(id, search_other_flows: false)
+          end
+        end
+        t
+      end
+
+      def identity_map # :nodoc:
+        @identity_map ||= {}
+      end
+
+      # If a class that includes this module has a finalize method it must
+      # call apply_relationships
+      def finalize(options = {}) # :nodoc:
+        apply_relationships
+        reset_globals
+      end
+
+      def apply_relationships # :nodoc:
+        if @relationships
+          @relationships.each do |rel|
+            t = find_by_id(rel[:target_id])
+            fail "Test not found with ID: #{rel[:target_id]}, referenced in flow: #{filename}" unless t
+            t.id = rel[:target_id]
+            confirm_valid_context(t, rel[:dependent])
+            case rel[:type]
+            # The first cases here contain J750 logic, these should be replaced
+            # with the call method style used for the later cases when time permits.
+            when :failed
+              if rel[:dependent].respond_to?(:run_if_failed)
+                rel[:dependent].run_if_failed(rel[:target_id])
+              else
+                t.continue_on_fail
+                flag = t.set_flag_on_fail
+                rel[:dependent].flag_true = flag
+              end
+            when :passed
+              if rel[:dependent].respond_to?(:run_if_passed)
+                rel[:dependent].run_if_passed(rel[:target_id])
+              else
+                t.continue_on_fail
+                flag = t.set_flag_on_pass
+                rel[:dependent].flag_true = flag
+              end
+            when :if_ran, :unless_ran
+              if rel[:type] == :if_ran
+                if rel[:dependent].respond_to?(:run_if_ran)
+                  rel[:dependent].run_if_ran(rel[:target_id])
+                else
+                  # t.continue_on_fail
+                  flag = t.set_flag_on_ran
+                  rel[:dependent].flag_true = flag
+                end
+              else
+                if rel[:dependent].respond_to?(:run_unless_ran)
+                  rel[:dependent].run_unless_ran(rel[:target_id])
+                else
+                  # t.continue_on_fail
+                  flag = t.set_flag_on_ran
+                  rel[:dependent].flag_clear = flag
+                end
+              end
+            when :any_passed
+              rel[:dependent].run_if_any_passed(t)
+            when :all_passed
+              rel[:dependent].run_if_all_passed(t)
+            when :any_failed
+              rel[:dependent].run_if_any_failed(t)
+            when :all_failed
+              rel[:dependent].run_if_all_failed(t)
+            else
+              fail 'Unknown relationship type!'
+            end
+          end
+          @relationships = nil
+        end
+      end
+
+      def confirm_valid_context(test, dependent) # :nodoc:
+        # TODO:  Add some validation checks here, for example make sure the dependent
+        #        executes in the same job(s) as the test, otherwise the dependent will
+        #        never be hit and will cause a validation error.
+      end
+
+      def record_id(test, options = {})
+        if options[:id]
+          @@existing_ids ||= []
+          if @@existing_ids.include?(options[:id].to_sym)
+            fail "The ID '#{test.id}' is not unique, it has already been assigned!"
+          else
+            @@existing_ids << options[:id].to_sym
+          end
+          identity_map[options[:id].to_sym] = test
+        end
+      end
+
+      # @api private
+      def at_run_start
+        @@existing_ids = nil
+        @@labels = nil
+      end
+      alias_method :reset_globals, :at_run_start
+
+      def replace_relationship_dependent(old_node, new_node)
+        @relationships.each do |rel|
+          rel[:dependent] = new_node if rel[:dependent] == old_node
+        end
+      end
+
+      # As generation of render and imports is not linear its possible that the test being
+      # referenced does not exist in the collection yet.
+      # Therefore the required relationship will be recorded for now and applied later upon
+      # closing the generator at which point the complete final collection will be available.
+      #
+      # Note - as of v2.0.1.dev64 the above is no longer true - imports are generated linearly.
+      # Therefore parent test should always already exist and it is possible that this relationship
+      # handling could be cleaned up considerably.
+      #
+      # However we should keep it around for now as it may come in useful when other tester
+      # platforms are supported in the future.
+      def track_relationships(test_options = {}) # :nodoc:
+        [:id, RELATION_METHODS].flatten.each do |id|
+          if test_options[id]
+            test_options[id] = Origen.interface.filter_id(test_options[id], test_options)
+          end
+        end
+        options = extract_relation_options!(test_options)
+        current_test = yield test_options
+        record_id(current_test, test_options)
+        @relationships ||= []
+        target_id = options[:if_failed] || options[:unless_passed] || @if_failed_block
+        if target_id
+          @relationships << {
+            type:      :failed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options[:if_passed] || options[:unless_failed] || @if_passed_block
+        if target_id
+          @relationships << {
+            type:      :passed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options.delete(:if_ran) || @if_ran_block
+        if target_id
+          @relationships << {
+            type:      :if_ran,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options.delete(:unless_ran) || @unless_ran_block
+        if target_id
+          @relationships << {
+            type:      :unless_ran,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options[:if_any_passed] || options[:unless_all_failed] || @if_any_passed_block
+        if target_id
+          @relationships << {
+            type:      :any_passed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options[:if_all_passed] || options[:unless_any_failed] || @if_all_passed_block
+        if target_id
+          @relationships << {
+            type:      :all_passed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options[:if_any_failed] || options[:unless_all_passed] || @if_any_failed_block
+        if target_id
+          @relationships << {
+            type:      :any_failed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        target_id = options[:if_all_failed] || options[:unless_any_passed] || @if_all_failed_block
+        if target_id
+          @relationships << {
+            type:      :all_failed,
+            target_id: target_id,
+            dependent: current_test
+          }
+        end
+        if test_options[:context] == :current  # Context has already been applied
+          current_test
+        else
+          apply_current_context!(current_test)
+        end
+      end
+
+      def apply_current_context!(line) # :nodoc:
+        if @if_enable_block
+          if line.enable && line.enable != @if_enable_block
+            fail "Cannot apply enable word '#{@if_enable_block}' to '#{line.parameter}', it already has '#{line.enable}'"
+          else
+            line.enable = @if_enable_block
+          end
+        end
+        if @unless_enable_block
+          line.unless_enable = @unless_enable_block
+        end
+        line.if_job = @if_job_block if @if_job_block
+        line.unless_job = @unless_job_block if @unless_job_block
+        line
+      end
+
+      # Removes any flow relationship options from given hash and returns them
+      # in a new hash
+      def extract_relation_options!(options) # :nodoc:
+        opts = {}
+        RELATION_METHODS.flatten.each do |o|
+          opts[o] = options.delete(o)
+        end
+        opts
+      end
+
+      def extract_flow_control_options!(options)
+        opts = {}
+        FLOW_METHODS.flatten.each do |o|
+          if options.key?(o)
+            opts[o] = options.delete(o)
+          end
+        end
+        opts
+      end
+
+      def generate_unique_label(id = nil)
+        id = 'label' if !id || id == ''
+        label = "#{Origen.interface.app_identifier}_#{id}"
+        label.gsub!(' ', '_')
+        label.upcase!
+        @@labels ||= {}
+        @@labels[Origen.tester.class] ||= {}
+        @@labels[Origen.tester.class][label] ||= 0
+        @@labels[Origen.tester.class][label] += 1
+        "#{label}_#{@@labels[Origen.tester.class][label]}"
+      end
+
+      module Interface
+        # Implement this method in your application interface if you want to
+        # sanitize all ID references used in the flow control API.
+        # For example you could use this to append a flow name prefix to every
+        # ID reference within a flow which can help with ID duplication problems
+        # when flow snippets are re-used.
+        def filter_id(id, options = {})
+          id
+        end
+
+        def extract_relation_options!(*args)
+          flow.extract_relation_options!(*args)
+        end
+
+        def extract_flow_control_options!(*args)
+          flow.extract_flow_control_options!(*args)
+        end
+
+        # Alias for flow#if_enable
+        def if_enable(*args, &block)
+          flow.if_enable(*args, &block)
+        end
+        alias_method :if_enabled, :if_enable
+
+        # Alias for flow#unless_enable
+        def unless_enable(*args, &block)
+          flow.unless_enable(*args, &block)
+        end
+        alias_method :unless_enabled, :unless_enable
+
+        # Alias for flow#if_job
+        def if_job(*args, &block)
+          flow.if_job(*args, &block)
+        end
+
+        # Alias for flow#unless_job
+        def unless_job(*args, &block)
+          flow.unless_job(*args, &block)
+        end
+
+        # Alias for flow#unless_ran
+        def unless_ran(*args, &block)
+          flow.unless_ran(*args, &block)
+        end
+
+        # Alias for flow#if_ran
+        def if_ran(*args, &block)
+          flow.if_ran(*args, &block)
+        end
+
+        # Alias for flow#if_failed
+        def if_failed(*args, &block)
+          flow.if_failed(*args, &block)
+        end
+        alias_method :unless_passed, :if_failed
+
+        # Alias for flow#if_passed
+        def if_passed(*args, &block)
+          flow.if_passed(*args, &block)
+        end
+        alias_method :unless_failed, :if_passed
+
+        # Alias for flow#if_any_passed
+        def if_any_passed(*args, &block)
+          flow.if_any_passed(*args, &block)
+        end
+        alias_method :unless_all_failed, :if_any_passed
+
+        # Alias for flow#if_all_passed
+        def if_all_passed(*args, &block)
+          flow.if_all_passed(*args, &block)
+        end
+        alias_method :unless_any_failed, :if_all_passed
+
+        # Alias for flow#if_any_failed
+        def if_any_failed(*args, &block)
+          flow.if_any_failed(*args, &block)
+        end
+        alias_method :unless_all_passed, :if_any_failed
+
+        # Alias for flow#if_all_failed
+        def if_all_failed(*args, &block)
+          flow.if_all_failed(*args, &block)
+        end
+        alias_method :unless_any_passed, :if_all_failed
+
+        # Alias for flow#skip
+        def skip(*args, &block)
+          flow.skip(*args, &block)
+        end
+
+        # Alias for flow#current_context
+        def current_context(*args, &block)
+          flow.current_context(*args, &block)
+        end
+
+        # Alias for flow#context_changed?
+        def context_changed?(*args, &block)
+          flow.context_changed?(*args, &block)
+        end
+      end
+    end
+  end
+end