external 0.1.0 → 0.3.0

data/test/external/base_test.rb

@@ -1,74 +0,0 @@
-require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
-require 'external/base'
-require 'tempfile'
-
-class BaseTest < Test::Unit::TestCase
-  include Benchmark
-  include External
-
-  acts_as_file_test
-  
-  attr_reader :array, :ab, :tempfile
-
-  def setup
-    @array = ('a'..'z').to_a
-    @tempfile = Tempfile.new("abtest")
-    @tempfile << array.to_s
-    @ab = Base.new(@tempfile)
-  end
-  
-  def teardown
-    tempfile.close unless tempfile.closed?
-  end
-
-  #
-  # setup tests
-  #
-
-  def test_setup
-    assert_equal ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"], array
-    assert_equal "abcdefghijklmnopqrstuvwxyz", array.to_s
-    
-    tempfile.pos = 0
-    assert_equal "abcdefghijklmnopqrstuvwxyz", tempfile.read
-  end
-
-  #
-  # initialize test
-  #
-  
-  def test_io_points_to_tempfile_when_io_is_nil
-    begin
-      ab = Base.new(nil)
-      assert ab.io != nil
-      assert_equal Tempfile, ab.io.class
-      assert ab.io.path =~ Regexp.new("^" + Dir.tmpdir)
-    ensure
-      ab.close if ab
-    end
-  end
-  
-  # def test_options_are_set_during_initialize
-  #   assert_equal 10000, ab.max_gap
-  #   assert_equal 1000000, ab.max_chunk_size
-  #   
-  #   ab = Base.new(nil, :max_gap => 1, :max_chunk_size => 10)
-  #   assert_equal 1, ab.max_gap
-  #   assert_equal 10, ab.max_chunk_size
-  # end
-  
-  #
-  # close, closed? test
-  #
-
-  def test_close_closes_io
-    assert !ab.io.closed?
-    ab.close
-    assert ab.io.closed?
-  end
-  
-  def test_closed_returns_closed_state_of_io
-    ab.io.close   
-    assert ab.closed?
-  end
-end

data/test/external/chunkable_test.rb

