activeldap 1.0.0 → 1.0.1

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

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

data/test-unit-ext/lib/test-unit-ext/xml-report.rb

@@ -1,224 +0,0 @@
-require "erb"
-require "test/unit/failure"
-require "test/unit/error"
-require "test/unit/testresult"
-require "test/unit/testsuite"
-require "test/unit/autorunner"
-
-module Test
-  module Unit
-    module XMLReportable
-      include ERB::Util
-
-      def to_xml
-        <<-XML.gsub(/\s*(\n  <\/test>|\n<\/result>)/m, "\\1")
-<result>
-  <test_case>
-    <name>#{h(@test.class.name)}</name>
-    <description/>
-  </test_case>
-  <test>
-    <name>#{h(@test.method_name)}</name>
-    <description/>
-#{options_xml}
-  </test>
-  <status>#{h(status_name)}</status>
-  <detail>#{h(message)}</detail>
-  <elapsed>#{h(elapsed_time)}</elapsed>
-#{backtrace_xml}
-</result>
-XML
-      end
-
-      private
-      def options_xml
-        @test.attributes.collect do |key, value|
-          <<-XML
-    <option>
-      <name>#{h(key)}</name>
-      <value>#{h(value)}</value>
-    </option>
-XML
-        end.join
-      end
-
-      def backtrace_xml
-        entries = backtrace_entries_xml
-        if entries.empty?
-          ""
-        else
-          <<-XML
-  <backtrace>
-#{entries.join.rstrip}
-  </backtrace>
-XML
-        end
-      end
-
-      def backtrace_entries_xml
-        location.collect do |location|
-          file, line, info = location.split(/:(\d+):/)
-          <<-XML
-    <entry>
-      <file>#{h(file)}</file>
-      <line>#{h(line)}</line>
-      <info>#{h(info.to_s.strip)}</info>
-    </entry>
-XML
-        end
-      end
-    end
-
-    class Success
-      include XMLReportable
-
-      attr_reader :test, :elapsed_time
-      def initialize(test, elapsed_time)
-        @test = test
-        @elapsed_time = elapsed_time
-      end
-
-      def message
-        nil
-      end
-
-      def location
-        []
-      end
-
-      def test_name
-        @test.name
-      end
-
-      def test_case_name
-        /\((.*)\)\z/ =~ test_name
-        $1
-      end
-
-      def status_name
-        "success"
-      end
-    end
-
-    class Failure
-      include XMLReportable
-
-      attr_accessor :test, :elapsed_time
-
-      def status_name
-        "failure"
-      end
-    end
-
-    class Error
-      include XMLReportable
-
-      attr_accessor :test, :elapsed_time
-
-      def status_name
-        "error"
-      end
-
-      def location
-        filter_backtrace(@exception.backtrace)
-      end
-    end
-
-    class TestCase
-      alias_method(:run_without_success_notify, :run)
-      def run(result, &block)
-        @_start_time = Time.now
-        run_result = run_without_success_notify(result, &block)
-        result.add_success(Success.new(self, Time.now - @_start_time)) if passed?
-        run_result
-      end
-
-      alias_method(:add_failure_without_test_case_set, :add_failure)
-      def add_failure(*args)
-        add_failure_without_test_case_set(*args)
-        failure = @_result.failures.last
-        failure.test = self
-        failure.elapsed_time = Time.now - @_start_time
-      end
-
-      alias_method(:add_error_without_test_case_set, :add_error)
-      def add_error(*args)
-        add_error_without_test_case_set(*args)
-        error = @_result.errors.last
-        error.test = self
-        error.elapsed_time = Time.now - @_start_time
-      end
-    end
-
-    class TestResult
-      attr_reader :failures, :errors
-
-      alias_method(:initialize_without_successes, :initialize)
-      def initialize
-        initialize_without_successes
-        @successes = []
-        @logs = []
-      end
-
-      def add_success(success)
-        @logs << success
-        @successes << success
-      end
-
-      alias_method(:add_failure_without_logs_store, :add_failure)
-      def add_failure(failure)
-        @logs << failure
-        add_failure_without_logs_store(failure)
-      end
-
-      alias_method(:add_error_without_logs_store, :add_error)
-      def add_error(error)
-        @logs << error
-        add_error_without_logs_store(error)
-      end
-
-      def to_xml
-        return "<report/>" if @logs.empty?
-        xml = @logs.collect {|log| log.to_xml.gsub(/^/, "  ")}.join
-        "<report>\n#{xml}</report>\n"
-      end
-    end
-
-    class TestSuite
-      attr_reader :result
-
-      alias_method(:run_without_keep_result, :run)
-      def run(result, &block)
-        @result = result
-        run_without_keep_result(result, &block)
-      end
-    end
-
-    class AutoRunner
-      alias_method(:options_without_xml_report_support, :options)
-      def options
-        opt = options_without_xml_report_support
-        @xml_report_support_option_added ||= false
-        unless @xml_report_support_option_added
-          @xml_report_file = nil
-          opt.on('--xml-report=FILE',
-                 "Output test report in XML to FILE.") do |file|
-            @xml_report_file = file
-          end
-        end
-        opt
-      end
-
-      alias_method(:run_without_xml_report_support, :run)
-      def run
-        passed = run_without_xml_report_support
-        if @xml_report_file
-          File.open(@xml_report_file, "w") do |f|
-            f.print(@suite.result.to_xml)
-          end
-        end
-        passed
-      end
-    end
-  end
-end

