external 0.1.0

data/test/benchmarks/test_copy_file.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
+require 'tempfile'
+require 'fileutils'
+
+ENV['ALL'] = 'true'
+
+class TestCopyFile < Test::Unit::TestCase
+  include Benchmark
+  include Tap::Test::SubsetMethods
+  
+  
+  # The lesson from this test is that chunky copy can be 
+  # faster than FileUtils.cp  It's interesting to note
+  # that if you look up the code, you can see that a
+  # chunky copy is exactly what cp is... with chunks of
+  # 1024 bytes.
+  def test_copy_vs_chunky_rewrite
+    t = Tempfile.new "large_file"
+    t.close
+    puts t.path
+
+    prompt_test(:path_to_large_file) do |config|
+      path = config[:path_to_large_file]
+      
+      benchmark_test do |x|
+        x.report("copy") { FileUtils.cp(path, t.path) }
+        assert FileUtils.cmp(path, t.path)
+        
+        # tenmb = 1 * 2097152
+        # x.report("chunk 2MB") do 
+        #   File.open(path, "r") do |src|
+        #     File.open(t.path, "w") do |target|
+        #       str = ""
+        #       while src.read(tenmb, str)
+        #         target << str
+        #       end
+        #     end
+        #   end
+        # end
+        
+        tenmb = 4 * 2097152
+        x.report("chunk 8MB") do 
+          File.open(path, "r") do |src|
+            File.open(t.path, "w") do |target|
+              str = ""
+              while src.read(tenmb, str)
+                target << str
+              end
+            end
+          end
+        end
+        assert FileUtils.cmp(path, t.path)
+        
+        # tenmb = 4 * 2097152
+        # x.report("chunk 8MB - no buf") do 
+        #   File.open(path, "r") do |src|
+        #     File.open(t.path, "w") do |target|
+        #       while str = src.read(tenmb)
+        #         target << str
+        #       end
+        #     end
+        #   end
+        # end
+        
+        # tenmb = 10 * 2097152
+        # x.report("chunk 20MB") do 
+        #   File.open(path, "r") do |src|
+        #     File.open(t.path, "w") do |target|
+        #       str = ""
+        #       while src.read(tenmb, str)
+        #         target << str
+        #       end
+        #     end
+        #   end
+        # end
+
+      end
+    end
+  end
+end

data/test/benchmarks/test_pos_speed.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
+require 'tempfile'
+require 'enumerator'
+require 'scanf'
+
+class TestPosSpeed < Test::Unit::TestCase
+  include Benchmark
+
+  attr_reader :path
+  
+  def setup
+    t = Tempfile.new('integers')
+    ints = [*(1..100000).to_a]
+    t << ints.pack("I*")
+    t.close
+    @path = t.path
+  end
+  
+  def test_pos_speed
+    file = File.open(path, "r")
+    length = file.stat.size
+    positions = Array.new(1000) do
+      p = rand(length)
+    end
+    
+    benchmark_test(20) do |x|
+      x.report("100kx pos=") do
+        (1000).times do
+          positions.each do |p|
+            file.pos = p
+            file.pos = p
+          end
+        end
+      end
+      
+      x.report("100kx pos= with check") do
+        (1000).times do
+          positions.each do |p|
+            file.pos = p
+            file.pos = p unless file.pos = p
+          end
+        end
+      end
+    end   
+  end
+
+end

data/test/benchmarks/test_read_time.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '../external_test_helper.rb') 
+require 'tempfile'
+require 'enumerator'
+require 'scanf'
+
+class TestReadTime < Test::Unit::TestCase
+  include Benchmark
+
+  attr_reader :path, :ints
+  
+  def setup
+    t = Tempfile.new('integers')
+    ints = [*(1..100000).to_a]
+    t << ints.pack("I*")
+    t.close
+    @path = t.path
+    
+    @ints = []
+    ints.each_slice(1) do |s|
+      @ints << s
+    end
+  end
+  
+  def test_read_time
+    file = File.open(path, "r")
+    results = nil
+
+    benchmark_test(20) do |x|
+      x.report("10x full (1)") do 
+        (10).times do 
+          file.pos = 0
+          str = file.read
+          results = []
+          str.unpack("I*").each_slice(1) do |s|
+            results << s
+          end
+        end 
+      end
+      assert_equal ints, results
+      
+      x.report("10x singles (1)") do 
+        (10).times do 
+          file.pos = 0
+          
+          results = []
+          ints.length.times do
+            results << file.read(4).unpack("I")
+          end
+        end 
+      end
+      assert_equal ints, results
+    end   
+  end
+
+end

data/test/cached_ext_ind_test.rb

