Class: ATP::Flow

Inherits:
Object
  • Object
show all
Defined in:
lib/atp/flow.rb

Overview

Implements the main user API for building and interacting with an abstract test program

Constant Summary collapse

CONDITION_KEYS = 
{
  if_enabled:        :if_enabled,
  if_enable:         :if_enabled,
  enabled:           :if_enabled,
  enable_flag:       :if_enabled,
  enable:            :if_enabled,

  unless_enabled:    :unless_enabled,
  not_enabled:       :unless_enabled,
  disabled:          :unless_enabled,
  disable:           :unless_enabled,
  unless_enable:     :unless_enabled,

  if_failed:         :if_failed,
  unless_passed:     :if_failed,
  failed:            :if_failed,

  if_passed:         :if_passed,
  unless_failed:     :if_passed,
  passed:            :if_passed,

  if_any_failed:     :if_any_failed,
  unless_all_passed: :if_any_failed,

  if_all_failed:     :if_all_failed,
  unless_any_passed: :if_all_failed,

  if_any_passed:     :if_any_passed,
  unless_all_failed: :if_any_passed,

  if_all_passed:     :if_all_passed,
  unless_any_failed: :if_all_passed,

  if_ran:            :if_ran,
  if_executed:       :if_ran,

  unless_ran:        :unless_ran,
  unless_executed:   :unless_ran,

  job:               :if_job,
  jobs:              :if_job,
  if_job:            :if_job,
  if_jobs:           :if_job,

  unless_job:        :unless_job,
  unless_jobs:       :unless_job,

  if_flag:           :if_flag,

  unless_flag:       :unless_flag,

  group:             :group
}
CONDITION_NODE_TYPES = 
CONDITION_KEYS.values.uniq

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(program, name = nil, options = {}) ⇒ Flow

Returns a new instance of Flow.



65
66
67
68
69
70
71
 
# File 'lib/atp/flow.rb', line 65

def initialize(program, name = nil, options = {})
  name, options = nil, name if name.is_a?(Hash)
  extract_meta!(options)
  @program = program
  @name = name
  @pipeline = [n1(:flow, n1(:name, name))]
end

Instance Attribute Details

#description ⇒ Object

Returns the value of attribute description.



7
8
9
 
# File 'lib/atp/flow.rb', line 7

def description
  @description
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



5
6
7
 
# File 'lib/atp/flow.rb', line 5

def name
  @name
end

#program ⇒ Object (readonly)

Returns the value of attribute program.



5
6
7
 
# File 'lib/atp/flow.rb', line 5

def program
  @program
end

#source_file ⇒ Object

Returns the value of attribute source_file.



7
8
9
 
# File 'lib/atp/flow.rb', line 7

def source_file
  @source_file
end

#source_line_number ⇒ Object

Returns the value of attribute source_line_number.



7
8
9
 
# File 'lib/atp/flow.rb', line 7

def source_line_number
  @source_line_number
end

Instance Method Details

#ast(options = {}) ⇒ Object

Returns a processed/optimized AST, this is the one that should be used to build and represent the given test flow



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/atp/flow.rb', line 99

