origen_testers 0.16.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cc2488bf76c9a0e7426660d81b852039e31ec87
-  data.tar.gz: fce554d775b85dc1131333062fe35183509999ae
+  metadata.gz: fd766d675c5dc9794ac28a826929bd9ddca1c602
+  data.tar.gz: 6a892c83abbc5fafda9b09cc6a25ff143d704d51
 SHA512:
-  metadata.gz: f3a81cfe3b60a8e45384dd3ebdaf0be3b905d24bec48806b857b6370ecf779c1ecf9eb5f2eea039beff1cdc5cbd8856d101e14d5a3646c791b9aefb3777104bd
-  data.tar.gz: ca85e8716996c3455a11e086cb2f1c2d4468d67550fed53f46b052dd50e3eb28d2993d670d38862c3682b673a81e60da994199da0c56727061d8cd986b2c35e2
+  metadata.gz: fed7f00ff4816dc84fa81d977617bad88812e6acdef1bf71c0599e3362077c5f27008f226d1b9aaf4aefb0eb74123f78a63c22eec2c16d8896576a444f7c5546
+  data.tar.gz: fa32ef3cec160f14984c94a22f7e2a8b3f2d2790b74582eec54ae4dda37d0c877b84dce979e99189e26e2794b6f7986134c66b07fd6200e61f8732f4234c39e0

data/config/version.rb

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

data/lib/origen_testers/labview_based_tester/pxie6570.rb

@@ -7,8 +7,8 @@ module OrigenTesters
 
       def initialize
         @pat_extension = 'digipatsrc'
-        @capture_started = {}
-        @source_started = {}
+        @capture_history = {}
+        @source_history = {}
         @global_label_export = []
         @called_subroutines = []
         @default_capture_wave_name = 'default_capture_waveform'
@@ -17,6 +17,8 @@ module OrigenTesters
 
       # Internal method called by Origen
       def pattern_header(options = {})
+        microcode "// source count: #{@source_history[:count]}" if @source_history[:started]
+        microcode "// capture count: #{@capture_history[:count]}" if @capture_history[:started]
         microcode 'file_format_version 1.0;'
         start_label = "#{options[:pattern]}_st"
         microcode "export #{start_label};"
@@ -41,7 +43,7 @@ module OrigenTesters
       # Internal method called by Origen
       def pattern_footer(options = {})
         # add capture/source stop to the end of the pattern
-        cycle microcode: 'capture_stop' if @capture_started[:default]
+        cycle microcode: 'capture_stop' if @capture_history[:started]
         cycle microcode: 'halt'
         microcode '}'
       end
@@ -141,15 +143,17 @@ module OrigenTesters
         cur_pin_state = nil
         if overlay_options.key?(:pins)
           overlay_options = { change_data: true }.merge(overlay_options)
-          unless @source_started[:default]
+          unless @source_history[:started]
             add_microcode_to_first_vec "source_start(#{@default_source_wave_name})"
-            @source_started[:default] = true
+            @source_history[:started] = true
+            @source_history[:count] = 0
           end
 
           # ensure no unwanted repeats on the source line
           options[:dont_compress] = true
 
           if overlay_options[:change_data]
+            @source_history[:count] += 1
             if options[:microcode].nil?
               options[:microcode] = 'source'
             else
@@ -169,10 +173,11 @@ module OrigenTesters
 
       # internal method to avoid needless code duplication
       def add_capture_start(pins, options = {})
-        unless @capture_started[:default]
+        unless @capture_history[:started]
           # add the capture start opcode to the top of the pattern
           add_microcode_to_first_vec "capture_start(#{@default_capture_wave_name})"
-          @capture_started[:default] = true
+          @capture_history[:started] = true
+          @capture_history[:count] = 0
         end
       end
 
@@ -182,8 +187,11 @@ module OrigenTesters
         options = { offset: 0 }.merge(options)
         pins = pins.flatten.compact
 
+        repeat_count = options[:repeat].nil? ? 1 : options[:repeat]
+
         fail 'For the PXIE6570 you must supply the pins to store/capture' if pins.empty?
         add_capture_start pins, options
+        @capture_history[:count] += repeat_count
 
         pins.each { |pin| pin.save; pin.capture }
         preset_next_vector(microcode: 'capture') do
@@ -203,6 +211,11 @@ module OrigenTesters
         response = super(pin)
         response.sub('C', 'V')
       end
+
+      # warn but don't fail if an api for another platform is not yet implemented
+      def method_missing(m, *args, &block)
+        Origen.log.warn "#{m} is not yet implemented for LabVIEWBasedTester::Pxie6570"
+      end
     end
   end
   Pxie6570 = LabVIEWBasedTester::Pxie6570

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

