uttk 0.3.1.2

data/lib/uttk/strategies/Collection.rb

@@ -0,0 +1,158 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/strategies/Collection.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I do the same job as the _Composite_ strategy, plus I provide the
+    # _attributes_ attribute which allow to share common attributes of the
+    # strategies I compose.
+    class Collection < Composite
+      include Abstract
+
+      attr_reader :internal_contents
+      protected   :internal_contents
+
+      def initialize ( *a, &b )
+        @attributes = OHash.new
+        @internal_contents = []
+        super
+      end
+
+
+      # Create a new test, using the current loader, and add it to the
+      # collection.
+      def create ( anObject=strategyclass, &block )
+        super do |t|
+          @log.debug{"assign collection attributes #{@attributes.size}"}
+          @attributes.each do |k,v|
+            @log.debug{"assign attribute: #{k}"}
+            next if k == :contents
+            t.assign_one(k, v, true)
+          end
+          if @attributes.has_key? :contents
+            t.assign_one(:contents, @attributes[:contents], true)
+          end
+          block[t] if block
+          @attributes.each do |k,v|
+            t.reject k if t.respond_to? k and t.send(k) == v
+          end
+        end
+      end
+
+
+      def prologue
+        super
+        # Create sub tests
+        if @internal_contents.is_a? Hash
+          unless @internal_contents.ordered?
+            raise ArgumentError, 'hash not ordered'
+          end
+          @internal_contents.each do |name, doc|
+            if doc.is_a? Hash
+              internal_create(doc, name)
+            else
+              create(doc)
+            end
+          end
+        elsif @internal_contents.is_a? Array
+          @internal_contents.each do |doc|
+            if doc.is_a? Hash
+              if doc.size == 1 and (tab = doc.to_a[0])[1].is_a? Hash
+                internal_create(tab[1], tab[0])
+              else
+                internal_create(doc)
+              end
+            elsif doc.is_a? String
+              internal_create(:name => doc)
+            else
+              create(doc)
+            end
+          end
+        else
+          raise_error 'bad contents type'
+        end
+        # Dump the attributes
+        attr = @attributes.dup.delete_if do |k,v|
+          v.nil? or v.respond_to?(:hidden) or k == :aliases
+        end
+        unless attr.empty?
+          @log.new_node :attributes do
+            attr.each { |k, v| @log[k] = v }
+          end
+        end
+      end
+      protected :prologue
+
+
+      def internal_create ( doc, name=nil )
+        doc[:name] ||= name unless name.nil?
+        doc[:strategy] ||= strategyclass
+        create(doc)
+      end
+      private :internal_create
+
+
+      def contents= ( other ) # :nodoc:
+        @internal_contents = other
+      end
+
+
+      def attributes(other=nil, &block)
+        if other.nil?
+          if block.nil?
+            @attributes
+          else
+            self.attributes = HashEval.new(&block).hash
+          end
+        else
+          self.attributes = other
+        end
+      end
+
+
+      def attributes=(other) # :nodoc:
+        other.each { |k,v| @attributes[k] = v }
+      end
+
+
+      def strategyclass= ( aClass )
+        @attributes[:strategy] = aClass
+      end
+
+
+      def strategyclass
+        @attributes[:strategy]
+      end
+
+
+      def testify_options
+        super.update(:strategy => strategyclass)
+      end
+      protected :testify_options
+
+
+      def method_missing(key, val=nil, *a) # :nodoc:
+        super unless a.empty?
+        key = key.to_s
+        if key =~ /^(.*)=$/
+          @attributes[$1] = val
+        else
+          @attributes[key]
+        end
+      end
+
+
+      attribute :attributes, 'the common part of the suite', :invisible do
+        OHash.new
+      end
+
+    end # class Collection
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Compile.rb

@@ -0,0 +1,59 @@
+# Author::    Marco Tessari  <marco.tessari@epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/strategies/Compile.rb 22112 2006-02-22T08:30:11.236459Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I'm not maintained that much since the _Package_ strategy do a better
+    # job than I. Can be useful if you have only few files to compile and do
+    # not have a Makefile.
+    class Compile < Proxy
+      include Concrete
+
+
+      def mk_command
+        # Build compiling command
+        command = ''
+        unless @source_dir.nil?
+          @source_dir = Pathname.new(@source_dir)
+          @source.map! { |file| @source_dir + file }
+        end
+        command << @compiler << ' ' << @flags
+        @include.each do |dir|
+          command << ' -I ' << dir
+        end
+        command << ' ' << @source.join(' ')
+        command << ' -o ' << @bin
+      end
+
+      def prologue
+        super
+        test = create(self, Cmd)
+        test.name = 'internal command'
+        test.exit = 0
+        test.fatal = true
+        test.command = mk_command
+
+        # Configure output
+        test.reject :exit
+        test.reject :fatal
+      end
+
+
+      attribute :source,  'source file for the compiler', :mandatory do [] end
+      attribute :bin,     'the binary output', :mandatory
+      attribute :include, 'include directories' do [] end
+      attribute :flags,   'compilation flags',
+                '-Wall -W -Werror -ansi -pedantic -O -fomit-frame-pointer'
+      attribute :compiler,   'the compiler command', 'gcc'
+      attribute :source_dir, 'the source directory, prefix all source file'
+
+    end # class Compile
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Composite.rb

