atp 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0318ad5ca67b39da3b87b038434eaa85b1ee2a1d
-  data.tar.gz: 63bdc11c210bba2219097d14b3c5aa55678a8c8f
+  metadata.gz: 7cdbd30f66efb6b3795073de37ccdf0623377b7b
+  data.tar.gz: 4b3deec7a4e80eaa56dfd1b14934790a044ab611
 SHA512:
-  metadata.gz: ae4da77cd22cc197e3ecf80af390de270b71c6a00cfcae3c49345156b9840c5f6429520707c29c36dffb89d54ec50b8af710257c93f23b872d44b5a10fb8aad6
-  data.tar.gz: 6ee881a43ee9cf5015860b50719d6d07c461f545180d967319d8ada891a36cd47adf8ac48a5ef277c79494bfbc0a54dfdddb77d1bbaac77a70dc8a6d67b63f24
+  metadata.gz: 5309d2a1ddef3772ae949e47d3ce750a3eee0236498741cc0d752e3a7973fca9a016186ff17c02d54095055af51676b03eb2af8d6a23ebf695d7273096b5a406
+  data.tar.gz: b391e87fa09e223a717b6f11842ca2af604b33849ade223a657f8acaa5202dc90153070a89c4117b6a99fdb8e36bfa2dbef633b22957032c274aba6332eeffae

data/config/version.rb

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

data/lib/atp.rb

@@ -9,9 +9,6 @@ module ATP
   autoload :Runner, 'atp/runner'
   autoload :Formatter, 'atp/formatter'
   autoload :Parser, 'atp/parser'
-  autoload :AND, 'atp/and'
-  autoload :OR, 'atp/or'
-  autoload :NOT, 'atp/not'
 
   module AST
     autoload :Node, 'atp/ast/node'
@@ -28,6 +25,8 @@ module ATP
     autoload :Relationship, 'atp/processors/relationship'
     autoload :PreCleaner, 'atp/processors/pre_cleaner'
     autoload :PostCleaner, 'atp/processors/post_cleaner'
+    autoload :Marshal, 'atp/processors/marshal'
+    autoload :AddIDs, 'atp/processors/add_ids'
   end
 
   # Summarizers extract summary data from the given AST
@@ -40,6 +39,7 @@ module ATP
     autoload :DuplicateIDs, 'atp/validators/duplicate_ids'
     autoload :MissingIDs, 'atp/validators/missing_ids'
     autoload :Condition, 'atp/validators/condition'
+    autoload :Jobs, 'atp/validators/jobs'
   end
 
   # Formatters are run on the processed AST to display the flow or to render

data/lib/atp/ast/builder.rb

@@ -47,6 +47,10 @@ module ATP
         n(:test_executed, id, executed, node)
       end
 
+      def job(id, enabled, node)
+        n(:job, id, enabled, node)
+      end
+
       def enable_flow_flag(var, options = {})
         test = n(:enable_flow_flag, var)
         if options[:conditions]
@@ -93,7 +97,7 @@ module ATP
       end
 
       def new_context
-        @context = { conditions: {} }
+        @context = { conditions: [] }
         yield if block_given?
         @context
       end
@@ -115,8 +119,20 @@ module ATP
 
       def apply_conditions(node, conditions)
         conditions.each do |key, value|
+          # Sometimes conditions can be an array (in the case of the current context
+          # being re-used), so rectify that now
+          if key.is_a?(Hash)
+            fail 'Something has gone wrong applying the test conditions' if key.size > 1
+            key, value = key.first[0], key.first[1]
+          end
           key = key.to_s.downcase.to_sym
-          context[:conditions][key] = value
+          # Represent all condition values as lower cased strings internally
+          if value.is_a?(Array)
+            value = value.map { |v| v.to_s.downcase }
+          else
+            value = value.to_s.downcase
+          end
+          context[:conditions] << { key => value }
           case key
           when :if_enabled, :enabled, :enable_flag, :enable, :if_enable
             node = flow_flag(value, true, node)
