summaryrefslogtreecommitdiff
path: root/test/rake/test_rake_task.rb
diff options
context:
space:
mode:
authorhsbt <hsbt@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2015-04-04 12:31:31 +0000
committerhsbt <hsbt@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2015-04-04 12:31:31 +0000
commitc4ee0df8ba2cf7cc6aaa785c8df20a91b1719021 (patch)
tree06beca468cce4a75a3e9890d18aa001ef2c41e54 /test/rake/test_rake_task.rb
parent8c0b2a286080609613b6b007e030ff7c7adaa23c (diff)
* lib/rake/*: Gemify rake [fix GH-862][Feature #11025]
* test/rake/*: ditto. * tool/rbinstall.rb: ditto. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@50163 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'test/rake/test_rake_task.rb')
-rw-r--r--test/rake/test_rake_task.rb393
1 files changed, 0 insertions, 393 deletions
diff --git a/test/rake/test_rake_task.rb b/test/rake/test_rake_task.rb
deleted file mode 100644
index 0416dfa8ddf..00000000000
--- a/test/rake/test_rake_task.rb
+++ /dev/null
@@ -1,393 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'fileutils'
-
-class TestRakeTask < Rake::TestCase
- include Rake
-
- def setup
- super
-
- Task.clear
- Rake::TaskManager.record_task_metadata = true
- end
-
- def teardown
- Rake::TaskManager.record_task_metadata = false
- Rake.application.thread_pool.join
-
- super
- end
-
- def test_create
- arg = nil
- t = task(:name) { |task| arg = task; 1234 }
- assert_equal "name", t.name
- assert_equal [], t.prerequisites
- assert t.needed?
- t.execute(0)
- assert_equal t, arg
- assert_nil t.source
- assert_equal [], t.sources
- assert_equal 1, t.locations.size
- assert_match(/#{Regexp.quote(__FILE__)}/, t.locations.first)
- end
-
- def test_inspect
- t = task(:foo => [:bar, :baz])
- assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
- end
-
- def test_invoke
- runlist = []
- t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
- task(:t2) { |t| runlist << t.name }
- task(:t3) { |t| runlist << t.name }
- assert_equal ["t2", "t3"], t1.prerequisites
- t1.invoke
- assert_equal ["t2", "t3", "t1"], runlist
- end
-
- def test_invoke_with_circular_dependencies
- runlist = []
- t1 = task(:t1 => [:t2]) { |t| runlist << t.name; 3321 }
- t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
- assert_equal ["t2"], t1.prerequisites
- assert_equal ["t1"], t2.prerequisites
- ex = assert_raises RuntimeError do
- t1.invoke
- end
- assert_match(/circular dependency/i, ex.message)
- assert_match(/t1 => t2 => t1/, ex.message)
- end
-
- def test_dry_run_prevents_actions
- Rake.application.options.dryrun = true
- runlist = []
- t1 = task(:t1) { |t| runlist << t.name; 3321 }
- _, err = capture_io { t1.invoke }
- assert_match(/execute .*t1/i, err)
- assert_match(/dry run/i, err)
- refute_match(/invoke/i, err)
- assert_equal [], runlist
- ensure
- Rake.application.options.dryrun = false
- end
-
- def test_tasks_can_be_traced
- Rake.application.options.trace = true
- t1 = task(:t1)
- _, err = capture_io {
- t1.invoke
- }
- assert_match(/invoke t1/i, err)
- assert_match(/execute t1/i, err)
- ensure
- Rake.application.options.trace = false
- end
-
- def test_no_double_invoke
- runlist = []
- t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
- task(:t2 => [:t3]) { |t| runlist << t.name }
- task(:t3) { |t| runlist << t.name }
- t1.invoke
- assert_equal ["t3", "t2", "t1"], runlist
- end
-
- def test_can_double_invoke_with_reenable
- runlist = []
- t1 = task(:t1) { |t| runlist << t.name }
- t1.invoke
- t1.reenable
- t1.invoke
- assert_equal ["t1", "t1"], runlist
- end
-
- def test_clear
- desc "a task"
- t = task("t" => "a") { }
- t.clear
- assert t.prerequisites.empty?, "prerequisites should be empty"
- assert t.actions.empty?, "actions should be empty"
- assert_nil t.comment, "comments should be empty"
- end
-
- def test_clear_prerequisites
- t = task("t" => ["a", "b"])
- assert_equal ['a', 'b'], t.prerequisites
- t.clear_prerequisites
- assert_equal [], t.prerequisites
- end
-
- def test_clear_actions
- t = task("t") { }
- t.clear_actions
- assert t.actions.empty?, "actions should be empty"
- end
-
- def test_clear_comments
- desc "the original foo"
- task :foo => [:x] do
- # Dummy action
- end
-
- task(:foo).clear_comments
-
- desc "a slightly different foo"
- task :foo
-
- assert_equal "a slightly different foo", task(:foo).comment
- assert_equal ["x"], task(:foo).prerequisites
- assert_equal 1, task(:foo).actions.size
- end
-
- def test_find
- task :tfind
- assert_equal "tfind", Task[:tfind].name
- ex = assert_raises(RuntimeError) { Task[:leaves] }
- assert_equal "Don't know how to build task 'leaves'", ex.message
- end
-
- def test_defined
- assert ! Task.task_defined?(:a)
- task :a
- assert Task.task_defined?(:a)
- end
-
- def test_multi_invocations
- runs = []
- p = proc do |t| runs << t.name end
- task({ :t1 => [:t2, :t3] }, &p)
- task({ :t2 => [:t3] }, &p)
- task(:t3, &p)
- Task[:t1].invoke
- assert_equal ["t1", "t2", "t3"], runs.sort
- end
-
- def test_task_list
- task :t2
- task :t1 => [:t2]
- assert_equal ["t1", "t2"], Task.tasks.map { |t| t.name }
- end
-
- def test_task_gives_name_on_to_s
- task :abc
- assert_equal "abc", Task[:abc].to_s
- end
-
- def test_symbols_can_be_prerequisites
- task :a => :b
- assert_equal ["b"], Task[:a].prerequisites
- end
-
- def test_strings_can_be_prerequisites
- task :a => "b"
- assert_equal ["b"], Task[:a].prerequisites
- end
-
- def test_arrays_can_be_prerequisites
- task :a => ["b", "c"]
- assert_equal ["b", "c"], Task[:a].prerequisites
- end
-
- def test_filelists_can_be_prerequisites
- task :a => FileList.new.include("b", "c")
- assert_equal ["b", "c"], Task[:a].prerequisites
- end
-
- def test_prerequisite_tasks_returns_tasks_not_strings
- a = task :a => ["b", "c"]
- b = task :b
- c = task :c
- assert_equal [b, c], a.prerequisite_tasks
- end
-
- def test_prerequisite_tasks_fails_if_prerequisites_are_undefined
- a = task :a => ["b", "c"]
- task :b
- assert_raises(RuntimeError) do
- a.prerequisite_tasks
- end
- end
-
- def test_prerequisite_tasks_honors_namespaces
- a = b = nil
- namespace "X" do
- a = task :a => ["b", "c"]
- b = task :b
- end
- c = task :c
-
- assert_equal [b, c], a.prerequisite_tasks
- end
-
- def test_all_prerequisite_tasks_includes_all_prerequisites
- a = task :a => "b"
- b = task :b => ["c", "d"]
- c = task :c => "e"
- d = task :d
- e = task :e
-
- assert_equal [b, c, d, e], a.all_prerequisite_tasks.sort_by { |t| t.name }
- end
-
- def test_all_prerequisite_tasks_does_not_include_duplicates
- a = task :a => ["b", "c"]
- b = task :b => "c"
- c = task :c
-
- assert_equal [b, c], a.all_prerequisite_tasks.sort_by { |t| t.name }
- end
-
- def test_all_prerequisite_tasks_includes_self_on_cyclic_dependencies
- a = task :a => "b"
- b = task :b => "a"
-
- assert_equal [a, b], a.all_prerequisite_tasks.sort_by { |t| t.name }
- end
-
- def test_timestamp_returns_now_if_all_prereqs_have_no_times
- a = task :a => ["b", "c"]
- task :b
- task :c
-
- assert_in_delta Time.now, a.timestamp, 0.1, 'computer too slow?'
- end
-
- def test_timestamp_returns_latest_prereq_timestamp
- a = task :a => ["b", "c"]
- b = task :b
- c = task :c
-
- now = Time.now
- def b.timestamp() Time.now + 10 end
- def c.timestamp() Time.now + 5 end
-
- assert_in_delta now, a.timestamp, 0.1, 'computer too slow?'
- end
-
- def test_always_multitask
- mx = Mutex.new
- result = []
-
- t_a = task(:a) do |t|
- sleep 0.2
- mx.synchronize { result << t.name }
- end
-
- t_b = task(:b) do |t|
- mx.synchronize { result << t.name }
- end
-
- t_c = task(:c => [:a, :b]) do |t|
- mx.synchronize { result << t.name }
- end
-
- t_c.invoke
-
- # task should always run in order
- assert_equal ['a', 'b', 'c'], result
-
- [t_a, t_b, t_c].each { |t| t.reenable }
- result.clear
-
- Rake.application.options.always_multitask = true
- t_c.invoke
-
- # with multitask, task 'b' should grab the mutex first
- assert_equal ['b', 'a', 'c'], result
- end
-
- def test_investigation_output
- t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
- task(:t2)
- task(:t3)
- out = t1.investigation
- assert_match(/class:\s*Rake::Task/, out)
- assert_match(/needed:\s*true/, out)
- assert_match(/pre-requisites:\s*--t[23]/, out)
- end
-
- # NOTE: Rail-ties uses comment=.
- def test_comment_setting
- t = task(:t, :name, :rev)
- t.comment = "A Comment"
- assert_equal "A Comment", t.comment
- end
-
- def test_comments_with_sentences
- desc "Comment 1. Comment 2."
- t = task(:t, :name, :rev)
- assert_equal "Comment 1", t.comment
- end
-
- def test_comments_with_tabbed_sentences
- desc "Comment 1.\tComment 2."
- t = task(:t, :name, :rev)
- assert_equal "Comment 1", t.comment
- end
-
- def test_comments_with_decimal_points
- desc "Revision 1.2.3."
- t = task(:t, :name, :rev)
- assert_equal "Revision 1.2.3", t.comment
- end
-
- def test_comments_do_not_set
- t = task(:t, :name, :rev)
- assert_equal nil, t.comment
- end
-
- def test_comments_is_nil
- t = task(:t, :name, :rev)
- t.comment = nil
- assert_equal nil, t.comment
- end
-
- def test_extended_comments
- desc %{
- This is a comment.
-
- And this is the extended comment.
- name -- Name of task to execute.
- rev -- Software revision to use.
- }
- t = task(:t, :name, :rev)
- assert_equal "[name,rev]", t.arg_description
- assert_equal "This is a comment", t.comment
- assert_match(/^\s*name -- Name/, t.full_comment)
- assert_match(/^\s*rev -- Software/, t.full_comment)
- assert_match(/\A\s*This is a comment\.$/, t.full_comment)
- end
-
- def test_multiple_comments
- desc "line one"
- t = task(:t)
- desc "line two"
- task(:t)
- assert_equal "line one / line two", t.comment
- end
-
- def test_duplicate_comments
- desc "line one"
- t = task(:t)
- desc "line one"
- task(:t)
- assert_equal "line one", t.comment
- end
-
- def test_interspersed_duplicate_comments
- desc "line one"
- t = task(:t)
- desc "line two"
- task(:t)
- desc "line one"
- task(:t)
- assert_equal "line one / line two", t.comment
- end
-
- def test_source_is_first_prerequisite
- t = task :t => ["preqA", "preqB"]
- assert_equal "preqA", t.source
- end
-end