drake 0.8.3.1.0.14 → 0.8.4.1.0.15

data/test/check_no_expansion.rb

@@ -0,0 +1,5 @@
+if ARGV[0] != ARGV[1]
+  exit 0
+else
+  exit 1
+end

data/test/data/sample.mf

@@ -10,3 +10,5 @@ c: c1
 d: d1 d2 \
 
 e f : e1 f1
+
+g\ 0: g1 g\ 2 g\ 3 g4

data/test/rake_test_setup.rb

@@ -8,3 +8,17 @@ rescue LoadError
 end
 
 require 'flexmock/test_unit'
+
+if RUBY_VERSION >= "1.9.0"
+  class Test::Unit::TestCase
+#    def passed?
+#      true
+#    end
+  end
+end
+
+module TestMethods
+  def assert_exception(ex, msg=nil, &block)
+    assert_raise(ex, msg, &block)
+  end
+end

data/test/session_functional.rb

@@ -8,6 +8,7 @@ require 'test/unit'
 require 'fileutils'
 require 'session'
 require 'test/in_environment'
+require 'test/rake_test_setup'
 
 # Version 2.1.9 of session has a bug where the @debug instance
 # variable is not initialized, causing warning messages.  This snippet
@@ -24,6 +25,7 @@ end
 
 class FunctionalTest < Test::Unit::TestCase
   include InEnvironment
+  include TestMethods
 
   RUBY_COMMAND = 'ruby'
 

data/test/test_application.rb

@@ -18,6 +18,7 @@ TESTING_REQUIRE = [ ]
 class TestApplication < Test::Unit::TestCase
   include CaptureStdout
   include InEnvironment
+  include TestMethods
 
   def setup
     @app = Rake::Application.new
@@ -109,7 +110,7 @@ class TestApplication < Test::Unit::TestCase
   end
 
   def test_finding_rakefile
-    assert_match(/[Rr]akefile/, @app.instance_eval { have_rakefile })
+    assert_match(/Rakefile/i, @app.instance_eval { have_rakefile })
   end
 
   def test_not_finding_rakefile
@@ -148,7 +149,7 @@ class TestApplication < Test::Unit::TestCase
         handle_options
         options.silent = true
       end
-      ex = assert_raise(RuntimeError) do 
+      ex = assert_exception(RuntimeError) do 
         @app.instance_eval do raw_load_rakefile end 
       end
       assert_match(/no rakefile found/i, ex.message)
@@ -162,6 +163,7 @@ class TestApplication < Test::Unit::TestCase
         handle_options
         options.silent = true
         options.load_system = true
+        options.rakelib = []
         load_rakefile
       end
       assert_equal "test/data/sys", @app.system_dir
@@ -169,46 +171,10 @@ class TestApplication < Test::Unit::TestCase
     end
   end
 
-  def test_load_from_system_rakefile_on_unix
-    flexmock(@app, :windows? => false,
-      :win32_system_dir => nil,
-      :load => nil)
-    flexmock(File).should_receive(:expand_path).with("~").and_return("/HOME")
-    flexmock(File).should_receive(:expand_path).and_return { |fn| fn }
-    
-    in_environment('RAKE_SYSTEM' => nil) do
-      @app.options.rakelib = []
-      @app.instance_eval do
-        handle_options
-        options.silent = true
-        options.load_system = true
-        load_rakefile
-      end
-      assert_equal "/HOME/.rake", @app.system_dir
-    end
-  end
-
   def test_windows
     assert ! (@app.windows? && @app.unix?)
   end
 
-  def test_load_from_system_rakefile_on_windows
-    flexmock(Rake::Win32, :windows? => true)
-    flexmock(@app, :standard_system_dir => "XX")
-    flexmock(@app).should_receive(:directory?).with("/AD/Rake").and_return(true)
-    flexmock(@app).should_receive(:load).and_return(nil)
-    in_environment('RAKE_SYSTEM' => nil, 'APPDATA' => '/AD') do
-      @app.options.rakelib = []
-      @app.instance_eval do
-        handle_options
-        options.silent = true
-        options.load_system = true
-        load_rakefile
-      end
-      assert_equal "/AD/Rake", @app.system_dir
-    end
-  end
-
   def test_loading_imports
     mock = flexmock("loader")
     mock.should_receive(:load).with("x.dummy").once