@@ -149,17 +165,9 @@ module ATP
           when :unless_ran, :unless_executed
             node = test_executed(value, false, node)
           when :job, :jobs, :if_job, :if_jobs
-            # Make sure these are wrapped by an OR, AND jobs doesn't make sense anyway
-            unless value.is_a?(OR)
-              value = ATP.or(value)
-            end
-            node = n(:job, apply_boolean(value), node)
+            node = job(value, true, node)
           when :unless_job, :unless_jobs
-            # Make sure these are wrapped by an OR, AND jobs doesn't make sense anyway
-            unless value.is_a?(OR)
-              value = ATP.or(value)
-            end
-            node = n(:job, apply_boolean(ATP.not(value)), node)
+            node = job(value, false, node)
           else
             fail "Unknown test condition attribute - #{key} (#{value})"
           end
@@ -167,18 +175,6 @@ module ATP
         node
       end
 
-      def apply_boolean(value)
-        if value.is_a?(OR)
-          n(:or, *value.map { |v| apply_boolean(v) })
-        elsif value.is_a?(AND)
-          n(:and, *value.map { |v| apply_boolean(v) })
-        elsif value.is_a?(NOT)
-          n(:not, apply_boolean(value.value))
-        else
-          value
-        end
-      end
-
       def test(object, options = {})
         children = [n(:object, object)]
 

data/lib/atp/ast/node.rb

@@ -4,7 +4,7 @@ module ATP
     class Node < ::AST::Node
       include Factories
 
-      attr_reader :file, :line_number
+      attr_reader :file, :line_number, :description
 
       def initialize(type, children = [], properties = {})
         # Always use strings instead of symbols in the AST, makes serializing
@@ -60,21 +60,12 @@ module ATP
 
       # Returns the first child node of the given type that is found
       def find(type)
-        nodes = find_all(type)
-        nodes.first
+        children.find { |c| c.try(:type) == type }
       end
 
       # Returns an array containing all child nodes of the given type(s)
       def find_all(*types)
-        Extractor.new.process(self, types)
-      end
-
-      def to_h
-        h = {}
-        children.each do |node|
-          h[node.type] = node.children.map { |n| n.is_a?(AST::Node) ? n.to_h : n }
-        end
-        h
+        children.select { |c| types.include?(c.try(:type)) }
       end
     end
   end

data/lib/atp/flow.rb

@@ -9,10 +9,19 @@ module ATP
     def initialize(program, name = nil)
       @program = program
       @name = name
-      @builder = AST::Builder.new
       @raw = builder.flow
     end
 
+    # @api private
+    def marshal_dump
+      [@name, @program, Processors::Marshal.new.process(@raw)]
+    end
+
+    # @api private
+    def marshal_load(array)
+      @name, @program, @raw = array
+    end
+
     # Returns a processed/optimized AST, this is the one that should be
     # used to build and represent the given test flow
     def ast
@@ -22,6 +31,8 @@ module ATP
       ast = Processors::Condition.new.process(ast)
       ast = Processors::Relationship.new.process(ast)
       ast = Processors::PostCleaner.new.process(ast)
+      Validators::Jobs.new(self).process(ast)
+      ast
     end
 
     # Group all tests generated within the given block
@@ -139,8 +150,97 @@ module ATP
       nil
     end
 
+    # 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.
+    def context_changed?(options)
+      a = context[:conditions]
+      b = build_context(options)[:conditions]
+      !conditions_equal?(a, b)
+    end
+
+    def context
+      builder.context
+    end
+
     private
 
