origen_testers 0.13.1 → 0.13.2

data/config/users.rb

@@ -1,18 +1,18 @@
-# This file defines the users associated with your project, it is basically the 
-# mailing list for release notes.
-#
-# You can split your users into "admin" and "user" groups, the main difference 
-# between the two is that admin users will get all tag emails, users will get
-# emails on external/official releases only.
-#
-# Users are also prohibited from running the "origen tag" task, but this is 
-# really just to prevent a casual user from executing it inadvertently and is
-# not intended to be a serious security gate.
-module Origen
-  module Users
-    def users
-      @users ||= [
-      ]
-    end
-  end
-end
+# This file defines the users associated with your project, it is basically the 
+# mailing list for release notes.
+#
+# You can split your users into "admin" and "user" groups, the main difference 
+# between the two is that admin users will get all tag emails, users will get
+# emails on external/official releases only.
+#
+# Users are also prohibited from running the "origen tag" task, but this is 
+# really just to prevent a casual user from executing it inadvertently and is
+# not intended to be a serious security gate.
+module Origen
+  module Users
+    def users
+      @users ||= [
+      ]
+    end
+  end
+end

data/config/version.rb

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

data/lib/commands/build.rb

@@ -1,69 +1,69 @@
-require 'optparse'
-require 'pathname'
-
-options = {}
-
-opt_parser = OptionParser.new do |opts|
-  opts.banner = <<-EOT
-Build a test program from a collection of sub-programs.
-
-The user must supply a manifest file to define the test program's flows. Each flow definition will state
-which sub-program modules that the flow is comprised of, and the order in which they should be executed.
-The manifest file is written in YAML format and a new manifest file can be generated for the current target
-tester by running the command with the --new option.
-
-Upon launch the command will parse all of the sub-program files into memory. It will then combine and render
-them out to new files, making edits on the fly where necessary to enable the sub-programs to co-exist within
-the same test program.
-The generated files can be tracked and diff-checked by Origen in the usual way.
-
-Usage: origen testers:build MANIFEST [options]
-  EOT
-  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
-  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
-  opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
-  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
-  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
-  opts.on('-n', '--new', 'Generate a new manifest file for the current tester platform') { options[:new] = true }
-  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
-  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
-  opts.separator ''
-  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
-end
-
-opt_parser.parse! ARGV
-
-Origen.load_application
-Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
-Origen.environment.temporary = options[:environment] if options[:environment]
-Origen.target.temporary = options[:target] if options[:target]
-Origen.app.load_target!
-
-manifest = ARGV.first
-
-unless manifest
-  puts 'You must supply a path to a manifest file'
-  exit 1
-end
-unless $tester.v93k?
-  puts "Sorry but the #{$tester.name} tester is not yet supported by the build command :-("
-  exit 1
-end
-
-if options[:new]
-  template = "#{Origen.root!}/templates/manifest/#{$tester.name}.yaml.erb"
-  manifest += '.yaml' unless manifest =~ /\..*/
-
-  Origen.app.runner.launch action:            :compile,
-                           files:             template,
-                           output:            Pathname.new(manifest).dirname.to_s,
-                           output_file_name:  Pathname.new(manifest).basename.to_s,
-                           quiet:             true,
-                           check_for_changes: false
-
-  puts "New #{$tester.name} manifest created: #{manifest}"
-  exit 0
-end
-
-# Ideally should auto select the correct test platform here, for now hardcoding to V93K
-eval("#{$tester.class}::Builder").new.build(manifest, options)
+require 'optparse'
+require 'pathname'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Build a test program from a collection of sub-programs.
+
+The user must supply a manifest file to define the test program's flows. Each flow definition will state
+which sub-program modules that the flow is comprised of, and the order in which they should be executed.
+The manifest file is written in YAML format and a new manifest file can be generated for the current target
+tester by running the command with the --new option.
+
+Upon launch the command will parse all of the sub-program files into memory. It will then combine and render
+them out to new files, making edits on the fly where necessary to enable the sub-programs to co-exist within
+the same test program.
+The generated files can be tracked and diff-checked by Origen in the usual way.
+
+Usage: origen testers:build MANIFEST [options]
+  EOT
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-n', '--new', 'Generate a new manifest file for the current tester platform') { options[:new] = true }
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
+  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+
+Origen.load_application
+Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+Origen.app.load_target!
+
+manifest = ARGV.first
+
+unless manifest
+  puts 'You must supply a path to a manifest file'
+  exit 1
+end
+unless $tester.v93k?
+  puts "Sorry but the #{$tester.name} tester is not yet supported by the build command :-("
+  exit 1
+end
+
+if options[:new]
+  template = "#{Origen.root!}/templates/manifest/#{$tester.name}.yaml.erb"
+  manifest += '.yaml' unless manifest =~ /\..*/
+
+  Origen.app.runner.launch action:            :compile,
+                           files:             template,
+                           output:            Pathname.new(manifest).dirname.to_s,
+                           output_file_name:  Pathname.new(manifest).basename.to_s,
+                           quiet:             true,
+                           check_for_changes: false
+
+  puts "New #{$tester.name} manifest created: #{manifest}"
+  exit 0
+end
+
+# Ideally should auto select the correct test platform here, for now hardcoding to V93K
+eval("#{$tester.class}::Builder").new.build(manifest, options)

