origen_testers 0.4.0

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

@@ -0,0 +1,123 @@
+module OrigenTesters
+  module SmartestBasedTester
+    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
+          @initialized = true
+        end
+
+        def add_tml(name, methods)
+          custom_tmls[name] = methods
+        end
+        alias_method :add_test_method_library, :add_tml
+
+        # @api private
+        def at_flow_start
+        end
+
+        # @api private
+        def at_run_start
+          flow.at_run_start
+          @@flow_sheets = nil
+        end
+        alias_method :reset_globals, :at_run_start
+
+        def resources_filename=(name)
+        end
+
+        def flow(filename = Origen.file_handler.current_file.basename('.rb').to_s)
+          f = filename.to_sym
+          if Origen.interface.resources_mode?
+            f = f.to_s.sub(/_resources?/, '').to_sym
+          end
+          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
+          p.test_suites ||= platform::TestSuites.new(p)
+          p.test_methods ||= platform::TestMethods.new(p)
+          p.pattern_master ||= platform::PatternMaster.new(p)
+          flow_sheets[f] = p
+        end
+
+        # Returns a top-level pattern master file which will contain all patterns from
+        # all flows. Additionally each flow has its own pattern master file containing
+        # only the patterns for the specific flow.
+        def pattern_master
+          @pattern_master ||= begin
+            m = platform::PatternMaster.new(manually_register: true)
+            name = 'complete.pmfl'
+            name = "#{Origen.config.program_prefix}_#{name}" if Origen.config.program_prefix
+            m.filename = name
+            m
+          end
+        end
+
+        # Generates a pattern compiler configuration file (.aiv) to compile all
+        # patterns referenced in all flows.
+        def pattern_compiler
+          @pattern_compiler ||= begin
+            m = platform::PatternCompiler.new(manually_register: true)
+            name = 'complete.aiv'
+            name = "#{Origen.config.program_prefix}_#{name}" if Origen.config.program_prefix
+            m.filename = name
+            m
+          end
+        end
+
+        def test_suites
+          flow.test_suites
+        end
+
+        def test_methods
+          flow.test_methods
+        end
+
+        def flow_sheets
+          @@flow_sheets ||= {}
+        end
+
+        # Returns an array containing all sheet generators.
+        # All Origen program generators must implement this method
+        def sheet_generators # :nodoc:
+          g = []
+          flow_sheets.each do |_name, sheet|
+            g << sheet
+            g << sheet.pattern_master
+          end
+          g << pattern_master if pattern_master
+          g << pattern_compiler unless referenced_subroutine_patterns.empty? && referenced_patterns.empty?
+          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
+
+        private
+
+        def custom_tmls
+          @custom_tmls ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/pattern_compiler.rb

@@ -0,0 +1,23 @@
+require 'pathname'
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class PatternCompiler
+        include OrigenTesters::Generator
+
+        attr_accessor :filename
+
+        def initialize(flow = nil)
+        end
+
+        def subroutines
+          Origen.interface.referenced_subroutine_patterns
+        end
+
+        def patterns
+          Origen.interface.referenced_patterns
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/pattern_master.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class PatternMaster
+        include OrigenTesters::Generator
+
+        attr_reader :flow, :paths
+        attr_accessor :filename
+
+        def initialize(flow = nil)
+          @flow = flow
+          @paths = {}
+        end
+
+        def filename
+          @filename || flow.filename.sub('.flow', '.pmfl')
+        end
+
+        def subdirectory
+          'vectors'
+        end
+
+        def add(name, options = {})
+          name, subdir = extract_subdir(name, options)
+          name += '.binl.gz' unless name =~ /binl.gz$/
+          Origen.interface.referenced_patterns << name
+          paths[subdir] ||= []
+          # Just add it, duplicates will be removed at render time
+          paths[subdir] << name unless paths[subdir].include?(name)
+        end
+
+        private
+
+        def extract_subdir(name, options = {})
+          p = Pathname.new(name.to_s)
+          name = p.basename.to_s
+          subdir = p.dirname.to_s
+          # if subdir == '.'
+          #  # In future may support setting a default subdir via the interface
+          # end
+          [name, subdir]
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_method.rb

