vtd_xml 0.0.3-java → 0.0.6-java

data/bundle/jruby/1.9/gems/rake-10.1.1/test/test_rake_application_options.rb

@@ -1,457 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-TESTING_REQUIRE = []
-
-class TestRakeApplicationOptions < Rake::TestCase
-
-  def setup
-    super
-
-    clear_argv
-    Rake::FileUtilsExt.verbose_flag = false
-    Rake::FileUtilsExt.nowrite_flag = false
-    TESTING_REQUIRE.clear
-  end
-
-  def teardown
-    clear_argv
-    Rake::FileUtilsExt.verbose_flag = false
-    Rake::FileUtilsExt.nowrite_flag = false
-
-    super
-  end
-
-  def clear_argv
-    ARGV.pop until ARGV.empty?
-  end
-
-  def test_default_options
-    opts = command_line
-    assert_nil opts.backtrace
-    assert_nil opts.dryrun
-    assert_nil opts.ignore_system
-    assert_nil opts.load_system
-    assert_nil opts.always_multitask
-    assert_nil opts.nosearch
-    assert_equal ['rakelib'], opts.rakelib
-    assert_nil opts.show_prereqs
-    assert_nil opts.show_task_pattern
-    assert_nil opts.show_tasks
-    assert_nil opts.silent
-    assert_nil opts.trace
-    assert_nil opts.thread_pool_size
-    assert_equal ['rakelib'], opts.rakelib
-    assert ! Rake::FileUtilsExt.verbose_flag
-    assert ! Rake::FileUtilsExt.nowrite_flag
-  end
-
-  def test_dry_run
-    flags('--dry-run', '-n') do |opts|
-      assert opts.dryrun
-      assert opts.trace
-      assert Rake::FileUtilsExt.verbose_flag
-      assert Rake::FileUtilsExt.nowrite_flag
-    end
-  end
-
-  def test_describe
-    flags('--describe') do |opts|
-      assert_equal :describe, opts.show_tasks
-      assert_equal(//.to_s, opts.show_task_pattern.to_s)
-    end
-  end
-
-  def test_describe_with_pattern
-    flags('--describe=X') do |opts|
-      assert_equal :describe, opts.show_tasks
-      assert_equal(/X/.to_s, opts.show_task_pattern.to_s)
-    end
-  end
-
-  def test_execute
-    $xyzzy = 0
-    flags('--execute=$xyzzy=1', '-e $xyzzy=1') do |opts|
-      assert_equal 1, $xyzzy
-      assert_equal :exit, @exit
-      $xyzzy = 0
-    end
-  end
-
-  def test_execute_and_continue
-    $xyzzy = 0
-    flags('--execute-continue=$xyzzy=1', '-E $xyzzy=1') do |opts|
-      assert_equal 1, $xyzzy
-      refute_equal :exit, @exit
-      $xyzzy = 0
-    end
-  end
-
-  def test_execute_and_print
-    $xyzzy = 0
-    out, = capture_io do
-      flags('--execute-print=$xyzzy="pugh"', '-p $xyzzy="pugh"') do |opts|
-        assert_equal 'pugh', $xyzzy
-        assert_equal :exit, @exit
-        $xyzzy = 0
-      end
-    end
-
-    assert_match(/^pugh$/, out)
-  end
-
-  def test_help
-    out, = capture_io do
-      flags '--help', '-H', '-h'
-    end
-
-    assert_match(/\Arake/, out)
-    assert_match(/\boptions\b/, out)
-    assert_match(/\btargets\b/, out)
-    assert_equal :exit, @exit
-  end
-
-  def test_jobs
-    flags(['--jobs', '4'], ['-j', '4']) do |opts|
-      assert_equal 4, opts.thread_pool_size
-    end
-    flags(['--jobs', 'asdas'], ['-j', 'asdas']) do |opts|
-      assert_equal 2, opts.thread_pool_size
-    end
-    flags('--jobs', '-j') do |opts|
-      assert_equal 2, opts.thread_pool_size
-    end
-  end
-
-  def test_libdir
-    flags(['--libdir', 'xx'], ['-I', 'xx'], ['-Ixx']) do |opts|
-      $:.include?('xx')
-    end
-  ensure
-    $:.delete('xx')
-  end
-
-  def test_multitask
-    flags('--multitask', '-m') do |opts|
-      assert_equal opts.always_multitask, true
-    end
-  end
-
-  def test_rakefile
-    flags(['--rakefile', 'RF'], ['--rakefile=RF'], ['-f', 'RF'], ['-fRF']) do |opts|
-      assert_equal ['RF'], @app.instance_eval { @rakefiles }
-    end
-  end
-
-  def test_rakelib
-    dirs = %w(A B C).join(File::PATH_SEPARATOR)
-    flags(
-      ['--rakelibdir', dirs],
-      ["--rakelibdir=#{dirs}"],
-      ['-R', dirs],
-      ["-R#{dirs}"]) do |opts|
-      assert_equal ['A', 'B', 'C'], opts.rakelib
-    end
-  end
-
-  def test_require
-    $LOAD_PATH.unshift @tempdir
-
-    open 'reqfile.rb',    'w' do |io| io << 'TESTING_REQUIRE << 1' end
-    open 'reqfile2.rb',   'w' do |io| io << 'TESTING_REQUIRE << 2' end
-    open 'reqfile3.rake', 'w' do |io| io << 'TESTING_REQUIRE << 3' end
-
-    flags(['--require', 'reqfile'], '-rreqfile2', '-rreqfile3')
-
-    assert_includes TESTING_REQUIRE, 1
-    assert_includes TESTING_REQUIRE, 2
-    assert_includes TESTING_REQUIRE, 3
-
-    assert_equal 3, TESTING_REQUIRE.size
-  ensure
-    $LOAD_PATH.delete @tempdir
-  end
-
-  def test_missing_require
-    ex = assert_raises(LoadError) do
-      flags(['--require', 'test/missing']) do |opts|
-      end
-    end
-    assert_match(/such file/, ex.message)
-    assert_match(/test\/missing/, ex.message)
-  end
-
-  def test_prereqs
-    flags('--prereqs', '-P') do |opts|
-      assert opts.show_prereqs
-    end
-  end
-
-  def test_quiet
-    Rake::FileUtilsExt.verbose_flag = true
-    flags('--quiet', '-q') do |opts|
-      assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag shoud be false"
-      assert ! opts.silent, "should not be silent"
-    end
-  end
-
-  def test_no_search
-    flags('--nosearch', '--no-search', '-N') do |opts|
-      assert opts.nosearch
-    end
-  end
-
-  def test_silent
-    Rake::FileUtilsExt.verbose_flag = true
-    flags('--silent', '-s') do |opts|
-      assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag should be false"
-      assert opts.silent, "should be silent"
-    end
-  end
-
-  def test_system
-    flags('--system', '-g') do |opts|
-      assert opts.load_system
-    end
-  end
-
-  def test_no_system
-    flags('--no-system', '-G') do |opts|
-      assert opts.ignore_system
-    end
-  end
-
-  def test_trace
-    flags('--trace', '-t') do |opts|
-      assert opts.trace, "should enable trace option"
-      assert opts.backtrace, "should enabled backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert Rake::FileUtilsExt.verbose_flag
-      assert ! Rake::FileUtilsExt.nowrite_flag
-    end
-  end
-
-  def test_trace_with_stdout
-    flags('--trace=stdout', '-tstdout') do |opts|
-      assert opts.trace, "should enable trace option"
-      assert opts.backtrace, "should enabled backtrace option"
-      assert_equal $stdout, opts.trace_output
-      assert Rake::FileUtilsExt.verbose_flag
-      assert ! Rake::FileUtilsExt.nowrite_flag
-    end
-  end
-
-  def test_trace_with_stderr
-    flags('--trace=stderr', '-tstderr') do |opts|
-      assert opts.trace, "should enable trace option"
-      assert opts.backtrace, "should enabled backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert Rake::FileUtilsExt.verbose_flag
-      assert ! Rake::FileUtilsExt.nowrite_flag
-    end
-  end
-
-  def test_trace_with_error
-    ex = assert_raises(Rake::CommandLineOptionError) do
-      flags('--trace=xyzzy') do |opts| end
-    end
-    assert_match(/un(known|recognized).*\btrace\b.*xyzzy/i, ex.message)
-  end
-
-  def test_trace_with_following_task_name
-    flags(['--trace', 'taskname'], ['-t', 'taskname']) do |opts|
-      assert opts.trace, "should enable trace option"
-      assert opts.backtrace, "should enabled backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert Rake::FileUtilsExt.verbose_flag
-      assert_equal ['taskname'], @app.top_level_tasks
-    end
-  end
-
-  def test_backtrace
-    flags('--backtrace') do |opts|
-      assert opts.backtrace, "should enable backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert ! opts.trace, "should not enable trace option"
-    end
-  end
-
-  def test_backtrace_with_stdout
-    flags('--backtrace=stdout') do |opts|
-      assert opts.backtrace, "should enable backtrace option"
-      assert_equal $stdout, opts.trace_output
-      assert ! opts.trace, "should not enable trace option"
-    end
-  end
-
-  def test_backtrace_with_stderr
-    flags('--backtrace=stderr') do |opts|
-      assert opts.backtrace, "should enable backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert ! opts.trace, "should not enable trace option"
-    end
-  end
-
-  def test_backtrace_with_error
-    ex = assert_raises(Rake::CommandLineOptionError) do
-      flags('--backtrace=xyzzy') do |opts| end
-    end
-    assert_match(/un(known|recognized).*\bbacktrace\b.*xyzzy/i, ex.message)
-  end
-
-  def test_backtrace_with_following_task_name
-    flags(['--backtrace', 'taskname']) do |opts|
-      assert ! opts.trace, "should enable trace option"
-      assert opts.backtrace, "should enabled backtrace option"
-      assert_equal $stderr, opts.trace_output
-      assert_equal ['taskname'], @app.top_level_tasks
-    end
-  end
-
-  def test_trace_rules
-    flags('--rules') do |opts|
-      assert opts.trace_rules
-    end
-  end
-
-  def test_tasks
-    flags('--tasks', '-T') do |opts|
-      assert_equal :tasks, opts.show_tasks
-      assert_equal(//.to_s, opts.show_task_pattern.to_s)
-      assert_equal nil, opts.show_all_tasks
-    end
-    flags(['--tasks', 'xyz'], ['-Txyz']) do |opts|
-      assert_equal :tasks, opts.show_tasks
-      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
-      assert_equal nil, opts.show_all_tasks
-    end
-    flags(['--tasks', 'xyz', '--comments']) do |opts|
-      assert_equal :tasks, opts.show_tasks
-      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
-      assert_equal false, opts.show_all_tasks
-    end
-  end
-
-  def test_where
-    flags('--where', '-W') do |opts|
-      assert_equal :lines, opts.show_tasks
-      assert_equal(//.to_s, opts.show_task_pattern.to_s)
-      assert_equal true, opts.show_all_tasks
-    end
-    flags(['--where', 'xyz'], ['-Wxyz']) do |opts|
-      assert_equal :lines, opts.show_tasks
-      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
-      assert_equal true, opts.show_all_tasks
-    end
-    flags(['--where', 'xyz', '--comments'], ['-Wxyz', '--comments']) do |opts|
-      assert_equal :lines, opts.show_tasks
-      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
-      assert_equal false, opts.show_all_tasks
-    end
-  end
-
-  def test_no_deprecated_messages
-    flags('--no-deprecation-warnings', '-X') do |opts|
-      assert opts.ignore_deprecate
-    end
-  end
-
-  def test_verbose
-    capture_io do
-      flags('--verbose', '-v') do |opts|
-        assert Rake::FileUtilsExt.verbose_flag, "verbose should be true"
-        assert ! opts.silent, "opts should not be silent"
-      end
-    end
-  end
-
-  def test_version
-    out, _ = capture_io do
-      flags '--version', '-V'
-    end
-
-    assert_match(/\bversion\b/, out)
-    assert_match(/\b#{RAKEVERSION}\b/, out)
-    assert_equal :exit, @exit
-  end
-
-  def test_bad_option
-    _, err = capture_io do
-      ex = assert_raises(OptionParser::InvalidOption) do
-        flags('--bad-option')
-      end
-
-      if ex.message =~ /^While/ # Ruby 1.9 error message
-        assert_match(/while parsing/i, ex.message)
-      else                      # Ruby 1.8 error message
-        assert_match(/(invalid|unrecognized) option/i, ex.message)
-        assert_match(/--bad-option/, ex.message)
-      end
-    end
-
-    assert_equal '', err
-  end
-
-  def test_task_collection
-    command_line("a", "b")
-    assert_equal ["a", "b"], @tasks.sort
-  end
-
-  def test_default_task_collection
-    command_line()
-    assert_equal ["default"], @tasks
-  end
-
-  def test_environment_definition
-    ENV.delete('TESTKEY')
-    command_line("TESTKEY=12")
-    assert_equal '12', ENV['TESTKEY']
-  end
-
-  def test_multiline_environment_definition
-    ENV.delete('TESTKEY')
-    command_line("TESTKEY=a\nb\n")
-    assert_equal "a\nb\n", ENV['TESTKEY']
-  end
-
-  def test_environment_and_tasks_together
-    ENV.delete('TESTKEY')
-    command_line("a", "b", "TESTKEY=12")
-    assert_equal ["a", "b"], @tasks.sort
-    assert_equal '12', ENV['TESTKEY']
-  end
-
-  def test_rake_explicit_task_library
-    Rake.add_rakelib 'app/task', 'other'
-
-    libs = Rake.application.options.rakelib
-
-    assert libs.include?("app/task")
-    assert libs.include?("other")
-  end
-
-  private
-
-  def flags(*sets)
-    sets.each do |set|
-      ARGV.clear
-
-      @exit = catch(:system_exit) { command_line(*set) }
-
-      yield(@app.options) if block_given?
-    end
-  end
-
-  def command_line(*options)
-    options.each do |opt| ARGV << opt end
-    @app = Rake::Application.new
-    def @app.exit(*args)
-      throw :system_exit, :exit
-    end
-    @app.instance_eval do
-      handle_options
-      collect_tasks
-    end
-    @tasks = @app.top_level_tasks
-    @app.options
-  end
-end

data/bundle/jruby/1.9/gems/rake-10.1.1/test/test_rake_backtrace.rb

@@ -1,113 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'open3'
-
-class TestBacktraceSuppression < Rake::TestCase
-  def test_bin_rake_suppressed
-    paths = ["something/bin/rake:12"]
-
-    actual = Rake::Backtrace.collapse(paths)
-
-    assert_equal [], actual
-  end
-
-  def test_system_dir_suppressed
-    path = RbConfig::CONFIG['rubylibprefix']
-    paths = [path + ":12"]
-
-    actual = Rake::Backtrace.collapse(paths)
-
-    assert_equal [], actual
-  end
-
-  def test_near_system_dir_isnt_suppressed
-    path = RbConfig::CONFIG['rubylibprefix']
-    paths = [" " + path + ":12"]
-
-    actual = Rake::Backtrace.collapse(paths)
-
-    assert_equal paths, actual
-  end
-end
-
-class TestRakeBacktrace < Rake::TestCase
-  include RubyRunner
-
-  def setup
-    super
-
-    skip 'tmpdir is suppressed in backtrace' if
-      Dir.pwd =~ Rake::Backtrace::SUPPRESS_PATTERN
-  end
-
-  def invoke(*args)
-    rake(*args)
-    @err
-  end
-
-  def test_single_collapse
-    rakefile %q{
-      task :foo do
-        raise "foooo!"
-      end
-    }
-
-    lines = invoke("foo").split("\n")
-
-    assert_equal "rake aborted!", lines[0]
-    assert_equal "foooo!", lines[1]
-    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
-    assert_something_matches %r!\ATasks:!, lines
-  end
-
-  def test_multi_collapse
-    rakefile %q{
-      task :foo do
-        Rake.application.invoke_task(:bar)
-      end
-      task :bar do
-        raise "barrr!"
-      end
-    }
-
-    lines = invoke("foo").split("\n")
-
-    assert_equal "rake aborted!", lines[0]
-    assert_equal "barrr!", lines[1]
-    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!i, lines
-    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
-    assert_something_matches %r!\ATasks:!, lines
-  end
-
-  def test_suppress_option
-    rakefile %q{
-      task :baz do
-        raise "bazzz!"
-      end
-    }
-
-    lines = invoke("baz").split("\n")
-    assert_equal "rake aborted!", lines[0]
-    assert_equal "bazzz!", lines[1]
-    assert_something_matches %r!Rakefile!i, lines
-
-    lines = invoke("--suppress-backtrace", ".ak.file", "baz").split("\n")
-    assert_equal "rake aborted!", lines[0]
-    assert_equal "bazzz!", lines[1]
-    refute_match %r!Rakefile!i, lines[2]
-  end
-
-  private
-
-  # Assert that the pattern matches at least one line in +lines+.
-  def assert_something_matches(pattern, lines)
-    lines.each do |ln|
-      if pattern =~ ln
-        assert_match pattern, ln
-        return
-      end
-    end
-    flunk "expected #{pattern.inspect} to match something in:\n" +
-      "#{lines.join("\n    ")}"
-  end
-
-end

data/bundle/jruby/1.9/gems/rake-10.1.1/test/test_rake_clean.rb

@@ -1,46 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/clean'
-
-class TestRakeClean < Rake::TestCase
-  def test_clean
-    load 'rake/clean.rb', true
-
-    assert Rake::Task['clean'], "Should define clean"
-    assert Rake::Task['clobber'], "Should define clobber"
-    assert Rake::Task['clobber'].prerequisites.include?("clean"),
-      "Clobber should require clean"
-  end
-
-  def test_cleanup
-    file_name = create_undeletable_file
-
-    out, _ = capture_io do
-      Rake::Cleaner.cleanup(file_name, verbose: false)
-    end
-    assert_match(/failed to remove/i, out)
-
-  ensure
-    remove_undeletable_file
-  end
-
-  private
-
-  def create_undeletable_file
-    dir_name = File.join(@tempdir, "deletedir")
-    file_name = File.join(dir_name, "deleteme")
-    FileUtils.mkdir(dir_name)
-    FileUtils.touch(file_name)
-    FileUtils.chmod(0, file_name)
-    FileUtils.chmod(0, dir_name)
-    file_name
-  end
-
-  def remove_undeletable_file
-    dir_name = File.join(@tempdir, "deletedir")
-    file_name = File.join(dir_name, "deleteme")
-    FileUtils.chmod(0777, dir_name)
-    FileUtils.chmod(0777, file_name)
-    Rake::Cleaner.cleanup(file_name, verbose: false)
-    Rake::Cleaner.cleanup(dir_name, verbose: false)
-  end
-end

data/bundle/jruby/1.9/gems/rake-10.1.1/test/test_rake_definitions.rb

@@ -1,79 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'fileutils'
-
-class TestRakeDefinitions < Rake::TestCase
-  include Rake
-
-  EXISTINGFILE = "existing"
-
-  def setup
-    super
-
-    Task.clear
-  end
-
-  def test_task
-    done = false
-    task :one => [:two] do done = true end
-    task :two
-    task :three => [:one, :two]
-    check_tasks(:one, :two, :three)
-    assert done, "Should be done"
-  end
-
-  def test_file_task
-    done = false
-    file "one" => "two" do done = true end
-    file "two"
-    file "three" => ["one", "two"]
-    check_tasks("one", "two", "three")
-    assert done, "Should be done"
-  end
-
-  def check_tasks(n1, n2, n3)
-    t = Task[n1]
-    assert Task === t, "Should be a Task"
-    assert_equal n1.to_s, t.name
-    assert_equal [n2.to_s], t.prerequisites.map { |n| n.to_s }
-    t.invoke
-    t2 = Task[n2]
-    assert_equal FileList[], t2.prerequisites
-    t3 = Task[n3]
-    assert_equal [n1.to_s, n2.to_s], t3.prerequisites.map { |n| n.to_s }
-  end
-
-  def test_incremental_definitions
-    runs = []
-    task :t1 => [:t2] do runs << "A"; 4321 end
-    task :t1 => [:t3] do runs << "B"; 1234 end
-    task :t1 => [:t3]
-    task :t2
-    task :t3
-    Task[:t1].invoke
-    assert_equal ["A", "B"], runs
-    assert_equal ["t2", "t3"], Task[:t1].prerequisites
-  end
-
-  def test_missing_dependencies
-    task :x => ["missing"]
-    assert_raises(RuntimeError) { Task[:x].invoke }
-  end
-
-  def test_implicit_file_dependencies
-    runs = []
-    create_existing_file
-    task :y => [EXISTINGFILE] do |t| runs << t.name end
-    Task[:y].invoke
-    assert_equal runs, ['y']
-  end
-
-  private # ----------------------------------------------------------
-
-  def create_existing_file
-    Dir.mkdir File.dirname(EXISTINGFILE) unless
-      File.exist?(File.dirname(EXISTINGFILE))
-    open(EXISTINGFILE, "w") do |f| f.puts "HI" end unless
-      File.exist?(EXISTINGFILE)
-  end
-
-end