fit 1.1

data/lib/fit/row_fixture.rb

@@ -0,0 +1,188 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/column_fixture'
+require 'fit/parse'
+require 'fit/type_adapter'
+
+module Fit
+
+  class RowFixture < ColumnFixture
+
+    attr_accessor :results
+    attr_accessor :missing, :surplus
+
+    def initialize
+      super
+      @missing = []
+      @surplus = []
+    end
+
+    def do_rows rows
+      begin
+        bind rows.parts
+        @results = query
+        match list(rows.more), @results, 0
+        last = rows.last
+        last.more = build_rows @surplus
+        mark_parse last.more, 'surplus'
+        mark_list @missing, 'missing'
+      rescue Exception => e
+        exception rows.leaf, e
+      end
+    end
+
+    # Gets rows to be compared
+    def query; end
+
+    protected
+
+    def match expected, computed, column_index
+      if column_index >= @column_bindings.size
+        check_list expected, computed
+      elsif @column_bindings[column_index].nil?
+        match(expected, computed, column_index + 1)
+      else
+        e_map = e_sort(expected, column_index)
+        c_map = c_sort(computed, column_index)
+        keys = e_map.keys | c_map.keys
+        keys.each do |key|
+          e_list = e_map[key]
+          c_list = c_map[key]
+          if e_list.nil?
+            @surplus += c_list
+          elsif c_list.nil?
+            @missing += e_list
+          elsif e_list.size == 1 and c_list.size == 1
+            check_list e_list, c_list
+          else
+            match(e_list, c_list, column_index + 1)
+          end
+        end
+      end
+    end
+
+    def list rows
+      result = []
+      until rows.nil?
+        result << rows
+        rows = rows.more
+      end
+      result
+    end
+
+    def e_sort list, column_index
+      adapter = @column_bindings[column_index]
+      result = {}
+      list.each do |row|
+        cell = row.parts.at(column_index)
+        begin
+          key = adapter.parse(cell.text)
+          bin(result, key, row)
+        rescue Exception => e
+          exception cell, e
+          rest = cell.more
+          until rest.nil?
+            ignore rest
+            rest = rest.more
+          end
+        end
+      end
+      result
+    end
+
+    def c_sort list, column_index
+      adapter = @column_bindings[column_index]
+      result = {}
+      list.each do |row|
+        begin
+          adapter.target = row
+          key = adapter.get
+          bin(result, key, row)
+        rescue Exception => e
+          @surplus << row # surplus anything with bad keys, including nil
+        end
+      end
+      result
+    end
+
+    def bin map, key, row
+      if map.include? key
+        map[key] <<= row
+      else
+        map[key] = [row]
+      end
+    end
+
+    def check_list e_list, c_list
+      if e_list.empty?
+        @surplus += c_list
+        return
+      end
+      if c_list.empty?
+        @missing += e_list
+        return
+      end
+      row = e_list.shift
+      cell = row.parts
+      obj = c_list.shift
+      @column_bindings.each do |adapter|
+        adapter.target = obj unless adapter.nil?
+        check cell, adapter
+        cell = cell.more
+        break if cell.nil?
+      end
+      check_list e_list, c_list
+    end
+
+    def mark_parse rows, message
+      annotation = Fixture.label message
+      until rows.nil?
+        wrong rows.parts
+        rows.parts.add_to_body annotation
+        rows = rows.more
+      end
+    end
+
+    def mark_list rows, message
+      annotation = Fixture.label message
+      rows.each do |row|
+        wrong row.parts
+        row.parts.add_to_body annotation
+      end
+    end
+
+    def build_rows rows
+      root_parse = ParseHolder.create nil, nil, nil, nil
+      next_parse = root_parse
+      rows.each {|row| next_parse = next_parse.more = ParseHolder.create('tr', nil, build_cells(row), nil)}
+      root_parse.more
+    end
+
+    def build_cells row
+      if row.nil?
+        nihil = ParseHolder.create 'td', 'nil', nil, nil
+        nihil.add_to_tag('colspan="' + @column_bindings.size.to_s + '"')
+        return nihil
+      end
+      root_parse = ParseHolder.create nil, nil, nil, nil
+      next_parse = root_parse
+      @column_bindings.each do |adapter|
+        next_parse = next_parse.more = ParseHolder.create('td', '&nbsp;', nil, nil)
+        if adapter.nil?
+          ignore next_parse
+        else
+          begin
+            adapter.target = row
+            next_parse.body = Fixture.gray(Fixture.escape(adapter.to_s(adapter.get)))
+          rescue Exception => e
+            exception next_parse, e
+          end
+        end
+      end
+      root_parse.more
+    end
+
+  end
+
+end