@@ -0,0 +1,143 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethod
+        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer]
+
+        # Returns the object representing the test method library that the
+        # given test method is defined in
+        attr_reader :library
+        attr_reader :type
+        attr_reader :id
+        alias_method :name, :id
+        # Returns an hash corresponding to the parameters that the given test method has.
+        # The keys are the parameter names and the values are the parameter type.
+        attr_reader :parameters
+        attr_accessor :class_name
+        attr_accessor :abs_class_name
+
+        def initialize(options)
+          @type = options[:type]
+          @library = options[:library]
+          @class_name = options[:methods].delete(:class_name)
+          @parameters = {}
+          # Add limits by default
+          define_singleton_method('limits') do
+            @limits
+          end
+          @limits = TestMethods::Limits.new(self)
+          # Add any methods
+          if options[:methods][:methods]
+            methods = options[:methods][:methods]
+            @finalize = methods.delete(:finalize)
+            methods.each do |method_name, function|
+              var_name = "@#{method_name}".gsub(/=|\?/, '_')
+              instance_variable_set(var_name, function)
+              define_singleton_method method_name do |*args|
+                instance_variable_get(var_name).call(self, *args)
+              end
+            end
+          end
+          # Create attributes corresponding to the test method type represented
+          # by this method instance
+          options[:methods].each do |attr, type_default|
+            unless attr == :limits_type || attr == :aliases || attr == :methods
+              clean_attr = clean_attr_name(attr)
+              type = type_default[0]
+              default = type_default[1]
+              allowed = type_default[2]
+              @parameters[attr] = type
+              aliases = [clean_attr]
+              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
+              aliases.each do |alias_|
+                define_singleton_method("#{alias_}=") do |v|
+                  if allowed
+                    unless allowed.include?(v)
+                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
+                    end
+                  end
+                  instance_variable_set("@#{clean_attr}", v)
+                end
+                define_singleton_method(alias_) do
+                  instance_variable_get("@#{clean_attr}")
+                end
+              end
+              send("#{clean_attr}=", default)
+            end
+          end
+          if options[:methods][:aliases]
+            options[:methods][:aliases].each do |alias_, attr|
+              clean_attr = clean_attr_name(attr)
+              define_singleton_method("#{alias_}=") do |v|
+                send("#{clean_attr}=", v)
+              end
+              define_singleton_method(alias_) do
+                send(clean_attr)
+              end
+            end
+          end
+          # Finally set any initial values that have been supplied
+          options[:attrs].each do |k, v|
+            send("#{k}=", v) if respond_to?("#{k}=")
+          end
+        end
+
+        def format(attr)
+          clean_attr = clean_attr_name(attr)
+          val = send(clean_attr)
+          if FORMAT_TYPES.include?(parameters[attr])
+            type = parameters[attr]
+          else
+            # The type is based on the value of another attribute
+            type = send(clean_attr_name(parameters[attr]))
+          end
+          case type
+          when :current, 'CURR'
+            "#{val}[A]"
+          when :voltage, 'VOLT'
+            "#{val}[V]"
+          when :time
+            "#{val}[s]"
+          when :frequency
+            "#{val}[Hz]"
+          when :string, :integer
+            val.to_s
+          else
+            fail "Unknown type for attribute #{attr}: #{type}"
+          end
+        end
+
+        def klass
+          @abs_class_name ||
+            "#{library.klass}.#{@class_name || type.to_s.camelize}"
+        end
+
+        def finalize
+          @finalize
+        end
+
+        def method_missing(method, *args, &block)
+          if limits && limits.respond_to?(method)
+            limits.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          (limits && limits.respond_to?(method)) || super
+        end
+
+        private
+
+        def clean_attr_name(name)
+          name.to_s.gsub(/\.|-/, '_')
+        end
+
+        def id=(val)
+          @id = val
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_methods.rb

@@ -0,0 +1,73 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        # Origen::Tester::Generator not included since test methods do not have their
+        # own top-level sheet, they will be incorporated within the flow sheet
+
+        require 'origen_testers/smartest_based_tester/base/test_methods/base_tml'
+        require 'origen_testers/smartest_based_tester/base/test_methods/limits'
+        autoload :AcTml, 'origen_testers/smartest_based_tester/base/test_methods/ac_tml'
+        autoload :DcTml, 'origen_testers/smartest_based_tester/base/test_methods/dc_tml'
+        autoload :CustomTml, 'origen_testers/smartest_based_tester/base/test_methods/custom_tml'
+
+        attr_accessor :flow, :collection
+
+        def initialize(flow)
+          @flow = flow
+          @collection = []
+          @ix = 0
+        end
+
+        def filename
+          flow.filename
+        end
+
+        def add(test_method, options = {})
+          collection << test_method
+          test_method.send 'id=', "tm_#{collection.size}"
+          test_method
+        end
+
+        def [](ix)
+          collection[ix]
+        end
+
+        # Returns the AC test method library
+        def ac_tml
+          @ac_tml ||= AcTml.new(self)
+        end
+
+        # Returns the DC test method library
+        def dc_tml
+          @dc_tml ||= DcTml.new(self)
+        end
+
+        # Creates an accessor for custom test method libraries the first time they are called
+        def method_missing(method, *args, &block)
+          custom_tmls = Origen.interface.send(:custom_tmls)
+          if custom_tmls[method]
+            tml = CustomTml.new(self, custom_tmls[method])
+            instance_variable_set "@#{method}", tml
+            define_singleton_method method do
+              instance_variable_get("@#{method}")
+            end
+            send(method)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          !!Origen.interface.send(:custom_tmls)[method] || super
+        end
+
+        def finalize
+          collection.each do |method|
+            method.finalize.call(method) if method.finalize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_methods/ac_tml.rb

@@ -0,0 +1,33 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        class AcTml < BaseTml
+          TEST_METHODS = {
+            frequency_by_digital_capture: {
+              class_name:           'Frequency_byDigitalCapture',
+              vector_variable_name: [:string, ''],
+              algorithm:            [:string, 'FFT', %w(FFT LinearFit)],
+              sample_period:        [:time, 0],
+              target_frequency:     [:frequency, 0],
+              output:               [:string, 'None', %w(None ReportUI ShowFailOnly)],
+              test_name:            [:string, 'passFrequency_MHz']
+            },
+            functional_test:              {
+              test_name: [:string, 'Functional'],
+              output:    [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            }
+          }
+
+          def ac_test
+            self
+          end
+
+          def klass
+            'ac_tml.AcTest'
+          end
+        end
+      end
+    end
+  end
+end