data/test-unit-ext/test/run-test.rb

@@ -1,14 +0,0 @@
-#!/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-unit-ext/test/test_attributes.rb

@@ -1,139 +0,0 @@
-require 'test-unit-ext'
-
-class TestAttributes < 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
-
-    attribute :category, :accessor
-    def test_peek
-      @stack.push(1)
-      @stack.push(2)
-      assert_equal(2, @stack.peek)
-    end
-
-    attribute :bug, 1234
-    def test_bug_1234
-      assert_equal(0, @stack.size)
-    end
-
-    def test_no_attributes
-      assert(@stack.empty?)
-      @stack.push(1)
-      assert(!@stack.empty?)
-      assert_equal(1, @stack.size)
-    end
-  end
-
-  def test_set_attributes
-    test_for_bug_1234 = TestStack.new("test_bug_1234")
-    assert_equal({:bug => 1234}, test_for_bug_1234.attributes)
-
-    test_no_attributes = TestStack.new("test_no_attributes")
-    assert_equal({}, test_no_attributes.attributes)
-  end
-
-  def test_show_attributes
-    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_attributes"
-    assert_result(["Failure:\n" \
-                   "test_peek(TestAttributes::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>.\n" \
-                   "\n" \
-                   "diff:\n" \
-                   "- 2\n" \
-                   "+ 1",
-                   "Failure:\n" \
-                   "test_bug_1234(TestAttributes::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>.\n" \
-                   "\n" \
-                   "diff:\n" \
-                   "- 0\n" \
-                   "+ 11"],
-                  [],
-                  ["test_peek", "test_bug_1234"])
-  end
-
-  def test_not_show_attributes
-    assert_line = search_line('assert_equal(1, @stack.size')
-    first_arg_end_line = search_line("\"+ 12\"],")
-    method_name = "test_not_show_attributes"
-    assert_result(["Failure:\n" \
-                   "test_no_attributes(TestAttributes::TestStack)\n" \
-                   "#{__FILE__}:#{assert_line}:in `test_no_attributes'\n" \
-                   "#{__FILE__}:#{first_arg_end_line}:in `#{method_name}':\n" \
-                   "<1> expected but was\n" \
-                   "<12>.\n" \
-                   "\n" \
-                   "diff:\n" \
-                   "- 1\n" \
-                   "+ 12"],
-                  [],
-                  ["test_no_attributes"])
-  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

data/test-unit-ext/test/test_omission.rb

@@ -1,64 +0,0 @@
-require 'test-unit-ext'
-
-class TestOmission < Test::Unit::TestCase
-  class TestCase < Test::Unit::TestCase
-    class << self
-      def suite
-        Test::Unit::TestSuite.new(name)
-      end
-    end
-
-    def test_omit
-      omit("1st omit")
-      omit("2nd omit. Not reached here.")
-    end
-
-    def test_omit_with_failure_in_block
-      omit("Wait a minute") do
-        raise "Not implemented yet"
-      end
-      assert(true, "Not reached here.")
-    end
-
-    def test_omit_with_no_failure_in_block
-      omit("Wait a minute") do
-        "Nothing raised"
-      end
-      assert(true, "Reached here.")
-    end
-  end
-
-  def test_omit
-    result = run_test("test_omit")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_equal(["1st omit"],
-                 result.omissions.collect {|omission| omission.message})
-  end
-
-  def test_omit_with_failure_in_block
-    result = run_test("test_omit_with_failure_in_block")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_equal(["Wait a minute"],
-                 result.omissions.collect {|omission| omission.message})
-  end
-
-  def test_omit_with_no_failure_in_block
-    result = run_test("test_omit_with_no_failure_in_block")
-    assert_equal("1 tests, 1 assertions, 1 failures, 0 errors, 0 pendings, " \
-                 "0 omissions, 0 notifications",
-                 result.to_s)
-    assert_equal(["Omission block should not be passed: Wait a minute."],
-                 result.failures.collect {|failure| failure.message})
-  end
-
-  private
-  def run_test(name)
-    result = Test::Unit::TestResult.new
-    TestCase.new(name).run(result) {}
-    result
-  end
-end

