uttk 0.3.1.2

data/lib/uttk/strategies/Configure.rb

@@ -0,0 +1,66 @@
+# 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/Configure.rb 22112 2006-02-22T08:30:11.236459Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I run then check whether the configure stage of a compilation process fail.
+    # I used in the _Package_ strategy to handle the configuration stage.
+    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 Uttk

data/lib/uttk/strategies/Error.rb

@@ -0,0 +1,23 @@
+# 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/Error.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    # A test class which always raise an error.
+    class Error < Strategy
+      include Concrete
+
+      def assertion
+        raise_error('Error always raises an error')
+      end
+
+    end # class Error
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Fail.rb

@@ -0,0 +1,26 @@
+# 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/Fail.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    # A test class which always fails.
+    class Fail < Strategy
+      include Concrete
+
+      protected
+      def assertion
+        fail 'Fail always fails', Weights::Default.new(@value)
+      end
+
+      attribute :value, 'the returned weight', [Weights::Weight, Numeric], 0
+
+    end # class Fail
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/IOBased.rb

@@ -0,0 +1,159 @@
+# 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/IOBased.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+module Uttk
+
+  module Strategies
+
+    class IOBased < Strategy
+      include Abstract
+
+
+      #
+      # Constructor
+      #
+
+      def initialize ( *a, &b )
+        stream :input
+        stream :output
+        stream :error
+        super
+      end
+
+
+      #
+      # Methods
+      #
+
+      def prologue
+        super
+        make_streams
+        unless @input.nil?
+          if @input.ref.is_a? Pathname
+            @input.my = @input.ref
+          else
+            @input.my.open('w') do |my|
+              my.print @input.ref.to_s_for_uttk_log
+            end
+          end
+        end
+      end
+      protected :prologue
+
+
+      def assertion
+        @streams.each do |stream|
+          next if invalid_stream?(stream)
+          fail("#{stream.name} is different") unless stream.compare_streams
+        end
+        pass
+      end
+      protected :assertion
+
+
+      def epilogue
+        @streams.each { |strm| strm.clean unless strm.nil? }
+        super
+      end
+      protected :epilogue
+
+
+      def pass_hook
+        super
+        print_streams() if @verbose_print
+      end
+      protected :pass_hook
+
+
+      def failed_hook
+        super
+        @streams.each do |stream|
+          next if invalid_stream?(stream)
+          @log["#{stream.name}_status"] = stream.status
+        end
+        print_streams() unless @quiet_print
+      end
+      protected :failed_hook
+
+
+      def print_streams
+        @streams.each do |stream|
+          next if invalid_stream?(stream)
+          @log << stream
+        end
+      end
+      private :print_streams
+
+
+      def invalid_stream? ( stream )
+        stream.nil? or stream.ref.nil? or
+        stream.my.nil? or stream.name == 'input' or
+        (stream.my.is_a? Pathname and !stream.my.exist?) or
+        (stream.ref.is_a? Pathname and !stream.ref.exist?)
+      end
+      private :invalid_stream?
+
+      def stream ( name )
+        @streams ||= []
+        @streams_name ||= []
+        @streams_name << name
+      end
+
+
+      def make_streams
+        @streams = @streams_name.map do |name|
+          stream = nil
+          if instance_variables.include? "@#{name}"
+            val = instance_variable_get("@#{name}")
+            if val.nil?
+              stream = @stream_class.new(name)
+            else
+              val = val.do_symtbl_gsub(@symtbl)
+              if val.is_a? String
+                tmp = TempPath.new
+                tmp.open('w') { |res| res.print val }
+                val = tmp.open('r')
+              end
+              stream = @stream_class.new(name, val)
+            end
+          end
+          instance_variable_set "@#{name}", stream
+          stream
+        end
+      end
+      protected :make_streams
+
+      #
+      # Accessors
+      #
+
+      def stream_class= ( aClass )
+        if aClass.is_a? Class
+          @stream_class = aClass
+        else
+          @stream_class = Streams.const_get(aClass)
+        end
+      end
+
+
+      #
+      # Attributes
+      #
+
+      attribute :input,   'the input reference',  :invisible, nil
+      attribute :output,  'the output reference', :invisible, nil
+      attribute :error,   'the error reference',  :invisible, nil
+
+      attribute :stream_class, 'the stream class (< Streams::Stream)',
+                               Class, Streams::Stream
+
+      attribute :verbose_print, 'print even if the test pass', false, :invisible
+      attribute :quiet_print,  'quiet even if the test fails', false, :invisible
+
+    end # class IOBased
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Import.rb