@@ -16,6 +16,18 @@ module OrigenTesters
             functional_test:              {
               test_name: [:string, 'Functional'],
               output:    [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            spec_search:                  {
+              max:             [:string, nil],
+              method:          [:string, nil],
+              min:             [:string, nil],
+              output:          [:string, 'None', %w(None ReportUI ShowFailOnly)],
+              resolution:      [:string, ''],
+              result_pin_list: [:string, ''],
+              setup_pin_list:  [:string, ''],
+              spec:            [:string, nil],
+              step:            [:string, nil],
+              test_name:       [:string, 'SpecSearch_Test']
             }
           }
 

data/lib/origen_testers/timing.rb

@@ -170,10 +170,9 @@ module OrigenTesters
     # @api private
     def _if_dut
       if dut
-        true
+        yield
       else
         Origen.log.warning 'It looks like you are calling tester.set_timeset before the DUT is instantiated, you should avoid doing that until the dut object is available'
-        false
       end
     end
 

data/program/_additional_erase.rb

@@ -1,7 +1,7 @@
 Flow.create do |options|
 
   if_enable 'additional_erase', :or => options[:force] do
-    func :erase_all
+    func :erase_all, number: options[:number]
   end
 
 end

data/program/_erase.rb

@@ -12,14 +12,18 @@ Flow.create do |options|
   # Define default options
   options = { :pulses      => 4,
               :post_verify => true,
+              :number => 0,
   }.merge(options)
 
-  options[:pulses].times do
-    func :erase_all
+  number = options[:number]
+
+  options[:pulses].times do |i|
+    func :erase_all, number: number
+    number += i * 10
   end
 
   if options[:post_verify]
-    import 'erase_vfy'
+    import 'erase_vfy', number: number
   end
 
 end

data/program/_erase_vfy.rb

@@ -1,5 +1,5 @@
 Flow.create do |options|
 
-  func :margin_read1_all1
+  func :margin_read1_all1, number: options[:number]
 
 end

data/program/basic_interface.rb

@@ -1,5 +1,5 @@
 Flow.create interface: 'OrigenTesters::Test::BasicInterface' do
 
-  functional :test1, sbin: 100
+  functional :test1, sbin: 100, number: 20000
 
 end

data/program/components/_prb1_main.rb

@@ -1,215 +1,218 @@
 Flow.create do |options|
   # Instantiate tests via the
   # interface
-  func 'program_ckbd', :tname => 'PGM_CKBD', :tnum => 1000, :bin => 100, :soft_bin => 1100
-  func 'margin_read1_ckbd'
+  func 'program_ckbd', tname: 'PGM_CKBD', tnum: 1000, bin: 100, soft_bin: 1100
+  func 'margin_read1_ckbd', number: 1010
 
   # Control the build process based on
   # the current target
   if $dut.has_margin0_bug?
-    func 'normal_read_ckbd'
+    func 'normal_read_ckbd', number: 1020
   else
-    func 'margin_read0_ckbd'
+    func 'margin_read0_ckbd', number: 1030
   end
 
   # Include a sub flow, example of
   # parameter passing
-  import '../erase', :pulses => 6
+  import '../erase', pulses: 6, number: 2000
 
   # Render an ERB template, or raw
   # text file
   if $tester.j750?
-    flow.render 'templates/j750/vt_flow', :include_tifr => true
+    flow.render 'templates/j750/vt_flow', include_tifr: true
   end
 
   log 'Should be v1'
-  func :program_ckbd
+  func :program_ckbd, number: 3000
   log 'Should be v2'
-  func :program_ckbd, :duration => :dynamic
+  func :program_ckbd, duration: :dynamic, number: 3010
   log 'Should be v1'
-  func :program_ckbd
+  func :program_ckbd, number: 3020
   log 'Should be v2'
-  func :program_ckbd, :duration => :dynamic
+  func :program_ckbd, duration: :dynamic, number: 3030
 
   log 'Should be a v1 test instance group'
-  func :program_ckbd, :by_block => true
+  func :program_ckbd, by_block: true, number: 3040
   log 'Should be a v2 test instance group'
-  func :program_ckbd, :by_block => true, :duration => :dynamic
+  func :program_ckbd, by_block: true, duration: :dynamic, number: 3050
   log 'Should be a v1 test instance group'
-  func :program_ckbd, :by_block => true
+  func :program_ckbd, by_block: true, number: 3060
   log 'Should be a v2 test instance group'
-  func :program_ckbd, :by_block => true, :duration => :dynamic
+  func :program_ckbd, by_block: true, duration: :dynamic, number: 3070
 
   # Test job conditions
-  func :p1_only_test, :if_job => :p1
+  func :p1_only_test, if_job: :p1, number: 3080
   if_job [:p1, :p2] do
-    func :p1_or_p2_only_test
+    func :p1_or_p2_only_test, number: 3090
   end
-  func :not_p1_test, :unless_job => :p1
-  func :not_p1_or_p2_test, :unless_job => [:p1, :p2]
+  func :not_p1_test, unless_job: :p1, number: 3100
+  func :not_p1_or_p2_test, unless_job: [:p1, :p2], number: 3110
   unless_job [:p1, :p2] do
-    func :another_not_p1_or_p2_test
+    func :another_not_p1_or_p2_test, number: 3120
   end
 
   log 'Verify that a test with an external instance works'
-  por
+  por number: 3130
 
   log 'Verify that a request to use the current context works'
-  func :erase_all, :if_job => :p1             # Job should be P1
-  func :erase_all, :context => :current    # Job should be P1
+  func :erase_all, if_job: :p1, number: 3140          # Job should be P1
+  func :erase_all, context: :current, number: 3150    # Job should be P1
   unless_job :p2 do
-    func :erase_all, :context => :current  # Job should be P1
-    func :erase_all                        # Job should be !P2
+    func :erase_all, context: :current, number: 3160  # Job should be P1
+    func :erase_all, number: 3170                     # Job should be !P2
   end
 
   # Deliver an initial erase pulse
-  func :erase_all
+  func :erase_all, number: 3180
 
   # Deliver additional erase pulses as required until it verifies, maximum of 5 additional pulses
+  number = 3200
   5.times do |x|
     # Assign a unique id attribute to each verify so that we know which one we are talking about when
     # making other tests dependent on it.
     # When Origen sees the if_failed dependency on a future test it will be smart enough to inhibit the binning
     # on this test without having to explicitly declare that.
-    func :margin_read1_all1, :id => "erase_vfy_#{x}"
+    func :margin_read1_all1, id: "erase_vfy_#{x}", number: number
+    number += 10
     # Run this test only if the given verify failed
-    func :erase_all, :if_failed => "erase_vfy_#{x}"
+    func :erase_all, if_failed: "erase_vfy_#{x}", number: number
+    number += 10
   end
 
   # A final verify to set the binning
-  func :margin_read1_all1
+  func :margin_read1_all1, number: 4000
 
   log 'Test if enable'
-  func :erase_all, :if_enable => 'do_erase'
+  func :erase_all, if_enable: 'do_erase', number: 4010
 
   if_enable 'do_erase' do
-    func :erase_all
+    func :erase_all, number: 4020
   end
 
   log 'Test unless enable'
-  func :erase_all, :unless_enable => 'no_extra_erase'
+  func :erase_all, unless_enable: 'no_extra_erase', number: 4030
 
   unless_enable 'no_extra_erase' do
-    func :erase_all
-    func :erase_all
+    func :erase_all, number: 4040
+    func :erase_all, number: 4050
   end
 
-  func :erase_all
-  func :erase_all
+  func :erase_all, number: 4060
+  func :erase_all, number: 4070
 
   log 'Test if_passed'
-  func :erase_all, :id => 'erase_passed_1'
-  func :erase_all, :id => 'erase_passed_2'
+  func :erase_all, id: 'erase_passed_1', number: 4080
+  func :erase_all, id: 'erase_passed_2', number: 4090
 
-  func :margin_read1_all1, :if_passed => 'erase_passed_1'
+  func :margin_read1_all1, if_passed: 'erase_passed_1', number: 4100
   if_passed 'erase_passed_2' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4110
   end
 
   log 'Test unless_passed'
-  func :erase_all, :id => 'erase_passed_3'
-  func :erase_all, :id => 'erase_passed_4'
+  func :erase_all, id: 'erase_passed_3', number: 4120
+  func :erase_all, id: 'erase_passed_4', number: 4130
 
-  func :margin_read1_all1, :unless_passed => 'erase_passed_3'
+  func :margin_read1_all1, unless_passed: 'erase_passed_3', number: 4140
   unless_passed 'erase_passed_4' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4150
   end
 
   log 'Test if_failed'
-  func :erase_all, :id => 'erase_failed_1'
-  func :erase_all, :id => 'erase_failed_2'
+  func :erase_all, id: 'erase_failed_1', number: 4160
+  func :erase_all, id: 'erase_failed_2', number: 4170
 
-  func :margin_read1_all1, :if_failed => 'erase_failed_1'
+  func :margin_read1_all1, if_failed: 'erase_failed_1', number: 4180
   if_failed 'erase_failed_2' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4190
   end
 
   log 'Test unless_failed'
-  func :erase_all, :id => 'erase_failed_3'
-  func :erase_all, :id => 'erase_failed_4'
+  func :erase_all, id: 'erase_failed_3', number: 4200
+  func :erase_all, id: 'erase_failed_4', number: 4210
 
-  func :margin_read1_all1, :unless_failed => 'erase_failed_3'
+  func :margin_read1_all1, unless_failed: 'erase_failed_3', number: 4220
   unless_failed 'erase_failed_4' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4230
   end
 
   log 'Test if_ran'
-  func :erase_all, :id => 'erase_ran_1'
-  func :erase_all, :id => 'erase_ran_2'
+  func :erase_all, id: 'erase_ran_1', number: 4240
+  func :erase_all, id: 'erase_ran_2', number: 4250
 
-  func :margin_read1_all1, :if_ran => 'erase_ran_1'
+  func :margin_read1_all1, if_ran: 'erase_ran_1', number: 4260
   if_ran 'erase_ran_2' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4270
   end
 
   log 'Test unless_ran'
-  func :erase_all, :id => 'erase_ran_3'
-  func :erase_all, :id => 'erase_ran_4'
+  func :erase_all, id: 'erase_ran_3', number: 4280
+  func :erase_all, id: 'erase_ran_4', number: 4290
 
-  func :margin_read1_all1, :unless_ran => 'erase_ran_3'
+  func :margin_read1_all1, unless_ran: 'erase_ran_3', number: 4300
   unless_ran 'erase_ran_4' do
-    func :margin_read1_all1
+    func :margin_read1_all1, number: 4310
   end
 
   log 'Verify that job context wraps import'
   if_job :fr do
-    import '../erase'
+    import '../erase', number: 5000
   end
 
   log 'Verify that job context wraps enable block within an import'
   if_job :fr do
-    import '../additional_erase'
-    import '../additional_erase', :force => true
+    import '../additional_erase', number: 5500
+    import '../additional_erase', force: true, number: 5600
   end
 
   log 'Verify that flow.cz works...'
-  func :margin_read1_all1, :pin_levels => :cz, :cz_setup => 'vbplus_sweep'
+  func :margin_read1_all1, pin_levels: :cz, cz_setup: 'vbplus_sweep', number: 5700
 
   log 'Verify that flow.cz works with enable words'
   if_enable 'usb_xcvr_cz' do
-    func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vil_cz'
-    func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vih_cz'
+    func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vil_cz', number: 5710
+    func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vih_cz', number: 5720
   end
 
-  func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vil_cz', if_enable: 'usb_xcvr_cz'
-  func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vih_cz', if_enable: 'usb_xcvr_cz'
+  func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vil_cz', if_enable: 'usb_xcvr_cz', number: 5730
+  func :xcvr_fs_vilvih, cz_setup: 'usb_fs_vih_cz', if_enable: 'usb_xcvr_cz', number: 5740
 
   log 'Verify that MTO template works...'
-  mto_memory :mto_read1_all1
+  mto_memory :mto_read1_all1, number: 5750
 
   if tester.uflex?
     log 'import statement'
-    import 'temp' 
+    import 'temp', number: 5800 
 
     log 'direct call'
     
-    meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
-    meas :bgap_voltage_meas1
+    meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, number: 5910
+    meas :bgap_voltage_meas1, number: 5920
   end
 
   if tester.j750?
-    meas :lo_voltage, tnum: 1150, bin: 95, soft_bin: 5
-    meas :hi_voltage, pins: :hi_v, tnum: 1160, bin: 96, soft_bin: 6
-    meas :ps_leakage, pins: :power, tnum: 1170, bin: 97, soft_bin: 6
+    meas :lo_voltage, tnum: 1150, bin: 95, soft_bin: 5, number: 5920
+    meas :hi_voltage, pins: :hi_v, tnum: 1160, bin: 96, soft_bin: 6, number: 5930
+    meas :ps_leakage, pins: :power, tnum: 1170, bin: 97, soft_bin: 6, number: 5940
   end
 
   log 'Speed binning example bug from video 5'
   group "200Mhz Tests", id: :g200 do
-    test :test200_1
-    test :test200_2
-    test :test200_3
+    test :test200_1, number: 5950
+    test :test200_2, number: 5960
+    test :test200_3, number: 5970
   end
 
   group "100Mhz Tests", if_failed: :g200, id: :g100 do
-    test :test100_1, bin: 5
-    test :test100_2, bin: 5
-    test :test100_3, bin: 5
+    test :test100_1, bin: 5, number: 5980
+    test :test100_2, bin: 5, number: 5990
+    test :test100_3, bin: 5, number: 6000
   end
 
   pass 2, if_ran: :g100
 
   log 'Test node optimization within an if_failed branch'
-  func :some_func_test, id: :sft1
+  func :some_func_test, id: :sft1, number: 6010
 
   if_failed :sft1 do
     bin 10, if_flag: "Alarm"

data/program/components/_prb2_main.rb

@@ -1,6 +1,6 @@
 Flow.create do |options|
 
-  func :pgm_ckbd
-  func :mrd_ckbd
+  func :pgm_ckbd, number: options[:number] + 10
+  func :mrd_ckbd, number: options[:number] + 20
 
 end

data/program/components/_small.rb

@@ -1,15 +1,15 @@
 Flow.create do |options|
 
-  test :test1, if_enable: :small_flow
-  test :test2, if_enable: :small_flow
-  test :test1
-  test :test1
-  test :test1
-  test :test1
-  test :test1
-  test :test1
-  test :test1
-  test :test1, if_enable: :small_flow
-  test :test2, if_enable: :small_flow
+  test :test1, if_enable: :small_flow, number: options[:number] + 10
+  test :test2, if_enable: :small_flow, number: options[:number] + 20
+  test :test1, number: options[:number] + 30
+  test :test1, number: options[:number] + 40
+  test :test1, number: options[:number] + 50
+  test :test1, number: options[:number] + 60
+  test :test1, number: options[:number] + 70
+  test :test1, number: options[:number] + 80
+  test :test1, number: options[:number] + 90
+  test :test1, if_enable: :small_flow, number: options[:number] + 100
+  test :test2, if_enable: :small_flow, number: options[:number] + 110
 
 end

data/program/components/_temp.rb

@@ -1,6 +1,6 @@
 Flow.create do |options|
 
-  meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
-  meas :bgap_voltage_meas1
+  meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, number: options[:number] + 10
+  meas :bgap_voltage_meas1, number: options[:number] + 20
 
 end

data/program/custom_tests.rb

@@ -1,10 +1,10 @@
 # This flow is used to test custom test method API
 Flow.create interface: 'OrigenTesters::Test::CustomTestInterface' do
 
-  custom :test1
+  custom :test1, number: 30000
 
-  custom :test2
+  custom :test2, number: 30010
 
-  custom :test3
+  custom :test3, number: 30020
 
 end

data/program/flow_control.rb

@@ -8,244 +8,244 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
   self.resources_filename = 'flow_control'
 
   log "Test that if_failed works"
-  func :read1, id: :t1, bin: 10
-  func :erase1, if_failed: :t1, bin: 12
+  func :read1, id: :t1, bin: 10, number: 50000
+  func :erase1, if_failed: :t1, bin: 12, number: 50010
 
   log "Test the block form of if_failed"
-  func :read2, id: :t2, bin: 10
+  func :read2, id: :t2, bin: 10, number: 50020
   if_failed :t2 do
-    func :erase2
-    func :erase2
+    func :erase2, number: 50030
+    func :erase2, number: 50040
   end
 
   log "Test that if_passed works"
-  func :read1, id: :t3, bin: 10
-  func :pgm1, if_passed: :t3
+  func :read1, id: :t3, bin: 10, number: 50050
+  func :pgm1, if_passed: :t3, number: 50060
 
   log "Test the block form of if_passed"
-  func :read2, id: :t4, bin: 10
+  func :read2, id: :t4, bin: 10, number: 50070
   if_passed :t4 do
-    func :pgm1
-    func :pgm1
+    func :pgm1, number: 50080
+    func :pgm1, number: 50090
   end
 
   log "Test that if_ran works"
-  func :pgm, id: :t5, bin: 10
-  func :read0, if_ran: :t5
+  func :pgm, id: :t5, bin: 10, number: 50100
+  func :read0, if_ran: :t5, number: 50110
 
   log "Test the block form of if_ran"
-  func :pgm, id: :t6, bin: 10
+  func :pgm, id: :t6, bin: 10, number: 50120
   if_ran :t6 do
-    func :read0
-    func :read0
+    func :read0, number: 50130
+    func :read0, number: 50140
   end
 
   log "Test that unless_ran works"
-  func :pgm, id: :t7, bin: 10
-  func :read0, unless_ran: :t7
+  func :pgm, id: :t7, bin: 10, number: 50150
+  func :read0, unless_ran: :t7, number: 50160
 
   log "Test the block form of unless_ran"
-  func :pgm, id: :t8, bin: 10
+  func :pgm, id: :t8, bin: 10, number: 50170
   unless_ran :t8 do
-    func :read0
-    func :read0
+    func :read0, number: 50180
+    func :read0, number: 50190
   end
 
   log "Test that if_job works"
-  func :cold_test, if_job: :fc
+  func :cold_test, if_job: :fc, number: 50200
 
   log "Test the block form of if_job"
   if_job [:prb1, :prb2] do
-    func :probe_only_test1
-    func :probe_only_test2
+    func :probe_only_test1, number: 50210
+    func :probe_only_test2, number: 50220
   end
 
   log "Test that the block form of if_job can be overridden, prb9 should be removed"
   if_job [:prb1, :prb2, :prb9] do
-    func :probe_only_test1
+    func :probe_only_test1, number: 50230
   end
 
   log "Test that unless_job works"
-  func :warmish_test, unless_job: :fc
+  func :warmish_test, unless_job: :fc, number: 50240
 
   log "Test the block form of unless_job"
   unless_job [:prb1, :prb2] do
-    func :ft_only_test1
-    func :ft_only_test2
+    func :ft_only_test1, number: 50250
+    func :ft_only_test2, number: 50260
   end
 
   log "Test that if_enable works"
-  func :extra_test, if_enable: :extras
+  func :extra_test, if_enable: :extras, number: 50270
 
   log "Test the block form of if_enable"
   if_enable :cz do
-    func :cz_test1
-    func :cz_test2
+    func :cz_test1, number: 50280
+    func :cz_test2, number: 50290
   end
 
   log "Test that unless_enable works"
-  func :long_test, unless_enable: :quick
+  func :long_test, unless_enable: :quick, number: 50300
 
   log "Test the block form of unless_enable"
   unless_enable :quick do
-    func :long_test1
-    func :long_test2
+    func :long_test1, number: 50310
+    func :long_test2, number: 50320
   end
 
   log "Test that if_any_failed works"
-  func :test1, id: :ifa1
-  func :test2, id: :ifa2
-  func :test3, if_any_failed: [:ifa1, :ifa2]
+  func :test1, id: :ifa1, number: 50330
+  func :test2, id: :ifa2, number: 50340
+  func :test3, if_any_failed: [:ifa1, :ifa2], number: 50350
 
   log "Test the block form of if_any_failed"
-  func :test1, id: :oof_passcode1
-  func :test2, id: :oof_passcode2
+  func :test1, id: :oof_passcode1, number: 50360
+  func :test2, id: :oof_passcode2, number: 50370
   if_any_failed :oof_passcode1, :oof_passcode2 do
-    func :test3
-    func :test4
+    func :test3, number: 50380
+    func :test4, number: 50390
   end
 
   log "Test that if_all_failed works"
-  func :test1, id: :ifall1
-  func :test2, id: :ifall2
-  func :test3, if_all_failed: [:ifall1, :ifall2]
+  func :test1, id: :ifall1, number: 50400
+  func :test2, id: :ifall2, number: 50410
+  func :test3, if_all_failed: [:ifall1, :ifall2], number: 50420
 
   log "Test the block form of if_all_failed"
-  func :test1, id: :ifallb1
-  func :test2, id: :ifallb2
+  func :test1, id: :ifallb1, number: 50430
+  func :test2, id: :ifallb2, number: 50440
   if_all_failed [:ifallb1, :ifallb2] do
-    func :test3
-    func :test4
+    func :test3, number: 50450
+    func :test4, number: 50460
   end
 
   log "Test that if_any_passed works"
-  func :test1, id: :ifap1
-  func :test2, id: :ifap2
-  func :test3, if_any_passed: [:ifap1, :ifap2]
+  func :test1, id: :ifap1, number: 50470
+  func :test2, id: :ifap2, number: 50480
+  func :test3, if_any_passed: [:ifap1, :ifap2], number: 50490
 
   log "Test the block form of if_any_passed"
-  func :test1, id: :ifapb1
-  func :test2, id: :ifapb2
+  func :test1, id: :ifapb1, number: 50500
+  func :test2, id: :ifapb2, number: 50510
   if_any_passed :ifapb1, :ifapb2 do
-    func :test3
-    func :test4
+    func :test3, number: 50520
+    func :test4, number: 50530
   end
 
   log "Test that if_all_passed works"
-  func :test1, id: :ifallp1
-  func :test2, id: :ifallp2
-  func :test3, if_all_passed: [:ifallp1, :ifallp2]
+  func :test1, id: :ifallp1, number: 50540
+  func :test2, id: :ifallp2, number: 50550
+  func :test3, if_all_passed: [:ifallp1, :ifallp2], number: 50560
 
   log "Test the block form of if_all_passed"
-  func :test1, id: :ifallpb1
-  func :test2, id: :ifallpb2
+  func :test1, id: :ifallpb1, number: 50570
+  func :test2, id: :ifallpb2, number: 50580
   if_all_passed :ifallpb1, :ifallpb2 do
-    func :test3
-    func :test4
+    func :test3, number: 50590
+    func :test4, number: 50600
   end
 
   log "Test that group-level dependencies work"
   group "grp1", id: :grp1 do
-    func :grp1_test1, bin: 5
-    func :grp1_test2, bin: 5
-    func :grp1_test3, bin: 5
+    func :grp1_test1, bin: 5, number: 50610
+    func :grp1_test2, bin: 5, number: 50620
+    func :grp1_test3, bin: 5, number: 50630
   end
 
   group "grp2", if_failed: :grp1 do
-    func :grp2_test1, bin: 5
-    func :grp2_test2, bin: 5
-    func :grp2_test3, bin: 5
+    func :grp2_test1, bin: 5, number: 50640
+    func :grp2_test2, bin: 5, number: 50650
+    func :grp2_test3, bin: 5, number: 50660
   end
 
   log "Another group-level dependencies test based on a real life use case"
-  func :gt1, bin: 90
+  func :gt1, bin: 90, number: 50670
   group "gt_grp1", id: :gt_grp1 do
-    func :gt_grp1_test1, bin: 90, id: :gt_grp1
-    func :gt_grp1_test2, bin: 90, id: :gt_grp1
+    func :gt_grp1_test1, bin: 90, id: :gt_grp1, number: 50680
+    func :gt_grp1_test2, bin: 90, id: :gt_grp1, number: 50690
   end
-  func :gt2, bin: 90, if_failed: :gt_grp1
+  func :gt2, bin: 90, if_failed: :gt_grp1, number: 50700
   group "gt_grp2", id: :gt_grp2, if_failed: :gt_grp1 do
     # The if_failed and IDs here are redundant, but it should still generate
     # valid output if an application were to do this
-    func :gt_grp2_test1, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
-    func :gt_grp2_test2, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+    func :gt_grp2_test1, bin: 90, id: :gt_grp2, if_failed: :gt_grp1, number: 50710
+    func :gt_grp2_test2, bin: 90, id: :gt_grp2, if_failed: :gt_grp1, number: 50720
   end
-  func :gt3, bin: 90, if_failed: :gt_grp2
+  func :gt3, bin: 90, if_failed: :gt_grp2, number: 50730
 
   log "Test that nested groups work"
   group "level1" do
-    func :lev1_test1, bin: 5
-    func :lev1_test2, bin: 5
-    func :lev1_test3, id: :l1t3, bin: 10
-    func :lev1_test4, if_failed: :l1t3, bin: 12
-    func :lev1_test5, id: :l1t5, bin: 12
+    func :lev1_test1, bin: 5, number: 50740
+    func :lev1_test2, bin: 5, number: 50750
+    func :lev1_test3, id: :l1t3, bin: 10, number: 50760
+    func :lev1_test4, if_failed: :l1t3, bin: 12, number: 50770
+    func :lev1_test5, id: :l1t5, bin: 12, number: 50780
     group "level2" do
-      func :lev2_test1, bin: 5
-      func :lev2_test2, bin: 5
-      func :lev2_test3, id: :l2t3, bin: 10
-      func :lev2_test4, if_failed: :l2t3, bin: 12
+      func :lev2_test1, bin: 5, number: 50790
+      func :lev2_test2, bin: 5, number: 50800
+      func :lev2_test3, id: :l2t3, bin: 10, number: 50810
+      func :lev2_test4, if_failed: :l2t3, bin: 12, number: 50820
       # Test dependency on a test from another group
-      func :lev2_test5, if_failed: :l1t5, bin: 12
+      func :lev2_test5, if_failed: :l1t5, bin: 12, number: 50830
     end
   end
 
   log "Test nested conditions on a group"
-  func :nt1, bin: 10, id: :nt1
+  func :nt1, bin: 10, id: :nt1, number: 50840
   if_failed :nt1 do
-    func :nt2, bin: 11, id: :nt2
+    func :nt2, bin: 11, id: :nt2, number: 50850
     group "ntg1", id: :ntg1, if_passed: :nt2 do
-      func :nt3, bin: 12
+      func :nt3, bin: 12, number: 50860
     end
     group "ntg2", id: :ntg2, if_failed: :nt2 do
-      func :nt4, bin: 13
+      func :nt4, bin: 13, number: 50870
     end
   end
 
   log "Embedded conditional tests 1"
-  func :test1, id: :ect1_1
+  func :test1, id: :ect1_1, number: 50880
   if_failed :ect1_1 do
-    func :test2
-    func :test3, id: :ect1_3
+    func :test2, number: 50890
+    func :test3, id: :ect1_3, number: 50900
     if_failed :ect1_3 do
-      func :test4
+      func :test4, number: 50910
     end
   end
 
   log "Embedded conditional tests 2"
-  func :test1, id: :ect2_1
-  func :test2, id: :ect2_2
+  func :test1, id: :ect2_1, number: 50920
+  func :test2, id: :ect2_2, number: 50930
   if_failed :ect2_1 do
-    func :test3, if_failed: :ect2_2
-    func :test4, if_enable: "en1"
+    func :test3, if_failed: :ect2_2, number: 50940
+    func :test4, if_enable: "en1", number: 50950
     if_enable "en2" do
-      func :test5
-      func :test6
+      func :test5, number: 50960
+      func :test6, number: 50970
     end
-    func :test7
+    func :test7, number: 50980
   end
-  func :test8
+  func :test8, number: 51000
 
   log "Nested enable word test 1"
   if_enable "word1" do
-    func :test1
+    func :test1, number: 51010
     if_enable "word2" do
-      func :test2
+      func :test2, number: 51020
     end
   end
 
   log "Nested enable word test 2"
   if_enable "word1" do
-    func :test1
+    func :test1, number: 51030
     unless_enable "word2" do
-      func :test2
+      func :test2, number: 51040
     end
   end
 
   log "Nested enable word test 3"
   if_enable ["word1", "word2"] do
-    func :test1
+    func :test1, number: 51050
     if_enable "word3" do
-      func :test2
+      func :test2, number: 51060
     end
   end
 
@@ -256,126 +256,126 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
 
   log "Test enable words that wrap a lot of tests"
   if_enable :word1 do
-    5.times do
-      func :test1
+    5.times do |i|
+      func :test1, number: 51100 + (i * 10)
     end
     if_enable :word2 do
-      4.times do
-        func :test1
+      4.times do |i|
+        func :test1, number: 51200 + (i * 10)
       end
-      func :test1, enable: :word3
+      func :test1, enable: :word3, number: 51300
     end
   end
 
   if tester.j750?
     log "This should generate an AND flag"
-    func :test1, id: :at1
-    func :test2, id: :at2
+    func :test1, id: :at1, number: 51310
+    func :test2, id: :at2, number: 51320
     if_failed :at1 do
-      func :test3, if_failed: :at2
+      func :test3, if_failed: :at2, number: 51330
       # This should re-use the AND flag, rather than create a duplicate
-      func :test4, if_failed: :at2
+      func :test4, if_failed: :at2, number: 51340
     end 
     log "This should NOT generate an AND flag"
     # Creating an AND flag here is logically correct, but creates un-necessary flow lines. Since
     # the test at11 is already gated by the at21 condition, it does not need to be applied to any
     # tests that are dependent on at11.
-    func :test1, id: :at11
+    func :test1, id: :at11, number: 51350
     if_failed :at11 do
-      func :test2, id: :at21
-      func :test3, if_failed: :at21
-      func :test4, if_failed: :at21
+      func :test2, id: :at21, number: 51360
+      func :test3, if_failed: :at21, number: 51370
+      func :test4, if_failed: :at21, number: 51380
     end 
   end
 
   log "Manual flag setting"
-  test :test1, on_fail: { set_flag: :my_flag }, continue: true
-  test :test2, if_flag: :my_flag
+  test :test1, on_fail: { set_flag: :my_flag }, continue: true, number: 51390
+  test :test2, if_flag: :my_flag, number: 51400
   unless_flag :my_flag do
-    test :test3
+    test :test3, number: 51410
   end
   
   log "Mixed-case manual flags"
-  test :test1, on_fail: { set_flag: :$My_Mixed_Flag }, continue: true
-  test :test2, if_flag: "$My_Mixed_Flag"
+  test :test1, on_fail: { set_flag: :$My_Mixed_Flag }, continue: true, number: 51420
+  test :test2, if_flag: "$My_Mixed_Flag", number: 51430
   unless_flag "$My_Mixed_Flag" do
-    test :test3
+    test :test3, number: 51440
   end
   
   log "Mixed-case enables"
-  test :extra_test, if_enable: :$MCEn_extras
+  test :extra_test, if_enable: :$MCEn_extras, number: 51450
   unless_enable "$MCEn_test" do
-    test :test1
-    test :test2
+    test :test1, number: 51460
+    test :test2, number: 51470
   end
 
   if tester.v93k?
     log "This should retain the set-run-flag in the else conditional"
-    func :test22, id: :at22
+    func :test22, id: :at22, number: 51480
     
     if_failed :at22 do
-      func :test22a
-      func :test22b
+      func :test22a, number: 51490
+      func :test22b, number: 51500
     end 
     
-    func :test22c
-    func :test22d
+    func :test22c, number: 51510
+    func :test22d, number: 51520
   
     if_failed :at22 do
-      func :test22e
-      func :test22f
+      func :test22e, number: 51530
+      func :test22f, number: 51540
     end 
   end
 
   if tester.v93k?
     log "This should optimize away then/else branches that are empty"
-    func :test36, continue: true
-    func :test36b, bin: 12, continue:true
+    func :test36, continue: true, number: 51550
+    func :test36b, bin: 12, continue:true, number: 51560
 
     log "Tests of render"
 
     render 'multi_bin;', if_flag: :my_flag
 
-    func :test36, on_fail: { render: 'multi_bin;' }, if_flag: :my_flag
+    func :test36, on_fail: { render: 'multi_bin;' }, if_flag: :my_flag, number: 51570
   end
 
   log 'An optimization test case, this should not generate a flag on V93K'
-  func :test1, id: :t1a
+  func :test1, id: :t1a, number: 51580
 
   if_passed :t1a do
-    func :test2
+    func :test2, number: 51590
   end
 
   if_failed :t1a do
-    func :test3
+    func :test3, number: 51600
     bin 10
   end
 
   log 'The reverse optimization test case, this should not generate a flag on V93K'
-  func :test1, id: :t1b
+  func :test1, id: :t1b, number: 51610
 
   if_failed :t1b do
-    func :test3
+    func :test3, number: 51620
     bin 10
   end
 
   if_passed :t1b do
-    func :test2
+    func :test2, number: 51630
   end
 
   if tester.v93k?
     log 'Nested optimization test case'
-    func :outer_test, id: :ot
+    func :outer_test, id: :ot, number: 51640
     if_failed :ot do
       unless_flag :flag1 do
-        func :inner_test1, id: :it1
+        func :inner_test1, id: :it1, number: 51650
         render 'multi_bin;', if_failed: :it1
       end
     end
 
     log 'Nested flag optimization test case'
     if_flag :flag1 do
-      func :test4, id: :nf_t4
+      func :test4, id: :nf_t4, number: 51660
       if_failed :nf_t4 do
         render 'multi_bin;', if_flag: :flag1
       end
@@ -384,82 +384,82 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     log 'Same test case with volatile flag'
     volatile :$Alarm
     if_flag :$Alarm do
-      func :test10, id: :nf_t5
+      func :test10, id: :nf_t5, number: 51670
       if_failed :nf_t5 do
         render 'multi_bin;', if_flag: :$Alarm
       end
     end
 
     log 'The setting of flags used in later OR conditions should be preserved'
-    func :test2, id: :of1
-    func :test3, if_failed: :of1
-    func :test2, id: :of2
-    func :test3, if_failed: :of2
-    func :test4
-    func :test4, if_any_failed: [:of1, :of2]
+    func :test2, id: :of1, number: 51680
+    func :test3, if_failed: :of1, number: 51690
+    func :test2, id: :of2, number: 51700
+    func :test3, if_failed: :of2, number: 51710
+    func :test4, number: 51720
+    func :test4, if_any_failed: [:of1, :of2], number: 51730
 
     log 'The setting of flags used in later AND conditions should be preserved'
-    func :test2, id: :af1
-    func :test3, if_failed: :af1
-    func :test2, id: :af2
-    func :test3, if_failed: :af2
-    func :test4
-    func :test4, if_all_failed: [:af1, :af2]
+    func :test2, id: :af1, number: 51740
+    func :test3, if_failed: :af1, number: 51750
+    func :test2, id: :af2, number: 51760
+    func :test3, if_failed: :af2, number: 51770
+    func :test4, number: 51780
+    func :test4, if_all_failed: [:af1, :af2], number: 51790
     
     log 'Adjacent tests that set a flag and then use it in an OR condition should be valid'
-    func :test2, id: :of11
-    func :test2, id: :of12
-    func :test4, if_any_failed: [:of11, :of12]
+    func :test2, id: :of11, number: 51800
+    func :test2, id: :of12, number: 51810
+    func :test4, if_any_failed: [:of11, :of12], number: 51820
 
     log 'Adjacent tests that set a flag and then use it in an AND condition should be valid'
-    func :test2, id: :af11
-    func :test2, id: :af12
-    func :test4, if_all_failed: [:af11, :af12]
+    func :test2, id: :af11, number: 51830
+    func :test2, id: :af12, number: 51840
+    func :test4, if_all_failed: [:af11, :af12], number: 51850
 
     log 'Adjacent if combiner test case 1'
-    func :test1, if_enable: :my_enable_word
-    func :test2, unless_enable: :my_enable_word
-    func :test1, if_flag: :my_flag
-    func :test2, unless_flag: :my_flag
+    func :test1, if_enable: :my_enable_word, number: 51860
+    func :test2, unless_enable: :my_enable_word, number: 51870
+    func :test1, if_flag: :my_flag, number: 51880
+    func :test2, unless_flag: :my_flag, number: 51890
 
     log 'Adjacent if combiner test case 2'
-    func :test2, unless_enable: :my_enable_word
-    func :test1, if_enable: :my_enable_word
-    func :test2, unless_flag: :my_flag
-    func :test1, if_flag: :my_flag
+    func :test2, unless_enable: :my_enable_word, number: 51900
+    func :test1, if_enable: :my_enable_word, number: 51910
+    func :test2, unless_flag: :my_flag, number: 51920
+    func :test1, if_flag: :my_flag, number: 51930
 
     log 'Volatile if combiner test case'
-    func :test1, if_flag: :$Alarm
-    func :test2, unless_flag: :$Alarm
+    func :test1, if_flag: :$Alarm, number: 51940
+    func :test2, unless_flag: :$Alarm, number: 51950
   end
 
   log 'Test the block form of expressing if passed/failed dependents'
   func :test1, on_pass: ->{
-    func :test2
+    func :test2, number: 51970
   }, on_fail: ->{
-    func :test3
+    func :test3, number: 51980
     bin 10
-  }
+  }, number: 51960
 
   log 'Test the else block on a flag condition'
   if_enabled "bitmap", then: ->{
-    test :test2
+    test :test2, number: 51990
   }, else: ->{
-    test :test3
+    test :test3, number: 52000
   }
   if_flag :some_flag, then: ->{
-    test :test2
+    test :test2, number: 52010
   }, else: ->{
-    test :test3
+    test :test3, number: 52020
   }
 
   log 'Test of a real life case which was found to have problems'
   unless_enable "eword1" do
     unless_enable "eword2" do
