origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/igxl_based_tester/base/ac_specsets.rb

@@ -1,79 +1,79 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class ACSpecsets
-        include ::OrigenTesters::Generator
-
-        attr_accessor :ac_specs
-        attr_accessor :ac_specsets
-
-        OUTPUT_PREFIX = 'SpecsAC'
-        # OUTPUT_POSTFIX = 'SpecsAC'
-
-        def initialize # :nodoc:
-          ## Hash Autovivification
-          l = ->(h, k) { h[k] = Hash.new(&l) }
-
-          @ac_specs = []
-          @ac_specsets = Hash.new(&l)
-        end
-
-        # Assigns an AC spec value object to the given variable for this specset
-        #   The attrs hash is expected to defined as follows:
-        #     attrs = {
-        #       specset:  :specset_name,    # if not defined, specset = :default
-        #                                   # Spec selectors that contain both the scope and value of the spec
-        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
-        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
-        #       max:      { max:  1.9 }
-        #     }
-        def add(spec, attrs = {})
-          attrs = {
-            specset: :default
-          }.merge(attrs)
-
-          specset = attrs.delete(:specset)
-
-          @ac_specs << spec unless @ac_specs.include?(spec)
-
-          attrs.each do |selector, value|
-            @ac_specsets[specset][spec][selector] = value
-          end
-        end
-
-        # Prepare the spec information for file output
-        def format_uflex_ac_spec(data, options = {})
-          case data
-          when NilClass
-            data_new = 0
-          when Fixnum, Float
-            case
-            when data == 0
-              data_new = data.to_s
-            when data.abs < 1e-9
-              data_new = (data * 1_000_000_000_000).round(4).to_s + '*ps'
-            when data.abs < 1e-6
-              data_new = (data * 1_000_000_000).round(4).to_s + '*ns'
-            when data.abs < 1e-3
-              data_new = (data * 1_000_000).round(4).to_s + '*us'
-            when data.abs < 1
-              data_new = (data * 1_000).round(4).to_s + '*ms'
-            else
-              data_new = data.to_s
-            end
-            data_new = data_new.gsub(/^/, '=')
-          when String
-            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
-            # Remove underscores from unit designations
-            data_new.gsub!(/(\W)_(nS|uS|mS|S)(\W)/i, '\1\2\3')
-            data_new.gsub!(/(\W)_(nS|uS|mS|S)$/i, '\1\2')
-          else
-            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
-            fail
-          end
-          data_new
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class ACSpecsets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :ac_specs
+        attr_accessor :ac_specsets
+
+        OUTPUT_PREFIX = 'SpecsAC'
+        # OUTPUT_POSTFIX = 'SpecsAC'
+
+        def initialize # :nodoc:
+          ## Hash Autovivification
+          l = ->(h, k) { h[k] = Hash.new(&l) }
+
+          @ac_specs = []
+          @ac_specsets = Hash.new(&l)
+        end
+
+        # Assigns an AC spec value object to the given variable for this specset
+        #   The attrs hash is expected to defined as follows:
+        #     attrs = {
+        #       specset:  :specset_name,    # if not defined, specset = :default
+        #                                   # Spec selectors that contain both the scope and value of the spec
+        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
+        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
+        #       max:      { max:  1.9 }
+        #     }
+        def add(spec, attrs = {})
+          attrs = {
+            specset: :default
+          }.merge(attrs)
+
+          specset = attrs.delete(:specset)
+
+          @ac_specs << spec unless @ac_specs.include?(spec)
+
+          attrs.each do |selector, value|
+            @ac_specsets[specset][spec][selector] = value
+          end
+        end
+
+        # Prepare the spec information for file output
+        def format_uflex_ac_spec(data, options = {})
+          case data
+          when NilClass
+            data_new = 0
+          when Fixnum, Float
+            case
+            when data == 0
+              data_new = data.to_s
+            when data.abs < 1e-9
+              data_new = (data * 1_000_000_000_000).round(4).to_s + '*ps'
+            when data.abs < 1e-6
+              data_new = (data * 1_000_000_000).round(4).to_s + '*ns'
+            when data.abs < 1e-3
+              data_new = (data * 1_000_000).round(4).to_s + '*us'
+            when data.abs < 1
+              data_new = (data * 1_000).round(4).to_s + '*ms'
+            else
+              data_new = data.to_s
+            end
+            data_new = data_new.gsub(/^/, '=')
+          when String
+            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
+            # Remove underscores from unit designations
+            data_new.gsub!(/(\W)_(nS|uS|mS|S)(\W)/i, '\1\2\3')
+            data_new.gsub!(/(\W)_(nS|uS|mS|S)$/i, '\1\2')
+          else
+            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
+            fail
+          end
+          data_new
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/custom_test_instance.rb