data/lib/commands/run.rb

@@ -1,48 +1,48 @@
-require 'optparse'
-require 'pathname'
-
-options = {}
-
-opt_parser = OptionParser.new do |opts|
-  opts.banner = <<-EOT
-Run (execute a flow) of the last test program generated for the given target.
-
-Usage: origen testers:run FLOW [options]
-  EOT
-  opts.on('--enable FLAG,FLAG', Array, 'Comma-separated list of flow flags to enable') { |flags| options[:flow_flags] = flags }
-  opts.on('--job NAME', String, 'Job name to enable') { |job| options[:job] = job }
-  opts.on('--fail ID,ID', Array, 'Comma-separated list of test IDs to fail') { |ids| options[:failed_test_ids] = ids }
-  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
-  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
-  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
-  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
-  opts.separator ''
-  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
-end
-
-opt_parser.parse! ARGV
-
-Origen.environment.temporary = options[:environment] if options[:environment]
-Origen.target.temporary = options[:target] if options[:target]
-# Origen.app.load_target!
-
-program =  OrigenTesters.program
-
-unless program
-  puts 'Sorry, but there is no program model available for the current target, generate the program then retry'
-  exit 1
-end
-
-unless ARGV.first
-  if OrigenTesters.program.flows.keys.size == 1
-    ARGV << OrigenTesters.program.flows.keys.first
-  else
-    puts 'You must supply the name of the flow to execute, the current program has these flows'
-    puts OrigenTesters.program.flows.keys
-    exit 1
-  end
-end
-
-ARGV.each do |flow|
-  OrigenTesters.program.flows[flow.to_sym].run(options)
-end
+require 'optparse'
+require 'pathname'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Run (execute a flow) of the last test program generated for the given target.
+
+Usage: origen testers:run FLOW [options]
+  EOT
+  opts.on('--enable FLAG,FLAG', Array, 'Comma-separated list of flow flags to enable') { |flags| options[:flow_flags] = flags }
+  opts.on('--job NAME', String, 'Job name to enable') { |job| options[:job] = job }
+  opts.on('--fail ID,ID', Array, 'Comma-separated list of test IDs to fail') { |ids| options[:failed_test_ids] = ids }
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+# Origen.app.load_target!
+
+program =  OrigenTesters.program
+
+unless program
+  puts 'Sorry, but there is no program model available for the current target, generate the program then retry'
+  exit 1
+end
+
+unless ARGV.first
+  if OrigenTesters.program.flows.keys.size == 1
+    ARGV << OrigenTesters.program.flows.keys.first
+  else
+    puts 'You must supply the name of the flow to execute, the current program has these flows'
+    puts OrigenTesters.program.flows.keys
+    exit 1
+  end
+end
+
+ARGV.each do |flow|
+  OrigenTesters.program.flows[flow.to_sym].run(options)
+end

data/lib/origen_testers.rb

