jimweirich-rake 0.8.1.5

data/test/test_pathmap.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+# ====================================================================
+class TestPathMap < Test::Unit::TestCase
+
+  def test_returns_self_with_no_args
+    assert_equal "abc.rb", "abc.rb".pathmap
+  end
+
+  def test_s_returns_file_separator
+    sep = File::ALT_SEPARATOR || File::SEPARATOR
+    assert_equal sep, "abc.rb".pathmap("%s")
+    assert_equal sep, "".pathmap("%s")
+    assert_equal "a#{sep}b", "a/b".pathmap("%d%s%f")
+  end
+
+  def test_f_returns_basename
+    assert_equal "abc.rb", "abc.rb".pathmap("%f")
+    assert_equal "abc.rb", "this/is/a/dir/abc.rb".pathmap("%f")
+    assert_equal "abc.rb", "/this/is/a/dir/abc.rb".pathmap("%f")
+  end
+
+  def test_n_returns_basename_without_extension
+    assert_equal "abc", "abc.rb".pathmap("%n")
+    assert_equal "abc", "abc".pathmap("%n") 
+    assert_equal "abc", "this/is/a/dir/abc.rb".pathmap("%n")
+    assert_equal "abc", "/this/is/a/dir/abc.rb".pathmap("%n")
+    assert_equal "abc", "/this/is/a/dir/abc".pathmap("%n")
+  end
+
+  def test_d_returns_dirname
+    assert_equal ".", "abc.rb".pathmap("%d")
+    assert_equal "/", "/abc".pathmap("%d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%d")
+    assert_equal "/this/is/a/dir", "/this/is/a/dir/abc.rb".pathmap("%d")
+  end
+
+  def test_9d_returns_partial_dirname
+    assert_equal "this/is", "this/is/a/dir/abc.rb".pathmap("%2d")
+    assert_equal "this", "this/is/a/dir/abc.rb".pathmap("%1d")
+    assert_equal ".", "this/is/a/dir/abc.rb".pathmap("%0d")
+    assert_equal "dir", "this/is/a/dir/abc.rb".pathmap("%-1d")
+    assert_equal "a/dir", "this/is/a/dir/abc.rb".pathmap("%-2d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%100d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%-100d")
+  end
+
+  def test_x_returns_extension
+    assert_equal "", "abc".pathmap("%x")
+    assert_equal ".rb", "abc.rb".pathmap("%x")
+    assert_equal ".rb", "abc.xyz.rb".pathmap("%x")
+    assert_equal "", ".depends".pathmap("%x")
+    assert_equal "", "dir/.depends".pathmap("%x")
+  end
+
+  def test_X_returns_everything_but_extension
+    assert_equal "abc", "abc".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
+    assert_equal "ab.xyz", "ab.xyz.rb".pathmap("%X")
+    assert_equal "a.xyz", "a.xyz.rb".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "ab", "ab.rb".pathmap("%X")
+    assert_equal "a", "a.rb".pathmap("%X")
+    assert_equal ".depends", ".depends".pathmap("%X")
+    assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X")
+    assert_equal "/.depends", "/.depends".pathmap("%X")
+  end
+
+  def test_p_returns_entire_pathname
+    assert_equal "abc.rb", "abc.rb".pathmap("%p")
+    assert_equal "this/is/a/dir/abc.rb", "this/is/a/dir/abc.rb".pathmap("%p")
+    assert_equal "/this/is/a/dir/abc.rb", "/this/is/a/dir/abc.rb".pathmap("%p")
+  end
+
+  def test_dash_returns_empty_string
+    assert_equal "", "abc.rb".pathmap("%-")
+    assert_equal "abc.rb", "abc.rb".pathmap("%X%-%x")
+  end
+
+  def test_percent_percent_returns_percent
+    assert_equal "a%b", "".pathmap("a%%b")
+  end
+
+  def test_undefined_percent_causes_error
+    ex = assert_raise(ArgumentError) {
+      "dir/abc.rb".pathmap("%z")
+    }
+  end
+
+  def test_pattern_returns_substitutions
+    assert_equal "bin/org/osb",
+      "src/org/osb/Xyz.java".pathmap("%{src,bin}d")
+  end
+
+  def test_pattern_can_use_backreferences
+    assert_equal "dir/hi/is", "dir/this/is".pathmap("%{t(hi)s,\\1}p")
+  end
+
+  def test_pattern_with_star_replacement_string_uses_block
+    assert_equal "src/ORG/osb",
+      "src/org/osb/Xyz.java".pathmap("%{/org,*}d") { |d| d.upcase }
+    assert_equal "Xyz.java",
+      "src/org/osb/Xyz.java".pathmap("%{.*,*}f") { |f| f.capitalize }
+  end
+
+  def test_pattern_with_no_replacement_nor_block_substitutes_empty_string
+    assert_equal "bc.rb", "abc.rb".pathmap("%{a}f")
+  end
+
+  def test_pattern_works_with_certain_valid_operators
+    assert_equal "dir/xbc.rb", "dir/abc.rb".pathmap("%{a,x}p")
+    assert_equal "d1r", "dir/abc.rb".pathmap("%{i,1}d")
+    assert_equal "xbc.rb", "dir/abc.rb".pathmap("%{a,x}f")
+    assert_equal ".Rb", "dir/abc.rb".pathmap("%{r,R}x")
+    assert_equal "xbc", "dir/abc.rb".pathmap("%{a,x}n")
+  end
+
+  def test_multiple_patterns
+    assert_equal "this/is/b/directory/abc.rb",
+      "this/is/a/dir/abc.rb".pathmap("%{a,b;dir,\\0ectory}p")
+  end
+
+  def test_partial_directory_selection_works_with_patterns
+    assert_equal "this/is/a/long",
+      "this/is/a/really/long/path/ok.rb".pathmap("%{/really/,/}5d")
+  end
+
+  def test_pattern_with_invalid_operator
+    ex = assert_raise(ArgumentError) do
+      "abc.xyz".pathmap("%{src,bin}z")
+    end
+    assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)
+  end
+
+  def test_works_with_windows_separators
+    if File::ALT_SEPARATOR
+      assert_equal "abc", 'dir\abc.rb'.pathmap("%n")
+      assert_equal 'this\is\a\dir',
+        'this\is\a\dir\abc.rb'.pathmap("%d")
+    end
+  end
+
+  def test_complex_patterns
+    sep = "".pathmap("%s")
+    assert_equal "dir/abc.rb", "dir/abc.rb".pathmap("%d/%n%x")
+    assert_equal "./abc.rb", "abc.rb".pathmap("%d/%n%x")
+    assert_equal "Your file extension is '.rb'",
+      "dir/abc.rb".pathmap("Your file extension is '%x'")
+    assert_equal "bin/org/onstepback/proj/A.class",
+      "src/org/onstepback/proj/A.java".pathmap("%{src,bin}d/%n.class")
+    assert_equal "src_work/bin/org/onstepback/proj/A.class",
+      "src_work/src/org/onstepback/proj/A.java".pathmap('%{\bsrc\b,bin}X.class')
+    assert_equal ".depends.bak", ".depends".pathmap("%X.bak")
+    assert_equal "d#{sep}a/b/c#{sep}file.txt", "a/b/c/d/file.txt".pathmap("%-1d%s%3d%s%f")
+  end
+end
+
+class TestPathMapExplode < Test::Unit::TestCase
+  def setup
+    String.class_eval { public :pathmap_explode }
+  end
+
+  def teardown
+    String.class_eval { protected :pathmap_explode }
+  end
+
+  def test_explode
+    assert_equal ['a'], 'a'.pathmap_explode
+    assert_equal ['a', 'b'], 'a/b'.pathmap_explode
+    assert_equal ['a', 'b', 'c'], 'a/b/c'.pathmap_explode
+    assert_equal ['/', 'a'], '/a'.pathmap_explode
+    assert_equal ['/', 'a', 'b'], '/a/b'.pathmap_explode
+    assert_equal ['/', 'a', 'b', 'c'], '/a/b/c'.pathmap_explode
+    if File::ALT_SEPARATOR
+      assert_equal ['c:.', 'a'], 'c:a'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b'], 'c:a/b'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b', 'c'], 'c:a/b/c'.pathmap_explode
+      assert_equal ['c:/', 'a'], 'c:/a'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b'], 'c:/a/b'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b', 'c'], 'c:/a/b/c'.pathmap_explode
+    end
+  end
+end
+
+class TestPathMapPartial < Test::Unit::TestCase
+  def test_pathmap_partial
+    @path = "1/2/file"
+    def @path.call(n)
+      pathmap_partial(n)
+    end
+    assert_equal("1", @path.call(1))
+    assert_equal("1/2", @path.call(2))
+    assert_equal("1/2", @path.call(3))
+    assert_equal(".", @path.call(0))
+    assert_equal("2", @path.call(-1))
+    assert_equal("1/2", @path.call(-2))
+    assert_equal("1/2", @path.call(-3))
+  end
+end
+
+class TestFileListPathMap < Test::Unit::TestCase
+  def test_file_list_supports_pathmap
+    assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")
+  end
+end

