origen_testers 0.10.0 → 0.11.0

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

@@ -1,13 +1,13 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Include any V93K specific AST processors here
-        autoload :IfRanCleaner, 'origen_testers/smartest_based_tester/base/processors/if_ran_cleaner'
-        autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
-        autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
-        autoload :ExtractSetVariables, 'origen_testers/smartest_based_tester/base/processors/extract_set_variables'
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Include any V93K specific AST processors here
+        autoload :IfRanCleaner, 'origen_testers/smartest_based_tester/base/processors/if_ran_cleaner'
+        autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
+        autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
+        autoload :ExtractSetVariables, 'origen_testers/smartest_based_tester/base/processors/extract_set_variables'
+      end
+    end
+  end
+end

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

@@ -1,49 +1,49 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        class EmptyBranchCleaner < ATP::Processor
-          # Delete any on-fail child if it's 'empty'
-          def on_test(node)
-            on_pass = node.find(:on_pass)
-            on_fail = node.find(:on_fail)
-            unless on_fail.nil?
-              n = node.remove(on_fail) if branch_is_empty?(on_fail)
-              return n
-            end
-            node
-          end
-
-          # Returns true if:
-          #   - node is completely empty
-          #   - only child is (continue) node
-          #   - only two children, one continue and one set-result
-          def branch_is_empty?(node)
-            children = node.children.dup
-            return true if children.nil?
-
-            # test for only-child situation
-            first_born = children.shift
-            if children.empty?
-              if first_born == n0(:continue)
-                return true
-              else
-                return false
-              end
-            end
-
-            # if only 2 children, check qualificataions, else done and return false
-            next_born = children.shift
-            if children.empty?
-              if (first_born.type == :continue && next_born.type == :set_result) ||
-                 (first_born.type == :set_result && next_born.type == :continue)
-                return true
-              end
-            end
-            false
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class EmptyBranchCleaner < ATP::Processor
+          # Delete any on-fail child if it's 'empty'
+          def on_test(node)
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+            unless on_fail.nil?
+              n = node.remove(on_fail) if branch_is_empty?(on_fail)
+              return n
+            end
+            node
+          end
+
+          # Returns true if:
+          #   - node is completely empty
+          #   - only child is (continue) node
+          #   - only two children, one continue and one set-result
+          def branch_is_empty?(node)
+            children = node.children.dup
+            return true if children.nil?
+
+            # test for only-child situation
+            first_born = children.shift
+            if children.empty?
+              if first_born == n0(:continue)
+                return true
+              else
+                return false
+              end
+            end
+
+            # if only 2 children, check qualificataions, else done and return false
+            next_born = children.shift
+            if children.empty?
+              if (first_born.type == :continue && next_born.type == :set_result) ||
+                 (first_born.type == :set_result && next_born.type == :continue)
+                return true
+              end
+            end
+            false
+          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.upcase
-            @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.upcase
+            @results << flag
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,143 +1,143 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        class FlagOptimizer < ATP::Processor
-          attr_reader :run_flag_table
-          # This optimizes the AST such that any adjacent flow noes that
-          #
-          # For example this AST:
-          #   (flow
-          #     (test
-          #       (name "test1")
-          #       (on-fail
-          #         (set-run-flag "t1_FAILED")))
-          #     (run-flag "t1_FAILED" true
-          #       (test
-          #         (name "test2"))
-          #       (test
-          #         (name "test3")))
-          #     (test
-          #       (name "test4")
-          #       (on-pass
-          #         (set-run-flag "t4_PASSED"))
-          #       (on-fail
-          #         (continue)))
-          #     (run-flag "t4_PASSED" true
-          #       (test
-          #         (name "test5"))
-          #       (test
-          #         (name "test6"))))
-          #
-          # Will be optimized to this:
-          #   (flow
-          #     (test
-          #       (name "test1")
-          #       (on-fail
-          #         (test
-          #           (name "test2"))
-          #         (test
-          #           (name "test3"))))
-          #     (test
-          #       (name "test4")
-          #       (on-pass
-          #         (test
-          #           (name "test5"))
-          #         (test
-          #           (name "test6")))
-          #       (on-fail
-          #         (continue))))
-
-          # Processes the AST and tabulates occurences 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 = {}
-            end
-
-            # For run_flag nodes, increment # of occurences for specified flag
-            def on_run_flag(node)
-              children = node.children.dup
-              name = children.shift
-              state = children.shift
-              unless name.is_a?(Array)
-                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
-            end
-          end
-
-          # Only run this on top level flow and consider adjacent nodes, no need for
-          # looking at nested conditions.
-          def on_flow(node)
-            # Pre-process the AST for # of occurences of each run-flag used
-            t = ExtractRunFlagTable.new
-            t.process(node)
-            @run_flag_table = t.run_flag_table
-
-            name, *nodes = *node
-            results = []
-            node_a = nil
-            nodes.each do |node_b|
-              if node_a && node_a.type == :test && node_b.type == :run_flag
-                result, node_a = remove_run_flag(node_a, node_b)
-                results << result
-              else
-                results << node_a unless node_a.nil?
-                node_a = node_b
-              end
-            end
-            results << node_a unless node_a.nil?
-            node.updated(nil, [name] + results)
-          end
-
-          # Given two adjacent nodes, where the first (a) is a test and the second (b)
-          # is a run_flag, determine if (a) conditionally sets the same flag that (b)
-          # uses.  If it does, do a logical replacement, if not, move on quietly.
-          def remove_run_flag(node_a, node_b)
-            on_pass = node_a.find(:on_pass)
-            on_fail = node_a.find(:on_fail)
-
-            unless on_pass.nil? && on_fail.nil?
-              if on_pass.nil?
-                flag_node = on_fail.find(:set_run_flag)
-                conditional = [flag_node, on_fail]
-              else
-                flag_node = on_pass.find(:set_run_flag)
-                conditional = [flag_node, on_pass]
-              end
-            end
-            unless conditional.nil?
-              children = node_b.children.dup
-              name = children.shift
-              # remove the '_RAN' here so it won't match and if_ran cases are ignored
-              name = name.gsub(/_RAN$/, '') unless name.is_a?(Array)
-              state = children.shift
-              *nodes = *children
-              flag_node_b = n2(:set_run_flag, name, 'auto_generated') if state == true
-
-              if conditional.first == flag_node_b
-                n = conditional.last.dup
-                result = node_a.remove(n)
-                n = n.remove(conditional.first) if @run_flag_table[name.to_sym] == 1
-                n = n.remove(n0(:continue)) if n.type == :on_fail
-                s = n.find(:set_result) if n.type == :on_fail
-                n = n.remove(s) if s
-                n = n.updated(nil, n.children + (nodes.is_a?(Array) ? nodes : [nodes]))
-                result = result.updated(nil, result.children + (n.is_a?(Array) ? n : [n]))
-                return result, nil
-              end
-            end
-            [node_a, node_b]
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class FlagOptimizer < ATP::Processor
+          attr_reader :run_flag_table
+          # This optimizes the AST such that any adjacent flow noes that
+          #
+          # For example this AST:
+          #   (flow
+          #     (test
+          #       (name "test1")
+          #       (on-fail
+          #         (set-run-flag "t1_FAILED")))
+          #     (run-flag "t1_FAILED" true
+          #       (test
+          #         (name "test2"))
+          #       (test
+          #         (name "test3")))
+          #     (test
+          #       (name "test4")
+          #       (on-pass
+          #         (set-run-flag "t4_PASSED"))
+          #       (on-fail
+          #         (continue)))
+          #     (run-flag "t4_PASSED" true
+          #       (test
+          #         (name "test5"))
+          #       (test
+          #         (name "test6"))))
+          #
+          # Will be optimized to this:
+          #   (flow
+          #     (test
+          #       (name "test1")
+          #       (on-fail
+          #         (test
+          #           (name "test2"))
+          #         (test
+          #           (name "test3"))))
+          #     (test
+          #       (name "test4")
+          #       (on-pass
+          #         (test
+          #           (name "test5"))
+          #         (test
+          #           (name "test6")))
+          #       (on-fail
+          #         (continue))))
+
+          # Processes the AST and tabulates occurences 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 = {}
+            end
+
+            # For run_flag nodes, increment # of occurences for specified flag
+            def on_run_flag(node)
+              children = node.children.dup
+              name = children.shift
+              state = children.shift
+              unless name.is_a?(Array)
+                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
+            end
+          end
+
+          # Only run this on top level flow and consider adjacent nodes, no need for
+          # looking at nested conditions.
+          def on_flow(node)
+            # Pre-process the AST for # of occurences of each run-flag used
+            t = ExtractRunFlagTable.new
+            t.process(node)
+            @run_flag_table = t.run_flag_table
+
+            name, *nodes = *node
+            results = []
+            node_a = nil
+            nodes.each do |node_b|
+              if node_a && node_a.type == :test && node_b.type == :run_flag
+                result, node_a = remove_run_flag(node_a, node_b)
+                results << result
+              else
+                results << node_a unless node_a.nil?
+                node_a = node_b
+              end
+            end
+            results << node_a unless node_a.nil?
+            node.updated(nil, [name] + results)
+          end
+
+          # Given two adjacent nodes, where the first (a) is a test and the second (b)
+          # is a run_flag, determine if (a) conditionally sets the same flag that (b)
+          # uses.  If it does, do a logical replacement, if not, move on quietly.
+          def remove_run_flag(node_a, node_b)
+            on_pass = node_a.find(:on_pass)
+            on_fail = node_a.find(:on_fail)
+
+            unless on_pass.nil? && on_fail.nil?
+              if on_pass.nil?
+                flag_node = on_fail.find(:set_run_flag)
+                conditional = [flag_node, on_fail]
+              else
+                flag_node = on_pass.find(:set_run_flag)
+                conditional = [flag_node, on_pass]
+              end
+            end
+            unless conditional.nil?
+              children = node_b.children.dup
+              name = children.shift
+              # remove the '_RAN' here so it won't match and if_ran cases are ignored
+              name = name.gsub(/_RAN$/, '') unless name.is_a?(Array)
+              state = children.shift
+              *nodes = *children
+              flag_node_b = n2(:set_run_flag, name, 'auto_generated') if state == true
+
+              if conditional.first == flag_node_b
+                n = conditional.last.dup
+                result = node_a.remove(n)
+                n = n.remove(conditional.first) if @run_flag_table[name.to_sym] == 1
+                n = n.remove(n0(:continue)) if n.type == :on_fail
+                s = n.find(:set_result) if n.type == :on_fail
+                n = n.remove(s) if s
+                n = n.updated(nil, n.children + (nodes.is_a?(Array) ? nodes : [nodes]))
+                result = result.updated(nil, result.children + (n.is_a?(Array) ? n : [n]))
+                return result, nil
+              end
+            end
+            [node_a, node_b]
+          end
+        end
+      end
+    end
+  end
+end