-      import 'components/small'
+      import 'components/small', number: 53000
     end
     if_enable "eword2" do
-      import 'components/small'
+      import 'components/small', number: 54000
     end
   end
 end

data/program/prb2.rb

@@ -7,21 +7,21 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
 
   self.resources_filename = 'prb2'
 
-  func :erase_all, :duration => :dynamic
+  func :erase_all, duration: :dynamic, number: 10000
 
-  func :margin_read1_all1
+  func :margin_read1_all1, number: 10010
 
-  func :erase_all, :duration => :dynamic
-  func :margin_read1_all1
+  func :erase_all, duration: :dynamic, number: 10020
+  func :margin_read1_all1, number: 10030
 
-  import 'components/prb2_main'
+  import 'components/prb2_main', number: 11000
 
-  func :erase_all, :duration => :dynamic
-  func :margin_read1_all1, :id => 'erased_successfully'
+  func :erase_all, duration: :dynamic, number: 12000
+  func :margin_read1_all1, id: 'erased_successfully', number: 12010
 
   if_enable 'extra_tests' do
-    import 'components/prb2_main'
+    import 'components/prb2_main', number: 13000
   end
 
-  func :margin_read1_all1
+  func :margin_read1_all1, number: 14000
 end

data/program/test.rb

@@ -10,16 +10,16 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
 
 #  para 'charge_pump', :high_voltage => true, :lo_limit => 5, :hi_limit => 6
 
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: 35
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, continue: true
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 2000, lo_limit: 0.01, continue: true
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: "_some_spec", lo_limit: 0.01, continue: true
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: [1, 2]
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: [1.uA, 2.uA, 3.uA], hi_limit: [4.uA,5.uA], units: "A", defer_limits: true
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: 35, number: 40000
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, number: 40010
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40020
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40030
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, number: 40040
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, continue: true, number: 40050
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 2000, lo_limit: 0.01, continue: true, number: 40060
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: "_some_spec", lo_limit: 0.01, continue: true, number: 40070
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: [1, 2], number: 40080
+  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: [1.uA, 2.uA, 3.uA], hi_limit: [4.uA,5.uA], units: "A", defer_limits: true, number: 40090
 
   if tester.uflex?
     log "Test of ultraflex render API"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.17.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-14 00:00:00.000000000 Z
+date: 2018-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen