ptools 1.2.2-universal-mingw32

data/test/test_middle.rb

@@ -0,0 +1,61 @@
+#####################################################################
+# test_middle.rb
+#
+# Test case for the File.middle method. You should run this test
+# via the 'rake test_middle' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileMiddle < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup   
+      @test_file = 'test_file1.txt'
+
+      @expected_middle1 = ["line10\n", "line11\n", "line12\n", "line13\n", "line14\n"]
+      @expected_middle1.push("line15\n","line16\n", "line17\n", "line18\n")
+      @expected_middle1.push("line19\n","line20\n")
+
+      @expected_middle2 = ["line14\n","line15\n","line16\n","line17\n"]
+      @expected_middle2.push("line18\n","line19\n","line20\n")
+
+      @expected_middle3 = ["line5\n","line6\n","line7\n"]
+      @expected_middle3.push("line8\n","line9\n","line10\n")
+   end
+
+   def test_method_basic
+      assert_respond_to(File, :middle)
+      assert_nothing_raised{ File.middle(@test_file) }
+      assert_nothing_raised{ File.middle(@test_file, 14) }
+      assert_nothing_raised{ File.middle(@test_file, 5, 10) }
+      assert_nothing_raised{ File.middle(@test_file){} }
+   end
+
+   def test_middle_expected_results
+      assert_kind_of(Array, File.middle(@test_file))
+      assert_equal(@expected_middle1, File.middle(@test_file))
+      assert_equal(@expected_middle2, File.middle(@test_file, 14))
+      assert_equal(@expected_middle3, File.middle(@test_file, 5, 10))
+   end
+
+   def test_middle_expected_errors
+      assert_raises(ArgumentError){ File.middle }
+      assert_raises(ArgumentError){ File.middle(@test_file, 5, 10, 15) }
+      assert_raises(NoMethodError){ File.middle(@test_file, "foo") }
+      assert_raises(Errno::ENOENT){ File.middle("bogus") }
+   end
+
+   def teardown
+      @test_file = nil
+      @expected_middle1 = nil
+      @expected_middle2 = nil
+      @expected_middle3 = nil
+   end
+end

data/test/test_nlconvert.rb

