ptools 1.3.5-universal-mingw32 → 1.4.2-universal-mingw32

data/spec/sparse_spec.rb

@@ -0,0 +1,43 @@
+#####################################################################
+# test_is_sparse.rb
+#
+# Test case for the File.sparse? method. You should run this test
+# via the 'rake test:is_sparse' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :sparse do
+  let(:windows) { File::ALT_SEPARATOR }
+  let(:osx) { RbConfig::CONFIG['host_os'] =~ /darwin|osx/i }
+  let(:non_sparse_file) { File.expand_path(File.basename(__FILE__)) }
+  let(:sparse_file) { 'test_sparse_file' }
+
+  before do
+    Dir.chdir("spec") if File.exist?("spec")
+    system("dd of=#{sparse_file} bs=1k seek=5120 count=0 2>/dev/null") unless windows
+  end
+
+  example "is_sparse basic functionality" do
+    skip "skipped on MS Windows or OSX" if windows || osx
+    expect(File).to respond_to(:sparse?)
+    expect{ File.sparse?(sparse_file) }.not_to raise_error
+    expect(File.sparse?(sparse_file)).to be(true).or be(false)
+  end
+
+  example "is_sparse returns the expected results" do
+    skip "skipped on MS Windows or OSX" if windows || osx
+    expect(File.sparse?(sparse_file)).to be true
+    expect(File.sparse?(non_sparse_file)).to be false
+  end
+
+  example "is_sparse only accepts one argument" do
+    skip if windows
+    expect{ File.sparse?(sparse_file, sparse_file) }.to raise_error(ArgumentError)
+  end
+
+  after do
+    Dir.chdir("spec") if File.exist?("spec")
+    File.delete(sparse_file) if File.exist?(sparse_file)
+  end
+end

data/spec/tail_spec.rb

