origen_testers 0.51.5 → 0.52.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a180bdac7bac206de7e54920fe663e70d1a2385d719a4a2ee134168856926142
-  data.tar.gz: 1882b6db742cdcb8f4a05a2a5f2d14c8bf0edcbee5e2ad65cff473a4a0ebefb7
+  metadata.gz: eb1671039082e3f1856ec1facd0861776bf7ed44b07be01103028a21e20962cc
+  data.tar.gz: a9855748f37e09b0f80d86c42c111c3577eec987e49336ad43b772fb267c8a36
 SHA512:
-  metadata.gz: 1dc6ab272a3770ee8351f0b1fad2d17cc41fa1a0abf5fe3df4f0d7caba4aea82551fe2719dae4bb676c2080af4c0327e12d2682afd288db50f5f9bbad44a392e
-  data.tar.gz: 1be16fa7b79f24afeb21d59713c66134917922d19a4534e611bc9a153cdf10911e3a96c9a066928a30db3850ee26084dd9655065d388f5bcdf9102f00cef778c
+  metadata.gz: b647195f53446e14b390662d93ebe7207aba5f8a90af089cad0e5368f0ee9f8347db00c7440ea497509b6b565067ddebf8b4e0e4e3f47a3f4f1d50e6aa16784b
+  data.tar.gz: 2ec5f3ed1581bdaac66f115c8f0950e0e965d40c7b369da6b3b16d405c7cddfd337fa5f9b088c7bbb54ee3d51166b5904a43aca8c2a1055c12170bb7bd451c10

data/config/commands.rb

@@ -200,7 +200,7 @@ when "examples", "test"
     puts
     puts "To approve any diffs in the reference.list files run the following command:"
     puts
-    platforms = %w(j750 j750_literals j750_hpt ultraflex ultraflex_literals v93k v93k_multiport v93k_enable_flow v93k_disable_flow v93k_limits_file v93k_global v93k_smt8) # put here the various platforms used in examples/program_generator.rb
+    platforms = %w(j750 j750_literals j750_hpt ultraflex ultraflex_literals v93k v93k_multiport v93k_enable_flow v93k_disable_flow v93k_limits_file v93k_global v93k_smt8 v93k_flowgrouping) # put here the various platforms used in examples/program_generator.rb
     reflist_command = ''
     platforms.each do |platform|
       unless reflist_command == ''

data/config/version.rb

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

data/lib/origen_testers/atp/flow.rb

@@ -479,6 +479,21 @@ module OrigenTesters::ATP
       end
     end
 
+    def add_auxiliary_flow(name, options = {})
+      if tester.smt8?
+        if name.to_s != options[:path].split('.').last.to_s
+          fail "Auxiliary flow path does not end in '#{name}'. The path instead is '#{options[:path]}'. Please update the path to align with the provided name."
+        end
+        extract_meta!(options) do
+          apply_conditions(options) do
+            n2(:auxiliary_flow, n1(:name, name), n1(:path, options[:path]))
+          end
+        end
+      else
+        fail 'Auxiliary flow API is only usable in SMT8.'
+      end
+    end
+
     def bin(number, options = {})
       if number.is_a?(Hash)
         fail 'The bin number must be passed as the first argument'
@@ -547,6 +562,22 @@ module OrigenTesters::ATP
       end
     end
 
+    def unset_flag(flag, options = {})
+      extract_meta!(options) do
+        apply_conditions(options) do
+          unset_flag_node(flag)
+        end
+      end
+    end
+
+    def add_flag(flag, options = {})
+      extract_meta!(options) do
+        apply_conditions(options) do
+          add_flag_node(flag)
+        end
+      end
+    end
+
     def set(var, val, options = {})
       extract_meta!(options) do
         apply_conditions(options) do
@@ -938,6 +969,14 @@ module OrigenTesters::ATP
       n1(:set_flag, flag)
     end
 
+    def unset_flag_node(flag)
+      n1(:unset_flag, flag)
+    end
+
+    def add_flag_node(flag)
+      n1(:add_flag, flag)
+    end
+
     # Ensures the flow ast has a volatile node, then adds the
     # given flags to it
     def add_volatile_flags(node, flags)

data/lib/origen_testers/atp/flow_api.rb

@@ -8,8 +8,8 @@ module OrigenTesters::ATP
       @atp
     end
 
-    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :add_global_flag, :set_flag, :set, :enable, :disable, :render,
-      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin, :loop] +
+    ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :add_global_flag, :set_flag, :unset_flag, :add_flag, :set, :enable, :disable, :render,
+      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin, :loop, :add_auxiliary_flow] +
       OrigenTesters::ATP::Flow::CONDITION_KEYS.keys + OrigenTesters::ATP::Flow::RELATIONAL_OPERATORS).each do |method|
       define_method method do |*args, &block|
         options = args.pop if args.last.is_a?(Hash)

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

@@ -50,7 +50,12 @@ module OrigenTesters
                 parents.unshift(File.basename(f.filename, '.*').to_s.downcase)
                 f = f.parent
               end
-              File.join tester.package_namespace, 'flows', *parents
+              # need to variablize this for internal usage!!
+              if Origen.interface.respond_to?(:insertion)
+                File.join tester.package_namespace, Origen.interface.insertion.to_s, 'flows', *parents
+              else
+                File.join tester.package_namespace, 'flows', *parents
+              end
             else
               'testflow/mfh.testflow.group'
             end
@@ -447,17 +452,26 @@ module OrigenTesters
 
         def on_whenever(node)
           expressions, *nodes = *node
