origen_testers 0.10.0 → 0.11.0

data/pattern/tester_store.rb

@@ -1,29 +1,29 @@
-Pattern.create(name: "test_store") do
-  tester.capture_style = :digcap
-  # configure tdo to non-default settings
-  tester.capture_memory :digcap do |mem|
-    mem.pin :tdo, size: 8
-  end
-
-  tester.cycle
-
-  dut.pin(:tclk).drive(1)
-  dut.pin(:tdi).drive(1)
-  dut.pin(:tdo).assert(1)
-  dut.pin(:tms).drive(1)
-  
-  cc 'should get a repeat 5 vector'
-  tester.cycle repeat: 5
-  tester.cycle
-  tester.store(dut.pin(:tdo))
-  
-  tester.cycle
-  tester.cycle
-  
-  dut.pin(:tclk).drive(0)
-  tester.store!(dut.pin(:tdo))
-  tester.cycle
-  tester.cycle
-  tester.store!(dut.pin(:pa))
-  tester.cycle
+Pattern.create(name: "test_store") do
+  tester.capture_style = :digcap
+  # configure tdo to non-default settings
+  tester.capture_memory :digcap do |mem|
+    mem.pin :tdo, size: 8
+  end
+
+  tester.cycle
+
+  dut.pin(:tclk).drive(1)
+  dut.pin(:tdi).drive(1)
+  dut.pin(:tdo).assert(1)
+  dut.pin(:tms).drive(1)
+  
+  cc 'should get a repeat 5 vector'
+  tester.cycle repeat: 5
+  tester.cycle
+  tester.store(dut.pin(:tdo))
+  
+  tester.cycle
+  tester.cycle
+  
+  dut.pin(:tclk).drive(0)
+  tester.store!(dut.pin(:tdo))
+  tester.cycle
+  tester.cycle
+  tester.store!(dut.pin(:pa))
+  tester.cycle
 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
-  end
-
-end
+Flow.create do |options|
+
+  if_enable 'additional_erase', :or => options[:force] do
+    func :erase_all
+  end
+
+end

data/program/_efa_resources.rb

@@ -1,7 +1,7 @@
-Resources.create do |options|
-
-  func :bitmap_all0
-
-  import 'iv_resources', :number => 3
-
-end
+Resources.create do |options|
+
+  func :bitmap_all0
+
+  import 'iv_resources', :number => 3
+
+end

data/program/_erase.rb

@@ -1,25 +1,25 @@
-# A sub flow is a flow like any other.
-# However the name should begin with
-# _ to indicate that it is a sub
-# flow  this will prevent it being
-# generated as a top-level flow by
-# Origen.
-# Any arguments passed in when
-# instantiating this flow will be available via a hash as the second
-# argument, here called options, although the naming is arbitrary.
-Flow.create do |options|
-
-  # Define default options
-  options = { :pulses      => 4,
-              :post_verify => true,
-  }.merge(options)
-
-  options[:pulses].times do
-    func :erase_all
-  end
-
-  if options[:post_verify]
-    import 'erase_vfy'
-  end
-
-end
+# A sub flow is a flow like any other.
+# However the name should begin with
+# _ to indicate that it is a sub
+# flow  this will prevent it being
+# generated as a top-level flow by
+# Origen.
+# Any arguments passed in when
+# instantiating this flow will be available via a hash as the second
+# argument, here called options, although the naming is arbitrary.
+Flow.create do |options|
+
+  # Define default options
+  options = { :pulses      => 4,
+              :post_verify => true,
+  }.merge(options)
+
+  options[:pulses].times do
+    func :erase_all
+  end
+
+  if options[:post_verify]
+    import 'erase_vfy'
+  end
+
+end

data/program/_erase_vfy.rb

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

data/program/_iv_resources.rb

@@ -1,10 +1,10 @@
-Resources.create do |options|
-
-  options = { :number => 2,
-  }.merge(options)
-
-  options[:number].times do |x|
-    func "bitcell_iv_#{x}"
-  end
-
-end
+Resources.create do |options|
+
+  options = { :number => 2,
+  }.merge(options)
+
+  options[:number].times do |x|
+    func "bitcell_iv_#{x}"
+  end
+
+end

data/program/basic_interface.rb

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

data/program/components/_prb1_main.rb