@@ -1,169 +1,169 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class CustomTestInstance
-        attr_accessor :type, :index, :version, :append_version, :finalize
-
-        # Returns the object representing the test instance library that the
-        # given test instance is defined in
-        attr_reader :library
-
-        def self.define
-          # Generate accessors for all attributes and their aliases
-          attrs.each do |attr|
-            writer = "#{attr}=".to_sym
-            reader = attr.to_sym
-            attr_reader attr.to_sym unless method_defined? reader
-            attr_writer attr.to_sym unless method_defined? writer
-          end
-
-          # Define the common aliases now, the instance type specific ones will
-          # be created when the instance type is known
-          self::TEST_INSTANCE_ALIASES.each do |_alias, val|
-            writer = "#{_alias}=".to_sym
-            reader = _alias.to_sym
-            unless val.is_a? Hash
-              unless method_defined? writer
-                define_method("#{_alias}=") do |v|
-                  send("#{val}=", v)
-                end
-              end
-              unless method_defined? reader
-                define_method("#{_alias}") do
-                  send(val)
-                end
-              end
-            end
-          end
-        end
-
-        def self.attrs
-          @attrs ||= begin
-            attrs = self::TEST_INSTANCE_ATTRS.dup
-
-            self::TEST_INSTANCE_EXTRA_ARGS.times do |i|
-              attrs << "arg#{i}"
-            end
-            attrs << 'comment'
-            attrs
-          end
-        end
-
-        def initialize(name, options = {})
-          @append_version = true
-          self.name = name
-          # 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, arg_default|
-            arg_default = [arg_default] unless arg_default.is_a?(Array)
-            unless attr == :aliases || attr == :methods
-              clean_attr = clean_attr_name(attr)
-              arg = arg_default[0]
-              default = arg_default[1]
-              allowed = arg_default[2]
-              aliases = [clean_attr]
-              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
-              aliases.each do |alias_|
-                define_singleton_method("#{alias_}=") do |v|
-                  if allowed
-                    unless allowed.include?(v)
-                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
-                    end
-                  end
-                  instance_variable_set("@#{arg}", v)
-                end
-                define_singleton_method(alias_) do
-                  instance_variable_get("@#{arg}")
-                end
-              end
-              send("#{arg}=", 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
-          # Set the defaults
-          self.class::TEST_INSTANCE_DEFAULTS.each do |k, v|
-            send("#{k}=", v) if self.respond_to?("#{k}=", v)
-          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 ==(other_instance)
-          self.class == other_instance.class &&
-            unversioned_name.to_s == other_instance.unversioned_name.to_s &&
-            self.class.attrs.all? do |attr|
-              # Exclude test name, already examined above and don't want to include
-              # the version in the comparison
-              if attr == 'test_name'
-                true
-              else
-                send(attr) == other_instance.send(attr)
-              end
-            end
-        end
-
-        # Returns the fully formatted test instance for insertion into an instance sheet
-        def to_s(override_name = nil)
-          l = "\t"
-          self.class.attrs.each do |attr|
-            if attr == 'test_name' && override_name
-              l += "#{override_name}\t"
-            else
-              l += "#{send(attr)}\t"
-            end
-          end
-          "#{l}"
-        end
-
-        def name
-          if version && @append_version
-            "#{@test_name}_v#{version}"
-          else
-            @test_name.to_s
-          end
-        end
-        alias_method :test_name, :name
-
-        def name=(val)
-          self.test_name = val
-        end
-
-        def unversioned_name
-          @test_name.to_s
-        end
-
-        private
-
-        def clean_attr_name(name)
-          name.to_s.gsub(/\.|-/, '_')
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class CustomTestInstance
+        attr_accessor :type, :index, :version, :append_version, :finalize
+
+        # Returns the object representing the test instance library that the
+        # given test instance is defined in
+        attr_reader :library
+
+        def self.define
+          # Generate accessors for all attributes and their aliases
+          attrs.each do |attr|
+            writer = "#{attr}=".to_sym
+            reader = attr.to_sym
+            attr_reader attr.to_sym unless method_defined? reader
+            attr_writer attr.to_sym unless method_defined? writer
+          end
+
+          # Define the common aliases now, the instance type specific ones will
+          # be created when the instance type is known
+          self::TEST_INSTANCE_ALIASES.each do |_alias, val|
+            writer = "#{_alias}=".to_sym
+            reader = _alias.to_sym
+            unless val.is_a? Hash
+              unless method_defined? writer
+                define_method("#{_alias}=") do |v|
+                  send("#{val}=", v)
+                end
+              end
+              unless method_defined? reader
+                define_method("#{_alias}") do
+                  send(val)
+                end
+              end
+            end
+          end
+        end
+
+        def self.attrs
+          @attrs ||= begin
+            attrs = self::TEST_INSTANCE_ATTRS.dup
+
+            self::TEST_INSTANCE_EXTRA_ARGS.times do |i|
+              attrs << "arg#{i}"
+            end
+            attrs << 'comment'
+            attrs
+          end
+        end
+
+        def initialize(name, options = {})
+          @append_version = true
+          self.name = name
+          # 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, arg_default|
+            arg_default = [arg_default] unless arg_default.is_a?(Array)
+            unless attr == :aliases || attr == :methods
+              clean_attr = clean_attr_name(attr)
+              arg = arg_default[0]
+              default = arg_default[1]
+              allowed = arg_default[2]
+              aliases = [clean_attr]
+              aliases << clean_attr.underscore if clean_attr.underscore != clean_attr
+              aliases.each do |alias_|
+                define_singleton_method("#{alias_}=") do |v|
+                  if allowed
+                    unless allowed.include?(v)
+                      fail "Cannot set #{alias_} to #{v}, valid values are: #{allowed.join(', ')}"
+                    end
+                  end
+                  instance_variable_set("@#{arg}", v)
+                end
+                define_singleton_method(alias_) do
+                  instance_variable_get("@#{arg}")
+                end
+              end
+              send("#{arg}=", 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
+          # Set the defaults
+          self.class::TEST_INSTANCE_DEFAULTS.each do |k, v|
+            send("#{k}=", v) if self.respond_to?("#{k}=", v)
+          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 ==(other_instance)
+          self.class == other_instance.class &&
+            unversioned_name.to_s == other_instance.unversioned_name.to_s &&
+            self.class.attrs.all? do |attr|
+              # Exclude test name, already examined above and don't want to include
+              # the version in the comparison
+              if attr == 'test_name'
+                true
+              else
+                send(attr) == other_instance.send(attr)
+              end
+            end
+        end
+
+        # Returns the fully formatted test instance for insertion into an instance sheet
+        def to_s(override_name = nil)
+          l = "\t"
+          self.class.attrs.each do |attr|
+            if attr == 'test_name' && override_name
+              l += "#{override_name}\t"
+            else
+              l += "#{send(attr)}\t"
+            end
+          end
+          "#{l}"
+        end
+
+        def name
+          if version && @append_version
+            "#{@test_name}_v#{version}"
+          else
+            @test_name.to_s
+          end
+        end
+        alias_method :test_name, :name
+
+        def name=(val)
+          self.test_name = val
+        end
+
+        def unversioned_name
+          @test_name.to_s
+        end
+
+        private
+
+        def clean_attr_name(name)
+          name.to_s.gsub(/\.|-/, '_')
+        end
+      end
+    end
+  end
+end