external 0.1.0 → 0.3.0

data/test/ext_ind_test.rb

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