origen_testers 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc27fe7836db3c3c77b2ea70f6b82fa845480749
-  data.tar.gz: 05f95c91897e5e88b89b40e81739f285f8e4bd29
+  metadata.gz: 6023b80a1b6acff09fb009dfe06653086cde1101
+  data.tar.gz: 7983d124ed3453e03611bbe18c311e1478d4d837
 SHA512:
-  metadata.gz: c4154784dad3a7fd28dc2ad103342b2a175692d7f7e92e1cbd2542db8bd47d61faba84c8ca7353b4408bcb4366ec474ce7d8f26080cded6eab68cd981b7cc581
-  data.tar.gz: 93d476e8c2bb23cd5166d0ab7ef26fc2115c292579eb5f4dfb878ca1a1fb44f5a8a4a4c42550831117e30b6c9c9d4ca5143033cc32b6bcbb845994a41f445f8b
+  metadata.gz: 7048fcf4fa639db5f22bfc616e4bab64168dbd551ea44f079b624245c9d1b23929d53548eebea074b9a6eece440753584b312a7be776ce34087cfe55742219bd
+  data.tar.gz: 60e493228741d4c898014d1c85a91957f2a2c32fe42319a87665283d84d912c419aba44ef226f03e837b3977d3b7aa23126b96428541a2bedd64c870453b90cc

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 4
-  BUGFIX = 1
+  MINOR = 5
+  BUGFIX = 0
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/origen_testers/command_based_tester.rb

@@ -0,0 +1,45 @@
+
+module OrigenTesters
+  # A base class that can be used to model command-based, rather than
+  # vector-based testers.
+  class CommandBasedTester
+    include VectorBasedTester
+
+    def initialize
+      @vector_based = false
+    end
+
+    # Write a string directly to the output file without being processed
+    # or modified in any way
+    def direct_write(str)
+      microcode str
+    end
+    alias_method :dw, :direct_write
+
+    # Concept of a cycle not supported, print out an error to the output
+    # file to alert the user that execution has hit code that is not
+    # compatible with a command based tester.
+    def cycle(*_args)
+      microcode '*** Cycle called ***'
+    end
+
+    # Concept of a subroutine not supported, print out an error to the output
+    # file to alert the user that execution has hit code that is not
+    # compatible with a command based tester.
+    def call_subroutine(sub)
+      microcode "Call_subroutine called to #{sub}"
+    end
+
+    def format_vector(vec)
+      vec.microcode
+    end
+
+    # Loop the content embedded in the supplied block
+    def loop(_name = nil, number_of_loops)
+      number_of_loops.times do
+        yield
+      end
+    end
+    alias_method :loop_vector, :loop
+  end
+end

data/lib/origen_testers/doc/generator/flow.rb

@@ -0,0 +1,69 @@
+module OrigenTesters
+  class Doc
+    module Generator
+      class Flow
+        include OrigenTesters::Generator
+        include OrigenTesters::Generator::FlowControlAPI
+
+        OUTPUT_POSTFIX = 'flow'
+        OUTPUT_EXTENSION = 'yaml'
+
+        def add(type, options = {})
+          preserve_comments = options.delete(:preserve_comments)
+          line = track_relationships(options) do |options|
+            FlowLine.new(type, options)
+          end
+          collection << line unless Origen.interface.resources_mode?
+          if preserve_comments
+            line.description = Origen.interface.doc_comments
+          else
+            line.description = Origen.interface.doc_comments_consume
+          end
+          line
+        end
+
+        def start_section(options = {})
+          l = FlowLine.new(:section_start, options)
+          if options[:name]
+            desc = [options[:name]]
+          else
+            desc = []
+          end
+          l.description = desc + Origen.interface.doc_comments_consume
+          collection << l
+        end
+
+        def stop_section(options = {})
+          collection << FlowLine.new(:section_stop, options)
+        end
+
+        def test(instance, options = {})
+          options = save_context(options)
+          add(:test, { test: instance }.merge(options))
+        end
+
+        def set_device(options = {})
+          add(:set_device, options)
+        end
+
+        def to_yaml(options = {})
+          collection.map { |l| l.to_yaml(options) }
+        end
+
+        def render(file, options = {})
+          options[:file] = file
+          add(:render, options)
+        end
+
+        def skip(identifier = nil, options = {})
+          identifier, options = nil, identifier if identifier.is_a?(Hash)
+          identifier = generate_unique_label(identifier)
+          options[:test] = identifier
+          add(:branch, options)
+          yield
+          add(:label, test: identifier)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/doc/generator/flow_line.rb