data/test/test_rake.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+class TestRake < Test::Unit::TestCase
+  def test_each_dir_parent
+    assert_equal ['a'], alldirs('a')
+    assert_equal ['a/b', 'a'], alldirs('a/b')
+    assert_equal ['/a/b', '/a', '/'], alldirs('/a/b')
+    assert_equal ['c:/a/b', 'c:/a', 'c:'], alldirs('c:/a/b')
+    assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b')
+  end
+
+  def alldirs(fn)
+    result = []
+    Rake.each_dir_parent(fn) { |d| result << d }
+    result
+  end
+
+  def test_can_override_application
+    old_app = Rake.application
+    fake_app = Object.new
+    Rake.application = fake_app
+    assert_equal fake_app, Rake.application
+  ensure
+    Rake.application = old_app
+  end
+
+  def test_original_dir_reports_current_dir
+    assert_equal Dir.pwd, Rake.original_dir
+  end
+    
+end

data/test/test_require.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+# ====================================================================
+class TestRequire < Test::Unit::TestCase
+
+  def test_can_load_rake_library
+    app = Rake::Application.new
+    assert app.instance_eval {
+      rake_require("test2", ['test/data/rakelib'], [])
+    }
+  end
+
+  def test_wont_reload_rake_library
+    app = Rake::Application.new
+    assert ! app.instance_eval {
+      rake_require("test2", ['test/data/rakelib'], ['test2'])
+    }
+  end
+
+  def test_throws_error_if_library_not_found
+    app = Rake::Application.new
+    ex = assert_raise(LoadError) {
+      assert app.instance_eval {
+        rake_require("testx", ['test/data/rakelib'], [])
+      }
+    }
+    assert_match(/x/, ex.message)
+  end
+end
+

