atp 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 898bb2e160b6d893026e211eba9cf858387c33b5
-  data.tar.gz: f6e78515801ad71eed4358f3c5373df08a32e115
+  metadata.gz: 0a0d850eca7f69b2f9c49af6e1192fc97d248cb8
+  data.tar.gz: fcf7c3fa24bcca9d19eb3d590d68f6acef66ac83
 SHA512:
-  metadata.gz: ef51a2e7bdcd532882e9266db0f5be8537e9079dd6f6c370b4ccff34e989737539f7fa7123cdbadf7d388540f29570946a49bde56d4b3f63b5bb740753acf92e
-  data.tar.gz: c35f0f652e10edf1634b8ed839c4d77efbbfed048b80529d73c61ff08b7987ce35355e10f73ab4e9fa5b18abca593ad4ee89b1fcbca715019e0a648e743969c9
+  metadata.gz: 7b2cf5e3e8b7252884cdb9f45ef8cd57374b1eda91e1559f19f5303c10ccfb6c16b35fdf38a2fd5d7ca58a124034b6551964e59937227398ec67710125c9ab8d
+  data.tar.gz: 88d0018049a88372325e2acbbec0fd729f872c70500ae15208001321da2504404814d5401886e8752d5ed8f3dc2cb50d6fb97bf63293697b9df986325cf3241f

data/config/version.rb

@@ -1,6 +1,6 @@
 module ATP
   MAJOR = 1
-  MINOR = 0
+  MINOR = 1
   BUGFIX = 0
   DEV = nil
 

data/lib/atp.rb

@@ -79,6 +79,7 @@ module ATP
     autoload :MissingIDs, 'atp/validators/missing_ids'
     autoload :Condition, 'atp/validators/condition'
     autoload :Jobs, 'atp/validators/jobs'
+    autoload :Flags, 'atp/validators/flags'
   end
 
   # Formatters are run on the processed AST to display the flow or to render

data/lib/atp/ast/node.rb

@@ -86,6 +86,13 @@ module ATP
       def set_flags
         Processors::ExtractSetFlags.new.run(self)
       end
+
+      # Returns true if the node contains any nodes of the given type(s) or if any
+      # of its children do.
+      # To consider only direct children of this node use: node.find_all(*types).empty?
+      def contains?(*types)
+        !Extractor.new.process(self, types).empty?
+      end
     end
   end
 end

data/lib/atp/flow.rb

@@ -98,17 +98,21 @@ module ATP
     # used to build and represent the given test flow
     def ast(options = {})
       options = {
-        apply_relationships: true,
+        apply_relationships:          true,
         # Supply a unique ID to append to all IDs
-        unique_id:           nil,
+        unique_id:                    nil,
         # Set to :smt, or :igxl
-        optimization:        :runner,
+        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,
-        implement_continue:  true
+        add_ids:                      true,
+        optimize_flags:               true,
+        one_flag_per_test:            true
       }.merge(options)
       ###############################################################################
       ## Common pre-processing and validation
@@ -117,6 +121,7 @@ module ATP
       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]
@@ -132,7 +137,9 @@ module ATP
         unless options[:optimization] == :runner
           ast = Processors::ContinueImplementer.new.run(ast) if options[:implement_continue]
         end
-        ast = Processors::FlagOptimizer.new.run(ast) if options[:optimize_flags]
+        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)
 
       ###############################################################################
@@ -187,6 +194,17 @@ module ATP
       @pipeline[0] = add_volatile_flags(@pipeline[0], flags)
     end
 
+    # Record a description for a bin number
+    def describe_bin(number, description, options = {})
+      @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :hard)
+    end
+
+    # Record a description for a softbin number
+    def describe_soft_bin(number, description, options = {})
+      @pipeline[0] = add_bin_description(@pipeline[0], number, description, type: :soft)
+    end
+    alias_method :describe_softbin, :describe_soft_bin
+
     # Group all tests generated within the given block
     #
     # @example
@@ -240,6 +258,10 @@ module ATP
           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
@@ -276,11 +298,22 @@ module ATP
           end
         end
 
-        if lims = options[:limit] || options[:limits]
-          lims = [lims] unless lims.is_a?(Array)
-          lims.each do |l|
-            if l.is_a?(Hash)
-              children << limit(l[:value], l[:rule], l[:unit] || l[:units])
+        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
@@ -450,6 +483,10 @@ module ATP
       "<ATP::Flow:#{object_id} #{name}>"
     end
 
+    def ids(options = {})
+      ATP::AST::Extractor.new.process(raw, [:id]).map { |node| node.to_a[0] }
+    end
+
     private
 
     def flow_control_method(name, flag, options = {}, &block)
@@ -617,6 +654,7 @@ module ATP
           children << set_flag_node(options[:set_run_flag] || options[:set_flag])
         end
         children << n0(:continue) if options[:continue]