@@ -0,0 +1,201 @@
+module OrigenTesters
+  class Doc
+    module Generator
+      class FlowLine
+        attr_accessor :type, :id, :test, :context, :attributes, :description
+
+        def initialize(type, attrs = {})
+          @type = type
+          @test = attrs.delete(:test)
+          @context = {}
+          @attributes = {}
+          flow_control_options = Origen.interface.extract_flow_control_options!(attrs)
+          flow_control_options.each do |opt, val|
+            send("#{opt}=", val)
+          end
+          attrs.each do |attribute, val|
+            @attributes[attribute] = val
+          end
+        end
+
+        def to_yaml(options = {})
+          options = {
+            include_descriptions: true
+          }.merge(options)
+          y = {
+            'type'        => @type,
+            'description' => description,
+            'instance'    => test_to_yaml(options),
+            'flow'        => {
+              'attributes' => attributes_to_yaml(options),
+              'context'    => context_to_yaml(options)
+            }
+          }
+          y.delete('description') unless options[:include_descriptions]
+          y
+        end
+
+        def attributes_to_yaml(_options = {})
+          a = {}
+          @attributes.each do |name, val|
+            a[name.to_s] = val if val
+          end
+          a
+        end
+
+        def context_to_yaml(_options = {})
+          # Turn attribute keys into strings for prettier yaml, this includes all
+          # relationship meta data
+          c = @context.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+          # Now add job/enable word data
+          if @enable
+            c['if_enable'] = @enable
+          end
+          if @unless_enable
+            c['unless_enable'] = @unless_enable
+          end
+          unless if_jobs.empty?
+            c['if_jobs'] = if_jobs
+          end
+          unless unless_jobs.empty?
+            c['unless_jobs'] = unless_jobs
+          end
+          c
+        end
+
+        def test_to_yaml(options = {})
+          if @test
+            if @test.is_a?(String) || @test.is_a?(Symbol)
+              {
+                'attributes' => {
+                  'name' => @test.to_s
+                }
+              }
+            else
+              @test.to_yaml(options)
+            end
+          end
+        end
+
+        def method_missing(method, *args, &_block)
+          method = method.to_s
+          if method.gsub!('=', '')
+            @attributes[method] = args.first
+          else
+            @attributes[method]
+          end
+        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 if_jobs
+          @if_jobs ||= []
+        end
+
+        def unless_jobs
+          @unless_jobs ||= []
+        end
+
+        def if_enable=(val)
+          @enable = val
+        end
+        alias_method :enable=, :if_enable=
+        alias_method :if_enabled=, :if_enable=
+
+        def unless_enable=(val)
+          @unless_enable = val
+        end
+        alias_method :unless_enabled=, :unless_enable=
+
+        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 run_if_failed(id)
+          @context[:if_failed] = id
+        end
+
+        def run_if_passed(id)
+          @context[:if_passed] = id
+        end
+
+        def run_if_ran(id)
+          @context[:if_ran] = id
+        end
+
+        def run_unless_ran(id)
+          @context[:unless_ran] = id
+        end
+
+        def run_if_any_passed(parent)
+          @context[:if_any_passed] = parent.id
+        end
+
+        def run_if_all_passed(parent)
+          @context[:if_all_passed] = parent.id
+        end
+
+        def run_if_any_failed(parent)
+          @context[:if_any_failed] = parent.id
+        end
+
+        def run_if_all_failed(parent)
+          @context[:if_all_failed] = parent.id
+        end
+
+        def continue_on_fail
+          @attributes[:continue] = true
+        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

data/lib/origen_testers/doc/generator/test.rb

@@ -0,0 +1,66 @@
+module OrigenTesters
+  class Doc
+    module Generator
+      class Test
+        attr_accessor :name, :index, :version, :append_version, :attributes
+
+        def initialize(name, attrs = {})
+          attrs = {}.merge(attrs)  # Important to keep this to clone the original options
+          # so that the caller's copy if not affected by stripping
+          # out the flow/relation options
+          @attributes = {}
+          @append_version = true
+          self.name = name
+          Origen.interface.extract_relation_options!(attrs)
+          Origen.interface.extract_flow_control_options!(attrs)
+          attrs.each do |attribute, val|
+            @attributes[attribute] = val
+          end
+        end
+
+        def to_yaml(options = {})
+          {
+            'attributes' => attributes_to_yaml(options)
+          }
+        end
+
+        def attributes_to_yaml(_options = {})
+          a = {}
+          @attributes.each do |name, val|
+            a[name.to_s] = val if val
+          end
+          a['name'] = name
+          a
+        end
+
+        def method_missing(method, *args, &_block)
+          method = method.to_s
+          if method.gsub!('=', '')
+            @attributes[method] = args.first
+          else
+            @attributes[method]
+          end
+        end
+
+        def ==(other_test)
+          self.class == other_test.class &&
+            unversioned_name.to_s == other_test.unversioned_name.to_s &&
+            attributes.size == other_test.attributes.size &&
+            attributes.all? { |name, val| other_test.attributes[name] == val }
+        end
+
+        def name
+          if version && @append_version
+            "#{@name}_v#{version}"
+          else
+            @name.to_s
+          end
+        end
+
+        def unversioned_name
+          @name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/doc/generator/test_group.rb