data/test/test_rules.rb

@@ -0,0 +1,347 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+
+######################################################################
+class TestRules < Test::Unit::TestCase
+  include Rake
+  include FileCreation
+
+  SRCFILE  = "testdata/abc.c"
+  SRCFILE2 =  "testdata/xyz.c"
+  FTNFILE  = "testdata/abc.f"
+  OBJFILE  = "testdata/abc.o"
+  FOOFILE  = "testdata/foo"
+  DOTFOOFILE = "testdata/.foo"
+
+  def setup
+    Task.clear
+    @runs = []
+  end
+
+  def teardown
+    FileList['testdata/*'].each do |f| rm_r(f, :verbose=>false) end
+  end
+
+  def test_multiple_rules1
+    create_file(FTNFILE)
+    delete_file(SRCFILE)
+    delete_file(OBJFILE)
+    rule(/\.o$/ => ['.c']) do @runs << :C end
+    rule(/\.o$/ => ['.f']) do @runs << :F end
+    t = Task[OBJFILE]
+    t.invoke
+    Task[OBJFILE].invoke
+    assert_equal [:F], @runs
+  end
+
+  def test_multiple_rules2
+    create_file(FTNFILE)
+    delete_file(SRCFILE)
+    delete_file(OBJFILE)
+    rule(/\.o$/ => ['.f']) do @runs << :F end
+    rule(/\.o$/ => ['.c']) do @runs << :C end
+    Task[OBJFILE].invoke
+    assert_equal [:F], @runs
+  end
+
+  def test_create_with_source
+    create_file(SRCFILE)
+    rule(/\.o$/ => ['.c']) do |t|
+      @runs << t.name
+      assert_equal OBJFILE, t.name
+      assert_equal SRCFILE, t.source
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_single_dependent
+    create_file(SRCFILE)
+    rule(/\.o$/ => '.c') do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_rule_can_be_created_by_string
+    create_file(SRCFILE)
+    rule '.o' => ['.c'] do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_rule_prereqs_can_be_created_by_string
+    create_file(SRCFILE)
+    rule '.o' => '.c' do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_plain_strings_as_dependents_refer_to_files
+    create_file(SRCFILE)
+    rule '.o' => SRCFILE do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_file_names_beginning_with_dot_can_be_tricked_into_refering_to_file
+    verbose(false) do
+      chdir("testdata") do
+        create_file('.foo')
+        rule '.o' => "./.foo" do |t|
+          @runs << t.name
+        end
+        Task[OBJFILE].invoke
+        assert_equal [OBJFILE], @runs
+      end
+    end
+  end
+
+  def test_file_names_beginning_with_dot_can_be_wrapped_in_lambda
+    verbose(false) do
+      chdir("testdata") do
+        create_file(".foo")
+        rule '.o' => lambda{".foo"} do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task[OBJFILE].invoke
+        assert_equal ["#{OBJFILE} - .foo"], @runs
+      end
+    end
+  end
+
+  def test_file_names_containing_percent_can_be_wrapped_in_lambda
+    verbose(false) do
+      chdir("testdata") do
+        create_file("foo%x")
+        rule '.o' => lambda{"foo%x"} do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task[OBJFILE].invoke
+        assert_equal ["#{OBJFILE} - foo%x"], @runs
+      end
+    end
+  end
+
+  def test_non_extension_rule_name_refers_to_file
+    verbose(false) do
+      chdir("testdata") do
+        create_file("abc.c")
+        rule "abc" => '.c' do |t|
+          @runs << t.name
+        end
+        Task["abc"].invoke
+        assert_equal ["abc"], @runs
+      end
+    end
+  end
+
+  def test_pathmap_automatically_applies_to_name
+    verbose(false) do
+      chdir("testdata") do
+        create_file("zzabc.c")
+        rule ".o" => 'zz%{x,a}n.c' do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task["xbc.o"].invoke
+        assert_equal ["xbc.o - zzabc.c"], @runs
+      end
+    end
+  end
+
+  def test_plain_strings_are_just_filenames
+    verbose(false) do
+      chdir("testdata") do
+        create_file("plainname")
+        rule ".o" => 'plainname' do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task["xbc.o"].invoke
+        assert_equal ["xbc.o - plainname"], @runs
+      end
+    end
+  end
+
+  def test_rule_runs_when_explicit_task_has_no_actions
+    create_file(SRCFILE)
+    create_file(SRCFILE2)
+    delete_file(OBJFILE)
+    rule '.o' => '.c' do |t|
+      @runs << t.source
+    end
+    file OBJFILE => [SRCFILE2]
+    Task[OBJFILE].invoke
+    assert_equal [SRCFILE], @runs
+  end
+
+  def test_close_matches_on_name_do_not_trigger_rule
+    create_file("testdata/x.c")
+    rule '.o' => ['.c'] do |t|
+      @runs << t.name
+    end
+    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
+    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
+  end
+
+  def test_rule_rebuilds_obj_when_source_is_newer
+    create_timed_files(OBJFILE, SRCFILE)
+    rule(/\.o$/ => ['.c']) do
+      @runs << :RULE
+    end
+    Task[OBJFILE].invoke
+    assert_equal [:RULE], @runs
+  end
+
+  def test_rule_with_two_sources_runs_if_both_sources_are_present
+    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
+    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
+      @runs << :RULE
+    end
+    Task[OBJFILE].invoke
+    assert_equal [:RULE], @runs
+  end
+
+  def test_rule_with_two_sources_but_one_missing_does_not_run
+    create_timed_files(OBJFILE, SRCFILE)
+    delete_file(SRCFILE2)
+    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
+      @runs << :RULE
+    end
+    Task[OBJFILE].invoke
+    assert_equal [], @runs
+  end
+
+  def test_rule_with_two_sources_builds_both_sources
+    task 'x.aa'
+    task 'x.bb'
+    rule '.a' => '.aa' do
+      @runs << "A"
+    end
+    rule '.b' => '.bb' do
+      @runs << "B"
+    end
+    rule ".c" => ['.a', '.b'] do
+      @runs << "C"
+    end
+    Task["x.c"].invoke
+    assert_equal ["A", "B", "C"], @runs.sort
+  end
+
+  def test_second_rule_runs_when_first_rule_doesnt
+    create_timed_files(OBJFILE, SRCFILE)
+    delete_file(SRCFILE2)
+    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
+      @runs << :RULE1
+    end
+    rule OBJFILE => [lambda{SRCFILE}] do
+      @runs << :RULE2
+    end
+    Task[OBJFILE].invoke
+    assert_equal [:RULE2], @runs
+  end
+
+  def test_second_rule_doest_run_if_first_triggers
+    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
+    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
+      @runs << :RULE1
+    end
+    rule OBJFILE => [lambda{SRCFILE}] do
+      @runs << :RULE2
+    end
+    Task[OBJFILE].invoke
+    assert_equal [:RULE1], @runs
+  end
+
+  def test_second_rule_doest_run_if_first_triggers_with_reversed_rules
+    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
+    rule OBJFILE => [lambda{SRCFILE}] do
+      @runs << :RULE1
+    end
+    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
+      @runs << :RULE2
+    end
+    Task[OBJFILE].invoke
+    assert_equal [:RULE1], @runs
+  end
+
+  def test_rule_with_proc_dependent_will_trigger
+    ran = false
+    mkdir_p("testdata/src/jw")
+    create_file("testdata/src/jw/X.java")
+    rule %r(classes/.*\.class) => [
+      proc { |fn| fn.pathmap("%{classes,testdata/src}d/%n.java") }
+    ] do |task|
+      assert_equal task.name, 'classes/jw/X.class'
+      assert_equal task.source, 'testdata/src/jw/X.java'
+      @runs << :RULE
+    end
+    Task['classes/jw/X.class'].invoke
+    assert_equal [:RULE], @runs
+  ensure
+    rm_r("testdata/src", :verbose=>false) rescue nil
+  end
+
+  def test_proc_returning_lists_are_flattened_into_prereqs
+    ran = false
+    mkdir_p("testdata/flatten")
+    create_file("testdata/flatten/a.txt")
+    task 'testdata/flatten/b.data' do |t|
+      ran = true
+      touch t.name, :verbose => false
+    end
+    rule '.html' =>
+      proc { |fn|
+      [
+        fn.ext("txt"),
+        "testdata/flatten/b.data"
+      ]
+    } do |task|
+    end
+    Task['testdata/flatten/a.html'].invoke
+    assert ran, "Should have triggered flattened dependency"
+  ensure
+    rm_r("testdata/flatten", :verbose=>false) rescue nil
+  end
+
+  def test_recursive_rules_will_work_as_long_as_they_terminate
+    actions = []
+    create_file("testdata/abc.xml")
+    rule '.y' => '.xml' do actions << 'y' end
+    rule '.c' => '.y' do actions << 'c'end
+    rule '.o' => '.c' do actions << 'o'end
+    rule '.exe' => '.o' do actions << 'exe'end
+    Task["testdata/abc.exe"].invoke
+    assert_equal ['y', 'c', 'o', 'exe'], actions
+  end
+
+  def test_recursive_rules_that_dont_terminate_will_overflow
+    create_file("testdata/a.a")
+    prev = 'a'
+    ('b'..'z').each do |letter|
+      rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
+      prev = letter
+    end
+    ex = assert_raises(Rake::RuleRecursionOverflowError) {
+      Task["testdata/a.z"].invoke
+    }
+    assert_match(/a\.z => testdata\/a.y/, ex.message)
+  end
+
+  def test_rules_with_bad_dependents_will_fail
+    rule "a" => [ 1 ] do |t| puts t.name end
+    assert_raise(RuntimeError) do Task['a'].invoke end
+  end
+
+end
+