-
+          and_string = ' and '
+          or_string  = ' or '
+          if smt8?
+            and_string = ' && '
+            or_string  = ' || '
+          end
           case node.type
           when :whenever_all
-            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' and ')
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(and_string)
           when :whenever_any
-            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(' or ')
+            condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join(or_string)
           else
             condition = expressions.map { |e| "#{generate_expr_string(e)}" }.join('ERROR')
           end
 
-          line "if #{condition} then"
+          if smt8?
+            line "if (#{condition})"
+          else
+            line "if #{condition} then"
+          end
           line '{'
           @indent += 1
           process_all(node.children)
@@ -471,13 +485,23 @@ module OrigenTesters
         alias_method :on_whenever_all, :on_whenever
 
         def on_loop(node, options = {})
-          # TODO: don't have the SMT8 way to do this yet
-          if smt8?
-            fail 'Flow loop control not yet supported for SMT8!'
-          end
           start = node.to_a[0]
+          if start.is_a?(String)
+            start = generate_flag_name(start)
+            unless smt8?
+              start = "@#{start}"
+            end
+          end
           stop = node.to_a[1]
+          if stop.is_a?(String) && smt8?
+            stop = generate_flag_name(stop)
+          elsif stop.is_a?(String)
+            fail 'loops with \'stop\' defined as a variable cannot be supported in the defined environments.'
+          end
           step = node.to_a[2]
+          if smt8? && !(step == -1 || step == 1)
+            fail 'SMT8 does not support steps other than -1 or 1.'
+          end
           if node.to_a[3].nil?
             fail 'You must supply a loop variable name!'
           else
@@ -487,7 +511,7 @@ module OrigenTesters
           unless smt8?
             var = "@#{var}"
           end
-          num = (stop - start) / step + 1
+          # num = (stop - start) / step + 1
           # Handle increment/decrement
           if step < 0
             compare = '>'
@@ -496,13 +520,24 @@ module OrigenTesters
             compare = '<'
             incdec = "+ #{step}"
           end
-          line "for #{var} = #{start}; #{var} #{compare} #{stop + step} ; #{var} = #{var} #{incdec}; do"
-          line "test_number_loop_increment = #{test_num_inc}"
-          line '{'
-          @indent += 1
-          process_all(node.children)
-          @indent -= 1
-          line '}'
+          if tester.smt7?
+            line "for #{var} = #{start}; #{var} #{compare} #{stop + step} ; #{var} = #{var} #{incdec}; do"
+            line "test_number_loop_increment = #{test_num_inc}"
+            line '{'
+            @indent += 1
+            process_all(node.children)
+            @indent -= 1
+            line '}'
+          elsif smt8?
+            line "for (#{var} : #{start}..#{stop})"
+            line '{'
+            @indent += 1
+            process_all(node.children)
+            @indent -= 1
+            line '}'
+          else
+            fail 'Environment was not supported for flow loops.'
+          end
         end
 
         def generate_expr_string(node, options = {})
@@ -614,6 +649,15 @@ module OrigenTesters
           end
         end
 
+        def on_unset_flag(node)
+          flag = generate_flag_name(node.value)
+          if smt8?
+            line "#{flag} = 0;"
+          else
+            line "@#{flag} = 0;"
+          end
+        end
+
         # Note that for smt8?, this should never be hit anymore since groups are now generated as sub-flows
         def on_group(node)
           on_fail = node.children.find { |n| n.try(:type) == :on_fail }

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

@@ -88,7 +88,11 @@ module OrigenTesters
           return flow_sheets[id] if flow_sheets[id] # will return flow if already existing
           p = platform::Flow.new
           p.inhibit_output if Origen.interface.resources_mode?
-          p.filename = filename
+          if id == Origen.file_handler.current_file.basename('.rb').to_s && Origen.interface.try(:use_flow_name_for_top_level)
+            p.filename = Origen.interface.flow_name
+          else
+            p.filename = filename
+          end
           p.test_suites ||= platform::TestSuites.new(p)
           p.test_methods ||= platform::TestMethods.new(p)
           flow_sheets[id] = p

data/lib/origen_testers/smartest_based_tester/base/processors/extract_flow_vars.rb

@@ -7,7 +7,8 @@ module OrigenTesters
         # and their default values
         class ExtractFlowVars < ATP::Processor
           OWNERS = [:all, :this_flow, :sub_flows]
-          CATEGORIES = [:jobs, :referenced_flags, :set_flags, :set_flags_extern,
+          CATEGORIES = [:jobs, :referenced_flags, :set_flags, :unset_flags, :add_flags,
+                        :set_flags_extern, :unset_flags_extern, :add_flags_extern,
                         :referenced_enables, :set_enables]
 
           def run(node, options = {})
@@ -72,6 +73,22 @@ module OrigenTesters
             end
           end
 
+          def on_unset_flag(node)
+            add generate_flag_name(node.value), :unset_flags
+            # Also separate flags which have been set and which should be externally visible
+            if !node.to_a.include?('auto_generated') || node.to_a.include?('extern')
+              add generate_flag_name(node.value), :unset_flags_extern
+            end
+          end
+
+          def on_add_flag(node)
+            add generate_flag_name(node.value), :add_flags
+            # Also separate flags which have been set and which should be externally visible
+            if !node.to_a.include?('auto_generated') || node.to_a.include?('extern')
+              add generate_flag_name(node.value), :add_flags_extern
+            end
+          end
+
           def on_if_enabled(node)
             flag, *nodes = *node
             [flag].flatten.each do |f|

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

@@ -2,7 +2,7 @@ module OrigenTesters
   module SmartestBasedTester
     class Base
       class TestMethod
-        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double, :boolean]
+        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double, :boolean, :class, :list_strings, :list_classes]
 
         # Returns the object representing the test method library that the
         # given test method is defined in
