origen_testers 0.13.1 → 0.13.2

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

@@ -1,34 +1,34 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        class IfRanCleaner < ATP::Processor
-          def on_test(node)
-            on_pass = node.find(:on_pass)
-            on_fail = node.find(:on_fail)
-
-            unless on_pass.nil? || on_fail.nil?
-              set_run_flag = on_fail.find(:set_run_flag)
-              set_result = on_fail.find(:set_result)
-              unless set_run_flag.nil? || set_result.nil?
-                children = set_run_flag.children.dup
-                name = children.shift
-                ag_string = children.shift
-
-                if name =~ /_RAN$/ && ag_string == 'auto_generated'
-                  f = on_fail.dup
-                  f = f.remove(set_result)
-                  n = node.remove(on_fail)
-                  n = n.updated(nil, n.children + (f.is_a?(Array) ? f : [f]))
-                  return n
-                end
-
-              end
-            end
-            node
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class IfRanCleaner < ATP::Processor
+          def on_test(node)
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+
+            unless on_pass.nil? || on_fail.nil?
+              set_run_flag = on_fail.find(:set_run_flag)
+              set_result = on_fail.find(:set_result)
+              unless set_run_flag.nil? || set_result.nil?
+                children = set_run_flag.children.dup
+                name = children.shift
+                ag_string = children.shift
+
+                if name =~ /_RAN$/ && ag_string == 'auto_generated'
+                  f = on_fail.dup
+                  f = f.remove(set_result)
+                  n = node.remove(on_fail)
+                  n = n.updated(nil, n.children + (f.is_a?(Array) ? f : [f]))
+                  return n
+                end
+
+              end
+            end
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,164 +1,178 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      class TestMethod
-        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double]
-
-        # Returns the object representing the test method library that the
-        # given test method is defined in
-        attr_reader :library
-        attr_reader :type
-        attr_reader :id
-        alias_method :name, :id
-        # Returns an hash corresponding to the parameters that the given test method has.
-        # The keys are the parameter names and the values are the parameter type.
-        attr_reader :parameters
-        attr_accessor :class_name
-        attr_accessor :abs_class_name
-
-        def initialize(options)
-          @type = options[:type]
-          @library = options[:library]
-          @class_name = options[:methods].delete(:class_name)
-          @parameters = {}
-          # Add limits by default
-          define_singleton_method('limits') do
-            @limits
-          end
-          @limits = TestMethods::Limits.new(self)
-          # Add any methods
-          if options[:methods][:methods]
-            methods = options[:methods][:methods]
-            @finalize = methods[:finalize]
-            methods.each do |method_name, function|
-              unless method_name == :finalize
-                var_name = "@#{method_name}".gsub(/=|\?/, '_')
-                instance_variable_set(var_name, function)
-                define_singleton_method method_name do |*args|
-                  instance_variable_get(var_name).call(self, *args)
-                end
-              end
-            end
-          end
-          # Create attributes corresponding to the test method type represented
-          # by this method instance
-          options[:methods].each do |attr, type_default|
-            unless attr == :limits_type || attr == :aliases || attr == :methods
-              clean_attr = clean_attr_name(attr)
-              type = type_default[0]
-              default = type_default[1]
-              allowed = type_default[2]
-              @parameters[attr] = type
-              aliases = [clean_attr]
-              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
-              aliases.each do |alias_|
-                define_singleton_method("#{alias_}=") do |v|
-                  v = v.to_s if v.is_a?(Symbol)
-                  if allowed
-                    unless allowed.include?(v)
-                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
-                    end
-                  end
-                  instance_variable_set("@#{clean_attr}", v)
-                end
-                define_singleton_method(alias_) do
-                  instance_variable_get("@#{clean_attr}")
-                end
-              end
-              send("#{clean_attr}=", default)
-            end
-          end
-          if options[:methods][:aliases]
-            options[:methods][:aliases].each do |alias_, attr|
-              clean_attr = clean_attr_name(attr)
-              define_singleton_method("#{alias_}=") do |v|
-                send("#{clean_attr}=", v)
-              end
-              define_singleton_method(alias_) do
-                send(clean_attr)
-              end
-            end
-          end
-          # Finally set any initial values that have been supplied
-          options[:attrs].each do |k, v|
-            send("#{k}=", v) if respond_to?("#{k}=")
-          end
-        end
-
-        def format(attr)
-          clean_attr = clean_attr_name(attr)
-          val = send(clean_attr)
-          if FORMAT_TYPES.include?(parameters[attr])
-            type = parameters[attr]
-          else
-            # The type is based on the value of another attribute
-            name = clean_attr_name(parameters[attr])
-            if respond_to?(name)
-              type = send(name)
-            elsif respond_to?(name.sub(/b$/, ''))
-              type = inverse_of(send(name.sub(/b$/, '')))
-            else
-              fail "Unknown attribute type: #{parameters[attr]}"
-            end
-          end
-          case type
-          when :current, 'CURR'
-            "#{val}[A]"
-          when :voltage, 'VOLT'
-            "#{val}[V]"
-          when :time
-            "#{val}[s]"
-          when :frequency
-            "#{val}[Hz]"
-          when :string, :integer, :double
-            val.to_s
-          else
-            fail "Unknown type for attribute #{attr}: #{type}"
-          end
-        end
-
-        def klass
-          @abs_class_name ||
-            "#{library.klass}.#{@class_name || type.to_s.camelize}"
-        end
-
-        def finalize
-          @finalize
-        end
-
-        def method_missing(method, *args, &block)
-          if limits && limits.respond_to?(method)
-            limits.send(method, *args, &block)
-          else
-            super
-          end
-        end
-
-        def respond_to?(method)
-          (limits && limits.respond_to?(method)) || super
-        end
-
-        private
-
-        def inverse_of(type)
-          case type
-          when :current, 'CURR'
-            :voltage
-          when :voltage, 'VOLT'
-            :current
-          else
-            fail "Don't know the inverse of type: #{type}"
-          end
-        end
-
-        def clean_attr_name(name)
-          name.to_s.gsub(/\.|-|\s+/, '_')
-        end
-
-        def id=(val)
-          @id = val
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethod
+        FORMAT_TYPES = [:current, :voltage, :time, :string, :integer, :double]
+
+        # Returns the object representing the test method library that the
+        # given test method is defined in
+        attr_reader :library
+        attr_reader :type
+        attr_reader :id
+        alias_method :name, :id
+        # Returns an hash corresponding to the parameters that the given test method has.
+        # The keys are the parameter names and the values are the parameter type.
+        attr_reader :parameters
+        attr_accessor :class_name
+        attr_accessor :abs_class_name
+
+        def initialize(options)
+          @type = options[:type]
+          @library = options[:library]
+          @class_name = options[:methods].delete(:class_name)
+          @parameters = {}
+          # Add limits by default
+          define_singleton_method('limits') do
+            @limits
+          end
+          @limits = TestMethods::Limits.new(self)
+          # Add any methods
+          if options[:methods][:methods]
+            methods = options[:methods][:methods]
+            @finalize = methods[:finalize]
+            methods.each do |method_name, function|
+              unless method_name == :finalize
+                var_name = "@#{method_name}".gsub(/=|\?/, '_')
+                instance_variable_set(var_name, function)
+                define_singleton_method method_name do |*args|
+                  instance_variable_get(var_name).call(self, *args)
+                end
+              end
+            end
+          end
+          # Create attributes corresponding to the test method type represented
+          # by this method instance
+          options[:methods].each do |attr, type_default|
+            unless attr == :limits_type || attr == :aliases || attr == :methods
+              clean_attr = clean_attr_name(attr)
+              type = type_default[0]
+              default = type_default[1]
+              allowed = type_default[2]
+              @parameters[attr] = type
+              aliases = [clean_attr]
+              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
+              aliases.each do |alias_|
+                define_singleton_method("#{alias_}=") do |v|
+                  v = v.to_s if v.is_a?(Symbol)
+                  if allowed
+                    unless allowed.include?(v)
+                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
+                    end
+                  end
+                  instance_variable_set("@#{clean_attr}", v)
+                end
+                define_singleton_method(alias_) do
+                  instance_variable_get("@#{clean_attr}")
+                end
+              end
+              send("#{clean_attr}=", default)
+            end
+          end
+          if options[:methods][:aliases]
+            options[:methods][:aliases].each do |alias_, attr|
+              clean_attr = clean_attr_name(attr)
+              define_singleton_method("#{alias_}=") do |v|
+                send("#{clean_attr}=", v)
+              end
+              define_singleton_method(alias_) do
+                send(clean_attr)
+              end
+            end
+          end
+          # Finally set any initial values that have been supplied
+          options[:attrs].each do |k, v|
+            send("#{k}=", v) if respond_to?("#{k}=")
+          end
+        end
+
+        def format(attr)
+          clean_attr = clean_attr_name(attr)
+          val = send(clean_attr)
+          if FORMAT_TYPES.include?(parameters[attr])
+            type = parameters[attr]
+          else
+            # The type is based on the value of another attribute
+            name = clean_attr_name(parameters[attr])
+            if respond_to?(name)
+              type = send(name)
+            elsif respond_to?(name.sub(/b$/, ''))
+              type = inverse_of(send(name.sub(/b$/, '')))
+            else
+              fail "Unknown attribute type: #{parameters[attr]}"
+            end
+          end
+          case type
+          when :current, 'CURR'
+            "#{val}[A]"
+          when :voltage, 'VOLT'
+            "#{val}[V]"
+          when :time
+            "#{val}[s]"
+          when :frequency
+            "#{val}[Hz]"
+          when :string, :integer, :double
+            val.to_s
+          else
+            fail "Unknown type for attribute #{attr}: #{type}"
+          end
+        end
+
+        def klass
+          @abs_class_name ||
+            "#{library.klass}.#{@class_name || type.to_s.camelize}"
+        end
+
+        def finalize
+          @finalize
+        end
+
+        def method_missing(method, *args, &block)
+          if limits && limits.respond_to?(method)
+            limits.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          (limits && limits.respond_to?(method)) || super
+        end
+
+        def sorted_parameters
+          @parameters.sort_by do |name|
+            if name.is_a?(String)
+              name
+            else
+              if name.to_s[0] == '_'
+                name.to_s.camelize(:upper)
+              else
+                name.to_s.camelize(:lower)
+              end
+            end
+          end
+        end
+
+        private
+
+        def inverse_of(type)
+          case type
+          when :current, 'CURR'
+            :voltage
+          when :voltage, 'VOLT'
+            :current
+          else
+            fail "Don't know the inverse of type: #{type}"
+          end
+        end
+
+        def clean_attr_name(name)
+          name.to_s.gsub(/\.|-|\s+/, '_')
+        end
+
+        def id=(val)
+          @id = val
+        end
+      end
+    end
+  end
+end

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

