hatena_bookmark_client_for_ruby 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_test_task.rb

@@ -0,0 +1,146 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/testtask'
+
+class TestRakeTestTask < Rake::TestCase
+  include Rake
+
+  def test_initialize
+    tt = Rake::TestTask.new do |t| end
+    refute_nil tt
+    assert_equal :test, tt.name
+    assert_equal ['lib'], tt.libs
+    assert_equal 'test/test*.rb', tt.pattern
+    assert_equal false, tt.verbose
+    assert Task.task_defined?(:test)
+  end
+
+  def test_initialize_override
+    tt = Rake::TestTask.new(:example) do |t|
+      t.description = "Run example tests"
+      t.libs = ['src', 'ext']
+      t.pattern = 'test/tc_*.rb'
+      t.verbose = true
+    end
+    refute_nil tt
+    assert_equal "Run example tests", tt.description
+    assert_equal :example, tt.name
+    assert_equal ['src', 'ext'], tt.libs
+    assert_equal 'test/tc_*.rb', tt.pattern
+    assert_equal true, tt.verbose
+    assert Task.task_defined?(:example)
+  end
+
+  def test_file_list_env_test
+    ENV['TEST'] = 'testfile.rb'
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*'
+    end
+
+    assert_equal ["testfile.rb"], tt.file_list.to_a
+  ensure
+    ENV.delete 'TEST'
+  end
+
+  def test_libs_equals
+    test_task = Rake::TestTask.new do |t|
+      t.libs << ["A", "B"]
+    end
+
+    path = %w[lib A B].join File::PATH_SEPARATOR
+
+    assert_equal "-I\"#{path}\"", test_task.ruby_opts_string
+  end
+
+  def test_libs_equals_empty
+    test_task = Rake::TestTask.new do |t|
+      t.libs = []
+    end
+
+    assert_equal '', test_task.ruby_opts_string
+  end
+
+  def test_pattern_equals
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*.rb'
+    end
+    assert_equal ['*.rb'], tt.file_list.to_a
+  end
+
+  def test_pattern_equals_test_files_equals
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+      t.pattern = '*.rb'
+    end
+    assert_equal ['a.rb', 'b.rb', '*.rb'], tt.file_list.to_a
+  end
+
+  def test_run_code_direct
+    test_task = Rake::TestTask.new do |t|
+      t.loader = :direct
+    end
+
+    assert_equal '-e "ARGV.each{|f| require f}"', test_task.run_code
+  end
+
+  def test_run_code_rake
+    spec = Gem::Specification.new 'rake', 0
+    spec.loaded_from = File.join Gem::Specification.dirs.last, 'rake-0.gemspec'
+    rake, Gem.loaded_specs['rake'] = Gem.loaded_specs['rake'], spec
+
+    test_task = Rake::TestTask.new do |t|
+      t.loader = :rake
+    end
+
+    assert_match(/\A-I".*?" ".*?"\Z/, test_task.run_code)
+  ensure
+    Gem.loaded_specs['rake'] = rake
+  end
+
+  def test_run_code_rake_default_gem
+    skip 'this ruby does not have default gems' unless
+      Gem::Specification.method_defined? :default_specifications_dir
+
+    default_spec = Gem::Specification.new 'rake', 0
+    default_spec.loaded_from = File.join Gem::Specification.default_specifications_dir, 'rake-0.gemspec'
+    begin
+      rake, Gem.loaded_specs['rake'] = Gem.loaded_specs['rake'], default_spec
+
+      test_task = Rake::TestTask.new do |t|
+        t.loader = :rake
+      end
+
+      assert_match(/\A(-I".*?" *)* ".*?"\Z/, test_task.run_code)
+    ensure
+      Gem.loaded_specs['rake'] = rake
+    end
+  end
+
+  def test_run_code_testrb_ruby_1_8_2
+    test_task = Rake::TestTask.new do |t|
+      t.loader = :testrb
+    end
+
+    def test_task.ruby_version() '1.8.2' end
+
+    assert_match(/^-S testrb +".*"$/, test_task.run_code)
+  end
+
+  def test_run_code_testrb_ruby_1_8_6
+    test_task = Rake::TestTask.new do |t|
+      t.loader = :testrb
+    end
+
+    def test_task.ruby_version() '1.8.6' end
+
+    assert_match(/^-S testrb +$/, test_task.run_code)
+  end
+
+  def test_test_files_equals
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+    end
+
+    assert_equal ["a.rb", 'b.rb'], tt.file_list.to_a
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_thread_pool.rb

