ttk 0.1.576

data/lib/ttk/strategies/Glob.rb

@@ -0,0 +1,48 @@
+# Author::    Marco Tessari  <marco.tessari@epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Glob.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    # The Glob strategy collects a set of files using a globing expression,
+    # bundles them in a Composite strategy and finally run them sequentially.
+    class Glob < Composite
+      include Concrete
+
+      def prologue
+        super
+        Dir[@glob].each do |file|
+	  create(@test) do |t|
+            # Symtbl must be filled before the test attributes initialization
+            if file =~ @regexp
+              t.symtbl[:match] = $1
+            else
+              raise ArgumentError,
+                    "Path name (#{file}) doesn't match the regexp (#@regexp)"
+            end
+            t.symtbl[:path] = file
+          end
+        end
+      end
+
+
+      def regexp= ( aRegexp )
+        @regexp = aRegexp
+	@regexp = Regexp.new(aRegexp) unless aRegexp.is_a? Regexp
+      end
+
+      attribute :glob,   'a globing pattern',             :mandatory
+      attribute :regexp, 'a regular expression to extract a part of the ' +
+                         'path (ex: the tarball author)', :mandatory
+      attribute :test,   'the test to run on each file',
+                         :mandatory, :invisible, :dont_expand
+
+    end # class Glob
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/IOBased.rb

@@ -0,0 +1,156 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: IOBased.rb 572 2005-04-13 14:53:54Z ertai $
+
+
+module TTK
+
+  module Strategies
+
+    class IOBased < Strategy
+      include Abstract
+
+      #
+      # Internal classes
+      #
+
+      autoload(:Streams, 'ttk/strategies/Streams/Stream')
+
+
+      #
+      # Constructor
+      #
+
+      def initialize ( *a, &b )
+	stream :input
+	stream :output
+        stream :error
+        super
+      end
+
+
+      #
+      # Methods
+      #
+
+      def prologue
+        super
+        make_streams
+        @input.my = nil unless @input.nil?
+      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)
+          stream.to_ttk_log(@log)
+        end
+      end
+      private :print_streams
+
+
+      def invalid_stream? ( stream )
+        stream.nil? or stream.ref.nil? or
+        stream.my.nil? or stream.name == :input
+      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 TTK

data/lib/ttk/strategies/Import.rb

@@ -0,0 +1,45 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Import.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    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
+        create(@import) do |t|
+          t.symtbl[:loader] = @symtbl[:loader]
+        end
+        @symtbl[:loader] = save_loader unless @loader.nil?
+      end
+
+      def import= ( aPath )
+        @import = aPath
+        @import = Pathname.new(aPath) unless aPath.is_a? Pathname
+      end
+
+      def loader= ( aLoader )
+        @loader = Loaders.const_get(aLoader).new
+      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 TTK

data/lib/ttk/strategies/JUnit.rb

