allegro_api_client 0.0.1

data/gems/ruby/2.1.0/gems/rake-10.3.2/test/test_rake_scope.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeScope < Rake::TestCase
+  include Rake
+
+  def test_path_against_empty_scope
+    scope = Scope.make
+    assert_equal scope, Scope::EMPTY
+    assert_equal scope.path, ""
+  end
+
+  def test_path_against_one_element
+    scope = Scope.make(:one)
+    assert_equal "one", scope.path
+  end
+
+  def test_path_against_two_elements
+    scope = Scope.make(:inner, :outer)
+    assert_equal "outer:inner", scope.path
+  end
+
+  def test_path_with_task_name
+    scope = Scope.make(:inner, :outer)
+    assert_equal "outer:inner:task", scope.path_with_task_name("task")
+  end
+
+  def test_path_with_task_name_against_empty_scope
+    scope = Scope.make
+    assert_equal "task", scope.path_with_task_name("task")
+  end
+
+  def test_conj_against_two_elements
+    scope = Scope.make.conj("B").conj("A")
+    assert_equal Scope.make("A", "B"), scope
+  end
+
+  def test_trim
+    scope = Scope.make("A", "B")
+    assert_equal scope, scope.trim(0)
+    assert_equal scope.tail, scope.trim(1)
+    assert_equal scope.tail.tail, scope.trim(2)
+    assert_equal scope.tail.tail, scope.trim(3)
+  end
+end

data/gems/ruby/2.1.0/gems/rake-10.3.2/test/test_rake_task.rb

@@ -0,0 +1,392 @@
+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
+
+    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_prerequiste_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_prerequiste_tasks_fails_if_prerequisites_are_undefined
+    a = task :a => ["b", "c"]
+    task :b
+    assert_raises(RuntimeError) do
+      a.prerequisite_tasks
+    end
+  end
+
+  def test_prerequiste_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.02
+      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

data/gems/ruby/2.1.0/gems/rake-10.3.2/test/test_rake_task_argument_parsing.rb

@@ -0,0 +1,109 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskArgumentParsing < Rake::TestCase
+  def setup
+    super
+
+    @app = Rake::Application.new
+  end
+
+  def test_name_only
+    name, args = @app.parse_task_string("name")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_empty_args
+    name, args = @app.parse_task_string("name[]")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_one_argument
+    name, args = @app.parse_task_string("name[one]")
+    assert_equal "name", name
+    assert_equal ["one"], args
+  end
+
+  def test_two_arguments
+    name, args = @app.parse_task_string("name[one,two]")
+    assert_equal "name", name
+    assert_equal ["one", "two"], args
+  end
+
+  def test_can_handle_spaces_between_args
+    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
+    assert_equal "name", name
+    assert_equal ["one", "two", "three", "four"], args
+  end
+
+  def test_keeps_embedded_spaces
+    name, args = @app.parse_task_string("name[a one ana, two]")
+    assert_equal "name", name
+    assert_equal ["a one ana", "two"], args
+  end
+
+  def test_can_handle_commas_in_args
+    name, args = @app.parse_task_string("name[one, two, three_a\\, three_b, four]")
+    assert_equal "name", name
+    assert_equal ["one", "two", "three_a, three_b", "four"], args
+  end
+
+  def test_terminal_width_using_env
+    app = Rake::Application.new
+    app.terminal_columns = 1234
+
+    assert_equal 1234, app.terminal_width
+  end
+
+  def test_terminal_width_using_stty
+    def @app.unix?() true end
+    def @app.dynamic_width_stty() 1235 end
+    def @app.dynamic_width_tput() 0 end
+
+    assert_equal 1235, @app.terminal_width
+  end
+
+  def test_terminal_width_using_tput
+    def @app.unix?() true end
+    def @app.dynamic_width_stty() 0 end
+    def @app.dynamic_width_tput() 1236 end
+
+    assert_equal 1236, @app.terminal_width
+  end
+
+  def test_terminal_width_using_hardcoded_80
+    def @app.unix?() false end
+
+    assert_equal 80, @app.terminal_width
+  end
+
+  def test_terminal_width_with_failure
+    def @app.unix?() raise end
+
+    assert_equal 80, @app.terminal_width
+  end
+
+  def test_no_rakeopt
+    ARGV << '--trace'
+    app = Rake::Application.new
+    app.init
+    assert !app.options.silent
+  end
+
+  def test_rakeopt_with_blank_options
+    ARGV << '--trace'
+    app = Rake::Application.new
+    app.init
+    assert !app.options.silent
+  end
+
+  def test_rakeopt_with_silent_options
+    ENV['RAKEOPT'] = '-s'
+    app = Rake::Application.new
+
+    app.init
+
+    assert app.options.silent
+  end
+end