sb_prime_table 0.1.0

data/vendor/bundle/ruby/2.4.0/gems/rake-10.5.0/test/test_rake_application_options.rb

@@ -0,0 +1,468 @@
+require File.expand_path('../helper', __FILE__)
+
+TESTING_REQUIRE = []
+
+class TestRakeApplicationOptions < Rake::TestCase
+
+  def setup
+    super
+
+    @testkey = ENV['TESTKEY']
+    clear_argv
+    Rake::FileUtilsExt.verbose_flag = false
+    Rake::FileUtilsExt.nowrite_flag = false
+    TESTING_REQUIRE.clear
+  end
+
+  def teardown
+    ENV['TESTKEY'] = @testkey
+    clear_argv
+    Rake::FileUtilsExt.verbose_flag = false
+    Rake::FileUtilsExt.nowrite_flag = false
+
+    super
+  end
+
+  def clear_argv
+    ARGV.pop until ARGV.empty?
+  end
+
+  def test_default_options
+    opts = command_line
+    assert_nil opts.backtrace
+    assert_nil opts.dryrun
+    assert_nil opts.ignore_system
+    assert_nil opts.load_system
+    assert_nil opts.always_multitask
+    assert_nil opts.nosearch
+    assert_equal ['rakelib'], opts.rakelib
+    assert_nil opts.show_prereqs
+    assert_nil opts.show_task_pattern
+    assert_nil opts.show_tasks
+    assert_nil opts.silent
+    assert_nil opts.trace
+    assert_nil opts.thread_pool_size
+    assert_equal ['rakelib'], opts.rakelib
+    assert ! Rake::FileUtilsExt.verbose_flag
+    assert ! Rake::FileUtilsExt.nowrite_flag
+  end
+
+  def test_dry_run
+    flags('--dry-run', '-n') do |opts|
+      assert opts.dryrun
+      assert opts.trace
+      assert Rake::FileUtilsExt.verbose_flag
+      assert Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_describe
+    flags('--describe') do |opts|
+      assert_equal :describe, opts.show_tasks
+      assert_equal(//.to_s, opts.show_task_pattern.to_s)
+    end
+  end
+
+  def test_describe_with_pattern
+    flags('--describe=X') do |opts|
+      assert_equal :describe, opts.show_tasks
+      assert_equal(/X/.to_s, opts.show_task_pattern.to_s)
+    end
+  end
+
+  def test_execute
+    $xyzzy = 0
+    flags('--execute=$xyzzy=1', '-e $xyzzy=1') do |opts|
+      assert_equal 1, $xyzzy
+      assert_equal :exit, @exit
+      $xyzzy = 0
+    end
+  end
+
+  def test_execute_and_continue
+    $xyzzy = 0
+    flags('--execute-continue=$xyzzy=1', '-E $xyzzy=1') do |opts|
+      assert_equal 1, $xyzzy
+      refute_equal :exit, @exit
+      $xyzzy = 0
+    end
+  end
+
+  def test_execute_and_print
+    $xyzzy = 0
+    out, = capture_io do
+      flags('--execute-print=$xyzzy="pugh"', '-p $xyzzy="pugh"') do |opts|
+        assert_equal 'pugh', $xyzzy
+        assert_equal :exit, @exit
+        $xyzzy = 0
+      end
+    end
+
+    assert_match(/^pugh$/, out)
+  end
+
+  def test_help
+    out, = capture_io do
+      flags '--help', '-H', '-h'
+    end
+
+    assert_match(/\Arake/, out)
+    assert_match(/\boptions\b/, out)
+    assert_match(/\btargets\b/, out)
+    assert_equal :exit, @exit
+  end
+
+  def test_jobs
+    flags([]) do |opts|
+      assert_nil opts.thread_pool_size
+    end
+    flags(['--jobs', '0'], ['-j', '0']) do |opts|
+      assert_equal 0, opts.thread_pool_size
+    end
+    flags(['--jobs', '1'], ['-j', '1']) do |opts|
+      assert_equal 0, opts.thread_pool_size
+    end
+    flags(['--jobs', '4'], ['-j', '4']) do |opts|
+      assert_equal 3, opts.thread_pool_size
+    end
+    flags(['--jobs', 'asdas'], ['-j', 'asdas']) do |opts|
+      assert_equal Rake.suggested_thread_count-1, opts.thread_pool_size
+    end
+    flags('--jobs', '-j') do |opts|
+      assert opts.thread_pool_size > 1_000_000, "thread pool size should be huge (was #{opts.thread_pool_size})"
+    end
+  end
+
+  def test_libdir
+    flags(['--libdir', 'xx'], ['-I', 'xx'], ['-Ixx']) do |opts|
+      $:.include?('xx')
+    end
+  ensure
+    $:.delete('xx')
+  end
+
+  def test_multitask
+    flags('--multitask', '-m') do |opts|
+      assert_equal opts.always_multitask, true
+    end
+  end
+
+  def test_rakefile
+    flags(['--rakefile', 'RF'], ['--rakefile=RF'], ['-f', 'RF'], ['-fRF']) do |opts|
+      assert_equal ['RF'], @app.instance_eval { @rakefiles }
+    end
+  end
+
+  def test_rakelib
+    dirs = %w(A B C).join(File::PATH_SEPARATOR)
+    flags(
+      ['--rakelibdir', dirs],
+      ["--rakelibdir=#{dirs}"],
+      ['-R', dirs],
+      ["-R#{dirs}"]) do |opts|
+      assert_equal ['A', 'B', 'C'], opts.rakelib
+    end
+  end
+
+  def test_require
+    $LOAD_PATH.unshift @tempdir
+
+    open 'reqfile.rb',    'w' do |io| io << 'TESTING_REQUIRE << 1' end
+    open 'reqfile2.rb',   'w' do |io| io << 'TESTING_REQUIRE << 2' end
+    open 'reqfile3.rake', 'w' do |io| io << 'TESTING_REQUIRE << 3' end
+
+    flags(['--require', 'reqfile'], '-rreqfile2', '-rreqfile3')
+
+    assert_includes TESTING_REQUIRE, 1
+    assert_includes TESTING_REQUIRE, 2
+    assert_includes TESTING_REQUIRE, 3
+
+    assert_equal 3, TESTING_REQUIRE.size
+  ensure
+    $LOAD_PATH.delete @tempdir
+  end
+
+  def test_missing_require
+    ex = assert_raises(LoadError) do
+      flags(['--require', 'test/missing']) do |opts|
+      end
+    end
+    assert_match(/such file/, ex.message)
+    assert_match(/test\/missing/, ex.message)
+  end
+
+  def test_prereqs
+    flags('--prereqs', '-P') do |opts|
+      assert opts.show_prereqs
+    end
+  end
+
+  def test_quiet
+    Rake::FileUtilsExt.verbose_flag = true
+    flags('--quiet', '-q') do |opts|
+      assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag should be false"
+      assert ! opts.silent, "should not be silent"
+    end
+  end
+
+  def test_no_search
+    flags('--nosearch', '--no-search', '-N') do |opts|
+      assert opts.nosearch
+    end
+  end
+
+  def test_silent
+    Rake::FileUtilsExt.verbose_flag = true
+    flags('--silent', '-s') do |opts|
+      assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag should be false"
+      assert opts.silent, "should be silent"
+    end
+  end
+
+  def test_system
+    flags('--system', '-g') do |opts|
+      assert opts.load_system
+    end
+  end
+
+  def test_no_system
+    flags('--no-system', '-G') do |opts|
+      assert opts.ignore_system
+    end
+  end
+
+  def test_trace
+    flags('--trace', '-t') do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert ! Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_trace_with_stdout
+    flags('--trace=stdout', '-tstdout') do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stdout, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert ! Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_trace_with_stderr
+    flags('--trace=stderr', '-tstderr') do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert ! Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_trace_with_error
+    ex = assert_raises(Rake::CommandLineOptionError) do
+      flags('--trace=xyzzy') do |opts| end
+    end
+    assert_match(/un(known|recognized).*\btrace\b.*xyzzy/i, ex.message)
+  end
+
+  def test_trace_with_following_task_name
+    flags(['--trace', 'taskname'], ['-t', 'taskname']) do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert_equal ['taskname'], @app.top_level_tasks
+    end
+  end
+
+  def test_backtrace
+    flags('--backtrace') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+    end
+  end
+
+  def test_backtrace_with_stdout
+    flags('--backtrace=stdout') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stdout, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+    end
+  end
+
+  def test_backtrace_with_stderr
+    flags('--backtrace=stderr') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+    end
+  end
+
+  def test_backtrace_with_error
+    ex = assert_raises(Rake::CommandLineOptionError) do
+      flags('--backtrace=xyzzy') do |opts| end
+    end
+    assert_match(/un(known|recognized).*\bbacktrace\b.*xyzzy/i, ex.message)
+  end
+
+  def test_backtrace_with_following_task_name
+    flags(['--backtrace', 'taskname']) do |opts|
+      assert ! opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert_equal ['taskname'], @app.top_level_tasks
+    end
+  end
+
+  def test_trace_rules
+    flags('--rules') do |opts|
+      assert opts.trace_rules
+    end
+  end
+
+  def test_tasks
+    flags('--tasks', '-T') do |opts|
+      assert_equal :tasks, opts.show_tasks
+      assert_equal(//.to_s, opts.show_task_pattern.to_s)
+      assert_equal nil, opts.show_all_tasks
+    end
+    flags(['--tasks', 'xyz'], ['-Txyz']) do |opts|
+      assert_equal :tasks, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal nil, opts.show_all_tasks
+    end
+    flags(['--tasks', 'xyz', '--comments']) do |opts|
+      assert_equal :tasks, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal false, opts.show_all_tasks
+    end
+  end
+
+  def test_where
+    flags('--where', '-W') do |opts|
+      assert_equal :lines, opts.show_tasks
+      assert_equal(//.to_s, opts.show_task_pattern.to_s)
+      assert_equal true, opts.show_all_tasks
+    end
+    flags(['--where', 'xyz'], ['-Wxyz']) do |opts|
+      assert_equal :lines, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal true, opts.show_all_tasks
+    end
+    flags(['--where', 'xyz', '--comments'], ['-Wxyz', '--comments']) do |opts|
+      assert_equal :lines, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal false, opts.show_all_tasks
+    end
+  end
+
+  def test_no_deprecated_messages
+    flags('--no-deprecation-warnings', '-X') do |opts|
+      assert opts.ignore_deprecate
+    end
+  end
+
+  def test_verbose
+    capture_io do
+      flags('--verbose', '-v') do |opts|
+        assert Rake::FileUtilsExt.verbose_flag, "verbose should be true"
+        assert ! opts.silent, "opts should not be silent"
+      end
+    end
+  end
+
+  def test_version
+    out, _ = capture_io do
+      flags '--version', '-V'
+    end
+
+    assert_match(/\bversion\b/, out)
+    assert_match(/\b#{RAKEVERSION}\b/, out)
+    assert_equal :exit, @exit
+  end
+
+  def test_bad_option
+    _, err = capture_io do
+      ex = assert_raises(OptionParser::InvalidOption) do
+        flags('--bad-option')
+      end
+
+      if ex.message =~ /^While/ # Ruby 1.9 error message
+        assert_match(/while parsing/i, ex.message)
+      else                      # Ruby 1.8 error message
+        assert_match(/(invalid|unrecognized) option/i, ex.message)
+        assert_match(/--bad-option/, ex.message)
+      end
+    end
+
+    assert_equal '', err
+  end
+
+  def test_task_collection
+    command_line("a", "b")
+    assert_equal ["a", "b"], @tasks.sort
+  end
+
+  def test_default_task_collection
+    command_line()
+    assert_equal ["default"], @tasks
+  end
+
+  def test_environment_definition
+    ENV.delete('TESTKEY')
+    command_line("TESTKEY=12")
+    assert_equal '12', ENV['TESTKEY']
+  end
+
+  def test_multiline_environment_definition
+    ENV.delete('TESTKEY')
+    command_line("TESTKEY=a\nb\n")
+    assert_equal "a\nb\n", ENV['TESTKEY']
+  end
+
+  def test_environment_and_tasks_together
+    ENV.delete('TESTKEY')
+    command_line("a", "b", "TESTKEY=12")
+    assert_equal ["a", "b"], @tasks.sort
+    assert_equal '12', ENV['TESTKEY']
+  end
+
+  def test_rake_explicit_task_library
+    Rake.add_rakelib 'app/task', 'other'
+
+    libs = Rake.application.options.rakelib
+
+    assert libs.include?("app/task")
+    assert libs.include?("other")
+  end
+
+  private
+
+  def flags(*sets)
+    sets.each do |set|
+      ARGV.clear
+
+      @exit = catch(:system_exit) { command_line(*set) }
+
+      yield(@app.options) if block_given?
+    end
+  end
+
+  def command_line(*options)
+    options.each do |opt| ARGV << opt end
+    @app = Rake::Application.new
+    def @app.exit(*args)
+      throw :system_exit, :exit
+    end
+    @app.instance_eval do
+      args = handle_options
+      collect_command_line_tasks(args)
+    end
+    @tasks = @app.top_level_tasks
+    @app.options
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/rake-10.5.0/test/test_rake_backtrace.rb

@@ -0,0 +1,119 @@
+require File.expand_path('../helper', __FILE__)
+require 'open3'
+
+class TestBacktraceSuppression < Rake::TestCase
+  def test_bin_rake_suppressed
+    paths = ["something/bin/rake:12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal [], actual
+  end
+
+  def test_system_dir_suppressed
+    path = RbConfig::CONFIG['rubylibprefix']
+    skip if path.nil?
+    path = File.expand_path path
+
+    paths = [path + ":12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal [], actual
+  end
+
+  def test_near_system_dir_isnt_suppressed
+    path = RbConfig::CONFIG['rubylibprefix']
+    skip if path.nil?
+    path = File.expand_path path
+
+    paths = [" " + path + ":12"]
+
+    actual = Rake::Backtrace.collapse(paths)
+
+    assert_equal paths, actual
+  end
+end
+
+class TestRakeBacktrace < Rake::TestCase
+  include RubyRunner
+
+  def setup
+    super
+
+    skip 'tmpdir is suppressed in backtrace' if
+      Rake::Backtrace::SUPPRESS_PATTERN =~ Dir.pwd
+  end
+
+  def invoke(*args)
+    rake(*args)
+    @err
+  end
+
+  def test_single_collapse
+    rakefile %q{
+      task :foo do
+        raise "foooo!"
+      end
+    }
+
+    lines = invoke("foo").split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "foooo!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_multi_collapse
+    rakefile %q{
+      task :foo do
+        Rake.application.invoke_task(:bar)
+      end
+      task :bar do
+        raise "barrr!"
+      end
+    }
+
+    lines = invoke("foo").split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "barrr!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!i, lines
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_suppress_option
+    rakefile %q{
+      task :baz do
+        raise "bazzz!"
+      end
+    }
+
+    lines = invoke("baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    assert_something_matches %r!Rakefile!i, lines
+
+    lines = invoke("--suppress-backtrace", ".ak.file", "baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    refute_match %r!Rakefile!i, lines[2]
+  end
+
+  private
+
+  # Assert that the pattern matches at least one line in +lines+.
+  def assert_something_matches(pattern, lines)
+    lines.each do |ln|
+      if pattern =~ ln
+        assert_match pattern, ln
+        return
+      end
+    end
+    flunk "expected #{pattern.inspect} to match something in:\n" +
+      "#{lines.join("\n    ")}"
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/rake-10.5.0/test/test_rake_clean.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/clean'
+
+class TestRakeClean < Rake::TestCase
+  def test_clean
+    load 'rake/clean.rb', true
+
+    assert Rake::Task['clean'], "Should define clean"
+    assert Rake::Task['clobber'], "Should define clobber"
+    assert Rake::Task['clobber'].prerequisites.include?("clean"),
+      "Clobber should require clean"
+  end
+
+  def test_cleanup
+    file_name = create_undeletable_file
+
+    out, _ = capture_io do
+      Rake::Cleaner.cleanup(file_name, :verbose => false)
+    end
+    assert_match(/failed to remove/i, out)
+
+  ensure
+    remove_undeletable_file
+  end
+
+  def test_cleanup_ignores_missing_files
+    file_name = File.join(@tempdir, "missing_directory", "no_such_file")
+
+    out, _ = capture_io do
+      Rake::Cleaner.cleanup(file_name, :verbose => false)
+    end
+    refute_match(/failed to remove/i, out)
+  end
+
+  private
+
+  def create_undeletable_file
+    dir_name = File.join(@tempdir, "deletedir")
+    file_name = File.join(dir_name, "deleteme")
+    FileUtils.mkdir(dir_name)
+    FileUtils.touch(file_name)
+    FileUtils.chmod(0, file_name)
+    FileUtils.chmod(0, dir_name)
+    begin
+      FileUtils.chmod(0644, file_name)
+    rescue
+      file_name
+    else
+      skip "Permission to delete files is different on thie system"
+    end
+  end
+
+  def remove_undeletable_file
+    dir_name = File.join(@tempdir, "deletedir")
+    file_name = File.join(dir_name, "deleteme")
+    FileUtils.chmod(0777, dir_name)
+    FileUtils.chmod(0777, file_name)
+    Rake::Cleaner.cleanup(file_name, :verbose => false)
+    Rake::Cleaner.cleanup(dir_name, :verbose => false)
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/rake-10.5.0/test/test_rake_cpu_counter.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeCpuCounter < Rake::TestCase
+
+  def setup
+    super
+
+    @cpu_counter = Rake::CpuCounter.new
+  end
+
+  def test_count
+    num = @cpu_counter.count
+    skip 'cannot count CPU' if num == nil
+    assert_kind_of Numeric, num
+    assert_operator num, :>=, 1
+  end
+
+  def test_count_with_default_nil
+    def @cpu_counter.count; nil; end
+    assert_equal(8, @cpu_counter.count_with_default(8))
+    assert_equal(4, @cpu_counter.count_with_default)
+  end
+
+  def test_count_with_default_raise
+    def @cpu_counter.count; raise; end
+    assert_equal(8, @cpu_counter.count_with_default(8))
+    assert_equal(4, @cpu_counter.count_with_default)
+  end
+
+  class TestClassMethod < Rake::TestCase
+    def setup
+      super
+
+      @klass = Class.new(Rake::CpuCounter)
+    end
+
+    def test_count
+      @klass.class_eval do
+        def count; 8; end
+      end
+      assert_equal(8, @klass.count)
+    end
+
+    def test_count_nil
+      counted = false
+      @klass.class_eval do
+        define_method(:count) do
+          counted = true
+          nil
+        end
+      end
+      assert_equal(4, @klass.count)
+      assert_equal(true, counted)
+    end
+
+    def test_count_raise
+      counted = false
+      @klass.class_eval do
+        define_method(:count) do
+          counted = true
+          raise
+        end
+      end
+      assert_equal(4, @klass.count)
+      assert_equal(true, counted)
+    end
+  end
+end