@@ -0,0 +1,219 @@
+require File.join(File.dirname(__FILE__), 'ext_ind_test.rb') 
+
+class CachedExtIndTest < ExtIndTest
+  class CachedExtInd < ExtInd
+    def initialize(io=nil, options={})
+      options = {
+        :cached => true
+      }.merge(options)
+      
+      super(io, options)
+    end
+  end
+  
+  def setup
+    # cls represents an array
+    @cls = CachedExtInd
+
+    @index = CachedExtInd.new
+    @index.cache.concat(framed_array)
+  end
+  
+  def teardown
+  end
+  
+  #
+  # setup tests
+  #
+  
+  def test_setup
+    assert_equal CachedExtInd, @cls
+    
+    assert_equal 0, index.pos
+    assert_equal 5, index.length
+    assert_equal 4, index.frame_size
+    assert index.cached?
+    assert_equal framed_array, index.cache
+  end
+  
+  
+  #
+  # initialize tests
+  #
+  
+  undef_method :test_index_initialized_to_single_int_format_by_default
+  
+  def test_cache_initialized_to_empty_array_in_cached_mode
+    index = @cls.new
+  
+    assert_equal 'I*', index.format
+    assert_equal 1, index.frame
+    assert_equal 4, index.frame_size
+    assert_equal [0], index.nil_value
+    assert index.cached?
+    assert_equal [], index.cache
+  end
+  
+  def test_cache_initialized_to_empty_array_in_cached_mode_regardless_of_format
+    index = @cls.new nil, :format => "IQS"
+
+    assert index.cached?
+    assert_equal [], index.cache
+  end
+  
+  #
+  # class read tests
+  #
+  
+  undef_method :test_read_returns_the_index_file_in_frame
+  
+  #
+  # class directive size tests
+  #
+  
+  undef_method :test_directive_size_returns_the_number_of_bytes_to_pack_a_directive
+ 
+  #
+  # length test
+  #
+  
+  undef_method :test_length_returns_io_length_divided_by_frame_size
+  
+  def test_length_returns_cache_length
+    assert_equal index.cache.length, index.length
+    
+    index.cache.clear
+    assert_equal 0, index.length
+    
+    index.cache.concat([[1],[2],[3]])
+    assert_equal 3, index.length
+  end
+  
+  def test_length_is_separate_from_io_length
+    index.cache.clear
+    assert_equal 0, index.length
+    
+    index.io.length = 10
+    assert_equal 0, index.length
+  end
+  
+  #
+  # pos test
+  #
+  
+  undef_method :test_pos_returns_io_pos_divided_by_frame_size
+  
+  def test_pos_is_kept_separate_from_io_pos_in_cached_mode
+    assert_equal 0, index.io.pos
+    assert_equal 0, index.pos
+    
+    index.io.pos = 4
+    assert_equal 4, index.io.pos
+    assert_equal 0, index.pos
+  end
+  
+  #
+  # pos= test
+  #
+  
+  undef_method :test_pos_set_sets_io_pos_to_index_value_of_input_times_frame_size
+  
+  def test_pos_set_sets_pos_to_index_value_of_input
+    index.pos = 1
+    assert_equal 1, index.pos
+    
+    index.pos = -1
+    assert_equal 4, index.pos
+  end
+  
+  #
+  # readbytes test
+  #
+  
+  undef_method :test_readbytes_behavior_is_like_io_behavior
+  
+  #
+  # unframed_write tests
+  #
+  
+  undef_method :test_unframed_write_unframed_writes_packed_array_to_io_at_pos_and_adjusts_io_length
+  
+  def test_unframed_write_unframed_writes_packed_array_to_cache_in_frame_and_does_not_affect_io
+    index = @cls.new
+    index.unframed_write([1,2,3])
+    assert_equal 0, index.io.length
+    assert_equal 0, index.io.pos
+    
+    assert_equal [[1],[2],[3]], index.cache
+     
+    index.unframed_write([-2], 1)
+    assert_equal 0, index.io.length
+    assert_equal 0, index.io.pos
+
+    assert_equal [[1],[-2],[3]], index.cache
+  end
+  
+  def test_unframed_write_pads_with_nil_value_if_position_is_past_length
+    index = @cls.new nil, :nil_value => [8]
+    assert_equal 0, index.length
+    
+    index.unframed_write([1,2,3], 2)
+    assert_equal [[8],[8],[1],[2],[3]], index.cache
+  end
+  
+  def test_unframed_write_unframed_writes_nothing_with_empty_array
+    assert_equal framed_array, index.cache
+    
+    index.unframed_write([])
+    assert_equal framed_array, index.cache
+    
+    index.unframed_write([], 0)
+    assert_equal framed_array, index.cache
+  end
+  
+  #
+  # mixed formats test
+  #
+  
+  def test_read_handles_mixed_formats
+    index = @cls.new nil, :format => "IQS"
+    
+    index.cache << [1,2,3]
+    index.cache << [4,5,6]
+    index.cache << [7,8,9]
+    
+    assert_equal [[1,2,3],[4,5,6],[7,8,9]], index.read
+    
+    index.pos = 1
+    assert_equal [4,5,6], index.read(1)
+  end
+  
+  def test_unframed_write_handles_mixed_formats
+    index = @cls.new nil, :format => "IQS"
+    a = [1,2,3]
+    b = [4,5,6]
+    c = [7,8,9]
+    d = [-4,-5,-6]
+    
+    index.unframed_write([1,2,3,4,5,6,7,8,9])
+    assert_equal [a,b,c], index.cache
+
+    index.pos = 1
+    index.unframed_write([-4,-5,-6])
+    assert_equal [a,d,c], index.cache
+  end
+  
+  #
+  # numeric format range tests
+  #
+  
+  undef_method :test_read_and_unframed_write_handles_full_numeric_range_for_numeric_formats
+  undef_method :test_read_and_unframed_write_cycle_numerics_beyond_natural_range
+  undef_method :test_numerics_cycle_up_to_the_unsigned_max_in_either_sign
+
+  def test_unframed_write_does_NOT_check_formatting_of_input_in_cached_mode
+    index = @cls.new nil, :format => "S"
+    assert_raise(RangeError) { [ExtIndTest::ULLONG_MAX].pack("S") }
+    assert_nothing_raised { index.unframed_write([ExtIndTest::ULLONG_MAX]) }
+  end
+end