origen_testers 0.4.0

data/lib/origen_testers/igxl_based_tester/base/generator.rb

@@ -0,0 +1,217 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      module Generator
+        extend ActiveSupport::Concern
+
+        autoload :Placeholder, 'origen_testers/generator/placeholder'
+
+        included do
+          include Interface  # adds the interface helpers/Origen hook-up
+        end
+
+        # This is just to give all interfaces an initialize that takes
+        # one argument. The super is important for cases where this module
+        # is included late via Testers::ProgramGenerators
+        def initialize(options = {})
+          super
+        end
+
+        # @api private
+        def at_flow_start
+          @@test_instances_filename = nil
+          @@patsets_filename = nil
+          @@patgroups_filename = nil
+        end
+
+        # @api private
+        def at_run_start
+          flow.at_run_start
+          @@test_instance_sheets = nil
+          @@patset_sheets = nil
+          @@flow_sheets = nil
+          @@patgroup_sheets = nil
+        end
+        alias_method :reset_globals, :at_run_start
+
+        # Convenience method to allow the current name for the test instance,
+        # patsets and patgroups sheets to be set to the same value.
+        #
+        #   # my j750 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
+          @@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
+          @@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
+          @@patgroups_filename = name
+        end
+
+        # Returns the name of the current test instances sheet
+        def test_instances_filename
+          @@test_instances_filename ||= @test_instances_filename || 'global'
+        end
+
+        # Returns the name of the current pat sets sheet
+        def patsets_filename
+          @@patsets_filename ||= @patsets_filename || 'global'
+        end
+
+        # Returns the name of the current pat groups sheet
+        def patgroups_filename
+          @@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 = platform::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 = platform::Patsets.new
+          p.filename = f
+          patset_sheets[f] = p
+        end
+        alias_method :pat_sets, :patsets
+        alias_method :pattern_sets, :patsets
+
+        # Returns the current pattern subroutine sheet (as defined by the current value of
+        # patsubrs_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 patsubrs(filename = patsubrs_filename)
+          f = filename.to_sym
+          return patsubr_sheets[f] if patsubr_sheets[f]
+          p = platform::Patsubrs.new
+          p.filename = f
+          patsubr_sheets[f] = p
+        end
+        alias_method :pat_subrs, :patsubrs
+        alias_method :pattern_subrs, :patsubrs
+
+        # 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)
+          # DH here need to reset the flow!!
+          f = filename.to_sym
+          return flow_sheets[f] if flow_sheets[f] # will return flow if already existing
+          p = platform::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 = platform::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_testers/igxl_based_tester/base/patgroup.rb