@@ -0,0 +1,201 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/strategies/Composite.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I'm the super class of every strategy class that are composed by other
+    # strategies.
+    class Composite < Strategy
+      include Abstract
+
+      require 'uttk/strategies/Composite/contents_eval'
+
+      def initialize ( *a, &b )
+        @contents = []
+        @status_list = []
+        super
+      end
+
+
+      def initialize_copy ( aTest )
+        super
+        aTest.contents = @contents.dup
+      end
+
+
+      def initialize_test ( aTest )
+        aTest.wclass = @wclass
+      end
+
+
+      def create ( anObject, &block )
+        res = anObject.testify(new_symtbl.merge!(testify_options)) do |aTest|
+          initialize_test(aTest)
+          raise "nil symtbl" if aTest.symtbl.nil?
+          block[aTest] if block
+        end
+        @contents << res
+        res
+      end
+
+
+      def << ( anObject )
+        create(anObject)
+        self
+      end
+
+
+      def new_symtbl
+        @symtbl.new_child
+      end
+      protected :new_symtbl
+
+
+      def testify_options
+        {}
+      end
+      protected :testify_options
+
+
+      def contents(other=nil, &block)
+        if other.nil?
+          if block.nil?
+            internal_contents
+          else
+            self.contents = ContentsEval.new(&block).contents
+          end
+        else
+          self.contents = other
+        end
+      end
+
+
+      def internal_contents
+        @contents
+      end
+      protected :internal_contents
+
+
+      def run_impl
+        skip if @contents.empty?
+        run_composite()
+      end
+      protected :run_impl
+
+
+      def compute_final_weight
+        return if defined? @final_weight
+        @tmp_weight = @wclass.new(:START)
+        @status_list.each { |status| @tmp_weight += status.weight }
+        @final_weight = @tmp_weight.normalize(@weight)
+      end
+      private :compute_final_weight
+
+
+      def assertion
+        compute_final_weight
+        fail @final_weight, @fatal_failure if defined? @fatal_failure
+        skip if @tmp_weight.start?
+        pass if @final_weight.pass?
+        fail @final_weight
+      end
+      protected :assertion
+
+
+      def epilogue
+        compute_final_weight
+        super
+      end
+      protected :epilogue
+
+
+      # Do some tasks before a test of the composite is run.
+      def prologue_test ( test, log )
+      end
+      protected :prologue_test
+
+
+      # Do some tasks at the moment where a test of the composite is run.
+      def run_impl_test ( test, log )
+        test.run(log)
+      end
+      protected :run_impl_test
+
+
+      # Do some tasks after a test of the composite has been run.
+      def epilogue_test ( test, log )
+        st = test.status
+        if test.fatal and
+           not (st.pass? or (st.is_a? SkipStatus and st.weight.max?))
+          @fatal_failure = "Last test was fatal (#{test.name})"
+        end
+      end
+      protected :epilogue_test
+
+
+      def run_test ( test, log )
+        prologue_test(test, log)
+        @status_list << run_impl_test(test, log)
+        epilogue_test(test, log)
+      end
+      protected :run_test
+
+
+      def run_composite
+        @log.new_node :contents, :ordered => true do
+          @contents.each do |t|
+            if defined? @fatal_failure
+              st = FailStatus.new
+              st.weight *= t.weight
+              @status_list << st
+            else
+              run_test(t, @log)
+            end
+          end
+        end
+      end
+      protected :run_composite
+
+
+      def assign_at_last
+        :contents
+      end
+      protected :assign_at_last
+
+
+      attribute :contents, 'an array of tests', :invisible, :dont_expand do
+        []
+      end
+
+
+      module Ordered
+
+        def self.included ( aClass )
+
+          aClass.module_eval do
+
+            def new_symtbl
+              if @contents.empty?
+                @symtbl.new_child
+              else
+                @contents.last.symtbl.new_child
+              end
+            end
+            protected :new_symtbl
+
+          end
+
+        end
+
+      end # module Ordered
+
+    end # class Composite
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Composite/contents_eval.rb

@@ -0,0 +1,40 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /fey/uttk/trunk/lib/uttk/strategies/Composite/contents_eval.rb 8788 2005-09-27T14:23:19.686215Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    class Composite < Strategy
+
+      class ContentsEval
+
+        def initialize(contents=[], &block)
+          @contents = contents
+          if block
+            if block.arity == -1
+              instance_eval(&block)
+            else
+              block[self]
+            end
+          end
+        end
+
+        attr_reader :contents
+
+        def name(item_name, &block)
+          contents << { item_name.to_s => HashEval.new(&block).hash }
+        end
+
+      end # class ContentsEval
+
+    end # class Composite
+
+  end # module Strategies
+
+end # module Uttk
+
+