ptools 1.3.3 → 1.4.0

data/test/test_binary.rb

@@ -1,65 +0,0 @@
-#####################################################################
-# test_binary.rb
-#
-# Test case for the File.binary? method. You should run this test
-# via the 'rake test_binary' task.
-#####################################################################
-require 'rubygems'
-require 'test-unit'
-require 'ptools'
-
-class TC_Ptools_Binary < Test::Unit::TestCase
-  def self.startup
-    if File::ALT_SEPARATOR
-      @@bin_file = File.join(ENV['windir'], 'notepad.exe')
-    else
-      @@bin_file = '/bin/ls'
-    end
-
-    @@dirname = File.dirname(__FILE__)
-  end
-
-  def setup
-    @txt_file = File.join(@@dirname, 'txt', 'english.txt')
-    @uni_file = File.join(@@dirname, 'txt', 'korean.txt')
-    @png_file = File.join(@@dirname, 'img', 'test.png')
-    @jpg_file = File.join(@@dirname, 'img', 'test.jpg')
-    @gif_file = File.join(@@dirname, 'img', 'test.gif')
-  end
-
-  test "File.binary? basic functionality" do
-    assert_respond_to(File, :binary?)
-    assert_nothing_raised{ File.binary?(@txt_file) }
-  end
-
-  test "File.binary? returns true for binary files" do
-    assert_true(File.binary?(@@bin_file))
-  end
-
-  test "File.binary? returns false for text files" do
-    assert_false(File.binary?(@txt_file))
-    assert_false(File.binary?(@uni_file))
-  end
-
-  test "File.binary? returns false for image files" do
-    assert_false(File.binary?(@png_file))
-    assert_false(File.binary?(@jpg_file))
-    assert_false(File.binary?(@gif_file))
-  end
-
-  test "File.binary? raises an error if the file cannot be found" do
-    assert_raise_kind_of(SystemCallError){ File.binary?('bogus') }
-  end
-
-  test "File.binary? only accepts one argument" do
-    assert_raise_kind_of(ArgumentError){ File.binary?(@txt_file, @@bin_file) }
-  end
-
-  def teardown
-    @txt_file = nil
-    @uni_file = nil
-    @png_file = nil
-    @jpg_file = nil
-    @gif_file = nil
-  end
-end

data/test/test_constants.rb

@@ -1,38 +0,0 @@
-#####################################################################
-# test_constants.rb
-#
-# Tests the constants that have been defined for our package. This
-# test case should be run via the 'rake test_constants' task.
-#####################################################################
-require 'rubygems'
-require 'test-unit'
-require 'rbconfig'
-require 'ptools'
-
-class TC_Ptools_Constants < Test::Unit::TestCase
-  def self.startup
-    @@windows = File::ALT_SEPARATOR
-  end
-
-  test "PTOOLS_VERSION constant is set to expected value" do
-    assert_equal('1.3.3', File::PTOOLS_VERSION)
-  end
-
-  test "IMAGE_EXT constant is set to array of values" do
-    assert_equal(%w[.bmp .gif .jpeg .jpg .png], File::IMAGE_EXT.sort)
-  end
-
-  test "WINDOWS constant is defined on MS Windows" do
-    omit_unless(@@windows, "Skipping on Unix systems")
-    assert_not_nil(File::MSWINDOWS)
-  end
-
-  test "WIN32EXTS constant is defiend on MS Windows" do
-    omit_unless(@@windows, "Skipping on Unix systems")
-    assert_not_nil(File::WIN32EXTS)
-  end
-
-  def self.shutdown
-    @@windows = nil
-  end
-end

data/test/test_head.rb

