uttk 0.3.1.2

data/lib/uttk/strategies/PackageCollection.rb

@@ -0,0 +1,78 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /fey/uttk/trunk/lib/uttk/strategies/PackageCollection.rb 8789 2005-09-27T14:49:49.088376Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    # This strategy takes a set of packages with their dependencies, it
+    # computes the topological sort, and make all packages in the right order.
+    #
+    # * Dependencies are given as a Yaml file.
+    # * Installation directories are propagated by with configure options.
+    class PackageCollection < Composite
+      include Concrete
+
+      def prologue
+        super
+        @dependencies = Pathname.new(@dependencies)
+        @deps = YAML::load(@dependencies.read)
+        @order = @deps.tsort_from(@target)
+        @order.each do |dep|
+          @symtbl["#{dep}_install_dir".to_sym] = "<<pwd>>/#{dep}"
+          create(Import) do |t|
+            t.name = dep
+            t.import = "#{dep}.yml"
+            t.symtbl[:configure_flags] =
+              @deps[dep].map { |d| "--with-#{d}=<<pwd>>/#{d}" }.join(' ')
+            t.fatal = true
+          end
+        end
+      end
+      protected :prologue
+
+      attribute :dependencies, 'the dependency file', :mandatory
+      attribute :target,       'the target package name'
+
+    end # class PackageCollection
+
+  end # module Strategies
+
+end # module Uttk
+
+
+
+require 'tsort'
+
+class Hash
+
+  include TSort
+
+  alias tsort_each_node each_key
+
+  def tsort_each_child(node, &block)
+    fetch(node).each(&block)
+  end
+
+  def tsort_each_from ( node=nil, &block )
+    return tsort_each(&block) if node.nil?
+    each_strongly_connected_component_from(node) do |component|
+      if component.size == 1
+        block[component.first]
+      else
+        raise Cyclic, "topological sort failed: #{component.inspect}"
+      end
+    end
+  end
+
+  def tsort_from ( node=nil )
+    return tsort if node.nil?
+    result = []
+    tsort_each_from(node) { |n| result << n }
+    result
+  end
+
+end # class Hash

data/lib/uttk/strategies/Pass.rb

@@ -0,0 +1,24 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /fey/uttk/trunk/lib/uttk/strategies/Pass.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    # A test strategy class which always pass.
+    class Pass < Strategy
+      include Concrete
+
+      protected
+      def assertion
+        pass
+      end
+
+    end # class Pass
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Pool.rb

@@ -0,0 +1,104 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/strategies/Pool.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I'm a collection of strategies and I run all of them in a separated
+    # thread.
+    class Pool < Collection
+      include Concrete
+
+      class PoolComponent
+        attr_accessor :test, :thread, :flow, :log
+      end
+
+
+      def initialize ( *a, &b )
+        @pool_contents = []
+        super
+      end
+
+
+      def abort_hook
+        return if defined? @already_aborted
+        @already_aborted = true
+        @pool_contents.each do |comp|
+          test = comp.test
+          next if test.status.is_a? StartStatus
+          test.abort('pool aborted') if test.running?
+        end
+        super
+      end
+      protected :abort_hook
+
+
+      def prologue
+        super
+        @pool_upper = @log.new_node :contents, :ordered => true
+        path = @log.path
+        @pool_contents = @contents.map do |test|
+          comp = PoolComponent.new
+          comp.test = test
+          comp.log = Filters::Saver.new
+          comp.flow = @symtbl[:flow_factory].new_flow
+          test.symtbl[:flow] = comp.flow
+          comp.thread = Thread.new do
+            begin
+              sleep
+              new_log = Logger.new(comp.log)
+              new_log.chpath(path)
+              run_test(test, new_log)
+            rescue Exception => ex
+              display_unexpected_exc ex
+            end
+          end
+          comp
+        end
+
+        # This thread is here to catch properly exceptions.
+        @real_parent_thread = @thread
+        @thread = Thread.new do
+          begin
+            sleep
+          rescue Exception => ex
+            abort_hook()
+            @real_parent_thread.raise ex
+          end
+        end
+      end
+      protected :prologue
+
+
+      def run_composite
+        @pool_contents.each { |comp| comp.thread.wakeup }
+        @pool_contents.each { |comp| comp.thread.join }
+      end
+      protected :run_composite
+
+
+      def epilogue
+        @pool_contents.each do |comp|
+          comp.flow << :not_running?
+          @log << comp.log
+        end
+        @pool_upper.up
+        @pool_contents.each do |comp|
+          comp.thread.kill if comp.thread.alive?
+          comp.flow.destroy
+        end
+        @pool_contents.clear
+        super
+      end
+      protected :epilogue
+
+    end # class Pool
+
+  end # module Strategies
+
+end # module Uttk
+