@@ -0,0 +1,99 @@
+#####################################################################
+# test_nlconvert.rb
+#
+# Test case for the File.nl_convert method. You should run this
+# test via the 'rake test_nlconvert' task.
+#####################################################################
+require 'rubygems'
+require 'test-unit'
+require 'ptools'
+
+class TC_Ptools_NLConvert < Test::Unit::TestCase
+  def self.startup
+    Dir.chdir('test') if File.exists?('test')
+    @@test_file1 = 'test_nl_convert1.txt'
+    @@test_file2 = 'test_nl_convert2.txt'
+    File.open(@@test_file1, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    File.open(@@test_file2, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+  end
+
+  def setup
+    @test_file1 = 'test_nl_convert1.txt'
+    @test_file2 = 'test_nl_convert2.txt'
+    @dos_file   = 'dos_test_file.txt'
+    @mac_file   = 'mac_test_file.txt'
+    @unix_file  = 'nix_test_file.txt'
+  end
+
+  test "nl_convert basic functionality" do
+    assert_respond_to(File, :nl_convert)
+  end
+
+  test "nl_convert accepts one, two or three arguments" do
+    assert_nothing_raised{ File.nl_convert(@test_file2) }
+    assert_nothing_raised{ File.nl_convert(@test_file2, @test_file2) }
+    assert_nothing_raised{ File.nl_convert(@test_file2, @test_file2, "unix") }
+  end
+
+  test "nl_convert with dos platform argument works as expected" do
+    msg = "dos file should be larger, but isn't"
+
+    assert_nothing_raised{ File.nl_convert(@test_file1, @dos_file, "dos") }
+    assert_true(File.size(@dos_file) > File.size(@test_file1), msg)
+    assert_equal(["\cM","\cJ"], IO.readlines(@dos_file).first.split("")[-2..-1])
+  end
+
+  test "nl_convert with mac platform argument works as expected" do
+    assert_nothing_raised{ File.nl_convert(@test_file1, @mac_file, 'mac') }
+    assert_equal("\cM", IO.readlines(@mac_file).first.split("").last)
+
+    omit_if(File::ALT_SEPARATOR)
+    msg = "=> Mac file should be the same size (or larger), but isn't"
+    assert_true(File.size(@mac_file) == File.size(@test_file1), msg)
+  end
+
+  test "nl_convert with unix platform argument works as expected" do
+    msg = "unix file should be the same size (or smaller), but isn't"
+
+    assert_nothing_raised{ File.nl_convert(@test_file1, @unix_file, "unix") }
+    assert_equal("\n", IO.readlines(@unix_file).first.split("").last)
+
+    if File::ALT_SEPARATOR
+      assert_true(File.size(@unix_file) >= File.size(@test_file1), msg)
+    else
+      assert_true(File.size(@unix_file) <= File.size(@test_file1), msg)
+    end
+  end
+
+  test "nl_convert requires at least one argument" do
+    assert_raise(ArgumentError){ File.nl_convert }
+  end
+
+  test "nl_convert requires a valid platform string" do
+    assert_raise(ArgumentError){ File.nl_convert(@test_file1, "bogus.txt", "blah") }
+  end
+
+  test "nl_convert accepts a maximum of three arguments" do
+    assert_raise(ArgumentError){ File.nl_convert(@test_file1, @test_file2, 'dos', 1) }
+  end
+
+  test "nl_convert will fail on anything but plain files" do
+    assert_raise(ArgumentError){ File.nl_convert(File.null_device, @test_file1) }
+  end
+
+  def teardown
+    [@dos_file, @mac_file, @unix_file].each{ |file|
+      File.delete(file) if File.exists?(file)
+    }
+    @dos_file   = nil
+    @mac_file   = nil
+    @unix_file  = nil
+    @test_file1 = nil
+    @test_file2 = nil
+  end
+
+  def self.shutdown
+    File.delete(@@test_file1) if File.exists?(@@test_file1)
+    File.delete(@@test_file2) if File.exists?(@@test_file2)
+  end
+end

data/test/test_null.rb

@@ -0,0 +1,40 @@
+#####################################################################
+# test_null.rb
+# 
+# Test case for the File.null method. You should run this test via
+# the 'rake test_null' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileNull < Test::Unit::TestCase
+  def setup
+    @nulls = ['/dev/null', 'NUL', 'NIL:', 'NL:']
+  end
+
+  test "null method basic functionality" do
+    assert_respond_to(File, :null)
+    assert_nothing_raised{ File.null }
+  end
+
+  test "null method returns expected results" do
+    assert_kind_of(String, File.null)
+    assert(@nulls.include?(File.null))
+  end
+
+  test "null method does not accept any arguments" do
+    assert_raises(ArgumentError){ File.null(1) }
+  end
+
+  test "null_device is an alias for null" do
+    assert_respond_to(File, :null_device)
+    assert_alias_method(File, :null_device, :null)
+  end
+
+  def teardown
+    @nulls = nil
+  end
+end

data/test/test_tail.rb

@@ -0,0 +1,56 @@
+#####################################################################
+# test_tail.rb
+#
+# Test case for the File.tail method. This test should be run via
+# the 'rake test_tail' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileTail < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup     
+      @test_file = 'test_file1.txt'
+
+      @expected_tail1 = ["line16\n","line17\n","line18\n","line19\n"]
+      @expected_tail1.push("line20\n","line21\n","line22\n", "line23\n")
+      @expected_tail1.push("line24\n","line25\n")
+
+      @expected_tail2 = ["line21\n","line22\n","line23\n","line24\n","line25\n"]
+   end
+
+   def test_tail_basic
+      assert_respond_to(File, :tail)
+      assert_nothing_raised{ File.tail(@test_file) }
+      assert_nothing_raised{ File.tail(@test_file, 5) }
+      assert_nothing_raised{ File.tail(@test_file){} }
+   end
+
+   def test_tail_expected_return_values
+      assert_kind_of(Array, File.tail(@test_file))
+      assert_equal(@expected_tail1, File.tail(@test_file))
+      assert_equal(@expected_tail2, File.tail(@test_file, 5))
+   end
+
+   def test_tail_expected_errors
+      assert_raises(ArgumentError){ File.tail }
+      assert_raises(ArgumentError){ File.tail(@test_file, 5, 5) }
+   end
+
+   def teardown
+      @test_file = nil
+      @expected_tail1 = nil
+      @expected_tail2 = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end

data/test/test_touch.rb

@@ -0,0 +1,55 @@
+#####################################################################
+# tc_touch.rb
+#
+# Test case for the File.touch method. This test should be run
+# via the 'rake test_touch task'.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileTouch < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+   end
+   
+   def setup   
+      @test_file = 'delete.this'
+      @xfile = 'test_file1.txt'
+   end
+
+   def test_touch_basic
+      assert_respond_to(File, :touch)
+      assert_nothing_raised{ File.touch(@test_file) }
+   end
+
+   def test_touch_expected_results
+      assert_equal(File, File.touch(@test_file))
+      assert_equal(true, File.exists?(@test_file))
+      assert_equal(0, File.size(@test_file))
+   end
+
+   def test_touch_existing_file
+      stat = File.stat(@xfile)
+      sleep 1
+      assert_nothing_raised{ File.touch(@xfile) }
+      assert_equal(true, File.size(@xfile) == stat.size)
+      assert_equal(false, File.mtime(@xfile) == stat.mtime)
+   end
+
+   def test_touch_expected_errors
+      assert_raises(ArgumentError){ File.touch }
+   end
+
+   def teardown
+      File.delete(@test_file) if File.exists?(@test_file)
+      @test_file = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end

data/test/test_wc.rb

@@ -0,0 +1,76 @@
+#####################################################################
+# test_wc.rb
+#
+# Test case for the File.wc method. This test should be run via
+# the 'rake test_wc' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileWC < Test::Unit::TestCase
+  def self.startup
+    Dir.chdir('test') if File.exists?('test')      
+    File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+    @@test_file = 'test_file1.txt'
+  end
+   
+  def setup     
+    @test_file = 'test_file1.txt'
+  end
+
+  test "wc method basic functionality" do
+    assert_respond_to(File, :wc)
+    assert_nothing_raised{ File.wc(@test_file) }
+  end
+
+  test "wc accepts specific optional arguments" do
+    assert_nothing_raised{ File.wc(@test_file, 'bytes') }
+    assert_nothing_raised{ File.wc(@test_file, 'chars') }
+    assert_nothing_raised{ File.wc(@test_file, 'words') }
+    assert_nothing_raised{ File.wc(@test_file, 'lines') }
+  end
+
+  test "argument to wc ignores the case of the option argument" do
+    assert_nothing_raised{ File.wc(@test_file, 'LINES') }
+  end
+
+  test "wc with no option returns expected results" do
+    assert_kind_of(Array, File.wc(@test_file))
+    assert_equal([166,166,25,25], File.wc(@test_file))
+  end
+
+  test "wc with bytes option returns the expected result" do
+    assert_equal(166, File.wc(@test_file, 'bytes'), "Wrong number of bytes")
+  end
+
+  test "wc with chars option returns the expected result" do
+    assert_equal(166, File.wc(@test_file, 'chars'), "Wrong number of chars")
+  end
+
+  test "wc with words option returns the expected result" do
+    assert_equal(25, File.wc(@test_file, 'words'), "Wrong number of words")
+  end
+
+  test "wc with lines option returns the expected result" do
+    assert_equal(25, File.wc(@test_file, 'lines'), "Wrong number of lines")
+  end
+
+  test "wc requires at least on argument" do
+    assert_raises(ArgumentError){ File.wc }
+  end
+
+  test "an invalid option raises an error" do
+    assert_raises(ArgumentError){ File.wc(@test_file, 'bogus') }
+  end
+
+  def teardown
+    @test_file = nil
+  end
+
+  def self.shutdown
+    File.delete(@@test_file) if File.exists?(@@test_file)
+  end
+end

data/test/test_whereis.rb

@@ -0,0 +1,98 @@
+######################################################################
+# test_whereis.rb
+#
+# Tests for the File.whereis method.
+######################################################################
+require 'rubygems'
+require 'test-unit'
+require 'ptools'
+require 'rbconfig'
+
+class TC_Ptools_Whereis < Test::Unit::TestCase
+  def self.startup
+    @@windows = File::ALT_SEPARATOR
+    @@ruby = RUBY_PLATFORM == 'java' ? 'jruby' : 'ruby'
+  end
+
+  def setup
+    @bin_dir = RbConfig::CONFIG['bindir']
+    @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
+
+  test "whereis basic functionality" do
+    assert_respond_to(File, :whereis)
+    assert_nothing_raised{ File.whereis('ruby') }
+    assert_kind_of([Array, NilClass], File.whereis('ruby'))
+  end
+
+  test "whereis accepts an optional second argument" do
+    assert_nothing_raised{ File.whereis('ruby', '/usr/bin:/usr/local/bin') }
+  end
+
+  test "whereis returns expected values" do
+    assert_nothing_raised{ @actual_locs = File.whereis(@@ruby) }
+    assert_kind_of(Array, @actual_locs)
+    assert_true((@expected_locs & @actual_locs).size > 0)
+  end
+
+  test "whereis returns nil if program not found" do
+    assert_nil(File.whereis('xxxyyy'))
+  end
+
+  test "whereis returns nil if program cannot be found in provided path" do
+    assert_nil(File.whereis(@@ruby, '/foo/bar'))
+  end
+
+  test "whereis returns single element array or nil if absolute path is provided" do
+    absolute = File.join(@bin_dir, @@ruby)
+    absolute << '.exe' if @@windows
+
+    assert_equal([absolute], File.whereis(absolute))
+    assert_nil(File.whereis("/foo/bar/baz/#{@@ruby}"))
+  end
+
+  test "whereis works with an explicit extension on ms windows" do
+    omit_unless(@@windows, 'test skipped except on MS Windows')
+    assert_not_nil(File.whereis(@@ruby + '.exe'))
+  end
+
+  test "whereis requires at least one argument" do
+    assert_raise(ArgumentError){ File.whereis }
+  end
+
+  test "whereis returns unique paths only" do
+    assert_true(File.whereis(@@ruby) == File.whereis(@@ruby).uniq)
+  end
+
+  test "whereis accepts a maximum of two arguments" do
+    assert_raise(ArgumentError){ File.whereis(@@ruby, 'foo', 'bar') }
+  end
+
+  test "the second argument to whereis cannot be nil or empty" do
+    assert_raise(ArgumentError){ File.whereis(@@ruby, nil) }
+    assert_raise(ArgumentError){ File.whereis(@@ruby, '') }
+  end
+
+  def teardown
+    @expected_locs = nil
+    @actual_locs = nil
+  end
+
+  def self.shutdown
+    @@windows = nil
+  end
+end

data/test/test_which.rb

@@ -0,0 +1,113 @@
+#####################################################################
+# test_which.rb
+#
+# Test case for the File.which method. You should run this test
+# via the 'rake test_which' rake task.
+#
+# NOTE: I make the assumption that Ruby (or JRuby) is in your
+# PATH for these tests.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'rbconfig'
+require 'fileutils'
+require 'ptools'
+
+class TC_FileWhich < Test::Unit::TestCase
+  def self.startup
+    @@windows = File::ALT_SEPARATOR
+    @@dir = File.join(Dir.pwd, 'tempdir')
+    @@non_exe = File.join(Dir.pwd, 'tempfile')
+
+    Dir.mkdir(@@dir) unless File.exists?(@@dir)
+    FileUtils.touch(@@non_exe)
+    File.chmod(775, @@dir)
+    File.chmod(644, @@non_exe)
+  end
+
+  def setup
+    @ruby = RUBY_PLATFORM.match('java') ? 'jruby' : 'ruby'
+    @ruby = 'rbx' if defined?(Rubinius)
+
+    @exe = File.join(
+      RbConfig::CONFIG['bindir'],
+      RbConfig::CONFIG['ruby_install_name']
+    )
+
+    if @@windows
+      @exe.tr!('/','\\')
+      @exe << ".exe"
+    end
+  end
+
+  test "which method basic functionality" do
+    assert_respond_to(File, :which)
+    assert_nothing_raised{ File.which(@ruby) }
+    assert_kind_of(String, File.which(@ruby))
+  end
+
+  test "which accepts an optional path to search" do
+    assert_nothing_raised{ File.which(@ruby, "/usr/bin:/usr/local/bin") }
+  end
+
+  test "which returns nil if not found" do
+    assert_equal(nil, File.which(@ruby, '/bogus/path'))
+    assert_equal(nil, File.which('blahblahblah'))
+  end
+
+  test "which handles executables without extensions on windows" do
+    omit_unless(@@windows, "test skipped unless MS Windows")
+    assert_not_nil(File.which('ruby'))
+    assert_not_nil(File.which('notepad'))
+  end
+
+  test "which handles executables that already contain extensions on windows" do
+    omit_unless(@@windows, "test skipped unless MS Windows")
+    assert_not_nil(File.which('ruby.exe'))
+    assert_not_nil(File.which('notepad.exe'))
+  end
+
+  test "which returns argument if an existent absolute path is provided" do
+    assert_equal(@exe, File.which(@ruby), "=> May fail on a symlink")
+  end
+
+  test "which returns nil if a non-existent absolute path is provided" do
+    assert_nil(File.which('/foo/bar/baz/ruby'))
+  end
+
+  test "which does not pickup files that are not executable" do
+    assert_nil(File.which(@@non_exe))
+  end
+
+  test "which does not pickup executable directories" do
+    assert_nil(File.which(@@dir))
+  end
+
+  test "which accepts a minimum of one argument" do
+    assert_raises(ArgumentError){ File.which }
+  end
+
+  test "which accepts a maximum of two arguments" do
+    assert_raises(ArgumentError){ File.which(@ruby, "foo", "bar") }
+  end
+
+  test "the second argument cannot be nil or empty" do
+    assert_raises(ArgumentError){ File.which(@ruby, nil) }
+    assert_raises(ArgumentError){ File.which(@ruby, '') }
+  end
+
+  def teardown
+    @exe  = nil
+    @ruby = nil
+  end
+
+  def self.shutdown
+    FileUtils.rm(@@non_exe)
+    FileUtils.rm_rf(@@dir)
+    @@windows = nil
+    @@dir = nil
+    @@non_exe = nil
+  end
+end