origen_testers 0.4.0

data/lib/origen_testers/igxl_based_tester/ultraflex/test_instance_group.rb

@@ -0,0 +1,9 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class UltraFLEX
+      require 'origen_testers/igxl_based_tester/base/test_instance_group'
+      class TestInstanceGroup < Base::TestInstanceGroup
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/ultraflex/test_instances.rb

@@ -0,0 +1,10 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class UltraFLEX
+      require 'origen_testers/igxl_based_tester/base/test_instances'
+      class TestInstances < Base::TestInstances
+        TEMPLATE = "#{Origen.root!}/lib/origen_testers/igxl_based_tester/ultraflex/templates/instances.txt.erb"
+      end
+    end
+  end
+end

data/lib/origen_testers/interface.rb

@@ -0,0 +1,183 @@
+require 'active_support/concern'
+
+module OrigenTesters
+  # Include this module in any class you define as a test interface
+  module Interface
+    extend ActiveSupport::Concern
+
+    included do
+      Origen.add_interface(self)
+      include Generator::FlowControlAPI::Interface
+    end
+
+    # This identifier will be used to make labels and other references unique to the
+    # current application. This will help to avoid name duplication if a program is
+    # comprised of many modules generated by Origen.
+    #
+    # Override in the application interface to customize, by default the identifier
+    # will be Origen.config.initials
+    def app_identifier
+      Origen.config.initials || 'Anon App'
+    end
+
+    def close(options = {})
+      sheet_generators.each do |generator|
+        generator.close(options)
+      end
+    end
+
+    # Compile a template file
+    def compile(file, options = {})
+      Origen.file_handler.preserve_state do
+        begin
+          file = Origen.file_handler.clean_path_to_template(file)
+          Origen.generator.compile_file_or_directory(file, initial_options: options)
+        rescue
+          file = Origen.file_handler.clean_path_to(file)
+          Origen.generator.compile_file_or_directory(file, initial_options: options)
+        end
+      end
+    end
+
+    def import(file, options = {})
+      # Attach the import request to the first generator, when it imports
+      # it any generated resources will automatically find their way to the
+      # correct generator/collection
+      generator = flow || sheet_generators.first
+      generator.import(file, options)
+    end
+
+    def render(file, options = {})
+      if sheet_generators.size > 1
+        fail "You must specify which generator to render content to! e.g.  i.test_instances.render '#{file}'"
+      else
+        sheet_generators.first.render(file, options)
+      end
+    end
+
+    def write_files(options = {})
+      sheet_generators.each do |generator|
+        generator.finalize(options)
+      end
+      sheet_generators.each do |generator|
+        generator.write_to_file(options) if generator.to_be_written?
+      end
+      clean_referenced_patterns
+      reset_globals
+    end
+
+    # All generators should push to this array whenever they reference a pattern
+    # so that it is captured in the pattern list, e.g.
+    #   Origen.interface.referenced_patterns << pattern
+    def referenced_patterns
+      @@referenced_patterns ||= []
+    end
+
+    # All generators should push to this array whenever they reference a subroutine
+    # pattern so that it is captured in the pattern list, e.g.
+    #   Origen.interface.referenced_subroutine_patterns << pattern
+    def referenced_subroutine_patterns
+      unless Origen.tester.v93k?
+        fail 'referenced_subroutine_patterns is currently only implemented for V93k!'
+      end
+      @@referenced_subroutine_patterns ||= []
+    end
+
+    # Remove duplicates and file extensions from the referenced pattern lists
+    def clean_referenced_patterns
+      refs = [:referenced_patterns]
+      refs << :referenced_subroutine_patterns if Origen.tester.v93k?
+      refs.each do |ref|
+        ref = send(ref)
+        ref.uniq!
+        ref.map! do |pat|
+          pat.sub(/\..*/, '')
+        end
+        ref.uniq!
+      end
+    end
+
+    # Add a comment line into the buffer
+    def comment(text)
+      comments << text
+    end
+
+    def comments
+      @@comments ||= []
+    end
+
+    def discard_comments
+      @@comments = nil
+    end
+
+    # Returns the buffered description comments and clears the buffer
+    def consume_comments
+      c = comments
+      discard_comments
+      c
+    end
+
+    def top_level_flow
+      @@top_level_flow ||= nil
+    end
+    alias_method :top_level_flow_filename, :top_level_flow
+
+    def flow_generator
+      flow
+    end
+
+    def set_top_level_flow
+      @@top_level_flow = flow_generator.output_file
+    end
+
+    def clear_top_level_flow
+      @@top_level_flow = nil
+    end
+
+    # A storage Hash that all generators can push comment descriptions
+    # into when generating.
+    # At the end of a generation run this will contain all descriptions
+    # for all flows that were just created.
+    #
+    # Access via Origen.interface.descriptions
+    def descriptions
+      @@descriptions ||= Parser::DescriptionLookup.new
+    end
+
+    # Any tests generated within the given block will be generated in resources mode.
+    # Generally this means that all resources for a given test will be generated but
+    # flow entries will be inhibited.
+    def resources_mode
+      orig = @resources_mode
+      @resources_mode = true
+      yield
+      @resources_mode = orig
+    end
+
+    def resources_mode?
+      @resources_mode
+    end
+
+    def identity_map # :nodoc:
+      @@identity_map ||= ::OrigenTesters::Generator::IdentityMap.new
+    end
+
+    def platform
+      # This branch to support the ProgramGenerators module where the generator
+      # is included into an interface instance and not the class
+      if singleton_class.const_defined? :PLATFORM
+        singleton_class::PLATFORM
+      else
+        self.class::PLATFORM
+      end
+    end
+
+    module ClassMethods
+      # Returns true if the interface class supports the
+      # given tester instance
+      def supports?(tester_instance)
+        tester_instance.class == self::PLATFORM
+      end
+    end
+  end
+end