+    def conditions_equal?(a, b)
+      if a.size == b.size
+        a = clean_condition(a)
+        b = clean_condition(b)
+        if a.keys.sort == b.keys.sort
+          a.all? do |key, value|
+            value.flatten.uniq.sort == b[key].flatten.uniq.sort
+          end
+        end
+      end
+    end
+
+    def clean_condition(h)
+      c = {}
+      h.each do |hash|
+        key, value = hash.first[0], hash.first[1]
+        key = clean_key(key)
+        value = clean_value(value)
+        c[key] ||= []
+        c[key] << value unless c[key].include?(value)
+      end
+      c
+    end
+
+    def clean_value(value)
+      if value.is_a?(Array)
+        value.map { |v| v.to_s.downcase }.sort
+      else
+        value.to_s.downcase
+      end
+    end
+
+    def clean_key(key)
+      case key.to_sym
+      when :if_enabled, :enabled, :enable_flag, :enable, :if_enable
+        :if_enable
+      when :unless_enabled, :not_enabled, :disabled, :disable, :unless_enable
+        :unless_enable
+      when :if_failed, :unless_passed, :failed
+        :if_failed
+      when :if_passed, :unless_failed, :passed
+        :if_passed
+      when :if_any_failed, :unless_all_passed
+        :if_any_failed
+      when :if_all_failed, :unless_any_passed
+        :if_all_failed
+      when :if_any_passed, :unless_all_failed
+        :if_any_passed
+      when :if_all_passed, :unless_any_failed
+        :if_all_passed
+      when :if_ran, :if_executed
+        :if_ran
+      when :unless_ran, :unless_executed
+        :unless_ran
+      when :job, :jobs, :if_job, :if_jobs
+        :if_job
+      when :unless_job, :unless_jobs
+        :unless_job
+      else
+        fail "Unknown test condition attribute - #{key}"
+      end
+    end
+
+    def build_context(options)
+      c = open_conditions.dup
+      if options[:conditions]
+        options[:conditions].each do |key, value|
+          c << { key => value }
+        end
+      end
+      { conditions: c }
+    end
+
+    def builder
+      @builder ||= AST::Builder.new
+    end
+
     def apply_open_conditions(options)
       if options[:context] == :current
         options[:conditions] = builder.context[:conditions]
@@ -180,9 +280,5 @@ module ATP
         open_groups.last << node
       end
     end
-
-    def builder
-      @builder
-    end
   end
 end

data/lib/atp/formatters/basic.rb

@@ -10,7 +10,7 @@ module ATP
       end
 
       def on_test(node)
-        @output += node.to_h[:name][0]
+        @output += node.find(:name).value
         @output += "\n"
       end
     end

data/lib/atp/formatters/datalog.rb

@@ -1,20 +1,60 @@
+require 'colored'
 module ATP
   module Formatters
     # Outputs the given AST to something resembling an ATE datalog,
     # this can optionally be rendered to a file or the console (the default).
     class Datalog < Formatter
       def on_flow(node)
-        puts 'Number     Result   Test Name                 Pin            Channel   Low            Measured       High           Force          Loc'
+        str = 'Number'.ljust(15)
+        str += 'Result'.ljust(9)
+        str += 'Name'.ljust(55)
+        str += 'Test'.ljust(55)
+        str += 'ID'
+        puts str
         process_all(node.children)
       end
 
       def on_test(node)
-        t = node.to_h
-        str = "#{t[:number]}".ljust(11)
-        str += "#{t[:failed] ? 'FAIL' : 'PASS'}".ljust(9)
-        str += "#{t[:name][0]}".ljust(20)
+        str = "#{node.find(:number).try(:value)}".ljust(15)
+        if node.find(:failed)
+          str += 'FAIL'.ljust(9).red
+        else
+          str += 'PASS'.ljust(9)
+        end
+        str += "#{node.find(:name).value}".ljust(55)
+        str += "#{node.find(:object).value}".ljust(55)
+        str += "#{node.find(:id).value}"
         puts str
       end