@@ -1,73 +1,77 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      class TestMethods
-        # Origen::Tester::Generator not included since test methods do not have their
-        # own top-level sheet, they will be incorporated within the flow sheet
-
-        require 'origen_testers/smartest_based_tester/base/test_methods/base_tml'
-        require 'origen_testers/smartest_based_tester/base/test_methods/limits'
-        autoload :AcTml, 'origen_testers/smartest_based_tester/base/test_methods/ac_tml'
-        autoload :DcTml, 'origen_testers/smartest_based_tester/base/test_methods/dc_tml'
-        autoload :CustomTml, 'origen_testers/smartest_based_tester/base/test_methods/custom_tml'
-
-        attr_accessor :flow, :collection
-
-        def initialize(flow)
-          @flow = flow
-          @collection = []
-          @ix = 0
-        end
-
-        def filename
-          flow.filename
-        end
-
-        def add(test_method, options = {})
-          collection << test_method
-          test_method.send 'id=', "tm_#{collection.size}"
-          test_method
-        end
-
-        def [](ix)
-          collection[ix]
-        end
-
-        # Returns the AC test method library
-        def ac_tml
-          @ac_tml ||= AcTml.new(self)
-        end
-
-        # Returns the DC test method library
-        def dc_tml
-          @dc_tml ||= DcTml.new(self)
-        end
-
-        # Creates an accessor for custom test method libraries the first time they are called
-        def method_missing(method, *args, &block)
-          custom_tmls = Origen.interface.send(:custom_tmls)
-          if custom_tmls[method]
-            tml = CustomTml.new(self, custom_tmls[method])
-            instance_variable_set "@#{method}", tml
-            define_singleton_method method do
-              instance_variable_get("@#{method}")
-            end
-            send(method)
-          else
-            super
-          end
-        end
-
-        def respond_to?(method)
-          !!Origen.interface.send(:custom_tmls)[method] || super
-        end
-
-        def finalize
-          collection.each do |method|
-            method.finalize.call(method) if method.finalize
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        # Origen::Tester::Generator not included since test methods do not have their
+        # own top-level sheet, they will be incorporated within the flow sheet
+
+        require 'origen_testers/smartest_based_tester/base/test_methods/base_tml'
+        require 'origen_testers/smartest_based_tester/base/test_methods/limits'
+        autoload :AcTml, 'origen_testers/smartest_based_tester/base/test_methods/ac_tml'
+        autoload :DcTml, 'origen_testers/smartest_based_tester/base/test_methods/dc_tml'
+        autoload :CustomTml, 'origen_testers/smartest_based_tester/base/test_methods/custom_tml'
+
+        attr_accessor :flow, :collection
+
+        def initialize(flow)
+          @flow = flow
+          @collection = []
+          @ix = 0
+        end
+
+        def filename
+          flow.filename
+        end
+
+        def add(test_method, options = {})
+          collection << test_method
+          test_method.send 'id=', "tm_#{collection.size}"
+          test_method
+        end
+
+        def [](ix)
+          collection[ix]
+        end
+
+        # Returns the AC test method library
+        def ac_tml
+          @ac_tml ||= AcTml.new(self)
+        end
+
+        # Returns the DC test method library
+        def dc_tml
+          @dc_tml ||= DcTml.new(self)
+        end
+
+        # Creates an accessor for custom test method libraries the first time they are called
+        def method_missing(method, *args, &block)
+          custom_tmls = Origen.interface.send(:custom_tmls)
+          if custom_tmls[method]
+            tml = CustomTml.new(self, custom_tmls[method])
+            instance_variable_set "@#{method}", tml
+            define_singleton_method method do
+              instance_variable_get("@#{method}")
+            end
+            send(method)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          !!Origen.interface.send(:custom_tmls)[method] || super
+        end
+
+        def finalize
+          collection.each do |method|
+            method.finalize.call(method) if method.finalize
+          end
+        end
+
+        def sorted_collection
+          @collection.sort_by { |tm| tm.name.to_s }
+        end
+      end
+    end
+  end
+end