origen_testers 0.13.1 → 0.13.2

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

@@ -1,66 +1,66 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class TestInstanceGroup
-        attr_accessor :name, :version, :append_version
-
-        include Enumerable
-
-        def initialize(name, options = {})
-          @name = name
-          @store = []
-          @append_version = true
-        end
-
-        def name
-          if unversioned_name
-            if version && @append_version
-              "#{unversioned_name}_v#{version}"
-            else
-              unversioned_name.to_s
-            end
-          end
-        end
-
-        def unversioned_name
-          if @name
-            if @name =~ /grp$/
-              @name
-            else
-              "#{@name}_grp"
-            end
-          end
-        end
-
-        def <<(instance)
-          @store << instance
-        end
-
-        def size
-          @store.size
-        end
-
-        def each
-          @store.each { |ins| yield ins }
-        end
-
-        def ==(other_instance_group)
-          self.class == other_instance_group.class &&
-            unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
-            size == other_instance_group.size &&
-            self.all? do |ins|
-              other_instance_group.any? { |other_ins| ins == other_ins }
-            end
-        end
-
-        def finalize
-          lambda do |group|
-            each do |ti|
-              ti.finalize.call(ti) if ti.finalize
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TestInstanceGroup
+        attr_accessor :name, :version, :append_version
+
+        include Enumerable
+
+        def initialize(name, options = {})
+          @name = name
+          @store = []
+          @append_version = true
+        end
+
+        def name
+          if unversioned_name
+            if version && @append_version
+              "#{unversioned_name}_v#{version}"
+            else
+              unversioned_name.to_s
+            end
+          end
+        end
+
+        def unversioned_name
+          if @name
+            if @name =~ /grp$/
+              @name
+            else
+              "#{@name}_grp"
+            end
+          end
+        end
+
+        def <<(instance)
+          @store << instance
+        end
+
+        def size
+          @store.size
+        end
+
+        def each
+          @store.each { |ins| yield ins }
+        end
+
+        def ==(other_instance_group)
+          self.class == other_instance_group.class &&
+            unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
+            size == other_instance_group.size &&
+            self.all? do |ins|
+              other_instance_group.any? { |other_ins| ins == other_ins }
+            end
+        end
+
+        def finalize
+          lambda do |group|
+            each do |ti|
+              ti.finalize.call(ti) if ti.finalize
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,212 +1,212 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class TestInstances
-        include OrigenTesters::Generator
-
-        autoload :CustomTil, 'origen_testers/igxl_based_tester/base/test_instances/custom_til'
-
-        OUTPUT_POSTFIX = 'instances'
-
-        class IndexedString < ::String
-          attr_accessor :index
-
-          def name
-            self
-          end
-        end
-
-        def add(name, type, options = {})
-          options = {
-            test_instance_class: platform::TestInstance
-          }.merge(options)
-          klass =
-          if type.is_a?(Symbol) || type.is_a?(String)
-            ins = options.delete(:test_instance_class).new(name, type, options)
-          else
-            ins = type
-          end
-          if @current_group
-            @current_group << ins
-          else
-            collection << ins
-          end
-          c = Origen.interface.consume_comments
-          Origen.interface.descriptions.add_for_test_definition(name, c)
-          ins
-        end
-
-        # IG-XL doesn't have a formal instance group type and instead declares them anonymously
-        # whenever test instances of the same name appear consecutively in the test instance sheet.
-        # However when it comes to generating a test program life becomes much easier if we have
-        # a way to explicitly declare instances as part of a group - this makes duplicate tracking
-        # and sorting of the test instance sheet much easier.
-        #
-        # Use this method to generate instance groups via a block. Within the block you should
-        # generate instances as normal and they will automatically be assigned to the current group.
-        # Note that the name of the instances generated within the group is discarded and replaced
-        # with the name of the group. Origen automatically appends "grp" to this name to highlight
-        # instances that were generated as part of the group.
-        #
-        #   test_instances.group("erase_all_blocks") do |group|
-        #     # Generate instances here as normal
-        #     test_instances.functional("erase_blk0")
-        #     test_instances.functional("erase_blk1")
-        #   end
-        #
-        # The group object is passed into the block but usually you should not need to interact
-        # with this directly except maybe to set the name if it is not yet established at the point
-        # where the group is initiated:
-        #
-        #   test_instances.group do |group|
-        #     # Generate instances here as normal
-        #     group.name = "group_blah"
-        #   end
-        #
-        # A common way to generate groups is to create a helper method in your application which
-        # is responsible for creating groups as required:
-        #
-        #   def group_wrapper(name, options)
-        #     if options[:by_block]
-        #       test_instances.group(name) do |group|
-        #         yield group
-        #       end
-        #     else
-        #       yield
-        #     end
-        #   end
-        #
-        # In that case the group argument becomes quite useful for branching based on whether you
-        # are generating a group or standalone instances:
-        #
-        #  group_wrapper(name, options) do |group|
-        #    if group
-        #      # Generate group instances
-        #    else
-        #      # Generate standalone instances
-        #    end
-        #  end
-        def group(name = nil, options = {})
-          name, options = nil, name if name.is_a?(Hash)
-          @current_group = platform::TestInstanceGroup.new(name, options)
-          collection << @current_group
-          yield @current_group
-          @current_group = nil
-        end
-        alias_method :add_group, :group
-
-        def finalize(options = {}) # :nodoc:
-          uniq!
-          sort_and_finalize!
-        end
-
-        def uniq! # :nodoc:
-          uniques = []
-          versions = {}
-          multi_version_tests = {}
-          collection.each do |instance|
-            # If a uniquely named instance is found add it, otherwise update the version
-            # of the current instance to match that of the existing instance that it duplicates
-            unless uniques.any? do |i|
-              if i == instance
-                instance.version = i.version
-                true
-              else
-                false
-              end
-            end
-              if instance.respond_to?(:version=)
-                versions[instance.unversioned_name] ||= 0
-                versions[instance.unversioned_name] += 1
-                if versions[instance.unversioned_name] > 1
-                  multi_version_tests[instance.unversioned_name] = true
-                end
-                instance.version = versions[instance.unversioned_name]
-              end
-              uniques << instance
-            end
-          end
-          # This final loop disables the version identifier for tests that have only a single version,
-          # this makes it clearer when multiple versions exist - whenever you see a v1 you know there
-          # is at least a v2 also.
-          collection.map! do |instance|
-            if instance.respond_to?(:version=)
-              unless multi_version_tests[instance.unversioned_name]
-                instance.append_version = false
-              end
-            end
-            instance
-          end
-          self.collection = uniques
-        end
-
-        def sort_and_finalize! # :nodoc:
-          # Present the instances in the final sheet in alphabetical order
-          collection.map!.with_index do |ins, i|
-            if ins.is_a?(String)   # Can happen if content has been rendered in from a template
-              ins = IndexedString.new(ins)
-            else
-              ins.finalize.call(ins) if ins.finalize
-            end
-            ins
-          end
-          collection.sort! { |a, b| [a.name.to_s] <=> [b.name.to_s] }
-        end
-
-        def bpmu(name, options = {})
-          add(name, :board_pmu, options)
-        end
-        alias_method :board_pmu, :bpmu
-
-        def powersupply(name, options = {})
-          add(name, :powersupply, options)
-        end
-        alias_method :power_supply, :powersupply
-
-        def ppmu(name, options = {})
-          add(name, :pin_pmu, options)
-        end
-        alias_method :pin_pmu, :ppmu
-
-        def functional(name, options = {})
-          add(name, :functional, options)
-        end
-
-        def empty(name, options = {})
-          add(name, :empty, options)
-        end
-
-        def other(name, options = {})
-          add(name, :other, options)
-        end
-
-        def apmu_powersupply(name, options = {})
-          add(name, :apmu_powersupply, options)
-        end
-
-        def mto_memory(name, options = {})
-          add(name, :mto_memory, options)
-        end
-
-        # Creates an accessor for custom test method libraries the first time they are called
-        def method_missing(method, *args, &block)
-          custom_tils = Origen.interface.send(:custom_tils)
-          if custom_tils[method]
-            ti = CustomTil.new(self, custom_tils[method])
-            instance_variable_set "@#{method}", ti
-            define_singleton_method method do
-              instance_variable_get("@#{method}")
-            end
-            send(method)
-          else
-            super
-          end
-        end
-
-        def respond_to?(method)
-          !!Origen.interface.send(:custom_tils)[method] || super
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TestInstances
+        include OrigenTesters::Generator
+
+        autoload :CustomTil, 'origen_testers/igxl_based_tester/base/test_instances/custom_til'
+
+        OUTPUT_POSTFIX = 'instances'
+
+        class IndexedString < ::String
+          attr_accessor :index
+
+          def name
+            self
+          end
+        end
+
+        def add(name, type, options = {})
+          options = {
+            test_instance_class: platform::TestInstance
+          }.merge(options)
+          klass =
+          if type.is_a?(Symbol) || type.is_a?(String)
+            ins = options.delete(:test_instance_class).new(name, type, options)
+          else
+            ins = type
+          end
+          if @current_group
+            @current_group << ins
+          else
+            collection << ins
+          end
+          c = Origen.interface.consume_comments
+          Origen.interface.descriptions.add_for_test_definition(name, c)
+          ins
+        end
+
+        # IG-XL doesn't have a formal instance group type and instead declares them anonymously
+        # whenever test instances of the same name appear consecutively in the test instance sheet.
+        # However when it comes to generating a test program life becomes much easier if we have
+        # a way to explicitly declare instances as part of a group - this makes duplicate tracking
+        # and sorting of the test instance sheet much easier.
+        #
+        # Use this method to generate instance groups via a block. Within the block you should
+        # generate instances as normal and they will automatically be assigned to the current group.
+        # Note that the name of the instances generated within the group is discarded and replaced
+        # with the name of the group. Origen automatically appends "grp" to this name to highlight
+        # instances that were generated as part of the group.
+        #
+        #   test_instances.group("erase_all_blocks") do |group|
+        #     # Generate instances here as normal
+        #     test_instances.functional("erase_blk0")
+        #     test_instances.functional("erase_blk1")
+        #   end
+        #
+        # The group object is passed into the block but usually you should not need to interact
+        # with this directly except maybe to set the name if it is not yet established at the point
+        # where the group is initiated:
+        #
+        #   test_instances.group do |group|
+        #     # Generate instances here as normal
+        #     group.name = "group_blah"
+        #   end
+        #
+        # A common way to generate groups is to create a helper method in your application which
+        # is responsible for creating groups as required:
+        #
+        #   def group_wrapper(name, options)
+        #     if options[:by_block]
+        #       test_instances.group(name) do |group|
+        #         yield group
+        #       end
+        #     else
+        #       yield
+        #     end
+        #   end
+        #
+        # In that case the group argument becomes quite useful for branching based on whether you
+        # are generating a group or standalone instances:
+        #
+        #  group_wrapper(name, options) do |group|
+        #    if group
+        #      # Generate group instances
+        #    else
+        #      # Generate standalone instances
+        #    end
+        #  end
+        def group(name = nil, options = {})
+          name, options = nil, name if name.is_a?(Hash)
+          @current_group = platform::TestInstanceGroup.new(name, options)
+          collection << @current_group
+          yield @current_group
+          @current_group = nil
+        end
+        alias_method :add_group, :group
+
+        def finalize(options = {}) # :nodoc:
+          uniq!
+          sort_and_finalize!
+        end
+
+        def uniq! # :nodoc:
+          uniques = []
+          versions = {}
+          multi_version_tests = {}
+          collection.each do |instance|
+            # If a uniquely named instance is found add it, otherwise update the version
+            # of the current instance to match that of the existing instance that it duplicates
+            unless uniques.any? do |i|
+              if i == instance
+                instance.version = i.version
+                true
+              else
+                false
+              end
+            end
+              if instance.respond_to?(:version=)
+                versions[instance.unversioned_name] ||= 0
+                versions[instance.unversioned_name] += 1
+                if versions[instance.unversioned_name] > 1
+                  multi_version_tests[instance.unversioned_name] = true
+                end
+                instance.version = versions[instance.unversioned_name]
+              end
+              uniques << instance
+            end
+          end
+          # This final loop disables the version identifier for tests that have only a single version,
+          # this makes it clearer when multiple versions exist - whenever you see a v1 you know there
+          # is at least a v2 also.
+          collection.map! do |instance|
+            if instance.respond_to?(:version=)
+              unless multi_version_tests[instance.unversioned_name]
+                instance.append_version = false
+              end
+            end
+            instance
+          end
+          self.collection = uniques
+        end
+
+        def sort_and_finalize! # :nodoc:
+          # Present the instances in the final sheet in alphabetical order
+          collection.map!.with_index do |ins, i|
+            if ins.is_a?(String)   # Can happen if content has been rendered in from a template
+              ins = IndexedString.new(ins)
+            else
+              ins.finalize.call(ins) if ins.finalize
+            end
+            ins
+          end
+          collection.sort! { |a, b| [a.name.to_s] <=> [b.name.to_s] }
+        end
+
+        def bpmu(name, options = {})
+          add(name, :board_pmu, options)
+        end
+        alias_method :board_pmu, :bpmu
+
+        def powersupply(name, options = {})
+          add(name, :powersupply, options)
+        end
+        alias_method :power_supply, :powersupply
+
+        def ppmu(name, options = {})
+          add(name, :pin_pmu, options)
+        end
+        alias_method :pin_pmu, :ppmu
+
+        def functional(name, options = {})
+          add(name, :functional, options)
+        end
+
+        def empty(name, options = {})
+          add(name, :empty, options)
+        end
+
+        def other(name, options = {})
+          add(name, :other, options)
+        end
+
+        def apmu_powersupply(name, options = {})
+          add(name, :apmu_powersupply, options)
+        end
+
+        def mto_memory(name, options = {})
+          add(name, :mto_memory, options)
+        end
+
+        # Creates an accessor for custom test method libraries the first time they are called
+        def method_missing(method, *args, &block)
+          custom_tils = Origen.interface.send(:custom_tils)
+          if custom_tils[method]
+            ti = CustomTil.new(self, custom_tils[method])
+            instance_variable_set "@#{method}", ti
+            define_singleton_method method do
+              instance_variable_get("@#{method}")
+            end
+            send(method)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          !!Origen.interface.send(:custom_tils)[method] || super
+        end
+      end
+    end
+  end
+end