origen 0.2.6 → 0.3.0

data/lib/origen/tester/ultraflex/generator/patgroup.rb

@@ -1,111 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class Patgroup
-          attr_accessor :index
-
-          class Pattern
-            ATTRS = %w(group_name pattern_file comment)
-
-            ALIASES = {
-              pattern: :pattern_file
-            }
-
-            DEFAULTS = {
-            }
-
-            # Generate accessors for all attributes and their aliases
-            ATTRS.each do |attr|
-              attr_accessor attr.to_sym
-            end
-
-            ALIASES.each do |_alias, val|
-              define_method("#{_alias}=") do |v|
-                send("#{val}=", v)
-              end
-              define_method("#{_alias}") do
-                send(val)
-              end
-            end
-
-            def initialize(patgroup, attrs = {})
-              # Set the defaults
-              DEFAULTS.each do |k, v|
-                send("#{k}=", v)
-              end
-              # Then the values that have been supplied
-              self.group_name = patgroup
-              attrs.each do |k, v|
-                send("#{k}=", v)
-              end
-            end
-
-            def to_s
-              l = "\t"
-              ATTRS.each do |attr|
-                l += "#{send(attr)}\t"
-              end
-              "#{l}"
-            end
-          end
-
-          # Specify multiple patterns by passing an array of attributes
-          # as the 2nd argument:
-          #
-          #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
-          #
-          #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
-          #                            {:pattern => "nvm_global_subs.PAT},
-          #                           ])
-          def initialize(name, attrs = {})
-            attrs = [attrs] unless attrs.is_a? Array
-            attrs.each do |pattrs|
-              if pattrs[:pattern]
-                pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
-                Origen.interface.referenced_patterns << pat
-              end
-              lines << Pattern.new(name, pattrs)
-            end
-            self.name = name
-          end
-
-          def ==(other_patgroup)
-            self.class == other_patgroup.class &&
-              name.to_s == other_patgroup.name.to_s &&
-              sorted_pattern_files == other_patgroup.sorted_pattern_files
-          end
-
-          def name
-            @name
-          end
-
-          def name=(n)
-            @name = n
-            lines.each { |l| l.group_name = n }
-            n
-          end
-
-          # Returns all lines in the pattern set
-          def lines
-            @lines ||= []
-          end
-
-          # Returns all pattern files in the pattern set in alphabetical order
-          def sorted_pattern_files
-            @lines.map(&:file_name).sort
-          end
-
-          # Returns the fully formatted pattern group for insertion into a patgroups sheet
-          def to_s
-            l = ''
-            lines.each do |line|
-              l += "#{line}\r\n"
-            end
-            l.chomp
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/patgroups.rb

@@ -1,41 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class Patgroups
-          include Origen::Tester::Generator
-
-          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/patgroups.txt.erb"
-          OUTPUT_POSTFIX = 'patgroups'
-
-          def add(name, options = {})
-            p = Patgroup.new(name, options)
-            collection << p
-            p
-          end
-
-          def finalize(_options = {})
-            uniq!
-            sort!
-          end
-
-          # Present the patgroups in the final sheet in alphabetical order
-          def sort!
-            collection.sort_by!(&:name)
-          end
-
-          # Removes all duplicate patgroups
-          def uniq!
-            uniques = []
-            collection.each do |patgroup|
-              unless uniques.any? { |p| p == patgroup }
-                uniques << patgroup
-              end
-            end
-            self.collection = uniques
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/patset.rb