@@ -1,182 +0,0 @@
-require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
-require 'external/chunkable'
-require 'pp'
-
-class ChunkableTest < Test::Unit::TestCase
-  include Benchmark
-  include External::Chunkable
-  
-  def setup
-    @default_blksize = 100
-    @length = 10
-  end
-  
-  def pps(obj)
-    PP.singleline_pp(obj, "")
-  end
-  
-  def test_setup
-    assert_equal 100, default_blksize
-    assert_equal 10, length
-  end
-
-  #
-  # default_span
-  #
-  
-  def test_default_span_is_zero_to_length
-    assert_equal [0,length], default_span
-  end
-  
-  #
-  # split_range 
-  #
-  
-  def test_split_range_doc
-    assert_equal 10, length
-    assert_equal [0,10], split_range(0..10) 
-    assert_equal [0,9], split_range(0...10) 
-    assert_equal [9,1], split_range(-1..10) 
-    assert_equal [0,9], split_range(0..-1)
-  end
-  
-  def test_split_range
-    {
-      0..100 => [0,100],
-      0...100 => [0, 99],
-      1..100 => [1,99],
-      1...100 => [1,98]
-    }.each_pair do |range, expected|
-      assert_equal expected, split_range(range), range
-    end
-  end
-  
-  def test_split_range_for_negative_indicies_counts_back_from_length
-    assert_equal 10, length
-    {
-      # for begin index
-      -1..100 => [9,91],  # equivalent to 9..100
-      -1...100 => [9,90],
-      -2..100 => [8,92],
-      -2...100 => [8,91],
-      -11..100 => [-1,101],
-      -11...100 => [-1,100],
-      
-      # for end index
-      0..-1 => [0,9],  # equivalent to 0..9
-      0...-1 => [0,8],
-      0..-10 => [0,0]
-    }.each_pair do |range, expected|
-      assert_equal expected, split_range(range), range
-    end
-  end
-  
-  def test_split_range_for_zero_cases
-    {
-      0..0 => [0,0],
-      0...0 => [0,-1],
-      -0..-0 => [0,0],
-      -0...-0 => [0,-1]
-    }.each_pair do |range, expected|
-      assert_equal expected, split_range(range), range
-    end
-  end
-  
-  #
-  # chunk tests
-  #
-  
-  def test_chunk_documentation
-    assert_equal 100, default_blksize 
-    assert_equal [[0,100],[100,100],[200,50]], chunk(0..250) 
-    
-    results = []
-    chunk([10,190]) {|offset, length| results << [offset, length]}
-    assert_equal [[10,100],[110,90]], results
-  end
-
-  def test_chunk_returns_offset_and_length_of_each_chunk
-    assert_equal [[0,99]], chunk([0,99])
-    assert_equal [[0,100]], chunk([0,100])
-    assert_equal [[0,100],[100,1]], chunk([0,101])
-    assert_equal [[0,100],[100,100],[200,100]], chunk([0,300])
-    assert_equal [[50,100],[150,100],[250,50]], chunk([50,250])
-    
-    # zero or neg length
-    assert_equal [], chunk([0,0])
-    assert_equal [], chunk([0,-1])
-    
-    # neg index
-    assert_equal [[9,100]], chunk([-1,100])
-    assert_equal [[0,100]], chunk([-10,100])
-    assert_raise(ArgumentError) { chunk([-11,100]) }
-    assert_raise(ArgumentError) { chunk([-11,0]) }
-  end
-  
-  def test_chunk_uses_default_span_without_inputs
-    assert_equal [0,10], default_span
-    assert_equal [[0,10]], chunk
-    
-    self.length = 300
-    assert_equal [0, 300], default_span
-    assert_equal [[0,100],[100,100],[200,100]], chunk
-  end
-  
-  def test_chunk_passes_results_to_block_if_given
-    results = []
-    chunk([0,300]) do |offset, length|
-      results << [offset, length]
-    end
-      
-    assert_equal [[0,100],[100, 100],[200, 100]], results
-  end
-
-  #
-  # reverse chunk tests
-  #
-  
-  def test_reverse_chunk_documentation
-    assert_equal 100, default_blksize 
-    assert_equal [[150,100],[50,100],[0,50]], reverse_chunk(0..250) 
-    
-    results = []
-    reverse_chunk([10,190]) {|offset, length| results << [offset, length]}
-    assert_equal [[100,100],[10,90]], results
-  end
-  
-  def test_reverse_chunk_returns_offset_and_length_of_each_chunk
-    assert_equal [[0,99]], reverse_chunk([0,99])
-    assert_equal [[0,100]], reverse_chunk([0,100])
-    assert_equal [[1,100],[0,1]], reverse_chunk([0,101])
-    assert_equal [[200,100],[100,100],[0,100]], reverse_chunk([0,300])
-    assert_equal [[200,100],[100,100],[50,50]], reverse_chunk([50,250])
-    
-    # zero or neg length
-    assert_equal [], reverse_chunk([0,0])
-    assert_equal [], reverse_chunk([0,-1])
-
-    # neg index
-    assert_equal [[9,100]], reverse_chunk([-1,100])
-    assert_equal [[0,100]], reverse_chunk([-10,100])
-    assert_raise(ArgumentError) { reverse_chunk([-11,100]) }
-    assert_raise(ArgumentError) { reverse_chunk([-11,0]) }
-  end
-
-  def test_reverse_chunk_uses_default_span_without_inputs
-    assert_equal [0,10], default_span
-    assert_equal [[0,10]], reverse_chunk
-    
-    self.length = 300
-    assert_equal [0,300], default_span
-    assert_equal [[200,100],[100,100],[0,100]], reverse_chunk
-  end
-  
-  def test_reverse_chunk_passes_results_to_block_if_given
-    results = []
-    reverse_chunk([0,300]) do |offset, length|
-      results << [offset, length]
-    end
-      
-    assert_equal [[200,100],[100,100],[0,100]], results
-  end
-end

data/test/external/io_test.rb