@@ -0,0 +1,212 @@
+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'
+
+  # Control the build process based on
+  # the current target
+  if $dut.has_margin0_bug?
+    func 'normal_read_ckbd'
+  else
+    func 'margin_read0_ckbd'
+  end
+
+  # Include a sub flow, example of
+  # parameter passing
+  import '../erase', :pulses => 6
+
+  # Render an ERB template, or raw
+  # text file
+  if $tester.j750?
+    flow.render 'templates/j750/vt_flow', :include_tifr => true
+  end
+
+  log 'Should be v1'
+  func :program_ckbd
+  log 'Should be v2'
+  func :program_ckbd, :duration => :dynamic
+  log 'Should be v1'
+  func :program_ckbd
+  log 'Should be v2'
+  func :program_ckbd, :duration => :dynamic
+
+  log 'Should be a v1 test instance group'
+  func :program_ckbd, :by_block => true
+  log 'Should be a v2 test instance group'
+  func :program_ckbd, :by_block => true, :duration => :dynamic
+  log 'Should be a v1 test instance group'
+  func :program_ckbd, :by_block => true
+  log 'Should be a v2 test instance group'
+  func :program_ckbd, :by_block => true, :duration => :dynamic
+
+  # Test job conditions
+  func :p1_only_test, :if_job => :p1
+  if_job [:p1, :p2] do
+    func :p1_or_p2_only_test
+  end
+  func :not_p1_test, :unless_job => :p1
+  func :not_p1_or_p2_test, :unless_job => [:p1, :p2]
+  unless_job [:p1, :p2] do
+    func :another_not_p1_or_p2_test
+  end
+
+  log 'Verify that a test with an external instance works'
+  por
+
+  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
+  unless_job :p2 do
+    func :erase_all, :context => :current  # Job should be P1
+    func :erase_all                        # Job should be !P2
+  end
+
+  # Deliver an initial erase pulse
+  func :erase_all
+
+  # Deliver additional erase pulses as required until it verifies, maximum of 5 additional pulses
+  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}"
+    # Run this test only if the given verify failed
+    func :erase_all, :if_failed => "erase_vfy_#{x}"
+  end
+
+  # A final verify to set the binning
+  func :margin_read1_all1
+
+  log 'Test if enable'
+  func :erase_all, :if_enable => 'do_erase'
+
+  if_enable 'do_erase' do
+    func :erase_all
+  end
+
+  log 'Test unless enable'
+  func :erase_all, :unless_enable => 'no_extra_erase'
+
+  unless_enable 'no_extra_erase' do
+    func :erase_all
+    func :erase_all
+  end
+
+  func :erase_all
+  func :erase_all
+
+  log 'Test if_passed'
+  func :erase_all, :id => 'erase_passed_1'
+  func :erase_all, :id => 'erase_passed_2'
+
+  func :margin_read1_all1, :if_passed => 'erase_passed_1'
+  if_passed 'erase_passed_2' do
+    func :margin_read1_all1
+  end
+
+  log 'Test unless_passed'
+  func :erase_all, :id => 'erase_passed_3'
+  func :erase_all, :id => 'erase_passed_4'
+
+  func :margin_read1_all1, :unless_passed => 'erase_passed_3'
+  unless_passed 'erase_passed_4' do
+    func :margin_read1_all1
+  end
+
+  log 'Test if_failed'
+  func :erase_all, :id => 'erase_failed_1'
+  func :erase_all, :id => 'erase_failed_2'
+
+  func :margin_read1_all1, :if_failed => 'erase_failed_1'
+  if_failed 'erase_failed_2' do
+    func :margin_read1_all1
+  end
+
+  log 'Test unless_failed'
+  func :erase_all, :id => 'erase_failed_3'
+  func :erase_all, :id => 'erase_failed_4'
+
+  func :margin_read1_all1, :unless_failed => 'erase_failed_3'
+  unless_failed 'erase_failed_4' do
+    func :margin_read1_all1
+  end
+
+  log 'Test if_ran'
+  func :erase_all, :id => 'erase_ran_1'
+  func :erase_all, :id => 'erase_ran_2'
+
+  func :margin_read1_all1, :if_ran => 'erase_ran_1'
+  if_ran 'erase_ran_2' do
+    func :margin_read1_all1
+  end
+
+  log 'Test unless_ran'
+  func :erase_all, :id => 'erase_ran_3'
+  func :erase_all, :id => 'erase_ran_4'
+
+  func :margin_read1_all1, :unless_ran => 'erase_ran_3'
+  unless_ran 'erase_ran_4' do
+    func :margin_read1_all1
+  end
+
+  log 'Verify that job context wraps import'
+  if_job :fr do
+    import '../erase'
+  end
+
+  log 'Verify that job context wraps enable block within an import'
+  if_job :fr do
+    import '../additional_erase'
+    import '../additional_erase', :force => true
+  end
+
+  log 'Verify that flow.cz works...'
+  func :margin_read1_all1, :pin_levels => :cz, :cz_setup => 'vbplus_sweep'
+
+  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'
+  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'
+
+  log 'Verify that MTO template works...'
+  mto_memory :mto_read1_all1
+
+  if tester.uflex?
+    log 'import statement'
+    import 'temp' 
+
+    log 'direct call'
+    
+    meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
+    meas :bgap_voltage_meas1
+  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
+  end
+
+  log 'Speed binning example bug from video 5'
+  group "200Mhz Tests", id: :g200 do
+    test :test200_1
+    test :test200_2
+    test :test200_3
+  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
+  end
+
+  pass 2, if_ran: :g100
+
+  pass 1, description: "Good die!", softbin: 1
+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
-
-end
+Flow.create do |options|
+
+  meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
+  meas :bgap_voltage_meas1
+
+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 :test2
-
-  custom :test3
-
-end
+# This flow is used to test custom test method API
+Flow.create interface: 'OrigenTesters::Test::CustomTestInterface' do
+
+  custom :test1
+
+  custom :test2
+
+  custom :test3
+
+end