@@ -1,47 +1,47 @@
-require 'origen'
-require_relative '../config/application.rb'
-
-require 'active_support/concern'
-require 'require_all'
-require 'atp'
-require 'origen_testers/origen_ext/generator/flow'
-require 'origen_testers/origen_ext/generator/resources'
-require 'origen_testers/origen_ext/application/runner'
-require 'origen_testers/origen_ext/generator'
-
-module OrigenTesters
-  autoload :CommandBasedTester, 'origen_testers/command_based_tester'
-  autoload :VectorBasedTester,  'origen_testers/vector_based_tester'
-  autoload :Vector,             'origen_testers/vector'
-  autoload :VectorPipeline,     'origen_testers/vector_pipeline'
-  autoload :Interface,          'origen_testers/interface'
-  autoload :Generator,          'origen_testers/generator'
-  autoload :Parser,             'origen_testers/parser'
-  autoload :BasicTestSetups,    'origen_testers/basic_test_setups'
-  autoload :ProgramGenerators,  'origen_testers/program_generators'
-  autoload :Flow,               'origen_testers/flow'
-  autoload :NoInterface,        'origen_testers/no_interface'
-  autoload :MemoryStyle,        'origen_testers/memory_style'
-
-  # not yet autoload :Time,     'origen_testers/time'
-
-  # The documentation tester model has been removed, but this keeps some
-  # legacy code working e.g. $tester.is_a?(OrigenTesters::Doc)
-  class Doc
-  end
-
-  def self.program
-    f = "#{Flow::PROGRAM_MODELS_DIR}/#{Origen.target.name}"
-    if File.exist?(f)
-      ATP::Program.load(f)
-    end
-  end
-end
-
-require 'origen_testers/igxl_based_tester'
-require 'origen_testers/smartest_based_tester'
-require 'origen_testers/pattern_compilers'
-
-require 'origen_testers/callback_handlers'
-require 'origen_testers/origen_ext/pins/pin'
-require 'origen_testers/origen_ext/pins/pin_collection'
+require 'origen'
+require_relative '../config/application.rb'
+
+require 'active_support/concern'
+require 'require_all'
+require 'atp'
+require 'origen_testers/origen_ext/generator/flow'
+require 'origen_testers/origen_ext/generator/resources'
+require 'origen_testers/origen_ext/application/runner'
+require 'origen_testers/origen_ext/generator'
+
+module OrigenTesters
+  autoload :CommandBasedTester, 'origen_testers/command_based_tester'
+  autoload :VectorBasedTester,  'origen_testers/vector_based_tester'
+  autoload :Vector,             'origen_testers/vector'
+  autoload :VectorPipeline,     'origen_testers/vector_pipeline'
+  autoload :Interface,          'origen_testers/interface'
+  autoload :Generator,          'origen_testers/generator'
+  autoload :Parser,             'origen_testers/parser'
+  autoload :BasicTestSetups,    'origen_testers/basic_test_setups'
+  autoload :ProgramGenerators,  'origen_testers/program_generators'
+  autoload :Flow,               'origen_testers/flow'
+  autoload :NoInterface,        'origen_testers/no_interface'
+  autoload :MemoryStyle,        'origen_testers/memory_style'
+
+  # not yet autoload :Time,     'origen_testers/time'
+
+  # The documentation tester model has been removed, but this keeps some
+  # legacy code working e.g. $tester.is_a?(OrigenTesters::Doc)
+  class Doc
+  end
+
+  def self.program
+    f = "#{Flow::PROGRAM_MODELS_DIR}/#{Origen.target.name}"
+    if File.exist?(f)
+      ATP::Program.load(f)
+    end
+  end
+end
+
+require 'origen_testers/igxl_based_tester'
+require 'origen_testers/smartest_based_tester'
+require 'origen_testers/pattern_compilers'
+
+require 'origen_testers/callback_handlers'
+require 'origen_testers/origen_ext/pins/pin'
+require 'origen_testers/origen_ext/pins/pin_collection'

data/lib/origen_testers/api.rb

