ttk 0.1.576

data/lib/ttk/strategies/Collection.rb

@@ -0,0 +1,131 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Collection.rb 572 2005-04-13 14:53:54Z ertai $
+
+
+module TTK
+
+  module Strategies
+
+    class Collection < Composite
+      include Abstract
+
+
+      def initialize ( *a, &b )
+        @attributes = OHash.new
+        super
+      end
+
+
+      # Create a new test, using the current loader,
+      # and add it to the collection.
+      def create ( anObject, &block )
+	super do |t|
+          @log.log_debug{"assign collection attributes #{@attributes.size}"}
+          @attributes.each do |k,v|
+            @log.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_given?
+          @attributes.each do |k,v|
+            t.reject k if t.respond_to? k and t.send(k) == v
+          end
+        end
+      end
+
+
+      def prologue
+	super
+        # 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
+
+
+      #FIXME: Collection should create the tests in its contents during its
+      #       prologue as every other Composite do.
+      def contents= ( other ) # :nodoc:
+        if other.is_a? Hash
+          raise ArgumentError, 'hash not ordered' unless other.ordered?
+          other.each do |name, doc|
+            if doc.is_a? Hash
+              internal_create(doc, name)
+            else
+              create(doc)
+            end
+          end
+        elsif other.is_a? Array
+          other.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 ArgumentError, 'bad contents type'
+        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 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 TTK

data/lib/ttk/strategies/Compile.rb

@@ -0,0 +1,56 @@
+# Author::    Marco Tessari  <marco.tessari@epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Compile.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    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 TTK

data/lib/ttk/strategies/Composite.rb

@@ -0,0 +1,173 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Composite.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    class Composite < Strategy
+      include Abstract
+
+
+      def initialize ( *a, &b )
+        @contents = []
+        @status_list = []
+        super
+      end
+
+
+      def initialize_test ( aTest )
+        aTest.wclass = @wclass
+        aTest.symtbl = new_symtbl
+      end
+
+
+      def create ( anObject, &block )
+        res = @symtbl[:loader].load(anObject) do |aTest|
+          initialize_test(aTest)
+          block[aTest] if block_given?
+        end
+        @contents << res
+        res
+      end
+
+
+      def << ( anObject )
+        create(anObject)
+        self
+      end
+
+
+      def new_symtbl
+        @symtbl.class.new(@symtbl)
+      end
+
+
+      def prologue
+        begin
+          super
+        ensure
+          @composite_saved_path_size = @log.path_size
+        end
+        # @contents.map! do |t|
+          # t.testify
+        # end
+      end
+      protected :prologue
+
+
+      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
+        (@log.path_size - @composite_saved_path_size).times { @log.up }
+        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 )
+        if test.fatal and not test.status.pass?
+          @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, :seq do
+          @contents.each do |t|
+            run_test(t, @log)
+            break if defined? @fatal_failure
+          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.class.new(@symtbl)
+              else
+                @symtbl.class.new(@contents.last.symtbl)
+              end
+            end
+            protected :new_symtbl
+
+          end
+
+        end
+
+      end # module Ordered
+
+    end # class Composite
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/Configure.rb

@@ -0,0 +1,64 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Configure.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    class Configure < Proxy
+      include Concrete
+
+      CONFIGURE = /^configure(\.sh)?$/
+      CONFIGURE_INPUT = /^configure\.(ac|in)$/
+
+      def mk_command ( script )
+        cmd = script.to_s
+        cmd += " --prefix=#@prefix" if @prefix
+        if @flags.is_a? Array
+          @flags = @flags.join(' ')
+        else
+          @flags = @flags.to_s
+        end
+        symtbl_configure_flags = @symtbl[:configure_flags]
+        @flags += ' ' + symtbl_configure_flags unless symtbl_configure_flags.nil?
+        @symtbl[:configure_flags] = @flags
+        cmd + ' ' + @flags
+      end
+
+      def prologue 
+        super
+	@dir = Pathname.new(@dir)
+	if script = self.class.have_configure?(@dir)
+	  create(Cmd) do |test|
+            test.name = 'command'
+            test.exit = 0
+            test.dir = @dir
+            test.command = mk_command(script)
+            test.verbose_print = true
+            test.reject :strategy, :dir
+          end
+	end
+      end
+
+      def self.have_configure_input? ( dir=Pathname.new('.') )
+        res = dir.entries.find { |ent| ent.to_s =~ CONFIGURE_INPUT }
+        (res.nil?) ? nil : dir + res
+      end
+
+      def self.have_configure? ( dir=Pathname.new('.') )
+        res = dir.entries.find { |ent| ent.to_s =~ CONFIGURE }
+        (res.nil?) ? nil : dir + res
+      end
+
+      attribute :dir,    'configure directory', :mandatory
+      attribute :prefix, 'the prefix directory for --prefix'
+      attribute :flags,  'set flags for the configure script'
+
+    end # class Configure
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/DistDelegate.rb

@@ -0,0 +1,45 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: DistDelegate.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    class DistDelegate < DistStrategy
+      include Concrete
+
+      protected
+      def prologue
+        super
+        if @symtbl[:tester].nil?
+          raise(ArgumentError, 'not run within a tester')
+        end
+        sub_testers = @symtbl[:tester].sub_testers
+        if sub_testers.nil? or sub_testers.empty? #FIXME: use the logger sugar
+          @log.log(Logger::Severity::WARN){'no sub testers available'}
+        end
+        @remains_sub_testers = []
+        sub_testers.each do |uri, sub_tester|
+          create(@test)
+          @remains_sub_testers << sub_tester
+        end
+      end
+
+      protected
+      def prologue_test(test, log)
+        super
+        @tester = @remains_sub_testers.shift
+      end
+
+      attribute :test, 'Test delegated to direct sub testers',
+                       :mandatory, :invisible, :dont_expand
+
+    end # class DistDelegate
+
+  end # module Strategies
+
+end # module TTK
+