test-unit-ext 0.1.0

data/lib/test-unit-ext/priority.rb

@@ -0,0 +1,186 @@
+require "test/unit"
+
+require "fileutils"
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        def inherited(sub)
+          super
+          sub.instance_variable_set("@priority_initialized", true)
+          sub.instance_variable_set("@priority_table", {})
+          sub.priority :normal
+        end
+
+        def include(*args)
+          args.reverse_each do |mod|
+            super(mod)
+            next unless defined?(@priority_initialized)
+            mod.instance_methods(false).each do |name|
+              set_priority(name)
+            end
+          end
+        end
+
+        alias_method :method_added_without_priority, :method_added
+        def method_added(name)
+          method_added_without_priority(name)
+          set_priority(name) if defined?(@priority_initialized)
+        end
+
+        def priority(name, *tests)
+          singleton_class = (class << self; self; end)
+          priority_check_method = priority_check_method_name(name)
+          unless singleton_class.private_method_defined?(priority_check_method)
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          if tests.empty?
+            @current_priority = name
+          else
+            tests.each do |test|
+              set_priority(test, name)
+            end
+          end
+        end
+
+        def need_to_run?(test_name)
+          normalized_test_name = normalize_test_name(test_name)
+          priority = @priority_table[normalized_test_name]
+          return true unless priority
+          __send__(priority_check_method_name(priority), test_name)
+        end
+
+        private
+        def priority_check_method_name(priority_name)
+          "run_priority_#{priority_name}?"
+        end
+
+        def normalize_test_name(test_name)
+          "test_#{test_name.to_s.sub(/^test_/, '')}"
+        end
+
+        def set_priority(name, priority=@current_priority)
+          @priority_table[normalize_test_name(name)] = priority
+        end
+
+        def run_priority_must?(test_name)
+          true
+        end
+
+        def run_priority_important?(test_name)
+          rand > 0.1
+        end
+
+        def run_priority_high?(test_name)
+          rand > 0.3
+        end
+
+        def run_priority_normal?(test_name)
+          rand > 0.5
+        end
+
+        def run_priority_low?(test_name)
+          rand > 0.75
+        end
+
+        def run_priority_never?(test_name)
+          false
+        end
+      end
+
+      def need_to_run?
+        !previous_test_success? or self.class.need_to_run?(@method_name)
+      end
+
+      alias_method :run_without_priority, :run
+      def run(result, &block)
+        run_without_priority(result, &block)
+      ensure
+        if passed?
+          FileUtils.touch(passed_file)
+        else
+          FileUtils.rm_f(passed_file)
+        end
+      end
+
+      private
+      def previous_test_success?
+        File.exist?(passed_file)
+      end
+
+      def result_dir
+        components = [".test-result", self.class.name, @method_name.to_s]
+        dir = File.join(File.dirname($0), *components)
+        dir = File.expand_path(dir)
+        begin
+          FileUtils.mkdir_p(dir)
+        rescue Errno::EACCES
+          retry_dir = File.join(File.dirname(__FILE__), "..", *components)
+          retry_dir = File.expand_path(retry_dir)
+          raise if retry_dir == dir
+          dir = retry_dir
+          retry
+        end
+        dir
+      end
+
+      def passed_file
+        File.join(result_dir, "passed")
+      end
+
+      def escaped_method_name
+        @method_name.to_s.gsub(/[!?]$/) do |matched|
+          case matched
+          when "!"
+            ".destructive"
+          when "?"
+            ".predicate"
+          end
+        end
+      end
+    end
+
+    class TestSuite
+      @@priority_mode = false
+
+      class << self
+        def priority_mode=(bool)
+          @@priority_mode = bool
+        end
+      end
+
+      alias_method :original_run, :run
+      def run(*args, &block)
+        priority_mode = @@priority_mode
+        if priority_mode
+          @original_tests = @tests
+          apply_priority
+        end
+        original_run(*args, &block)
+      ensure
+        @tests = @original_tests if priority_mode
+      end
+
+      def apply_priority
+        @tests = @tests.reject {|test| !test.need_to_run?}
+      end
+
+      def need_to_run?
+        apply_priority
+        !@tests.empty?
+      end
+    end
+
+    class AutoRunner
+      alias_method :options_without_priority, :options
+      def options
+        opts = options_without_priority
+        opts.on("--[no-]priority", "use priority mode") do |bool|
+          TestSuite.priority_mode = bool
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/test-unit-ext/version.rb

@@ -0,0 +1,3 @@
+module TestUnitExt
+  VERSION = "0.1.0"
+end