@@ -0,0 +1,205 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: JUnit.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+#FIXME: adapt me
+#FIXME: remove $debug
+
+module TTK
+
+  module Strategies
+
+    # I'm not currently usable, I will be fixed soon.
+    class JUnit < Strategy
+      include Concrete
+
+      def initialize ( *a, &b )
+        super
+        @failure = true
+        @output = ""
+        @result = { }
+      end
+
+      def parse_outcome(line)
+        case line
+        when /^OK \((\d+) test(s|)\)$/
+          @result['total tests'] = $1.to_i
+          @failure = false
+        when /^FAILURES!!!$/
+          line = next_line
+          if line =~ /^Tests run: (\d+),  Failures: (\d+),  Errors: (\d+)$/ then
+            @result['total tests'] = $1.to_i
+            @result['total failures'] = $2.to_i
+            @result['total errors' ] = $3.to_i
+          end
+        else
+         @result['outcome'] = "not found" if $debug >= 1
+        end
+        next_line
+      end
+      protected :parse_outcome
+
+      def parse_location(test_name, line)
+        location = []
+        i = 0
+        while line =~ /^\t(at.+\))$/
+          location[i] = $1
+          i += 1
+          line = next_line
+        end
+        if location.length != 0 then
+          @result[test_name].update({ 'location' => location })
+        else
+          @result[test_name].update({ 'location' => 'not found' }) if $debug >= 1
+        end
+        line
+      end
+      protected :parse_location
+
+      def parse_failures(line)
+        if line =~ /^There (was|were) \d+ failure(s|):$/ then
+          line = next_line
+          while line =~ /(\d)+\) (\w+)\(([\w.]+)\)junit.framework.(\w+): expected:<(.*)> but was:<(.*)>$/
+            @result["failure #$1"] = {'name' => $3 + "." + $2,
+                                     'reason' => $4,
+                                      'expected' => $5,
+                                      'was' => $6 }
+            line = parse_location("failure #$1", next_line)
+          end
+        else
+          @result['failures'] = "not found" if $debug >= 1
+        end
+        line
+      end
+      protected :parse_failures
+
+      def parse_errors(line)
+        if line =~ /^There (was|were) \d+ error(s|):$/ then
+          line = next_line
+          while line =~ /(\d)+\) (\w+)\(([\w.]+)\)([.\w]+)$/
+            @result["error #$1"] = {'name' => $3 + "." + $2,
+                                        'reason' => $4 }
+            line = parse_location("error #$1", next_line)
+          end
+        else
+          @result['errors'] = "not found" if $debug >= 1
+        end
+        line
+      end
+      protected :parse_errors
+
+      def parse_time(line)
+        if line =~ /^Time: ([\d.]+)$/ then
+          @result['time'] = $1.to_f
+        else
+          @result['time'] = "not found" if $debug >= 1
+        end
+        next_line
+      end
+      protected :parse_time
+
+      def assert_line(line, re)
+        if not line =~ re
+          raise(Failure, "cannot recognized JUnit output '#{line}'.")
+        end
+        next_line
+      end
+      protected :assert_line
+
+      def parse_output(line)
+        line = assert_line(line, /^[.FE]*$/)
+        line = parse_time(line)
+        line = parse_errors(line)
+        line = parse_failures(line)
+        line = assert_line(line, /^$/)
+        line = parse_outcome(line)
+        line = assert_line(line, /^$/)
+      end
+      protected :parse_output
+
+      def next_line
+        line = @output.gets
+        line.chomp unless line.nil?
+      end
+      protected :next_line
+
+      def check_workdir
+        if not File.exist?(@workdir) then
+          raise Failure, "the work dir '#{workdir}' doesn't exist."
+        elsif not File.directory?(@workdir) then
+          raise Failure, "the work dir '#{workdir}' is not a directory."
+        elsif not File.readable?(@workdir) then
+          raise Failure, "the work dir '#{workdir}' isn unreadable."
+        end
+      end
+      protected :check_workdir
+
+      def check_testclasses_validity
+        @testclasses.gsub!(/\.class(\s+|$)/, ' ')
+        @testclasses.chomp!(' ')
+        testclasses_tbl = @testclasses.split(/\s+/)
+        if testclasses_tbl.length == 0 then
+          raise Failure, "no testclass are specified."
+        end
+        testclasses_tbl.each do |x|
+          filename = @workdir + "/" + x.gsub(/\./, '/') + ".class"
+          if not File.exist?(filename) then
+            raise Failure, "the testclass '#{filename}' doesn't exist."
+          elsif not File.file?(filename) then
+            raise Failure, "the testclass '#{filename}' is not a regular file."
+          elsif not File.readable?(filename) then
+            raise Failure, "the testclass '#{filename}' is unreadable."
+          end
+        end
+      end
+      protected :check_testclasses_validity
+
+      def prologue
+        super
+        check_workdir
+        check_testclasses_validity
+        @old_classpath = ENV['CLASSPATH'];
+        ENV['CLASSPATH'] = "" if ENV['CLASSPATH'].nil?
+        ENV['CLASSPATH'] += ':/usr/share/java/junit.jar:.'
+        @old_workdir = Dir.pwd
+        Dir.chdir(@workdir)
+        @log['real working dir is'] = Dir.pwd if $debug >= 1
+      end
+      protected :prologue
+
+      def run_impl
+        @output = IO.popen("java junit.textui.TestRunner #@testclasses")
+        parse_output(next_line)
+        @output.close
+      end
+      protected :run_impl
+
+      def assertion
+        @failure ? fail : pass
+      end
+      protected :assertion
+
+      def epilogue
+        ENV['CLASSPATH'] = @old_classpath
+        Dir.chdir(@old_workdir)
+        print_result
+        super
+      end
+      protected :epilogue
+
+      def print_result
+        @result.sort.each { |k,v| @log[k] = v }
+      end
+      protected :print_result
+
+      attribute :testclasses, 'the name of the JUnit classes to test', "", :mandatory
+      attribute :workdir, 'the working directory where java is runned', '.'
+      attribute :options, 'extra options to pass to java', ''
+
+    end # class JUnit
+
+  end # module Strategies
+
+end # module TTK