flex_array 0.2.0

data/tests/flex_array_index_test.rb

@@ -0,0 +1,222 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayIndexTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_that_it_indexes_correctly
+    q1 = FlexArray.new([3, 3, 3]) {|i| i.dup}
+    
+    (0...3).each do |x|
+      (0...3).each do |y|
+        (0...3).each do |z|
+          assert_equal([x,y,z], q1[x,y,z])
+        end
+      end
+    end
+
+    (-3..-1).each do |x|
+      (-3..-1).each do |y|
+        (-3..-1).each do |z|
+          assert_equal([x+3,y+3,z+3], q1[x,y,z])
+        end
+      end
+    end
+    
+    q = q1[0, 0, :all]
+    a = [[0,0,0], [0,0,1], [0,0,2]]
+    assert_equal(a, q)
+    q = q1[0, 0, 0...3]
+    assert_equal(a, q)
+    q = q1[0, 0, -3..-1]
+    assert_equal(a, q)
+    q = q1[0, 0, [0,2]]
+    assert_equal(a, q)
+    q = q1[0, 0, [0,-1]]
+    assert_equal(a, q)
+    q = q1[0, 0, [-3,-1]]
+    assert_equal(a, q)
+    q = q1[0, 0, [-3,2]]
+    assert_equal(a, q)
+
+    q = q1[0, :all, 0]
+    a = [[0,0,0], [0,1,0], [0,2,0]]
+    assert_equal(a, q)
+    q = q1[0, 0...3, 0]
+    assert_equal(a, q)
+    q = q1[0, -3..-1, 0]
+    assert_equal(a, q)
+    q = q1[0, [0,2], 0]
+    assert_equal(a, q)
+    q = q1[0, [0,-1], 0]
+    assert_equal(a, q)
+    q = q1[0, [-3,-1], 0]
+    assert_equal(a, q)
+    q = q1[0, [-3,2], 0]
+    assert_equal(a, q)
+    
+    q = q1[:all, 0, 0]
+    a = [[0,0,0], [1,0,0], [2,0,0]]
+    assert_equal(a, q)
+    q = q1[0...3, 0, 0]
+    assert_equal(a, q)
+    q = q1[-3..-1, 0, 0]
+    assert_equal(a, q)
+    q = q1[[0,2], 0, 0]
+    assert_equal(a, q)
+    q = q1[[0,-1], 0, 0]
+    assert_equal(a, q)
+    q = q1[[-3,-1], 0, 0]
+    assert_equal(a, q)
+    q = q1[[-3,2], 0, 0]
+    assert_equal(a, q)
+    
+    q = q1[0, 1, :all]
+    a = [[0,1,0], [0,1,1], [0,1,2]]
+    assert_equal(a, q)
+    q = q1[0, 1, 0...3]
+    assert_equal(a, q)
+    q = q1[0, 1, -3..-1]
+    assert_equal(a, q)
+    q = q1[0, 1, [0,2]]
+    assert_equal(a, q)
+    q = q1[0, 1, [0,-1]]
+    assert_equal(a, q)
+    q = q1[0, 1, [-3,-1]]
+    assert_equal(a, q)
+    q = q1[0, 1, [-3,2]]
+    assert_equal(a, q)
+    
+    q = q1[0, :all, 1]
+    a = [[0,0,1], [0,1,1], [0,2,1]]
+    assert_equal(a, q)
+    q = q1[0, 0...3, 1]
+    assert_equal(a, q)
+    q = q1[0, -3..-1, 1]
+    assert_equal(a, q)
+    q = q1[0, [0,2], 1]
+    assert_equal(a, q)
+    q = q1[0, [0,-1], 1]
+    assert_equal(a, q)
+    q = q1[0, [-3,-1], 1]
+    assert_equal(a, q)
+    q = q1[0, [-3,2], 1]
+    assert_equal(a, q)
+
+    q = q1[:all, 1, 0]
+    a = [[0,1,0], [1,1,0], [2,1,0]]
+    assert_equal(a, q)
+    q = q1[0...3, 1, 0]
+    assert_equal(a, q)
+    q = q1[-3..-1, 1, 0]
+    assert_equal(a, q)
+    q = q1[[0,2], 1, 0]
+    assert_equal(a, q)
+    q = q1[[0,-1], 1, 0]
+    assert_equal(a, q)
+    q = q1[[-3,-1], 1, 0]
+    assert_equal(a, q)
+    q = q1[[-3,2], 1, 0]
+    assert_equal(a, q)
+    
+    q = q1[0, 2, :all]
+    a = [[0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+    q = q1[0, 2, 0...3]
+    assert_equal(a, q)
+    q = q1[0, 2, -3..-1]
+    assert_equal(a, q)
+    q = q1[0, 2, [0,2]]
+    assert_equal(a, q)
+    q = q1[0, 2, [0,-1]]
+    assert_equal(a, q)
+    q = q1[0, 2, [-3,-1]]
+    assert_equal(a, q)
+    q = q1[0, 2, [-3,2]]
+    assert_equal(a, q)
+    
+    q = q1[0, :all, 2]
+    a = [[0,0,2], [0,1,2], [0,2,2]]
+    assert_equal(a, q)
+    q = q1[0, 0...3, 2]
+    assert_equal(a, q)
+    q = q1[0, -3..-1, 2]
+    assert_equal(a, q)
+    q = q1[0, [0,2], 2]
+    assert_equal(a, q)
+    q = q1[0, [0,-1], 2]
+    assert_equal(a, q)
+    q = q1[0, [-3,-1], 2]
+    assert_equal(a, q)
+    q = q1[0, [-3,2], 2]
+    assert_equal(a, q)
+
+    q = q1[:all, 2, 0]
+    a = [[0,2,0], [1,2,0], [2,2,0]]
+    assert_equal(a, q)
+    q = q1[0...3, 2, 0]
+    assert_equal(a, q)
+    q = q1[-3..-1, 2, 0]
+    assert_equal(a, q)
+    q = q1[[0,2], 2, 0]
+    assert_equal(a, q)
+    q = q1[[0,-1], 2, 0]
+    assert_equal(a, q)
+    q = q1[[-3,-1], 2, 0]
+    assert_equal(a, q)
+    q = q1[[-3,2], 2, 0]
+    assert_equal(a, q)
+    
+    q = q1[0, :all, :all]
+    a = [[0,0,0], [0,0,1], [0,0,2], 
+         [0,1,0], [0,1,1], [0,1,2], 
+         [0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+    
+    q = q1[0, 1..2, :all]
+    a = [[0,1,0], [0,1,1], [0,1,2], [0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+    
+    q = q1[0, 0..2, :all]
+    a = [[0,0,0], [0,0,1], [0,0,2], 
+         [0,1,0], [0,1,1], [0,1,2], 
+         [0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+    
+    q = q1[0, :all, 0..2]
+    a = [[0,0,0], [0,0,1], [0,0,2],
+           [0,1,0], [0,1,1], [0,1,2],
+           [0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+
+    q = q1[0, 0..2, 0..2]
+    a = [[0,0,0], [0,0,1], [0,0,2],
+           [0,1,0], [0,1,1], [0,1,2],
+           [0,2,0], [0,2,1], [0,2,2]]
+    assert_equal(a, q)
+    
+    assert_equal([2,2,2], q1[-1,-1,-1])    
+  end
+
+  def test_that_it_rejects_bad_indexes
+    q1 = FlexArray.new([3, 3, 3]) {|i| i.clone}
+
+    assert_raises(IndexError) { q1[0,0,3] }
+    assert_raises(IndexError) { q1[0,3,0] }
+    assert_raises(IndexError) { q1[3,0,0] }
+
+    assert_raises(IndexError) { q1[0,0,0..3] }
+    assert_raises(IndexError) { q1[0,0..3,0] }
+    assert_raises(IndexError) { q1[0..3,0,0] }
+  end
+end

data/tests/flex_array_new_test.rb

@@ -0,0 +1,131 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayNewTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_the_new_method
+    q1 = FlexArray.new(10, 0)
+    a1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    assert_equal(10, q1.count)
+    assert_equal(1, q1.dimensions)
+    assert_equal([0...10], q1.limits)
+    assert_equal(a1, q1.array_data)
+  
+    q2 = FlexArray.new(1..10, 0)
+    a2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    assert_equal(10, q2.count)
+    assert_equal(1, q2.dimensions)
+    assert_equal([1..10], q2.limits)
+    assert_equal(a2, q2.array_data)
+    
+    q3 = FlexArray.new(10) {|i| i[0]}
+    a3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    assert_equal(a3, q3.array_data) 
+  
+    q4 = FlexArray.new(1..10) {|i| i[0]}
+    a4 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert_equal(a4, q4.array_data)
+
+    q5 = FlexArray.new([2, 2], 0)
+    a5 = [0, 0, 0, 0]
+    assert_equal(4, q5.count)
+    assert_equal(2, q5.dimensions)
+    assert_equal([0...2, 0...2], q5.limits)
+    assert_equal(a5, q5.array_data)
+    
+    q6 = FlexArray.new([2, 2]) {|i| i.clone}
+    a6 = [[0,0], [0,1], [1,0], [1,1]]
+    assert_equal(a6, q6.array_data)
+  end
+  
+  def test_the_dup_method
+    fa1 = FlexArray.new(10) {|idx| idx.clone}
+    fa2 = fa1.dup
+    
+    #Test that the array reference cells are independent.
+    fa2[0] = 'Hello'
+    assert_equal([0], fa1[0])
+    assert_equal('Hello', fa2[0])
+
+    #Test that the array contents are still dependant.    
+    fa2[1][0] = 'Dolly'
+    assert_equal(['Dolly'], fa1[1])
+    assert_equal(['Dolly'], fa2[1])
+  end
+  
+  def test_the_new_from_method
+    #Test new_from a regular array.
+    ba1 = [1,2,3,4,5,6]
+    q1 = FlexArray.new_from([2,3], ba1)
+    assert_equal(ba1, q1.array_data)
+    assert_equal(q1.limits, [0...2, 0...3])
+    assert_equal(q1.dimensions, 2)
+
+    #Test new_from with a smaller target.
+    q2 = FlexArray.new_from(4, q1)
+    a2 = [1,2,3,4]
+    assert_equal(a2, q2.array_data)
+    assert_equal(q2.dimensions, 1)
+
+    #Test new_from with a larger target.
+    q3 = FlexArray.new_from(8, q1)
+    a3 = [1,2,3,4,5,6,1,2]
+    assert_equal(a3, q3.array_data)
+    assert_equal(q3.dimensions, 1)
+    
+    #Test new_from with same size but different shape.
+    q4 = FlexArray.new_from([3,2], q1)
+    assert_equal(ba1, q4.array_data)
+    assert_equal(q4.limits, [0...3, 0...2])
+    assert_equal(q4.dimensions, 2)
+  end
+  
+  def test_the_new_from_selection_method
+    #Create a new array from a row of data.
+    fa1 = FlexArray.new([3,4]) {|idx| idx.clone}
+    fa2 = FlexArray.new_from_selection(4, fa1, [0, :all])
+    assert_equal([[0,0],[0,1],[0,2],[0,3]], fa2.array_data)
+    
+    #Create a new array from a column of data.
+    fa1 = FlexArray.new([3,4]) {|idx| idx.clone}
+    fa2 = FlexArray.new_from_selection(3, fa1, [:all, 0])
+    assert_equal([[0,0],[1,0],[2,0]], fa2.array_data)
+  end
+  
+  def test_the_new_from_array_method
+    a = [0,1,2,3,4,5,6,7,8,9]
+    f = FlexArray.new_from_array(a)
+    assert_equal([0...10], f.limits)
+    assert_equal(a.object_id, f.array_data.object_id)
+  end
+
+  def test_that_it_rejects_bad_specs
+    assert_raises(ArgumentError) { FlexArray.new(10.5, 0) }
+    assert_raises(ArgumentError) { FlexArray.new('Hello', 0) }
+    assert_raises(ArgumentError) { FlexArray.new(:all, 0) }
+    
+    assert_raises(ArgumentError) { FlexArray.new([10.5], 0) }
+    assert_raises(ArgumentError) { FlexArray.new(['Hello'], 0) }
+    assert_raises(ArgumentError) { FlexArray.new([:all], 0) }
+    
+    assert_raises(ArgumentError) { FlexArray.new(1...1, 0) }
+    assert_raises(ArgumentError) { FlexArray.new(-1..-5, 0) }
+    
+    assert_raises(ArgumentError) { FlexArray.new([1...1], 0) }
+    assert_raises(ArgumentError) { FlexArray.new([-1..-5], 0) }
+    
+    assert_raises(ArgumentError) { FlexArray.new('a'..'z', 0) }    
+    assert_raises(ArgumentError) { FlexArray.new(['a'..'z'], 0) }
+  end
+end

data/tests/flex_array_reshape_test.rb

@@ -0,0 +1,76 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayReshapeTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_the_reshape_method
+    ba1 = [[0,0], [0,1], [0,2], [0,3],
+           [1,0], [1,1], [1,2], [1,3],
+           [2,0], [2,1], [2,2], [2,3]]
+           
+    fa1 = FlexArray.new([3,4]) {|idx| idx.clone}
+    fa2 = fa1.reshape([2,6])
+    assert_equal([0...3, 0...4], fa1.limits)
+    assert_equal([0...2, 0...6], fa2.limits)
+    assert_equal(ba1, fa1.array_data)
+    assert_equal(ba1, fa2.array_data)
+
+    ba2 = [[0,0], [0,1], [0,2], [0,3],
+           [1,0], [1,1], [1,2], [1,3],
+           [2,0], [2,1], [2,2], [2,3],
+           [0,0], [0,1], [0,2]]
+    
+    fa3 = fa1.reshape([3,5])
+    assert_equal(ba2, fa3.array_data)
+  end
+  
+  def test_the_reshape_e_m_method
+    ba1 = [[0,0], [0,1], [0,2], [0,3],
+           [1,0], [1,1], [1,2], [1,3],
+           [2,0], [2,1], [2,2], [2,3]]
+           
+    fa1 = FlexArray.new([3,4]) {|idx| idx.clone}
+    fa1.reshape!([2,6])
+    assert_equal([0...2, 0...6], fa1.limits)
+    assert_equal(ba1, fa1.array_data)
+    assert_equal(2, fa1.dimensions)
+
+    ba2 = [[0,0], [0,1], [0,2], [0,3],
+           [1,0], [1,1], [1,2], [1,3],
+           [2,0], [2,1], [2,2], [2,3],
+           [0,0], [0,1], [0,2]]
+    
+    fa1.reshape!([3,5])
+    assert_equal(ba2, fa1.array_data)
+    assert_equal(2, fa1.dimensions)
+    
+    fa1.reshape!(15)
+    assert_equal([0...15], fa1.limits)
+    assert_equal(1, fa1.dimensions)
+  end
+  
+  def test_the_flatten_method
+    fa = FlexArray.new([2,3]) {|idx| idx.clone}
+    a = [0,0,0,1,0,2,1,0,1,1,1,2]
+    assert_equal(a, fa.flatten)
+    assert(fa.array_data.object_id != fa.flatten.object_id)
+  end
+  
+  def test_the_to_a_method
+    fa = FlexArray.new([2,3]) {|idx| idx.clone}
+    a = [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2]]
+    assert_equal(a, fa.to_a)
+    assert(fa.array_data.object_id != fa.to_a.object_id)
+  end
+end

data/tests/flex_array_test.rb

@@ -0,0 +1,58 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+  
+  def test_version_reporting
+    version = '0.2.0'
+    f = FlexArray.new([3,3], 'test')
+    
+    assert_equal(version, FlexArray.version)
+    assert_equal(version, f.version)
+  end
+
+  def test_the_limits_method
+    f = FlexArray.new([3,3], 'test')
+    assert_equal([0...3, 0...3], f.limits)
+  end
+  
+  def test_the_to_flex_array_method
+    f = FlexArray.new([3,3], 'test')
+    g = f.to_flex_array
+    
+    assert_equal(f, g)
+    assert_equal(f.object_id, g.object_id)
+  end
+  
+  def test_the_equal_method
+    f = FlexArray.new([3,3], 'test')
+    g = FlexArray.new([3,3], 'test')
+    h = FlexArray.new([3,3], 'not')
+    
+    assert(f == g)
+    refute(f == h)
+  end
+
+  def test_the_compariositality_method
+    f = FlexArray.new([3,3], 1)
+    g = FlexArray.new([3,3], 1)
+    h = FlexArray.new([3,3], 2)
+    i = FlexArray.new([3,3], 0)
+    
+    assert_equal( 0, f <=> g)
+    assert_equal(-1, f <=> h)
+    assert_equal( 1, f <=> i)
+  end
+  
+end

data/tests/flex_array_transpose_test.rb

@@ -0,0 +1,32 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayTransposeTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_the_transpose_method
+    f = FlexArray.new([3,3]) { |i| i[0]*3 + i[1] }
+    a = [0,1,2,
+         3,4,5,
+         6,7,8]
+    assert_equal(a, f[:all, :all])
+    assert_equal(a, f[:all])
+    
+    f.transpose(0,1)
+    a = [0,3,6,
+         1,4,7,
+         2,5,8]
+    assert_equal(a, f[:all, :all])
+    assert_equal(a, f[:all])
+  end
+end

data/tests/flex_array_validate_test.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayValidateTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_the_compatible_method
+    f = FlexArray.new([3,3], 'f')
+    g = FlexArray.new([0...3,0...3], 'g')
+    h = FlexArray.new([1..3,1..3], 'h')
+    i = FlexArray.new([3,3,3], 'i')
+    j = FlexArray.new([3], 'j')
+    
+    assert(f.compatible?(g))
+    refute(f.compatible?(h))
+    refute(f.compatible?(i))
+    refute(f.compatible?(j))
+  end
+end

data/tests/integer_test.rb

@@ -0,0 +1,40 @@
+require_relative '../lib/flex_array/integer'
+require          'minitest/autorun'
+
+class IntegerTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_that_to_spec_component_works
+    lc = (10).to_spec_component(3)
+    assert_equal(0...10, lc.range)
+    assert_equal(3, lc.stride)
+    
+    lc = (0).to_spec_component(3)
+    assert_equal(0...0, lc.range)
+  end
+
+  def test_that_to_spec_component_rejects_bad
+    assert_raises(ArgumentError) { (-100).to_spec_component(3) }
+  end
+  
+  def test_the_to_index_range_method
+    lc = SpecComponent.new(0...10, 1)
+    assert_equal(0..0, (0).to_index_range(lc))
+    assert_equal(1..1, (1).to_index_range(lc))
+    assert_equal(9..9, (-1).to_index_range(lc))  
+    
+    assert_raises(IndexError) { (10).to_index_range(lc) }
+    assert_raises(IndexError) { (-12).to_index_range(lc) }
+  end
+  
+end

data/tests/object_test.rb

@@ -0,0 +1,38 @@
+require_relative '../lib/flex_array/object'
+require          'minitest/autorun'
+
+class ObjectTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+  
+  def test_that_to_spec_component_fails
+    obj = Object.new
+    assert_raises(ArgumentError) { obj.to_spec_component(42) }
+    
+    #Test other invalid objects as well...
+    assert_raises(ArgumentError) { (89.0).to_spec_component(42) }
+    assert_raises(ArgumentError) { 'Hello'.to_spec_component(42) }
+    assert_raises(ArgumentError) { :Hello.to_spec_component(42) }
+    assert_raises(ArgumentError) { [1,2,3].to_spec_component(42) }
+    assert_raises(ArgumentError) { {:hi => 42}.to_spec_component(42) }
+  end
+
+  def test_the_to_index_range_method
+    lc = SpecComponent.new(0...10, 1)
+    assert_equal(0...10, (:all).to_index_range(lc))
+    assert_raises(IndexError) { (:y_all).to_index_range(lc) }
+    assert_raises(IndexError) { (:all_y_all).to_index_range(lc) }
+    assert_raises(IndexError) { ('all').to_index_range(lc) }
+    assert_raises(IndexError) { (98.9).to_index_range(lc) }
+  end
+  
+end

data/tests/range_test.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/flex_array/range'
+require          'minitest/autorun'
+
+class RangeTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_that_to_spec_component_works
+    lc = (0...10).to_spec_component(3)
+    assert_equal(0...10, lc.range)
+    assert_equal(3, lc.stride)
+    
+    lc = (0...0).to_spec_component(3)
+    assert_equal(0...0, lc.range)
+    assert_equal(3, lc.stride)
+  end
+
+  def test_that_to_spec_component_rejects_bad
+    assert_raises(ArgumentError) { (8...0).to_spec_component(3) }
+    assert_raises(ArgumentError) { ('a'..'b').to_spec_component(3) }
+  end
+  
+  def test_the_to_index_range_method
+    lc = SpecComponent.new(0...10, 1)
+    assert_equal(1...3, (1...3).to_index_range(lc))
+    assert_equal(8..9, (-2..-1).to_index_range(lc))
+    
+    assert_raises(IndexError) { (1...11).to_index_range(lc) }
+    assert_raises(IndexError) { (1..10).to_index_range(lc) }
+    assert_raises(IndexError) { (-2..2).to_index_range(lc) }
+  end
+end