origen 0.2.6 → 0.3.0

data/lib/origen/tester/ultraflex/files.rb

@@ -1,45 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      # Methods for handling all Ultraflex file parsing, e.g. datalogs,
-      # test time profiles, etc.
-      module Files
-        # Reads all lines from a Ultraflex detailed execution time file, returning the lines
-        # as an array like this:
-        #
-        #   [
-        #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
-        #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
-        #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
-        #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
-        #   ]
-        def read_test_times(file, _options = {})
-          tests = []
-          File.readlines(file).each do |line|
-            unless line.strip.empty? || line =~ /Entire Job/
-              # http://rubular.com/r/vZOcqovTsf
-              if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
-                t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
-                # If an indexed test
-                if Regexp.last_match[2]
-                  str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
-                  fields = str.split('/')
-                  i = fields[0].to_i
-                  g = fields[1].to_i
-                  t[:index] = i
-                  t[:group] = g
-
-                else
-                  t[:index] = nil
-                  t[:group] = nil
-                end
-                tests << t
-              end
-            end
-          end
-          tests
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator.rb

@@ -1,200 +0,0 @@
-require 'active_support/concern'
-
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        extend ActiveSupport::Concern
-
-        autoload :TestInstance,  'origen/tester/ultraflex/generator/test_instance'
-        autoload :TestInstanceGroup,  'origen/tester/ultraflex/generator/test_instance_group'
-        autoload :TestInstances, 'origen/tester/ultraflex/generator/test_instances'
-        autoload :Patset,  'origen/tester/ultraflex/generator/patset'
-        autoload :Patsets, 'origen/tester/ultraflex/generator/patsets'
-        autoload :Patgroup,  'origen/tester/ultraflex/generator/patgroup'
-        autoload :Patgroups, 'origen/tester/ultraflex/generator/patgroups'
-        autoload :Flow,  'origen/tester/ultraflex/generator/flow'
-        autoload :FlowLine,  'origen/tester/ultraflex/generator/flow_line'
-        autoload :Placeholder, 'origen/tester/generator/placeholder'
-
-        included do
-          include Origen::Tester::Interface  # adds the interface helpers/Origen hook-up
-          include Origen::Tester::Generator::FlowControlAPI::Interface
-          PLATFORM = Origen::Tester::Ultraflex
-        end
-
-        def reset_globals
-          flow.reset_globals
-          @@test_instances_filename = nil
-          @@patsets_filename = nil
-          @@patgroups_filename = nil
-          @@test_instances_filename = nil
-          @@patsets_filename = nil
-          @@patgroups_filename = nil
-          @@test_instance_sheets = nil
-          @@patset_sheets = nil
-          @@flow_sheets = nil
-          @@patgroup_sheets = nil
-        end
-
-        # Convenience method to allow the current name for the test instance,
-        # patsets and patgroups sheets to be set to the same value.
-        #
-        #   # my ultraflex interface
-        #
-        #   resources_filename = "common"
-        #
-        #   # The above is equivalent to:
-        #
-        #   test_instances_filename = "common"
-        #   patsets_filename = "common"
-        #   patgroups_filename = "common"
-        def resources_filename=(name)
-          self.test_instances_filename = name
-          self.patsets_filename = name
-          self.patgroups_filename = name
-        end
-
-        # Set the name of the current test instances sheet. This does not change
-        # the name of the current sheet, but rather sets the name of the sheet that
-        # will be generated the next time you access test_instances.
-        def test_instances_filename=(name)
-          @@test_instances_filename = name
-        end
-
-        # Set the name of the current pattern sets sheet. This does not change
-        # the name of the current sheet, but rather sets the name of the sheet that
-        # will be generated the next time you access patsets.
-        def patsets_filename=(name)
-          @@patsets_filename = name
-        end
-
-        # Set the name of the current pattern groups sheet. This does not change
-        # the name of the current sheet, but rather sets the name of the sheet that
-        # will be generated the next time you access patgroups.
-        def patgroups_filename=(name)
-          @@patgroups_filename = name
-        end
-
-        # Returns the name of the current test instances sheet
-        def test_instances_filename
-          @@test_instances_filename ||= 'global'
-        end
-
-        # Returns the name of the current pat sets sheet
-        def patsets_filename
-          @@patsets_filename ||= 'global'
-        end
-
-        # Returns the name of the current pat groups sheet
-        def patgroups_filename
-          @@patgroups_filename ||= 'global'
-        end
-
-        # Returns a hash containing all test instance sheets
-        def test_instance_sheets
-          @@test_instance_sheets ||= {}
-        end
-
-        # Returns a hash containing all pat set sheets
-        def patset_sheets
-          @@patset_sheets ||= {}
-        end
-
-        # Returns a hash containing all flow sheets
-        def flow_sheets
-          @@flow_sheets ||= {}
-        end
-
-        # Returns a hash containing all pat group sheets
-        def patgroup_sheets
-          @@patgroup_sheets ||= {}
-        end
-
-        # Returns an array containing all sheet generators where a sheet generator is a flow,
-        # test instance, patset or pat group sheet.
-        # All Origen program generators must implement this method
-        def sheet_generators # :nodoc:
-          g = []
-          [flow_sheets, test_instance_sheets, patset_sheets, patgroup_sheets].each do |sheets|
-            sheets.each do |_name, sheet|
-              g << sheet
-            end
-          end
-          g
-        end
-
-        # Returns an array containing all flow sheet generators.
-        # All Origen program generators must implement this method
-        def flow_generators
-          g = []
-          flow_sheets.each do |_name, sheet|
-            g << sheet
-          end
-          g
-        end
-
-        # Returns the current test instances sheet (as defined by the current value of
-        # test_instances_filename).
-        #
-        # Pass in a filename argument to have a specific sheet returned instead.
-        #
-        # If the sheet does not exist yet it will be created.
-        def test_instances(filename = test_instances_filename)
-          f = filename.to_sym
-          return test_instance_sheets[f] if test_instance_sheets[f]
-          t = TestInstances.new
-          t.filename = f
-          test_instance_sheets[f] = t
-        end
-
-        # Returns the current pattern sets sheet (as defined by the current value of
-        # patsets_filename).
-        #
-        # Pass in a filename argument to have a specific sheet returned instead.
-        #
-        # If the sheet does not exist yet it will be created.
-        def patsets(filename = patsets_filename)
-          f = filename.to_sym
-          return patset_sheets[f] if patset_sheets[f]
-          p = Patsets.new
-          p.filename = f
-          patset_sheets[f] = p
-        end
-        alias_method :pat_sets, :patsets
-        alias_method :pattern_sets, :patsets
-
-        # Returns the current flow sheet (as defined by the name of the current top
-        # level flow source file).
-        #
-        # Pass in a filename argument to have a specific sheet returned instead.
-        #
-        # If the sheet does not exist yet it will be created.
-        def flow(filename = Origen.file_handler.current_file.basename('.rb').to_s)
-          f = filename.to_sym
-          return flow_sheets[f] if flow_sheets[f]
-          p = Flow.new
-          p.inhibit_output if Origen.interface.resources_mode?
-          p.filename = f
-          flow_sheets[f] = p
-        end
-
-        # Returns the current pattern groups sheet (as defined by the current value of
-        # patgroups_filename).
-        #
-        # Pass in a filename argument to have a specific sheet returned instead.
-        #
-        # If the sheet does not exist yet it will be created.
-        def patgroups(filename = patgroups_filename)
-          f = filename.to_sym
-          return patgroup_sheets[f] if patgroup_sheets[f]
-          p = Patgroups.new
-          p.filename = f
-          patgroup_sheets[f] = p
-        end
-        alias_method :pat_groups, :patgroups
-        alias_method :pattern_groups, :patgroups
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/flow.rb