@@ -107,10 +107,20 @@ module OrigenTesters
               type = send(name)
             elsif respond_to?(name.sub(/b$/, ''))
               type = inverse_of(send(name.sub(/b$/, '')))
+            elsif parameters[attr].is_a?(Hash) || parameters[attr.to_sym].is_a?(Hash)
+              type = :hash
             else
               fail "Unknown attribute type: #{parameters[attr]}"
             end
           end
+          if val.nil? && !tester.print_all_params
+            nil
+          else
+            handle_val_type(val, type, attr)
+          end
+        end
+
+        def handle_val_type(val, type, attr)
           case type
           when :current, 'CURR'
             "#{val}[A]"
@@ -126,9 +136,9 @@ module OrigenTesters
             val
           when :boolean
             # Check for valid values
-            if [0, 1, true, false].include?(val)
+            if [0, 1, true, false, 'true', 'false'].include?(val)
               # Use true/false for smt8 and 0/1 for smt7
-              if [1, true].include?(val)
+              if [1, true, 'true'].include?(val)
                 tester.smt8? ? true : 1
               else
                 tester.smt8? ? false : 0
@@ -136,6 +146,18 @@ module OrigenTesters
             else
               fail "Unknown boolean value for attribute #{attr}: #{val}"
             end
+          when :hash, :class
+            val
+          when :list_strings
+            unless val.is_a?(Array)
+              fail "#{val} is not an Array. List_strings must have Array values"
+            end
+            "##{val}"
+          when :list_classes
+            unless val.is_a?(Array)
+              fail "#{val} is not an Array. List_classes must have Array values"
+            end
+            "##{val.to_s.gsub('"', '')}"
           else
             fail "Unknown type for attribute #{attr}: #{type}"
           end

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

@@ -48,7 +48,7 @@ module OrigenTesters
         # What SMT7 calls a declaration
         def declarations
           if variables
-            (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags]).uniq.sort do |x, y|
+            (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags] + variables[:all][:unset_flags] + variables[:all][:add_flags]).uniq.sort do |x, y|
               x = x[0] if x.is_a?(Array)
               y = y[0] if y.is_a?(Array)
               # Need to use strings for the comparison as some declarations can be a string and some a symbol

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -19,6 +19,9 @@ module OrigenTesters
       # flow, the default value is :signature
       attr_reader :unique_test_names
 
+      # use flow variable grouping or not
+      attr_accessor :flow_variable_grouping
+
       # Returns the SMT version, defaults to 7
       attr_reader :smt_version
 
@@ -66,6 +69,8 @@ module OrigenTesters
       # defaults to the application's namespace if not defined (SMT8 only)
       attr_writer :package_namespace
 
+      attr_writer :spec_path, :seq_path
+
       # When set to true, the bins and softbins sheets from the limits spreadsheet will
       # be written out to a standalone (spreadsheet) file instead (SMT8 only)
       attr_accessor :separate_bins_file
@@ -74,6 +79,10 @@ module OrigenTesters
       # format (SMT8 only)
       attr_accessor :zip_patterns
 