data/program/flow_control.rb

@@ -1,321 +1,329 @@
-# Flow to exercise the Flow Control API
-#
-# Some of the other flows also cover the flow control API and those tests are used
-# to guarantee that the test ID references work when sub-flows are involved.
-# This flow provides a full checkout of all flow control methods.
-Flow.create interface: 'OrigenTesters::Test::Interface' do
-
-  self.resources_filename = 'flow_control'
-
-  log "Test that if_failed works"
-  func :read1, id: :t1, bin: 10
-  func :erase1, if_failed: :t1, bin: 12
-
-  log "Test the block form of if_failed"
-  func :read2, id: :t2, bin: 10
-  if_failed :t2 do
-    func :erase2
-    func :erase2
-  end
-
-  log "Test that if_passed works"
-  func :read1, id: :t3, bin: 10
-  func :pgm1, if_passed: :t3
-
-  log "Test the block form of if_passed"
-  func :read2, id: :t4, bin: 10
-  if_passed :t4 do
-    func :pgm1
-    func :pgm1
-  end
-
-  log "Test that if_ran works"
-  func :pgm, id: :t5, bin: 10
-  func :read0, if_ran: :t5
-
-  log "Test the block form of if_ran"
-  func :pgm, id: :t6, bin: 10
-  if_ran :t6 do
-    func :read0
-    func :read0
-  end
-
-  log "Test that unless_ran works"
-  func :pgm, id: :t7, bin: 10
-  func :read0, unless_ran: :t7
-
-  log "Test the block form of unless_ran"
-  func :pgm, id: :t8, bin: 10
-  unless_ran :t8 do
-    func :read0
-    func :read0
-  end
-
-  log "Test that if_job works"
-  func :cold_test, if_job: :fc
-
-  log "Test the block form of if_job"
-  if_job [:prb1, :prb2] do
-    func :probe_only_test1
-    func :probe_only_test2
-  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
-  end
-
-  log "Test that unless_job works"
-  func :warmish_test, unless_job: :fc
-
-  log "Test the block form of unless_job"
-  unless_job [:prb1, :prb2] do
-    func :ft_only_test1
-    func :ft_only_test2
-  end
-
-  log "Test that if_enable works"
-  func :extra_test, if_enable: :extras
-
-  log "Test the block form of if_enable"
-  if_enable :cz do
-    func :cz_test1
-    func :cz_test2
-  end
-
-  log "Test that unless_enable works"
-  func :long_test, unless_enable: :quick
-
-  log "Test the block form of unless_enable"
-  unless_enable :quick do
-    func :long_test1
-    func :long_test2
-  end
-
-  log "Test that if_any_failed works"
-  func :test1, id: :ifa1
-  func :test2, id: :ifa2
-  func :test3, if_any_failed: [:ifa1, :ifa2]
-
-  log "Test the block form of if_any_failed"
-  func :test1, id: :oof_passcode1
-  func :test2, id: :oof_passcode2
-  if_any_failed :oof_passcode1, :oof_passcode2 do
-    func :test3
-    func :test4
-  end
-
-  log "Test that if_all_failed works"
-  func :test1, id: :ifall1
-  func :test2, id: :ifall2
-  func :test3, if_all_failed: [:ifall1, :ifall2]
-
-  log "Test the block form of if_all_failed"
-  func :test1, id: :ifallb1
-  func :test2, id: :ifallb2
-  if_all_failed [:ifallb1, :ifallb2] do
-    func :test3
-    func :test4
-  end
-
-  log "Test that if_any_passed works"
-  func :test1, id: :ifap1
-  func :test2, id: :ifap2
-  func :test3, if_any_passed: [:ifap1, :ifap2]
-
-  log "Test the block form of if_any_passed"
-  func :test1, id: :ifapb1
-  func :test2, id: :ifapb2
-  if_any_passed :ifapb1, :ifapb2 do
-    func :test3
-    func :test4
-  end
-
-  log "Test that if_all_passed works"
-  func :test1, id: :ifallp1
-  func :test2, id: :ifallp2
-  func :test3, if_all_passed: [:ifallp1, :ifallp2]
-
-  log "Test the block form of if_all_passed"
-  func :test1, id: :ifallpb1
-  func :test2, id: :ifallpb2
-  if_all_passed :ifallpb1, :ifallpb2 do
-    func :test3
-    func :test4
-  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
-  end
-
-  group "grp2", if_failed: :grp1 do
-    func :grp2_test1, bin: 5
-    func :grp2_test2, bin: 5
-    func :grp2_test3, bin: 5
-  end
-
-  log "Another group-level dependencies test based on a real life use case"
-  func :gt1, bin: 90
-  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
-  end
-  func :gt2, bin: 90, if_failed: :gt_grp1
-  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
-  end
-  func :gt3, bin: 90, if_failed: :gt_grp2
-
-  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
-    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
-      # Test dependency on a test from another group
-      func :lev2_test5, if_failed: :l1t5, bin: 12
-    end
-  end
-
-  log "Test nested conditions on a group"
-  func :nt1, bin: 10, id: :nt1
-  if_failed :nt1 do
-    func :nt2, bin: 11, id: :nt2
-    group "ntg1", id: :ntg1, if_passed: :nt2 do
-      func :nt3, bin: 12
-    end
-    group "ntg2", id: :ntg2, if_failed: :nt2 do
-      func :nt4, bin: 13
-    end
-  end
-
-  log "Embedded conditional tests 1"
-  func :test1, id: :ect1_1
-  if_failed :ect1_1 do
-    func :test2
-    func :test3, id: :ect1_3
-    if_failed :ect1_3 do
-      func :test4
-    end
-  end
-
-  log "Embedded conditional tests 2"
-  func :test1, id: :ect2_1
-  func :test2, id: :ect2_2
-  if_failed :ect2_1 do
-    func :test3, if_failed: :ect2_2
-    func :test4, if_enable: "en1"
-    if_enable "en2" do
-      func :test5
-      func :test6
-    end
-    func :test7
-  end
-  func :test8
-
-  log "Nested enable word test 1"
-  if_enable "word1" do
-    func :test1
-    if_enable "word2" do
-      func :test2
-    end
-  end
-
-  log "Nested enable word test 2"
-  if_enable "word1" do
-    func :test1
-    unless_enable "word2" do
-      func :test2
-    end
-  end
-
-  log "Nested enable word test 3"
-  if_enable ["word1", "word2"] do
-    func :test1
-    if_enable "word3" do
-      func :test2
-    end
-  end
-
-  log "Conditional enable test"
-  enable :nvm_minimum_ft, if_enable: "nvm_minimum_room", if_job: :fr
-  enable :nvm_minimum_ft, if_enable: "nvm_minimum_cold", if_job: :fc
-  disable :nvm_minimum_ft, if_enable: "nvm_minimum_hot", if_job: :fh
-
-  log "Test enable words that wrap a lot of tests"
-  if_enable :word1 do
-    5.times do
-      func :test1
-    end
-    if_enable :word2 do
-      4.times do
-        func :test1
-      end
-      func :test1, enable: :word3
-    end
-  end
-
-  if tester.j750?
-    log "This should generate an AND flag"
-    func :test1, id: :at1
-    func :test2, id: :at2
-    if_failed :at1 do
-      func :test3, if_failed: :at2
-      # This should re-use the AND flag, rather than create a duplicate
-      func :test4, if_failed: :at2
-    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
-    if_failed :at11 do
-      func :test2, id: :at21
-      func :test3, if_failed: :at21
-      func :test4, if_failed: :at21
-    end 
-  end
-
-  log "Manual flag setting"
-  test :test1, on_fail: { set_flag: :my_flag }, continue: true
-  test :test2, if_flag: :my_flag
-  unless_flag :my_flag do
-    test :test3
-  end
-  
-  if tester.v93k?
-    log "This should retain the set-run-flag in the else conditional"
-    func :test22, id: :at22
-    
-    if_failed :at22 do
-      func :test22a
-      func :test22b
-    end 
-    
-    func :test22c
-    func :test22d
-  
-    if_failed :at22 do
-      func :test22e
-      func :test22f
-    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
-  end
-end
+# Flow to exercise the Flow Control API
+#
+# Some of the other flows also cover the flow control API and those tests are used
+# to guarantee that the test ID references work when sub-flows are involved.
+# This flow provides a full checkout of all flow control methods.
+Flow.create interface: 'OrigenTesters::Test::Interface' do
+
+  self.resources_filename = 'flow_control'
+
+  log "Test that if_failed works"
+  func :read1, id: :t1, bin: 10
+  func :erase1, if_failed: :t1, bin: 12
+
+  log "Test the block form of if_failed"
+  func :read2, id: :t2, bin: 10
+  if_failed :t2 do
+    func :erase2
+    func :erase2
+  end
+
+  log "Test that if_passed works"
+  func :read1, id: :t3, bin: 10
+  func :pgm1, if_passed: :t3
+
+  log "Test the block form of if_passed"
+  func :read2, id: :t4, bin: 10
+  if_passed :t4 do
+    func :pgm1
+    func :pgm1
+  end
+
+  log "Test that if_ran works"
+  func :pgm, id: :t5, bin: 10
+  func :read0, if_ran: :t5
+
+  log "Test the block form of if_ran"
+  func :pgm, id: :t6, bin: 10
+  if_ran :t6 do
+    func :read0
+    func :read0
+  end
+
+  log "Test that unless_ran works"
+  func :pgm, id: :t7, bin: 10
+  func :read0, unless_ran: :t7
+
+  log "Test the block form of unless_ran"
+  func :pgm, id: :t8, bin: 10
+  unless_ran :t8 do
+    func :read0
+    func :read0
+  end
+
+  log "Test that if_job works"
+  func :cold_test, if_job: :fc
+
+  log "Test the block form of if_job"
+  if_job [:prb1, :prb2] do
+    func :probe_only_test1
+    func :probe_only_test2
+  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
+  end
+
+  log "Test that unless_job works"
+  func :warmish_test, unless_job: :fc
+
+  log "Test the block form of unless_job"
+  unless_job [:prb1, :prb2] do
+    func :ft_only_test1
+    func :ft_only_test2
+  end
+
+  log "Test that if_enable works"
+  func :extra_test, if_enable: :extras
+
+  log "Test the block form of if_enable"
+  if_enable :cz do
+    func :cz_test1
+    func :cz_test2
+  end
+
+  log "Test that unless_enable works"
+  func :long_test, unless_enable: :quick
+
+  log "Test the block form of unless_enable"
+  unless_enable :quick do
+    func :long_test1
+    func :long_test2
+  end
+
+  log "Test that if_any_failed works"
+  func :test1, id: :ifa1
+  func :test2, id: :ifa2
+  func :test3, if_any_failed: [:ifa1, :ifa2]
+
+  log "Test the block form of if_any_failed"
+  func :test1, id: :oof_passcode1
+  func :test2, id: :oof_passcode2
+  if_any_failed :oof_passcode1, :oof_passcode2 do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_all_failed works"
+  func :test1, id: :ifall1
+  func :test2, id: :ifall2
+  func :test3, if_all_failed: [:ifall1, :ifall2]
+
+  log "Test the block form of if_all_failed"
+  func :test1, id: :ifallb1
+  func :test2, id: :ifallb2
+  if_all_failed [:ifallb1, :ifallb2] do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_any_passed works"
+  func :test1, id: :ifap1
+  func :test2, id: :ifap2
+  func :test3, if_any_passed: [:ifap1, :ifap2]
+
+  log "Test the block form of if_any_passed"
+  func :test1, id: :ifapb1
+  func :test2, id: :ifapb2
+  if_any_passed :ifapb1, :ifapb2 do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_all_passed works"
+  func :test1, id: :ifallp1
+  func :test2, id: :ifallp2
+  func :test3, if_all_passed: [:ifallp1, :ifallp2]
+
+  log "Test the block form of if_all_passed"
+  func :test1, id: :ifallpb1
+  func :test2, id: :ifallpb2
+  if_all_passed :ifallpb1, :ifallpb2 do
+    func :test3
+    func :test4
+  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
+  end
+
+  group "grp2", if_failed: :grp1 do
+    func :grp2_test1, bin: 5
+    func :grp2_test2, bin: 5
+    func :grp2_test3, bin: 5
+  end
+
+  log "Another group-level dependencies test based on a real life use case"
+  func :gt1, bin: 90
+  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
+  end
+  func :gt2, bin: 90, if_failed: :gt_grp1
+  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
+  end
+  func :gt3, bin: 90, if_failed: :gt_grp2
+
+  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
+    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
+      # Test dependency on a test from another group
+      func :lev2_test5, if_failed: :l1t5, bin: 12
+    end
+  end
+
+  log "Test nested conditions on a group"
+  func :nt1, bin: 10, id: :nt1
+  if_failed :nt1 do
+    func :nt2, bin: 11, id: :nt2
+    group "ntg1", id: :ntg1, if_passed: :nt2 do
+      func :nt3, bin: 12
+    end
+    group "ntg2", id: :ntg2, if_failed: :nt2 do
+      func :nt4, bin: 13
+    end
+  end
+
+  log "Embedded conditional tests 1"
+  func :test1, id: :ect1_1
+  if_failed :ect1_1 do
+    func :test2
+    func :test3, id: :ect1_3
+    if_failed :ect1_3 do
+      func :test4
+    end
+  end
+
+  log "Embedded conditional tests 2"
+  func :test1, id: :ect2_1
+  func :test2, id: :ect2_2
+  if_failed :ect2_1 do
+    func :test3, if_failed: :ect2_2
+    func :test4, if_enable: "en1"
+    if_enable "en2" do
+      func :test5
+      func :test6
+    end
+    func :test7
+  end
+  func :test8
+
+  log "Nested enable word test 1"
+  if_enable "word1" do
+    func :test1
+    if_enable "word2" do
+      func :test2
+    end
+  end
+
+  log "Nested enable word test 2"
+  if_enable "word1" do
+    func :test1
+    unless_enable "word2" do
+      func :test2
+    end
+  end
+
+  log "Nested enable word test 3"
+  if_enable ["word1", "word2"] do
+    func :test1
+    if_enable "word3" do
+      func :test2
+    end
+  end
+
+  log "Conditional enable test"
+  enable :nvm_minimum_ft, if_enable: "nvm_minimum_room", if_job: :fr
+  enable :nvm_minimum_ft, if_enable: "nvm_minimum_cold", if_job: :fc
+  disable :nvm_minimum_ft, if_enable: "nvm_minimum_hot", if_job: :fh
+
+  log "Test enable words that wrap a lot of tests"
+  if_enable :word1 do
+    5.times do
+      func :test1
+    end
+    if_enable :word2 do
+      4.times do
+        func :test1
+      end
+      func :test1, enable: :word3
+    end
+  end
+
+  if tester.j750?
+    log "This should generate an AND flag"
+    func :test1, id: :at1
+    func :test2, id: :at2
+    if_failed :at1 do
+      func :test3, if_failed: :at2
+      # This should re-use the AND flag, rather than create a duplicate
+      func :test4, if_failed: :at2
+    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
+    if_failed :at11 do
+      func :test2, id: :at21
+      func :test3, if_failed: :at21
+      func :test4, if_failed: :at21
+    end 
+  end
+
+  log "Manual flag setting"
+  test :test1, on_fail: { set_flag: :my_flag }, continue: true
+  test :test2, if_flag: :my_flag
+  unless_flag :my_flag do
+    test :test3
+  end
+  
+  if tester.v93k?
+    log "This should retain the set-run-flag in the else conditional"
+    func :test22, id: :at22
+    
+    if_failed :at22 do
+      func :test22a
+      func :test22b
+    end 
+    
+    func :test22c
+    func :test22d
+  
+    if_failed :at22 do
+      func :test22e
+      func :test22f
+    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
+
+    log "Tests of render"
+
+    if_flag :my_flag do
+      render 'multi_bin;'
+
+      func :test36, on_fail: { render: 'multi_bin;' }
+    end
+  end
+end