data/test/test_task_arguments.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+######################################################################
+class TestTaskArguments < Test::Unit::TestCase
+  def teardown
+    ENV.delete('rev')
+    ENV.delete('VER')
+  end
+
+  def test_empty_arg_list_is_empty
+    ta = Rake::TaskArguments.new([], [])
+    assert_equal({}, ta.to_hash)
+  end
+
+  def test_multiple_values_in_args
+    ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three])
+    assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash)
+  end
+
+  def test_to_s
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal ta.to_hash.inspect, ta.to_s
+    assert_equal ta.to_hash.inspect, ta.inspect
+  end
+
+  def test_enumerable_behavior
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2 ,3])
+    assert_equal [10, 20, 30], ta.collect { |k,v| v * 10 }.sort
+  end
+
+  def test_named_args
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal 1, ta.aa
+    assert_equal 1, ta[:aa]
+    assert_equal 1, ta["aa"]
+    assert_equal 2, ta.bb
+    assert_nil ta.cc
+  end
+
+  def test_args_knows_its_names
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal ["aa", "bb"], ta.names
+  end
+
+  def test_extra_names_are_nil
+    ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2])
+    assert_nil ta.cc
+  end
+
+  def test_args_can_reference_env_values
+    ta = Rake::TaskArguments.new(["aa"], [1])
+    ENV['rev'] = "1.2"
+    ENV['VER'] = "2.3"
+    assert_equal "1.2", ta.rev
+    assert_equal "2.3", ta.ver
+  end
+
+  def test_creating_new_argument_scopes
+    parent = Rake::TaskArguments.new(['p'], [1])
+    child = parent.new_scope(['c', 'p'])
+    assert_equal({:c => nil, :p=>1}, child.to_hash)
+    assert_equal 1, child.p
+    assert_equal 1, child["p"]
+    assert_equal 1, child[:p]
+    assert_nil child.c
+  end
+
+  def test_child_hides_parent_arg_names
+    parent = Rake::TaskArguments.new(['aa'], [1])
+    child = Rake::TaskArguments.new(['aa'], [2], parent)
+    assert_equal 2, child.aa
+  end
+end