@@ -1,119 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class Flow
-          include Origen::Tester::Generator
-          include Origen::Tester::Generator::FlowControlAPI
-
-          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/flow.txt.erb"
-          OUTPUT_POSTFIX = 'flow'
-
-          def add(type, options = {})
-            ins = false
-            options = save_context(options) if [:test, :cz].include?(type)
-            branch_unless_enabled(options) do |options|
-              ins = track_relationships(options) do |options|
-                FlowLine.new(type, options)
-              end
-              collection << ins unless Origen.interface.resources_mode?
-              if ins.test?
-                c = Origen.interface.consume_comments
-                unless Origen.interface.resources_mode?
-                  Origen.interface.descriptions.add_for_test_usage(ins.parameter, Origen.interface.top_level_flow, c)
-                end
-              else
-                Origen.interface.discard_comments
-              end
-            end
-            ins
-          end
-
-          def logprint(message, options = {})
-            message.gsub!(/\s/, '_')
-            add(:logprint, options.merge(parameter: message))
-          end
-
-          def test(instance, options = {})
-            add(:test, options.merge(parameter: instance))
-          end
-
-          def cz(instance, cz_setup, options = {})
-            add(:cz, options.merge(parameter: instance, cz_setup: cz_setup))
-          end
-
-          def goto(label, options = {})
-            add(:goto, options.merge(parameter: label))
-          end
-
-          def nop(options = {})
-            add(:nop, options.merge(parameter: nil))
-          end
-
-          def set_device(options = {})
-            add(:set_device, options)
-          end
-
-          def enable_flow_word(word, options = {})
-            add(:enable_flow_word, options.merge(parameter: word))
-          end
-
-          def disable_flow_word(word, options = {})
-            add(:disable_flow_word, options.merge(parameter: word))
-          end
-
-          # All tests generated will not run unless the given enable word is asserted.
-          #
-          # This is specially implemented for Ultraflex since it does not have a native
-          # support for flow word not enabled.
-          # It will generate a goto branch around the tests contained with the block
-          # if the given flow word is enabled.
-          def unless_enable(word, options = {})
-            if options[:or]
-              yield
-            else
-              @unless_enable_block = word
-              options = options.merge(unless_enable: word)
-              branch_unless_enabled(options.merge(_force_unless_enable: true)) do
-                yield
-              end
-              @unless_enable_block = nil
-            end
-          end
-          alias_method :unless_enabled, :unless_enable
-
-          def start_flow_branch(identifier, options = {})
-            goto(identifier, options)
-          end
-
-          def skip(identifier = nil, options = {})
-            identifier, options = nil, identifier if identifier.is_a?(Hash)
-            identifier = generate_unique_label(identifier)
-            goto(identifier, options)
-            yield
-            nop(label: identifier)
-          end
-
-          private
-
-          # If the test has an unless_enable then branch around it
-          def branch_unless_enabled(options)
-            word = options.delete(:unless_enable) || options.delete(:unless_enabled)
-            if word && (word != @unless_enable_block || options.delete(:_force_unless_enable))
-              # Not sure if this is really required, but duplicating these hashes here to ensure
-              # that all other flow context keys are preserved and applied to the branch lines
-              orig_options = options.merge({})
-              close_options = options.merge({})
-              label = generate_unique_label
-              goto(label, options.merge(if_enable: word))
-              yield orig_options
-              nop(close_options.merge(label: label))
-            else
-              yield options
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/flow_line.rb