+      # When set to true (the default), parameters will be generated in the flow file regardless if the default is selected
+      # (SMT8 only)
+      attr_accessor :print_all_params
+
       def initialize(options = {})
         options = {
           # whether to use multiport bursts or not, if so this indicates the name of the port to use
@@ -104,6 +113,7 @@ module OrigenTesters
         if smt8?
           @pat_extension = 'pat'
           @program_comment_char = ['println', '//']
+          @print_all_params = options[:print_all_params].nil? ? true : options[:print_all_params]
         else
           @pat_extension = 'avc'
           @program_comment_char = ['print_dl', '//']
@@ -135,15 +145,20 @@ module OrigenTesters
             @unique_test_names = :signature
           end
         end
-        if smt8?
-          @create_limits_file = true
+        if options.key?(:create_limits_file)
+          @create_limits_file = options[:create_limits_file]
         else
-          if options.key?(:create_limits_file)
-            @create_limits_file = options[:create_limits_file]
+          if smt8?
+            @create_limits_file = true
           else
             @create_limits_file = false
           end
         end
+
+        if options.key?(:flow_variable_grouping)
+          @flow_variable_grouping = options[:flow_variable_grouping]
+        end
+
         if options[:literal_flags]
           @literal_flags = true
         end
@@ -152,6 +167,8 @@ module OrigenTesters
         end
 
         @package_namespace = options.delete(:package_namespace)
+        @spec_path = options.delete(:spec_path)
+        @seq_path = options.delete(:seq_path)
         self.limitfile_test_modes = options[:limitfile_test_modes] || options[:limitsfile_test_modes]
         self.force_pass_on_continue = options[:force_pass_on_continue]
         self.delayed_binning = options[:delayed_binning]
@@ -167,6 +184,13 @@ module OrigenTesters
         @package_namespace || Origen.app.namespace
       end
 
+      def spec_path
+        @spec_path || 'specs'
+      end
+
+      def seq_path
+        @seq_path || 'specs'
+      end
       # Set the test mode(s) that you want to see in the limits files, supply an array of mode names
       # to set multiple.
       def limitfile_test_modes=(val)

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

@@ -4,6 +4,7 @@ module OrigenTesters
       require 'origen_testers/smartest_based_tester/base/flow'
       class Flow < Base::Flow
         TEMPLATE = "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb"
+        IN_IDENTIFIER = '_AUTOIN'
 
         def on_test(node)
           test_suite = node.find(:object).to_a[0]
@@ -93,18 +94,44 @@ module OrigenTesters
           @sub_flows ||= {}
           path = Pathname.new(node.find(:path).value)
           name = path.basename('.*').to_s
+          path = Origen.interface.sub_flow_path_overwrite(path) if Origen.interface.respond_to? :sub_flow_path_overwrite
           @sub_flows[name] = "#{path.dirname}.#{name}".gsub(/(\/|\\)/, '.')
           # Pass down all input variables before executing
+          if sub_flow.input_variables.size > 0 && tester.flow_variable_grouping
+            line "// #{name} sub-flow input variables"
+            line '{'
+            @indent += 1
+          end
           sub_flow.input_variables.each do |var|
-            var = var[0] if var.is_a?(Array)
-            line "#{name}.#{var} = #{var};"
+            # Handle the inout variables
+            # Get the main value into the temporary input variable
+            if sub_flow.inout_variables.keys.include?(var)
+              var = var[0] if var.is_a?(Array)
+              line "#{name}.#{var} = #{sub_flow.inout_variables[var]};"
+            else
+              var = var[0] if var.is_a?(Array)
+              line "#{name}.#{var} = #{var};"
+            end
+          end
+          if sub_flow.input_variables.size > 0 && tester.flow_variable_grouping
+            @indent -= 1
+            line '}'
           end
           line "#{name}.execute();"
           # And then retrieve all common output variables
+          if (output_variables & sub_flow.output_variables).size > 0 && tester.flow_variable_grouping
+            line "// #{name} sub-flow output variables"
+            line '{'
+            @indent += 1
+          end
           (output_variables & sub_flow.output_variables).sort.each do |var|
             var = var[0] if var.is_a?(Array)
             line "#{var} = #{name}.#{var};"
           end
+          if (output_variables & sub_flow.output_variables).size > 0 && tester.flow_variable_grouping
+            @indent -= 1
+            line '}'
+          end
           if on_pass = node.find(:on_pass)
             pass_lines = capture_lines do
               @indent += 1
@@ -146,20 +173,48 @@ module OrigenTesters
           end
         end
 
+        def on_auxiliary_flow(node)
+          @auxiliary_flows ||= {}
+          path = node.find(:path).value
+          name = node.find(:name).value
+          @auxiliary_flows[name] = "#{path}"
+          line "#{name}.execute();"
+        end
+
         def sub_flows
           @sub_flows || {}
         end
 
+        def auxiliary_flows
+          @auxiliary_flows || {}
+        end
+
+        def inout_variables
+          @inout_variables || {}
+        end
+
         # Variables which should be defined as an input to the current flow
         def input_variables
           vars = flow_variables
           # Jobs and enables flow into a sub-flow
-          (vars[:all][:jobs] + vars[:all][:referenced_enables] + vars[:all][:set_enables] +
+          in_var_array = (vars[:all][:jobs] + vars[:all][:referenced_enables] + vars[:all][:set_enables] +
             # As do any flags which are referenced by it but which are not set within it
-            (vars[:all][:referenced_flags] - vars[:all][:set_flags])).uniq.sort do |x, y|
+            (vars[:all][:referenced_flags] - vars[:all][:set_flags] - vars[:all][:unset_flags])).uniq
+          identified_inout_variables = in_var_array.select { |e| output_variables.include?(e) }
+          result = in_var_array.reject { |e| output_variables.include?(e) }
+          @inout_variables = {}
+          # create inout variables with unique ids to reduce user conflicts
+          identified_inout_variables.each do |var|
+            unique_id = 0
+            var.each_byte { |n| unique_id += n }
+            identifier = IN_IDENTIFIER + "_#{unique_id.to_s[0..4]}"
+            @inout_variables[:"#{var}#{identifier}"] = var
+          end
+          result += @inout_variables.keys
+          result.uniq.sort do |x, y|
             x = x[0] if x.is_a?(Array)
             y = y[0] if y.is_a?(Array)
-            x <=> y
+            x.to_s <=> y.to_s
           end
         end
 
@@ -170,6 +225,10 @@ module OrigenTesters
           (vars[:this_flow][:set_flags] +
            # As do any flags set by its children which are marked as external
            vars[:all][:set_flags_extern] +
+           # Other test methods are setting the flags
+           vars[:this_flow][:add_flags] +
+           # Other test methods are set in the children
+           vars[:all][:add_flags_extern] +
            # And any flags which are set by a child and referenced in this flow
            (vars[:this_flow][:referenced_flags] & vars[:sub_flows][:set_flags]) +
            # And also intermediate flags, those are flags which are set by a child and referenced
@@ -217,6 +276,11 @@ module OrigenTesters
               h << i + "#{var} = -1;"
             end
           end
+          # Handle the inout variables
+          # Use the original variable name and get the value out of the temporary input variable
+          inout_variables.each do |inout_var, orig_var|
+            h << i + "#{orig_var} = #{inout_var};"
+          end
           h << '' unless flow_variables[:this_flow][:set_flags].empty?
           h
         end

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

@@ -65,35 +65,37 @@ module OrigenTesters
           Origen.log.info "Writing... #{output_file}"
           spreadsheet = RODF::Spreadsheet.new
           Origen.interface.flow_sheets.each do |name, flow|
-            if flow.limits_file
-              limits_name = flow.limits_file.filename.sub('.csv', '')
-              table = spreadsheet.table limits_name
-              flow.limits_file.output_file.readlines.each_with_index do |line, i|
-                # Need to fix the first row, SMT8 won't allow the Low/High limits cells not to be merged
-                if i == 0
-                  row = table.row
-                  x = nil
-                  line.chomp.split(',').each do |word|
-                    if word == 'Low Limit'
-                      x = 0
-                    elsif word == 'High Limit'
-                      row.cell 'Low Limit', span: x + 1
-                      x = 0
-                    elsif word == 'Unit'
-                      row.cell 'High Limit', span: x + 1
-                      row.cell word
-                      x = nil
-                    elsif x
-                      x += 1
-                    else
+            if tester.create_limits_file
+              if flow.limits_file
+                limits_name = flow.limits_file.filename.sub('.csv', '')
+                table = spreadsheet.table limits_name
+                flow.limits_file.output_file.readlines.each_with_index do |line, i|
+                  # Need to fix the first row, SMT8 won't allow the Low/High limits cells not to be merged
+                  if i == 0
+                    row = table.row
+                    x = nil
+                    line.chomp.split(',').each do |word|
+                      if word == 'Low Limit'
+                        x = 0
+                      elsif word == 'High Limit'
+                        row.cell 'Low Limit', span: x + 1
+                        x = 0
+                      elsif word == 'Unit'
+                        row.cell 'High Limit', span: x + 1
+                        row.cell word
+                        x = nil
+                      elsif x
+                        x += 1
+                      else
+                        row.cell word
+                      end
+                    end
+                  else
+                    row = table.row
+                    line.chomp.split(',').each do |word|
                       row.cell word
                     end
                   end
-                else
-                  row = table.row
-                  line.chomp.split(',').each do |word|
-                    row.cell word
-                  end
                 end
               end
             end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb

@@ -21,6 +21,9 @@ flow <%= flow_name %> {
         <%= line %>
 %   end
 
+% end
+% auxiliary_flows.each do |name, path|
+        flow <%= name %> calls <%= path %> {}
 % end
 % sub_flows.each do |name, path|
         flow <%= name %> calls <%= path %> { }

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

@@ -7,11 +7,19 @@ module OrigenTesters
           %w(
             name
             comment
+            bypass
 
             test_method
 
             pattern
             specification
+            seq
+            burst
+
+            spec_namespace
+            spec_path
+            seq_namespace
+            seq_path
           )
 
         ALIASES = {
@@ -22,6 +30,7 @@ module OrigenTesters
         DEFAULTS = {
         }
 
+        NO_STRING_TYPES = [:list_strings, :list_classes, :class]
         # Generate accessors for all attributes and their aliases
         ATTRS.each do |attr|
           if attr == 'name' || attr == 'pattern'
@@ -42,24 +51,120 @@ module OrigenTesters
         end
 
         def lines
+          # Initialize path setting
+          # prefix = test method library prefix expectations
+          # self.spec_namespace = instance override from the tester specification namespace
+          # self.seq_namespace = instance override from the tester sequence namespace
+          # self.spec_path = instance override from the tester specification path
+          # self.seq_path = instance override from the tester sequence path
+          if Origen.interface.respond_to? :custom_smt8_prefix
+            prefix = Origen.interface.custom_smt8_prefix
+          else
+            prefix = 'measurement.'
+          end
+          spec_namespace = self.spec_namespace || tester.package_namespace
+          spec_path      = self.spec_path || tester.spec_path
+          seq_namespace  = self.seq_namespace || tester.package_namespace
+          seq_path       = self.seq_path || tester.seq_path
           l = []
-          l << "suite #{name} calls #{test_method.klass} {"
+          l << "suite #{name} calls #{test_method.klass[0].downcase + test_method.klass[1..-1]} {"
           if pattern && !pattern.to_s.empty?
-            l << "    measurement.pattern = setupRef(#{tester.package_namespace}.patterns.#{pattern});"
+            l << "    #{prefix}pattern = setupRef(#{seq_namespace}.patterns.#{pattern});"
+          end
+          if seq && !seq.to_s.empty?
+            l << "    #{prefix}operatingSequence = setupRef(#{seq_namespace}.#{seq_path}.#{seq});"
+          end
+          if burst && !burst.to_s.empty?
+            l << "    #{prefix}operatingSequence = setupRef(#{seq_namespace}.#{seq_path}.#{burst});"
           end
           if specification && !specification.to_s.empty?
-            l << "    measurement.specification = setupRef(#{tester.package_namespace}.specs.#{specification});"
+            l << "    #{prefix}specification = setupRef(#{spec_namespace}.#{spec_path}.#{specification});"
+          end
+          if bypass
+            l << '    bypass = true;'
           end
           test_method.sorted_parameters.each do |param|
             name = param[0]
             unless name.is_a?(String)
               name = name.to_s[0] == '_' ? name.to_s.camelize(:upper) : name.to_s.camelize(:lower)
             end
-            l << "    #{name} = #{wrap_if_string(test_method.format(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
+                l = add_nested_params(l, name, 'param0', {}, param.last, 1)
+              elsif test_method.format(name).nil?
+                # Do nothing
+              else
+                test_method.format(name).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])};"
+            else
+              l << "    #{name} = #{wrap_if_string(test_method.format(param[0]))};"
+            end
           end
           l << '}'
           l
         end
+
+        # 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                   = []
+          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}"
+            end
+            dynamic_spacing = ' ' * (4 * nested_loop_count)
+            l << "#{dynamic_spacing}#{name}[#{key}] = {" unless name.nil?
+            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.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
+              nested_key = nested_param.first.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
+              # 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) &&
+                 value_hash.keys.include?(nested_key_underscore) && nested_key != nested_key_underscore
+                fail 'You are using a hash based test method and provided both the parameter name and alias name.'
+              end
+              nested_key = nested_key_underscore if value_hash.keys.include?(nested_key_underscore)
+              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
+                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)
+                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)
+                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)
+                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)
+                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)
+                fail "You provided a parameter \'#{nested_key}\' that was not an accepted parameter to the hash parameter \'#{name}\'"
+              end
+            end
+          end
+          l
+        end
+        # rubocop:enable Metrics/ParameterLists: Avoid parameter lists longer than 5 parameters.
       end
     end
   end