@@ -1,111 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class Patset
-          attr_accessor :index
-
-          class Pattern
-            ATTRS = %w(pattern_set file_name start_label stop_label comment)
-
-            ALIASES = {
-              pattern: :file_name
-            }
-
-            DEFAULTS = {
-            }
-
-            # Generate accessors for all attributes and their aliases
-            ATTRS.each do |attr|
-              attr_accessor attr.to_sym
-            end
-
-            ALIASES.each do |_alias, val|
-              define_method("#{_alias}=") do |v|
-                send("#{val}=", v)
-              end
-              define_method("#{_alias}") do
-                send(val)
-              end
-            end
-
-            def initialize(patset, attrs = {})
-              # Set the defaults
-              DEFAULTS.each do |k, v|
-                send("#{k}=", v)
-              end
-              # Then the values that have been supplied
-              self.pattern_set = patset
-              attrs.each do |k, v|
-                send("#{k}=", v)
-              end
-            end
-
-            def to_s
-              l = "\t"
-              ATTRS.each do |attr|
-                l += "#{send(attr)}\t"
-              end
-              "#{l}"
-            end
-          end
-
-          # Specify multiple patterns by passing an array of attributes
-          # as the 2nd argument:
-          #
-          #   Patset.new("mrd1_pset", :pattern => "nvm_mrd1.PAT")
-          #
-          #   Patset.new("mrd1_pset", [{:pattern => "nvm_mrd1.PAT"},
-          #                            {:pattern => "nvm_global_subs.PAT, :start_label => "subr"}
-          #                           ])
-          def initialize(name, attrs = {})
-            attrs = [attrs] unless attrs.is_a? Array
-            attrs.each do |pattrs|
-              if pattrs[:pattern]
-                pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
-                Origen.interface.referenced_patterns << pat
-              end
-              lines << Pattern.new(name, pattrs)
-            end
-            self.name = name
-          end
-
-          def ==(other_patset)
-            self.class == other_patset.class &&
-              name.to_s == other_patset.name.to_s &&
-              sorted_pattern_files == other_patset.sorted_pattern_files
-          end
-
-          def name
-            @name
-          end
-
-          def name=(n)
-            @name = n
-            lines.each { |l| l.pattern_set = n }
-            n
-          end
-
-          # Returns all lines in the pattern set
-          def lines
-            @lines ||= []
-          end
-
-          # Returns all pattern files in the pattern set in alphabetical order
-          def sorted_pattern_files
-            @lines.map(&:file_name).sort
-          end
-
-          # Returns the fully formatted pattern set for insertion into a patset sheet
-          def to_s
-            l = ''
-            lines.each do |line|
-              l += "#{line}\r\n"
-            end
-            l.chomp
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/patsets.rb

@@ -1,41 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class Patsets
-          include Origen::Tester::Generator
-
-          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/patsets.txt.erb"
-          OUTPUT_POSTFIX = 'patsets'
-
-          def add(name, options = {})
-            p = Patset.new(name, options)
-            collection << p
-            p
-          end
-
-          def finalize(_options = {})
-            uniq!
-            sort!
-          end
-
-          # Present the patsets in the final sheet in alphabetical order
-          def sort!
-            collection.sort_by!(&:name)
-          end
-
-          # Removes all duplicate patsets
-          def uniq!
-            uniques = []
-            collection.each do |patset|
-              unless uniques.any? { |p| p == patset }
-                uniques << patset
-              end
-            end
-            self.collection = uniques
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/ultraflex/generator/templates/flow.txt.erb

@@ -1,9 +0,0 @@
-% unless @append
-DFF 1.1	Flow Table																											
-																												
-			Gate			Command				Bin Number		Sort Number			Flag			Group				Device			Debug			
-	Label	Enable	Job	Part	Env	Opcode	Parameter	TName	TNum	Pass	Fail	Pass	Fail	Result	Pass	Fail	State	Specifier	Sense	Condition	Name	Sense	Condition	Name	Assume	Sites	Comment	
-% end    
-% collection.each do |test|
-<%= test %>
-% end    

data/lib/origen/tester/ultraflex/generator/templates/instances.txt.erb

@@ -1,16 +0,0 @@
-% unless @append
-DFF 1.3	Test Instances																																																																																													
-																																																																																														
-		Test Procedure			DC Specs		AC Specs		Sheet Parameters				Other Parameters																																																																																	
-	Test Name	Type	Name	Called As	Category	Selector	Category	Selector	Time Sets	Edge Sets	Pin Levels	Overlay	Arg0	Arg1	Arg2	Arg3	Arg4	Arg5	Arg6	Arg7	Arg8	Arg9	Arg10	Arg11	Arg12	Arg13	Arg14	Arg15	Arg16	Arg17	Arg18	Arg19	Arg20	Arg21	Arg22	Arg23	Arg24	Arg25	Arg26	Arg27	Arg28	Arg29	Arg30	Arg31	Arg32	Arg33	Arg34	Arg35	Arg36	Arg37	Arg38	Arg39	Arg40	Arg41	Arg42	Arg43	Arg44	Arg45	Arg46	Arg47	Arg48	Arg49	Arg50	Arg51	Arg52	Arg53	Arg54	Arg55	Arg56	Arg57	Arg58	Arg59	Arg60	Arg61	Arg62	Arg63	Arg64	Arg65	Arg66	Arg67	Arg68	Arg69	Arg70	Arg71	Arg72	Arg73	Arg74	Arg75	Arg76	Arg77	Arg78	Arg79	Comment	
-% end    
-% collection.each do |test_instance|
-%   if test_instance.respond_to?("each")
-%# Instance group case...
-%     test_instance.each do |ins|
-<%= ins.to_s(test_instance.name) %>
-%     end    
-%   else
-<%= test_instance %>
-%   end    
-% end    