data/lib/uttk/strategies/ProbabilityThreshold.rb

@@ -0,0 +1,46 @@
+# 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/ProbabilityThreshold.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I validate the status of the strategy _test_ if it is under the value of
+    # my _threshold_ attribute.
+    class ProbabilityThreshold < Proxy
+      include Concrete
+
+      def prologue
+        super
+        if @threshold > 1
+          raise ArgumentError, "Threshold too high: #@threshold not in [0..1]"
+        elsif @threshold < 0
+          raise ArgumentError, "Threshold too low: #@threshold not in [0..1]"
+        end
+        create(@test)
+      end
+      protected :prologue
+
+
+      def assertion
+        compute_final_weight
+        final = @final_weight.get
+        @log.final_weight = final
+        fail("Not enough (#{final} < #@threshold)") if @final_weight < @threshold
+        pass
+      end
+      protected :assertion
+
+
+      attribute :test,      'the strategy',              :mandatory, :invisble
+      attribute :threshold, 'the probability threshold', :mandatory, nil
+                                                         Weights::Weight
+
+    end # class ProbabilityThreshold
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Proxy.rb

@@ -0,0 +1,42 @@
+# 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/Proxy.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I'm composed by only one strategy and I'm transparent in the log.
+    class Proxy < Composite
+      include Abstract
+
+
+      def create ( anObject, &block )
+        unless @contents.empty?
+          raise ArgumentError, "A proxy can contain only one test"
+        end
+        super
+      end
+
+
+      def run_composite
+        test = @contents.first
+        test.name ||= 'test'
+        run_test(test, @log)
+      end
+      protected :run_composite
+
+
+      def new_symtbl
+        @symtbl
+      end
+      protected :new_symtbl
+
+
+    end # class Proxy
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/RMatch.rb

@@ -0,0 +1,92 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/strategies/RMatch.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I can be used with to test a test strategy. I will be merged soon with
+    # the _Test_ strategy.
+    class RMatch < Proxy
+      include Concrete
+
+      #
+      # Methods
+      #
+
+      def prologue
+        super
+        @errors_must_match = @match.dup
+        @errors_must_not_match = []
+
+        prefix = @log.path.to_regex_path_string
+        @log.debug { @log.prefix = prefix ; nil }
+
+        c = Class.new(Filters::RPathFilter)
+        c.include Concrete
+
+        @match.each do |rpath|
+          c.match prefix + rpath do |filter, path|
+            @errors_must_match.delete rpath
+            c.disable_matcher()
+          end
+        end
+
+        @dont_match.each do |rpath|
+          c.match prefix + rpath do |filter, path|
+            @errors_must_not_match << rpath
+            c.disable_matcher()
+          end
+        end
+
+        @c_filter = c.new
+        @log.add_observer(@c_filter)
+        create @test
+      end
+      protected :prologue
+
+
+      def assertion
+        if @errors_must_match.empty? and @errors_must_not_match.empty?
+          pass
+        else
+          unless @errors_must_match.empty?
+            @log.some_wanted_paths_are_missing = @errors_must_match
+          end
+          unless @errors_must_not_match.empty?
+            @log.some_unwanted_paths_are_present = @errors_must_not_match
+          end
+          fail
+        end
+      end
+      protected :assertion
+
+
+      def epilogue
+        @log.delete_observer @c_filter
+        super
+      end
+      protected :epilogue
+
+
+      #
+      # Attributes
+      #
+
+      attribute :match,      'a list of regexp paths which must matched with ' +
+                             'the test output', Array, []
+
+      attribute :dont_match, 'a list of regexp paths which must NOT matched with ' +
+                             'the test output', Array, []
+
+      attribute :test,       'the test to run at each time',
+                             :mandatory, :invisible, :dont_expand
+
+    end # class RMatch
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/RUnit.rb

