origen_testers 0.53.0 → 0.54.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd70a31c286817288ecefd2da59f6e353a7352e68b7fda835d003863bb31b335
-  data.tar.gz: 15a7415efb5843bf6de77749d322fe58d83c90ed7d6f33a55493b720602f53b1
+  metadata.gz: 38a51e599ac6dfccc090e03554f2931094af5834be2b72a9ea64a3a1b3f5f013
+  data.tar.gz: d0355b74097a788f4f9255f02d795f676e31c63698b13d2e03e3abb322e89d91
 SHA512:
-  metadata.gz: b63efbe6a34c23da197eb95b35631b37fe143b4a998c391a920acf6edd664eff512de5241915cd491578ae869f8d721bd7be4be4e51580037e5a0a7b83e5862a
-  data.tar.gz: 9992f1ee5387bcef67571ae85b59aedb20578d98fa7218f7c36a1281e35aba80571288d861405ae3f2936b2d6f4f7f1e64c405ce75feeec2295936c152097c67
+  metadata.gz: 7132a0000a8fff568498a299ac9e5de0cf9258be9fd5a3a5c0980a11ff89e6f0ddb9af44270016c876da8d6ae085e844b018f95d140ed8e986ab1f7a4ca94d3c
+  data.tar.gz: 239b6fc0eedaf76e12115c3cb541f3a079f863a5740c72ad7b72efff3801b8deaedd8ccb1352e8c34f3ff8a8eaa074215b72e46c29cca8290b89fd6cbf96812d

data/config/version.rb

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

data/lib/origen_testers/flow.rb

@@ -203,23 +203,16 @@ module OrigenTesters
     alias_method :signature, :sig
 
     def active_description