@@ -1,48 +0,0 @@
-######################################################################
-# test_head.rb
-#
-# Test case for the File.head method. This test should be run via
-# the 'rake test_head' task.
-######################################################################
-require 'test-unit'
-require 'ptools'
-
-class TC_FileHead < Test::Unit::TestCase
-  def self.startup
-    Dir.chdir('test') if File.exist?('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_head1 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
-    @expected_head1.push("line6\n","line7\n","line8\n","line9\n","line10\n")
-    @expected_head2 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
-  end
-
-  def test_head_basic
-    assert_respond_to(File, :head)
-    assert_nothing_raised{ File.head(@test_file) }
-    assert_nothing_raised{ File.head(@test_file, 5) }
-    assert_nothing_raised{ File.head(@test_file){} }
-  end
-
-  def test_head_expected_results
-    assert_kind_of(Array, File.head(@test_file))
-    assert_equal(@expected_head1, File.head(@test_file))
-    assert_equal(@expected_head2, File.head(@test_file, 5))
-  end
-
-  def test_head_expected_errors
-    assert_raises(ArgumentError){ File.head(@test_file, 5, "foo") }
-    assert_raises(Errno::ENOENT){ File.head("bogus") }
-  end
-
-  def teardown
-    @test_file = nil
-  end
-
-  def self.shutdown
-    File.delete('test_file1.txt') if File.exist?('test_file1.txt')
-  end
-end

data/test/test_image.rb

@@ -1,57 +0,0 @@
-#####################################################################
-# test_image.rb
-#
-# Test case for the File.image? method. You should run this test
-# via the 'rake test:image' task.
-#####################################################################
-require 'test-unit'
-require 'ptools'
-
-class TC_Ptools_Image < Test::Unit::TestCase
-  def self.startup
-    Dir.chdir('test') if File.exist?('test')
-  end
-
-  def setup
-    @txt_file  = File.join(Dir.pwd, 'txt', 'english.txt')
-    @uni_file  = File.join(Dir.pwd, 'txt', 'korean.txt')
-    @jpg_file  = File.join(Dir.pwd, 'img', 'test.jpg')
-    @png_file  = File.join(Dir.pwd, 'img', 'test.png')
-    @gif_file  = File.join(Dir.pwd, 'img', 'test.gif')
-  end
-
-  test "image? method basic functionality" do
-    assert_respond_to(File, :image?)
-    assert_nothing_raised{ File.image?(@txt_file) }
-    assert_boolean(File.image?(@txt_file))
-  end
-
-  test "image? method returns false for a text file" do
-    assert_false(File.image?(@txt_file))
-    assert_false(File.image?(@uni_file))
-  end
-
-  test "image? method returns true for a gif" do
-    assert_true(File.image?(@gif_file))
-  end
-
-  test "image? method returns true for a jpeg" do
-    assert_true(File.image?(@jpg_file))
-  end
-
-  test "image? method returns true for a png" do
-    assert_true(File.image?(@png_file))
-  end
-
-  test "image? method raises an error if the file does not exist" do
-    assert_raises(Errno::ENOENT, ArgumentError){ File.image?('bogus') }
-  end
-
-  def teardown
-    @txt_file = nil
-    @uni_file = nil
-    @jpg_file = nil
-    @png_file = nil
-    @gif_file = nil
-  end
-end

data/test/test_is_sparse.rb

@@ -1,53 +0,0 @@
-#####################################################################
-# test_is_sparse.rb
-#
-# Test case for the File.sparse? method. You should run this test
-# via the 'rake test:is_sparse' task.
-#####################################################################
-require 'test-unit'
-require 'ptools'
-
-class TC_IsSparse < Test::Unit::TestCase
-  def self.startup
-    Dir.chdir("test") if File.exist?("test")
-    @@win = File::ALT_SEPARATOR
-    @@osx = RbConfig::CONFIG['host_os'] =~ /darwin|osx/i
-    system("dd of=test_sparse bs=1k seek=5120 count=0 2>/dev/null") unless @@win
-  end
-
-  def setup
-    @sparse_file = 'test_sparse'
-    @non_sparse_file = File.expand_path(File.basename(__FILE__))
-  end
-
-  test "is_sparse basic functionality" do
-    omit_if(@@win, "File.sparse? tests skipped on MS Windows")
-    omit_if(@@osx, "File.sparse? tests skipped on OS X")
-
-    assert_respond_to(File, :sparse?)
-    assert_nothing_raised{ File.sparse?(@sparse_file) }
-    assert_boolean(File.sparse?(@sparse_file))
-  end
-
-  test "is_sparse returns the expected results" do
-    omit_if(@@win, "File.sparse? tests skipped on MS Windows")
-    omit_if(@@osx, "File.sparse? tests skipped on OS X")
-
-    assert_true(File.sparse?(@sparse_file))
-    assert_false(File.sparse?(@non_sparse_file))
-  end
-
-  test "is_sparse only accepts one argument" do
-    omit_if(@@win, "File.sparse? tests skipped on MS Windows")
-    assert_raise(ArgumentError){ File.sparse?(@sparse_file, @sparse_file) }
-  end
-
-  def teardown
-    @sparse_file = nil
-    @non_sparse_file = nil
-  end
-
-  def self.shutdown
-    File.delete('test_sparse') if File.exist?('test_sparse')
-  end
-end

data/test/test_nlconvert.rb

@@ -1,110 +0,0 @@
-#####################################################################
-# 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
-    @@dirname = File.dirname(__FILE__)
-    @@test_file1 = File.join(@@dirname, 'test_nl_convert1.txt')
-    @@test_file2 = File.join(@@dirname, '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 = File.join(@@dirname, 'test_nl_convert1.txt')
-    @test_file2 = File.join(@@dirname, 'test_nl_convert2.txt')
-    @dos_file   = File.join(@@dirname, 'dos_test_file.txt')
-    @mac_file   = File.join(@@dirname, 'mac_test_file.txt')
-    @unix_file  = 'nix_test_file.txt'
-  end
-
-  test "nl_for_platform basic functionality" do
-    assert_respond_to(File, :nl_for_platform)
-  end
-
-  test "nl_for_platform" do
-    assert_equal( "\cM\cJ", File.nl_for_platform('dos') )
-    assert_equal( "\cJ",    File.nl_for_platform('unix') )
-    assert_equal( "\cM",    File.nl_for_platform('mac') )
-    assert_nothing_raised{ File.nl_for_platform('local') }
-  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.exist?(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.exist?(@@test_file1)
-    File.delete(@@test_file2) if File.exist?(@@test_file2)
-  end
-end

data/test/test_null.rb

@@ -1,40 +0,0 @@
-#####################################################################
-# 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

@@ -1,124 +0,0 @@
-#####################################################################
-# test_tail.rb
-#
-# Test case for the File.tail method. This test should be run via
-# the 'rake test_tail' task.
-#####################################################################
-require 'test-unit'
-require 'ptools'
-
-class TC_FileTail < Test::Unit::TestCase
-  def self.startup
-    @@dirname = File.dirname(__FILE__)
-
-    @@test_file1   = File.join(@@dirname, 'test_file1.txt')
-    @@test_file64  = File.join(@@dirname, 'test_file64.txt')
-    @@test_file128 = File.join(@@dirname, 'test_file128.txt')
-
-    @@test_file_trail = File.join(@@dirname, 'test_file_trail.txt')
-    @@test_file_trail_nl = File.join(@@dirname, 'test_file_trail_nl.txt')
-
-    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
-      }
-    }
-  end
-
-  def setup
-    @test_file     = @@test_file1
-    @test_trail    = @@test_file_trail
-    @test_trail_nl = @@test_file_trail_nl
-    @test_file_64  = @@test_file64
-    @test_file_128 = @@test_file128
-
-    @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
-
-  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_more_lines_than_file
-    assert_equal( @expected_tail_more, File.tail(@test_file, 30) )
-  end
-
-  def test_tail_expected_errors
-    assert_raises(ArgumentError){ File.tail }
-    assert_raises(ArgumentError){ File.tail(@test_file, 5, 5) }
-  end
-
-  def test_no_trailing_newline
-    assert_equal( @expected_tail_trail, File.tail(@test_trail, 2) )
-    assert_equal( @expected_tail_trail, File.tail(@test_trail_nl, 2) )
-  end
-
-  def test_tail_larger_than_64k
-    expected_tail_64k=[]
-    2000.times{ |n| expected_tail_64k.push( @test_tail_fmt_str % (n+1).to_s ) }
-    assert_equal( expected_tail_64k, File.tail(@test_file_64, 2000) )
-  end
-
-  def test_tail_larger_than_128k
-    expected_tail_128k = []
-    4500.times{ |n| expected_tail_128k.push( @test_tail_fmt_str % (n+1).to_s ) }
-    assert_equal( expected_tail_128k, File.tail(@test_file_128, 4500) )
-  end
-
-  def teardown
-    @test_file = nil
-    @expected_tail1 = nil
-    @expected_tail2 = nil
-  end
-
-  def self.shutdown
-    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