data/misc/rd2html.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+html_dir = File.join(top, "html")
+
+require "fileutils"
+
+css = "base.css"
+kcode = "utf8"
+
+options = [
+  "-I#{File.join(top, 'misc')}",
+  "-S",
+  "rd2",
+  "-rrd/rd2html-lib",
+  "--out-code=#{kcode}",
+  proc do |f|
+    "--html-title=#{File.basename(f)}"
+  end,
+#   proc do |f|
+#     "--with-css=#{css}"
+#   end,
+  proc do |f|
+    f
+  end
+]
+
+Dir[File.join(top, "*.{ja,en}")].each do |f|
+  if /(README|NEWS)\.(ja|en)\z/ =~ f
+    args = options.collect do |x|
+      if x.respond_to?(:call)
+        x.call(f)
+      else
+        x
+      end
+    end
+    output_base = File.basename(f).downcase.sub(/(ja|en)\z/, "html.\\1")
+    File.open(File.join(html_dir, output_base), "w") do |out|
+      out.puts(`ruby #{args.flatten.join(' ')}`)
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("./lib")
+$LOAD_PATH.unshift("./test")
+
+require "test-unit-ext"
+
+Dir.glob("test/**/test_*.rb") do |test|
+  begin
+    require test
+  rescue LoadError
+    puts "Can't load: #{test}: #{$!.message}"
+  end
+end

data/test/test_color.rb

@@ -0,0 +1,39 @@
+require 'test-unit-ext'
+
+class TestColor < Test::Unit::TestCase
+  def test_color_escape_sequence
+    assert_escape_sequence(["31"], color("red"))
+    assert_escape_sequence(["32", "1"], color("green", :bold => true))
+    assert_escape_sequence(["0"], color("reset"))
+    assert_escape_sequence(["45"], color("magenta", :foreground => false))
+  end
+
+  def test_mix_color_escape_sequence
+    assert_escape_sequence(["34", "1"],
+                           mix_color([color("blue"),
+                                      color("none", :bold => true)]))
+    assert_escape_sequence(["34", "1", "4"],
+                           mix_color([color("blue"),
+                                      color("none", :bold => true)]) +
+                           color("none", :underline => true))
+    assert_escape_sequence(["34", "1", "4"],
+                           color("blue") +
+                           color("none", :bold => true) +
+                           color("none", :underline => true))
+  end
+
+  private
+  def color(name, options={})
+    Test::Color.new(name, options)
+  end
+
+  def mix_color(colors)
+    Test::MixColor.new(colors)
+  end
+
+  def assert_escape_sequence(expected, color)
+    assert_equal(expected, color.sequence)
+    assert_match(/\e\[(?:\d+;)*\d+m/, color.escape_sequence)
+    assert_equal(expected, color.escape_sequence[2..-2].split(";"))
+  end
+end

data/test/test_diff.rb

@@ -0,0 +1,109 @@
+require 'test-unit-ext'
+
+class TestDiff < Test::Unit::TestCase
+  def test_to_indexes
+    assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
+                      ["abc def", "abc", "abc def"])
+  end
+
+  def test_longest_match
+    assert_longest_match([0, 1, 3],
+                         %w(b c d), %w(a b c d x y z),
+                         0, 2, 0, 7)
+    assert_longest_match([1, 2, 2],
+                         %w(b c d), %w(a b c d x y z),
+                         1, 2, 0, 6)
+    assert_longest_match([0, 0, 0],
+                         %w(a b), %w(c),
+                         0, 1, 0, 0)
+    assert_longest_match([1, 0, 2],
+                         %w(q a b x c d), %w(a b y c d f),
+                         0, 5, 0, 5)
+  end
+
+  def _test_matching_blocks
+    assert_matching_blocks([[0, 0, 2],
+                            [3, 2, 2],
+                            [5, 4, 0]],
+                           %w(a b x c d), %w(a b c d))
+    assert_matching_blocks([[1, 0, 2],
+                            [4, 3, 2],
+                            [6, 6, 0]],
+                           %w(q a b x c d), %q(a b y c d f))
+  end
+
+  def test_operations
+    assert_operations([[:delete, 0, 1, 0, 0],
+                       [:equal, 1, 3, 0, 2],
+                       [:replace, 3, 4, 2, 3],
+                       [:equal, 4, 6, 3, 5],
+                       [:insert, 6, 6, 5, 6]],
+                      %w(q a b x c d), %w(a b y c d f))
+  end
+
+  def test_same_contents
+    assert_ndiff("  aaa", ["aaa"], ["aaa"])
+    assert_ndiff("  aaa\n" \
+                 "  bbb",
+                 ["aaa", "bbb"], ["aaa", "bbb"])
+  end
+
+  def test_deleted
+    assert_ndiff("  aaa\n" \
+                 "  bbb\n" \
+                 "- bbb",
+                 ["aaa", "bbb"], ["aaa"])
+    assert_ndiff("  aaa\n" \
+                 "  bbb\n" \
+                 "- bbb\n" \
+                 "- ccc\n" \
+                 "- ddd",
+                 ["aaa", "bbb", "ccc", "ddd"], ["aaa"])
+  end
+
+  def test_format_diff_point
+    assert_format_diff_point(["- \tabcDefghiJkl",
+                              "? \t ^ ^  ^",
+                              "+ \t\tabcdefGhijkl",
+                              "? \t  ^ ^  ^"],
+                             "\tabcDefghiJkl",
+                             "\t\tabcdefGhijkl",
+                             "  ^ ^  ^      ",
+                             "+  ^ ^  ^      ")
+  end
+
+  private
+  def assert_to_indexes(expected, to)
+    matcher = Test::Diff::SequenceMatcher.new([""], to)
+    assert_equal(expected, matcher.instance_variable_get("@to_indexes"))
+  end
+
+  def assert_longest_match(expected, from, to,
+                           from_start, from_end,
+                           to_start, to_end)
+    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    assert_equal(expected, matcher.longest_match(from_start, from_end,
+                                                 to_start, to_end))
+  end
+
+  def assert_matching_blocks(expected, from, to)
+    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    assert_equal(expected, matcher.matching_blocks)
+  end
+
+  def assert_operations(expected, from, to)
+    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    assert_equal(expected, matcher.operations)
+  end
+
+  def assert_ndiff(expected, from, to)
+    assert_equal(expected, Test::Diff.ndiff(from, to))
+  end
+
+  def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
+    differ = Test::Diff::Differ.new([""], [""])
+    assert_equal(expected, differ.send(:format_diff_point,
+                                       from_line, to_line,
+                                       from_tags, to_tags))
+  end
+end