@@ -1,381 +1,381 @@
-module OrigenTesters
-  # This module implements the basic set of methods that a tester must have
-  # in order for Origen to talk to it.
-  #
-  # They can be overridden by tester specific classes and who may go on to add
-  # additional methods of their own.
-  #
-  # Essentially this API means that any class that includes Origen::Tester will
-  # function as a tester, although it might not do very much!
-  module API
-    attr_accessor :includes
-    attr_accessor :comment_level
-    attr_accessor :generating
-    # Get/Set the overlay style
-    #
-    # This method changes the way overlay is handled.
-    # The default value and possible settings is dependent on the individual tester.
-    #
-    # @example
-    #   tester.overlay_style = :label
-    attr_accessor :overlay_style
-    # Get/Set the capture style
-    #
-    # This method changes the way tester.store() implements the store
-    # The default value and possible settings is dependent on the individual tester.
-    #
-    # @example
-    #   tester.capture_style = :hram
-    attr_accessor :capture_style
-
-    def name
-      @name || self.class
-    end
-
-    def generate?
-      true
-    end
-
-    def generating_pattern?
-      @generating == :pattern
-    end
-
-    def generating_program?
-      @generating == :program
-    end
-
-    def pat_extension
-      @pat_extension || 'txt'
-    end
-    alias_method :pattern_extension, :pat_extension
-
-    def comment_char
-      @comment_char || '//'
-    end
-
-    def program_comment_char
-      @program_comment_char || comment_char
-    end
-
-    def pattern_header(*args)
-    end
-
-    def pattern_footer(*args)
-    end
-
-    def step_comment_prefix
-      @step_comment_prefix || '##'
-    end
-
-    def is_vector_based?
-      return @vector_based if defined?(@vector_based)
-      true
-    end
-
-    def is_command_based?
-      !is_vector_based?
-    end
-
-    def stil?
-      defined?(OrigenTesters::StilBasedTester::Base) &&
-        is_a?(OrigenTesters::StilBasedTester::Base)
-    end
-
-    def j750?
-      is_a?(OrigenTesters::IGXLBasedTester::J750)
-    end
-
-    def j750_hpt?
-      is_a?(OrigenTesters::IGXLBasedTester::J750_HPT)
-    end
-
-    def v93k?
-      is_a?(OrigenTesters::SmartestBasedTester::V93K)
-    end
-
-    def ultraflex?
-      is_a?(OrigenTesters::IGXLBasedTester::UltraFLEX)
-    end
-    alias_method :uflex?, :ultraflex?
-
-    def link?
-      !!(self.class.to_s =~ /^OrigenLink::/)
-    end
-
-    def doc?
-      false
-    end
-
-    def annotate(msg, options = {})
-    end
-
-    def diff_friendly_output=(value)
-      @diff_friendly_output = value
-    end
-
-    def diff_friendly_output?
-      !!@diff_friendly_output
-    end
-    alias_method :diff_friendly_output, :diff_friendly_output?
-
-    # Ignore fails on the given pins for the duration of the given block, this
-    # has the effect of temporarily setting the states of the given pins to
-    # don't care.
-    def ignore_fails(*pins)
-      pins.each(&:suspend)
-      yield
-      pins.each(&:resume)
-    end
-
-    # Output a comment in the pattern, normally you would not call this directly
-    # and instead use these shorthand methods:
-    #   cc "Some comment"
-    #   ss "A single line step comment"
-    #   step_comment do
-    #       cc "A multi line"
-    #       cc "step comment"
-    #   end
-    def c1(msg, options = {})
-      prefix = comment_char + ' '
-      prefix += step_comment_prefix + ' ' if @step_comment_on
-      push_comment(prefix + msg.to_s)
-    end
-
-    def c2(msg, options = {})
-      c1(msg, options)
-    end
-
-    def pattern_section(msg)
-      if generating_program?
-        yield
-      else
-        step_comment(msg)
-        yield
-      end
-    end
-
-    def ss(msg = nil)
-      div = step_comment_prefix.length
-      div = 1 if div == 0
-      c1(step_comment_prefix * (70 / div))
-      @step_comment_on = true
-      if block_given?
-        yield
-      else
-        c1(msg)
-      end
-      @step_comment_on = false
-      if $_testers_enable_vector_comments
-        timestamp = " #{execution_time_in_ns}ns #{step_comment_prefix}"
-        str = step_comment_prefix * (70 / div)
-        c1 str.sub(/#{step_comment_prefix}{#{timestamp.length - 1}}$/, timestamp)
-      else
-        c1(step_comment_prefix * (70 / div))
-      end
-    end
-
-    def snip(number, options = {})
-      yield
-    end
-
-    # Allows a section to be run without actually generating any vectors. This can be useful
-    # to ensure the pin states end up as they otherwise would have if the section had been run.
-    # Classic example of this is a subroutine pattern, wrap this around a call to the startup
-    # routine to ensure the pin states are as they would have been immediately after the startup.
-    # ==== Example
-    #   # Setup state as if I had run startup without actually doing so
-    #   $tester.inhibit_vectors_and_comments do
-    #       $soc.startup
-    #       $top.startup
-    #   end
-    def inhibit_vectors_and_comments
-      inhibit_vectors = @inhibit_vectors
-      inhibit_comments = @inhibit_comments
-      @inhibit_vectors = true
-      @inhibit_comments = true
-      yield
-      @inhibit_vectors = inhibit_vectors      # Restore to their initial state
-      @inhibit_comments = inhibit_comments
-    end
-
-    # Generate a vector.
-    # Calling this method will generate a vector in the output pattern based on the
-    # current pin states and timeset.
-    def cycle(options = {})
-      options = {
-        microcode: '',
-        timeset:   current_timeset,
-        pin_vals:  current_pin_vals,
-        repeat:    nil
-      }.merge(options)
-
-      if any_clocks_running?
-        update_running_clocks
-        if options[:repeat]
-          slice_repeats(options).each do |slice|
-            options[:repeat] = slice[0]
-            delay(options.delete(:repeat), options) do |options|
-              push_vector(options)
-            end
-            slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
-            options[:pin_vals] = current_pin_vals
-          end
-          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
-        else
-          push_vector(options)
-          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
-        end
-      else
-        if options[:repeat]
-          delay(options.delete(:repeat), options) do |options|
-            push_vector(options)
-          end
-        else
-          push_vector(options)
-        end
-      end
-    end
-
-    def import_test_time(file, options = {})
-      puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
-    end
-
-    def any_clocks_running?
-      @clocks_running.nil? ? false : @clocks_running.count > 0
-    end
-
-    def clocks_running
-      @clocks_running
-    end
-    alias_method :running_clocks, :clocks_running
-
-    def push_running_clock(pin)
-      @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
-    end
-
-    def pop_running_clock(pin)
-      fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
-      @clocks_running.delete(pin.name.to_s)
-    end
-
-    def slice_repeats(options = {})
-      slices = {}
-      repeat_ary = []
-      clocks_running.each do |name, clock_pin|
-        if clock_pin.next_edge < (cycle_count + options[:repeat])
-          if clock_pin.respond_to?(:duty_cycles)
-            d0, d1 = clock_pin.duty_cycles
-          else
-            # keep legacy support for older pin_clock styling, supports only 50% duty-cycle
-            d0 = clock_pin.half_period
-            d1 = clock_pin.half_period
-          end
-          pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(d0 + d1).to_a
-          pin_slices += ((clock_pin.next_edge + d0)..(cycle_count + options[:repeat])).step(d0 + d1).to_a
-          pin_slices.sort!
-          pin_slices.insert(0, cycle_count)
-        else
-          pin_slices = [cycle_count]
-        end
-        pin_slices.each do |cycle|
-          slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
-        end
-        slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
-      end
-      slices.keys.sort.each do |edge_cycles|
-        # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
-        repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
-      end
-
-      (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
-      repeat_ary[1..-1]
-    end
-
-    def pins_need_toggling
-      toggle_ary = []
-      clocks_running.each do |name, clock_pin|
-        toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
-      end
-      toggle_ary
-    end
-
-    def update_running_clocks
-      clocks_running.each do |name, clock_pin|
-        clock_pin.update_clock
-      end
-    end
-
-    def transaction
-      yield
-      true
-    end
-
-    def source_memory_config
-      @source_memory_config ||= {}
-    end
-
-    def capture_memory_config
-      @capture_memory_config ||= {}
-    end
-
-    # Configure source memory to a non-default setting
-    #
-    # This method changes the way the instruments statement gets rendered
-    # if the tester's source memory is used.
-    #
-    # @example
-    #   tester.source_memory :default do |mem|
-    #     mem.pin :tdi, size: 32, format: :long
-    #   end
-    #
-    # If called without a block, this method will return
-    # the instance of type OrigenTesters::MemoryStyle for
-    # the corresponding memory type
-    #
-    # @example
-    #   mem_style = tester.source_memory(:default)
-    #   mem_style.contained_pins.each do |pin|
-    #     attributes_hash = mem_style.accumulate_attributes(pin)
-    #
-    #   end
-    def source_memory(type = :default)
-      type = :subroutine if type == :default
-      source_memory_config[type] = OrigenTesters::MemoryStyle.new unless source_memory_config.key?(type)
-      if block_given?
-        yield source_memory_config[type]
-      else
-        source_memory_config[type]
-      end
-    end
-
-    # Configure capture memory to a non-default setting
-    #
-    # This method changes the way the instruments statement gets rendered
-    # if the tester's capture memory is used.
-    #
-    # @example
-    #   tester.capture_memory :default do |mem|
-    #     mem.pin :tdo, size: 32, format: :long
-    #   end
-    #
-    # If called without a block, this method will return
-    # the instance of type OrigenTesters::MemoryStyle for
-    # the corresponding memory type
-    #
-    # @example
-    #   mem_style = tester.capture_memory(:default)
-    #   if mem_style.contains_pin?(:tdo)
-    #     attributes_hash = mem_style.accumulate_attributes(:tdo)
-    #
-    #   end
-    def capture_memory(type = :default)
-      type = :hram if type == :default
-      capture_memory_config[type] = OrigenTesters::MemoryStyle.new unless capture_memory_config.key?(type)
-      if block_given?
-        yield capture_memory_config[type]
-      else
-        capture_memory_config[type]
-      end
-    end
-  end
-end
+module OrigenTesters
+  # This module implements the basic set of methods that a tester must have
+  # in order for Origen to talk to it.
+  #
+  # They can be overridden by tester specific classes and who may go on to add
+  # additional methods of their own.
+  #
+  # Essentially this API means that any class that includes Origen::Tester will
+  # function as a tester, although it might not do very much!
+  module API
+    attr_accessor :includes
+    attr_accessor :comment_level
+    attr_accessor :generating
+    # Get/Set the overlay style
+    #
+    # This method changes the way overlay is handled.
+    # The default value and possible settings is dependent on the individual tester.
+    #
+    # @example
+    #   tester.overlay_style = :label
+    attr_accessor :overlay_style
+    # Get/Set the capture style
+    #
+    # This method changes the way tester.store() implements the store
+    # The default value and possible settings is dependent on the individual tester.
+    #
+    # @example
+    #   tester.capture_style = :hram
+    attr_accessor :capture_style
+
+    def name
+      @name || self.class
+    end
+
+    def generate?
+      true
+    end
+
+    def generating_pattern?
+      @generating == :pattern
+    end
+
+    def generating_program?
+      @generating == :program
+    end
+
+    def pat_extension
+      @pat_extension || 'txt'
+    end
+    alias_method :pattern_extension, :pat_extension
+
+    def comment_char
+      @comment_char || '//'
+    end
+
+    def program_comment_char
+      @program_comment_char || comment_char
+    end
+
+    def pattern_header(*args)
+    end
+
+    def pattern_footer(*args)
+    end
+
+    def step_comment_prefix
+      @step_comment_prefix || '##'
+    end
+
+    def is_vector_based?
+      return @vector_based if defined?(@vector_based)
+      true
+    end
+
+    def is_command_based?
+      !is_vector_based?
+    end
+
+    def stil?
+      defined?(OrigenTesters::StilBasedTester::Base) &&
+        is_a?(OrigenTesters::StilBasedTester::Base)
+    end
+
+    def j750?
+      is_a?(OrigenTesters::IGXLBasedTester::J750)
+    end
+
+    def j750_hpt?
+      is_a?(OrigenTesters::IGXLBasedTester::J750_HPT)
+    end
+
+    def v93k?
+      is_a?(OrigenTesters::SmartestBasedTester::V93K)
+    end
+
+    def ultraflex?
+      is_a?(OrigenTesters::IGXLBasedTester::UltraFLEX)
+    end
+    alias_method :uflex?, :ultraflex?
+
+    def link?
+      !!(self.class.to_s =~ /^OrigenLink::/)
+    end
+
+    def doc?
+      false
+    end
+
+    def annotate(msg, options = {})
+    end
+
+    def diff_friendly_output=(value)
+      @diff_friendly_output = value
+    end
+
+    def diff_friendly_output?
+      !!@diff_friendly_output
+    end
+    alias_method :diff_friendly_output, :diff_friendly_output?
+
+    # Ignore fails on the given pins for the duration of the given block, this
+    # has the effect of temporarily setting the states of the given pins to
+    # don't care.
+    def ignore_fails(*pins)
+      pins.each(&:suspend)
+      yield
+      pins.each(&:resume)
+    end
+
+    # Output a comment in the pattern, normally you would not call this directly
+    # and instead use these shorthand methods:
+    #   cc "Some comment"
+    #   ss "A single line step comment"
+    #   step_comment do
+    #       cc "A multi line"
+    #       cc "step comment"
+    #   end
+    def c1(msg, options = {})
+      prefix = comment_char + ' '
+      prefix += step_comment_prefix + ' ' if @step_comment_on
+      push_comment(prefix + msg.to_s)
+    end
+
+    def c2(msg, options = {})
+      c1(msg, options)
+    end
+
+    def pattern_section(msg)
+      if generating_program?
+        yield
+      else
+        step_comment(msg)
+        yield
+      end
+    end
+
+    def ss(msg = nil)
+      div = step_comment_prefix.length
+      div = 1 if div == 0
+      c1(step_comment_prefix * (70 / div))
+      @step_comment_on = true
+      if block_given?
+        yield
+      else
+        c1(msg)
+      end
+      @step_comment_on = false
+      if $_testers_enable_vector_comments
+        timestamp = " #{execution_time_in_ns}ns #{step_comment_prefix}"
+        str = step_comment_prefix * (70 / div)
+        c1 str.sub(/#{step_comment_prefix}{#{timestamp.length - 1}}$/, timestamp)
+      else
+        c1(step_comment_prefix * (70 / div))
+      end
+    end
+
+    def snip(number, options = {})
+      yield
+    end
+
+    # Allows a section to be run without actually generating any vectors. This can be useful
+    # to ensure the pin states end up as they otherwise would have if the section had been run.
+    # Classic example of this is a subroutine pattern, wrap this around a call to the startup
+    # routine to ensure the pin states are as they would have been immediately after the startup.
+    # ==== Example
+    #   # Setup state as if I had run startup without actually doing so
+    #   $tester.inhibit_vectors_and_comments do
+    #       $soc.startup
+    #       $top.startup
+    #   end
+    def inhibit_vectors_and_comments
+      inhibit_vectors = @inhibit_vectors
+      inhibit_comments = @inhibit_comments
+      @inhibit_vectors = true
+      @inhibit_comments = true
+      yield
+      @inhibit_vectors = inhibit_vectors      # Restore to their initial state
+      @inhibit_comments = inhibit_comments
+    end
+
+    # Generate a vector.
+    # Calling this method will generate a vector in the output pattern based on the
+    # current pin states and timeset.
+    def cycle(options = {})
+      options = {
+        microcode: '',
+        timeset:   current_timeset,
+        pin_vals:  current_pin_vals,
+        repeat:    nil
+      }.merge(options)
+
+      if any_clocks_running?
+        update_running_clocks
+        if options[:repeat]
+          slice_repeats(options).each do |slice|
+            options[:repeat] = slice[0]
+            delay(options.delete(:repeat), options) do |options|
+              push_vector(options)
+            end
+            slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+            options[:pin_vals] = current_pin_vals
+          end
+          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+        else
+          push_vector(options)
+          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+        end
+      else
+        if options[:repeat]
+          delay(options.delete(:repeat), options) do |options|
+            push_vector(options)
+          end
+        else
+          push_vector(options)
+        end
+      end
+    end
+
+    def import_test_time(file, options = {})
+      puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
+    end
+
+    def any_clocks_running?
+      @clocks_running.nil? ? false : @clocks_running.count > 0
+    end
+
+    def clocks_running
+      @clocks_running
+    end
+    alias_method :running_clocks, :clocks_running
+
+    def push_running_clock(pin)
+      @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
+    end
+
+    def pop_running_clock(pin)
+      fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
+      @clocks_running.delete(pin.name.to_s)
+    end
+
+    def slice_repeats(options = {})
+      slices = {}
+      repeat_ary = []
+      clocks_running.each do |name, clock_pin|
+        if clock_pin.next_edge < (cycle_count + options[:repeat])
+          if clock_pin.respond_to?(:duty_cycles)
+            d0, d1 = clock_pin.duty_cycles
+          else
+            # keep legacy support for older pin_clock styling, supports only 50% duty-cycle
+            d0 = clock_pin.half_period
+            d1 = clock_pin.half_period
+          end
+          pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(d0 + d1).to_a
+          pin_slices += ((clock_pin.next_edge + d0)..(cycle_count + options[:repeat])).step(d0 + d1).to_a
+          pin_slices.sort!
+          pin_slices.insert(0, cycle_count)
+        else
+          pin_slices = [cycle_count]
+        end
+        pin_slices.each do |cycle|
+          slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
+        end
+        slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
+      end
+      slices.keys.sort.each do |edge_cycles|
+        # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
+        repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
+      end
+
+      (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
+      repeat_ary[1..-1]
+    end
+
+    def pins_need_toggling
+      toggle_ary = []
+      clocks_running.each do |name, clock_pin|
+        toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
+      end
+      toggle_ary
+    end
+
+    def update_running_clocks
+      clocks_running.each do |name, clock_pin|
+        clock_pin.update_clock
+      end
+    end
+
+    def transaction
+      yield
+      true
+    end
+
+    def source_memory_config
+      @source_memory_config ||= {}
+    end
+
+    def capture_memory_config
+      @capture_memory_config ||= {}
+    end
+
+    # Configure source memory to a non-default setting
+    #
+    # This method changes the way the instruments statement gets rendered
+    # if the tester's source memory is used.
+    #
+    # @example
+    #   tester.source_memory :default do |mem|
+    #     mem.pin :tdi, size: 32, format: :long
+    #   end
+    #
+    # If called without a block, this method will return
+    # the instance of type OrigenTesters::MemoryStyle for
+    # the corresponding memory type
+    #
+    # @example
+    #   mem_style = tester.source_memory(:default)
+    #   mem_style.contained_pins.each do |pin|
+    #     attributes_hash = mem_style.accumulate_attributes(pin)
+    #
+    #   end
+    def source_memory(type = :default)
+      type = :subroutine if type == :default
+      source_memory_config[type] = OrigenTesters::MemoryStyle.new unless source_memory_config.key?(type)
+      if block_given?
+        yield source_memory_config[type]
+      else
+        source_memory_config[type]
+      end
+    end
+
+    # Configure capture memory to a non-default setting
+    #
+    # This method changes the way the instruments statement gets rendered
+    # if the tester's capture memory is used.
+    #
+    # @example
+    #   tester.capture_memory :default do |mem|
+    #     mem.pin :tdo, size: 32, format: :long
+    #   end
+    #
+    # If called without a block, this method will return
+    # the instance of type OrigenTesters::MemoryStyle for
+    # the corresponding memory type
+    #
+    # @example
+    #   mem_style = tester.capture_memory(:default)
+    #   if mem_style.contains_pin?(:tdo)
+    #     attributes_hash = mem_style.accumulate_attributes(:tdo)
+    #
+    #   end
+    def capture_memory(type = :default)
+      type = :hram if type == :default
+      capture_memory_config[type] = OrigenTesters::MemoryStyle.new unless capture_memory_config.key?(type)
+      if block_given?
+        yield capture_memory_config[type]
+      else
+        capture_memory_config[type]
+      end
+    end
+  end
+end