@@ -0,0 +1,64 @@
+module OrigenTesters
+  class Doc
+    module Generator
+      class TestGroup
+        attr_accessor :name, :version, :append_version
+
+        include Enumerable
+
+        def initialize(name, _options = {})
+          @name = name
+          @store = []
+          @append_version = true
+        end
+
+        def name
+          if unversioned_name
+            if version && @append_version
+              "#{unversioned_name}_v#{version}"
+            else
+              unversioned_name.to_s
+            end
+          end
+        end
+
+        def to_yaml(options = {})
+          y = {}
+          y['group'] = @store.map { |t| t.to_yaml(options) }
+          y
+        end
+
+        def unversioned_name
+          if @name
+            if @name =~ /grp$/
+              @name
+            else
+              "#{@name}_grp"
+            end
+          end
+        end
+
+        def <<(instance)
+          @store << instance
+        end
+
+        def size
+          @store.size
+        end
+
+        def each
+          @store.each { |ins| yield ins }
+        end
+
+        def ==(other_instance_group)
+          self.class == other_instance_group.class &&
+            unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
+            size == other_instance_group.size &&
+            self.all? do |ins|
+              other_instance_group.any? { |other_ins| ins == other_ins }
+            end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/doc/generator/tests.rb

@@ -0,0 +1,45 @@
+module OrigenTesters
+  class Doc
+    module Generator
+      class Tests
+        attr_accessor :collection
+
+        def initialize
+          @collection = []
+        end
+
+        class IndexedString < ::String
+          attr_accessor :index
+
+          def name
+            self
+          end
+        end
+
+        def add(name, attrs = {})
+          test = Test.new(name, attrs)
+          if @current_group
+            @current_group << test
+          else
+            collection << test
+          end
+          test
+        end
+
+        # Arbitrarily group a subset of tests together, see the J750 API for details on how to use
+        # this.
+        def group(name = nil, options = {})
+          name, options = nil, name if name.is_a?(Hash)
+          @current_group = TestGroup.new(name, options)
+          collection << @current_group
+          yield @current_group
+          @current_group = nil
+        end
+        alias_method :add_group, :group
+
+        def render(_file, _options = {})
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/doc/generator.rb

@@ -0,0 +1,124 @@
+require 'active_support/concern'
+
+module OrigenTesters
+  class Doc
+    module Generator
+      extend ActiveSupport::Concern
+
+      autoload :Test,  'origen_testers/doc/generator/test'
+      autoload :TestGroup,  'origen_testers/doc/generator/test_group'
+      autoload :Tests, 'origen_testers/doc/generator/tests'
+      autoload :Flow,  'origen_testers/doc/generator/flow'
+      autoload :FlowLine,  'origen_testers/doc/generator/flow_line'
+      autoload :Placeholder, 'origen_testers/generator/placeholder'
+
+      included do
+        include OrigenTesters::Interface  # adds the interface helpers/Origen hook-up
+        include OrigenTesters::Generator::FlowControlAPI::Interface
+        PLATFORM = OrigenTesters::Doc
+      end
+
+      # Returns the current flow (as defined by the name of the current top
+      # level flow source file).
+      #
+      # Pass in a filename argument to have a specific flow returned instead.
+      #
+      # If the flow does not exist yet it will be created.
+      def flow(filename = nil)
+        unless filename
+          if Origen.file_handler.current_file
+            filename = Origen.file_handler.current_file.basename('.rb').to_s
+          else
+            filename = 'anonymous'
+          end
+        end
+        f = filename.to_sym
+        return flows[f] if flows[f]
+        p = Flow.new
+        p.inhibit_output if Origen.interface.resources_mode?
+        p.filename = f
+        flows[f] = p
+      end
+
+      # @api private
+      def at_flow_start
+      end
+
+      # @api private
+      def at_run_start
+        flow.at_run_start
+        @@tests = nil
+        @@flows = nil
+      end
+      alias_method :reset_globals, :at_run_start
+
+      # Returns a container for all generated tests.
+      def tests
+        @@tests ||= Tests.new
+      end
+      alias_method :test_instances, :tests
+
+      # Returns a hash containing all flows
+      def flows
+        @@flows ||= {}
+      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 = []
+        [flows].each do |sheets|
+          sheets.each do |_name, sheet|
+            g << sheet
+          end
+        end
+        g
+      end
+
+      # Returns an array containing all flow generators.
+      # All Origen program generators must implement this method
+      def flow_generators
+        g = []
+        flows.each do |_name, sheet|
+          g << sheet
+        end
+        g
+      end
+
+      # The source of all program files is passed in here before executing.
+      # This will replace all comments with a method call containing the comment so that
+      # they can be captured.
+      def filter_source(source) # :nodoc:
+        src = ''
+        source.split(/\r?\n/).each do |line|
+          if line !~ /^\s*#-/ && line =~ /^\s*#(.*)/
+            comment = Regexp.last_match[1].gsub("'", "\\\\'")
+            src << "Origen.interface.doc_comments_capture('#{comment}')\n"
+          else
+            src << "#{line}\n"
+          end
+        end
+        src
+      end
+
+      def doc_comments_capture(comment)
+        doc_comments << "#{comment}"
+      end
+
+      def doc_comments
+        @doc_comments ||= []
+      end
+
+      def doc_comments_consume
+        c = doc_comments
+        doc_comments_discard
+        c
+      end
+
+      def doc_comments_discard
+        @doc_comments = []
+      end
+    end
+  end
+end