+        children << n1(:delayed, !!options[:delayed]) if options.key?(:delayed)
         children << n1(:render, options[:render]) if options[:render]
         n(:on_fail, children)
       end
@@ -663,14 +701,6 @@ module ATP
       end
     end
 
-    def limit(value, rule, units = nil)
-      if units
-        n(:limit, [value, rule, units])
-      else
-        n2(:limit, value, rule)
-      end
-    end
-
     def pin(name)
       n1(:pin, name)
     end
@@ -717,6 +747,27 @@ module ATP
       node.updated(nil, [name, v] + nodes)
     end
 
+    # Ensures the flow ast has a bin descriptions node, then adds the
+    # given description to it
+    def add_bin_description(node, number, description, options)
+      @existing_bin_descriptions ||= { soft: {}, hard: {} }
+      return node if @existing_bin_descriptions[options[:type]][number]
+      @existing_bin_descriptions[options[:type]][number] = true
+      name, *nodes = *node
+      if nodes[0] && nodes[0].type == :volatile
+        v = nodes.shift
+      else
+        v = nil
+      end
+      if nodes[0] && nodes[0].type == :bin_descriptions
+        d = nodes.shift
+      else
+        d = n0(:bin_descriptions)
+      end
+      d = d.updated(nil, d.children + [n2(options[:type], number, description)])
+      node.updated(nil, [name, v, d].compact + nodes)
+    end
+
     def n(type, children, options = {})
       options[:file] ||= options.delete(:source_file) || source_file
       options[:line_number] ||= options.delete(:source_line_number) || source_line_number

data/lib/atp/flow_api.rb

@@ -9,7 +9,7 @@ module ATP
     end
 
     ([:test, :bin, :pass, :continue, :cz, :log, :sub_test, :volatile, :set_flag, :enable, :disable, :render,
-      :context_changed?] +
+      :context_changed?, :ids, :describe_bin, :describe_softbin, :describe_soft_bin] +
       ATP::Flow::CONDITION_KEYS.keys).each do |method|
       define_method method do |*args, &block|
         options = args.pop if args.last.is_a?(Hash)
@@ -22,5 +22,35 @@ module ATP
     end
 
     alias_method :logprint, :log
