origen_testers 0.5.7 → 0.6.0

data/lib/origen_testers/doc/generator/test.rb

@@ -1,66 +0,0 @@
-module OrigenTesters
-  class Doc
-    module Generator
-      class Test
-        attr_accessor :name, :index, :version, :append_version, :attributes
-
-        def initialize(name, attrs = {})
-          attrs = {}.merge(attrs)  # Important to keep this to clone the original options
-          # so that the caller's copy if not affected by stripping
-          # out the flow/relation options
-          @attributes = {}
-          @append_version = true
-          self.name = name
-          Origen.interface.extract_relation_options!(attrs)
-          Origen.interface.extract_flow_control_options!(attrs)
-          attrs.each do |attribute, val|
-            @attributes[attribute] = val
-          end
-        end
-
-        def to_yaml(options = {})
-          {
-            'attributes' => attributes_to_yaml(options)
-          }
-        end
-
-        def attributes_to_yaml(_options = {})
-          a = {}
-          @attributes.each do |name, val|
-            a[name.to_s] = val if val
-          end
-          a['name'] = name
-          a
-        end
-
-        def method_missing(method, *args, &_block)
-          method = method.to_s
-          if method.gsub!('=', '')
-            @attributes[method] = args.first
-          else
-            @attributes[method]
-          end
-        end
-
-        def ==(other_test)
-          self.class == other_test.class &&
-            unversioned_name.to_s == other_test.unversioned_name.to_s &&
-            attributes.size == other_test.attributes.size &&
-            attributes.all? { |name, val| other_test.attributes[name] == val }
-        end
-
-        def name
-          if version && @append_version
-            "#{@name}_v#{version}"
-          else
-            @name.to_s
-          end
-        end
-
-        def unversioned_name
-          @name.to_s
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/generator/test_group.rb

@@ -1,64 +0,0 @@
-module OrigenTesters
-  class Doc
-    module Generator
-      class TestGroup
-        attr_accessor :name, :version, :append_version
-
-        include Enumerable
-
-        def initialize(name, _options = {})
-          @name = name
-          @store = []
-          @append_version = true
-        end
-
-        def name
-          if unversioned_name
-            if version && @append_version
-              "#{unversioned_name}_v#{version}"
-            else
-              unversioned_name.to_s
-            end
-          end
-        end
-
-        def to_yaml(options = {})
-          y = {}
-          y['group'] = @store.map { |t| t.to_yaml(options) }
-          y
-        end
-
-        def unversioned_name
-          if @name
-            if @name =~ /grp$/
-              @name
-            else
-              "#{@name}_grp"
-            end
-          end
-        end
-
-        def <<(instance)
-          @store << instance
-        end
-
-        def size
-          @store.size
-        end
-
-        def each
-          @store.each { |ins| yield ins }
-        end
-
-        def ==(other_instance_group)
-          self.class == other_instance_group.class &&
-            unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
-            size == other_instance_group.size &&
-            self.all? do |ins|
-              other_instance_group.any? { |other_ins| ins == other_ins }
-            end
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/generator/tests.rb

@@ -1,45 +0,0 @@
-module OrigenTesters
-  class Doc
-    module Generator
-      class Tests
-        attr_accessor :collection
-
-        def initialize
-          @collection = []
-        end
-
-        class IndexedString < ::String
-          attr_accessor :index
-
-          def name
-            self
-          end
-        end
-
-        def add(name, attrs = {})
-          test = Test.new(name, attrs)
-          if @current_group
-            @current_group << test
-          else
-            collection << test
-          end
-          test
-        end
-
-        # Arbitrarily group a subset of tests together, see the J750 API for details on how to use
-        # this.
-        def group(name = nil, options = {})
-          name, options = nil, name if name.is_a?(Hash)
-          @current_group = TestGroup.new(name, options)
-          collection << @current_group
-          yield @current_group
-          @current_group = nil
-        end
-        alias_method :add_group, :group
-
-        def render(_file, _options = {})
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/doc/model.rb