@@ -231,6 +197,19 @@ class TestApplication < Test::Unit::TestCase
     end
   end
 
+  def test_handle_options_should_strip_options_from_ARGV
+    assert !@app.options.trace
+
+    valid_option = '--trace'
+    ARGV.clear
+    ARGV << valid_option
+
+    @app.handle_options
+
+    assert !ARGV.include?(valid_option)
+    assert @app.options.trace
+  end
+
   def test_good_run
     ran = false
     ARGV.clear
@@ -279,7 +258,7 @@ class TestApplication < Test::Unit::TestCase
     @app.intern(Rake::Task, "default").enhance { fail }
     ARGV.clear
     ARGV << '-f' << '-s' <<  '--rakelib=""'
-    assert_raise(SystemExit) {
+    assert_exception(SystemExit) {
       err = capture_stderr { @app.run }
       assert_match(/see full trace/, err)
     }
@@ -291,7 +270,7 @@ class TestApplication < Test::Unit::TestCase
     @app.intern(Rake::Task, "default").enhance { fail }
     ARGV.clear
     ARGV << '-f' << '-s' << '-t'
-    assert_raise(SystemExit) {
+    assert_exception(SystemExit) {
       err = capture_stderr { capture_stdout { @app.run } }
       assert_no_match(/see full trace/, err)
     }
@@ -303,7 +282,7 @@ class TestApplication < Test::Unit::TestCase
     @app.intern(Rake::Task, "default").enhance { fail }
     ARGV.clear
     ARGV << '-f' << '-s' << '--xyzzy'
-    assert_raise(SystemExit) {
+    assert_exception(SystemExit) {
       err = capture_stderr { capture_stdout { @app.run } }
     }
   ensure
@@ -315,6 +294,7 @@ end
 ######################################################################
 class TestApplicationOptions < Test::Unit::TestCase
   include CaptureStdout
+  include TestMethods
 
   def setup
     clear_argv
@@ -447,7 +427,7 @@ class TestApplicationOptions < Test::Unit::TestCase
   end
 
   def test_missing_require
-    ex = assert_raises(LoadError) do
+    ex = assert_exception(LoadError) do
       flags(['--require', 'test/missing']) do |opts|
       end
     end
@@ -546,7 +526,7 @@ class TestApplicationOptions < Test::Unit::TestCase
 
   def test_bad_option
     capture_stderr do
-      ex = assert_raise(OptionParser::InvalidOption) do
+      ex = assert_exception(OptionParser::InvalidOption) do
         flags('--bad-option') 
       end
       if ex.message =~ /^While/ # Ruby 1.9 error message
@@ -594,7 +574,8 @@ class TestApplicationOptions < Test::Unit::TestCase
       throw :system_exit, :exit
     end
     @app.instance_eval do
-      collect_tasks handle_options
+      handle_options
+      collect_tasks
     end
     @tasks = @app.top_level_tasks
     @app.options

data/test/test_definitions.rb

@@ -4,10 +4,13 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestDefinitions < Test::Unit::TestCase
   include Rake
+  include TestMethods
+  
   EXISTINGFILE = "testdata/existing"
 
   def setup
@@ -58,7 +61,7 @@ class TestDefinitions < Test::Unit::TestCase
 
   def test_missing_dependencies
     task :x => ["testdata/missing"]
-    assert_raises(RuntimeError) { Task[:x].invoke }
+    assert_exception(RuntimeError) { Task[:x].invoke }
   end
 
   def test_implicit_file_dependencies

data/test/test_file_task.rb

@@ -4,11 +4,13 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestFileTask < Test::Unit::TestCase
   include Rake
   include FileCreation
+  include TestMethods
 
   def setup
     Task.clear
@@ -118,22 +120,24 @@ class TestDirectoryTask < Test::Unit::TestCase
     assert ! File.exist?("testdata/a/b/c")
   end
 
-  def test_directory_win32
-    desc "WIN32 DESC"
-    FileUtils.mkdir_p("testdata")
-    Dir.chdir("testdata") do
-      directory 'c:/testdata/a/b/c'
-      assert_equal FileCreationTask, Task['c:/testdata'].class
-      assert_equal FileCreationTask, Task['c:/testdata/a'].class
-      assert_equal FileCreationTask, Task['c:/testdata/a/b/c'].class
-      assert_nil             Task['c:/testdata'].comment
-      assert_equal "WIN32 DESC",   Task['c:/testdata/a/b/c'].comment
-      assert_nil             Task['c:/testdata/a/b'].comment
-      verbose(false) {
-        Task['c:/testdata/a/b'].invoke
-      }
-      assert File.exist?('c:/testdata/a/b')
-      assert ! File.exist?('c:/testdata/a/b/c')
+  if Rake::Win32.windows?
+    def test_directory_win32
+      desc "WIN32 DESC"
+      FileUtils.mkdir_p("testdata")
+      Dir.chdir("testdata") do
+        directory 'c:/testdata/a/b/c'
+        assert_equal FileCreationTask, Task['c:/testdata'].class
+        assert_equal FileCreationTask, Task['c:/testdata/a'].class
+        assert_equal FileCreationTask, Task['c:/testdata/a/b/c'].class
+        assert_nil             Task['c:/testdata'].comment
+        assert_equal "WIN32 DESC",   Task['c:/testdata/a/b/c'].comment
+        assert_nil             Task['c:/testdata/a/b'].comment
+        verbose(false) {
+          Task['c:/testdata/a/b'].invoke
+        }
+        assert File.exist?('c:/testdata/a/b')
+        assert ! File.exist?('c:/testdata/a/b/c')
+      end
     end
   end
 end

data/test/test_filelist.rb

@@ -4,10 +4,12 @@ require 'test/unit'
 require 'rake'
 
 require 'test/capture_stdout'
+require 'test/rake_test_setup'
 
 class TestFileList < Test::Unit::TestCase
   FileList = Rake::FileList
   include CaptureStdout
+  include TestMethods
 
   def setup
     create_test_data
@@ -283,9 +285,7 @@ class TestFileList < Test::Unit::TestCase
     assert_equal "one.two.net", "one.two.c".ext(".net")
     assert_equal "one/two.net", "one/two.c".ext(".net")
     assert_equal "one.x/two.net", "one.x/two.c".ext(".net")
-    assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net")
     assert_equal "one.x/two.net", "one.x/two".ext(".net")
-    assert_equal "one.x\\two.net", "one.x\\two".ext(".net")
     assert_equal ".onerc.net", ".onerc.dot".ext("net")
     assert_equal ".onerc.net", ".onerc".ext("net")
     assert_equal ".a/.onerc.net", ".a/.onerc".ext("net")
@@ -295,6 +295,11 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ".one", ".one".ext
     assert_equal ".", ".".ext("c")
     assert_equal "..", "..".ext("c")
+    # These only need to work in windows
+    if Rake::Win32.windows?
+      assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net")
+      assert_equal "one.x\\two.net", "one.x\\two".ext(".net")
+    end
   end
 
   def test_filelist_ext
@@ -442,7 +447,7 @@ class TestFileList < Test::Unit::TestCase
     a = FileList['a', 'b', 'c']
     a.freeze
     c = a.clone
-    assert_raise(TypeError, RuntimeError) do
+    assert_exception(TypeError, RuntimeError) do
       c << 'more'
     end
   end

data/test/test_fileutils.rb

@@ -5,9 +5,11 @@ require 'test/unit'
 require 'test/filecreation'
 require 'fileutils'
 require 'stringio'
+require 'test/rake_test_setup'
 
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
+  include TestMethods
 
   def setup
     File.chmod(0750,"test/shellcommand.rb")
@@ -81,7 +83,7 @@ class TestFileUtils < Test::Unit::TestCase
   def test_safe_ln_fails_on_script_error
     FileUtils::LN_SUPPORTED[0] = true
     c = BadLink.new(ScriptError)
-    assert_raise(ScriptError) do c.safe_ln "a", "b" end
+    assert_exception(ScriptError) do c.safe_ln "a", "b" end
   end
 
   def test_verbose
@@ -114,8 +116,8 @@ class TestFileUtils < Test::Unit::TestCase
 
   def test_fileutils_methods_dont_leak
     obj = Object.new
-    assert_raise(NoMethodError) { obj.copy } # from FileUtils
-    assert_raise(NoMethodError) { obj.ruby } # from RubyFileUtils
+    assert_exception(NoMethodError) { obj.copy } # from FileUtils
+    assert_exception(NoMethodError) { obj.ruby } # from RubyFileUtils
   end
 
   def test_sh
@@ -123,21 +125,37 @@ class TestFileUtils < Test::Unit::TestCase
     assert true, "should not fail"
   end
 
-  def test_sh_multiple_arguments
+  # If the :sh method is invoked directly from a test unit instance
+  # (under mini/test), the mini/test version of fail is invoked rather
+  # than the kernel version of fail. So we run :sh from within a
+  # non-test class to avoid the problem.
+  class Sh
+    include FileUtils
+    def run(*args)
+      sh(*args)
+    end
+    def self.run(*args)
+      new.run(*args)
+    end
+  end
+
+  def test_sh_with_a_single_string_argument
     ENV['RAKE_TEST_SH'] = 'someval'
-    expanded = windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
-    # This one gets expanded by the shell
-    verbose(false) { sh %{ruby test/check_expansion.rb #{expanded} someval} }
-    assert true, "should not fail"
-    assert_raises(RuntimeError) {
-      # This one does not get expanded
-      verbose(false) { sh 'ruby', 'test/check_expansion.rb', expanded, 'someval' }
+    verbose(false) {
+      sh %{ruby test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_sh_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      Sh.run 'ruby', 'test/check_no_expansion.rb', env_var, 'someval'
     }
   end
 
   def test_sh_failure
-    assert_raises(RuntimeError) { 
-      verbose(false) { sh %{ruby test/shellcommand.rb 1} }
+    assert_exception(RuntimeError) { 
+      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
     }
   end
 
@@ -164,7 +182,7 @@ class TestFileUtils < Test::Unit::TestCase
   end
 
   def test_sh_bad_option
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
     }
     assert_match(/bad_option/, ex.message)
@@ -188,39 +206,18 @@ class TestFileUtils < Test::Unit::TestCase
     assert_equal '', out
   end
 
-  def test_sh_default_is_no_verbose
-    out = redirect_stderr {
-      sh %{test/shellcommand.rb}, :noop=>true
+  def test_ruby_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby %{test/check_expansion.rb #{env_var} someval}
     }
-    assert_equal '', out
   end
 
-  def test_ruby
-    verbose(false) do
-      ENV['RAKE_TEST_RUBY'] = "123"
-      block_run = false
-      # This one gets expanded by the shell
-      env_var = windows? ? '%RAKE_TEST_RUBY%' : '$RAKE_TEST_RUBY'
-      ruby %{-e "exit #{env_var}"} do |ok, status| # " (emacs wart)
-        assert(!ok)
-        assert_equal 123, status.exitstatus
-        block_run = true
-      end
-      assert block_run, "The block must be run"
-
-      if windows?
-        puts "SKIPPING test_ruby/part 2 when in windows"
-      else
-        # This one does not get expanded
-        block_run = false
-        ruby '-e', %{exit "#{env_var}".length} do |ok, status| # " (emacs wart)
-          assert(!ok)
-          assert_equal 15, status.exitstatus
-          block_run = true
-        end
-        assert block_run, "The block must be run"
-      end
-    end
+  def test_ruby_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby 'test/check_no_expansion.rb', env_var, 'someval'
+    }
   end
 
   def test_split_all
@@ -247,4 +244,8 @@ class TestFileUtils < Test::Unit::TestCase
     ! File::ALT_SEPARATOR.nil?
   end
 
+  def env_var
+    windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
+  end
+  
 end