+
+    def lo_limit(value, options)
+      {
+        value:    value,
+        rule:     options[:rule] || :gte,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
+
+    def hi_limit(value, options)
+      {
+        value:    value,
+        rule:     options[:rule] || :lte,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
+
+    def limit(value, options)
+      unless options[:rule]
+        fail 'You must supply option :rule (e.g. rule: :gt) when calling the limit helper'
+      end
+      {
+        value:    value,
+        rule:     options[:rule] || :lt,
+        units:    options[:units],
+        selector: options[:selector] || options[:test_mode]
+      }
+    end
   end
 end

data/lib/atp/processors/adjacent_if_combiner.rb

@@ -90,7 +90,8 @@ module ATP
       def safe_to_combine?(node1, node2)
         # Nodes won't be collapsed if node1 touches the shared run flag, i.e. if there is any chance
         # that by the time it would naturally execute node2, the flag could have been changed by node1
-        !volatile?(node1.to_a[0]) && !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
+        (!volatile?(node1.to_a[0]) || (volatile?(node1.to_a[0]) && !node1.contains?(:test))) &&
+          !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
       end
     end
   end

data/lib/atp/processors/flag_optimizer.rb

@@ -25,7 +25,7 @@ module ATP
     #           s(:name, "test2")))))
     #
     class FlagOptimizer < Processor
-      attr_reader :run_flag_table
+      attr_reader :run_flag_table, :optimize_when_continue
 
       class ExtractRunFlagTable < Processor
         # Hash table of run_flag name with number of times used
@@ -53,7 +53,11 @@ module ATP
         alias_method :on_unless_flag, :on_if_flag
       end
 
-      def run(node)
+      def run(node, options = {})
+        options = {
+          optimize_when_continue: true
+        }.merge(options)
+        @optimize_when_continue = options[:optimize_when_continue]
         # Pre-process the AST for # of occurrences of each run-flag used
         t = ExtractRunFlagTable.new
         t.process(node)
@@ -70,11 +74,16 @@ module ATP
       alias_method :on_group, :on_named_collection
       alias_method :on_unless_flag, :on_named_collection
 
+      def on_unnamed_collection(node)
+        node.updated(nil, optimize(process_all(node.children)))
+      end
+      alias_method :on_else, :on_unnamed_collection
+
       def on_if_flag(node)
         name, *nodes = *node
         # Remove this node and return its children if required
         if if_run_flag_to_remove.last == node.to_a[0]
-          node.updated(:inline, node.to_a[1..-1])
+          node.updated(:inline, optimize(process_all(node.to_a[1..-1])))
         else
           node.updated(nil, [name] + optimize(process_all(nodes)))
         end
@@ -124,7 +133,10 @@ module ATP
       end
 
       def can_be_combined?(node1, node2)
-        if node1.type == :test && (node2.type == :if_flag || node2.type == :unless_flag)
+        if node1.type == :test && (node2.type == :if_flag || node2.type == :unless_flag) &&
+           # Don't optimize tests which are marked as continue if told not to
+           !(node1.find(:on_fail) && node1.find(:on_fail).find(:continue) && !optimize_when_continue)
+
           if node1.find_all(:on_fail, :on_pass).any? do |node|
             if n = node.find(:set_flag)
               # Inline instead of setting a flag if...
@@ -141,7 +153,7 @@ module ATP
       end
 
       def combine(node1, node2)
-        nodes_to_inline_on_pass_or_fail << node2
+        nodes_to_inline_on_pass_or_fail << node2 # .updated(nil, process_all(node2.children))
         node1 = node1.updated(nil, process_all(node1.children))
         nodes_to_inline_on_pass_or_fail.pop
         node1

data/lib/atp/processors/relationship.rb

@@ -66,7 +66,12 @@ module ATP
           if n.type == :on_pass
             n = n.add node.updated(:set_flag, ["#{id}_PASSED", :auto_generated])
           elsif n.type == :on_fail
-            n.ensure_node_present(:continue)
+            delayed = n.find(:delayed)
+            if delayed && delayed.to_a[0]
+              n
+            else
+              n.ensure_node_present(:continue)
+            end
           else
             n
           end
@@ -78,7 +83,12 @@ module ATP
         node.updated(nil, node.children.map do |n|
           if n.type == :on_fail
             n = n.add node.updated(:set_flag, ["#{id}_FAILED", :auto_generated])
-            n.ensure_node_present(:continue)
+            delayed = n.find(:delayed)
+            if delayed && delayed.to_a[0]
+              n
+            else
+              n.ensure_node_present(:continue)
+            end
           else
             n
           end
@@ -111,6 +121,7 @@ module ATP
       # Set flags depending on the result on tests which have dependents later
       # in the flow
       def on_test(node)
+        node = node.updated(nil, process_all(node.children))
         nid = id(node)
         # If this test has a dependent
         if test_results[nid]
@@ -118,11 +129,7 @@ module ATP
           node = add_fail_flag(nid, node) if test_results[nid][:failed]
           node = add_ran_flags(nid, node) if test_results[nid][:ran]
         end
-        if node.type == :group
-          node.updated(nil, process_all(node))
-        else
-          node
-        end
+        node
       end
       alias_method :on_group, :on_test
 

data/lib/atp/validators/flags.rb

@@ -0,0 +1,59 @@
+module ATP
+  module Validators
+    class Flags < Validator
+      def setup
+        @open_if_nodes = []
+        @open_unless_nodes = []
+        @conflicting = []
+      end
+
+      def on_completion
+        failed = false
+        unless @conflicting.empty?
+          error 'if_flag and unless_flag conditions cannot be nested and refer to the same flag unless it is declared as volatile'
+          error "The following conflicts were found in flow #{flow.name}:"
+          @conflicting.each do |a, b|
+            a_condition = a.to_a[1] ? 'if_job:    ' : 'unless_job:'
+            b_condition = b.to_a[1] ? 'if_job:    ' : 'unless_job:'
+            error "  #{a.type}(#{a.to_a[0]}) #{a.source}"
+            error "  #{b.type}(#{b.to_a[0]}) #{b.source}"
+            error ''
+          end
+          failed = true
+        end
+        failed
+      end
+
+      def on_flow(node)
+        extract_volatiles(node)
+        process_all(node.children)
+      end
+
+      def on_if_flag(node)
+        if volatile?(node.to_a[0])
+          process_all(node.children)
+        else
+          if n = @open_unless_nodes.find { |n| n.to_a[0] == node.to_a[0] }
+            @conflicting << [n, node]
+          end
+          @open_if_nodes << node
+          process_all(node.children)
+          @open_if_nodes.pop
+        end
+      end
+
+      def on_unless_flag(node)
+        if volatile?(node.to_a[0])
+          process_all(node.children)
+        else
+          if n = @open_if_nodes.find { |n| n.to_a[0] == node.to_a[0] }
+            @conflicting << [n, node]
+          end
+          @open_unless_nodes << node
+          process_all(node.children)
+          @open_unless_nodes.pop
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-20 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -97,6 +97,7 @@ files:
 - lib/atp/validator.rb
 - lib/atp/validators/condition.rb
 - lib/atp/validators/duplicate_ids.rb
+- lib/atp/validators/flags.rb
 - lib/atp/validators/jobs.rb
 - lib/atp/validators/missing_ids.rb
 - lib/tasks/atp.rake
@@ -125,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: An abstract test program model for Origen