data/lib/origen_testers/test/custom_test_interface.rb

@@ -33,11 +33,23 @@ module OrigenTesters
         end
       end
 
+      def custom_hash(name, options = {})
+        name = "custom_hash_#{name}".to_sym
+        if tester.v93k? && tester.smt8?
+          ti = test_methods.my_tml.test_hash
+          ti.my_arg_hash = {
+            my_param_name: {
+              my_arg2: 1
+            }
+          }
+        end
+      end
+
       private
 
       def add_custom_tml
         add_tml :my_tml,
-                test_a: {
+                test_a:    {
                   # Parameters can be defined with an underscored symbol as the name, this can be used
                   # if the C++ implementation follows the standard V93K convention of calling the attribute
                   # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
@@ -79,10 +91,32 @@ module OrigenTesters
                     end
                   }
                 },
-                test_b: {
+                test_b:    {
                   render_limits_in_tf: false,
                   my_arg0:             [:string, ''],
                   my_arg1:             [:string, 'b_default_value']
+                },
+                test_hash: {
+                  # Parameters can be defined with an underscored symbol as the name, this can be used
+                  # if the C++ implementation follows the standard V93K convention of calling the attribute
+                  # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
+                  # first example.
+                  # The attribute definition has two required parameters, the type and the default value.
+                  # The type can be :string, :current, :voltage, :time, :frequency, or :integer
+                  # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied,
+                  # Origen will raise an error upon an attempt to set it to an unlisted value.
+                  tester_state:   [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)],
+                  test_name:      [:string, 'Functional'],
+                  my_list_string: [:list_strings, %w(E1 E2)],
+                  my_list_class:  [:list_classes, %w(E1 E2)],
+                  my_arg_hash:    [{
+                    my_arg0: [:string, ''],
+                    my_arg1: [:string, 'a_default_value'],
+                    my_arg2: [:integer, 0],
+                    my_arg2: [:list_strings, %w(E1 E2)],
+                    my_arg3: [:list_classes, %w(E1 E2)]
+                  }]
+                  # Define any methods you want the test method to have
                 }
       end
 