+
+      def on_render(node)
+        puts '************ Directly rendered flow snippet ************'
+        puts node.value
+        puts '********************************************************'
+      end
+
+      def on_log(node)
+        puts "// #{node.value}"
+      end
+
+      def on_set_result(node)
+        bin = node.find(:bin).try(:value)
+        sbin = node.find(:softbin).try(:value)
+        desc = node.find(:description).try(:value)
+
+        if node.to_a[0] == 'pass'
+          str = "               PASS     #{bin}      #{sbin}"
+          color = :green
+        else
+          str = "               FAIL     #{bin}      #{sbin}"
+          color = :red
+        end
+        str += "      (#{desc})" if desc
+
+        puts '---------------------------------------------------------------------------------------------------------------------------------------------------------'
+        puts str.send(color)
+        puts '---------------------------------------------------------------------------------------------------------------------------------------------------------'
+      end
     end
   end
 end

data/lib/atp/processors/add_ids.rb

@@ -0,0 +1,23 @@
+module ATP
+  module Processors
+    # Assigns an ID to all test nodes that don't have one
+    class AddIDs < Processor
+      def run(node)
+        @i = 0
+        process(node)
+      end
+
+      def on_test(node)
+        @i += 1
+        node = node.ensure_node_present(:id)
+        node.updated(nil, process_all(node))
+      end
+
+      def on_id(node)
+        unless node.value
+          node.updated(nil, ["t#{@i}"])
+        end
+      end
+    end
+  end
+end

data/lib/atp/processors/condition.rb

@@ -77,6 +77,7 @@ module ATP
       alias_method :on_flow_flag, :on_boolean_condition
       alias_method :on_test_result, :on_boolean_condition
       alias_method :on_test_executed, :on_boolean_condition
+      alias_method :on_job, :on_boolean_condition
 
       def on_condition(node)
         children = node.children.dup
@@ -91,7 +92,6 @@ module ATP
         end
       end
       alias_method :on_group, :on_condition
-      alias_method :on_job, :on_condition
 
       # Returns true if the given node contains the given condition within
       # its immediate children
@@ -109,7 +109,7 @@ module ATP
 
       def equal_conditions?(node1, node2)
         if node1.type == node2.type
-          if node1.type == :group || node1.type == :job
+          if node1.type == :group
             node1.to_a.take(1) == node2.to_a.take(1)
           else
             node1.to_a.take(2) == node2.to_a.take(2)

data/lib/atp/processors/condition_extractor.rb

@@ -21,6 +21,7 @@ module ATP
       alias_method :on_flow_flag, :on_boolean_condition
       alias_method :on_test_result, :on_boolean_condition
       alias_method :on_test_executed, :on_boolean_condition
+      alias_method :on_job, :on_boolean_condition
 
       def on_condition(node)
         children = node.children.dup
@@ -29,7 +30,6 @@ module ATP
         process_all(children)
         conditions.pop
       end
-      alias_method :on_job, :on_condition
 
       def on_test(node)
         results << [conditions.uniq, node]

data/lib/atp/processors/marshal.rb

@@ -0,0 +1,14 @@
+module ATP
+  module Processors
+    # Makes the AST safe for Marshaling
+    class Marshal < Processor
+      def on_object(node)
+        if node.value.is_a?(String)
+          node
+        else
+          node.updated(nil, [node.value.name])
+        end
+      end
+    end
+  end
+end

data/lib/atp/program.rb

@@ -1,6 +1,15 @@
 module ATP
   # Program is the top-level container for a collection of test flows
   class Program
+    # Load a program from a previously saved file
+    def self.load(file)
+      p = nil
+      File.open(file) do |f|
+        p = Marshal.load(f)
+      end
+      p
+    end
+
     def flow(name)
       flows[name] ||= Flow.new(self, name)
     end
@@ -9,6 +18,13 @@ module ATP
       @flows ||= {}
     end
 
+    # Save the program to a file
+    def save(file)
+      File.open(file, 'w') do |f|
+        Marshal.dump(self, f)
+      end
+    end
+
     def respond_to?(*args)
       flows.key?(args.first) || super
     end