data/test-unit-ext/test/test_xml_report.rb

@@ -1,161 +0,0 @@
-require 'test-unit-ext'
-
-class TestXMLReport < Test::Unit::TestCase
-  class TestCase < Test::Unit::TestCase
-    def default_test
-    end
-
-    def _test_success
-      assert(true)
-    end
-
-    TEST_FAILURE_LINE = __LINE__ + 3
-    bug 1234
-    def _test_failure
-      assert(false)
-    end
-
-    TEST_ERROR_LINE = __LINE__ + 2
-    def _test_error
-      non_existence_method()
-    end
-
-    def inspect
-      "TEST-CASE"
-    end
-  end
-
-  include ERB::Util
-
-  def test_empty_test
-    assert_xml("<report/>", suite)
-  end
-
-  def test_success_result
-    elapsed = "0.001"
-    assert_xml(<<-XML, suite([TestCase.new("_test_success")]), elapsed)
-<report>
-  <result>
-    <test_case>
-      <name>TestXMLReport::TestCase</name>
-      <description/>
-    </test_case>
-    <test>
-      <name>_test_success</name>
-      <description/>
-    </test>
-    <status>success</status>
-    <detail></detail>
-    <elapsed>#{elapsed}</elapsed>
-  </result>
-</report>
-XML
-  end
-
-  def test_failure_result
-    elapsed = "0.001"
-    backtrace_line = __LINE__ + 1
-    assert_xml(<<-XML, suite([TestCase.new("_test_failure")]), elapsed)
-<report>
-  <result>
-    <test_case>
-      <name>TestXMLReport::TestCase</name>
-      <description/>
-    </test_case>
-    <test>
-      <name>_test_failure</name>
-      <description/>
-      <option>
-        <name>bug</name>
-        <value>1234</value>
-      </option>
-    </test>
-    <status>failure</status>
-    <detail>&lt;false&gt; is not true.</detail>
-    <elapsed>#{elapsed}</elapsed>
-    <backtrace>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{TestCase::TEST_FAILURE_LINE}</line>
-        <info>in `_test_failure'</info>
-      </entry>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{TEST_RUN_LINE}</line>
-        <info>in `assert_xml'</info>
-      </entry>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{backtrace_line}</line>
-        <info>in `test_failure_result'</info>
-      </entry>
-    </backtrace>
-  </result>
-</report>
-XML
-  end
-
-  def test_error_result
-    test = TestCase.new("_test_error")
-    detail = "NoMethodError: undefined method `non_existence_method' " +
-      "for TEST-CASE:#{test.class.name}"
-    elapsed = "0.001"
-    backtrace_line = __LINE__ + 1
-    assert_xml(<<-XML, suite([test]), elapsed)
-<report>
-  <result>
-    <test_case>
-      <name>TestXMLReport::TestCase</name>
-      <description/>
-    </test_case>
-    <test>
-      <name>_test_error</name>
-      <description/>
-    </test>
-    <status>error</status>
-    <detail>#{h(detail)}</detail>
-    <elapsed>#{elapsed}</elapsed>
-    <backtrace>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{TestCase::TEST_ERROR_LINE}</line>
-        <info>in `_test_error'</info>
-      </entry>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{TEST_RUN_LINE}</line>
-        <info>in `assert_xml'</info>
-      </entry>
-      <entry>
-        <file>#{__FILE__}</file>
-        <line>#{backtrace_line}</line>
-        <info>in `test_error_result'</info>
-      </entry>
-    </backtrace>
-  </result>
-</report>
-XML
-  end
-
-  private
-  def suite(tests=[], name="Unnamed TestSuite")
-    test_suite = Test::Unit::TestSuite.new(name)
-    tests.each do |test|
-      test_suite << test
-    end
-    test_suite
-  end
-
-  TEST_RUN_LINE = __LINE__ + 2
-  def assert_xml(expected, suite, normalized_elapsed=nil)
-    result = Test::Unit::UI::Console::TestRunner.run(suite,
-                                                     Test::Unit::UI::SILENT)
-    xml = result.to_xml
-    if xml and normalized_elapsed
-      xml = xml.gsub(/<elapsed>[\d.]+<\/elapsed>/) do
-        "<elapsed>#{normalized_elapsed}</elapsed>"
-      end
-    end
-    assert_equal(expected, xml)
-  end
-end