data/lib/origen_testers/test/interface.rb

@@ -12,6 +12,67 @@ module OrigenTesters
       def initialize(options = {})
         @environment = options[:environment]
         add_charz
+        add_my_tml if tester.v93k?
+      end
+
+      def add_my_tml
+        add_tml :my_hash_tml,
+                class_name:   'MyTmlHashNamespace',
+
+                # Here is a test definition.
+                # The identifier should be lower-cased and underscored, in-keeping with Ruby naming conventions.
+                # By default the class name will be the camel-cased version of this identifier, so 'myTest' in
+                # this case.
+                my_hash_test: {
+                  # [OPTIONAL] The C++ test method class name can be overridden from the default like this:
+                  class_name:             'MyHashExampleClass',
+                  # [OPTIONAL] If the test method does not require a definition in the testmethodlimits section
+                  #    of the .tf file, you can suppress like this:
+                  # render_limits_in_file: false,
+                  # Parameters can be defined with an underscored symbol as the name, this can be used
+                  # if the C++ implementation follows the standard V93K convention of calling the attribute
+                  # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
+                  # first example.
+                  # The attribute definition has two required parameters, the type and the default value.
+                  # The type can be :string, :current, :voltage, :time, :frequency, integer, :double or :boolean
+                  pin_list:               [:string, ''],
+                  samples:                [:integer, 1],
+                  precharge_voltage:      [:voltage, 0],
+                  settling_time:          [:time, 0],
+                  # An optional parameter that sets the limits name in the 'testmethodlimits' section
+                  # of the generated .tf file.  Defaults to 'Functional' if not provided.
+                  test_name:              [:string, 'HashExample'],
+                  # An optional 3rd parameter can be supplied to provide an array of allowed values. If supplied,
+                  # Origen will raise an error upon an attempt to set it to an unlisted value.
+                  tester_state:           [:string, 'CONNECTED', %w(CONNECTED UNCHANGED DISCONNECTED)],
+                  force_mode:             [:string, 'VOLT', %w(VOLT CURR)],
+                  # The name of another parameter can be supplied as the type argument, meaning that the type
+                  # here will be either :current or :voltage depending on the value of :force_mode
+                  # force_value: [:force_mode, 3800.mV],
+                  # In cases where the C++ library has deviated from standard attribute naming conventions
+                  # (camel-cased with lower cased first character), the absolute attribute name can be given
+                  # as a string.
+                  # The Origen accessor for these will be the underscored version, with '.' characters
+                  # converted to underscores e.g. tm.an_unusual_name
+                  'hashParameter':        [{ param_name0: [:string, 'NO'], param_name1: [:integer, 0] }],
+                  'hashParameter2':       [{ param_name0: [:string, 'NO'], param_name1: [:integer, 0] }],
+                  'nestedHashParameter':  [{
+                    param_name0:        [:string, ''],
+                    param_list_strings: [:list_strings, %w(E1 E2)],
+                    param_list_classes: [:list_classes, %w(E1 E2)],
+                    param_name1:        [{
+                      param_name0:        [:integer, 0],
+                      param_list_strings: [:list_strings, %w(E1 E2)],
+                      param_list_classes: [:list_classes, %w(E1 E2)]
+                    }]
+                  }],
+                  'nestedHashParameter2': [{
+                    param_name0: [:string, ''],
+                    param_name1: [{
+                      param_name0: [:integer, 0]
+                    }]
+                  }]
+                }
       end
 
       def add_charz