data/lib/atp/runner.rb

@@ -6,7 +6,9 @@ module ATP
   class Runner < Processor
     def run(node, options = {})
       @options = options
-      process(node)
+      @completed = false
+      @groups = []
+      process(Processors::AddIDs.new.run(node))
     end
 
     def on_flow(node)
@@ -17,8 +19,18 @@ module ATP
 
     def on_flow_flag(node)
       flag, enabled, *nodes = *node
-      if (enabled && flow_flags.include?(flag)) ||
-         (!enabled && !flow_flags.include?(flag))
+      flag = [flag].flatten
+      active = flag.any? { |f| flow_flags.include?(f) }
+      if (enabled && active) || (!enabled && !active)
+        process_all(nodes)
+      end
+    end
+
+    def on_run_flag(node)
+      flag, enabled, *nodes = *node
+      flag = [flag].flatten
+      active = flag.any? { |f| run_flags.include?(f) }
+      if (enabled && active) || (!enabled && !active)
         process_all(nodes)
       end
     end
@@ -28,9 +40,46 @@ module ATP
         id = id.to_a[0]
         if failed_test_ids.include?(id)
           node = node.add(n0(:failed))
+          failed = true
+        end
+      end
+      @flow << node unless completed?
+      if failed
+        # Give indication to the parent group that at least one test within it failed
+        if @groups.last
+          @groups.pop
+          @groups << false
+        end
+        if n = node.find(:on_fail)
+          @continue = !!n.find(:continue)
+          process_all(n)
+          @continue = false
+        end
+      else
+        if n = node.find(:on_pass)
+          process_all(n)
+        end
+      end
+    end
+
+    def on_group(node)
+      @groups << true  # This will be set to false by any tests that fail within the group
+      process_all(node.find(:members))
+      if !@groups.pop # If failed
+        if n = node.find(:on_fail)
+          @continue = !!n.find(:continue)
+          process_all(n)
+          @continue = false
+        end
+      else
+        if n = node.find(:on_pass)
+          process_all(n)
         end
       end
-      @flow << node
+    end
+
+    def on_members(node)
+      # Do nothing, will be processed directly by the on_group handler
     end
 
     def on_test_result(node)
@@ -41,13 +90,66 @@ module ATP
       end
     end
 
+    def on_set_result(node)
+      unless @continue
+        @flow << node unless completed?
+        @completed = true
+      end
+    end
+
+    def on_set_run_flag(node)
+      run_flags << node.to_a[0]
+    end
+
+    def on_enable_flow_flag(node)
+      flow_flags << node.value unless flow_flags.include?(node.value)
+    end
+
+    def on_disable_flow_flag(node)
+      flow_flags.delete(node.value)
+    end
+
+    def on_log(node)
+      @flow << node unless completed?
+    end
+    alias_method :on_render, :on_log
+
+    def on_job(node)
+      jobs, state, *nodes = *node
+      jobs = clean_job(jobs)
+      unless job
+        fail 'Flow contains JOB-based conditions and no current JOB has been given!'
+      end
+      if state
+        process_all(node) if jobs.include?(job)
+      else
+        process_all(node) unless jobs.include?(job)
+      end
+    end
+
+    def clean_job(job)
+      [job].flatten.map { |j| j.to_s.upcase }
+    end
+
+    def job
+      @options[:job].to_s.upcase if @options[:job]
+    end
+
     def failed_test_ids
       @failed_test_ids ||= [@options[:failed_test_id] || @options[:failed_test_ids]].flatten.compact
     end
 
+    def run_flags
+      @run_flags ||= []
+    end
+
     # Returns an array of enabled flow flags
     def flow_flags
       @flow_flags ||= [@options[:flow_flag] || @options[:flow_flags]].flatten.compact
     end
+
+    def completed?
+      @completed
+    end
   end
 end