data/lib/fit/scientific_double.rb

@@ -0,0 +1,70 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+module Fit
+
+  # Warning: not (yet) a general number usable in all calculations
+  class ScientificDouble
+
+    attr_accessor :precision
+    
+    def initialize value
+      @value = Float(value)
+      @precision = 0
+    end
+
+    def ScientificDouble.value_of s
+      if s.downcase.index('infinity')
+        new (1.0/0.0) # Infinity
+      else
+        result = new s.to_f
+        result.precision = precision s
+        result
+      end
+    end
+    
+    def ScientificDouble.precision s
+      value = s.to_f
+      bound = tweak(s.strip).to_f
+      (bound - value).abs
+    end
+
+    def ScientificDouble.tweak s
+      pos = s.downcase.index('e')
+      unless pos.nil?
+        return tweak(s[0..(pos - 1)]) + s[pos..-1]
+      end
+      unless s.index('.').nil?
+        return s + "5"
+      end
+      return s + ".5"
+    end
+
+    def == obj
+      sd = ScientificDouble.value_of obj.to_s
+      self.<=>(sd) == 0
+    end
+
+    def <=> obj
+      other = obj.to_f
+      diff = @value - other
+
+      # workaround the much more precise way of Ruby doing floats than Java
+      return 0 if @precision.zero? and diff.abs < 1.0e-5
+
+      precision = @precision > obj.precision ? @precision : obj.precision      
+      return -1 if diff < -precision
+      return 1 if diff > precision
+      return 0 if @value.nan? and other.nan?
+      return 1 if @value.nan?
+      return -1 if other.nan?
+      0
+    end
+
+    def nan?; @value.nan?; end # unused?
+    def to_f; @value; end
+    def to_s; @value.to_s; end
+
+  end
+
+end

data/lib/fit/summary.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+module Fit
+
+  class Summary < Fixture
+    @@counts_key = 'counts'
+
+    def do_table table
+      @summary[@@counts_key] = totals
+      table.parts.more = rows @summary.keys.sort
+    end
+
+    protected
+
+    def rows keys
+      return nil if keys.empty?
+      key = keys.shift
+      result = tr(td(key, td(summary[key].to_s, nil)), rows(keys))
+      mark(result) if key == @@counts_key
+      result
+    end
+
+    def tr parts, more
+      ParseHolder.create('tr', nil, parts, more)
+    end
+
+    def td body, more
+      ParseHolder.create('td', Fixture.gray(body), nil, more)
+    end
+
+    # Mark summary good or bad without counting
+    def mark row
+      official = @counts
+      @counts = Counts.new # use a fake results holder to avoid counting
+      cell = row.parts.more
+      if official.total_errors > 0
+        wrong cell
+      else
+        right cell
+      end
+      @counts = official
+    end
+  end
+
+end

data/lib/fit/timed_action_fixture.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/action_fixture'
+
+module Fit
+
+  class TimedActionFixture < ActionFixture
+    attr_accessor :format
+    def initialize
+      super
+      @format = '%H:%M:%S'
+    end
+    def do_table table
+      super
+      table.parts.parts.last.more = td('time')
+      table.parts.parts.last.more = td('split')
+    end
+    def do_cells cells
+      start = time
+      super
+      split = time - start
+      cells.last.more = td(start.strftime(@format))
+      cells.last.more = td(split < 1 ? '&nbsp;' : sprintf("%1.1f", split))
+    end
+    # Utility
+    def td body
+      ParseHolder.create('td', Fixture.gray(body), nil, nil)
+    end
+    def time
+      Time.now
+    end
+  end
+
+end

