external 0.1.0

data/test/ext_ind_test.rb

@@ -0,0 +1,1472 @@
+require File.join(File.dirname(__FILE__), 'external_test_helper.rb') 
+require 'ext_ind'
+require 'fileutils'
+
+require 'ext_arr'
+
+class ExtIndTest < Test::Unit::TestCase
+  include Benchmark
+  include External
+  include TestArray
+
+  attr_reader :index, :tempfile
+
+  def setup
+    # cls represents an array
+    @cls = ExtInd
+
+    @tempfile = Tempfile.new("indextest")
+    @tempfile << array.pack(format)
+    @tempfile.pos = 0
+    
+    @index = ExtInd.new(@tempfile)
+  end
+  
+  def array
+    [1,2,3,4,5]
+  end
+  
+  def framed_array
+    [[1],[2],[3],[4],[5]]
+  end
+  
+  def format
+    "I*"
+  end
+  
+  def teardown
+    @tempfile.close unless @tempfile.closed?
+  end
+
+  #
+  #  readme doc test
+  #
+  
+  def test_readme_doc_for_ext_ind
+    ea = ExtArr.new
+    assert_equal ExtInd, ea.index.class
+    index = ea.index
+    assert_equal 'I*', index.format
+    assert_equal 2, index.frame
+    index << [1,2]
+    index << [3,4]
+    assert_equal [[1,2],[3,4]], index.to_a
+    
+    Tempfile.open('test_readme_doc_for_ext_ind') do |file|
+      file << [1,2,3].pack("IQS")
+      file << [4,5,6].pack("IQS")
+      file << [7,8,9].pack("IQS")
+      file.flush
+
+      index = ExtInd.new(file, :format => "IQS")
+      assert_equal [4,5,6], index[1]
+      assert_equal [[1,2,3],[4,5,6],[7,8,9]], index.to_a
+    end
+  end
+  
+  #
+  # setup tests
+  #
+  
+  def test_setup
+    assert_equal ExtInd, @cls
+    
+    assert_equal 0, index.pos
+    assert_equal 5, index.length
+    assert_equal 4, index.frame_size
+    assert_equal 8 * 2**20, index.buffer_size
+    assert_equal [0], index.nil_value
+    assert !index.cached?
+    assert_nil index.cache
+    assert_equal({:format => "I", :buffer_size => 8 * 2**20, :nil_value => [0], :cached => false}, index.options)
+    
+    tempfile.pos = 0
+    assert_equal array.pack(format), tempfile.read
+    assert_equal tempfile.path, index.io.path
+  end
+  
+  #
+  # class read tests
+  #
+  
+  def test_read_returns_the_index_file_in_frame
+    assert_equal framed_array, ExtInd.read(tempfile.path)
+    
+    tempfile.pos = tempfile.length
+    tempfile << [6].pack("I")
+    tempfile.flush
+    tempfile.pos = 0
+    assert_equal [1,2,3,4,5,6].pack("I*"), tempfile.read
+    
+    assert_equal [[1,2],[3,4],[5,6]], ExtInd.read(tempfile.path, :format => 'II')
+  end
+  
+  #
+  # class directive size tests
+  #
+  
+  def test_directive_size_returns_the_number_of_bytes_to_pack_a_directive
+    # @     |  Moves to absolute position
+    # not implemented
+    assert_nil ExtInd.directive_size('@')
+    # A     |  ASCII string (space padded, count is width)
+    assert_equal 1, ["a"].pack("A").length
+    assert_equal 1, ExtInd.directive_size('A')
+    # a     |  ASCII string (null padded, count is width)
+    assert_equal 1, ["a"].pack("a").length
+    assert_equal 1, ExtInd.directive_size('a')
+    # B     |  Bit string (descending bit order)
+    assert_equal 1, ['a'].pack("B").length
+    assert_equal 1, ExtInd.directive_size('B')
+    # b     |  Bit string (ascending bit order)
+    assert_equal 1, ['a'].pack("b").length
+    assert_equal 1, ExtInd.directive_size('b')
+    # C     |  Unsigned char
+    assert_equal 1, [1].pack("C").length
+    assert_equal 1, ExtInd.directive_size('C')
+    # c     |  Char
+    assert_equal 1, [1].pack("c").length
+    assert_equal 1, ExtInd.directive_size('c')
+    # D, d  |  Double-precision float, native format
+    assert_equal 8, [1].pack("D").length
+    assert_equal 8, ExtInd.directive_size('D')
+    assert_equal 8, [1].pack("d").length
+    assert_equal 8, ExtInd.directive_size('d')
+    # E     |  Double-precision float, little-endian byte order
+    assert_equal 8, [1].pack("E").length
+    assert_equal 8, ExtInd.directive_size('E')
+    # e     |  Single-precision float, little-endian byte order
+    assert_equal 4, [1].pack("e").length
+    assert_equal 4, ExtInd.directive_size('e')
+    # F, f  |  Single-precision float, native format
+    assert_equal 4, [1].pack("F").length
+    assert_equal 4, ExtInd.directive_size('F')
+    assert_equal 4, [1].pack("f").length
+    assert_equal 4, ExtInd.directive_size('f')
+    # G     |  Double-precision float, network (big-endian) byte order
+    assert_equal 8, [1].pack("G").length
+    assert_equal 8, ExtInd.directive_size('G')
+    # g     |  Single-precision float, network (big-endian) byte order
+    assert_equal 4, [1].pack("g").length
+    assert_equal 4, ExtInd.directive_size('g')
+    # H     |  Hex string (high nibble first)
+    assert_equal 1, ['a'].pack("H").length
+    assert_equal 1, ExtInd.directive_size('H')
+    # h     |  Hex string (low nibble first)
+    assert_equal 1, ['a'].pack("h").length
+    assert_equal 1, ExtInd.directive_size('h')
+    # I     |  Unsigned integer
+    assert_equal 4, [1].pack("I").length
+    assert_equal 4, ExtInd.directive_size('I')
+    # i     |  Integer
+    assert_equal 4, [1].pack("i").length
+    assert_equal 4, ExtInd.directive_size('i')
+    # L     |  Unsigned long
+    assert_equal 4, [1].pack("L").length
+    assert_equal 4, ExtInd.directive_size('L')
+    # l     |  Long
+    assert_equal 4, [1].pack("l").length
+    assert_equal 4, ExtInd.directive_size('l')
+    # M     |  Quoted printable, MIME encoding (see RFC2045)
+    assert_equal 3, ['a'].pack("M").length
+    assert_equal 3, ExtInd.directive_size('M')
+    # m     |  Base64 encoded string
+    assert_equal 5, ['a'].pack("m").length
+    assert_equal 5, ExtInd.directive_size('m')
+    # N     |  Long, network (big-endian) byte order
+    assert_equal 4, [1].pack("N").length
+    assert_equal 4, ExtInd.directive_size('N')
+    # n     |  Short, network (big-endian) byte-order
+    assert_equal 2, [1].pack("n").length
+    assert_equal 2, ExtInd.directive_size('n')
+    # P     |  Pointer to a structure (fixed-length string)
+    assert_equal 4, ['a'].pack("P").length
+    assert_equal 4, ExtInd.directive_size('P')
+    # p     |  Pointer to a null-terminated string
+    assert_equal 4, ['a'].pack("p").length
+    assert_equal 4, ExtInd.directive_size('p')
+    # Q, q  |  64-bit number
+    assert_equal 8, [1].pack("Q").length
+    assert_equal 8, ExtInd.directive_size('Q')
+    assert_equal 8, [1].pack("q").length
+    assert_equal 8, ExtInd.directive_size('q')
+    # S     |  Unsigned short
+    assert_equal 2, [1].pack("S").length
+    assert_equal 2, ExtInd.directive_size('S')
+    # s     |  Short
+    assert_equal 2, [1].pack("s").length
+    assert_equal 2, ExtInd.directive_size('s')
+    # U     |  UTF-8
+    assert_equal 1, [1].pack("U").length
+    assert_equal 1, ExtInd.directive_size('U')
+    # u     |  UU-encoded string
+    assert_equal 6, ['a'].pack("u").length
+    assert_equal 6, ExtInd.directive_size('u')
+    # V     |  Long, little-endian byte order
+    assert_equal 4, [1].pack("V").length
+    assert_equal 4, ExtInd.directive_size('V')
+    # v     |  Short, little-endian byte order
+    assert_equal 2, [1].pack("v").length
+    assert_equal 2, ExtInd.directive_size('v')
+    # w     |  BER-compressed integer\fnm
+    # not implemented
+    assert_equal 1, [1].pack("w").length
+    assert_equal 1, ExtInd.directive_size('w')
+    # X     |  Back up a byte
+    # not implemented
+    assert_nil ExtInd.directive_size('X')
+    # x     |  Null byte
+    assert_equal 1, [nil].pack("x").length
+    assert_equal 1, ExtInd.directive_size('x')
+    # Z     |  Same as ``a'', except that null is added with *
+    assert_equal 1, ['a'].pack("Z").length
+    assert_equal 1, ExtInd.directive_size('Z')
+  end
+  
+  #
+  # initialize tests
+  #
+  
+  def test_index_initialized_to_single_int_format_by_default
+    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_nil index.cache
+  end
+  
+  def test_initialize_calculates_frame_and_frame_size_from_format
+    {
+      'I' => [1, 4],
+      'II' => [2, 8],
+      'IQS' => [3, 14]
+    }.each_pair do |format, expected|
+      index = @cls.new(nil, :format => format)
+  
+      assert_equal expected, [index.frame, index.frame_size]
+      assert_equal Array.new(expected.first, 0), index.nil_value
+    end
+  end
+  
+  def test_format_with_unknown_directive_raises_error
+    assert_raise(ArgumentError) { @cls.new(nil, :format => 'x') }
+  end
+  
+  def test_default_nil_value_is_calculated_according_to_frame
+    index = @cls.new(nil, :format => "I")
+    assert_equal [0], index.nil_value
+    
+    index = @cls.new(nil, :format => "II")
+    assert_equal [0, 0], index.nil_value
+  end
+  
+  def test_nil_value_can_be_provided_in_options
+    index = @cls.new(nil, :nil_value => [8])
+    assert_equal [8], index.nil_value
+    
+    index = @cls.new(nil, :format => "II", :nil_value => [8,9])
+    assert_equal [8,9], index.nil_value
+  end
+  
+  def test_nil_value_option_raises_error_if_out_of_frame
+    assert_raise(ArgumentError) { @cls.new(nil, :nil_value => [8, 9]) }
+    assert_raise(ArgumentError) { @cls.new(nil, :format => 'II', :nil_value => [0]) }
+  end
+  
+  #
+  # buffer_size test
+  #
+  
+  def test_index_and_io_chunk_and_gap_size_are_calculated_relative_to_buffer_size
+    index = @cls.new(nil, :buffer_size => 40000)
+    assert_equal 40000, index.buffer_size
+    assert_equal 4, index.frame_size
+    assert_equal 10000, index.default_blksize
+    assert_equal 40000, index.io.default_blksize
+
+    index.buffer_size = 80000
+    assert_equal 20000, index.default_blksize
+    assert_equal 80000, index.io.default_blksize
+  end
+  
+  def test_buffer_size_is_io_default_blksize
+    index = @cls.new
+    
+    index.io.default_blksize = 1000
+    assert_equal 1000, index.io.default_blksize
+    assert_equal 1000, index.buffer_size
+  end
+  
+  #
+  # default_blksize test
+  #
+  
+  def test_default_blksize_sets_io_default_blksize
+    index = @cls.new
+    assert_equal 4, index.frame_size
+    
+    index.default_blksize = 10000
+    assert_equal 10000, index.default_blksize
+    assert_equal 40000, index.io.default_blksize
+  end
+  
+  #
+  # nil_value tests
+  # 
+  
+  def test_nil_value_documentation
+    i = @cls.new 
+    assert_equal [0], i.nil_value         
+    assert_equal "\000\000\000\000",  i.nil_value(false)  
+  end
+  
+  #
+  # length test
+  #
+  
+  def test_length_returns_io_length_divided_by_frame_size
+    assert_equal 20, tempfile.length
+    assert_equal 5, index.length
+    
+    tempfile.length = 4
+    assert_equal 1, index.length
+    
+    tempfile.length = 0
+    assert_equal 0, index.length
+  end
+  
+  #
+  # pos test
+  #
+  
+  def test_pos_returns_io_pos_divided_by_frame_size
+    assert_equal 0, index.io.pos
+    assert_equal 0, index.pos
+    
+    index.io.pos = 4
+    assert_equal 1, index.pos
+    
+    index.io.pos = 20
+    assert_equal 5, index.pos
+  end
+  
+  #
+  # pos= test
+  #
+  
+  def test_pos_set_documentation
+    i = @cls[[1],[2],[3]]
+    assert_equal 3, i.length  
+    i.pos = 2
+    assert_equal 2, i.pos             
+    i.pos = -1
+    assert_equal 2, i.pos           
+  end
+  
+  def test_pos_set_sets_io_pos_to_index_value_of_input_times_frame_size
+    index.pos = 1
+    assert_equal 1, index.pos
+    assert_equal 4, index.io.pos
+    
+    index.pos = -1
+    assert_equal 4, index.pos
+    assert_equal 16, index.io.pos
+  end
+  
+  def test_positions_can_be_set_beyond_the_index_length
+    index.pos = 10
+    assert_equal 10, index.pos
+  end
+    
+  def test_pos_set_raises_error_if_out_of_bounds
+    assert_raise(ArgumentError) { index.pos = -6 }
+  end
+  
+  #
+  # readbytes test
+  #
+  
+  def test_readbytes_documentation
+    i = @cls[[1],[2],[3]]
+    assert_equal [1,2,3], i.readbytes.unpack("I*")       
+    assert_equal [1], i.readbytes(1,0).unpack("I*")      
+    assert_equal [2,3], i.readbytes(10,1).unpack("I*")    
+    i.pos = 3
+    assert_equal "", i.readbytes                    
+    assert_equal nil, i.readbytes(1)                 
+  end
+  
+  def test_readbytes_returns_bytestring_for_n_and_pos
+    assert_equal array.pack(format), index.readbytes(5,0) 
+    assert_equal array.pack(format), index.readbytes(5,-5) 
+    assert_equal [2,3].pack(format), index.readbytes(2,1) 
+    
+    assert_equal array.pack(format), index.readbytes(10,0)
+    assert_equal array.pack(format), index.readbytes(10,-5)
+  
+    index.pos = 0
+    assert_equal array.pack(format), index.readbytes
+    
+    index.pos = 3
+    assert_equal [4,5].pack(format), index.readbytes
+  
+    index.pos = 3
+    assert_equal [4].pack(format), index.readbytes(1)
+  end
+  
+  def test_readbytes_returns_nil_if_n_is_specified_and_no_entries_can_be_read
+    assert_nil index.readbytes(1,5)
+  end
+  
+  def test_readbytes_returns_empty_string_if_n_is_nil_and_no_entries_can_be_read
+    assert_equal "", index.readbytes(nil, 5)
+  end
+  
+  def test_readbytes_raises_error_if_position_is_out_of_bounds
+    assert_raise(ArgumentError) { index.readbytes(1,-6) }
+  end
+  
+  def test_readbytes_behavior_is_like_io_behavior
+    tempfile.pos = 20
+    assert_equal "", tempfile.read(nil)
+    assert_nil tempfile.read(1)
+  end
+  
+  #
+  # unpack tests
+  #
+  
+  def test_unpack_documentation
+    assert_equal "I*", index.format  
+    assert_equal [1], index.unpack( [1].pack('I*') )      
+    assert_equal [[1], [2], [3]], index.unpack( [1,2,3].pack('I*') ) 
+    assert_equal [], index.unpack("") 
+  end
+  
+  def test_unpack_unpacks_string_into_frames_using_format
+    assert_equal [[1],[2],[3],[4],[5]], index.unpack(array.pack(format))
+    assert_equal [1], index.unpack([1].pack(format))
+    assert_equal [], index.unpack("")
+  end
+  
+  #
+  # read tests
+  #
+  
+  def test_read_documentation
+    i = @cls[[1],[2],[3]]
+    assert_equal 0, i.pos                      
+    assert_equal [[1],[2],[3]], i.read                   
+    assert_equal [1], i.read(1,0)                 
+    assert_equal [[2],[3]], i.read(10,1)               
+    
+    i.pos = 3
+    assert_equal [], i.read                   
+    assert_equal nil, i.read(1)            
+  end
+  
+  def test_read_returns_unpacked_array_for_n_and_pos
+    assert_equal framed_array, index.read(5,0) 
+    assert_equal framed_array, index.read(5,-5) 
+    assert_equal [[2],[3]], index.read(2,1) 
+    
+    assert_equal framed_array, index.read(10,0)
+    assert_equal framed_array, index.read(10,-5)
+    
+    index.pos = 0
+    assert_equal framed_array, index.read
+    
+    index.pos = 3
+    assert_equal [[4],[5]], index.read
+  
+    index.pos = 3
+    assert_equal [4], index.read(1)
+  end
+  
+  def test_read_returns_nil_if_n_is_specified_and_no_entries_can_be_read
+    assert_nil index.read(1,5)
+  end
+  
+  def test_read_returns_empty_array_if_n_is_nil_and_no_entries_can_be_read
+    assert_equal [], index.read(nil, 5)
+  end
+  
+  def test_read_raises_error_if_position_is_out_of_bounds
+    assert_raise(ArgumentError) { index.read(1,-6) }
+  end
+  
+  #
+  # test unframed_write
+  #
+  
+  def test_documentation
+    i = @cls[]
+    i.unframed_write([2,3], 1) 
+    i.pos = 0
+    i.unframed_write([1])
+    assert_equal [[1],[2],[3]], i.read(3, 0)
+  end
+  
+  def test_unframed_write_unframed_writes_packed_array_to_io_at_pos_and_adjusts_io_length
+    index = @cls.new
+    index.unframed_write([1,2,3])
+    assert_equal 12, index.io.length
+    assert_equal 12, index.io.pos
+     
+    index.io.pos = 0
+    assert_equal [1,2,3].pack("I*"), index.io.read
+    
+    index.unframed_write([-2], 1)
+    assert_equal 12, index.io.length
+    assert_equal 8, index.io.pos
+     
+    index.io.pos = 0
+    assert_equal [1,-2,3].pack("I*"), index.io.read
+  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)
+    
+    index.io.pos = 0
+    assert_equal [8,8,1,2,3], index.io.read.unpack("I*")
+  end
+  
+  def test_unframed_write_unframed_writes_nothing_with_empty_array
+    assert_equal 20, index.io.length
+    
+    index.unframed_write([])
+    index.pos = 0
+    assert_equal 20, index.io.length
+    
+    index.unframed_write([], 0)
+    index.pos = 0
+    assert_equal 20, index.io.length
+  end
+  
+  def test_unframed_write_raises_error_if_array_is_not_in_frame
+    index = @cls.new(nil, :format => "II")
+    assert_raise(ArgumentError) { index.unframed_write([1]) }
+    assert_raise(ArgumentError) { index.unframed_write([1,2,3]) }
+  end
+  
+  #
+  # mixed formats test
+  #
+  
+  def test_read_handles_mixed_formats
+    index = @cls.new tempfile, :format => "IQS"
+    tempfile.pos = 0
+    a = [1,2,3].pack("IQS")
+    b = [4,5,6].pack("IQS")
+    c = [7,8,9].pack("IQS")
+    tempfile << a + b + c
+    
+    index.pos=0
+    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 tempfile, :format => "IQS"
+    a = [1,2,3].pack("IQS")
+    b = [4,5,6].pack("IQS")
+    c = [7,8,9].pack("IQS")
+    d = [-4,-5,-6].pack("IQS")
+    
+    index.unframed_write([1,2,3,4,5,6,7,8,9])
+    tempfile.pos=0
+    assert_equal a+b+c, tempfile.read
+    
+    index.pos=1
+    index.unframed_write([-4,-5,-6])
+    tempfile.pos=0
+    assert_equal a+d+c, tempfile.read
+  end
+  
+  #
+  # numeric format range tests
+  #
+  
+  unless defined?(SHRT_MIN)
+    SHRT_MIN = -32768
+    SHRT_MAX = 32767
+  
+    USHRT_MIN = 0
+    USHRT_MAX = 65535
+  
+    LONG_MIN = -2147483648
+    LONG_MAX = 2147483647 
+  
+    ULONG_MIN = 0
+    ULONG_MAX = 4294967295
+  
+    LLONG_MIN = -9223372036854775808
+    LLONG_MAX = 9223372036854775807
+  
+    ULLONG_MIN = 0
+    ULLONG_MAX = 18446744073709551615
+  end
+  
+  def test_read_and_unframed_write_handles_full_numeric_range_for_numeric_formats
+    # S handles an unsigned short
+    i = @cls.new tempfile, :format => 'S'
+    
+    i.unframed_write([USHRT_MIN], 0)
+    assert_equal [USHRT_MIN], i.read(1,0)
+    i.unframed_write([USHRT_MAX], 0)
+    assert_equal [USHRT_MAX], i.read(1,0)
+  
+    i.unframed_write([USHRT_MIN-1], 0)
+    assert_equal [USHRT_MAX], i.read(1,0)
+  
+    # s handles an signed short
+    i = @cls.new tempfile, :format => 's'
+    
+    i.unframed_write([SHRT_MIN], 0)
+    assert_equal [SHRT_MIN], i.read(1,0)
+    i.unframed_write([SHRT_MAX], 0)
+    assert_equal [SHRT_MAX], i.read(1,0)
+  
+    i.unframed_write([SHRT_MIN], 0)
+    assert_equal [SHRT_MIN], i.read(1,0)
+    i.unframed_write([SHRT_MIN-1], 0)
+    assert_equal [SHRT_MAX], i.read(1,0)
+    
+    # I,L handle an unsigned long
+    ['I', 'L'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      i.unframed_write([ULONG_MIN], 0)
+      assert_equal [ULONG_MIN], i.read(1,0)
+      i.unframed_write([ULONG_MAX], 0)
+      assert_equal [ULONG_MAX], i.read(1,0)
+  
+      i.unframed_write([ULONG_MIN-1], 0)
+      assert_equal [ULONG_MAX], i.read(1,0)
+    end
+    
+    # i,l handle an signed long
+    ['i', 'l'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      i.unframed_write([LONG_MIN], 0)
+      assert_equal [LONG_MIN], i.read(1,0)
+      i.unframed_write([LONG_MAX], 0)
+      assert_equal [LONG_MAX], i.read(1,0)
+  
+      i.unframed_write([LONG_MIN], 0)
+      assert_equal [LONG_MIN], i.read(1,0)
+      i.unframed_write([LONG_MIN-1], 0)
+      assert_equal [LONG_MAX], i.read(1,0)
+    end
+  
+    # Q handles an unsigned long long
+    i = @cls.new tempfile, :format => 'Q'
+    
+    i.unframed_write([ULLONG_MIN], 0)
+    assert_equal [ULLONG_MIN], i.read(1,0)
+    i.unframed_write([ULLONG_MAX], 0)
+    assert_equal [ULLONG_MAX], i.read(1,0)
+  
+    i.unframed_write([ULLONG_MIN-1], 0)
+    assert_equal [ULLONG_MAX], i.read(1,0)
+    
+    # q handles an signed long long
+    i = @cls.new tempfile, :format => 'q'
+    
+    i.unframed_write([LLONG_MIN], 0)
+    assert_equal [LLONG_MIN], i.read(1,0)
+    i.unframed_write([LLONG_MAX], 0)
+    assert_equal [LLONG_MAX], i.read(1,0)
+  
+    i.unframed_write([LLONG_MIN], 0)
+    assert_equal [LLONG_MIN], i.read(1,0)
+    i.unframed_write([LLONG_MIN-1], 0)
+    assert_equal [LLONG_MAX], i.read(1,0)
+  end
+  
+  def test_read_and_unframed_write_cycle_numerics_beyond_natural_range
+    # S handles an unsigned short
+    i = @cls.new tempfile, :format => 'S'
+    
+    i.unframed_write([-USHRT_MAX], 0)
+    assert_equal [1], i.read(1,0)
+    i.unframed_write([USHRT_MIN-1], 0)
+    assert_equal [USHRT_MAX], i.read(1,0)
+  
+    # s handles an signed short
+    i = @cls.new tempfile, :format => 's'
+  
+    i.unframed_write([SHRT_MIN], 0)
+    assert_equal [SHRT_MIN], i.read(1,0)
+    i.unframed_write([SHRT_MIN-1], 0)
+    assert_equal [SHRT_MAX], i.read(1,0)
+    
+    # I,L handle an unsigned long
+    ['I', 'L'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      i.unframed_write([-ULONG_MAX], 0)
+      assert_equal [1], i.read(1,0)
+      i.unframed_write([ULONG_MIN-1], 0)
+      assert_equal [ULONG_MAX], i.read(1,0)
+    end
+    
+    # i,l handle an signed long
+    ['i', 'l'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      i.unframed_write([LONG_MIN], 0)
+      assert_equal [LONG_MIN], i.read(1,0)
+      i.unframed_write([LONG_MIN-1], 0)
+      assert_equal [LONG_MAX], i.read(1,0)
+    end
+  
+    # Q handles an unsigned long long
+    i = @cls.new tempfile, :format => 'Q'
+    
+    i.unframed_write([-ULLONG_MAX], 0)
+    assert_equal [1], i.read(1,0)
+    i.unframed_write([ULLONG_MIN-1], 0)
+    assert_equal [ULLONG_MAX], i.read(1,0)
+    
+    # q handles an signed long long
+    i = @cls.new tempfile, :format => 'q'
+    
+    i.unframed_write([LLONG_MIN], 0)
+    assert_equal [LLONG_MIN], i.read(1,0)
+    i.unframed_write([LLONG_MIN-1], 0)
+    assert_equal [LLONG_MAX], i.read(1,0)
+  end
+  
+  def test_numerics_cycle_up_to_the_unsigned_max_in_either_sign
+    # S,s,I,i,L,l all can cycle up to the size of an ULONG 
+    ['S','s','I','i','L','l'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      assert_raise(RangeError) { i.unframed_write([-(ULONG_MAX+1)]) }
+      assert_raise(RangeError) { i.unframed_write([(ULONG_MAX+1)]) }
+    end
+    
+    # Q,q can cycle up to the size of an ULLONG 
+    ['Q', 'q'].each do |format|
+      i = @cls.new tempfile, :format => format
+      
+      assert_raise(RangeError) { i.unframed_write([-(ULLONG_MAX+1)]) }
+      assert_raise(RangeError) { i.unframed_write([(ULLONG_MAX+1)]) }
+    end
+  end
+  
+  #############################
+  # Array method documentation
+  #############################
+  
+  def test_AREF_doc
+    io = StringIO.new [1,2,3,4,5].pack("I*")
+    i = ExtInd.new(io, :format => 'I')
+    assert_equal [3], i[2]
+    assert_equal nil, i[6]
+    assert_equal [[2],[3]], i[1,2]
+    assert_equal [[2],[3],[4]], i[1..3]
+    assert_equal [[5]], i[4..7]
+    assert_equal nil, i[6..10]
+    assert_equal [[3],[4],[5]], i[-3,3]
+    assert_equal nil, i[5]
+    assert_equal [], i[5,1]
+    assert_equal [], i[5..10]
+  end
+  
+  def test_ASET_doc
+    io = StringIO.new ""
+    i = ExtInd.new(io, :format => 'I')
+    assert_equal [0], i.nil_value   
+                   
+    i[4] = [4]                   
+    assert_equal [[0], [0], [0], [0], [4]], i.to_a
+    
+    i[0, 3] = [ [1], [2], [3] ]  
+    assert_equal [[1], [2], [3], [0], [4]], i.to_a
+
+    i[1..2] = [ [5], [6] ]       
+    assert_equal [[1], [5], [6], [0], [4]], i.to_a
+
+    i[0, 2] = [[7]]               
+    assert_equal [[7], [6], [0], [4]], i.to_a
+
+    i[0..2] = [[8]]                
+    assert_equal [[8], [4]], i.to_a
+
+    i[-1]   = [9]            
+    assert_equal [[8], [9]], i.to_a
+
+    i[1..-1] = nil        
+    assert_equal [[8]], i.to_a
+  end
+  
+  #############################
+  # Modified Array methods tests
+  #############################
+
+  def test_01_square_brackets
+    # Changes: results returned in frame 
+    
+    a = @cls[ 5, 4, 3, 2, 1 ]
+    assert_instance_of(@cls, a)
+    assert_equal(5, a.length)
+    #5.times { |i| assert_equal(5-i, a[i]) }
+    5.times { |i| assert_equal([5-i], a[i]) }
+    assert_nil(a[6])
+  end
+
+  def test_PLUS # '+'
+    # Changes: strings not allowed in ExtInd
+    # replace 'cat' with 4, 'dog' with 5
+    
+    assert_equal(@cls[],     @cls[]  + @cls[])
+    assert_equal(@cls[1],    @cls[1] + @cls[])
+    assert_equal(@cls[1],    @cls[]  + @cls[1])
+    assert_equal(@cls[1, 1], @cls[1] + @cls[1])
+    #assert_equal(@cls['cat', 'dog', 1, 2, 3], %w(cat dog) + (1..3).to_a)
+    assert_equal(@cls[4, 5, 1, 2, 3], @cls[4,5] + @cls[*(1..3).to_a])
+
+    # Additional:
+    # check addition of Array to ExtInd (can't add ExtInd to Array)
+    assert_equal(@cls[4, 5, 1, 2, 3], @cls[4,5] + [[1],[2],[3]])
+    assert_raise(TypeError) { [4,5] + @cls[*(1..3).to_a] }
+    
+    # check result is distinct from factors
+    a = @cls[1]
+    b = @cls[2]
+    c = a + b
+    assert_equal [[1],[2]], c.to_a
+    
+    a.concat [[1]]
+    b.concat [[2]]
+    c.concat [[3]]
+    assert_equal [[1],[1]], a.to_a
+    assert_equal [[2],[2]], b.to_a
+    assert_equal [[1],[2],[3]], c.to_a
+  end
+  
+  def test_LSHIFT # '<<'
+    # Changes: inputs must be in frame and can't take
+    # strings.  And ExtInd can't accept itself as an entry
+    
+    a = @cls[]
+    #a << 1
+    a << [1]
+    assert_equal(@cls[1], a)
+    #a << 2 << 3
+    a << [2] << [3]
+    assert_equal(@cls[1, 2, 3], a)
+    #a << nil << 'cat'
+    #assert_equal(@cls[1, 2, 3, nil, 'cat'], a)
+    #a << a
+    #assert_equal(@cls[1, 2, 3, nil, 'cat', a], a)
+  end
+
+  def test_CMP # '<=>'
+    # Changes: strings not allowed in ExtInd
+    # replace 'cat' with 4, 'dog' with 5
+    assert_equal(-1, 4 <=> 5)
+    
+    assert_equal(0,  @cls[] <=> @cls[])
+    assert_equal(0,  @cls[1] <=> @cls[1])
+    #assert_equal(0,  @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3, 'cat'])
+    assert_equal(0,  @cls[1, 2, 3] <=> @cls[1, 2, 3])
+    assert_equal(-1, @cls[] <=> @cls[1])
+    assert_equal(1,  @cls[1] <=> @cls[])
+    #assert_equal(-1, @cls[1, 2, 3] <=> @cls[1, 2, 3, 'cat'])
+    assert_equal(-1, @cls[1, 2, 3] <=> @cls[1, 2, 3, 4])
+    #assert_equal(1,  @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3])
+    assert_equal(1,  @cls[1, 2, 3, 4] <=> @cls[1, 2, 3])
+    #assert_equal(-1, @cls[1, 2, 3, 'cat'] <=> @cls[1, 2, 3, 'dog'])
+    assert_equal(-1, @cls[1, 2, 3, 4] <=> @cls[1, 2, 3, 5])
+    #assert_equal(1,  @cls[1, 2, 3, 'dog'] <=> @cls[1, 2, 3, 'cat'])
+    assert_equal(1,  @cls[1, 2, 3, 5] <=> @cls[1, 2, 3, 4])
+  end
+
+  def test_AREF # '[]'
+    # Changes: results returned in frame 
+    
+    a = @cls[*(1..100).to_a]
+
+    #assert_equal(1, a[0])
+    assert_equal([1], a[0])
+    #assert_equal(100, a[99])
+    assert_equal([100], a[99])
+    assert_nil(a[100])
+    #assert_equal(100, a[-1])
+    assert_equal([100], a[-1])
+    #assert_equal(99,  a[-2])
+    assert_equal([99],  a[-2])
+    #assert_equal(1,   a[-100])
+    assert_equal([1],   a[-100])
+    assert_nil(a[-101])
+    assert_nil(a[-101,0])
+    assert_nil(a[-101,1])
+    assert_nil(a[-101,-1])
+    assert_nil(a[10,-1])
+
+    # assert_equal(@cls[1],   a[0,1])
+    assert_equal([[1]],   a[0,1])
+    #assert_equal(@cls[100], a[99,1])
+    assert_equal([[100]], a[99,1])
+    #assert_equal(@cls[],    a[100,1])
+    assert_equal([],    a[100,1])
+    #assert_equal(@cls[100], a[99,100])
+    assert_equal([[100]], a[99,100])
+    #assert_equal(@cls[100], a[-1,1])
+    assert_equal([[100]], a[-1,1])
+    #assert_equal(@cls[99],  a[-2,1])
+    assert_equal([[99]],  a[-2,1])
+    #assert_equal(@cls[],    a[-100,0])
+    assert_equal([],    a[-100,0])
+    #assert_equal(@cls[1],   a[-100,1])
+    assert_equal([[1]],   a[-100,1])
+
+    assert_equal(@cls[10, 11, 12], a[9, 3])
+    assert_equal(@cls[10, 11, 12], a[-91, 3])
+
+    # assert_equal(@cls[1],   a[0..0])
+    assert_equal([[1]],   a[0..0])
+    # assert_equal(@cls[100], a[99..99])
+    assert_equal([[100]], a[99..99])
+    # assert_equal(@cls[],    a[100..100])
+    assert_equal([],    a[100..100])
+    # assert_equal(@cls[100], a[99..200])
+    assert_equal([[100]], a[99..200])
+    # assert_equal(@cls[100], a[-1..-1])
+    assert_equal([[100]], a[-1..-1])
+    # assert_equal(@cls[99],  a[-2..-2])
+    assert_equal([[99]],  a[-2..-2])
+
+    assert_equal(@cls[10, 11, 12], a[9..11])
+    assert_equal(@cls[10, 11, 12], a[-91..-89])
+
+    assert_nil(a[10, -3])
+    # Ruby 1.8 feature change:
+    # Array#[size..x] returns [] instead of nil.
+    #assert_nil(a[10..7])
+    assert_equal [], a[10..7]
+
+    assert_raise(TypeError) {a['cat']}
+  end
+
+  def test_ASET # '[]='
+    # Changes: values and results specified in frame 
+    # added mirror tests to ensure testing using array
+    # and index inputs
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[0] = 0)
+    assert_equal([0], a[0] = [0])  
+    assert_equal(@cls[0] + @cls[*(1..99).to_a], a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[0] = b)  
+    assert_equal(@cls[0] + @cls[*(1..99).to_a], a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[10,10] = 0)
+    assert_equal([[0]], a[10,10] = [[0]])
+    assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[10,10] = b)
+    assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[-1] = 0) 
+    assert_equal([0], a[-1] = [0])
+    assert_equal(@cls[*(0..98).to_a] + @cls[0], a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[-1] = b)
+    assert_equal(@cls[*(0..98).to_a] + @cls[0], a)    
+
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[-10, 10] = 0)
+    assert_equal([[0]], a[-10, 10] = [[0]]) 
+    assert_equal(@cls[*(0..89).to_a] + @cls[0], a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[-10, 10] = b) 
+    assert_equal(@cls[*(0..89).to_a] + @cls[0], a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[0,1000] = 0)
+    assert_equal([[0]], a[0,1000] = [[0]])
+    assert_equal(@cls[0] , a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[0,1000] = b) 
+    assert_equal(@cls[0] , a)
+
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    #assert_equal(0, a[10..19] = 0)
+    assert_equal([[0]], a[10..19] = [[0]])
+    assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
+    
+    a = @cls[*(0..99).to_a]
+    b = @cls[0]
+    assert_equal(b, a[10..19] = b) 
+    assert_equal(@cls[*(0..9).to_a] + @cls[0] + @cls[*(20..99).to_a], a)
+
+    # -- pair -- 
+    # Changes: cannot take strings, 
+    # replace a,b,c with 1001, 1002, 10003
+    #b = @cls[*%w( a b c )]
+    b = @cls[1001, 1002, 10003]
+    c = [[1001],[1002],[10003]]
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[0,1] = b)
+    assert_equal(b + @cls[*(1..99).to_a], a)
+    
+    a = @cls[*(0..99).to_a] 
+    assert_equal(c, a[0,1] = c)
+    assert_equal(b + @cls[*(1..99).to_a], a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[10,10] = b)
+    assert_equal(@cls[*(0..9).to_a] + b + @cls[*(20..99).to_a], a)
+
+    a = @cls[*(0..99).to_a] 
+    assert_equal(c, a[10,10] = c)
+    assert_equal(@cls[*(0..9).to_a] + c + @cls[*(20..99).to_a], a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[-1, 1] = b)
+    assert_equal(@cls[*(0..98).to_a] + b, a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(c, a[-1, 1] = c)
+    assert_equal(@cls[*(0..98).to_a] + c, a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[-10, 10] = b)
+    assert_equal(@cls[*(0..89).to_a] + b, a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(c, a[-10, 10] = c)
+    assert_equal(@cls[*(0..89).to_a] + c, a)
+  
+    # -- pair --     
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[0,1000] = b)
+    assert_equal(b , a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(c, a[0,1000] = c)
+    assert_equal(c , a.to_a)
+    
+    # -- pair -- 
+    a = @cls[*(0..99).to_a]
+    assert_equal(b, a[10..19] = b)
+    assert_equal(@cls[*(0..9).to_a] + b + @cls[*(20..99).to_a], a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(c, a[10..19] = c)
+    assert_equal(@cls[*(0..9).to_a] + c + @cls[*(20..99).to_a], a)
+    
+    # Ruby 1.8 feature change:
+    # assigning nil does not remove elements.
+=begin
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[0,1] = nil)
+    assert_equal(@cls[*(1..99).to_a], a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[10,10] = nil)
+    assert_equal(@cls[*(0..9).to_a] + @cls[*(20..99).to_a], a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[-1, 1] = nil)
+    assert_equal(@cls[*(0..98).to_a], a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[-10, 10] = nil)
+    assert_equal(@cls[*(0..89).to_a], a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[0,1000] = nil)
+    assert_equal(@cls[] , a)
+
+    a = @cls[*(0..99).to_a]
+    assert_equal(nil, a[10..19] = nil)
+    assert_equal(@cls[*(0..9).to_a] + @cls[*(20..99).to_a], a)
+=end
+
+    # Changes: should have @cls in definition
+
+    a = @cls[1, 2, 3]
+    a[1, 0] = a
+    #assert_equal([1, 1, 2, 3, 2, 3], a)
+    assert_equal(@cls[1, 1, 2, 3, 2, 3], a)
+    
+    a = @cls[1, 2, 3]
+    a[-1, 0] = a
+    #assert_equal([1, 2, 1, 2, 3, 3], a)
+    assert_equal(@cls[1, 2, 1, 2, 3, 3], a)
+    
+    # Additional:
+    
+    # -- test self insertions --
+    a = @cls[1, 2, 3]
+    a[1, 3] = a
+    assert_equal(@cls[1,1,2,3], a)
+    
+    a = @cls[1, 2, 3]
+    a[3, 3] = a
+    assert_equal(@cls[1,2,3,1,2,3], a)
+    
+    a = @cls[1, 2, 3]
+    a[4, 3] = a
+    assert_equal(@cls[1,2,3,0,1,2,3], a)
+    
+    # -- test insertions where padding is necessary --
+    # -- pair -- 
+    a = @cls[1,2,3, {:nil_value => [8]}]
+    b = @cls[1001, 1002, 10003, {:nil_value => [8]}]
+    assert_equal(b, a[4, 3] = b)
+    assert_equal(@cls[1,2,3,8,1001,1002,10003, {:nil_value => [8]}], a.to_a)
+
+    a = @cls[1,2,3, {:nil_value => [8]}]
+    c = [[1001], [1002], [10003]]
+    assert_equal(c, a[4, 3] = c)
+    assert_equal(@cls[1,2,3,8,1001,1002,10003, {:nil_value => [8]}], a)
+    
+    # -- pair -- 
+    a = @cls[1,2,3, {:nil_value => [8]}]
+    b = @cls[1001, 1002, 10003, {:nil_value => [8]}]
+    assert_equal(b, a[4, 1] = b)
+    assert_equal(@cls[1,2,3,8,1001,1002,10003, {:nil_value => [8]}], a)
+
+    a = @cls[1,2,3, {:nil_value => [8]}]
+    c = [[1001], [1002], [10003]]
+    assert_equal(c, a[4, 1] = c)
+    assert_equal(@cls[1,2,3,8,1001,1002,10003, {:nil_value => [8]}], a)
+    
+    # -- test insertions with nils -- 
+    # -- pair -- 
+    a = @cls[1,2,3]
+    b = @cls[1001, nil, nil, 10003]
+    assert_equal(b, a[1, 3] = b)
+    assert_equal(@cls[1,1001,0,0,10003], a)
+    
+    a = @cls[1,2,3]
+    c = [[1001], nil, nil, [10003]]
+    assert_equal(c, a[1, 3] = c)
+    assert_equal(@cls[1,1001,0,0,10003], a)
+    
+    # -- insert beyond end of index, with inconsistent range --
+    # first check the array behavior, then assert the same with ExtInd
+    a = (0..5).to_a
+    assert_equal([11,12,13], a[11..12] = [11,12,13])
+    assert_equal((0..5).to_a + [nil,nil,nil,nil,nil] + (11..13).to_a, a)
+    
+    # -- pair -- 
+    a = @cls[*(0..5).to_a]
+    b = @cls[11,12,13]
+    assert_equal(b, a[11..12] = b)
+    assert_equal(@cls[*(0..5).to_a] + @cls[0,0,0,0,0] + b, a)
+    
+    a = @cls[*(0..5).to_a]
+    c = [[11],[12],[13]]
+    assert_equal(c, a[11..12] = c)
+    assert_equal(@cls[*(0..5).to_a] + @cls[0,0,0,0,0] + c, a)
+  end
+
+  def test_at
+    # Chagnes: values must be in frame
+    
+    a = @cls[*(0..99).to_a]
+    # assert_equal(0,   a.at(0))
+    assert_equal([0],   a.at(0))
+    # assert_equal(10,  a.at(10))
+    assert_equal([10],  a.at(10))
+    # assert_equal(99,  a.at(99))
+    assert_equal([99],  a.at(99))
+    assert_equal(nil, a.at(100))
+    # assert_equal(99,  a.at(-1))
+    assert_equal([99],  a.at(-1))
+    # assert_equal(0,  a.at(-100))
+    assert_equal([0],  a.at(-100))
+    assert_equal(nil, a.at(-101))
+
+    assert_raise(TypeError) { a.at('cat') }
+  end
+  
+  def test_concat
+    # Changes: ExtInd does not support Array/ExtInd nesting
+    
+    assert_equal(@cls[1, 2, 3, 4],     @cls[1, 2].concat(@cls[3, 4]))
+    assert_equal(@cls[1, 2, 3, 4],     @cls[].concat(@cls[1, 2, 3, 4]))
+    assert_equal(@cls[1, 2, 3, 4],     @cls[1, 2, 3, 4].concat(@cls[]))
+    assert_equal(@cls[],               @cls[].concat(@cls[]))
+    #assert_equal(@cls[@cls[1, 2], @cls[3, 4]], @cls[@cls[1, 2]].concat(@cls[@cls[3, 4]]))
+    
+    # Changes: should have @cls in definition
+    
+    a = @cls[1, 2, 3]
+    a.concat(a)
+    #assert_equal([1, 2, 3, 1, 2, 3], a)
+    assert_equal(@cls[1, 2, 3, 1, 2, 3], a)
+  end
+
+  def test_each
+    # Changes: cannot take strings, 
+    # replace (ant bat cat dog) with [1,2,3,4]
+    
+    #a = @cls[*%w( ant bat cat dog )]
+    a = @cls[*(1..4).to_a]
+    i = 0
+    a.each { |e|
+      assert_equal(a[i], e)
+      i += 1
+    }
+    assert_equal(4, i)
+
+    a = @cls[]
+    i = 0
+    a.each { |e|
+      assert_equal(a[i], e)
+      i += 1
+    }
+    assert_equal(0, i)
+
+    assert_equal(a, a.each {})
+  end
+  
+  def test_each_index
+    # Changes: cannot take strings, 
+    # replace (ant bat cat dog) with [1,2,3,4]
+    
+    #a = @cls[*%w( ant bat cat dog )]
+    a = @cls[*(1..4).to_a]
+    i = 0
+    a.each_index { |ind|
+      assert_equal(i, ind)
+      i += 1
+    }
+    assert_equal(4, i)
+
+    a = @cls[]
+    i = 0
+    a.each_index { |ind|
+      assert_equal(i, ind)
+      i += 1
+    }
+    assert_equal(0, i)
+
+    assert_equal(a, a.each_index {})
+  end
+  
+  def test_eql?
+    assert(@cls[].eql?(@cls[]))
+    assert(@cls[1].eql?(@cls[1]))
+    assert(@cls[1, 1, 2, 2].eql?(@cls[1, 1, 2, 2]))
+
+    # Changes: all values are treated according to the format
+    # so these floats are converted to ints and the ExtInds 
+    # are equal
+    #assert(!@cls[1.0, 1.0, 2.0, 2.0].eql?(@cls[1, 1, 2, 2]))
+    assert(@cls[1.0, 1.0, 2.0, 2.0].eql?(@cls[1, 1, 2, 2]))
+  end
+
+  def test_first
+    # Changes: must be in frame
+    #assert_equal(3,   @cls[3, 4, 5].first)
+    assert_equal([3],   @cls[3, 4, 5].first)
+    assert_equal(nil, @cls[].first)
+  end
+
+  def test_last
+    # Changes: must be in frame
+    
+    assert_equal(nil, @cls[].last)
+    # assert_equal(1, @cls[1].last)
+    assert_equal([1], @cls[1].last)
+    # assert_equal(99, @cls[*(3..99).to_a].last)
+    assert_equal([99], @cls[*(3..99).to_a].last)
+  end
+  
+  def test_to_a
+    a = @cls[ 1, 2, 3 ]
+    # Changes: can't do this comparison by object id
+    #a_id = a.__id__
+    #assert_equal(a, a.to_a)
+    assert_equal [[1],[2],[3]], a.to_a
+    #assert_equal(a_id, a.to_a.__id__)
+  end
+  
+  #############################
+  # Additional Array methods tests
+  #############################
+  
+  #
+  # ASET tests
+  #
+  
+  def test_ASET_raises_error_if_input_is_not_in_frame
+    a = @cls.new
+    assert_raise(ArgumentError) { a[0] = 1 }
+    assert_raise(ArgumentError) { a[0,1] = [1] }
+    assert_raise(ArgumentError) { a[0,1] = [[1,2]] }
+  end
+  
+  def test_ASET_raises_error_if_input_is_index_with_different_attributes
+    a = @cls.new(nil, :format => "I")
+    b = @cls.new(nil, :format => "II")
+    assert_raise(ArgumentError) { a[0,1] = b }
+  end
+  
+  #######################
+  # Benchmark tests
+  #######################
+
+  #
+  # benchmarks
+  #
+  
+  def index_bm_test(mode, length=20, array=nil, &block)
+    benchmark_test(length) do |x|
+      ['I', 'IIIIIIIIII'].each do |format|
+        unless array
+          array = []
+          1.upto(10000) {|i| array << i }
+        end
+        
+        Tempfile.open('benchmark') do |file|
+          file << array.pack('I*')
+          
+          begin
+            index = @cls.new(file, :format => format)  
+            yield(x, format, index)
+          ensure
+            index.close if index
+          end
+        end
+      end
+      
+      yield(x, "array reference", array)
+    end
+     
+    array
+  end
+  
+  def test_element_reference_speed_for_index
+    n = 100
+    index_bm_test('r') do |x, type, index|
+      puts type
+      
+      x.report("#{n}kx [index]") { (n*1000).times { index[1000] } }
+      x.report("#{n}kx [range]") { (n*1000).times { index[1000..1000] } }
+      x.report("#{n}kx [s,1]") { (n*1000).times { index[1000, 1] } }
+      x.report("#{n}kx [s,10]") { (n*1000).times { index[1000, 10] } }
+      x.report("#{n}kx [s,100]") { (n*1000).times { index[1000, 100] } }   
+      
+      puts
+    end
+  end
+
+  def test_element_assignment_speed_for_index
+    index_bm_test('r+') do |x, type, index|
+      puts type
+      
+      n = 10
+      obj = Array.new(index.respond_to?(:frame) ? index.frame : 1, 0)
+      
+      x.report("#{n}kx [index]=") do 
+        (n*1000).times { index[1000] = obj} 
+      end      
+      x.report("#{n}kx [range]=") do 
+        (n*1000).times { index[1000..1000] = [obj] } 
+      end  
+      x.report("#{n}kx [s,1]=") do 
+        (n*1000).times { index[1000,1] = [obj] } 
+      end
+      
+      puts
+    end
+  end
+end
+
+
+
+class Hold
+  def btest_each_speed
+    indexbm_test('r') do |x, type, index|
+      x.report("10x #{type} - cs100k") { 10.times { index.each {|e|} } }
+      #x.report("10x #{type} - cs100") { 10.times { index.each(0,index.length, 100) {|e|} } }      
+    end
+  end
+  
+  
+  def btest_push_speed
+    indexbm_test('r+') do |x, type, index|
+      obj = Array.new(index.frame, 0)
+      x.report("10kx #{type} index=") do 
+        10000.times { index << obj} 
+      end    
+    end
+  end
+  
+  def btest_sort_speed
+    benchmark_test(20) do |x|
+      n = 1
+      unsorted, sorted = sort_arrays(n*10**6)
+      
+      x.report("#{n}M array sort") do 
+        unsorted.sort
+      end
+      
+      index = setup_index({:default_blksize => 100000}, unsorted)
+      x.report("#{n}M index sort") do 
+        index.sort.close
+      end
+      index.close
+      
+      index = setup_index({:frame => 2, :default_blksize => 100000}, unsorted)
+      x.report("#{n}M frame with block") do 
+        index.sort {|a, b| b <=> a }.close
+      end
+      index.close
+      
+      sindex = setup_sindex({:default_blksize => 100000}, unsorted)
+      x.report("#{n}M sindex sort") do 
+        sindex.sort.close
+      end
+      sindex.close
+      
+      # cannot finish... not sure why
+    #  sindex = setup_sindex({:frame => 2, :default_blksize => 100000}, unsorted)
+    #  x.report("#{n}M frame with block") do 
+    #    sindex.sort {|a, b| b <=> a }.close
+    #  end
+    #  sindex.close
+    end
+  end
+end