origen 0.0.1 → 0.0.2

data/lib/origen/tester/v93k/generator/flow.rb

@@ -0,0 +1,63 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class Flow
+          include Origen::Tester::Generator
+
+          attr_accessor :test_functions, :test_suites, :test_methods
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/v93k/generator/templates/template.flow.erb"
+
+          def filename
+            super.gsub('_flow', '')
+          end
+
+          def run(test_suite, options = {})
+            add(:run, { test_suite: test_suite }.merge(options))
+          end
+
+          def run_and_branch(test_suite, options = {})
+            add(:run_and_branch, { test_suite: test_suite }.merge(options))
+          end
+
+          private
+
+          def add(type, options = {})
+            options = update_relationships(options)
+            ins = FlowLine.new(type, options)
+            collection << ins
+            if ins.test?
+              c = Origen.interface.consume_comments
+              Origen.interface.descriptions.add_for_test_usage(ins.parameter, Origen.interface.top_level_flow, c)
+            else
+              Origen.interface.discard_comments
+            end
+            ins
+          end
+
+          def update_relationships(options = {})
+            fail_id = options.delete(:if_failed)
+            pass_id = options.delete(:if_passed)
+            if fail_id
+              t = find_by_id(fail_id)
+              t.continue_on_fail
+              flag = t.set_flag_on_fail
+              options[:flag_true] = flag
+            elsif pass_id
+              t = find_by_id(pass_id)
+              t.continue_on_fail
+              flag = t.set_flag_on_pass
+              options[:flag_true] = flag
+            end
+            options
+          end
+
+          def find_by_id(id)
+            collection.find { |l| l.id == id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/flow_node/print.rb

@@ -0,0 +1,10 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class Print < FlowNode
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/flow_node.rb

@@ -0,0 +1,17 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class FlowNode
+          autoload :Run,  'origen/tester/v93k/generator/flow_node/run'
+          autoload :RunAndBranch,  'origen/tester/v93k/generator/flow_node/run_and_branch'
+          autoload :StopBin,  'origen/tester/v93k/generator/flow_node/stop_bin'
+
+          def collection
+            @collection ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/pattern.rb

@@ -0,0 +1,16 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class Pattern
+          attr_accessor :name
+
+          def initialize(name, _options = {})
+            self.name = name
+            Origen.interface.referenced_patterns << name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/pattern_master.rb

@@ -0,0 +1,54 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class PatternMaster
+          include Origen::Tester::Generator
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/v93k/generator/templates/template.pmfl.erb"
+
+          def add(name, options = {})
+            check_for_duplicates(name)
+            record_pattern(name)
+            p = Pattern.new(name, options)
+            collection << p
+            p
+          end
+
+          # Returns true if the given pattern name has already been added to the current pattern
+          # master file.
+          #
+          # Pass in :global => true for all pattern sets sheets to be considered.
+          def duplicate?(name, options = {})
+            files = existing_patterns[name]
+            if files && !files.empty?
+              options[:global] || files.include?(filename)
+            else
+              false
+            end
+          end
+
+          private
+
+          def check_for_duplicates(name)
+            if duplicate?(name)
+              error "Duplicate pattern #{name} generated in #{filename}"
+              exit 1
+            elsif duplicate?(name, global: true)
+              warning "Pattern #{name} is duplicated in: #{existing_patterns[name].join(', ')}"
+            end
+          end
+
+          def existing_patterns
+            @@existing_patterns ||= {}
+          end
+
+          def record_pattern(name)
+            existing_patterns[name] ||= []
+            existing_patterns[name] << filename
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/templates/_test_method.txt.erb

@@ -0,0 +1,6 @@
+% tm = options[:test_method]
+<%= tm.name %>:
+testmethod_class = "<%= tm.klass %>";
+testmethod_name = "<%= tm.method_name %>";
+testmethod_parameters = "<%= tm.parameters %>";
+testmethod_limits = "<%= tm.limits %>";

data/lib/origen/tester/v93k/generator/templates/_test_suite.txt.erb

@@ -0,0 +1,11 @@
+% suite = options[:suite]
+<%= suite.name %>:
+override_tim_equ_set = <%= suite.tim_equ_set %>;
+override_lev_equ_set = <%= suite.lev_equ_set %>;
+override_tim_spec_set = <%= suite.tim_spec_set %>;
+override_lev_spec_set = <%= suite.lev_spec_set %>;
+override_timset = <%= suite.timset %>;
+override_levset = <%= suite.levset %>;
+override_seqlbl = "<%= suite.pattern %>";
+override_testf = <%= suite.test_function %>;
+override_test_number = <%= suite.test_number %>;

data/lib/origen/tester/v93k/generator/templates/template.flow.erb

@@ -0,0 +1,121 @@
+hp93000,testflow,0.1
+language_revision = 1;
+ 
+information
+ 
+device_name = "Apache";
+ 
+device_revision = "0";
+ 
+test_revision = "<%= RGen.app.version %>";
+ 
+description = "";
+ 
+end
+--------------------------------------------------
+declarations
+ 
+end
+--------------------------------------------------
+flags
+
+-- System flags
+  report_to_file = 1;
+  report_to_printer = 0;
+  datalog_to_file = 1;
+  datalog_to_printer = 0;
+  datalog_to_report_win = 0;
+  datalog_formatter = 0;
+  datalog_sample_size = 1;
+  graphic_result_displa = 1;
+  state_display = 0;
+  print_wafermap = 0;
+  OOC_watch = 1;
+  OOC_sample_size = 1;
+  ink_wafer = 0;
+  max_reprobes = 1;
+  temp_monitor = 1;
+  calib_age_monitor = 1;
+  diag_monitor = 1;
+  current_monitor = 1;
+-- Testflow flags
+  set_pass_level = 0;
+  set_fail_level = 0;
+  set_bypass_level = 0;
+  hold_on_fail = 0;
+  optimized_mode = 1;
+  global_hold = 0;
+  debug_mode = 0;
+  parallel_mode = 1;
+  global_overon = 0;
+
+end
+--------------------------------------------------
+testfunctions
+
+% test_functions.collection.each do |key, func|
+%   func.lines.each do |line|
+<%= line %>
+%   end
+% end
+
+end
+--------------------------------------------------
+testmethods
+
+% test_methods.collection.each do |name, method|
+<%= render "#{RGen.top}/lib/rgen/tester/v93k/generator/templates/test_method.txt.erb", :test_method => method, :_inline => true %>
+% end
+
+end
+--------------------------------------------------
+test_suites
+
+% test_suites.collection.each do |suite|
+<%= render "#{RGen.top}/lib/rgen/tester/v93k/generator/templates/test_suite.txt.erb", :suite => suite, :_inline => true %>
+
+% end
+
+end
+--------------------------------------------------
+test_flow
+ 
+run_and_branch(Continuity) then
+{
+}
+else
+{
+stop_bin "AA", "Continuity failed", , bad,noreprobe,red, ,over_on;
+}
+run_and_branch(Basic_functional_tes) then
+{
+}
+else
+{
+stop_bin "BB", "Basic functional test failed", ,bad,noreprobe,red, ,over_on;
+}
+stop_bin "OK", "Everything went fine", , good,noreprobe,
+green, , over_on;
+end
+-------------------------------------------------
+binning
+ 
+otherwise bin = "db", "", , bad,noreprobe,red, , not_over_on;
+end
+-------------------------------------------------
+oocrule
+ 
+ 
+end
+-------------------------------------------------
+context
+ 
+context_config_file = "74145";
+context_levels_file = "LowPower";
+context_timing_file = "Fast";
+context_vector_file = "74145";
+context_attrib_file = "";
+context_mixsgl_file = "";
+ 
+end
+--------------------------------------------------

data/lib/origen/tester/v93k/generator/templates/template.pmfl.erb

@@ -0,0 +1,9 @@
+hp93000,pattern_master_file,0.1
+
+path:
+../vectors/
+
+files:
+% collection.each do |pattern|
+<%= pattern.name %>
+% end

data/lib/origen/tester/v93k/generator/test_function.rb

@@ -0,0 +1,103 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class TestFunction
+          attr_accessor :name, :type, :description
+
+          # When defining attributes of a given test function here they must be defined
+          # in the correct order
+          ATTRS = {
+
+            functional:  [],
+
+            general_pmu: %w(pins force_units force clamp_units clamp precharge_units precharge
+                            pass_min_units pass_min pass_max_units pass_max settling_time_units
+                            settling_time test_system_state term output_string mode
+                         )
+
+          }
+
+          ALIASES = {
+            desc:        :description,
+
+            general_pmu: {
+              state: :test_system_state
+            }
+          }
+
+          DEFAULTS = {
+            description: 'A test function generated by Origen'
+          }
+
+          # Define the common aliases now, the instance type specific ones will
+          # be created when the instance type is known
+          ALIASES.each do |_alias, val|
+            if val.is_a? Hash
+            else
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+              define_method("#{_alias}") do
+                send(val)
+              end
+            end
+          end
+
+          def initialize(name, type, attrs = {})
+            @type = type
+            self.name = name
+            # Build the type specific attribute accessors
+            ATTRS[@type.to_sym].each do |method|
+              define_singleton_method("#{method}=") do |v|
+                instance_variable_set("@#{method}".to_sym, v)
+              end
+              define_singleton_method("#{method}") do
+                instance_variable_get("@#{method}".to_sym)
+              end
+            end
+            # Build the type specific accessors (aliases)
+            if ALIASES[@type.to_sym]
+              ALIASES[@type.to_sym].each do |_alias, val|
+                define_singleton_method("#{_alias}=") do |v|
+                  send("#{val}=", v)
+                end
+                define_singleton_method("#{_alias}") do
+                  send(val)
+                end
+              end
+            end
+            # Set the defaults
+            DEFAULTS.each do |key, val|
+              send("#{key}=", val) unless val.is_a?(Hash)
+            end
+            if DEFAULTS[@type.to_sym]
+              DEFAULTS[@type.to_sym].each do |k, v|
+                send("#{k}=", v)
+              end
+            end
+            # Then the values that have been supplied
+            attrs.each do |k, v|
+              m = "#{k}="
+              send(m, v) if self.respond_to?(m)
+            end
+          end
+
+          # Returns the fully formatted lines (an array) that should be inserted into a flow
+          # sheet to include this test function
+          def lines
+            [
+              "#{name}:",
+              "testfunction_description = \"#{description}\";",
+              "testfunction_parameters = \"#{type};#{parameter_string}\";"
+            ]
+          end
+
+          def parameter_string
+            ATTRS[@type.to_sym].map { |attr| send(attr) }.compact.join(';')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/test_functions.rb

@@ -0,0 +1,79 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class TestFunctions
+          # Origen::Tester::Generator not included since test functions do not have their
+          # own top-level sheet, they will be incorporated within the flow sheet
+
+          attr_accessor :flow, :collection
+
+          def initialize(flow)
+            @flow = flow
+            @collection = {}
+            @ix = 0
+          end
+
+          def filename
+            flow.filename
+          end
+
+          def add(name, type, options = {})
+            check_for_duplicates(name)
+            record_test_function(name)
+            func = TestFunction.new(next_name, type, options)
+            @collection[name] = func
+            # c = Origen.interface.consume_comments
+            # Origen.interface.descriptions.add_for_test_definition(name, c)
+            func
+          end
+
+          def functional(name, options = {})
+            add(name, :functional, options)
+          end
+
+          def [](name)
+            @collection[name]
+          end
+
+          # Returns true if the given test function name has already been added to the current flow.
+          #
+          # Pass in :global => true for all test flows to be considered.
+          def duplicate?(name, options = {})
+            files = existing_test_functions[name]
+            if files && !files.empty?
+              options[:global] || files.include?(filename)
+            else
+              false
+            end
+          end
+
+          private
+
+          def next_name
+            @ix += 1
+            "tf_#{@ix}"
+          end
+
+          def check_for_duplicates(name)
+            if duplicate?(name)
+              error "Duplicate test function #{name} generated in #{filename}"
+              exit 1
+            elsif duplicate?(name, global: true)
+              warning "Test function #{name} is duplicated in: #{existing_test_functions[name].join(', ')}"
+            end
+          end
+
+          def existing_test_functions
+            @@existing_test_functions ||= {}
+          end
+
+          def record_test_function(name)
+            existing_test_functions[name] ||= []
+            existing_test_functions[name] << filename
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/test_method.rb

@@ -0,0 +1,46 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class TestMethod
+          ATTRS =
+            %w(name klass method_name parameters limits
+            )
+
+          ALIASES = {
+          }
+
+          DEFAULTS = {
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          # Define the aliases
+          ALIASES.each do |_alias, val|
+            define_method("#{_alias}=") do |v|
+              send("#{val}=", v)
+            end
+            define_method("#{_alias}") do
+              send(val)
+            end
+          end
+
+          def initialize(name, attrs = {})
+            self.name = name
+            # Set the defaults
+            DEFAULTS.each do |k, v|
+              send("#{k}=", v)
+            end
+            # Then the values that have been supplied
+            attrs.each do |k, v|
+              send("#{k}=", v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/test_methods.rb

@@ -0,0 +1,75 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        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
+
+          attr_accessor :flow, :collection
+
+          def initialize(flow)
+            @flow = flow
+            @collection = {}
+            @ix = 0
+          end
+
+          def filename
+            flow.filename
+          end
+
+          def add(name, _type, options = {})
+            check_for_duplicates(name)
+            record_test_method(name)
+            func = TestMethod.new(next_name, options)
+            @collection[name] = func
+            # c = Origen.interface.consume_comments
+            # Origen.interface.descriptions.add_for_test_definition(name, c)
+            func
+          end
+
+          def [](name)
+            @collection[name]
+          end
+
+          # Returns true if the given test method name has already been added to the current flow.
+          #
+          # Pass in :global => true for all test flows to be considered.
+          def duplicate?(name, options = {})
+            files = existing_test_methods[name]
+            if files && !files.empty?
+              options[:global] || files.include?(filename)
+            else
+              false
+            end
+          end
+
+          private
+
+          def next_name
+            @ix += 1
+            "tm_#{@ix}"
+          end
+
+          def check_for_duplicates(name)
+            if duplicate?(name)
+              error "Duplicate test method #{name} generated in #{filename}"
+              exit 1
+            elsif duplicate?(name, global: true)
+              warning "Test method #{name} is duplicated in: #{existing_test_methods[name].join(', ')}"
+            end
+          end
+
+          def existing_test_methods
+            @@existing_test_methods ||= {}
+          end
+
+          def record_test_method(name)
+            existing_test_methods[name] ||= []
+            existing_test_methods[name] << filename
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/v93k/generator/test_suite.rb

@@ -0,0 +1,54 @@
+module Origen
+  module Tester
+    class V93K
+      module Generator
+        class TestSuite
+          ATTRS =
+            %w(name tim_equ_set lev_equ_set tim_spec_set lev_spec_set timset levset
+               seqlbl testf test_number
+            )
+
+          ALIASES = {
+            pattern:        :seqlbl,
+            sequence_label: :seqlbl,
+            test_num:       :test_number,
+            test_function:  :testf,
+            levels:         :levset,
+            timeset:        :timset,
+            time_set:       :timset
+          }
+
+          DEFAULTS = {
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          # Define the aliases
+          ALIASES.each do |_alias, val|
+            define_method("#{_alias}=") do |v|
+              send("#{val}=", v)
+            end
+            define_method("#{_alias}") do
+              send(val)
+            end
+          end
+
+          def initialize(name, attrs = {})
+            self.name = name
+            # Set the defaults
+            DEFAULTS.each do |k, v|
+              send("#{k}=", v)
+            end
+            # Then the values that have been supplied
+            attrs.each do |k, v|
+              send("#{k}=", v)
+            end
+          end
+        end
+      end
+    end
+  end
+end