@@ -1,269 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class FlowLine
-          attr_accessor :type, :id, :cz_setup # cz_setup is a virtual attrib since it is not part of the regular flow line
-          # cz_setup combine with instance name when characterize opcode is used
-
-          # Attributes for each flow line, these must be declared in the order they are to be output
-          ATTRS = %w(label enable job part env opcode parameter tname tnum bin_pass bin_fail
-                     sort_pass sort_fail result flag_pass flag_fail state
-                     group_specifier group_sense group_condition group_name
-                     device_sense device_condition device_name
-                     debug_assume debug_sites comment
-                  )
-
-          # Map any aliases to the official names here, multiple aliases for a given attribute
-          # are allowed
-          ALIASES = {
-            bin:            :bin_fail,
-            softbin:        :sort_fail,
-            soft_bin:       :sort_fail,
-            name:           :tname,
-            number:         :tnum,
-            if_enable:      :enable,
-            if_enabled:     :enable,
-            enabled:        :enable,
-            # Aliases can also be used to set defaults on multiple attributes like this,
-            # use :value to refer to the value passed in to the given alias
-            flag_false:     { device_condition: 'flag-false',
-                              device_name:      :value
-                           },
-            flag_true:      { device_condition: 'flag-true',
-                              device_name:      :value
-                           },
-            flag_false_any: { group_specifier: 'any-active',
-                              group_condition: 'flag-false',
-                              group_name:      :value
-                               },
-            flag_false_all: { group_specifier: 'all-active',
-                              group_condition: 'flag-false',
-                              group_name:      :value
-                               },
-            flag_true_any:  { group_specifier: 'any-active',
-                              group_condition: 'flag-true',
-                              group_name:      :value
-                              },
-            flag_true_all:  { group_specifier: 'all-active',
-                              group_condition: 'flag-true',
-                              group_name:      :value
-                              },
-            flag_clear:     { device_condition: 'flag-clear',
-                              device_name:      :value
-                           }
-          }
-
-          # Assign attribute defaults here, generally this should match whatever defaults
-          # Teradyne has set whenever you create a new test instance, etc.
-          DEFAULTS = {
-            test:              {
-              opcode: 'Test',
-              result: 'Fail'
-            },
-            cz:                {
-              opcode: 'characterize',
-              result: 'None'
-            },
-            goto:              {
-              opcode: 'goto'
-            },
-            nop:               {
-              opcode: 'nop'
-            },
-            set_device:        {
-              opcode: 'set-device'
-            },
-            enable_flow_word:  {
-              opcode: 'enable-flow-word'
-            },
-            disable_flow_word: {
-              opcode: 'disable-flow-word'
-            },
-            logprint:          {
-              opcode: 'logprint'
-            }
-          }
-
-          # Generate accessors for all attributes and their aliases
-          ATTRS.each do |attr|
-            attr_accessor attr.to_sym
-          end
-
-          ALIASES.each do |_alias, val|
-            if val.is_a? Hash
-              define_method("#{_alias}=") do |v|
-                val.each do |k, _v|
-                  myval = _v == :value ? v : _v
-                  send("#{k}=", myval)
-                end
-              end
-            else
-              define_method("#{_alias}=") do |v|
-                send("#{val}=", v)
-              end
-              define_method("#{_alias}") do
-                send(val)
-              end
-            end
-          end
-
-          def initialize(type, attrs = {})
-            @ignore_missing_instance = attrs.delete(:instance_not_available)
-            self.cz_setup = attrs.delete(:cz_setup)
-            @type = type
-            # Set the defaults
-            DEFAULTS[@type.to_sym].each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=")
-            end
-            # Then the values that have been supplied
-            attrs.each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=")
-            end
-          end
-
-          def parameter=(value)
-            if (@type == :test || @test == :cz) && !@ignore_missing_instance
-              if value.is_a?(String) || value.is_a?(Symbol)
-                fail "You must supply the actual test instance object for #{value} when adding it to the flow"
-              end
-            end
-            @parameter = value
-          end
-
-          def parameter
-            # When referring to the test instance take the opportunity to refresh the current
-            # version of the test instance
-            @parameter = Origen.interface.identity_map.current_version_of(@parameter)
-          end
-
-          # Returns the fully formatted flow line for insertion into a flow sheet
-          def to_s
-            l = "\t"
-            ATTRS.each do |attr|
-              if attr == 'parameter'
-                ins = parameter
-                if ins.respond_to?(:name)
-                  l += "#{ins.name}"
-                else
-                  l += "#{ins}"
-                end
-                if cz_setup
-                  l += " #{cz_setup}\t"
-                else
-                  l += "\t"
-                end
-              else
-                l += "#{send(attr)}\t"
-              end
-            end
-            "#{l}"
-          end
-
-          def job
-            if !if_jobs.empty? && !unless_jobs.empty?
-              fail "Both if and unless jobs have been defined for test: #{parameter}"
-            elsif !if_jobs.empty?
-              if_jobs.join(',')
-            elsif !unless_jobs.empty?
-              unless_jobs.map { |j| "!#{j}" }.join(',')
-            else
-              ''
-            end
-          end
-          alias_method :jobs, :job
-
-          def unless_enable=(*_args)
-          end
-          alias_method :unless_enabled=, :unless_enable=
-
-          def if_jobs
-            @if_jobs ||= []
-          end
-
-          def unless_jobs
-            @unless_jobs ||= []
-          end
-
-          def if_job=(jobs)
-            [jobs].flatten.compact.each do |job|
-              job = job.to_s.upcase
-              if job =~ /!/
-                self.unless_job = job
-              else
-                if_jobs << job unless if_jobs.include?(job)
-              end
-            end
-          end
-          alias_method :if_jobs=, :if_job=
-          alias_method :add_if_jobs, :if_job=
-          alias_method :add_if_job, :if_job=
-
-          def unless_job=(jobs)
-            [jobs].flatten.compact.each do |job|
-              job = job.to_s.upcase
-              job.gsub!('!', '')
-              unless_jobs << job unless unless_jobs.include?(job)
-            end
-          end
-          alias_method :unless_jobs=, :unless_job=
-          alias_method :add_unless_jobs, :unless_job=
-          alias_method :add_unless_job, :unless_job=
-
-          def continue_on_fail
-            self.result = 'None'
-          end
-
-          def set_flag_on_fail
-            self.flag_fail = "#{id}_FAILED"
-          end
-
-          def set_flag_on_pass
-            self.flag_pass = "#{id}_PASSED"
-          end
-
-          def set_flag_on_ran
-            self.flag_pass = "#{id}_RAN"
-          end
-
-          def run_if_any_passed(parent)
-            parent.continue_on_fail
-            self.flag_true_any = parent.set_flag_on_pass
-          end
-
-          def run_if_all_passed(parent)
-            parent.continue_on_fail
-            self.flag_true_all = parent.set_flag_on_pass
-          end
-
-          def run_if_any_failed(parent)
-            parent.continue_on_fail
-            self.flag_true_any = parent.set_flag_on_fail
-          end
-
-          def run_if_all_failed(parent)
-            parent.continue_on_fail
-            self.flag_true_all = parent.set_flag_on_fail
-          end
-
-          def id
-            @id || "#{parameter}_#{unique_counter}"
-          end
-
-          def unique_counter
-            @unique_counter ||= self.class.unique_counter
-          end
-
-          def self.unique_counter
-            @ix ||= -1
-            @ix += 1
-          end
-
-          def test?
-            @type == :test
-          end
-        end
-      end
-    end
-  end
-end