data/lib/fit/type_adapter.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/scientific_double'
+
+module Fit
+
+  class TypeAdapter
+
+    attr_accessor :target, :type, :fixture
+
+    def initialize target, name = '', is_output = false
+      @is_output = is_output
+      @target = @fixture = target
+      
+      @name=name
+      ends_in_qm = is_output && name=~/\?$/
+      if @name.index(/[A-Z]/)
+        @name = @name.split(/([A-Z][^A-Z]+)/).delete_if {|e| e.empty?}.collect {|e| e.downcase}.join('_')
+      end
+      @name = @name.gsub(/[^0-9a-zA-Z_]+$/,'').gsub(/[^0-9a-zA-Z_]+/,'_').gsub(/_+/,'_')
+      @name << '?' if ends_in_qm
+    end
+
+    # Factories
+
+    def TypeAdapter.for fixture, name, is_output=(name=~/(\(\))|(\?)$/)
+      GenericAdapter.new fixture, name, is_output
+    end
+
+    def TypeAdapter.on fixture, type
+      adapter = GenericAdapter.new fixture
+      adapter.type = type
+      adapter
+    end
+
+    def get
+      return nil if @name.nil?
+      getter = @name
+      getter.chop! if getter =~ /\?$/ && ! @target.respond_to?(getter.to_sym)
+      @target.send(getter)
+    end
+
+    def set value
+      raise 'Output fields cannot be set' if @is_output
+      @target.send("#{@name}=", value)
+    end
+
+    def is_output?
+      @is_output
+    end
+
+    def equals a, b
+      if ((a.kind_of? Float) and (b.kind_of? Numeric)) or ((a.kind_of? Numeric) and (b.kind_of? Float))
+        (a - b).abs < 1.0e-5 # use a delta to test equality between a float and a number
+      else
+        a == b
+      end
+    end
+
+    def to_s target
+      target.to_s
+    end
+
+  end
+
+  # A generic adapter uses the appartent type of its input to store
+  # appropriate values. For example, if a cell contains <td>1</td>,
+  # a Fixnum is generated; if a cell contains <td>0.5</td>, a Float
+  # is generated. Note that this process might not feasible for every
+  # type of primitive data.
+  class GenericAdapter < TypeAdapter
+    def parse value
+      return true if value.downcase == 'true'
+      return false if value.downcase == 'false'
+      unless @type.nil?
+        result = @fixture.parse value, @type
+        return result unless result.nil?
+      end
+      return Integer(value) if value =~ /^-?\d+$/
+      return Float(value) if (value =~ /^-?\d*\.\d*$/ || value =~ /^-?\d*\.\d*[e|E]\d+$/)
+      elements = value.split(',')
+      unless elements.size == 1
+        array = []
+        element_adapter = TypeAdapter.for @target, @name, @is_output
+        elements.each do |e|
+          array << element_adapter.parse(e.strip)
+        end
+        return array
+      end
+      return value
+    end
+  end
+
+end

data/lib/fit/wiki_runner.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/file_runner'
+
+$stderr.puts 'WikiRunner is deprecated: use FileRunner'
+
+if __FILE__ == $0
+  begin
+    Fit::FileRunner.new.run ARGV
+  rescue Exception => e
+    $stderr.puts e.message
+    exit -1
+  end
+end

data/lib/fittask.rb