@@ -1,160 +0,0 @@
-module OrigenTesters
-  class Doc
-    # Class representing a program model, provides an API to iterate
-    # on the flow based on context (e.g. which job).
-    class Model
-      attr_accessor :flows, :target
-
-      def initialize
-        @flows = {}
-      end
-
-      # Iterates through each line in the given flow returning a hash for each
-      # line with the following structure:
-      #
-      #   {
-      #     :type => Symbol,     # Type of flow line
-      #     :description => [],  # Array of strings
-      #     :instance => [{}],   # Array of attributes hashes (each one represents an individual test instance)
-      #     :flow => {},         # Hash of attributes
-      #     :context => {},      # Hash of attributes
-      #   }
-      #
-      # In all cases if an item is missing then it will be replaced by an empty
-      # array or hash as appropriate so that the caller does not need to worry
-      # about this.
-      #
-      # Supply the name of the flow(s) to consider, if the flows argument is left
-      # out then all lines in all flows will be returned.
-      #
-      # A context option can be supplied to only return the tests for which the given
-      # context is true.
-      #
-      #   puts "The following tests run at FR:"
-      #   program_model.each_in_flow(:ft_flow, :context => { :job => "FR" }) do |line|
-      #     puts "  #{line[:flow][:name]}"
-      #   end
-      def each_in_flow(flows = nil, options = {})
-        if flows.is_a?(Hash)
-          options = flows
-          flows = nil
-        end
-        unless flows
-          flows = self.flows.keys
-        end
-        [flows].flatten.each do |flow|
-          @flows[flow.to_sym].each do |test|
-            test = format_test(test)
-            if valid_in_context?(test, options[:context])
-              yield test
-            end
-          end
-        end
-        nil
-      end
-
-      # Searches the given flows to find dependents of the given test id. The dependents
-      # are returned in arrays grouped by context:
-      #
-      #   {
-      #     :if_failed => [],
-      #     :if_passed => [],
-      #     :if_ran => [],
-      #     :unless_ran => [],
-      #   }
-      #
-      # Each test will have the same format as described in #each_in_flow.
-      #
-      # If no dependents are found an empty hash is returned.
-      def dependents_of(id, flows, options = {})
-        d = {}
-        each_in_flow(flows, options) do |test|
-          test[:context].each do |key, val|
-            if val == id
-              d[key] ||= []
-              d[key] << test
-            end
-          end
-        end
-        d
-      end
-
-      # Search for the given test id in the given flows.
-      # Returns nil if not found.
-      def find_by_id(id, flows, options = {})
-        each_in_flow(flows, options) do |test|
-          return test if test[:flow][:id] == id
-        end
-      end
-
-      # Returns true if the given tests id valid under the given context
-      # (currently only tests for job matching)
-      def valid_in_context?(test, context = nil)
-        if context && context[:job] && test[:context]
-          if test[:context][:if_jobs]
-            test[:context][:if_jobs].include?(context[:job])
-          elsif test[:context][:unless_jobs]
-            !test[:context][:unless_jobs].include?(context[:job])
-          else
-            true
-          end
-        else
-          true
-        end
-      end
-
-      # @api private
-      def format_test(test, _options = {})
-        {
-          type:        test[:type] ? test[:type].to_sym : :unknown,
-          description: test[:description] || [],
-          instance:    build_instance(test),
-          flow:        test[:flow] ? test[:flow][:attributes] || {} : {},
-          context:     test[:flow] ? test[:flow][:context] || {} : {}
-        }
-      end
-
-      # @api private
-      def build_instance(test)
-        if test[:instance]
-          if test[:instance][:group]
-            test[:instance][:group].map { |g| g[:attributes] || {} }
-          else
-            [test[:instance][:attributes] || {}]
-          end
-        else
-          [{}]
-        end
-      end
-
-      # YAML likes strings for keys, we don't, so make sure all keys are symbols
-      # when receiving a new flow
-      # @api private
-      def add_flow(name, content)
-        @flows[name.to_sym] = content.map do |h|
-          h = symbolize_keys h
-          if h[:instance] && h[:instance][:group]
-            h[:instance][:group] = h[:instance][:group].map { |j| symbolize_keys j }
-          end
-          h
-        end
-      end
-
-      # @api private
-      def symbolize_keys(hash)
-        hash.reduce({}) do |result, (key, value)|
-          new_key = case key
-                    when String then key.to_sym
-                    else key
-                    end
-          new_value = case value
-                      when Hash then symbolize_keys(value)
-                      else value
-                      end
-          result[new_key] = new_value
-          result
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/generator/flow_control_api.rb

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