@@ -0,0 +1,109 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Patgroup
+        attr_accessor :index
+
+        class Pattern
+          ATTRS = %w(group_name pattern_file comment)
+
+          ALIASES = {
+            pattern: :pattern_file
+          }
+
+          DEFAULTS = {
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          ALIASES.each do |_alias, val|
+            define_method("#{_alias}=") do |v|
+              send("#{val}=", v)
+            end
+            define_method("#{_alias}") do
+              send(val)
+            end
+          end
+
+          def initialize(patgroup, attrs = {})
+            # Set the defaults
+            DEFAULTS.each do |k, v|
+              send("#{k}=", v)
+            end
+            # Then the values that have been supplied
+            self.group_name = patgroup
+            attrs.each do |k, v|
+              send("#{k}=", v)
+            end
+          end
+
+          def to_s
+            l = "\t"
+            ATTRS.each do |attr|
+              l += "#{send(attr)}\t"
+            end
+            "#{l}"
+          end
+        end
+
+        # Specify multiple patterns by passing an array of attributes
+        # as the 2nd argument:
+        #
+        #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
+        #
+        #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
+        #                            {:pattern => "nvm_global_subs.PAT},
+        #                           ])
+        def initialize(name, attrs = {})
+          attrs = [attrs] unless attrs.is_a? Array
+          attrs.each do |pattrs|
+            if pattrs[:pattern]
+              pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
+              Origen.interface.referenced_patterns << pat
+            end
+            lines << Pattern.new(name, pattrs)
+          end
+          self.name = name
+        end
+
+        def ==(other_patgroup)
+          self.class == other_patgroup.class &&
+            name.to_s == other_patgroup.name.to_s &&
+            sorted_pattern_files == other_patgroup.sorted_pattern_files
+        end
+
+        def name
+          @name
+        end
+
+        def name=(n)
+          @name = n
+          lines.each { |l| l.group_name = n }
+          n
+        end
+
+        # Returns all lines in the pattern set
+        def lines
+          @lines ||= []
+        end
+
+        # Returns all pattern files in the pattern set in alphabetical order
+        def sorted_pattern_files
+          @lines.map(&:file_name).sort
+        end
+
+        # Returns the fully formatted pattern group for insertion into a patgroups sheet
+        def to_s
+          l = ''
+          lines.each do |line|
+            l += "#{line}\r\n"
+          end
+          l.chomp
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/patgroups.rb

@@ -0,0 +1,38 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Patgroups
+        include ::OrigenTesters::Generator
+
+        OUTPUT_POSTFIX = 'patgroups'
+
+        def add(name, options = {})
+          p = platform::Patgroup.new(name, options)
+          collection << p
+          p
+        end
+
+        def finalize(options = {})
+          uniq!
+          sort!
+        end
+
+        # Present the patgroups in the final sheet in alphabetical order
+        def sort!
+          collection.sort_by!(&:name)
+        end
+
+        # Removes all duplicate patgroups
+        def uniq!
+          uniques = []
+          collection.each do |patgroup|
+            unless uniques.any? { |p| p == patgroup }
+              uniques << patgroup
+            end
+          end
+          self.collection = uniques
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/patset.rb

@@ -0,0 +1,68 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Patset
+        attr_accessor :index
+
+        # Specify multiple patterns by passing an array of attributes
+        # as the 2nd argument:
+        #
+        #   Patset.new("mrd1_pset", :pattern => "nvm_mrd1.PAT")
+        #
+        #   Patset.new("mrd1_pset", [{:pattern => "nvm_mrd1.PAT"},
+        #                            {:pattern => "nvm_global_subs.PAT, :start_label => "subr"}
+        #                           ])
+        def initialize(name, attrs = {})
+          attrs = [attrs] unless attrs.is_a? Array
+          attrs.each do |pattrs|
+            if pattrs[:pattern]
+              pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
+              Origen.interface.referenced_patterns << pat
+            end
+            lines << platform::PatsetPattern.new(name, pattrs)
+          end
+          self.name = name
+        end
+
+        def ==(other_patset)
+          self.class == other_patset.class &&
+            name.to_s == other_patset.name.to_s &&
+            sorted_pattern_files == other_patset.sorted_pattern_files
+        end
+
+        def name
+          @name
+        end
+
+        def name=(n)
+          @name = n
+          lines.each { |l| l.pattern_set = n }
+          n
+        end
+
+        # Returns all lines in the pattern set
+        def lines
+          @lines ||= []
+        end
+
+        # Returns all pattern files in the pattern set in alphabetical order
+        def sorted_pattern_files
+          @lines.map(&:file_name).sort
+        end
+
+        # Returns the fully formatted pattern set for insertion into a patset sheet
+        def to_s
+          l = ''
+          lines.each do |line|
+            l += "#{line}\r\n"
+          end
+          l.chomp
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/patset_pattern.rb

@@ -0,0 +1,56 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class PatsetPattern
+        ALIASES = {
+          pattern: :file_name
+        }
+
+        def self.define
+          # Generate accessors for all attributes and their aliases
+          self::PATSET_ATTRS.each do |attr|
+            writer = "#{attr}=".to_sym
+            reader = attr.to_sym
+            attr_reader attr.to_sym unless method_defined? reader
+            attr_writer attr.to_sym unless method_defined? writer
+          end
+
+          ALIASES.each do |_alias, val|
+            writer = "#{_alias}=".to_sym
+            reader = _alias.to_sym
+            unless method_defined? writer
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+            end
+            unless method_defined? reader
+              define_method("#{_alias}") do
+                send(val)
+              end
+            end
+          end
+        end
+
+        def initialize(patset, attrs = {})
+          # Set the defaults
+          self.class::PATSET_DEFAULTS.each do |k, v|
+            send("#{k}=", v)
+          end
+          # Then the values that have been supplied
+          self.pattern_set = patset
+          attrs.each do |k, v|
+            send("#{k}=", v)
+          end
+        end
+
+        def to_s
+          l = "\t"
+          self.class::PATSET_ATTRS.each do |attr|
+            l += "#{send(attr)}\t"
+          end
+          "#{l}"
+        end
+      end
+    end
+  end
+end