@@ -0,0 +1,107 @@
+#####################################################################
+# tail_spec.rb
+#
+# Tests for the File.tail method. This test should be run via
+# the 'rake spec:tail' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :tail do
+  let(:dirname)            { File.dirname(__FILE__) }
+  let(:test_file1)         { File.join(dirname, 'test_file1.txt') }
+  let(:test_file64)        { File.join(dirname, 'test_file64.txt') }
+  let(:test_file128)       { File.join(dirname, 'test_file128.txt') }
+  let(:test_file_trail)    { File.join(dirname, 'test_file_trail.txt') }
+  let(:test_file_trail_nl) { File.join(dirname, 'test_file_trail_nl.txt') }
+
+  before do
+    File.open(test_file1, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+
+    # Trailing newline test
+    File.open(test_file_trail, 'w'){ |fh|
+      2.times{ |n| fh.puts "trail#{n+1}" }
+      fh.write "trail3"
+    }
+
+    File.open(test_file_trail_nl, 'w'){ |fh|
+      3.times{ |n| fh.puts "trail#{n+1}" }
+    }
+
+    # Larger files
+    test_tail_fmt_str = "line data data data data data data data %5s"
+
+    File.open(test_file64, 'w'){ |fh|
+      2000.times{ |n|
+        fh.puts test_tail_fmt_str % (n+1).to_s
+      }
+    }
+
+    File.open(test_file128, 'w'){ |fh|
+      4500.times{ |n|
+        fh.puts test_tail_fmt_str % (n+1).to_s
+      }
+    }
+
+    @expected_tail1 = %w{
+      line16 line17 line18 line19 line20
+      line21 line22 line23 line24 line25
+    }
+
+    @expected_tail2 = ["line21","line22","line23","line24","line25"]
+
+    @expected_tail_more = []
+    25.times{ |n| @expected_tail_more.push "line#{n+1}" }
+
+    @expected_tail_trail = %w{ trail2 trail3 }
+
+    @test_tail_fmt_str = "line data data data data data data data %5s"
+  end
+
+  example "tail basic functionality" do
+    expect(File).to respond_to(:tail)
+    expect{ File.tail(test_file1) }.not_to raise_error
+    expect{ File.tail(test_file1, 5) }.not_to raise_error
+    expect{ File.tail(test_file1){}.not_to raise_error }
+  end
+
+  example "tail returns the expected values" do
+    expect(File.tail(test_file1)).to be_kind_of(Array)
+    expect(File.tail(test_file1)).to eq(@expected_tail1)
+    expect(File.tail(test_file1, 5)).to eq(@expected_tail2)
+  end
+
+  example "specifying a number greater than the actual number of lines works as expected" do
+    expect(File.tail(test_file1, 30)).to eq(@expected_tail_more)
+  end
+
+  example "tail requires two arguments" do
+    expect{ File.tail }.to raise_error(ArgumentError)
+    expect{ File.tail(test_file1, 5, 5) }.to raise_error(ArgumentError)
+  end
+
+  example "tail works as expected when there is no trailing newline" do
+    expect(File.tail(test_file_trail, 2)).to eq(@expected_tail_trail)
+    expect(File.tail(test_file_trail_nl, 2)).to eq(@expected_tail_trail)
+  end
+
+  example "tail works as expected on a file larger than 64k" do
+    expected_tail_64k = []
+    2000.times{ |n| expected_tail_64k.push(@test_tail_fmt_str % (n+1).to_s) }
+    expect(File.tail(test_file64, 2000)).to eq(expected_tail_64k)
+  end
+
+  example "tail works as expected on a file larger than 128k" do
+    expected_tail_128k = []
+    4500.times{ |n| expected_tail_128k.push(@test_tail_fmt_str % (n+1).to_s) }
+    expect(File.tail(test_file128, 4500)).to eq(expected_tail_128k)
+  end
+
+  after do
+    File.delete(test_file1) if File.exist?(test_file1)
+    File.delete(test_file64) if File.exist?(test_file64)
+    File.delete(test_file128) if File.exist?(test_file128)
+    File.delete(test_file_trail_nl) if File.exist?(test_file_trail_nl)
+    File.delete(test_file_trail) if File.exist?(test_file_trail)
+  end
+end

data/spec/touch_spec.rb

@@ -0,0 +1,47 @@
+#####################################################################
+# test_touch.rb
+#
+# Test case for the File.touch method. This test should be run
+# via the 'rake test_touch task'.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :touch do
+  let(:dirname) { File.dirname(__FILE__) }
+  let(:filename) { 'test_file_touch.txt' }
+  let(:xfile) { File.join(dirname, filename) }
+
+  before do
+    File.open(xfile, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    @test_file = File.join(dirname, 'delete.this')
+  end
+
+  example "touch basic functionality" do
+    expect(File).to respond_to(:touch)
+    expect{ File.touch(@test_file) }.not_to raise_error
+  end
+
+  example "touch a new file returns expected results" do
+    expect(File.touch(@test_file)).to eq(File)
+    expect(File.exist?(@test_file)).to be true
+    expect(File.size(@test_file)).to eq(0)
+  end
+
+  example "touch an existing file returns expected results" do
+    stat = File.stat(xfile)
+    sleep 1
+    expect{ File.touch(xfile) }.not_to raise_error
+    expect(File.size(xfile) == stat.size).to be true
+    expect(File.mtime(xfile) == stat.mtime).to be false
+  end
+
+  example "touch requires an argument" do
+    expect{ File.touch }.to raise_error(ArgumentError)
+  end
+
+  after do
+    File.delete(@test_file) if File.exist?(@test_file)
+    File.delete(xfile) if File.exist?(xfile)
+  end
+end

data/spec/wc_spec.rb

@@ -0,0 +1,65 @@
+#####################################################################
+# wc_spec.rb
+#
+# Specs for the File.wc method. These specs should be run via
+# the 'rake wc' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :wc do
+  let(:test_file) { 'test_file_wc.txt' }
+
+  before do
+    File.open(test_file, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+  end
+
+  example "wc method basic functionality" do
+    expect(File).to respond_to(:wc)
+    expect{ File.wc(test_file) }.not_to raise_error
+  end
+
+  example "wc accepts specific optional arguments" do
+    expect{ File.wc(test_file, 'bytes') }.not_to raise_error
+    expect{ File.wc(test_file, 'chars') }.not_to raise_error
+    expect{ File.wc(test_file, 'words') }.not_to raise_error
+    expect{ File.wc(test_file, 'lines') }.not_to raise_error
+  end
+
+  example "argument to wc ignores the case of the option argument" do
+    expect{ File.wc(test_file, 'LINES') }.not_to raise_error
+  end
+
+  example "wc with no option returns expected results" do
+    expect(File.wc(test_file)).to be_kind_of(Array)
+    expect(File.wc(test_file)).to eq([166, 166, 25, 25])
+  end
+
+  example "wc with bytes option returns the expected result" do
+    expect(File.wc(test_file, 'bytes')).to eq(166)
+  end
+
+  example "wc with chars option returns the expected result" do
+    expect(File.wc(test_file, 'chars')).to eq(166)
+  end
+
+  example "wc with words option returns the expected result" do
+    expect(File.wc(test_file, 'words')).to eq(25)
+  end
+
+  example "wc with lines option returns the expected result" do
+    expect(File.wc(test_file, 'lines')).to eq(25)
+  end
+
+  example "wc requires at least on argument" do
+    expect{ File.wc }.to raise_error(ArgumentError)
+  end
+
+  example "an invalid option raises an error" do
+    expect{ File.wc(test_file, 'bogus') }.to raise_error(ArgumentError)
+  end
+
+  after do
+    File.delete(test_file) if File.exists?(test_file)
+  end
+end

data/spec/whereis_spec.rb

@@ -0,0 +1,87 @@
+######################################################################
+# test_whereis.rb
+#
+# Tests for the File.whereis method.
+######################################################################
+require 'rubygems'
+require 'rspec'
+require 'ptools'
+require 'rbconfig'
+
+RSpec.describe File, :whereis do
+  let(:windows) { File::ALT_SEPARATOR }
+  let(:ruby) { RUBY_ENGINE }
+  let(:bin_dir) { RbConfig::CONFIG['bindir'] }
+
+  before do
+    @expected_locs = [File.join(bin_dir, ruby)]
+
+    if windows
+      @expected_locs[0] << '.exe'
+      @expected_locs[0].tr!("/", "\\")
+    end
+
+    unless windows
+      @expected_locs << "/usr/local/bin/#{ruby}"
+      @expected_locs << "/opt/sfw/bin/#{ruby}"
+      @expected_locs << "/opt/bin/#{ruby}"
+      @expected_locs << "/usr/bin/#{ruby}"
+    end
+
+    @actual_locs = nil
+  end
+
+  example "whereis basic functionality" do
+    expect(File).to respond_to(:whereis)
+    expect{ File.whereis('ruby') }.not_to raise_error
+    expect(File.whereis('ruby')).to be_kind_of(Array).or be_nil
+  end
+
+  example "whereis accepts an optional second argument" do
+    expect{ File.whereis('ruby', '/usr/bin:/usr/local/bin') }.not_to raise_error
+  end
+
+  example "whereis returns expected values" do
+    expect{ @actual_locs = File.whereis(ruby) }.not_to raise_error
+    expect(@actual_locs).to be_kind_of(Array)
+    expect((@expected_locs & @actual_locs).size > 0).to be true
+  end
+
+  example "whereis returns nil if program not found" do
+    expect(File.whereis('xxxyyy')).to be_nil
+  end
+
+  example "whereis returns nil if program cannot be found in provided path" do
+    expect(File.whereis(ruby, '/foo/bar')).to be_nil
+  end
+
+  example "whereis returns single element array or nil if absolute path is provided" do
+    absolute = File.join(bin_dir, ruby)
+    absolute << '.exe' if windows
+
+    expect(File.whereis(absolute)).to eq([absolute])
+    expect(File.whereis("/foo/bar/baz/#{ruby}")).to be_nil
+  end
+
+  example "whereis works with an explicit extension on ms windows" do
+    skip "skipped unless MS Windows" unless windows
+    expect(File.whereis(ruby + '.exe')).not_to be_nil
+  end
+
+  example "whereis requires at least one argument" do
+    expect{ File.whereis }.to raise_error(ArgumentError)
+  end
+
+  example "whereis returns unique paths only" do
+    expect(File.whereis(ruby) == File.whereis(ruby).uniq).to be true
+  end
+
+  example "whereis accepts a maximum of two arguments" do
+    expect{ File.whereis(ruby, 'foo', 'bar') }.to raise_error(ArgumentError)
+  end
+
+  example "the second argument to whereis cannot be nil or empty" do
+    expect{ File.whereis(ruby, nil) }.to raise_error(ArgumentError)
+    expect{ File.whereis(ruby, '') }.to raise_error(ArgumentError)
+  end
+end

data/spec/which_spec.rb

@@ -0,0 +1,112 @@
+#####################################################################
+# which_spec.rb
+#
+# Test case for the File.which method. You should run this test
+# via 'rake spec' or 'rake spec --tag which'.
+#####################################################################
+require 'rspec'
+require 'rbconfig'
+require 'fileutils'
+require 'ptools'
+require 'tempfile'
+
+describe File, :which do
+  before(:context) do
+    @windows = File::ALT_SEPARATOR
+    @dir = File.join(Dir.pwd, 'tempdir')
+    @non_exe = File.join(Dir.pwd, 'tempfile')
+    @ruby = RUBY_PLATFORM.match('java') ? 'jruby' : 'ruby'
+    @ruby = 'rbx' if defined?(Rubinius)
+
+    Dir.mkdir(@dir) unless File.exist?(@dir)
+    FileUtils.touch(@non_exe)
+    File.chmod(775, @dir)
+    File.chmod(644, @non_exe)
+
+    @exe = File.join(
+      RbConfig::CONFIG['bindir'],
+      RbConfig::CONFIG['ruby_install_name']
+    )
+
+    if @windows
+      @exe.tr!('/','\\')
+      @exe << ".exe"
+    end
+  end
+
+  example "which method basic functionality" do
+    expect(File).to respond_to(:which)
+    expect{ File.which(@ruby) }.not_to raise_error
+    expect(File.which(@ruby)).to be_kind_of(String)
+  end
+
+  example "which accepts an optional path to search" do
+    expect{ File.which(@ruby, "/usr/bin:/usr/local/bin") }.not_to raise_error
+  end
+
+  example "which returns nil if not found" do
+    expect(File.which(@ruby, '/bogus/path')).to be_nil
+    expect(File.which('blahblahblah')).to be_nil
+  end
+
+  example "which handles executables without extensions on windows" do
+    skip "skipped unless MS Windows" unless @windows
+    expect(File.which('ruby')).not_to be_nil
+    expect(File.which('notepad')).not_to be_nil
+  end
+
+  example "which handles executables that already contain extensions on windows" do
+    skip "skipped unless MS Windows" unless @windows
+    expect(File.which('ruby.exe')).not_to be_nil
+    expect(File.which('notepad.exe')).not_to be_nil
+  end
+
+  example "which returns argument if an existent absolute path is provided" do
+    expect(File.which(@ruby)).to eq(@exe), "May fail on a symlink"
+  end
+
+  example "which returns nil if a non-existent absolute path is provided" do
+    expect(File.which('/foo/bar/baz/ruby')).to be_nil
+  end
+
+  example "which does not pickup files that are not executable" do
+    expect(File.which(@non_exe)).to be_nil
+  end
+
+  example "which does not pickup executable directories" do
+    expect(File.which(@dir)).to be_nil
+  end
+
+  example "which accepts a minimum of one argument" do
+    expect{ File.which }.to raise_error(ArgumentError)
+  end
+
+  example "which accepts a maximum of two arguments" do
+    expect{ File.which(@ruby, "foo", "bar") }.to raise_error(ArgumentError)
+  end
+
+  example "the second argument cannot be nil or empty" do
+    expect{ File.which(@ruby, nil) }.to raise_error(ArgumentError)
+    expect{ File.which(@ruby, '') }.to raise_error(ArgumentError)
+  end
+
+  example "resolves with with ~" do
+    skip "skipped on MS Windows" if @windows
+    begin
+      old_home = ENV['HOME']
+
+      ENV['HOME'] = Dir::Tmpname.tmpdir
+      program = Tempfile.new(['program', '.sh'])
+      File.chmod(755, program.path)
+
+      expect(File.which(File.basename(program.path), '~/')).not_to be_nil
+    ensure
+      ENV['HOME'] = old_home
+    end
+  end
+
+  after(:context) do
+    FileUtils.rm(@non_exe)
+    FileUtils.rm_rf(@dir)
+  end
+end