@@ -218,6 +279,68 @@ module OrigenTesters
         end
       end
 
+      def my_hash_test(name, options = {})
+        number = options[:number]
+
+        if tester.v93k? && tester.smt8?
+          block_loop(name, options) do |block, i|
+            options[:number] = number + i if number && i
+            tm = test_methods.my_hash_tml.my_hash_test
+            tm.hashParameter = {
+              param1: {}
+            }
+            tm.nestedHashParameter = {
+              my_param_name0: {
+                param_name0: 'hello',
+                param_name1: {
+                  my_param_name1: {
+                    param_name0: 1
+                  },
+                  my_param_name2: {
+                    param_name0: 2
+                  },
+                  my_param_name3: {
+                    param_name0: 3
+                  }
+                }
+              }
+            }
+            tm.nestedHashParameter2 = {
+              my_param_name4: {
+                param_name0: 'goodbye'
+              },
+              my_param_name5: {
+                param_name0: 'goodbye forever'
+              }
+            }
+            ts = test_suites.run(name, options)
+            ts.test_method = tm
+            ts.spec = options.delete(:pin_levels) if options[:pin_levels]
+            ts.spec ||= 'specs.Nominal'
+            flow.test ts, options
+          end
+        end
+      end
+
+      def my_override_spec_test(name, options = {})
+        number = options[:number]
+
+        if tester.v93k? && tester.smt8?
+          tm = test_methods.ac_tml.ac_test.functional_test
+          ts = test_suites.run(name, options)
+          ts.test_method = tm
+          ts.spec = options.delete(:pin_levels) if options[:pin_levels]
+          ts.spec ||= 'specs.Nominal'
+          ts.pattern = 'pat1'
+          ts.burst = 'sequence1'
+          ts.spec_path = 'myCustomSpecPath'
+          ts.seq_path  = 'myCustomSeqPath'
+          ts.spec_namespace = 'myCustomSpecNamespace'
+          ts.seq_namespace  = 'myCustomSeqNamespace'
+          flow.test ts, options
+        end
+      end
+
       def block_loop(name, options)
         if options[:by_block]
           if tester.j750? || tester.uflex?

data/program/components/_prb1_main.rb

@@ -1,4 +1,10 @@
 Flow.create do |options|
+  if tester.smt8?
+    my_hash_test :hash_example, number: 8000
+    my_override_spec_test :spec_override_example, number: 8010
+    add_auxiliary_flow :POWERDOWN, path: 'testflow.POWERDOWN'
+  end
+
   # Instantiate tests via the
   # interface
   func 'program_ckbd', tname: 'PGM_CKBD', tnum: 1000, bin: 100, soft_bin: 1100
@@ -240,6 +246,9 @@ Flow.create do |options|
     log 'Passing test flags works as expected'
     func :test_with_no_flags, bypass: false, output_on_pass: false, output_on_fail: false, value_on_pass: false, value_on_fail: false, per_pin_on_pass: false, per_pin_on_fail: false, number: 6020
     func :test_with_flags, bypass: true, output_on_pass: true, output_on_fail: true, value_on_pass: true, value_on_fail: true, per_pin_on_pass: true, per_pin_on_fail: true, number: 6030
+  elsif tester.smt8?
+    func :test_with_no_flags, bypass: false, number: 6020
+    func :test_with_flags, bypass: true, number: 6030
   end
 
   if tester.smt7?

data/program/custom_tests.rb

@@ -9,5 +9,8 @@ Flow.create interface: 'OrigenTesters::Test::CustomTestInterface', flow_descript
 
   if tester.v93k?
     custom_b :test4, number: 30040
+    if tester.smt8?
+      custom_hash :test5, number: 30050
+    end
   end
 end

data/program/flow_control.rb

@@ -319,6 +319,18 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     set_flag '$global'
   end
 
+  log 'Test unset_flag functionality'
+  set_flag '$my_unset_flag'
+  unset_flag '$my_unset_flag'
+
+  log 'Test add_flag functionality'
+  add_flag :my_uncalled_flag
+
+  log 'Test inout variables'
+  add_flag :MY_INOUT_ADD_FLAG
+  if_flag '$MY_INOUT_ADD_FLAG' do
+  end
+
   if tester.v93k?
     log "This should retain the set-run-flag in the else conditional"
     func :test22, id: :at22, number: 51480
@@ -349,7 +361,7 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     func :test36, on_fail: { render: 'multi_bin;' }, if_flag: :my_flag, number: 51570
   end
 
-  if tester.v93k? && !tester.smt8?
+  if tester.v93k?
     log "Tests of flow loop"
     loop from: 0, to: 5, step: 1, var: '$LOOP_VARIABLE' do
       func :test_myloop, number: 56000
@@ -360,9 +372,11 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
       func :test_myloop2, number: 5610
     end
 