@@ -1,414 +0,0 @@
-require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
-require 'external/io'
-
-class  IOTest < Test::Unit::TestCase
-  include External
-  
-  def std_class_test(data)
-    Tempfile.open("file_test") do |tempfile|
-      tempfile << data
-      tempfile.flush
-    
-      File.open(tempfile.path, "r+") do |file|
-        file.extend IO
-        yield(file)
-      end
-    end
-    
-    Tempfile.open("tempfile_test") do |tempfile|
-      tempfile << data
-      tempfile.extend IO
-
-      yield(tempfile)
-    end
-    
-    Tempfile.open("strio_test") do |tempfile|
-      tempfile << data
-      tempfile.flush
-    
-      tempfile.pos = 0
-      StringIO.open(tempfile.read, "r+") do |file|
-        file.extend IO
-        yield(file)
-      end
-    end
-  end
-  
-  #
-  # length test
-  #
-  
-  def test_length_is_set_to_file_size_upon_extend_for_file
-    # File
-    t = Tempfile.new "position_test"
-    t << "abcd"
-    t.close
-    
-    File.open(t.path, "r+") do |file|
-      file.extend IO
-      assert_equal 4, file.length 
-      assert_equal 4, File.size(file.path)
-    end
-
-    # Tempfile
-    t = Tempfile.new "position_test"
-    t << "abcd"
-    t.fsync
-    assert_equal 4, File.size(t.path)
-    
-    t.extend IO
-    assert_equal 4, t.length
-
-    t.close
-  end
-  
-  def test_length_does_NOT_automatically_correspond_to_file_size
-    t = Tempfile.new "position_test"
-    t.close 
-    
-    assert_equal 0, File.size(t.path)
-    File.open(t.path, "r+") do |file|
-      file.extend IO
-    
-      assert_equal 0, file.length
-      assert_equal 0, File.size(t.path)
-      
-      file << "abcd"
-      file.fsync
-      
-      assert_equal 0, file.length
-      assert_equal 4, File.size(t.path)
-    end
-    
-    
-    # Tempfile
-    t = Tempfile.new "position_test"
-    t.extend IO
-    
-    assert_equal 0, t.length
-    assert_equal 0, File.size(t.path)
-    
-    t << "abcd"
-    t.fsync
-    
-    assert_equal 0, t.length
-    assert_equal 4, File.size(t.path)
-    
-    t.close
-  end
-  
-  #
-  # reset length test
-  #
-  
-  def test_reset_length_resets_length_to_file_size
-    # File
-    t = Tempfile.new "position_test"
-    t.close
-    
-    File.open(t.path, "r+") do |file|
-      file.extend IO
-    
-      assert_equal 0, file.length
-      assert_equal 0, File.size(file.path)
-    
-      file << "abcd"
-      file.fsync
-    
-      assert_equal 0, file.length
-      assert_equal 4, File.size(t.path)
-    
-      file.reset_length
-    
-      assert_equal 4, file.length
-    end
-    
-    # Tempfile
-    t = Tempfile.new "position_test"
-    t.extend IO
-    
-    assert_equal 0, t.length
-    assert_equal 0, File.size(t.path)
-    
-    t << "abcd"
-    t.fsync
-    
-    assert_equal 0, t.length
-    assert_equal 4, File.size(t.path)
-    
-    t.reset_length
-    
-    assert_equal 4, t.length
-    
-    t.close
-  end
-
-  #
-  # position test
-  #
-  
-  def two_gb_size
-    2147483647
-  end
-  
-  def test_position_mswin
-    platform_test('mswin') do 
-      prompt_test(:path_to_large_file) do |path|
-        path = $1 if path =~ /^"([^"]*)"$/ 
-
-        File.open(path) do |file|
-          file.extend IO
-          
-          # stat.size < 0 due to windows bug
-          assert file.stat.size < 0, "File size must be > 2GB (only #{file.length/two_gb_size})"
-          assert file.length > two_gb_size + 5,  "File size must be > 2GB (only #{file.length/two_gb_size})"
-          
-          file.pos = two_gb_size
-          assert_equal two_gb_size, file.pos
-          ten_bytes = file.read(10)
-          
-          file.pos = two_gb_size + 5
-          assert_equal two_gb_size + 5, file.pos
-          five_bytes = file.read(5)
-          
-          assert_equal ten_bytes[5..-1], five_bytes
-        end
-      end 
-    end
-  end
-  
-  def test_position
-    platform_test('non_mswin') do 
-      prompt_test(:path_to_large_file) do |path|
-        path = $1 if path =~ /^"([^"]*)"$/ 
-
-        File.open(path) do |file|
-          file.extend IO
-        
-          assert file.length > (two_gb_size + 5), "File size must be > 2GB (only #{file.length/two_gb_size})"
-        
-          file.pos = two_gb_size
-          assert_equal two_gb_size, file.pos
-          ten_bytes = file.read(10)
-        
-          file.pos = two_gb_size + 5
-          assert_equal two_gb_size + 5, file.pos
-          five_bytes = file.read(5)
-        
-          assert_equal ten_bytes[5..-1], five_bytes
-        end
-      end
-    end
-  end
-
-  #
-  # generic_mode test
-  #
-  
-  def test_generic_modes_are_determined_correctly
-    {
-      "r" => "r",
-      "r+" => "r+",
-      "w" => "w",
-      "w+" => "r+",
-      "a" => "w",
-      "a+" => "r+"
-    }.each_pair do |mode, expected|
-      Tempfile.open("position_test") do |t|
-        File.open(t.path, mode) do |file|
-          file.extend IO
-          assert_equal expected, file.generic_mode, mode
-          assert !file.closed?
-        end
-      end
-      
-      StringIO.open("", mode) do |file|
-        file.extend IO
-        assert_equal expected, file.generic_mode, mode
-        assert !file.closed?
-      end
-    end
-  end
-  
-  #
-  # quick_compare test
-  #
-  
-  def test_quick_compare_true_if_another_is_self
-    std_class_test("") do |io|
-      assert io.quick_compare(io)
-    end
-  end
-  
-  def test_quick_compare_true_if_paths_of_self_and_another_are_the_same
-    Tempfile.open("a") do |a|
-      a.extend IO
-      
-      File.open(a.path) do |b|
-        b.extend IO
-        
-        assert a != b
-        assert a.path == b.path
-        assert a.quick_compare(b)
-      end
-    end
-  end
-  
-  #
-  # <=> test
-  #
-
-  def test_sort_compare_with_self
-    std_class_test("") do |io|
-      assert_equal 0, (io <=> io)
-    end
-  end
-
-  def test_sort_compare_with_same_file
-    Tempfile.open("a") do |a|
-      a.extend IO
-      
-      File.open(a.path) do |b|
-        b.extend IO
-        
-        assert a != b
-        assert a.path == b.path
-        assert_equal 0, (a <=> b)
-      end
-    end
-  end
-  
-  def test_sort_compare_with_unequal_lengths
-    Tempfile.open("a") do |a|
-      a << "abcd"
-      a.extend IO
-      
-      Tempfile.open("b") do |b|
-        b << "abc"
-        b.extend IO
-        
-        assert !a.quick_compare(b)
-        assert_equal 1, ("abcd" <=> "abc")
-        assert_equal 1, (a <=> b)
-        
-        assert_equal -1, ("abc" <=> "abcd")
-        assert_equal -1, (b <=> a)
-      end
-    end
-  end
-  
-  def test_sort_compare
-    Tempfile.open("a") do |a|
-      a << "abcd"
-      a.extend IO
-      
-      Tempfile.open("b") do |b|
-        b << "abcz"
-        b.extend IO
-        
-        assert_equal -1, ("abcd" <=> "abcz")
-        assert_equal -1, (a <=> b)
-        
-        assert_equal 1, ("abcz" <=> "abcd")
-        assert_equal 1, (b <=> a)
-      end
-    end
-  end
-  
-  def test_sort_compare_same_content
-    Tempfile.open("a") do |a|
-      a.extend IO
-      a << "abcd"
-      
-      Tempfile.open("b") do |b|
-        b.extend IO
-        b << "abcd"
-        
-        assert a.path != b.path
-        assert_equal 0, (a <=> b)
-      end
-    end
-  end
-  
-  def test_sort_compare_no_content
-    Tempfile.open("a") do |a|
-      a.extend IO
-      
-      Tempfile.open("b") do |b|
-        b.extend IO
-
-        assert a.path != b.path
-        assert_equal 0, (a <=> b)
-      end
-    end
-  end
-  
-  def test_sort_compare_with_different_underlying_io_types
-    Tempfile.open("a") do |a|
-      a << "abcd"
-      a.extend IO
-      
-      StringIO.open("abcz") do |b|
-        b.extend IO
-        
-        assert_equal -1, ("abcd" <=> "abcz")
-        assert_equal -1, (a <=> b)
-        
-        assert_equal 1, ("abcz" <=> "abcd")
-        assert_equal 1, (b <=> a)
-      end
-    end
-  end
-
-  #
-  # copy test
-  #
-  
-  def test_std_class_test
-    classes = []
-    std_class_test("some data") do |io|
-      assert io.kind_of?(IO)
-      assert "r+", io.generic_mode
-      
-      io.pos = 0
-      assert_equal "some data", io.read
-      
-      # the new data will throw the previous assertion
-      # if the ios are not independent
-      io << " new data"  
-      io.pos = 0
-      assert_equal "some data new data", io.read
-      
-      classes << io.class
-    end
-    
-    assert_equal [File, Tempfile, StringIO], classes
-  end
-  
-  def test_copy_opens_a_copy_in_read_mode
-    data = "test data"
-    
-    std_class_test(data) do |io|
-      copy_path = nil
-      io.copy do |copy|
-        assert_equal "r", copy.generic_mode
-        assert_equal data, copy.read
-
-        copy_path =  copy.path
-        assert_not_equal io.path, copy_path
-      end
-
-      assert !copy_path.nil?
-      assert !File.exists?(copy_path)
-    end
-  end
-  
-  def test_copy_opens_copy_in_mode_if_provided 
-    std_class_test("") do |io|
-      assert_equal "r+", io.generic_mode
-      io.copy("w") do |copy|
-        assert_equal "w", copy.generic_mode
-      end
-    end
-  end
-end