data/lib/origen_testers/parser.rb

@@ -0,0 +1,22 @@
+module OrigenTesters
+  module Parser
+    autoload :SearchableArray, 'origen_testers/parser/searchable_array'
+    autoload :SearchableHash,  'origen_testers/parser/searchable_hash'
+    autoload :DescriptionLookup,  'origen_testers/parser/description_lookup'
+
+    def parse(*args, &block)
+      parser.parse(*args, &block)
+    end
+
+    # Returns a SearchableArray containing all tests parsed from flows, this is intended to
+    # be the main API for accessing parsed test program attributes and should be a consistent
+    # method that is implemented accross all tester models.
+    #
+    # Direct access to the underlying structure (which will be specific to the tester model)
+    # can be achieved through the parser method, which returns an instance of J750::Parser
+    #   $tester.parser.test_instances
+    def tests
+      parser.flow_items
+    end
+  end
+end

data/lib/origen_testers/parser/description_lookup.rb

@@ -0,0 +1,62 @@
+module OrigenTesters
+  module Parser
+    class DescriptionLookup
+      def initialize
+        @store = { flow: {}, test: {}, usage: {} }
+      end
+
+      def for_flow(name, options = {})
+        k = flow_key(name)
+        @store[:flow][k] || []
+      end
+
+      def for_test_definition(name, options = {})
+        n = name_key(name)
+        @store[:test][n] || []
+      end
+
+      def for_test_usage(name, flow, options = {})
+        k = flow_key(flow)
+        n = name_key(name)
+        @store[:usage][k] ||= {}
+        @store[:usage][k][n] || []
+      end
+
+      def add_for_flow(flow, description, options = {})
+        k = flow_key(flow)
+        @store[:flow][k] ||= []
+        [description].flatten.each do |d|
+          @store[:flow][k] << d
+        end
+      end
+
+      def add_for_test_definition(test, description, option = {})
+        n = name_key(test)
+        @store[:test][n] ||= []
+        [description].flatten.each do |d|
+          @store[:test][n] << d
+        end
+      end
+
+      def add_for_test_usage(test, flow, description, option = {})
+        k = flow_key(flow)
+        n = name_key(test)
+        @store[:usage][k] ||= {}
+        @store[:usage][k][n] ||= []
+        [description].flatten.each do |d|
+          @store[:usage][k][n] << d
+        end
+      end
+
+      private
+
+      def flow_key(flow)
+        Pathname.new(flow).basename('.*').to_s
+      end
+
+      def name_key(name)
+        name.to_s.downcase
+      end
+    end
+  end
+end

data/lib/origen_testers/parser/searchable_array.rb