def ast(options = {})
  options = {
    apply_relationships:          true,
    # Supply a unique ID to append to all IDs
    unique_id:                    nil,
    # Set to :smt, or :igxl
    optimization:                 :runner,
    # When true, will remove set_result nodes in an on_fail branch which contains a continue
    implement_continue:           true,
    # When false, this will not optimize the use of a flag by nesting a dependent test within
    # the parent test's on_fail branch if the on_fail contains a continue
    optimize_flags_when_continue: true,
    # These options are not intended for application use, but provide the ability to
    # turn off certain processors during test cases
    add_ids:                      true,
    optimize_flags:               true,
    one_flag_per_test:            true
  }.merge(options)
  ###############################################################################
  ## Common pre-processing and validation
  ###############################################################################
  ast = Processors::PreCleaner.new.run(raw)
  Validators::DuplicateIDs.new(self).run(ast)
  Validators::MissingIDs.new(self).run(ast)
  Validators::Jobs.new(self).run(ast)
  Validators::Flags.new(self).run(ast)
  # Ensure everything has an ID, this helps later if condition nodes need to be generated
  ast = Processors::AddIDs.new.run(ast) if options[:add_ids]
  ast = Processors::FlowID.new.run(ast, options[:unique_id]) if options[:unique_id]

  ###############################################################################
  ## Optimization for a C-like flow target, e.g. V93K
  ###############################################################################
  if options[:optimization] == :smt || options[:optimization] == :runner
    # This applies all the relationships by setting flags in the referenced test and
    # changing all if_passed/failed type nodes to if_flag type nodes
    ast = Processors::Relationship.new.run(ast) if options[:apply_relationships]
    ast = Processors::Condition.new.run(ast)
    unless options[:optimization] == :runner
      ast = Processors::ContinueImplementer.new.run(ast) if options[:implement_continue]
    end
    if options[:optimize_flags]
      ast = Processors::FlagOptimizer.new.run(ast, optimize_when_continue: options[:optimize_flags_when_continue])
    end
    ast = Processors::AdjacentIfCombiner.new.run(ast)

  ###############################################################################
  ## Optimization for a row-based target, e.g. UltraFLEX
  ###############################################################################
  elsif options[:optimization] == :igxl
    # Un-nest everything embedded in else nodes
    ast = Processors::ElseRemover.new.run(ast)
    # Un-nest everything embedded in on_pass/fail nodes except for binning and
    # flag setting
    ast = Processors::OnPassFailRemover.new.run(ast)
    # This applies all the relationships by setting flags in the referenced test and
    # changing all if_passed/failed type nodes to if_flag type nodes
    ast = Processors::Relationship.new.run(ast) if options[:apply_relationships]
    ast = Processors::Condition.new.run(ast)
    ast = Processors::ApplyPostGroupActions.new.run(ast)
    ast = Processors::OneFlagPerTest.new.run(ast) if options[:one_flag_per_test]
    ast = Processors::RedundantConditionRemover.new.run(ast)

  ###############################################################################
  ## Not currently used, more of a test case
  ###############################################################################
  elsif options[:optimization] == :flat
    # Un-nest everything embedded in else nodes
    ast = Processors::ElseRemover.new.run(ast)
    # Un-nest everything embedded in on_pass/fail nodes except for binning and
    # flag setting
    ast = Processors::OnPassFailRemover.new.run(ast)
    ast = Processors::Condition.new.run(ast)
    ast = Processors::Flattener.new.run(ast)

  ###############################################################################
  ## Default Optimization
  ###############################################################################
  else
    ast = Processors::Condition.new.run(ast)
  end

  ###############################################################################
  ## Common cleanup
  ###############################################################################
  # Removes any empty on_pass and on_fail branches
  ast = Processors::EmptyBranchRemover.new.run(ast)
  ast
end

#bin(number, options = {}) ⇒ Object 



372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/atp/flow.rb', line 372

def bin(number, options = {})
  if number.is_a?(Hash)
    fail 'The bin number must be passed as the first argument'
  end
  options[:bin_description] ||= options.delete(:description)
  extract_meta!(options)
  apply_conditions(options) do
    options[:type] ||= :fail
    options[:bin] = number
    options[:softbin] ||= options[:soft_bin] || options[:sbin]
    set_result(options[:type], options)
  end
end

#context_changed?(options) ⇒ Boolean

Returns true if the test context generated from the supplied options + existing condition wrappers, is different from that which was applied to the previous test.

Returns:

  • (Boolean) 


457
458
459
460
 
# File 'lib/atp/flow.rb', line 457

def context_changed?(options)
  options[:_dont_delete_conditions_] = true
  last_conditions != clean_conditions(open_conditions + [extract_conditions(options)])
end

#continue(options = {}) ⇒ Object 



442
443
444
445
446
447
 
# File 'lib/atp/flow.rb', line 442

def continue(options = {})
  extract_meta!(options)
  apply_conditions(options) do
    n0(:continue)
  end
end

#cz(instance, cz_setup, options = {}) ⇒ Object Also known as: characterize 



394
395
396
397
398
399
400
 
# File 'lib/atp/flow.rb', line 394

def cz(instance, cz_setup, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    node = n1(:cz, cz_setup)
    append_to(node) { test(instance, options) }
  end
end

#describe_bin(number, description, options = {}) ⇒ Object

Record a description for a bin number



198
199
200
 
# File 'lib/atp/flow.rb', line 198

def describe_bin(number, description, options = {})
  @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :hard)
end

#describe_soft_bin(number, description, options = {}) ⇒ Object Also known as: describe_softbin

Record a description for a softbin number



203
204
205
 