-    log "Tests of flow loop, non-default test number increment" 
-    loop from: 0, to: 5, var: '$LOOP_VARIABLE', test_num_inc: 2 do
-      func :test_myloop3, number: 56200
+    if tester.smt7?
+      log "Tests of flow loop, non-default test number increment" 
+      loop from: 0, to: 5, var: '$LOOP_VARIABLE', test_num_inc: 2 do
+        func :test_myloop3, number: 56200
+      end
     end
  
     log "Tests of decrementing loop"
@@ -371,14 +385,29 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     end
  
     log "Tests of nested flow loop, depth 3"
-    loop from: 0, to: 9, step: 2, var: '$LOOP_VARIABLE1'do
-      loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
-        loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
-          func :test_myloop5, number: 56400
+    if tester.smt7?
+      loop from: 0, to: 9, step: 2, var: '$LOOP_VARIABLE1'do
+        loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
+          loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
+            func :test_myloop5, number: 56400
+          end
+        end
+      end
+    else
+      loop from: 0, to: 9, step: 1, var: '$LOOP_VARIABLE1'do
+        loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
+          loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
+            func :test_myloop5, number: 56400
+          end
         end
       end
     end
 
+    log "Tests of variable loop"
+    loop from: '$TEST_VAR', to: 1, step: -1, var: '$LOOP_VARIABLE' do
+      func :test_myloop6, number: 56500
+    end
+
     # Test of skipping variable name not yet ready
   end
 

data/templates/origen_guides/program/flowapi.md.erb

@@ -280,6 +280,9 @@ test :test2, if_flag: :my_pass_flag
 unless_flag :my_pass_flag do
   test :test3
 end
+
+log "Example of manually unsetting flag"
+test :test4, on_pass: { unset_flag :my_custom_flag1 }
 ~~~
 
 Note that flag names will usually be forced to uppercase, this is to institute a convention that
@@ -303,6 +306,14 @@ unless_enable "$MCEn_test" do
 end
 ~~~
 
+For custom environment libraries, there might be a need to reference a flag without using the native
+flag API. `add_flag` will allow the flow and sub-flow to have access to the flag without adding to the flow.
+
+~~~ruby
+log "Example of manually adding a flag to a flow without calling the flag"
+add_flag :my_custom_flag2
+~~~
+
 In all cases the `$` will be removed from the final flag name that appears in the test program.
 
 Whenever you set a flag or automation initializes a variable, you can remove the variable from initialization flow by labeling as a global flag
@@ -352,7 +363,7 @@ end
 ~~~
 
 
-#### Flow Loops for V93k (SMT7 only)
+#### Flow Loops for V93k
 Use flow loop control to permit re-running tests without using additional sequence labels.
 
 ~~~ruby
@@ -381,7 +392,21 @@ loop from: 0, to: 5, var: '$LOOP_VARIABLE', test_num_inc: 2 do
 end
 ~~~
 
+You can also provide a variable starting point:
+~~~ruby
+loop from: '$TEST_VARIABLE', to: 5, var: '$LOOP_VARIABLE' do
+    func :test_myloop6, number: 56600
+end
+~~~
+
 Decrementing loops, having `from:` value > `to:` value and using negative `step:`, is also supported.
+
+##### Loop Rules For Each Environment
+
+`SMT7` cannot support a variable stop location. Only the `from:` parameter is allowed to be a variable.
+
+`SMT8` cannot have a step other than -1 or 1. The limitations of the range flow restrict those steps.
+The `to:` parameter can be a flow variable just like `from:`.
  
 
 

data/templates/origen_guides/program/v93k.md.erb

@@ -74,6 +74,20 @@ or to assign a spec in SMT8:
 t.spec = 'my_spec_min'
 ~~~
 
+The default namespace and folder paths are determined by your environment with `tester.package_namespace` and
+`tester.spec_path`/`tester.seq_path` respectively. If you need to override these values for specific test suites
+you have the following available:
+
+~~~ruby
+# Overrides spec namespace and folder path
+t.spec_namespace
+t.spec_path
+# Overrides sequence and pattern namespace
+t.seq_namespace
+# Overrides sequence folder path
+t.seq_path
+~~~
+
 If the test method provides parameters, you can set them in the same way. As a convenience,
 Origen will automatically work out whether the reference is to a parameter of the test suite
 or of the test method, and will assign it accordingly.

data/templates/origen_guides/program/v93ksmt8.md.erb

@@ -103,10 +103,35 @@ flow Main {
 }
 ~~~
 
+#### Auxiliary Flows
 
+SMT8 utilizes auxiliary flows to perform recurring actions. `add_auxiliary_flow` API exists to symlink to a predefined auxiliary flow.
+This API does not allow variables to be passed to or from the auxiliary flow since they are stand alone flows.
 
+~~~ruby
+add_auxiliary_flow :POWERDOWN, 'testflow.POWERDOWN'
+~~~
+
+~~~java
+flow Main {
+    setup {
+        flow POWERDOWN calls testflow.POWERDOWN {}
+    }
 
+    execute {
+        POWERDOWN.execute();
+    }
+}
+~~~
 
+#### Flow Variable Grouping
 
+Sub-flow variable passing causes variables before and after the execution call to populate the flow.
+If you wish to have a collapse-able block for the variables, you need to set the flow_variable_grouping variable to true.
+
+~~~
+# add this line to your origen_site_config.yml
+flow_variable_grouping: true
+~~~
 
 % end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.51.5
+  version: 0.52.1
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-11 00:00:00.000000000 Z
+date: 2024-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -601,7 +601,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: This plugin provides Origen tester models to drive ATE type testers like