origen_testers 0.4.0

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

@@ -0,0 +1,188 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class Flow
+        include OrigenTesters::Generator
+        include OrigenTesters::Generator::FlowControlAPI
+
+        attr_accessor :test_suites, :test_methods, :pattern_master
+
+        def subdirectory
+          'testflow'
+        end
+
+        def filename
+          super.gsub('_flow', '')
+        end
+
+        def finalize(options = {})
+          super
+          flow_control_variables.uniq!
+          collection.each { |n| n.finalize if n.respond_to?(:finalize) }
+          test_suites.finalize
+          test_methods.finalize
+        end
+
+        # Convenience method that will automatically generate a run and branch if a :bin
+        # option is supplied. If no :bin option is present then it will generate a simple
+        # run entry in the flow.
+        def test(test_suite, options = {})
+          sbin = options[:sbin] || options[:softbin] || options[:soft_bin]
+          if options[:bin] || sbin
+            node = run_and_branch(test_suite, options)
+            options.delete(:id)
+            # Only pass options to configure the bin, don't pass flow control options, those apply to the main
+            # test only in this case
+            bin = bad_bin(options[:bin], options.slice(*(FlowNode::ATTRS[:bad_bin].keys + FlowNode::ALIASES[:bad_bin].keys)))
+            node.else_nodes << bin
+            node
+          else
+            run(test_suite, options)
+          end
+        end
+
+        # This module contains methods that correspond to the test flow primitives available
+        # in the palette window of the test flow editor
+        module Palette
+          def run(test_suite, options = {})
+            add(:run, { test_suite: test_suite }.merge(options))
+          end
+          alias_method :run_test, :run
+
+          def run_and_branch(test_suite, options = {})
+            add(:run_and_branch, { test_suite: test_suite }.merge(options))
+          end
+
+          def good_bin(number, options = {})
+            add(:good_bin, { bin: number }.merge(options))
+          end
+
+          def bad_bin(number, options = {})
+            add(:bad_bin, { bin: number }.merge(options))
+          end
+
+          def multi_bin(number, options = {})
+            fail 'V93K Flow#multi_bin method has not been implemented yet!'
+          end
+
+          def print(msg, options = {})
+            add(:print, { value: msg }.merge(options))
+          end
+
+          def print_to_datalog(msg, options = {})
+            add(:print_to_datalog, { value: msg }.merge(options))
+          end
+
+          def assign_value(variable, value, options = {})
+            add(:assign_value, { variable: variable, value: value }.merge(options))
+          end
+
+          def if_then(condition, options = {})
+            add(:if_then, { condition: condition }.merge(options))
+          end
+
+          def group(name, options = {})
+            name = make_unique(:group, name)
+            g = add(:group, { name: name }.merge(options))
+            if block_given?
+              open_groups << g
+              yield g
+              open_groups.pop
+            end
+            g
+          end
+        end
+        include Palette
+
+        # Convenience method to provide similar functionality to enabling a Teradyne flow word/variable
+        def enable_flow_word(variable, options = {})
+          assign_value(variable, 1, options)
+        end
+
+        def skip(identifier = nil, options = {})
+          identifier, options = nil, identifier if identifier.is_a?(Hash)
+          open_skips << []
+          yield
+          nodes = open_skips.pop
+          s = if_then(:skip, options)
+          s.else_nodes = nodes
+        end
+
+        def hardware_bin_descriptions
+          @hardware_bin_descriptions ||= {}
+        end
+
+        def flow_control_variables
+          @flow_control_variables ||= []
+        end
+
+        private
+
+        def add(type, options = {})
+          options = save_context(options) if [:run, :run_and_branch].include?(type)
+
+          # Delete the ID if a test within a group with the same ID to avoid a duplicate ID
+          # error.
+          if options[:id]
+            id = Origen.interface.filter_id(options[:id], options)
+            options.delete(:id) if group_opened? && open_groups.any? { |g| g.id == id }
+          end
+          node = track_relationships(options) do |options|
+            platform::FlowNode.create(self, type, options)
+          end
+          unless Origen.interface.resources_mode?
+            if skip_opened?
+              open_skips.last << node
+              node.parent = open_skips.last
+            else
+              if group_opened?
+                open_groups.last.nodes << node
+                node.parent = open_groups.last.nodes
+              else
+                collection << node
+              end
+            end
+          end
+          if node.test?
+            node.test_suite = options[:test_suite]
+            c = Origen.interface.consume_comments
+            unless Origen.interface.resources_mode?
+              Origen.interface.descriptions.add_for_test_usage(node.test_suite.name, Origen.interface.top_level_flow, c)
+            end
+          else
+            Origen.interface.discard_comments
+          end
+          node
+        end
+
+        def open_skips
+          @open_skips ||= []
+        end
+
+        def skip_opened?
+          open_skips.size > 0
+        end
+
+        def open_groups
+          @open_groups ||= []
+        end
+
+        def group_opened?
+          open_groups.size > 0
+        end
+
+        def make_unique(type, name, options = {})
+          @uniques ||= {}
+          t = @uniques[type] ||= {}
+          t[name] ||= 0
+          t[name] += 1
+          if t[name] == 1
+            name
+          else
+            "#{name}_#{t[name]}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,476 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class FlowNode
+        attr_accessor :type, :id, :rendered, :parent, :deleted
+        alias_method :rendered?, :rendered
+        alias_method :deleted?, :deleted
+        attr_reader :flow
+
+        TYPES = [:run, :run_and_branch, :print, :print_to_datalog, :good_bin, :bad_bin, :group,
+                 :assign_value, :if_then
+                ]
+
+        ATTRS = {
+          good_bin:         {
+            soft_bin:      nil,
+            soft_bin_desc: nil,
+            bin:           nil,
+            bin_desc:      nil,
+            bin_type:      :good,
+            reprobe:       false,
+            color:         :green,
+            overon:        true
+          },
+          bad_bin:          {
+            soft_bin:      nil,
+            soft_bin_desc: 'fail',
+            bin:           nil,
+            bin_desc:      nil,
+            bin_type:      :bad,
+            reprobe:       false,
+            color:         :red,
+            overon:        true
+          },
+          run:              {
+            nodes:      [],
+            else_nodes: [],
+            test_suite: nil,
+            id:         nil
+          },
+          run_and_branch:   {
+            nodes:      [],
+            else_nodes: [],
+            test_suite: nil,
+            id:         nil
+          },
+          if_then:          {
+            condition:  nil,
+            nodes:      [],
+            else_nodes: []
+          },
+          print:            {
+            value: nil
+          },
+          print_to_datalog: {
+            value: nil
+          },
+          group:            {
+            name:    nil,
+            nodes:   [],
+            comment: nil,
+            bypass:  nil
+          },
+          assign_value:     {
+            variable: nil,
+            value:    nil
+          }
+        }
+
+        ALIASES = {
+          good_bin: {
+            sbin:    :soft_bin,
+            softbin: :soft_bin
+          },
+          bad_bin:  {
+            sbin:    :soft_bin,
+            softbin: :soft_bin
+          }
+        }
+
+        def parent
+          @parent || flow.collection
+        end
+
+        # Call this instead of FlowNode.new, this will return a dedicated object for the given
+        # type if one exists, otherwise it will instantiate a generic FlowNode object
+        def self.create(flow, type, attrs = {})
+          unless TYPES.include?(type)
+            fail "Uknown flow node type :#{type}, valid types are #{TYPES.map { |t| ':' + t.to_s }.join(', ')}"
+          end
+          attrs[:_flow] = flow
+          attrs[:called_internally] = true
+          FlowNode.new(type, attrs)
+        end
+
+        def initialize(type, attrs = {})
+          unless attrs.delete(:called_internally)
+            fail "Don't use FlowNode.new, use FlowNode.create instead"
+          end
+          @flow = attrs.delete(:_flow)
+          ATTRS[type].each do |attr, default|
+            define_singleton_method("#{attr}=") do |v|
+              instance_variable_set("@#{attr}", v)
+            end
+            define_singleton_method("#{attr}") do
+              instance_variable_get("@#{attr}")
+            end
+            send("#{attr}=", default.respond_to?(:each) ? default.dup : default)
+          end
+          if ALIASES[type]
+            ALIASES[type].each do |alias_, attr|
+              define_singleton_method("#{alias_}=") do |v|
+                send("#{attr}=", v)
+              end
+              define_singleton_method("#{alias_}") do
+                send(attr)
+              end
+            end
+          end
+          @type = type
+          attrs.each do |k, v|
+            send("#{k}=", v) if respond_to?("#{k}=")
+          end
+        end
+
+        def inspect
+          "<#{self.class}:#{object_id} type: #{type}>"
+        end
+
+        # This module implements the flow control API for the V93K
+        module FlowControlAPI
+          def enable
+            @enable
+          end
+
+          def enable=(val)
+            @enable = val
+          end
+          alias_method :if_enable=, :enable=
+          alias_method :if_enabled=, :enable=
+          alias_method :enabled=, :enable=
+
+          def unless_enable
+            @unless_enable
+          end
+
+          def unless_enable=(val)
+            @unless_enable = val
+          end
+          alias_method :unless_enabled=, :unless_enable=
+
+          def if_jobs
+            @if_jobs ||= []
+          end
+
+          def unless_jobs
+            @unless_jobs ||= []
+          end
+
+          def if_job=(jobs)
+            [jobs].flatten.compact.each do |job|
+              job = job.to_s.upcase
+              if_jobs << job unless if_jobs.include?(job)
+            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=
+
+          # Run the test only if the given flow variable is true
+          def flag_true=(var)
+            c = "@#{var.to_s.upcase} == 1"
+            if type == :if_then && condition == :skip
+              self.condition = c
+              self
+            else
+              node = FlowNode.create(flow, :if_then)
+              node.parent = parent
+              node.condition = c
+              node.nodes << self
+              # Replace self in the main flow with the conditional node (which includes self
+              # in its parent collection)
+              parent[parent.index(self)] = node
+              flow.replace_relationship_dependent(self, node)
+            end
+          end
+
+          # Run the test unless the given flow variable is true
+          def flag_clear=(var)
+            c = "@#{var.to_s.upcase} != 1"
+            if type == :if_then && condition == :skip
+              self.condition = c
+              self
+            else
+              node = FlowNode.create(flow, :if_then)
+              node.parent = parent
+              node.condition = c
+              node.nodes << self
+              # Replace self in the main flow with the conditional node (which includes self
+              # in its parent collection)
+              parent[parent.index(self)] = node
+              flow.replace_relationship_dependent(self, node)
+            end
+          end
+
+          def continue_on_fail
+            if group? || if_then?
+              nodes.reject! do |n|
+                if n.bin?
+                  n.deleted = true
+                  parent.delete(n)
+                  true
+                end
+              end
+              nodes.each { |n| n.continue_on_fail if n.test? || n.if_then? }
+              if if_then?
+                else_nodes.reject! do |n|
+                  if n.bin?
+                    n.deleted = true
+                    parent.delete(n)
+                    true
+                  end
+                end
+                else_nodes.each { |n| n.continue_on_fail if n.test? || n.if_then? }
+              end
+            else
+              else_nodes.reject! do |n|
+                if n.bin?
+                  n.deleted = true
+                  parent.delete(n)
+                  true
+                end
+              end
+            end
+          end
+
+          def set_flag_on_fail(id = id)
+            var = "#{id}_FAILED"
+            if group?
+              nodes.each { |n| n.set_flag_on_fail(id) if n.test? || n.if_then? }
+            elsif if_then?
+              nodes.each { |n| n.set_flag_on_fail(id) if n.test? || n.if_then? }
+              else_nodes.each { |n| n.set_flag_on_fail(id) if n.test? || n.if_then? }
+            else
+              @fail_flags_set ||= []
+              unless @fail_flags_set.include?(var)
+                flow.flow_control_variables << var
+                else_nodes << flow.assign_value(var, 1)
+                @fail_flags_set << var
+              end
+            end
+            var
+          end
+
+          def set_flag_on_pass(id = id)
+            var = "#{id}_PASSED"
+            if group?
+              nodes.each { |n| n.set_flag_on_pass(id) if n.test? || n.if_then? }
+            elsif if_then?
+              nodes.each { |n| n.set_flag_on_pass(id) if n.test? || n.if_then? }
+              else_nodes.each { |n| n.set_flag_on_pass(id) if n.test? || n.if_then? }
+            else
+              @pass_flags_set ||= []
+              unless @pass_flags_set.include?(var)
+                flow.flow_control_variables << var
+                nodes << flow.assign_value(var, 1)
+                @pass_flags_set << var
+              end
+            end
+            var
+          end
+
+          def set_flag_on_ran(id = id)
+            var = "#{id}_RAN"
+            if group?
+              nodes.each { |n| n.set_flag_on_ran(id) if n.test? }
+            else
+              @ran_flags_set ||= []
+              unless @ran_flags_set.include?(var)
+                flow.flow_control_variables << var
+                nodes << flow.assign_value(var, 1)
+                else_nodes << flow.assign_value(var, 1)
+                @ran_flags_set << var
+              end
+            end
+            var
+          end
+
+          def run_if_all_passed(parent)
+          end
+
+          def run_if_any_passed(parent)
+          end
+
+          def run_if_all_failed(parent)
+          end
+
+          def run_if_any_failed(parent)
+          end
+        end
+        include FlowControlAPI
+
+        def empty?
+          return false if type == :run
+          if respond_to?(:nodes)
+            nodes.each { |n| return false unless n.deleted? || n.rendered? || n.empty? }
+            if respond_to?(:else_nodes)
+              else_nodes.each { |n| return false unless n.deleted? || n.rendered? || n.empty? }
+            end
+            true
+          end
+        end
+
+        def lines(options = {})
+          return [] if empty?
+          # Convert Run nodes to Run and Branch as required
+          if type == :run && (!nodes.empty? || !else_nodes.empty?)
+            self.type = :run_and_branch
+          end
+          case type
+          when :good_bin, :bad_bin
+            l = ["stop_bin \"#{soft_bin || bin}\", \"#{soft_bin_desc}\", , #{bin_type}, #{reprobe ? 'reprobe' : 'noreprobe'}, #{color}, #{bin}, #{overon ? 'over_on' : 'not_over_on'};"]
+          when :print
+            l = ["print(\"#{value}\");"]
+          when :print_to_datalog
+            l = ["print_dl(\"#{value}\");"]
+          when :run
+            l = ["run(#{test_suite.name});"]
+          when :run_and_branch
+            l = [
+              "run_and_branch(#{test_suite.name})",
+              'then',
+              '{'
+            ]
+            nodes.each do |node|
+              l << node.lines(indent: 3) unless node.rendered
+              node.rendered = true
+            end
+            l += [
+              '}',
+              'else',
+              '{'
+            ]
+            else_nodes.each do |node|
+              l << node.lines(indent: 3) unless node.rendered
+              node.rendered = true
+            end
+            l << '}'
+            l.flatten!
+
+          when :if_then
+            c = condition == :skip ? '1' : condition
+            l = [
+              "if #{c} then",
+              '{'
+            ]
+            nodes.each do |node|
+              l << node.lines(indent: 3) unless node.rendered
+              node.rendered = true
+            end
+            l += [
+              '}',
+              'else',
+              '{'
+            ]
+            else_nodes.each do |node|
+              l << node.lines(indent: 3) unless node.rendered
+              node.rendered = true
+            end
+            l << '}'
+            l.flatten!
+
+          when :group
+            l = ['{']
+            nodes.each do |node|
+              l << node.lines(indent: 3) unless node.rendered
+              node.rendered = true
+            end
+            l << "}, #{bypass ? 'groupbypass, ' : ''}open,\"#{name}\", \"#{comment}\""
+            l.flatten!
+          when :assign_value
+            l = ["@#{variable.to_s.upcase} = #{value};"]
+          else
+            fail "Don't know how to render: #{type}"
+          end
+          if options[:indent]
+            l.map! { |line| (' ' * options[:indent]) + line }
+          end
+          l
+        end
+
+        def finalize(options = {})
+          case type
+          when :good_bin, :bad_bin
+            if bin && bin_desc
+              flow.hardware_bin_descriptions[bin] = bin_desc
+            end
+          end
+
+          # Implement job/enable branches
+          unless if_jobs.empty?
+            condition = if_jobs.map { |j| "@JOB == \"#{j}\"" }.join(' or ')
+            node = FlowNode.create(flow, :if_then)
+            node.parent = parent
+            node.condition = condition
+            node.nodes << self
+            parent[parent.index(self)] = node
+            self.parent = node.nodes
+          end
+          unless unless_jobs.empty?
+            condition = unless_jobs.map { |j| "@JOB != \"#{j}\"" }.join(' and ')
+            node = FlowNode.create(flow, :if_then)
+            node.parent = parent
+            node.condition = condition
+            node.nodes << self
+            parent[parent.index(self)] = node
+            self.parent = node.nodes
+          end
+          if enable
+            condition = "@#{enable.to_s.upcase} == 1"
+            node = FlowNode.create(flow, :if_then)
+            node.parent = parent
+            node.condition = condition
+            node.nodes << self
+            parent[parent.index(self)] = node
+            self.parent = node.nodes
+          end
+          if unless_enable
+            condition = "@#{unless_enable.to_s.upcase} == 1"
+            node = FlowNode.create(flow, :if_then)
+            node.parent = parent
+            node.condition = condition
+            node.else_nodes << self
+            parent[parent.index(self)] = node
+            self.parent = node.else_nodes
+          end
+        end
+
+        def group?
+          type == :group
+        end
+
+        def test?
+          [:run, :run_and_branch].include?(@type)
+        end
+
+        def if_then?
+          type == :if_then
+        end
+
+        def bin?
+          [:stop_bin, :bad_bin].include?(@type)
+        end
+
+        def self.platform
+          Origen.interface.platform
+        end
+
+        def platform
+          self.class.platform
+        end
+      end
+    end
+  end
+end