@@ -0,0 +1,30 @@
+module Tester
+  module Parser
+    class SearchableArray < ::Array
+      def where(conditions)
+        exact = conditions.delete(:exact)
+        results = SearchableArray.new
+        each do |item|
+          if conditions.all? do |attr, val|
+               if val.is_a?(Array)
+                 if exact
+                   val.any? { |v| item.send(attr).to_s == v.to_s }
+                 else
+                   val.any? { |v| item.send(attr).to_s =~ /#{v.to_s}/ }
+                 end
+               else
+                 if exact
+                   item.send(attr).to_s == val.to_s
+                 else
+                   item.send(attr).to_s =~ /#{val.to_s}/
+                 end
+               end
+             end
+            results << item
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/origen_testers/parser/searchable_hash.rb

@@ -0,0 +1,30 @@
+module OrigenTesters
+  module Parser
+    class SearchableHash < ::Hash
+      def where(conditions)
+        exact = conditions.delete(:exact)
+        results = SearchableArray.new
+        each do |key, item|
+          if conditions.all? do |attr, val|
+               if val.is_a?(Array)
+                 if exact
+                   val.any? { |v| item.send(attr).to_s == v.to_s }
+                 else
+                   val.any? { |v| item.send(attr).to_s =~ /#{v.to_s}/ }
+                 end
+               else
+                 if exact
+                   item.send(attr).to_s == val.to_s
+                 else
+                   item.send(attr).to_s =~ /#{val.to_s}/
+                 end
+               end
+             end
+            results << item
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers.rb

@@ -0,0 +1,116 @@
+module OrigenTesters
+  module PatternCompilers
+    require 'pathname'
+    require_relative 'pattern_compilers/ultraflex_pattern_compiler'
+
+    PLATFORMS = [:ultraflex]
+
+    # Linux compiler executable path
+    LINUX_PATTERN_COMPILER = "#{Origen.root!}/bin/latest/bin/atpcompiler"
+
+    # Windows compiler executable path
+    WINDOWS_PATTERN_COMPILER = "#{ENV['IGXLROOT']}/bin/apc.exe"
+
+    # Hash wrapper for compiler instances, defaults to display currently enabled
+    # tester platform.  If none is set then user must supply a valid tester platform argument
+    def pattern_compilers(id = nil)
+      @pattern_compilers ||= begin
+        hash = {}
+        PLATFORMS.each { |platform| hash[platform] = {} }
+        hash
+      end
+      if id.nil?
+        @pattern_compilers[platform]
+      else
+        @pattern_compilers[platform][id].inspect_options
+      end
+    end
+    alias_method :compilers, :pattern_compilers
+
+    def pattern_compiler_platforms
+      PLATFORMS
+    end
+    alias_method :compiler_platforms, :pattern_compiler_platforms
+
+    # Delete pattern compiler instances.  If no argument default to current platform
+    def delete_pattern_compilers(p = platform)
+      @pattern_compilers[p].delete_if { |k, v| true }
+    end
+    alias_method :delete_compilers, :delete_pattern_compilers
+
+    # Delete a pattern compiler instance.
+    def delete_pattern_compiler(id)
+      @pattern_compilers[platform].delete(id)
+    end
+    alias_method :delete_compiler, :delete_pattern_compiler
+
+    # Add a compiler for a particular tester platform and pattern type
+    def add_pattern_compiler(id, platform, options = {})
+      pattern_compilers
+      id = id.to_sym
+      platform = platform.to_sym
+      options[:location] = options[:location].to_sym unless options[:location].nil?
+      case platform
+      when :ultraflex
+        fail "Compiler ID #{id} for platform #{platform} already exists!  Pick another name, delete the compiler, or clear all compilers" if @pattern_compilers[platform].keys.include? id
+        @pattern_compilers[platform][id] = UltraFlexPatternCompiler.new(id, options)
+      else
+        fail "Platform #{platform} is not valid, please choose from #{PLATFORMS.join(', ')}"
+      end
+    end
+    alias_method :add_compiler, :add_pattern_compiler
+
+    # Returns an array of the pattern compiler instance ids
+    # for the currently selected tester platform.
+    def pattern_compiler_instances(p = platform)
+      # Check if nil which means no tester is defined so ask user to supply it
+      fail "No tester platform defined so supply one of the following as an argument: #{PLATFORMS.join(', ')}" if p.nil?
+      p = p.to_sym
+      @pattern_compilers[p].keys
+    end
+    alias_method :compiler_instances, :pattern_compiler_instances
+
+    def pattern_compiler_options
+      cmd = ''
+      running_on_windows? ? cmd = "#{WINDOWS_PATTERN_COMPILER} -help" : cmd = "#{LINUX_PATTERN_COMPILER} -help"
+      system cmd
+    end
+    alias_method :compiler_options, :pattern_compiler_options
+
+    def pattern_compiler_version
+      cmd = ''
+      running_on_windows? ? cmd = "#{WINDOWS_PATTERN_COMPILER} -version" : cmd = "#{LINUX_PATTERN_COMPILER} -version"
+      system cmd
+    end
+    alias_method :compiler_version, :pattern_compiler_version
+
+    # Check if the current tester is supported
+    def pattern_compiler_supported?
+      PLATFORMS.include? platform ? true : false
+    end
+    alias_method :compiler_supported?, :pattern_compiler_supported?
+
+    private
+
+    def running_on_windows?
+      RUBY_PLATFORM == 'i386-mingw32'
+    end
+
+    # Check if the current tester is an Ultraflex
+    def is_ultraflex?
+      platform == :ultraflex ? true : false
+    end
+
+    def platform
+      if $tester.nil?
+        fail 'No tester instantiated, $tester is set to nil'
+      else
+        $tester.class.to_s.downcase.split('::').last.to_sym
+      end
+    end
+
+    def target_enabled?
+      Origen.target.name.nil? ? true : false
+    end
+  end
+end