external 0.1.0

data/test/external/base_test.rb

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

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

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

data/test/external_test_helper.rb

@@ -0,0 +1,31 @@
+require 'tap'
+require 'tap/test/file_methods'
+require 'tap/test/subset_methods'
+
+require File.join(File.dirname(__FILE__), 'test_array.rb')
+
+class Test::Unit::TestCase
+  include Tap::Test::SubsetMethods
+  
+  # method to duplicate one of the source files to a target file
+  def dup_file(source_base, target_base)
+    filepath = tempfile(target_base)
+    FileUtils.cp(source_base + '.txt', filepath + ".txt")
+    FileUtils.cp(source_base + '.index', filepath + ".index")
+    
+    filepath + ".txt"
+  end
+  
+  #
+  #  The default data 
+  #
+  
+  def string
+    "abcdefgh"
+  end
+  
+  def array
+    ["a", "b", "c", "d", "e", "f", "g", "h"]
+  end
+
+end

data/test/external_test_suite.rb

@@ -0,0 +1,4 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+#ENV["ALL"] = 'true'
+Dir.glob("./**/*_test.rb").each {|test| require test}