data/lib/atp/validator.rb

@@ -14,10 +14,20 @@ module ATP
         @top_level_called = true
         setup
         super(node)
-        exit 1 if on_completion
+        unless @testing
+          exit 1 if on_completion
+        end
       end
     end
 
+    # For test purposes, returns true if validation failed rather
+    # than exiting the process
+    def test_process(node)
+      @testing = true
+      process(node)
+      on_completion
+    end
+
     def setup
     end
   end

data/lib/atp/validators/jobs.rb

@@ -0,0 +1,53 @@
+module ATP
+  module Validators
+    class Jobs < Validator
+      def setup
+        @conflicting = []
+        @negative = []
+      end
+
+      def on_completion
+        failed = false
+        unless @conflicting.empty?
+          Origen.log.error 'if_job and unless_job conditions cannot both be applied to the same tests'
+          Origen.log.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:'
+            Origen.log.error "  #{a_condition} #{a.source}"
+            Origen.log.error "  #{b_condition} #{b.source}"
+            Origen.log.error ''
+          end
+          failed = true
+        end
+
+        unless @negative.empty?
+          Origen.log.error 'Job names should not be negated, use unless_job if you want to specify !JOB'
+          Origen.log.error "The following negative job names were found in flow #{flow.name}:"
+          @negative.each do |node|
+            Origen.log.error "  #{node.to_a[0]} #{node.source}"
+          end
+          failed = true
+        end
+
+        failed
+      end
+
+      def on_job(node)
+        jobs, state, *nodes = *node
+        jobs = [jobs].flatten
+        if jobs.any? { |j| j.to_s =~ /^(!|~)/ }
+          @negative << node
+        end
+        @stack ||= []
+        if !@stack.empty? && @stack.last[1] != state
+          @conflicting << [@stack.last[0], node]
+        else
+          @stack << [node, state]
+          process_all(node)
+          @stack.pop
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -64,7 +64,6 @@ files:
 - config/commands.rb
 - config/version.rb
 - lib/atp.rb
-- lib/atp/and.rb
 - lib/atp/ast/builder.rb
 - lib/atp/ast/extractor.rb
 - lib/atp/ast/factories.rb
@@ -73,12 +72,12 @@ files:
 - lib/atp/formatter.rb
 - lib/atp/formatters/basic.rb
 - lib/atp/formatters/datalog.rb
-- lib/atp/not.rb
-- lib/atp/or.rb
 - lib/atp/parser.rb
 - lib/atp/processor.rb
+- lib/atp/processors/add_ids.rb
 - lib/atp/processors/condition.rb
 - lib/atp/processors/condition_extractor.rb
+- lib/atp/processors/marshal.rb
 - lib/atp/processors/post_cleaner.rb
 - lib/atp/processors/pre_cleaner.rb
 - lib/atp/processors/relationship.rb
@@ -87,6 +86,7 @@ files:
 - lib/atp/validator.rb
 - lib/atp/validators/condition.rb
 - lib/atp/validators/duplicate_ids.rb
+- lib/atp/validators/jobs.rb
 - lib/atp/validators/missing_ids.rb
 - lib/tasks/atp.rake
 - templates/web/archive.md.erb

data/lib/atp/and.rb

@@ -1,11 +0,0 @@
-module ATP
-  class AND < ::Array
-    def initialize(*vals)
-      vals.flatten.each { |v| self << v }
-    end
-
-    def inspect
-      "AND#{super}"
-    end
-  end
-end

data/lib/atp/not.rb

@@ -1,13 +0,0 @@
-module ATP
-  class NOT
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      "NOT[#{value}]"
-    end
-  end
-end

data/lib/atp/or.rb

@@ -1,11 +0,0 @@
-module ATP
-  class OR < ::Array
-    def initialize(*vals)
-      vals.flatten.each { |v| self << v }
-    end
-
-    def inspect
-      "OR#{super}"
-    end
-  end
-end