origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner.rb

@@ -1,21 +1,21 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Removes any empty on_pass and on_fail branches
-        class EmptyBranchCleaner < ATP::Processor
-          # Delete any on-fail child if it's 'empty'
-          def on_test(node)
-            if on_pass = node.find(:on_pass)
-              node = node.remove(on_pass) if on_pass.children.empty?
-            end
-            if on_fail = node.find(:on_fail)
-              node = node.remove(on_fail) if on_fail.children.empty?
-            end
-            node = node.updated(nil, process_all(node.children))
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Removes any empty on_pass and on_fail branches
+        class EmptyBranchCleaner < ATP::Processor
+          # Delete any on-fail child if it's 'empty'
+          def on_test(node)
+            if on_pass = node.find(:on_pass)
+              node = node.remove(on_pass) if on_pass.children.empty?
+            end
+            if on_fail = node.find(:on_fail)
+              node = node.remove(on_fail) if on_fail.children.empty?
+            end
+            node = node.updated(nil, process_all(node.children))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/extract_run_flag_table.rb

@@ -1,33 +1,33 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Processes the AST and tabulates occurrences of unique set_run_flag nodes
-        class ExtractRunFlagTable < ATP::Processor
-          # Hash table of run_flag name with number of times used
-          attr_reader :run_flag_table
-
-          # Reset hash table
-          def initialize
-            @run_flag_table = {}.with_indifferent_access
-          end
-
-          # For run_flag nodes, increment # of occurrences for specified flag
-          def on_run_flag(node)
-            children = node.children.dup
-            names = children.shift
-            state = children.shift
-            Array(names).each do |name|
-              if @run_flag_table[name.to_sym].nil?
-                @run_flag_table[name.to_sym] = 1
-              else
-                @run_flag_table[name.to_sym] += 1
-              end
-            end
-            process_all(node.children)
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Processes the AST and tabulates occurrences of unique set_run_flag nodes
+        class ExtractRunFlagTable < ATP::Processor
+          # Hash table of run_flag name with number of times used
+          attr_reader :run_flag_table
+
+          # Reset hash table
+          def initialize
+            @run_flag_table = {}.with_indifferent_access
+          end
+
+          # For run_flag nodes, increment # of occurrences for specified flag
+          def on_run_flag(node)
+            children = node.children.dup
+            names = children.shift
+            state = children.shift
+            Array(names).each do |name|
+              if @run_flag_table[name.to_sym].nil?
+                @run_flag_table[name.to_sym] = 1
+              else
+                @run_flag_table[name.to_sym] += 1
+              end
+            end
+            process_all(node.children)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/extract_set_variables.rb

@@ -1,22 +1,22 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Extracts all runtime variables which are set within the given flow, returning
-        # them in an array
-        class ExtractSetVariables < ATP::Processor
-          def run(nodes)
-            @results = []
-            process_all(nodes)
-            @results.uniq
-          end
-
-          def on_set_run_flag(node)
-            flag = node.value
-            @results << flag
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Extracts all runtime variables which are set within the given flow, returning
+        # them in an array
+        class ExtractSetVariables < ATP::Processor
+          def run(nodes)
+            @results = []
+            process_all(nodes)
+            @results.uniq
+          end
+
+          def on_set_run_flag(node)
+            flag = node.value
+            @results << flag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/flag_optimizer.rb