data/lib/origen/tester/ultraflex/generator/templates/patgroups.txt.erb

@@ -1,8 +0,0 @@
-% unless @append
-DFF 1.0	Pattern Groups							
-								
-	Group Name	Pattern File	Comment					
-% end
-% collection.each do |patgroup|
-<%= patgroup %>
-% end    

data/lib/origen/tester/ultraflex/generator/templates/patsets.txt.erb

@@ -1,10 +0,0 @@
-% unless @append
-DFF 1.1	Pattern Sets					
-						
-	Pattern Set	File/Group Name	Start Label	Stop Label	Comment	
-% end    
-% collection.each do |patset|
-%   patset.lines.each do |line|
-<%= line %>
-%   end
-% end    

data/lib/origen/tester/ultraflex/generator/test_instance.rb

@@ -1,622 +0,0 @@
-module Origen
-  module Tester
-    class Ultraflex
-      module Generator
-        class TestInstance
-          attr_accessor :type, :index, :version, :append_version
-
-          attrs = %w(
-            test_name proc_type proc_name proc_called_as dc_category
-            dc_selector ac_category ac_selector
-            time_sets edge_sets pin_levels overlay
-          )
-
-          80.times do |i|
-            attrs << "arg#{i}"
-          end
-          attrs << 'comment'
-
-          ATTRS = attrs
-
-          ALIASES = {
-            name:       :test_name,
-            time_set:   :time_sets,
-            timeset:    :time_sets,
-            timesets:   :time_sets,
-
-            other:      {
-            },
-
-            empty:      {
-              start_func:           :arg0,
-              start_of_body_f:      :arg0,
-              pre_pat_func:         :arg1,
-              pre_pat_f:            :arg1,
-              pre_test_func:        :arg2,
-              pre_test_f:           :arg2,
-              post_test_func:       :arg3,
-              post_test_f:          :arg3,
-              post_pat_func:        :arg4,
-              post_pat_f:           :arg4,
-              end_func:             :arg5,
-              end_of_body_f:        :arg5,
-              start_func_args:      :arg6,
-              start_of_body_f_args: :arg6,
-              pre_pat_func_args:    :arg7,
-              pre_pat_f_args:       :arg7,
-              pre_test_func_args:   :arg8,
-              pre_test_f_args:      :arg8,
-              post_test_func_args:  :arg9,
-              post_test_f_args:     :arg9,
-              post_pat_func_args:   :arg10,
-              post_pat_f_args:      :arg10,
-              end_func_args:        :arg11,
-              end_of_body_f_args:   :arg11,
-              utility_pins_1:       :arg12,
-              utility_pins_0:       :arg13,
-              init_lo:              :arg14,
-              start_lo:             :arg14,
-              init_hi:              :arg15,
-              start_hi:             :arg15,
-              init_hiz:             :arg16,
-              start_hiz:            :arg16,
-              float_pins:           :arg17
-            },
-
-            # Functional test instances
-            functional: {
-              pattern:              :arg0,
-              patterns:             :arg0,
-              start_func:           :arg1,
-              start_of_body_f:      :arg1,
-              pre_pat_func:         :arg2,
-              pre_pat_f:            :arg2,
-              pre_test_func:        :arg3,
-              pre_test_f:           :arg3,
-              post_test_func:       :arg4,
-              post_test_f:          :arg4,
-              post_pat_func:        :arg5,
-              post_pat_f:           :arg5,
-              end_func:             :arg6,
-              end_of_body_f:        :arg6,
-              set_pass_fail:        :arg7,
-              init_lo:              :arg8,
-              start_lo:             :arg8,
-              init_hi:              :arg9,
-              start_hi:             :arg9,
-              init_hiz:             :arg10,
-              start_hiz:            :arg10,
-              float_pins:           :arg11,
-              start_func_args:      :arg13,
-              start_of_body_f_args: :arg13,
-              pre_pat_func_args:    :arg14,
-              pre_pat_f_args:       :arg14,
-              pre_test_func_args:   :arg15,
-              pre_test_f_args:      :arg15,
-              post_test_func_args:  :arg16,
-              post_test_f_args:     :arg16,
-              post_pat_func_args:   :arg17,
-              post_pat_f_args:      :arg17,
-              end_func_args:        :arg18,
-              end_of_body_f_args:   :arg18,
-              wait_flags:           :arg21,
-              wait_time:            :arg22,
-              pat_flag_func:        :arg23,
-              pat_flag_f:           :arg23,
-              PatFlagF:             :arg23,
-              pat_flag_func_args:   :arg24,
-              pat_flag_f_args:      :arg24,
-              relay_mode:           :arg25,
-              threading:            :arg26,
-              match_all_sites:      :arg27,
-              capture_mode:         :arg30,
-              capture_what:         :arg31,
-              capture_memory:       :arg32,
-              capture_size:         :arg33,
-              datalog_mode:         :arg34,
-              data_type:            :arg35
-            },
-
-            board_pmu:  {
-              hsp_start:            :arg0,
-              start_func:           :arg1,
-              start_of_body_f:      :arg1,
-              pre_pat_func:         :arg2,
-              pre_pat_f:            :arg2,
-              pre_test_func:        :arg3,
-              pre_test_f:           :arg3,
-              post_test_func:       :arg4,
-              post_test_f:          :arg4,
-              post_pat_func:        :arg5,
-              post_pat_f:           :arg5,
-              end_func:             :arg6,
-              end_of_body_f:        :arg6,
-              precond_pat:          :arg7,
-              hold_state_pat:       :arg8,
-              holdstate_pat:        :arg8,
-              pattern:              :arg8,
-              pcp_stop:             :arg9,
-              wait_flags:           :arg10,
-              start_lo:             :arg11,
-              init_lo:              :arg11,
-              start_hi:             :arg12,
-              init_hi:              :arg12,
-              start_hiz:            :arg13,
-              init_hiz:             :arg13,
-              float_pins:           :arg14,
-              pinlist:              :arg15,
-              pin:                  :arg15,
-              pin_list:             :arg15,
-              measure_mode:         :arg16,
-              irange:               :arg17,
-              clamp:                :arg18,
-              vrange:               :arg19,
-              sampling_time:        :arg20,
-              samples:              :arg21,
-              settling_time:        :arg22,
-              hi_lo_lim_valid:      :arg23,
-              hi_lo_limit_valid:    :arg23,
-              hi_limit:             :arg24,
-              lo_limit:             :arg25,
-              force_cond_1:         :arg26,
-              force_cond:           :arg26,
-              force_condition:      :arg26,
-              force_cond_2:         :arg27,
-              gang_pins_tested:     :arg28,
-              relay_mode:           :arg29,
-              wait_time_out:        :arg30,
-              start_func_args:      :arg31,
-              start_of_body_f_args: :arg31,
-              pre_pat_func_args:    :arg32,
-              pre_pat_f_args:       :arg32,
-              pre_test_func_args:   :arg33,
-              pre_test_f_args:      :arg33,
-              post_test_func_args:  :arg34,
-              post_test_f_args:     :arg34,
-              post_pat_func_args:   :arg35,
-              post_pat_f_args:      :arg35,
-              end_func_args:        :arg36,
-              end_of_body_f_args:   :arg36,
-              pcp_start:            :arg37,
-              pcp_check_pg:         :arg38,
-              hsp_stop:             :arg39,
-              hsp_check_pg:         :arg40,
-              resume_pat:           :arg41,
-              utility_pins_1:       :arg42,
-              utility_pins_0:       :arg43,
-              pre_charge_enable:    :arg44,
-              pre_charge:           :arg45,
-              threading:            :arg46
-            },
-
-            pin_pmu:    {
-              hsp_start:            :arg0,
-              start_func:           :arg1,
-              start_of_body_f:      :arg1,
-              pre_pat_func:         :arg2,
-              pre_pat_f:            :arg2,
-              pre_test_func:        :arg3,
-              pre_test_f:           :arg3,
-              post_test_func:       :arg4,
-              post_test_f:          :arg4,
-              post_pat_func:        :arg5,
-              post_pat_f:           :arg5,
-              end_func:             :arg6,
-              end_of_body_f:        :arg6,
-              precond_pat:          :arg7,
-              hold_state_pat:       :arg8,
-              holdstate_pat:        :arg8,
-              pattern:              :arg8,
-              pcp_stop:             :arg9,
-              wait_flags:           :arg10,
-              start_lo:             :arg11,
-              init_lo:              :arg11,
-              start_hi:             :arg12,
-              init_hi:              :arg12,
-              start_hiz:            :arg13,
-              init_hiz:             :arg13,
-              float_pins:           :arg14,
-              pinlist:              :arg15,
-              pin:                  :arg15,
-              pin_list:             :arg15,
-              measure_mode:         :arg16,
-              irange:               :arg17,
-              settling_time:        :arg18,
-              hi_lo_lim_valid:      :arg19,
-              hi_lo_limit_valid:    :arg19,
-              hi_limit:             :arg20,
-              lo_limit:             :arg21,
-              force_cond_1:         :arg22,
-              force_cond:           :arg22,
-              force_condition:      :arg22,
-              force_cond_2:         :arg23,
-              fload:                :arg24,
-              relay_mode:           :arg25,
-              wait_time_out:        :arg26,
-              start_func_args:      :arg27,
-              start_of_body_f_args: :arg27,
-              pre_pat_func_args:    :arg28,
-              pre_pat_f_args:       :arg28,
-              pre_test_func_args:   :arg29,
-              pre_test_f_args:      :arg29,
-              post_test_func_args:  :arg30,
-              post_test_f_args:     :arg30,
-              post_pat_func_args:   :arg31,
-              post_pat_f_args:      :arg31,
-              end_func_args:        :arg32,
-              end_of_body_f_args:   :arg32,
-              pcp_start:            :arg33,
-              pcp_check_pg:         :arg34,
-              hsp_stop:             :arg35,
-              hsp_check_pg:         :arg36,
-              sampling_time:        :arg37,
-              samples:              :arg38,
-              resume_pat:           :arg39,
-              vcl:                  :arg40,
-              vch:                  :arg41,
-              utility_pins_1:       :arg42,
-              utility_pins_0:       :arg43,
-              pre_charge_enable:    :arg44,
-              pre_charge:           :arg45,
-              threading:            :arg46
-            }
-          }
-
-          DEFAULTS = {
-            empty:      {
-              proc_type:      'IG-XL Template',
-              proc_name:      'Empty_T',
-              proc_called_as: 'Excel Macro'
-            },
-            other:      {
-              proc_type:      'Other',
-              proc_called_as: 'Excel Macro'
-            },
-            functional: {
-              proc_type:       'IG-XL Template',
-              proc_name:       'Functional_T',
-              proc_called_as:  'VB DLL',
-              set_pass_fail:   1,
-              wait_flags:      'XXXX',
-              wait_time:       30,
-              relay_mode:      1,
-              threading:       0,
-              match_all_sites: 0,
-              capture_mode:    0,
-              capture_what:    0,
-              capture_memory:  0,
-              capture_size:    256,
-              datalog_mode:    0,
-              data_type:       0
-            },
-            board_pmu:  {
-              proc_type:        'IG-XL Template',
-              proc_name:        'BoardPmu_T',
-              proc_called_as:   'VB DLL',
-              wait_flags:       'XXXX',
-              measure_mode:     1,
-              irange:           5,
-              vrange:           3,
-              settling_time:    0,
-              hi_lo_lim_valid:  3,
-              gang_pins_tested: 0,
-              relay_mode:       0,
-              wait_time_out:    30,
-              pcp_check_pg:     1,
-              hsp_check_pg:     1,
-              resume_pat:       0,
-              threading:        0
-            },
-            pin_pmu:    {
-              proc_type:       'IG-XL Template',
-              proc_name:       'PinPmu_T',
-              proc_called_as:  'VB DLL',
-              wait_flags:      'XXXX',
-              measure_mode:    1,
-              irange:          2,
-              settling_time:   0,
-              hi_lo_lim_valid: 3,
-              fload:           0,
-              relay_mode:      0,
-              wait_time_out:   30,
-              pcp_check_pg:    1,
-              hsp_check_pg:    1,
-              resume_pat:      0,
-              threading:       0
-            }
-          }
-
-          # Generate accessors for all attributes and their aliases
-          ATTRS.each do |attr|
-            attr_accessor attr.to_sym
-          end
-
-          # 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
-            @append_version = true
-            self.name = name
-            # Build the type specific accessors (aliases)
-            ALIASES[@type.to_sym].each do |_alias, val|
-              define_singleton_method("#{_alias}=") do |v|
-                send("#{val}=", v) if self.respond_to?("#{val}=", v)
-              end
-              define_singleton_method("#{_alias}") do
-                send(val) if self.respond_to?(val)
-              end
-            end
-            # Set the defaults
-            DEFAULTS[@type.to_sym].each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=", v)
-            end
-            # Then the values that have been supplied
-            attrs.each do |k, v|
-              send("#{k}=", v) if self.respond_to?("#{k}=", v)
-            end
-          end
-
-          def ==(other_instance)
-            self.class == other_instance.class &&
-              unversioned_name.to_s == other_instance.unversioned_name.to_s &&
-              ATTRS.all? do |attr|
-                # Exclude test name, already examined above and don't want to include
-                # the version in the comparison
-                if attr == 'test_name'
-                  true
-                else
-                  send(attr) == other_instance.send(attr)
-                end
-              end
-          end
-
-          def self.new_empty(name, attrs = {})
-            new(name, :empty, attrs)
-          end
-
-          def self.new_functional(name, attrs = {})
-            new(name, :functional, attrs)
-          end
-
-          def self.new_board_pmu(name, attrs = {})
-            new(name, :board_pmu, attrs)
-          end
-
-          def self.new_pin_pmu(name, attrs = {})
-            new(name, :pin_pmu, attrs)
-          end
-
-          # Returns the fully formatted test instance for insertion into an instance sheet
-          def to_s(override_name = nil)
-            l = "\t"
-            ATTRS.each do |attr|
-              if attr == 'test_name' && override_name
-                l += "#{override_name}\t"
-              else
-                l += "#{send(attr)}\t"
-              end
-            end
-            "#{l}"
-          end
-
-          def name
-            if version && @append_version
-              "#{@test_name}_v#{version}"
-            else
-              @test_name.to_s
-            end
-          end
-          alias_method :test_name, :name
-
-          def unversioned_name
-            @test_name.to_s
-          end
-
-          # Set the cpu wait flags for the given test instance
-          #   instance.set_wait_flags(:a)
-          #   instance.set_wait_flags(:a, :c)
-          def set_wait_flags(*flags)
-            a = (flags.include?(:a) || flags.include?(:a)) ? '1' : 'X'
-            b = (flags.include?(:b) || flags.include?(:b)) ? '1' : 'X'
-            c = (flags.include?(:c) || flags.include?(:c)) ? '1' : 'X'
-            d = (flags.include?(:d) || flags.include?(:d)) ? '1' : 'X'
-            self.wait_flags = d + c + b + a
-            self
-          end
-
-          # Set and enable the pre-charge voltage of a parametric test instance.
-          def set_pre_charge(val)
-            if val
-              self.pre_charge_enable = 1
-              self.pre_charge = val
-            else
-              self.pre_charge_enable = 0
-            end
-            self
-          end
-          alias_method :set_precharge, :set_pre_charge
-
-          # Set and enable the hi limit of a parametric test instance, passing in
-          # nil or false as the lim parameter will disable the hi limit.
-          def set_hi_limit(lim)
-            if lim
-              self.hi_lo_limit_valid = hi_lo_limit_valid | 2
-              self.hi_limit = lim
-            else
-              self.hi_lo_limit_valid = hi_lo_limit_valid & 1
-            end
-            self
-          end
-
-          # Set and enable the hi limit of a parametric test instance, passing in
-          # nil or false as the lim parameter will disable the hi limit.
-          def set_lo_limit(lim)
-            if lim
-              self.hi_lo_limit_valid = hi_lo_limit_valid | 1
-              self.lo_limit = lim
-            else
-              self.hi_lo_limit_valid = hi_lo_limit_valid & 2
-            end
-            self
-          end
-
-          # Set the current range of the test instance, the following are valid:
-          #
-          # Board PMU
-          # * 2uA
-          # * 20uA
-          # * 200uA
-          # * 2mA
-          # * 20mA
-          # * 200mA
-          # * :smart
-          #
-          # Pin PMU
-          # * 200nA
-          # * 2uA
-          # * 20uA
-          # * 200uA
-          # * 2mA
-          # * :auto
-          # * :smart
-          #
-          # Examples
-          #   instance.set_irange(:smart)
-          #   instance.set_irange(:ua => 2)
-          #   instance.set_irange(2.uA) # Same as above
-          #   instance.set_irange(:ma => 200)
-          #   instance.set_irange(0.2) # Same as above
-          #   instance.set_irange(:a => 0.2) # Same as above
-          def set_irange(r = nil, options = {})
-            r, options = nil, r if r.is_a?(Hash)
-            unless r
-              # rubocop:disable AssignmentInCondition
-              if r = options.delete(:na) || options.delete(:nA)
-                r = r / 1_000_000_000
-              elsif r = options.delete(:ua) || options.delete(:uA)
-                r = r / 1_000_000.0
-              elsif r = options.delete(:ma) || options.delete(:mA)
-                r = r / 1000.0
-              elsif r = options.delete(:a) || options.delete(:A)
-              else
-                fail "Can't determine requested irange!"
-              end
-              # rubocop:enable AssignmentInCondition
-            end
-
-            if @type == :board_pmu
-              if r == :smart
-                self.irange = 6
-              else
-                self.irange = case
-                  when r > 0.02 then 5
-                  when r > 0.002 then 4
-                  when r > 0.0002 then 3
-                  when r > 0.00002 then 2
-                  when r > 0.000002 then 1
-                  else 0
-                  end
-              end
-
-            else # :pin_pmu
-              if r == :smart
-                self.irange = 5
-              elsif r == :auto
-                fail 'Auto range not available in FIMV mode!' if self.fimv?
-                self.irange = 6
-              else
-                if fimv?
-                  self.irange = case
-                    when r > 0.0002 then 2
-                    else 4
-                    end
-                else
-                  self.irange = case
-                    when r > 0.0002 then 2
-                    when r > 0.00002 then 4
-                    when r > 0.000002 then 0
-                    when r > 0.0000002 then 1
-                    else 3
-                    end
-                end
-              end
-            end
-
-            self
-          end
-
-          # Set the voltage range of the test instance, the following are valid:
-          #
-          # Board PMU
-          # * 2V
-          # * 5V
-          # * 10V
-          # * 24V
-          # * :auto
-          # * :smart
-          #
-          # Examples
-          #   instance.set_vrange(:auto)
-          #   instance.set_vrange(:v => 5)
-          #   instance.set_vrange(5) # Same as above
-          def set_vrange(r = nil, options = {})
-            r, options = nil, r if r.is_a?(Hash)
-            if r == :smart
-              self.vrange = 4
-            elsif r == :auto
-              self.vrange = 5
-            elsif !r
-              r = options.delete(:v) || options.delete(:V)
-              if r
-              else
-                fail "Can't determine requested vrange!"
-              end
-            end
-            self.vrange = case
-              when r > 10 then 3
-              when r > 5 then 2
-              when r > 2 then 1
-              else 0
-              end
-            self
-          end
-
-          # Set the meaure mode of a parametric test instance, either:
-          # * :voltage / :fimv
-          # * :current / :fvmi
-          def set_measure_mode(mode)
-            if mode == :current || mode == :fvmi
-              self.measure_mode = 0
-            elsif mode == :voltage || mode == :fimv
-              self.measure_mode = 1
-            else
-              fail "Unknown measure mode: #{mode}"
-            end
-          end
-
-          # Returns true if instance configured for force current, measure voltage
-          def fimv?
-            measure_mode == 1
-          end
-
-          # Returns true if instance configured for force voltage, measure current
-          def fvmi?
-            measure_mode == 0
-          end
-        end
-      end
-    end
-  end
-end