data/test/test_metadata.rb

@@ -0,0 +1,127 @@
+require 'test-unit-ext'
+
+class TestMetadata < Test::Unit::TestCase
+  class TestStack < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    class Stack
+      def initialize
+        @data = []
+      end
+
+      def push(data)
+        @data.push(data)
+      end
+
+      def peek
+        @data[-2]
+      end
+
+      def empty?
+        @data.empty?
+      end
+
+      def size
+        @data.size + 11
+      end
+    end
+
+    def setup
+      @stack = Stack.new
+    end
+
+    metadata :category, :accessor
+    def test_peek
+      @stack.push(1)
+      @stack.push(2)
+      assert_equal(2, @stack.peek)
+    end
+
+    metadata :bug, 1234
+    def test_bug_1234
+      assert_equal(0, @stack.size)
+    end
+
+    def test_no_metadata
+      assert(@stack.empty?)
+      @stack.push(1)
+      assert(!@stack.empty?)
+      assert_equal(1, @stack.size)
+    end
+  end
+
+  def test_set_metadata
+    test_for_bug_1234 = TestStack.new("test_bug_1234")
+    assert_equal({:bug => 1234}, test_for_bug_1234.metadata)
+
+    test_no_metadata = TestStack.new("test_no_metadata")
+    assert_equal({}, test_no_metadata.metadata)
+  end
+
+  def test_show_metadata
+    assert_stack_size_line = search_line('assert_equal(0, @stack.size)')
+    assert_peek_line = search_line('assert_equal(2, @stack.peek)')
+    first_arg_end_line = search_line("\"<11>.\"],")
+    method_name = "test_show_metadata"
+    assert_result(["Failure:\n" \
+                   "test_peek(TestMetadata::TestStack)\n" \
+                   "  category: accessor\n" \
+                   "#{__FILE__}:#{assert_peek_line}:in `test_peek'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<2> expected but was\n" \
+                   "<1>.",
+                   "Failure:\n" \
+                   "test_bug_1234(TestMetadata::TestStack)\n" \
+                   "  bug: 1234\n" \
+                   "#{__FILE__}:#{assert_stack_size_line}:in `test_bug_1234'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<0> expected but was\n" \
+                   "<11>."],
+                  [],
+                  ["test_peek", "test_bug_1234"])
+  end
+
+  def test_not_show_metadata
+    assert_line = search_line('assert_equal(1, @stack.size')
+    first_arg_end_line = search_line("\"<12>.\"],")
+    method_name = "test_not_show_metadata"
+    assert_result(["Failure:\n" \
+                   "test_no_metadata(TestMetadata::TestStack)\n" \
+                   "#{__FILE__}:#{assert_line}:in `test_no_metadata'\n" \
+                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
+                   "<1> expected but was\n" \
+                   "<12>."],
+                  [],
+                  ["test_no_metadata"])
+  end
+
+  private
+  def search_line(pattern)
+    if pattern.is_a?(String)
+      pattern = /#{Regexp.escape(pattern)}/
+    end
+    File.open(__FILE__) do |file|
+      while line = file.gets
+        return file.lineno if pattern =~ line
+      end
+    end
+    nil
+  end
+
+  def assert_result(failure_results, error_results, names)
+    tests = names.collect {|name| TestStack.new(name)}
+    result = Test::Unit::TestResult.new
+    mark = /\A#{Regexp.escape(__FILE__)}:#{__LINE__ + 1}/
+    tests.each {|test| test.run(result) {}}
+    failures = result.instance_variable_get("@failures")
+    errors = result.instance_variable_get("@errors")
+    failures.each {|f| f.location.reject! {|l| mark =~ l}}
+    assert_equal([failure_results, error_results],
+                 [failures.collect {|failure| failure.long_display},
+                  errors.collect {|error| error.long_display}])
+  end
+end