origen_testers 0.4.1 → 0.5.0

data/lib/origen_testers/doc/model.rb

@@ -0,0 +1,160 @@
+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/doc.rb

@@ -0,0 +1,224 @@
+module OrigenTesters
+  # Tester model to generate test program documentation from your pattern sources.
+  # This is intended to be a drop in replacement for existing testers and instead
+  # of generating patterns or test program sheets it will generate a document object
+  # which you can then render out via a template or manually.
+  class Doc
+    include VectorBasedTester
+
+    autoload :Generator, 'origen_testers/doc/generator'
+    autoload :Model, 'origen_testers/doc/model'
+
+    attr_accessor :html_mode
+
+    def generate?
+      html_mode
+    end
+
+    def initialize(*_args)
+      @pat_extension = 'md'
+      @indent = 0
+      @snip_counters = []
+    end
+
+    # Snip the number of comment lines generated by the contained block
+    # to the number given, this is useful for keeping files sizes down and
+    # is typically used to snip sections like downloading LRE code.
+    def snip(number, _options = {})
+      @snip_counters.push number + 1
+      yield
+      @snip_counters.pop
+    end
+
+    def pc(msg)
+      if @snip_counters.last
+        if @snip_counters.last == 1
+          @snip_counters[@snip_counters.size - 1] = 0
+          msg = '  ...snipped'
+        elsif @snip_counters.last == 0
+          return
+        else
+          @snip_counters[@snip_counters.size - 1] -= 1
+        end
+      end
+      if html_mode
+        push_comment(msg)
+      else
+        Origen.log.info((' ' * @indent) + msg)
+      end
+    end
+
+    def c1(msg, options = {})
+      if generating_program?
+        Origen.interface.doc_comments_capture(msg)
+      else
+        unless @inhibit_comments
+          options = {
+            prefix: true
+          }.merge(options)
+          if @step_comment_on
+            open_text_block
+            if options[:prefix]
+              pc "# #{msg}"
+            else
+              pc "#{msg}"
+            end
+          end
+        end
+      end
+    end
+
+    def c2(msg, options = {})
+      unless @inhibit_comments
+        options = {
+          prefix: true
+        }.merge(options)
+        open_text_block
+        if options[:prefix]
+          pc "# #{msg}"
+        else
+          pc "#{msg}"
+        end
+      end
+    end
+
+    def annotate(msg, _options)
+      unless @inhibit_comments
+        if html_mode
+          pc ''
+          lines = msg.split("\n")
+          leading_spaces = lines.first[/\A */].size
+          lines.each do |line|
+            pc line.gsub(/^.{#{leading_spaces}}/, '')
+          end
+          pc ''
+        end
+      end
+    end
+
+    def open_text_block
+      if html_mode
+        unless @text_block_open
+          pc ''
+          pc '~~~text'
+          @text_block_open = true
+        end
+      end
+    end
+
+    def close_text_block
+      if html_mode
+        if @text_block_open
+          pc '~~~'
+          pc ''
+          @text_block_open = false
+        end
+      end
+    end
+
+    def pattern_name
+      Origen.app.current_job.output_pattern_filename.gsub('.md', '')
+    end
+
+    def pre_header
+      # pc "---"
+      # pc "layout: bootstrap"
+      # pc "title: #{pattern_name}"
+      # pc "gzip: false"
+      # pc "---"
+      # pc ""
+      # pc "# #{pattern_name}"
+      # pc ""
+    end
+
+    def pattern_section(msg)
+      unless @inhibit_comments
+        if generating_program?
+          Origen.interface.flow.start_section(name: msg)
+          yield
+          Origen.interface.flow.stop_section
+        else
+          if html_mode
+            counter = next_accordion_counter
+            close_text_block
+            pc ''
+            pc "<div class=\"accordion-group\">"
+            pc "<div class=\"accordion-heading\">"
+            pc "<a class=\"accordion-toggle\" data-toggle=\"collapse\" data-parent=\"#accordion2\" href=\"#collapseComment#{counter}\">"
+            pc "#{msg}"
+            pc '</a>'
+            pc '</div>'
+            pc "<div id=\"collapseComment#{counter}\" class=\"accordion-body collapse\">"
+            pc "<div class=\"accordion-inner\" markdown=\"1\">"
+            yield
+            close_text_block
+            pc '</div>'
+            pc '</div>'
+            pc '</div>'
+          else
+            pc ''
+            pc "#{msg}"
+            pc ''
+            @indent += 4
+            yield
+            @indent -= 4
+          end
+        end
+      end
+    end
+
+    def next_accordion_counter
+      @accordion_counter ||= 0
+      @accordion_counter += 1
+    end
+
+    def ss(msg = nil)
+      unless @inhibit_comments
+        @step_comment_on = true
+        if block_given?
+          yield
+        else
+          c2(msg)
+        end
+        @step_comment_on = false
+      end
+    end
+
+    def self.generate_program_model(files, options = {})
+      options = {
+        action:       :program,
+        return_model: true,
+        skip_diff:    true
+      }.merge(options)
+      Origen.app.with_doc_tester do
+        Origen.target.temporary = options[:target] if options[:target]
+        Origen.app.load_target!
+        Origen.interface.reset_globals
+        options[:files] = files
+        Origen.file_handler.preserve_and_clear_state do
+          Origen.app.runner.launch(options)
+        end
+      end
+      model.target = Origen.target.name
+      model
+    end
+
+    def self.model
+      @model ||= Model.new
+    end
+
+    def doc?
+      true
+    end
+
+    def cycle(_options = {})
+    end
+
+    # Ignore any tester-specific methods
+    def method_missing(_method, *_args, &_block)
+      if block_given?
+        yield
+      end
+    end
+  end
+end

data/lib/origen_testers/generator.rb

@@ -154,7 +154,7 @@ module OrigenTesters
     def write_to_file(options = {})
       c = caller[0]
       unless output_inhibited?
-        if defined? self.class::TEMPLATE || Origen.tester.is_a?(Origen::Tester::Doc)
+        if defined? self.class::TEMPLATE || Origen.tester.is_a?(OrigenTesters::Doc)
           write_from_template(options)
         else
           fail "Don't know hot to write without a template!"
@@ -174,7 +174,7 @@ module OrigenTesters
         # The use of a class variable to store the opened files means that it will be
         # shared by all generators in this run.
         @@opened_files ||= []
-        if @@opened_files.include?(output_file) && !Origen.tester.is_a?(Origen::Tester::Doc)
+        if @@opened_files.include?(output_file) && !Origen.tester.is_a?(OrigenTesters::Doc)
           @append = true
           Origen.file_handler.preserve_state do
             File.open(output_file, 'a') do |out|
@@ -186,9 +186,9 @@ module OrigenTesters
         else
           @append = false
           Origen.file_handler.preserve_state do
-            if Origen.tester.is_a?(Origen::Tester::Doc)
+            if Origen.tester.is_a?(OrigenTesters::Doc)
               if options[:return_model]
-                Origen::Tester::Doc.model.add_flow(filename(include_extension: false), to_yaml)
+                OrigenTesters::Doc.model.add_flow(filename(include_extension: false), to_yaml)
               else
                 Origen.file_handler.open_for_write(output_file) do |f|
                   f.puts YAML.dump(to_yaml(include_descriptions: false))

data/lib/origen_testers/igxl_based_tester/base.rb

@@ -508,11 +508,13 @@ module OrigenTesters
 
         # here indicate pattern header specific stuff
         yield pin_list
-        max_pin_name_length = ordered_pins.map(&:name).max { |a, b| a.length <=> b.length }.length
-        pin_widths = ordered_pins.map { |p| p.size - 1 }
+        if ordered_pins.size > 0
+          max_pin_name_length = ordered_pins.map(&:name).max { |a, b| a.length <=> b.length }.length
+          pin_widths = ordered_pins.map { |p| p.size - 1 }
 
-        max_pin_name_length.times do |i|
-          cc((' ' * 93) + ordered_pins.map.with_index { |p, x| ((p.name[i] || ' ') + ' ' * pin_widths[x]).gsub('_', '-') }.join(' '))
+          max_pin_name_length.times do |i|
+            cc((' ' * 93) + ordered_pins.map.with_index { |p, x| ((p.name[i] || ' ') + ' ' * pin_widths[x]).gsub('_', '-') }.join(' '))
+          end
         end
       end
 

data/lib/origen_testers/igxl_based_tester/j750.rb

@@ -199,8 +199,6 @@ module OrigenTesters
         match_conditions.each_with_index do |condition, i|
           microcode "block_#{i}_matched_#{@unique_counter}:"
           cycle(microcode: 'pop_loop icc')
-        end
-        if options[:clr_fail_post_match]
           cycle(microcode: 'clr_fail')
         end
         if options[:on_block_match_goto]

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -344,11 +344,13 @@ module OrigenTesters
           end
         end.join(' ')
         microcode "FORMAT #{pin_list};"
-        max_pin_name_length = ordered_pins.map(&:name).max { |a, b| a.length <=> b.length }.length
-        pin_widths = ordered_pins.map { |p| p.size - 1 }
+        if ordered_pins.size > 0
+          max_pin_name_length = ordered_pins.map(&:name).max { |a, b| a.length <=> b.length }.length
+          pin_widths = ordered_pins.map { |p| p.size - 1 }
 
-        max_pin_name_length.times do |i|
-          cc((' ' * 50) + ordered_pins.map.with_index { |p, x| ((p.name[i] || ' ') + ' ' * pin_widths[x]).gsub('_', '-') }.join(' '))
+          max_pin_name_length.times do |i|
+            cc((' ' * 50) + ordered_pins.map.with_index { |p, x| ((p.name[i] || ' ') + ' ' * pin_widths[x]).gsub('_', '-') }.join(' '))
+          end
         end
       end
 

data/lib/origen_testers/vector_based_tester.rb

@@ -9,11 +9,10 @@ module OrigenTesters
     require 'origen_testers/timing'
     require 'origen_testers/api'
 
-    include VectorGenerator
-    include Timing
-    include API
-
     included do
+      include VectorGenerator
+      include Timing
+      include API
     end
 
     module ClassMethods # :nodoc:
@@ -22,7 +21,7 @@ module OrigenTesters
       # a tester with Origen
       def new(*args, &block) # :nodoc:
         if Origen.app.with_doc_tester?
-          x = Origen::Tester::Doc.allocate
+          x = OrigenTesters::Doc.allocate
           if Origen.app.with_html_doc_tester?
             x.html_mode = true
           end