@@ -0,0 +1,60 @@
+# 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/Import.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Strategies
+
+    # I can import a strategy from on another file. Just tell me which file
+    # using my _import_ attribute and which loader to use using my _loader_
+    # attribute.
+    class Import < Proxy
+      include Concrete
+
+      def prologue
+        super
+        unless @import.exist?
+          raise ArgumentError, "the import file must exits (#@import)"
+        end
+        unless @loader.nil?
+          @save_loader = @symtbl[:loader]
+          @symtbl[:loader] = @loader
+        end
+        @old_pwd = @symtbl[:pwd]
+        create(@import) do |t|
+          t.symtbl[:loader] = @symtbl[:loader]
+        end
+      end
+      protected :prologue
+
+      def epilogue
+        @symtbl[:loader] = @save_loader unless @loader.nil?
+        @symtbl[:pwd] = @old_pwd
+        super
+      end
+      protected :epilogue
+
+      def import= ( aPath )
+        @import = aPath
+        @import = Pathname.new(aPath) unless aPath.is_a? Pathname
+      end
+
+      def loader= ( aLoader )
+        if aLoader.is_a? Loaders::Loader
+          @loader = aLoader
+        else
+          @loader = Loaders.const_get(aLoader).new
+        end
+      end
+
+      attribute :import, 'the file to import', :mandatory
+      attribute :loader, 'loader to use for the imported file'
+
+    end # class Import
+
+  end # module Strategies
+
+end # module Uttk

data/lib/uttk/strategies/Iterate.rb

@@ -0,0 +1,139 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /fey/uttk/trunk/lib/uttk/strategies/Iterate.rb 8813 2005-10-12T08:41:50.904292Z ertai  $
+
+
+module Uttk
+
+  module Strategies
+
+    # _Iterate_ is a generic iteration strategy which bring the full power of
+    # Ruby to your test description.
+    #
+    # The common use case is somthing like that:
+    #
+    # my test:
+    #   strategy: Iterate
+    #   over:     aStructureWichSupportTheMethodMyEach
+    #   with:     TheMethodMyEach # `uttk_each' by default
+    #   iter:     MyIterator
+    #   test:
+    #      my sub test <<MyIterator:i>>:
+    #          strategy: AnotherStrategy
+    #          argument: <<MyIterator>>
+    #
+    # In the real life you can use it like that:
+    #
+    # my test suite:
+    #    strategy: Iterator
+    #    over: !filelist **/(*).yml
+    #    iter: [path, basename]
+    #    test:
+    #       my sub test <<basename>>:
+    #          strategy: Import
+    #          input:    <<path>>
+    #
+    class Iterate < Collection
+      include Concrete
+      include Composite::Ordered
+
+      alias_method :make_new_symtbl, :new_symtbl
+      attr_reader  :new_symtbl, :iterators
+      protected    :new_symtbl, :iterators
+
+
+      #
+      # Methods
+      #
+
+      def prologue
+        super
+
+        if @test.is_a? Hash and @test.size == 1
+          name, @attributes = @test.to_a.first
+          @attributes[:name] = name
+          @test = {}
+        else
+          name = @test.name
+        end
+
+        iter1 = iterators.first
+        iteri = "#{iter1}:i"
+        iterstar = "*#{iter1}"
+        unless name.to_s =~ /<<.*>>/
+          raise ArgumentError,
+            "You cannot provide a static name like (#{name}) because when " +
+            'iterating with this name all your tests will have the same ' +
+            "name, to avoid this you can add <<#{iteri}>> to your name"
+        end
+
+
+        # Iterate over the object `@over' with the method `@with'.
+        turn = 0
+        @over.send(@with) do |*args|
+          symtbl = make_new_symtbl
+          symtbl[iteri] = turn
+          symtbl[iterstar] = args
+          args.each_with_index do |arg, i|
+            symtbl["#{iter1}:#{i}"] = arg
+            symtbl["#{iterators[i]}"] = arg if i < iterators.size
+          end
+          @new_symtbl = symtbl
+          create @test
+          turn += 1
+        end
+
+      end
+      protected :prologue
+
+
+      def iter= ( iter )
+        @iter = iter
+        iter = iter.to_s if iter.is_a? Symbol
+        @iterators = case iter
+          when Array      then iter.flatten
+          when /^\[.*\]$/ then eval iter
+          when /,/        then iter.split(/\s*,\s*/)
+          else [iter]
+        end
+        unless iterators.all? { |it| it.is_a? String }
+          raise ArgumentError, 'The iterator name or list of names ' +
+                               "must be strings not (#{iterators.inspect})"
+        end
+      end
+
+
+      #
+      # Attributes
+      #
+
+      attribute :over, 'iterate *over* this object',     :mandatory
+      attribute :with, 'iterate *with* this method',     :uttk_each
+      attribute :iter, 'iterator name or list of names', :mandatory
+      attribute :test, 'the test to run at each time',
+                       :mandatory, :invisible, :dont_expand
+
+    end # class Iterate
+
+  end # module Strategies
+
+end # module Uttk
+
+
+class Object
+
+  def uttk_each ( *a, &b )
+    each(*a, &b)
+  end
+
+end # class Object
+
+
+class Hash
+
+  def uttk_each ( *a, &b )
+    each(*a) { |k, v| b[k, v] }
+  end
+
+end # class Hash