@@ -0,0 +1,184 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'fit/file_runner'
+require 'fit/parse'
+
+module Rake
+
+  class FitReportRunner < Fit::FileRunner
+    def run args
+      process_args args
+      process
+    end
+  end
+  
+  class FitRunner < Fit::FileRunner
+    def run args
+      process_args args
+      process
+    end
+    def process_args args
+      input_name = File.expand_path args[0]
+      input_file = File.open input_name
+      @input = input_file.read
+      input_file.close
+      @output = OutputStream.new
+    end
+  end
+    
+  # A dummy output stream to avoid creating output files
+  class OutputStream < String
+    def print text; end
+    def close; end
+  end
+
+  # Create a task that runs a set of FIT tests.
+  #
+  # If rake is invoked with a ATEST command line option, then the list of
+  # test files will be overridden to include only the filename specified on
+  # the command line.  This provides an easy way to run just one test.
+  # The exact syntax of the ATEST option is as follows:
+  #    ATEST=/path/to/FileHtml:Right:Wrong:Ignores:Exceptions
+  # where you can include a path to the HTML file, which must be specified
+  # without the .html extension; and where Rights, Wrong, Ignores and
+  # Exceptions are the numbers of the expected results from the test run.
+  # Note that the report path will be the same as the test path.
+  #
+  class FitTask < TaskLib
+  
+    attr_accessor :name, :libs, :pattern, :fail_on_failed_test
+    
+    def test_suites=(list)
+      @test_suites = list
+    end
+    
+    def test_suites
+      if ENV['ATEST']
+        atest = ENV['ATEST'].split ':'
+        filename = atest[0]
+        test_name = File.basename(filename)
+        test = { :name => test_name,
+                 :right => atest[1].to_i, :wrong => atest[2].to_i,
+                 :ignores => atest[3].to_i, :exceptions => atest[4].to_i }
+        suite = AcceptanceTestSuite.new
+        suite << test
+        suite.test_path = suite.report_path = File.dirname(filename) + File::SEPARATOR
+        [suite]
+      else
+        @test_suites
+      end
+    end
+    
+    def initialize(name=:fittest)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @test_files = []
+      @test_suites = []
+      @fail_on_failed_test=false
+      @tests_failed=false
+      yield self if block_given?
+      define name
+    end
+    
+    def define task_name
+      # describe the fit task
+      desc "Run FIT acceptance tests"
+      task task_name
+      # silence footnote creation since we don't want HTML reports
+      task task_name do
+        Fit::Parse.send(:define_method, 'footnote', lambda {''})
+      end
+      # define a fit task for each test suite
+      test_suites.each do |suite|
+        task task_name do
+          @tests_failed = true unless suite.run_tests
+        end
+      end      
+
+      task task_name do 
+         raise 'Tests failed.' if @fail_on_failed_test && @tests_failed
+      end
+
+      # describe the fit_report task
+      desc "Run FIT acceptance tests with HTML reports"
+      task_report_name = (task_name.to_s + '_report').to_sym
+      task task_report_name
+      # define a fit_report task for each test suite
+      test_suites.each do |suite|
+        task task_report_name do
+          # set footnote path to an appropriate location
+          Fit::Parse.footnote_path = suite.report_path
+          # run tests
+          @tests_failed = true unless suite.run_tests_with_reports
+        end
+      end
+
+      task task_report_name do 
+         raise 'Tests failed.' if @fail_on_failed_test && @tests_failed
+      end
+
+      self
+    end
+    
+    def create_test_suite &block
+      suite = AcceptanceTestSuite.new
+      block.call suite
+      @test_suites << suite
+    end
+      
+    class AcceptanceTestSuite
+      attr_accessor :test_path, :report_path, :tests
+      def initialize
+        @tests = []
+        @test_path = @report_path = ''
+      end
+      def << test
+        @tests << test
+      end
+
+      def run_tests_with_reports; run_tests true; end;
+
+      def run_tests with_report=false 
+         all_passed = true
+         @tests.each do |test|
+            begin
+               runner_args = [@test_path + "#{test[:name]}.html"]
+               puts "Running #{test[:name]}.html"
+
+               if with_report 
+                  report_file=@report_path + "Report_#{test[:name]}.html" 
+                  puts "   (Writing report to #{report_file})"
+                  runner_args << report_file
+                  runner = Rake::FitReportRunner.new
+               else
+                  runner = Rake::FitRunner.new
+               end
+               
+               runner.run runner_args
+               result = runner.fixture.counts
+               verify test, result
+            rescue Exception => e
+               puts "   #{test[:name]} failed: #{e}"
+               all_passed = false
+            end
+         end
+         all_passed
+      end
+
+      def verify test, result
+         [:exceptions,:wrong].each { |symbol| test[symbol] = 0 if test[symbol].nil? }
+         [:right, :wrong, :ignores, :exceptions].each do |symbol|
+          count = result.method(symbol).call
+          expected = test[symbol]
+          unless expected.nil? || count == expected
+            raise Exception.new("#{expected} #{symbol} expected, found #{count} instead.")
+          end
+        end
+      end
+    end
+    
+  end
+
+end

data/test/all_tests.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'test/unit'
+
+require 'test/file_runner_test'
+require 'test/fit_server_test'
+require 'test/fixture_test'
+#require 'test/framework_test'
+require 'test/parse_test'
+require 'test/scientific_double_test'
+require 'test/type_adapter_test'
+require 'test/fixture_loader_test'

data/test/file_runner_test.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'test/unit'
+# Make the test run location independent
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fit/file_runner'
+
+module Fit
+  
+  class FileRunnerTest < Test::Unit::TestCase
+    def test_simple_html
+      simple_html = "<table>" +
+                    "  <tr><td>fit.Fixture</td></tr>" +
+                    "</table>"
+      do_html simple_html
+    end
+    def test_wiki_html
+      wiki_html = "<table><tr><td>extra formatting" +
+                  "  <wiki>" +
+                  "    <table>" +
+                  "      <tr><td>fit.Fixture</td></tr>" +
+                  "    </table>" +
+                  "  </wiki>" +
+                  "</td></tr></table>"
+      do_html wiki_html
+    end
+    def do_html text
+      runner = FileRunner.new
+      runner.fixture = TempFixture.new
+      runner.input = text
+      runner.output = OutputStream.new
+      runner.process
+
+      assert_equal 'fit.Fixture', $tempParse.leaf.text
+    end
+  end
+
+  # What's the Ruby  equivalent of Java anonymous classes?
+  class TempFixture < Fixture
+    def do_tables tables
+      $tempParse = tables
+    end
+  end 
+
+  # A dummy output stream
+  class OutputStream < String
+    def print text; end
+    def close; end
+  end
+
+end