-      flow_file = OrigenTesters::Flow.callstack.last
-      called_from = caller.find { |l| l =~ /^#{flow_file}:.*/ }
-      # Windows fix - prevent the drive letter in the file name from changing the index of the line_no below
-      called_from.gsub!(flow_file, '')
+      line_no = active_flow_source_line
       desc = nil
-      if called_from
-        called_from = called_from.split(':')
-        line_no = called_from[1].to_i
+      if line_no
         ht_coms = OrigenTesters::Flow.ht_comments
         cc_coms = OrigenTesters::Flow.cc_comments
-        if line_no
-          if ht_coms[line_no]
-            desc = ht_coms[line_no].join(' ')
-          end
-          if cc_coms[line_no] && cc_coms[line_no].first
-            desc = [cc_coms[line_no].shift].join(' ')
-          end
+        if ht_coms[line_no]
+          desc = ht_coms[line_no].join(' ')
+        end
+        if cc_coms[line_no] && cc_coms[line_no].first
+          desc = [cc_coms[line_no].shift].join(' ')
         end
       end
       desc
@@ -256,14 +249,23 @@ module OrigenTesters
     # to the generated node
     def add_meta!(options)
       flow_file = OrigenTesters::Flow.callstack.last
-      called_from = caller.find { |l| l =~ /^#{flow_file}:.*/ }
-      if called_from
-        # Splitting on ':' when file names are included will yield a different index for everything in Windows
-        called_from.gsub!(flow_file, '')
-        called_from = called_from.split(':')
-        options[:source_file] = flow_file # called_from[0]
-        options[:source_line_number] = called_from[1].to_i
+      if line_no = active_flow_source_line
+        options[:source_file] = flow_file
+        options[:source_line_number] = line_no
+      end
+    end
+
+    # Find the application flow frame without materializing and parsing the full
+    # caller stack as strings. This runs for every generated flow node.
+    def active_flow_source_line
+      flow_file = OrigenTesters::Flow.callstack.last
+      return unless flow_file
+
+      flow_file = flow_file.to_s
+      location = caller_locations.find do |frame|
+        frame.path == flow_file || frame.absolute_path == flow_file
       end
+      location.lineno if location
     end
 
     # This gets called by ATP for all flow generation methods to add the description information

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

@@ -33,6 +33,14 @@ module OrigenTesters
           tester.smt8?
         end
 
+        def qualified_name
+          @qualified_name ||= if parent
+                                "#{parent.qualified_name}.#{name}"
+                              else
+                                name.to_s
+                              end
+        end
+
         def var_filename # rubocop:disable Lint/DuplicateMethods
           @var_filename || 'global'
         end

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

@@ -4,6 +4,22 @@ module OrigenTesters
       class TestMethod
         FORMAT_TYPES = [:current, :voltage, :time, :frequency, :string, :integer, :double, :boolean, :class, :list_strings, :list_classes]
 
+        def self.parameter_sort_keys
+          @@parameter_sort_keys ||= {}
+        end
+
+        def self.installed_dynamic_methods
+          @installed_dynamic_methods ||= {}
+        end
+
+        def self.underscored_parameter_names
+          @@underscored_parameter_names ||= {}
+        end
+
+        def self.underscore_parameter_name(name)
+          underscored_parameter_names[name] ||= name.underscore
+        end
+
         # Returns the object representing the test method library that the
         # given test method is defined in
         attr_reader :library
@@ -38,8 +54,11 @@ module OrigenTesters
               unless method_name == :finalize
                 var_name = "@#{method_name}".gsub(/=|\?/, '_')
                 instance_variable_set(var_name, function)
-                define_singleton_method method_name do |*args|
-                  instance_variable_get(var_name).call(self, *args)
+                unless self.class.installed_dynamic_methods[method_name]
+                  self.class.send(:define_method, method_name) do |*args|
+                    instance_variable_get(var_name).call(self, *args)
+                  end
+                  self.class.installed_dynamic_methods[method_name] = true
                 end
               end
             end
@@ -54,19 +73,28 @@ module OrigenTesters
               allowed = type_default[2]
               @parameters[attr] = type
               aliases = [clean_attr]
-              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
+              underscored_attr = self.class.underscore_parameter_name(clean_attr)
+              aliases << underscored_attr if underscored_attr != clean_attr
               aliases.each do |alias_|
-                define_singleton_method("#{alias_}=") do |v|
-                  v = v.to_s if v.is_a?(Symbol)
-                  if allowed
-                    unless allowed.include?(v)
-                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
+                setter = :"#{alias_}="
+                unless self.class.installed_dynamic_methods[setter]
+                  self.class.send(:define_method, setter) do |v|
+                    v = v.to_s if v.is_a?(Symbol)
+                    if allowed
+                      unless allowed.include?(v)
+                        fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
+                      end
                     end
+                    instance_variable_set("@#{clean_attr}", v)
                   end
-                  instance_variable_set("@#{clean_attr}", v)
+                  self.class.installed_dynamic_methods[setter] = true
                 end
-                define_singleton_method(alias_) do
-                  instance_variable_get("@#{clean_attr}")
+                alias_name = alias_.to_sym
+                unless self.class.installed_dynamic_methods[alias_name]
+                  self.class.send(:define_method, alias_name) do
+                    instance_variable_get("@#{clean_attr}")
+                  end
+                  self.class.installed_dynamic_methods[alias_name] = true
                 end
               end
               send("#{clean_attr}=", default)
@@ -75,11 +103,19 @@ module OrigenTesters
           if options[:methods][:aliases]
             options[:methods][:aliases].each do |alias_, attr|
               clean_attr = clean_attr_name(attr)
-              define_singleton_method("#{alias_}=") do |v|
-                send("#{clean_attr}=", v)
+              setter = :"#{alias_}="
+              unless self.class.installed_dynamic_methods[setter]
+                self.class.send(:define_method, setter) do |v|
+                  send("#{clean_attr}=", v)
+                end
+                self.class.installed_dynamic_methods[setter] = true
               end
-              define_singleton_method(alias_) do
-                send(clean_attr)
+              alias_name = alias_.to_sym
+              unless self.class.installed_dynamic_methods[alias_name]
+                self.class.send(:define_method, alias_name) do
+                  send(clean_attr)
+                end
+                self.class.installed_dynamic_methods[alias_name] = true
               end
             end
           end
@@ -89,7 +125,7 @@ module OrigenTesters
             if respond_to?(accessor)
               send(accessor, v)
             else
-              accessor = "#{k.to_s.underscore}="
+              accessor = "#{self.class.underscore_parameter_name(k.to_s)}="
               send(accessor, v) if respond_to?(accessor)
             end
           end
@@ -192,15 +228,13 @@ module OrigenTesters
 
         def sorted_parameters
           @parameters.sort_by do |name|
-            if name.is_a?(String)
-              name
-            else
-              if name.to_s[0] == '_'
-                name.to_s.camelize(:upper)
-              else
-                name.to_s.camelize(:lower)
-              end
-            end
+            self.class.parameter_sort_keys[name] ||= if name.is_a?(String)
+                                                       name
+                                                     elsif name.to_s[0] == '_'
+                                                       name.to_s.camelize(:upper)
+                                                     else
+                                                       name.to_s.camelize(:lower)
+                                                     end
           end
         end
 

data/lib/origen_testers/smartest_based_tester/base/test_methods/base_tml.rb

@@ -4,6 +4,10 @@ module OrigenTesters
       class TestMethods
         # Base class of all test method libraries
         class BaseTml
+          def self.test_method_classes
+            @test_method_classes ||= {}
+          end
+
           # Returns the test_methods object for the current flow
           attr_reader :test_methods
 
@@ -35,10 +39,20 @@ module OrigenTesters
           private
 
           def instantiate_test_method(method, args)
-            m = platform::TestMethod.new methods: definitions[method].dup,
-                                         attrs:   (args.first || {}),
-                                         type:    method,
-                                         library: self
+            definition = definitions[method]
+            base_class = platform::TestMethod
+            cache_key = [base_class, definition.object_id]
+            klass = BaseTml.test_method_classes[cache_key] ||= begin
+              generated_class = Class.new(base_class)
+              # Retain the definition so its object ID cannot be recycled while
+              # this generated class remains cached.
+              generated_class.instance_variable_set(:@test_method_definition, definition)
+              generated_class
+            end
+            m = klass.new methods: definition.dup,
+                          attrs:   (args.first || {}),
+                          type:    method,
+                          library: self
             test_methods.add(m)
             m
           end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/test_suite.rb

@@ -87,22 +87,23 @@ module OrigenTesters
             unless name.is_a?(String)
               name = name.to_s[0] == '_' ? name.to_s.camelize(:upper) : name.to_s.camelize(:lower)
             end
+            formatted_value = test_method.format(param.last.is_a?(Hash) ? name : param[0])
             if param.last.is_a? Hash
-              if !test_method.format(name).nil? && !test_method.format(name).is_a?(Hash)
-                fail "#{name} parameter structure requires a Hash but value provided is #{test_method.format(name).class}"
-              elsif test_method.format(name).nil? && tester.print_all_params
+              if !formatted_value.nil? && !formatted_value.is_a?(Hash)
+                fail "#{name} parameter structure requires a Hash but value provided is #{formatted_value.class}"
+              elsif formatted_value.nil? && tester.print_all_params
                 l = add_nested_params(l, name, 'param0', {}, param.last, 1)
-              elsif test_method.format(name).nil?
+              elsif formatted_value.nil?
                 # Do nothing
               else
-                test_method.format(name).each do |key, meta_hash|
+                formatted_value.each do |key, meta_hash|
                   l = add_nested_params(l, name, key, meta_hash, param.last, 1)
                 end
               end
-            elsif NO_STRING_TYPES.include?(param.last) && test_method.format(param[0]).is_a?(String) && !test_method.format(param[0]).empty?
-              l << "    #{name} = #{test_method.format(param[0])};"
+            elsif NO_STRING_TYPES.include?(param.last) && formatted_value.is_a?(String) && !formatted_value.empty?
+              l << "    #{name} = #{formatted_value};"
             else
-              l << "    #{name} = #{wrap_if_string(test_method.format(param[0]))};"
+              l << "    #{name} = #{wrap_if_string(formatted_value)};"
             end
           end
           l << '}'
@@ -111,8 +112,8 @@ module OrigenTesters
 
         # rubocop:disable Metrics/ParameterLists: Avoid parameter lists longer than 5 parameters.
         def add_nested_params(l, name, key, value_hash, nested_params, nested_loop_count)
-          nested_params_accepted_keys = []
-          skip_keys                   = []
+          nested_params_accepted_keys = {}
+          skip_keys = {}
           unless value_hash.nil?
             unless value_hash.is_a?(Hash)
               fail "Provided value to nested params was not a Hash. Instead the value was #{value_hash.class}"
@@ -120,14 +121,16 @@ module OrigenTesters
 
             dynamic_spacing = ' ' * (4 * nested_loop_count)
             l << "#{dynamic_spacing}#{name}[#{key}] = {" unless name.nil?
+            # Normalize once per hash rather than once per accepted parameter.
+            value_hash = value_hash.transform_keys(&:to_sym)
+            @nested_parameter_keys ||= {}
             nested_params.each do |nested_param|
-              # Guarentee hash is using all symbol keys
-              # Since we cannot guarentee ruby version is greater than 2.5, we have to use an older syntax to
-              value_hash = value_hash.transform_keys(&:to_sym)
-              nested_key = nested_param.first.to_s.gsub('.', '_').to_sym
-              nested_key_underscore = nested_key.to_s.underscore.to_sym
-              nested_params_accepted_keys << nested_key
-              nested_params_accepted_keys << nested_key_underscore
+              nested_key, nested_key_underscore = @nested_parameter_keys[nested_param.first] ||= begin
+                key_name = nested_param.first.to_s.gsub('.', '_').to_sym
+                [key_name, key_name.to_s.underscore.to_sym]
+              end
+              nested_params_accepted_keys[nested_key] = true
+              nested_params_accepted_keys[nested_key_underscore] = true
               # We cannot create nested member functions with aliases
               # Requirement for hash parameter passing is to pass one of the key types and not both
               if value_hash.keys.include?(nested_key) &&
@@ -139,26 +142,26 @@ module OrigenTesters
               if nested_param.last.first.is_a?(Hash) && value_hash[nested_key].is_a?(Hash)
                 value_hash[nested_key].each do |inner_key, inner_meta_hash|
                   l = add_nested_params(l, nested_param.first, inner_key, value_hash.dig(nested_key, inner_key), nested_param.last.first, nested_loop_count + 1)
-                  skip_keys << nested_key
+                  skip_keys[nested_key] = true
                 end
               elsif nested_param.last.first.is_a?(Hash) && tester.print_all_params
                 l = add_nested_params(l, nested_param.first, 'param0', {}, nested_param.last.first, nested_loop_count + 1)
               end
               type = nested_param.last.first
-              if NO_STRING_TYPES.include?(nested_param.last.first) && value_hash[nested_key] && !skip_keys.include?(nested_key)
+              if NO_STRING_TYPES.include?(nested_param.last.first) && value_hash[nested_key] && !skip_keys.key?(nested_key)
                 l << "    #{dynamic_spacing}#{nested_param.first} = #{test_method.handle_val_type(value_hash[nested_key], type, nested_param.first)};"
-              elsif value_hash[nested_key] && !skip_keys.include?(nested_key)
+              elsif value_hash[nested_key] && !skip_keys.key?(nested_key)
                 l << "    #{dynamic_spacing}#{nested_param.first} = #{wrap_if_string(test_method.handle_val_type(value_hash[nested_key], type, nested_param.first))};"
-              elsif NO_STRING_TYPES.include?(nested_param.last.first) && !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.include?(nested_key)
+              elsif NO_STRING_TYPES.include?(nested_param.last.first) && !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.key?(nested_key)
                 l << "    #{dynamic_spacing}#{nested_param.first} = #{test_method.handle_val_type(nested_param.last.last, type, nested_param.first)};"
-              elsif !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.include?(nested_key)
+              elsif !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.key?(nested_key)
                 l << "    #{dynamic_spacing}#{nested_param.first} = #{wrap_if_string(test_method.handle_val_type(nested_param.last.last, type, nested_param.first))};"
               end
             end
             l << "#{dynamic_spacing}};" unless name.nil?
             # Sanity check there are not overpassed parameters
             value_hash.keys.each do |nested_key|
-              unless nested_params_accepted_keys.include?(nested_key.to_sym)
+              unless nested_params_accepted_keys.key?(nested_key.to_sym)
                 fail "You provided a parameter \'#{nested_key}\' that was not an accepted parameter to the hash parameter \'#{name}\'"
               end
             end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.53.0
+  version: 0.54.0
 platform: ruby
 authors:
 - Stephen McGinty
 - Priyavadan Kumar
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dentaku
@@ -156,6 +157,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.24'
+description: 
 email:
 - stephen.f.mcginty@gmail.com
 - priyavadan@gmail.com
@@ -591,6 +593,7 @@ files:
 homepage: http://origen-sdk.org/testers
 licenses: []
 metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -605,7 +608,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: This plugin provides Origen tester models to drive ATE type testers like
   the J750, UltraFLEX, V93K,...