@@ -0,0 +1,145 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/thread_pool'
+
+class TestRakeTestThreadPool < Rake::TestCase
+  include Rake
+
+  def test_pool_executes_in_current_thread_for_zero_threads
+    pool = ThreadPool.new(0)
+    f = pool.future { Thread.current }
+    pool.join
+    assert_equal Thread.current, f.value
+  end
+
+  def test_pool_executes_in_other_thread_for_pool_of_size_one
+    pool = ThreadPool.new(1)
+    f = pool.future { Thread.current }
+    pool.join
+    refute_equal Thread.current, f.value
+  end
+
+  def test_pool_executes_in_two_other_threads_for_pool_of_size_two
+    pool = ThreadPool.new(2)
+    threads = 2.times.map {
+      pool.future {
+        sleep 0.1
+        Thread.current
+      }
+    }.each { |f|
+      f.value
+    }
+
+    refute_equal threads[0], threads[1]
+    refute_equal Thread.current, threads[0]
+    refute_equal Thread.current, threads[1]
+  ensure
+    pool.join
+  end
+
+  def test_pool_creates_the_correct_number_of_threads
+    pool = ThreadPool.new(2)
+    threads = Set.new
+    t_mutex = Mutex.new
+    10.times.each do
+      pool.future do
+        sleep 0.02
+        t_mutex.synchronize { threads << Thread.current }
+      end
+    end
+    pool.join
+    assert_equal 2, threads.count
+  end
+
+  def test_pool_future_does_not_duplicate_arguments
+    pool = ThreadPool.new(2)
+    obj = Object.new
+    captured = nil
+    pool.future(obj) { |var| captured = var }
+    pool.join
+    assert_equal obj, captured
+  end
+
+  def test_pool_join_empties_queue
+    pool = ThreadPool.new(2)
+    repeat = 25
+    repeat.times {
+      pool.future do
+        repeat.times {
+          pool.future do
+            repeat.times {
+              pool.future do end
+            }
+          end
+        }
+      end
+    }
+
+    pool.join
+    assert_equal(
+      true,
+      pool.__send__(:__queue__).empty?,
+      "queue should be empty")
+  end
+
+  CustomError = Class.new(StandardError)
+
+  # test that throwing an exception way down in the blocks propagates
+  # to the top
+  def test_exceptions
+    pool = ThreadPool.new(10)
+
+    deep_exception_block = lambda do |count|
+      raise CustomError if count < 1
+      pool.future(count - 1, &deep_exception_block).value
+    end
+
+    assert_raises(CustomError) do
+      pool.future(2, &deep_exception_block).value
+    end
+  ensure
+    pool.join
+  end
+
+  def test_pool_prevents_deadlock
+    pool = ThreadPool.new(5)
+
+    common_dependency_a = pool.future { sleep 0.2 }
+    futures_a = 10.times.map {
+      pool.future {
+        common_dependency_a.value
+        sleep(rand() * 0.01)
+      }
+    }
+
+    common_dependency_b = pool.future { futures_a.each { |f| f.value } }
+    futures_b = 10.times.map {
+      pool.future {
+        common_dependency_b.value
+        sleep(rand() * 0.01)
+      }
+    }
+
+    futures_b.each { |f| f.value }
+    pool.join
+  end
+
+  def test_pool_reports_correct_results
+    pool = ThreadPool.new(7)
+
+    a = 18
+    b = 5
+    c = 3
+
+    result = a.times.map do
+      pool.future do
+        b.times.map do
+          pool.future { sleep rand * 0.001; c }
+        end.reduce(0) { |m, f| m + f.value }
+      end
+    end.reduce(0) { |m, f| m + f.value }
+
+    assert_equal a * b * c, result
+    pool.join
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_top_level_functions.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTopLevelFunctions < Rake::TestCase
+
+  def setup
+    super
+
+    @app = Object.new
+
+    def @app.called
+      @called
+    end
+
+    def @app.method_missing(*a, &b)
+      @called ||= []
+      @called << [a, b]
+      nil
+    end
+
+    Rake.application = @app
+  end
+
+  def test_namespace
+    block = proc do end
+
+    namespace("xyz", &block)
+
+    expected = [
+      [[:in_namespace, 'xyz'], block]
+    ]
+
+    assert_equal expected, @app.called
+  end
+
+  def test_import
+    import('x', 'y', 'z')
+
+    expected = [
+      [[:add_import, 'x'], nil],
+      [[:add_import, 'y'], nil],
+      [[:add_import, 'z'], nil],
+    ]
+
+    assert_equal expected, @app.called
+  end
+
+  def test_when_writing
+    out, = capture_io do
+      when_writing("NOTWRITING") do
+        puts "WRITING"
+      end
+    end
+    assert_equal "WRITING\n", out
+  end
+
+  def test_when_not_writing
+    Rake::FileUtilsExt.nowrite_flag = true
+    _, err = capture_io do
+      when_writing("NOTWRITING") do
+        puts "WRITING"
+      end
+    end
+    assert_equal "DRYRUN: NOTWRITING\n", err
+  ensure
+    Rake::FileUtilsExt.nowrite_flag = false
+  end
+
+  def test_missing_other_constant
+    assert_raises(NameError) do Object.const_missing(:Xyz) end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_win32.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeWin32 < Rake::TestCase
+
+  Win32 = Rake::Win32
+
+  def test_win32_system_dir_uses_home_if_defined
+    ENV['HOME'] = 'C:\\HP'
+
+    assert_equal "C:/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined
+    ENV['HOME']      = nil
+    ENV['HOMEDRIVE'] = 'C:'
+    ENV['HOMEPATH']  = '\\HP'
+
+    assert_equal "C:/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo
+    ENV['APPDATA']   = "C:\\Documents and Settings\\HP\\Application Data"
+    ENV['HOME']      = nil
+    ENV['HOMEDRIVE'] = nil
+    ENV['HOMEPATH']  = nil
+
+    assert_equal "C:/Documents and Settings/HP/Application Data/Rake",
+                 Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_fallback_to_userprofile_otherwise
+    ENV['HOME']        = nil
+    ENV['HOMEDRIVE']   = nil
+    ENV['HOMEPATH']    = nil
+    ENV['APPDATA']     = nil
+    ENV['USERPROFILE'] = "C:\\Documents and Settings\\HP"
+
+    assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir
+  end
+
+  def test_win32_system_dir_nil_of_no_env_vars
+    ENV['APPDATA']     = nil
+    ENV['HOME']        = nil
+    ENV['HOMEDRIVE']   = nil
+    ENV['HOMEPATH']    = nil
+    ENV['RAKE_SYSTEM'] = nil
+    ENV['USERPROFILE'] = nil
+
+    assert_raises(Rake::Win32::Win32HomeError) do
+      Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_backtrace_with_different_case
+    ex = nil
+    begin
+     raise 'test exception'
+    rescue => ex
+    end
+
+    ex.set_backtrace ['abc', 'rakefile']
+
+    rake = Rake::Application.new
+    rake.options.trace = true
+    rake.instance_variable_set(:@rakefile, 'Rakefile')
+
+    _, err = capture_io { rake.display_error_message(ex) }
+
+    assert_match(/rakefile/, err)
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_thread_history_display.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../helper', __FILE__)
+
+require 'rake/thread_history_display'
+
+class TestThreadHistoryDisplay < Rake::TestCase
+  def setup
+    super
+    @time = 1_000_000
+    @stats = []
+    @display = Rake::ThreadHistoryDisplay.new(@stats)
+  end
+
+  def test_banner
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/Job History/i, out)
+  end
+
+  def test_item_queued
+    @stats << event(:item_queued,  :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+  end
+
+  def test_item_dequeued
+    @stats << event(:item_dequeued,  :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_dequeued +item_id:1$/, out)
+  end
+
+  def test_multiple_items
+    @stats << event(:item_queued,  :item_id => 123)
+    @stats << event(:item_queued,  :item_id => 124)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+    assert_match(/^ *1000001 +A +item_queued +item_id:2$/, out)
+  end
+
+  def test_waiting
+    @stats << event(:waiting, :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +waiting +item_id:1$/, out)
+  end
+
+  def test_continue
+    @stats << event(:continue, :item_id => 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +continue +item_id:1$/, out)
+  end
+
+  def test_thread_deleted
+    @stats << event(
+      :thread_deleted,
+      :deleted_thread => 123_456,
+      :thread_count => 12)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(
+      /^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/,
+      out)
+  end
+
+  def test_thread_created
+    @stats << event(
+      :thread_created,
+      :new_thread => 123_456,
+      :thread_count => 13)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(
+      /^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/,
+      out)
+  end
+
+  private
+
+  def event(type, data = {})
+    result = {
+      :event => type,
+      :time  => @time / 1_000_000.0,
+      :data  => data,
+      :thread => Thread.current.object_id
+    }
+    @time += 1
+    result
+  end
+
+end