@@ -1,188 +1,188 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # This processor eliminates the use of run flags between adjacent tests:
-        #
-        #   s(:flow,
-        #     s(:name, "prb1"),
-        #     s(:test,
-        #       s(:name, "test1"),
-        #       s(:id, "t1"),
-        #       s(:on_fail,
-        #         s(:set_run_flag, "t1_FAILED", "auto_generated"),
-        #         s(:continue))),
-        #     s(:run_flag, "t1_FAILED", true,
-        #       s(:test,
-        #         s(:name, "test2"))))
-        #
-        #
-        #   s(:flow,
-        #     s(:name, "prb1"),
-        #     s(:test,
-        #       s(:name, "test1"),
-        #       s(:id, "t1"),
-        #       s(:on_fail,
-        #         s(:test,
-        #           s(:name, "test2")))))
-        #
-        class FlagOptimizer < ATP::Processor
-          attr_reader :run_flag_table
-
-          def run(node)
-            # Pre-process the AST for # of occurrences of each run-flag used
-            t = ExtractRunFlagTable.new
-            t.process(node)
-            @run_flag_table = t.run_flag_table
-            process(node)
-          end
-
-          def on_named_collection(node)
-            name, *nodes = *node
-            node.updated(nil, [name] + optimize(process_all(nodes)))
-          end
-          alias_method :on_flow, :on_named_collection
-          alias_method :on_group, :on_named_collection
-
-          def on_run_flag(node)
-            name, state, *nodes = *node
-            if run_flag_to_remove.last && run_flag_to_remove.last == node.to_a[0..1]
-              node.to_a.last
-            else
-              node.updated(nil, [name, state] + optimize(process_all(nodes)))
-            end
-          end
-
-          def on_on_fail(node)
-            if to_inline = nodes_to_inline_on_pass_or_fail.last
-              # If this node sets the flag that gates the node to be inlined
-              set_run_flag = node.find(:set_run_flag)
-              if set_run_flag && gated_by_set?(set_run_flag.to_a[0], to_inline)
-                # Remove the sub-node that sets the flag if there are no further references to it
-
-                if @run_flag_table[set_run_flag.to_a[0]] == 1 || !@run_flag_table[set_run_flag.to_a[0]]
-                  node = node.updated(nil, node.children - [set_run_flag])
-                end
-
-                # And append the content of the node to be in_lined at the end of this on pass/fail node
-                append = reorder_nested_run_flags(set_run_flag.to_a[0], to_inline).to_a[2..-1]
-
-                # Belt and braces approach to make sure this node to be inlined does
-                # not get picked up anywhere else
-                nodes_to_inline_on_pass_or_fail.pop
-                nodes_to_inline_on_pass_or_fail << nil
-              end
-            end
-            node.updated(nil, optimize(process_all(node.children + Array(append))))
-          end
-          alias_method :on_on_pass, :on_on_fail
-
-          def optimize(nodes)
-            results = []
-            node1 = nil
-            nodes.each do |node2|
-              if node1
-                if can_be_combined?(node1, node2)
-                  node1 = combine(node1, node2)
-                else
-                  results << node1
-                  node1 = node2
-                end
-              else
-                node1 = node2
-              end
-            end
-            results << node1 if node1
-            results
-          end
-
-          def can_be_combined?(node1, node2)
-            if node1.type == :test && node2.type == :run_flag
-              if node1.find_all(:on_fail, :on_pass).any? do |node|
-                if n = node.find(:set_run_flag)
-                  # Inline instead of setting a flag if...
-                  gated_by_set?(n.to_a[0], node2) && # The flag set by node1 is gating node2
-                  n.to_a[1] == 'auto_generated' && # The flag has been generated and not specified by the user
-                  n.to_a[0] !~ /_RAN$/ # And don't compress RAN flags because they can be set by both on_fail and on_pass
-                end
-              end
-                return true
-              end
-            end
-            false
-          end
-
-          def combine(node1, node2)
-            nodes_to_inline_on_pass_or_fail << node2
-            node1 = node1.updated(nil, process_all(node1.children))
-            nodes_to_inline_on_pass_or_fail.pop
-            node1
-          end
-
-          # node will always be a run_flag type node, guaranteed by the caller
-          #
-          # Returns true if flag matches the one supplied and it is required to be set(true), like this:
-          #
-          #   s(:run_flag, flag, true,
-          #     s(:test, ...
-          #
-          # Also returns true if flag matches the one supplied, but it is nested within other flag conditions:
-          #
-          #   s(:run_flag, other_flag, false,
-          #     s(:run_flag, other_flag2, true,
-          #       s(:run_flag, flag, true,
-          #         s(:test, ...
-          def gated_by_set?(flag, node)
-            (flag == node.to_a[0] && node.to_a[1]) ||
-              (node.to_a.size == 3 && node.to_a.last.type == :run_flag && gated_by_set?(flag, node.to_a.last))
-          end
-
-          # Returns the node with the run_flag clauses re-ordered to have the given flag of interest at the top.
-          #
-          # The caller guarantees the run_flag clause containing the given flag is present.
-          #
-          # For example, given this node:
-          #
-          #   s(:run_flag, "flag1", false,
-          #     s(:run_flag, "ot_BEA7F3B_FAILED", true,
-          #       s(:test,
-          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
-          #         s(:name, "inner_test1_BEA7F3B"),
-          #         s(:number, 0),
-          #         s(:id, "it1_BEA7F3B"),
-          #         s(:on_fail,
-          #           s(:render, "multi_bin;")))))
-          #
-          # Then this node would be returned when the flag of interest is ot_BEA7F3B_FAILED:
-          #
-          #   s(:run_flag, "ot_BEA7F3B_FAILED", true,
-          #     s(:run_flag, "flag1", false,
-          #       s(:test,
-          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
-          #         s(:name, "inner_test1_BEA7F3B"),
-          #         s(:number, 0),
-          #         s(:id, "it1_BEA7F3B"),
-          #         s(:on_fail,
-          #           s(:render, "multi_bin;")))))
-          def reorder_nested_run_flags(flag, node)
-            # If the run_flag we care about is already at the top, just return node
-            unless node.to_a[0] == flag && node.to_a[1]
-              run_flag_to_remove << [flag, true]
-              node = n(:run_flag, [flag, true, process(node)])
-              run_flag_to_remove.pop
-            end
-            node
-          end
-
-          def run_flag_to_remove
-            @run_flag_to_remove ||= []
-          end
-
-          def nodes_to_inline_on_pass_or_fail
-            @nodes_to_inline_on_pass_or_fail ||= []
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # This processor eliminates the use of run flags between adjacent tests:
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:test,
+        #       s(:name, "test1"),
+        #       s(:id, "t1"),
+        #       s(:on_fail,
+        #         s(:set_run_flag, "t1_FAILED", "auto_generated"),
+        #         s(:continue))),
+        #     s(:run_flag, "t1_FAILED", true,
+        #       s(:test,
+        #         s(:name, "test2"))))
+        #
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:test,
+        #       s(:name, "test1"),
+        #       s(:id, "t1"),
+        #       s(:on_fail,
+        #         s(:test,
+        #           s(:name, "test2")))))
+        #
+        class FlagOptimizer < ATP::Processor
+          attr_reader :run_flag_table
+
+          def run(node)
+            # Pre-process the AST for # of occurrences of each run-flag used
+            t = ExtractRunFlagTable.new
+            t.process(node)
+            @run_flag_table = t.run_flag_table
+            process(node)
+          end
+
+          def on_named_collection(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+          alias_method :on_flow, :on_named_collection
+          alias_method :on_group, :on_named_collection
+
+          def on_run_flag(node)
+            name, state, *nodes = *node
+            if run_flag_to_remove.last && run_flag_to_remove.last == node.to_a[0..1]
+              node.to_a.last
+            else
+              node.updated(nil, [name, state] + optimize(process_all(nodes)))
+            end
+          end
+
+          def on_on_fail(node)
+            if to_inline = nodes_to_inline_on_pass_or_fail.last
+              # If this node sets the flag that gates the node to be inlined
+              set_run_flag = node.find(:set_run_flag)
+              if set_run_flag && gated_by_set?(set_run_flag.to_a[0], to_inline)
+                # Remove the sub-node that sets the flag if there are no further references to it
+
+                if @run_flag_table[set_run_flag.to_a[0]] == 1 || !@run_flag_table[set_run_flag.to_a[0]]
+                  node = node.updated(nil, node.children - [set_run_flag])
+                end
+
+                # And append the content of the node to be in_lined at the end of this on pass/fail node
+                append = reorder_nested_run_flags(set_run_flag.to_a[0], to_inline).to_a[2..-1]
+
+                # Belt and braces approach to make sure this node to be inlined does
+                # not get picked up anywhere else
+                nodes_to_inline_on_pass_or_fail.pop
+                nodes_to_inline_on_pass_or_fail << nil
+              end
+            end
+            node.updated(nil, optimize(process_all(node.children + Array(append))))
+          end
+          alias_method :on_on_pass, :on_on_fail
+
+          def optimize(nodes)
+            results = []
+            node1 = nil
+            nodes.each do |node2|
+              if node1
+                if can_be_combined?(node1, node2)
+                  node1 = combine(node1, node2)
+                else
+                  results << node1
+                  node1 = node2
+                end
+              else
+                node1 = node2
+              end
+            end
+            results << node1 if node1
+            results
+          end
+
+          def can_be_combined?(node1, node2)
+            if node1.type == :test && node2.type == :run_flag
+              if node1.find_all(:on_fail, :on_pass).any? do |node|
+                if n = node.find(:set_run_flag)
+                  # Inline instead of setting a flag if...
+                  gated_by_set?(n.to_a[0], node2) && # The flag set by node1 is gating node2
+                  n.to_a[1] == 'auto_generated' && # The flag has been generated and not specified by the user
+                  n.to_a[0] !~ /_RAN$/ # And don't compress RAN flags because they can be set by both on_fail and on_pass
+                end
+              end
+                return true
+              end
+            end
+            false
+          end
+
+          def combine(node1, node2)
+            nodes_to_inline_on_pass_or_fail << node2
+            node1 = node1.updated(nil, process_all(node1.children))
+            nodes_to_inline_on_pass_or_fail.pop
+            node1
+          end
+
+          # node will always be a run_flag type node, guaranteed by the caller
+          #
+          # Returns true if flag matches the one supplied and it is required to be set(true), like this:
+          #
+          #   s(:run_flag, flag, true,
+          #     s(:test, ...
+          #
+          # Also returns true if flag matches the one supplied, but it is nested within other flag conditions:
+          #
+          #   s(:run_flag, other_flag, false,
+          #     s(:run_flag, other_flag2, true,
+          #       s(:run_flag, flag, true,
+          #         s(:test, ...
+          def gated_by_set?(flag, node)
+            (flag == node.to_a[0] && node.to_a[1]) ||
+              (node.to_a.size == 3 && node.to_a.last.type == :run_flag && gated_by_set?(flag, node.to_a.last))
+          end
+
+          # Returns the node with the run_flag clauses re-ordered to have the given flag of interest at the top.
+          #
+          # The caller guarantees the run_flag clause containing the given flag is present.
+          #
+          # For example, given this node:
+          #
+          #   s(:run_flag, "flag1", false,
+          #     s(:run_flag, "ot_BEA7F3B_FAILED", true,
+          #       s(:test,
+          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+          #         s(:name, "inner_test1_BEA7F3B"),
+          #         s(:number, 0),
+          #         s(:id, "it1_BEA7F3B"),
+          #         s(:on_fail,
+          #           s(:render, "multi_bin;")))))
+          #
+          # Then this node would be returned when the flag of interest is ot_BEA7F3B_FAILED:
+          #
+          #   s(:run_flag, "ot_BEA7F3B_FAILED", true,
+          #     s(:run_flag, "flag1", false,
+          #       s(:test,
+          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+          #         s(:name, "inner_test1_BEA7F3B"),
+          #         s(:number, 0),
+          #         s(:id, "it1_BEA7F3B"),
+          #         s(:on_fail,
+          #           s(:render, "multi_bin;")))))
+          def reorder_nested_run_flags(flag, node)
+            # If the run_flag we care about is already at the top, just return node
+            unless node.to_a[0] == flag && node.to_a[1]
+              run_flag_to_remove << [flag, true]
+              node = n(:run_flag, [flag, true, process(node)])
+              run_flag_to_remove.pop
+            end
+            node
+          end
+
+          def run_flag_to_remove
+            @run_flag_to_remove ||= []
+          end
+
+          def nodes_to_inline_on_pass_or_fail
+            @nodes_to_inline_on_pass_or_fail ||= []
+          end
+        end
+      end
+    end
+  end
+end