# File 'lib/atp/flow.rb', line 203

def describe_soft_bin(number, description, options = {})
  @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :soft)
end

#disable(var, options = {}) ⇒ Object

Disable a flow control variable



420
421
422
423
424
425
 
# File 'lib/atp/flow.rb', line 420

def disable(var, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    n1(:disable, var)
  end
end

#enable(var, options = {}) ⇒ Object

Enable a flow control variable



412
413
414
415
416
417
 
# File 'lib/atp/flow.rb', line 412

def enable(var, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    n1(:enable, var)
  end
end

#group(name, options = {}) ⇒ Object

Group all tests generated within the given block

Examples:

flow.group "RAM Tests" do
  flow.test ...
  flow.test ...
end


215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/atp/flow.rb', line 215

def group(name, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    children = [n1(:name, name)]
    children << id(options[:id]) if options[:id]
    children << on_fail(options[:on_fail]) if options[:on_fail]
    children << on_pass(options[:on_pass]) if options[:on_pass]
    g = n(:group, children)
    append_to(g) { yield }
  end
end

#ids(options = {}) ⇒ Object 



486
487
488
 
# File 'lib/atp/flow.rb', line 486

def ids(options = {})
  ATP::AST::Extractor.new.process(raw, [:id]).map { |node| node.to_a[0] }
end

#inspect ⇒ Object 



482
483
484
 
# File 'lib/atp/flow.rb', line 482

def inspect
  "<ATP::Flow:#{object_id} #{name}>"
end

#log(message, options = {}) ⇒ Object

Append a log message line to the flow



404
405
406
407
408
409
 
# File 'lib/atp/flow.rb', line 404

def log(message, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    n1(:log, message.to_s)
  end
end

#marshal_dump ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



74
75
76
 
# File 'lib/atp/flow.rb', line 74

def marshal_dump
  [@name, @program, Processors::Marshal.new.process(raw)]
end

#marshal_load(array) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



79
80
81
82
 
# File 'lib/atp/flow.rb', line 79

def marshal_load(array)
  @name, @program, raw = array
  @pipeline = [raw]
end

#pass(number, options = {}) ⇒ Object 



386
387
388
389
390
391
392
 
# File 'lib/atp/flow.rb', line 386

def pass(number, options = {})
  if number.is_a?(Hash)
    fail 'The bin number must be passed as the first argument'
  end
  options[:type] = :pass
  bin(number, options)
end

#raw ⇒ Object

Returns the raw AST



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/atp/flow.rb', line 85

def raw
  n = nil
  @pipeline.reverse_each do |node|
    if n
      n = node.updated(nil, node.children + [n])
    else
      n = node
    end
  end
  n
end

#render(str, options = {}) ⇒ Object

Insert explicitly rendered content in to the flow



435
436
437
438
439
440
 
# File 'lib/atp/flow.rb', line 435

def render(str, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    n1(:render, str)
  end
end

#run(options = {}) ⇒ Object

Execute the given flow in the console



450
451
452
453
 
# File 'lib/atp/flow.rb', line 450

def run(options = {})
  Formatters::Datalog.run_and_format(ast, options)
  nil
end

#set_flag(flag, options = {}) ⇒ Object 



427
428
429
430
431
432
 
# File 'lib/atp/flow.rb', line 427

def set_flag(flag, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    set_flag_node(flag)
  end
end

#sub_test(instance, options = {}) ⇒ Object

Equivalent to calling test, but returns a sub_test node instead of adding it to the flow.

This is a helper to create sub_tests for inclusion in a top-level test node.



367
368
369
370
 
# File 'lib/atp/flow.rb', line 367

def sub_test(instance, options = {})
  temp = append_to(n0(:temp)) { test(instance, options) }
  temp.children.first.updated(:sub_test, nil)
end

#test(instance, options = {}) ⇒ Object

Add a test line to the flow

Parameters:

  • the (String, Symbol) —

    name of the test

  • options (Hash) (defaults to: {}) —

    a hash to describe the test’s attributes

Options Hash (options):

  • :id (Symbol) —

    A unique test ID

  • :description (String) —

    A description of what the test does, usually formatted in markdown

  • :on_fail (Hash) —

    What action to take if the test fails, e.g. assign a bin

  • :on_pass (Hash) —

    What action to take if the test passes

  • :conditions (Hash) —

    What conditions must be met to execute the test



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/atp/flow.rb', line 236

def test(instance, options = {})
  extract_meta!(options)
  apply_conditions(options) do
    # Allows any continue, bin, or soft bin argument passed in at the options top-level to be assumed
    # to be the action to take if the test fails
    if b = options.delete(:bin)
      options[:on_fail] ||= {}
      options[:on_fail][:bin] = b
    end
    if b = options.delete(:bin_description)
      options[:on_fail] ||= {}
      options[:on_fail][:bin_description] = b
    end
    if b = options.delete(:softbin) || b = options.delete(:sbin) || b = options.delete(:soft_bin)
      options[:on_fail] ||= {}
      options[:on_fail][:softbin] = b
    end
    if b = options.delete(:softbin_description) || options.delete(:sbin_description) || options.delete(:soft_bin_description)
      options[:on_fail] ||= {}
      options[:on_fail][:softbin_description] = b
    end
    if options.delete(:continue)
      options[:on_fail] ||= {}
      options[:on_fail][:continue] = true
    end
    if options.key?(:delayed)
      options[:on_fail] ||= {}
      options[:on_fail][:delayed] = options.delete(:delayed)
    end
    if f = options.delete(:flag_pass)
      options[:on_pass] ||= {}
      options[:on_pass][:set_flag] = f
    end
    if f = options.delete(:flag_fail)
      options[:on_fail] ||= {}
      options[:on_fail][:set_flag] = f
    end

    children = [n1(:object, instance)]

    name = (options[:name] || options[:tname] || options[:test_name])
    unless name
      [:name, :tname, :test_name].each do |m|
        name ||= instance.respond_to?(m) ? instance.send(m) : nil
      end
    end
    children << n1(:name, name) if name

    num = (options[:number] || options[:num] || options[:tnum] || options[:test_number])
    unless num
      [:number, :num, :tnum, :test_number].each do |m|
        num ||= instance.respond_to?(m) ? instance.send(m) : nil
      end
    end
    children << number(num) if num

    children << id(options[:id]) if options[:id]

    if levels = options[:level] || options[:levels]
      levels = [levels] unless levels.is_a?(Array)
      levels.each do |l|
        children << level(l[:name], l[:value], l[:unit] || l[:units])
      end
    end

    lims = options[:limit] || options[:limits]
    if lims || options[:lo] || options[:low] || options[:hi] || options[:high]
      if lims == :none || lims == 'none'
        children << n0(:nolimits)
      else
        lims = Array(lims) unless lims.is_a?(Array)
        if lo = options[:lo] || options[:low]
          lims << { value: lo, rule: :gte }
        end
        if hi = options[:hi] || options[:high]
          lims << { value: hi, rule: :lte }
        end
        lims.each do |l|
          if l.is_a?(Hash)
            children << n(:limit, [l[:value], l[:rule], l[:unit] || l[:units], l[:selector]])
          end
        end
      end
    end

    if pins = options[:pin] || options[:pins]
      pins = [pins] unless pins.is_a?(Array)
      pins.each do |p|
        if p.is_a?(Hash)
          children << pin(p[:name])
        else
          children << pin(p)
        end
      end
    end

    if pats = options[:pattern] || options[:patterns]
      pats = [pats] unless pats.is_a?(Array)
      pats.each do |p|
        if p.is_a?(Hash)
          children << pattern(p[:name], p[:path])
        else
          children << pattern(p)
        end
      end
    end

    if options[:meta]
      attrs = []
      options[:meta].each { |k, v| attrs << attribute(k, v) }
      children << n(:meta, attrs)
    end

    if subs = options[:sub_test] || options[:sub_tests]
      subs = [subs] unless subs.is_a?(Array)
      subs.each do |s|
        children << s.updated(:sub_test, nil)
      end
    end

    children << on_fail(options[:on_fail]) if options[:on_fail]
    children << on_pass(options[:on_pass]) if options[:on_pass]

    save_conditions
    n(:test, children)
  end
end

#volatile(*flags) ⇒ Object

Indicate the that given flags should be considered volatile (can change at any time), which will prevent them from been touched by the optimization algorithms



191
192
193
194
195
 
# File 'lib/atp/flow.rb', line 191

def volatile(*flags)
  options = flags.pop if flags.last.is_a?(Hash)
  flags = flags.flatten
  @pipeline[0] = add_volatile_flags(@pipeline[0], flags)
end