@@ -0,0 +1,132 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/strategies/RUnit.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+require 'yaml'
+
+module Uttk
+
+  module Strategies
+
+    #
+    # = Description
+    #
+    # This strategy is wrapper around a Ruby unit test suite based on the
+    # test/unit library. Using RUnit you avoid the Ruby `require' problem
+    # and you use all the power of the Uttk's Suite and/or Pool.
+    #
+    # = How it works ?
+    #
+    # RUnit works by invoking Ruby on the specified file and then by parsing
+    # the output in order to inject it into the Uttk's log stream. To do that,
+    # you must use a specific TestRunner based on YAML. This TestRunner
+    # produces a YAML output readable by a human and the strategy.
+    #
+    # = Examples
+    #
+    # You need to first write your unit test suite using the test/unit package
+    # and the YAML TestRunner. Then, you write a few line in the input Uttk
+    # file to incorporate the unit test in the Uttk's suite.
+    #
+    # == The unit test suite file: foo_test.rb
+    #
+    #   require 'foo'
+    #
+    #   class FooTest < Test::Unit::TestCase
+    #
+    #     def test_1
+    #       assert(true)
+    #     end
+    #
+    #   end
+    #
+    # == The YAML input file for Uttk
+    #
+    #   ---
+    #   RUnit example test:
+    #     strategy: RUnit
+    #     input: !path my_unit_directory/foo_test.rb
+    #
+    # == One suite for all your unit test suite
+    #
+    # If you find cumbersome to write for every unit test files a single RUnit
+    # strategy into the YAML input file of Uttk, there is another way that is
+    # used in test/unit-suite.yml.
+    #
+    class RUnit < CmdBase
+      include Concrete
+
+      protected
+      def prologue
+        @command = '<<ruby>> -- <<uttk-unit>> '
+        if @verbose
+          @command += '--verbose '
+        else
+          @command += '--no-verbose '
+        end
+        @load_path.each { |x| @command += "-I #{x} " }
+        @requires = [@requires] unless @requires.respond_to? :each
+        @requires.each { |x| @command += "-r #{x} " }
+        unless @uttk_unit_options.empty?
+          opts = @uttk_unit_options
+          opts = [opts] unless opts.respond_to? :each
+          opts.each { |x| @command += "#{x} " }
+        end
+        @command += '-- %i -- --runner yaml -- %a'
+        @quiet_print = true
+        super
+      end
+
+      protected
+      def assertion
+        result = nil
+        if @error.my.zero?  #FIXME: Shouldn't need to use my here !!
+          if @output.my.zero?
+            skip('No result has been collected probably because no test ' +
+                 'suite has been run')
+          else
+            result = YAML.load(@output.my.read)
+            r = OpenStruct.new(result)
+            @log[:result] = result
+            if r.tests_number == 0
+              skip PassStatus.new.weight, 'No test suite in this file'
+            end
+            if r.failures_number != 0 or r.errors_number != 0
+              rpath = '/^failures$/^default_test/No tests were specified'
+              if r.failures_number == 1 and result.rpath_find :first, rpath
+                skip 'No tests were specified'
+              elsif r.failures_number.zero?
+                fail 'There are errors'
+              elsif r.errors_number.zero?
+                fail 'There are failures'
+              else
+                fail 'There are failures and errors'
+              end
+            end
+            pass
+          end
+        else
+          @error.my.open { |io| result = io.read }
+          raise "Some error occures while running the unit test:\n" + result
+        end
+      end
+
+      attribute :load_path, 'directories to add to the $LOAD_PATH variable',
+                            :invisible do [] end
+      attribute :requires,  'features to require before load the input',
+                            [Array, String, Pathname] do [] end
+      attribute :uttk_unit_options,  'options for uttk-unit',
+                            [Array, String] do [] end
+      attribute :verbose,   'turn on/off the ruby verbose mode',
+                            false, :invisible
+
+    end # class RUnit
+
+  end # module Strategies
+
+end # module Uttk
+
+
+