flex_array 0.3.5 → 0.3.6

data/lib/flex_array/range.rb

@@ -1,10 +1,7 @@
-#Extensions to Range needed to support flex array.
+# Extensions to Range needed to support flex array.
+
 class Range
-  #Convert this integer to a limits component.
-  #<br>Parameters
-  #* stride - the number of cells separating data with adjacent indexes.
-  #<br>Returns
-  #* A SpecComponent object with the same range as self.
+  # Convert this integer to a limits component.
   def to_spec_component(stride)
     min = self.min
 
@@ -17,13 +14,7 @@ class Range
     end
   end
 
-  #Convert this range to an range index against the spec.
-  #<br>Parameters
-  #* spec - The spec component used to validate this index.
-  #<br>Returns
-  #* A range.
-  #<br>Exceptions
-  #* IndexError if the range is not valid.
+  # Convert this range to an range index against the spec.
   def to_index_range(spec)
     self_min, self_max, spec_max = self.begin, self.end, spec.max
     self_max -= 1 if self_max > 0 && self.exclude_end?

data/lib/flex_array/spec_array.rb

@@ -1,4 +1,5 @@
-#This helper class encapsulates an array of flex array spec components.
+# This helper class encapsulates an array of flex array spec components.
+
 class SpecArray < Array
   #The number of elements defined by this array specification.
   attr_reader :spec_count
@@ -6,12 +7,7 @@ class SpecArray < Array
   #The number of dimensions specified by this specification
   alias spec_dimensions length
 
-  #Create a flex array specification.
-  #<br>Parameters
-  #* array_specs - The specification of the flex array subscript limits.
-  #  These can either be an array of containing integers, in which case
-  #  the limits are 0...n or they can be ranges, in which case the
-  #  limits are those of the range.
+  # Create a flex array specification.
   def initialize(array_specs)
     super(0)
     @spec_count = 1
@@ -25,7 +21,7 @@ class SpecArray < Array
     self
   end
 
-  #Is this array specification transposed in any way?
+  # Is this array specification transposed in any way?
   def transposed?
     check = 1
 
@@ -37,7 +33,7 @@ class SpecArray < Array
     false
   end
 
-  #Enlarge the flex array along its first dimension.
+  # Enlarge the flex array along its first dimension.
   def enlarge(growth)
     self[0].enlarge(growth)
 

data/lib/flex_array/spec_component.rb

@@ -1,50 +1,44 @@
-#This helper class encapsulates a single component of the flex array spec.
+# This helper class encapsulates a single component of the flex array spec.
+
 class SpecComponent
-  #The range of acceptable values for this limit.
+  # The range of acceptable values for this limit.
   attr_reader :range
 
-  #The stride of this array dimension. That is, for each step in this
-  #dimension, how many steps are required in the low level array?
+  # The stride of this array dimension. That is, for each step in this
+  # dimension, how many steps are required in the low level array?
   attr_reader :stride
 
-  #Create a limits component from its constituent data.
-  #<br>Parameters
-  #* range - the range of values for this index limit.
-  #* stride - the number of cells separating data with adjacent indexes.
+  # Create a limits component from its constituent data.
   def initialize(range, stride)
     @range, @stride = range, stride
   end
 
-  #Forward '=== value' to the range.
+  # Forward '=== value' to the range.
   def ===(value)
     @range === value
   end
 
-  #Limits are equal if their ranges are equal.
-  #<br>Returns
-  #* true if the spec components have equal ranges.
+  # Limits are equal if their ranges are equal.
   def ==(other)
     @range == other.range
   end
 
-  #Forward 'min' to the range.
+  # Forward 'min' to the range.
   def min
     @range.min
   end
 
-  #Forward 'max' to the range.
+  # Forward 'max' to the range.
   def max
     @range.max
   end
 
-  #Forward 'each' and the block to the range.
+  # Forward 'each' and the block to the range.
   def each(&block)
     @range.each(&block)
   end
 
-  #Compute the span of indexes in this limit component.
-  #<br>Returns
-  #* The span of the range or zero if there is none.
+  # Compute the span of indexes in this limit component.
   def span
     if @range.none?
       0
@@ -53,7 +47,7 @@ class SpecComponent
     end
   end
 
-  #Enlarge the range of this spec by the growth term.
+  # Enlarge the range of this spec by the growth term.
   def enlarge(growth)
     if @range.none?
       @range = 0...growth
@@ -62,9 +56,7 @@ class SpecComponent
     end
   end
 
-  #Compute the step required for the index value.
-  #<br>Returns
-  #* The number of array cells to be skipped for this index.
+  # Compute the step required for the index value.
   def index_step(index)
     (index - @range.min) * @stride
   end

data/lib/flex_array/version.rb

@@ -1,7 +1,6 @@
 # coding: utf-8
 
-#* version.rb - The version string for flex array.
 class FlexArray
   #The version string for flex array.
-  VERSION = "0.3.5"
+  VERSION = "0.3.6".freeze
 end

data/rakefile.rb

@@ -2,18 +2,8 @@
 # coding: utf-8
 
 require 'rake/testtask'
-require 'rdoc/task'
 require "bundler/gem_tasks"
 
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-
-  #List out all the files to be documented.
-  rdoc.rdoc_files.include("lib/**/*.rb", "license.txt", "readme.txt")
-
-  rdoc.options << '--visibility' << 'private'
-end
-
 Rake::TestTask.new do |t|
   #List out all the test files.
   t.test_files = FileList['tests/**/*.rb']

data/reek.txt

@@ -1,2 +1,9 @@
-
-0 total warnings
+lib/flex_array/flex_array_each.rb -- 2 warnings:
+  [178, 198, 217, 237]:RepeatedConditional: FlexArray tests 'blk' at least 4 times [https://github.com/troessner/reek/blob/v5.0.2/docs/Repeated-Conditional.md]
+  [180, 200, 219, 239]:RepeatedConditional: FlexArray tests 'blk.call(@array_data[posn])' at least 4 times [https://github.com/troessner/reek/blob/v5.0.2/docs/Repeated-Conditional.md]
+lib/flex_array/spec_array.rb -- 1 warning:
+  [3]:SubclassedFromCoreClass: SpecArray inherits from core class 'Array' [https://github.com/troessner/reek/blob/v5.0.2/docs/Subclassed-From-Core-Class.md]
+lib/flex_array.rb -- 2 warnings:
+  [40]:Attribute: FlexArray#array_data is a writable attribute [https://github.com/troessner/reek/blob/v5.0.2/docs/Attribute.md]
+  [37]:Attribute: FlexArray#array_specs is a writable attribute [https://github.com/troessner/reek/blob/v5.0.2/docs/Attribute.md]
+5 total warnings

data/tests/array_test.rb

@@ -1,13 +1,9 @@
 require_relative '../lib/flex_array'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class ArrayTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_the_limits_method
     test = [1,2,3,4,5,6]
     assert_equal([0...6], test.limits)

data/tests/flex_array_append_test.rb

@@ -1,13 +1,9 @@
 require_relative '../lib/flex_array'
 gem              'minitest'
 require          'minitest/autorun'
-require          'minitest_visible'
 
 class FlexArrayAppendTester < Minitest::Test
 
-  #Track mini-test progress.
-  include MinitestVisible
-
   def test_append_onto_an_existing_array
     f = FlexArray.new([1,3], "Title")
     assert_equal(2, f.dimensions)
@@ -54,23 +50,4 @@ class FlexArrayAppendTester < Minitest::Test
     assert_raises(ArgumentError) { f << g }
   end
 
-  def test_the_copy_data_method
-    f = FlexArray.new([2,3], "Title")
-    g = FlexArray.new([2,3], "Fight")
-    f.copy_data(g)
-    assert_equal(f.array_data, g.array_data)
-    assert(f.array_data.object_id != g.array_data.object_id)
-  end
-
-  def test_copy_data_method_failures
-    f = FlexArray.new([2,3], "Title")
-    g = FlexArray.new([2,4], "Fight")
-    assert_raises(ArgumentError) { f.copy_data(g) }
-
-    g = FlexArray.new([1,3], "Fight")
-    assert_raises(ArgumentError) { f.copy_data(g) }
-
-    g = FlexArray.new([2,2], "Fight")
-    assert_raises(ArgumentError) { f.copy_data(g) }
-  end
 end

data/tests/flex_array_each_test.rb

@@ -1,487 +1,483 @@
-require_relative '../lib/flex_array'
-gem              'minitest'
-require          'minitest/autorun'
-require          'minitest_visible'
-
-class FlexArrayEachTester < Minitest::Test
-
-  #Track mini-test progress.
-  include MinitestVisible
-
-  def test_each
-    d = [0,1,2,3,4,5,6,7,8]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    it = d.each
-
-    result = q.each do |v|
-      assert_equal(it.next, v)
-    end
-
-    assert_equal(result, q)
-
-    it = q.each
-
-    result = d.each do |v|
-      assert_equal(it.next, v)
-    end
-  end
-
-  def test_select_each
-    d = [0,1,2,3,4,5,6,7,8]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    it = d.each
-
-    result = q.select_each([:all]) do |v|
-      assert_equal(it.next, v)
-    end
-
-    assert_equal(result, q)
-
-    it = q.select_each([:all])
-    d.each do |v|
-      assert_equal(it.next, v)
-    end
-
-    it = d.each
-
-    result = q.select_each([:all, :all]) do |v|
-      assert_equal(it.next, v)
-    end
-
-    d = [0,1,2]
-    it = d.each
-
-    result = q.select_each([0, :all]) do |v|
-      assert_equal(it.next, v)
-    end
-
-    d = [0,3,6]
-    it = d.each
-
-    result = q.select_each([:all, 0]) do |v|
-      assert_equal(it.next, v)
-    end
-  end
-
-  def test_each_with_index
-    d1 = [0,1,2,3,4,5,6,7,8]
-    d2 = [[0,0], [0,1], [0,2],
-          [1,0], [1,1], [1,2],
-          [2,0], [2,1], [2,2]]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    i1 = d1.each
-    i2 = d2.each
-
-    q.each_with_index do |v, i|
-      assert_equal(v, i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    iq = q.each_with_index
-    i2 = d2.each
-
-    d1.each do |v|
-      a,b = iq.next
-      assert_equal(a, v)
-      assert_equal(b, i2.next)
-    end
-  end
-
-  def test_select_each_with_index
-    d1 = [0,1,2,3,4,5,6,7,8]
-    d2 = [[0,0], [0,1], [0,2],
-          [1,0], [1,1], [1,2],
-          [2,0], [2,1], [2,2]]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    i1 = d1.each
-    i2 = d2.each
-
-    q.select_each_with_index([:all]) do |v, i|
-      assert_equal(v, i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    iq = q.select_each_with_index([:all])
-    i2 = d2.each
-
-    d1.each do |v|
-      a,b = iq.next
-      assert_equal(a, v)
-      assert_equal(b, i2.next)
-    end
-
-    i1 = d1.each
-    i2 = d2.each
-
-    q.select_each_with_index([:all, :all]) do |v, i|
-      assert_equal(v, i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    iq = q.select_each_with_index([:all, :all])
-    i2 = d2.each
-
-    d1.each do |v|
-      a,b = iq.next
-      assert_equal(a, v)
-      assert_equal(b, i2.next)
-    end
-
-    d1 = [0,1,2]
-    d2 = [[0,0], [0,1], [0,2]]
-
-    i1 = d1.each
-    i2 = d2.each
-
-    q.select_each_with_index([0, :all]) do |v, i|
-      assert_equal(v, i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    d1 = [0,3,6]
-    d2 = [[0,0], [1,0], [2,0]]
-
-    i1 = d1.each
-    i2 = d2.each
-
-    q.select_each_with_index([:all, 0]) do |v, i|
-      assert_equal(v, i1.next)
-      assert_equal(i, i2.next)
-    end
-  end
-
-  def test_each_raw
-    d0 = [0, 1, 2, 3, 4, 5, 6, 7, 8]
-    d1 = [100, 101, 102, 103, 104, 105, 106, 107, 108]
-    d2 = [[0,0], [0,1], [0,2],
-          [1,0], [1,1], [1,2],
-          [2,0], [2,1], [2,2]]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i0 = d0.each
-    i1 = d1.each
-    i2 = d2.each
-
-    q._each_raw do |i, posn|
-      assert_equal(posn, i0.next)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    iq = q._each_raw
-    i1 = d1.each
-    i2 = d2.each
-
-    d0.each do |v|
-      i, posn = iq.next
-      assert_equal(posn, v)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-  end
-
-  def test_select_each_raw
-    d0 = [0, 1, 2, 3, 4, 5, 6, 7, 8]
-    d1 = [100, 101, 102, 103, 104, 105, 106, 107, 108]
-    d2 = [[0,0], [0,1], [0,2],
-          [1,0], [1,1], [1,2],
-          [2,0], [2,1], [2,2]]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i0 = d0.each
-    i1 = d1.each
-    i2 = d2.each
-
-    q._select_each_raw([:all]) do |i, posn|
-      assert_equal(posn, i0.next)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    i0 = d0.each
-    i1 = d1.each
-    i2 = d2.each
-
-    q._select_each_raw([:all, :all]) do |i, posn|
-      assert_equal(posn, i0.next)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    d0 = [0, 1, 2]
-    d1 = [100, 101, 102]
-    d2 = [[0,0], [0,1], [0,2]]
-
-    i0 = d0.each
-    i1 = d1.each
-    i2 = d2.each
-
-    q._select_each_raw([0, :all]) do |i, posn|
-      assert_equal(posn, i0.next)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-
-    d0 = [0, 3, 6]
-    d1 = [100, 103, 106]
-    d2 = [[0,0], [1,0], [2,0]]
-
-    i0 = d0.each
-    i1 = d1.each
-    i2 = d2.each
-
-    q._select_each_raw([:all, 0]) do |i, posn|
-      assert_equal(posn, i0.next)
-      assert_equal(q.array_data[posn], i1.next)
-      assert_equal(i, i2.next)
-    end
-  end
-
-  def test_cycle
-    d = [0,1,2,3,4,5,6,7,8,0,1,2]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    i = 0
-
-    q.cycle do |v|
-      assert_equal(d[i], v)
-      i += 1
-      break if i == 12
-    end
-
-    iq = q.cycle
-
-    d.each do |v|
-      assert_equal(iq.next, v)
-    end
-  end
-
-  def test_select_cycle
-    d = [0,1,2,3,4,5,6,7,8,0,1,2]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    i = 0
-
-    q.select_cycle([:all]) do |v|
-      assert_equal(d[i], v)
-      i += 1
-      break if i == 12
-    end
-
-    iq = q.select_cycle([:all])
-
-    d.each do |v|
-      assert_equal(iq.next, v)
-    end
-
-    i = 0
-
-    q.select_cycle([:all, :all]) do |v|
-      assert_equal(d[i], v)
-      i += 1
-      break if i == 12
-    end
-
-    iq = q.select_cycle([:all, :all])
-
-    d.each do |v|
-      assert_equal(iq.next, v)
-    end
-
-    d = [0,1,2,0,1,2,0,1,2,0,1,2]
-    i = 0
-
-    q.select_cycle([0, :all]) do |v|
-      assert_equal(d[i], v)
-      i += 1
-      break if i == 12
-    end
-
-    iq = q.select_cycle([0, :all])
-
-    d.each do |v|
-      assert_equal(iq.next, v)
-    end
-
-    d = [0,3,6,0,3,6,0,3,6,0,3,6]
-    i = 0
-
-    q.select_cycle([:all, 0]) do |v|
-      assert_equal(d[i], v)
-      i += 1
-      break if i == 12
-    end
-
-    iq = q.select_cycle([:all, 0])
-
-    d.each do |v|
-      assert_equal(iq.next, v)
-    end
-  end
-
-  def test_flatten_collect
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-
-    b = q.flatten_collect {|v| v * v }
-    assert_equal(d, b)
-  end
-
-  def test_select_flatten_collect
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-
-    b = q.select_flatten_collect([:all]) {|v| v * v }
-    assert_equal(d, b)
-
-    b = q.select_flatten_collect([:all, :all]) {|v| v * v }
-    assert_equal(d, b)
-
-    d = [0,1,4]
-    b = q.select_flatten_collect([0, :all]) {|v| v * v }
-    assert_equal(d, b)
-
-    d = [0,9,36]
-    b = q.select_flatten_collect([:all, 0]) {|v| v * v }
-    assert_equal(d, b)
-  end
-
-
-
-
-
-  def test_collect
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    a = q.collect {|v| v * v }
-    assert_equal(d, a.array_data)
-  end
-
-  def test_select_collect
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    a = q.select_collect([:all]) {|v| v * v }
-    assert_equal(d, a.array_data)
-
-    d = [0,1,16,81,256,625,1296,2401,4096]
-    b = a.select_collect([:all, :all]) {|v| v * v }
-    assert_equal(d, b.array_data)
-
-    d = [0,1,256,81,256,625,1296,2401,4096]
-    c = b.select_collect([0, :all]) {|v| v * v }
-    assert_equal(d, c.array_data)
-
-    d = [0,1,256,6561,256,625,1679616,2401,4096]
-    e = c.select_collect([:all, 0]) {|v| v * v }
-    assert_equal(d, e.array_data)
-  end
-
-  def test_collect_em
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    q.collect! {|v| v * v }
-    assert_equal(d, q.array_data)
-  end
-
-  def test_select_collect_em
-    d = [0,1,4,9,16,25,36,49,64]
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
-    q.select_collect!([:all]) {|v| v * v }
-    assert_equal(d, q.array_data)
-
-    d = [0,1,16,81,256,625,1296,2401,4096]
-    q.select_collect!([:all, :all]) {|v| v * v }
-    assert_equal(d, q.array_data)
-
-    d = [0,1,256,81,256,625,1296,2401,4096]
-    q.select_collect!([0, :all]) {|v| v * v }
-    assert_equal(d, q.array_data)
-
-    d = [0,1,256,6561,256,625,1679616,2401,4096]
-    q.select_collect!([:all, 0]) {|v| v * v }
-    assert_equal(d, q.array_data)
-  end
-
-  def test_find_index
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i = q.find_index(107)
-    assert_equal([2, 1], i)
-
-    i = q.find_index { |v| v > 106 }
-    assert_equal([2, 1], i)
-
-    i = q.find_index(300)
-    assert_equal(nil, i)
-
-    i = q.find_index { |v| v > 206 }
-    assert_equal(nil, i)
-  end
-
-  def test_select_find_index
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i = q.select_find_index([:all], 107)
-    assert_equal([2, 1], i)
-
-    i = q.select_find_index([:all, :all], 107)
-    assert_equal([2, 1], i)
-
-    i = q.select_find_index([0, :all], 107)
-    assert_equal(nil, i)
-
-    i = q.select_find_index([1, :all], 107)
-    assert_equal(nil, i)
-
-    i = q.select_find_index([2, :all], 107)
-    assert_equal([2, 1], i)
-
-    i = q.select_find_index([:all, 0], 107)
-    assert_equal(nil, i)
-
-    i = q.select_find_index([:all, 1], 107)
-    assert_equal([2, 1], i)
-
-    i = q.select_find_index([:all, 2], 107)
-    assert_equal(nil, i)
-  end
-
-  def test_find_indexes
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i = q.find_indexes(107)
-    assert_equal([[2, 1]], i)
-
-    i = q.find_indexes { |v| v == 107 }
-    assert_equal([[2, 1]], i)
-
-    i = q.find_indexes { |v| v > 106 }
-    assert_equal([[2, 1], [2, 2]], i)
-
-    i = q.find_indexes(307)
-    assert_equal([], i)
-
-    i = q.find_indexes { |v| v > 406 }
-    assert_equal([], i)
-  end
-
-  def test_select_find_indexes
-    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
-    i = q.select_find_indexes([:all], 107)
-    assert_equal([[2, 1]], i)
-
-    i = q.select_find_indexes([:all, :all], 107)
-    assert_equal([[2, 1]], i)
-
-    i = q.select_find_indexes([0, :all], 107)
-    assert_equal([], i)
-
-    i = q.select_find_indexes([1, :all], 107)
-    assert_equal([], i)
-
-    i = q.select_find_indexes([2, :all], 107)
-    assert_equal([[2, 1]], i)
-
-    i = q.select_find_indexes([:all, 0], 107)
-    assert_equal([], i)
-
-    i = q.select_find_indexes([:all, 1], 107)
-    assert_equal([[2, 1]], i)
-
-    i = q.select_find_indexes([:all, 2], 107)
-    assert_equal([], i)
-  end
-end
+require_relative '../lib/flex_array'
+gem              'minitest'
+require          'minitest/autorun'
+
+class FlexArrayEachTester < Minitest::Test
+
+  def test_each
+    d = [0,1,2,3,4,5,6,7,8]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    it = d.each
+
+    result = q.each do |v|
+      assert_equal(it.next, v)
+    end
+
+    assert_equal(result, q)
+
+    it = q.each
+
+    result = d.each do |v|
+      assert_equal(it.next, v)
+    end
+  end
+
+  def test_select_each
+    d = [0,1,2,3,4,5,6,7,8]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    it = d.each
+
+    result = q.select_each([:all]) do |v|
+      assert_equal(it.next, v)
+    end
+
+    assert_equal(result, q)
+
+    it = q.select_each([:all])
+    d.each do |v|
+      assert_equal(it.next, v)
+    end
+
+    it = d.each
+
+    result = q.select_each([:all, :all]) do |v|
+      assert_equal(it.next, v)
+    end
+
+    d = [0,1,2]
+    it = d.each
+
+    result = q.select_each([0, :all]) do |v|
+      assert_equal(it.next, v)
+    end
+
+    d = [0,3,6]
+    it = d.each
+
+    result = q.select_each([:all, 0]) do |v|
+      assert_equal(it.next, v)
+    end
+  end
+
+  def test_each_with_index
+    d1 = [0,1,2,3,4,5,6,7,8]
+    d2 = [[0,0], [0,1], [0,2],
+          [1,0], [1,1], [1,2],
+          [2,0], [2,1], [2,2]]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    i1 = d1.each
+    i2 = d2.each
+
+    q.each_with_index do |v, i|
+      assert_equal(v, i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    iq = q.each_with_index
+    i2 = d2.each
+
+    d1.each do |v|
+      a,b = iq.next
+      assert_equal(a, v)
+      assert_equal(b, i2.next)
+    end
+  end
+
+  def test_select_each_with_index
+    d1 = [0,1,2,3,4,5,6,7,8]
+    d2 = [[0,0], [0,1], [0,2],
+          [1,0], [1,1], [1,2],
+          [2,0], [2,1], [2,2]]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    i1 = d1.each
+    i2 = d2.each
+
+    q.select_each_with_index([:all]) do |v, i|
+      assert_equal(v, i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    iq = q.select_each_with_index([:all])
+    i2 = d2.each
+
+    d1.each do |v|
+      a,b = iq.next
+      assert_equal(a, v)
+      assert_equal(b, i2.next)
+    end
+
+    i1 = d1.each
+    i2 = d2.each
+
+    q.select_each_with_index([:all, :all]) do |v, i|
+      assert_equal(v, i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    iq = q.select_each_with_index([:all, :all])
+    i2 = d2.each
+
+    d1.each do |v|
+      a,b = iq.next
+      assert_equal(a, v)
+      assert_equal(b, i2.next)
+    end
+
+    d1 = [0,1,2]
+    d2 = [[0,0], [0,1], [0,2]]
+
+    i1 = d1.each
+    i2 = d2.each
+
+    q.select_each_with_index([0, :all]) do |v, i|
+      assert_equal(v, i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    d1 = [0,3,6]
+    d2 = [[0,0], [1,0], [2,0]]
+
+    i1 = d1.each
+    i2 = d2.each
+
+    q.select_each_with_index([:all, 0]) do |v, i|
+      assert_equal(v, i1.next)
+      assert_equal(i, i2.next)
+    end
+  end
+
+  def test_each_raw
+    d0 = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    d1 = [100, 101, 102, 103, 104, 105, 106, 107, 108]
+    d2 = [[0,0], [0,1], [0,2],
+          [1,0], [1,1], [1,2],
+          [2,0], [2,1], [2,2]]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i0 = d0.each
+    i1 = d1.each
+    i2 = d2.each
+
+    q._each_raw do |i, posn|
+      assert_equal(posn, i0.next)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    iq = q._each_raw
+    i1 = d1.each
+    i2 = d2.each
+
+    d0.each do |v|
+      i, posn = iq.next
+      assert_equal(posn, v)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+  end
+
+  def test_select_each_raw
+    d0 = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    d1 = [100, 101, 102, 103, 104, 105, 106, 107, 108]
+    d2 = [[0,0], [0,1], [0,2],
+          [1,0], [1,1], [1,2],
+          [2,0], [2,1], [2,2]]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i0 = d0.each
+    i1 = d1.each
+    i2 = d2.each
+
+    q._select_each_raw([:all]) do |i, posn|
+      assert_equal(posn, i0.next)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    i0 = d0.each
+    i1 = d1.each
+    i2 = d2.each
+
+    q._select_each_raw([:all, :all]) do |i, posn|
+      assert_equal(posn, i0.next)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    d0 = [0, 1, 2]
+    d1 = [100, 101, 102]
+    d2 = [[0,0], [0,1], [0,2]]
+
+    i0 = d0.each
+    i1 = d1.each
+    i2 = d2.each
+
+    q._select_each_raw([0, :all]) do |i, posn|
+      assert_equal(posn, i0.next)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+
+    d0 = [0, 3, 6]
+    d1 = [100, 103, 106]
+    d2 = [[0,0], [1,0], [2,0]]
+
+    i0 = d0.each
+    i1 = d1.each
+    i2 = d2.each
+
+    q._select_each_raw([:all, 0]) do |i, posn|
+      assert_equal(posn, i0.next)
+      assert_equal(q.array_data[posn], i1.next)
+      assert_equal(i, i2.next)
+    end
+  end
+
+  def test_cycle
+    d = [0,1,2,3,4,5,6,7,8,0,1,2]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    i = 0
+
+    q.cycle do |v|
+      assert_equal(d[i], v)
+      i += 1
+      break if i == 12
+    end
+
+    iq = q.cycle
+
+    d.each do |v|
+      assert_equal(iq.next, v)
+    end
+  end
+
+  def test_select_cycle
+    d = [0,1,2,3,4,5,6,7,8,0,1,2]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    i = 0
+
+    q.select_cycle([:all]) do |v|
+      assert_equal(d[i], v)
+      i += 1
+      break if i == 12
+    end
+
+    iq = q.select_cycle([:all])
+
+    d.each do |v|
+      assert_equal(iq.next, v)
+    end
+
+    i = 0
+
+    q.select_cycle([:all, :all]) do |v|
+      assert_equal(d[i], v)
+      i += 1
+      break if i == 12
+    end
+
+    iq = q.select_cycle([:all, :all])
+
+    d.each do |v|
+      assert_equal(iq.next, v)
+    end
+
+    d = [0,1,2,0,1,2,0,1,2,0,1,2]
+    i = 0
+
+    q.select_cycle([0, :all]) do |v|
+      assert_equal(d[i], v)
+      i += 1
+      break if i == 12
+    end
+
+    iq = q.select_cycle([0, :all])
+
+    d.each do |v|
+      assert_equal(iq.next, v)
+    end
+
+    d = [0,3,6,0,3,6,0,3,6,0,3,6]
+    i = 0
+
+    q.select_cycle([:all, 0]) do |v|
+      assert_equal(d[i], v)
+      i += 1
+      break if i == 12
+    end
+
+    iq = q.select_cycle([:all, 0])
+
+    d.each do |v|
+      assert_equal(iq.next, v)
+    end
+  end
+
+  def test_flatten_collect
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+
+    b = q.flatten_collect {|v| v * v }
+    assert_equal(d, b)
+  end
+
+  def test_select_flatten_collect
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+
+    b = q.select_flatten_collect([:all]) {|v| v * v }
+    assert_equal(d, b)
+
+    b = q.select_flatten_collect([:all, :all]) {|v| v * v }
+    assert_equal(d, b)
+
+    d = [0,1,4]
+    b = q.select_flatten_collect([0, :all]) {|v| v * v }
+    assert_equal(d, b)
+
+    d = [0,9,36]
+    b = q.select_flatten_collect([:all, 0]) {|v| v * v }
+    assert_equal(d, b)
+  end
+
+
+
+
+
+  def test_collect
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    a = q.collect {|v| v * v }
+    assert_equal(d, a.array_data)
+  end
+
+  def test_select_collect
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    a = q.select_collect([:all]) {|v| v * v }
+    assert_equal(d, a.array_data)
+
+    d = [0,1,16,81,256,625,1296,2401,4096]
+    b = a.select_collect([:all, :all]) {|v| v * v }
+    assert_equal(d, b.array_data)
+
+    d = [0,1,256,81,256,625,1296,2401,4096]
+    c = b.select_collect([0, :all]) {|v| v * v }
+    assert_equal(d, c.array_data)
+
+    d = [0,1,256,6561,256,625,1679616,2401,4096]
+    e = c.select_collect([:all, 0]) {|v| v * v }
+    assert_equal(d, e.array_data)
+  end
+
+  def test_collect_em
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    q.collect! {|v| v * v }
+    assert_equal(d, q.array_data)
+  end
+
+  def test_select_collect_em
+    d = [0,1,4,9,16,25,36,49,64]
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1]}
+    q.select_collect!([:all]) {|v| v * v }
+    assert_equal(d, q.array_data)
+
+    d = [0,1,16,81,256,625,1296,2401,4096]
+    q.select_collect!([:all, :all]) {|v| v * v }
+    assert_equal(d, q.array_data)
+
+    d = [0,1,256,81,256,625,1296,2401,4096]
+    q.select_collect!([0, :all]) {|v| v * v }
+    assert_equal(d, q.array_data)
+
+    d = [0,1,256,6561,256,625,1679616,2401,4096]
+    q.select_collect!([:all, 0]) {|v| v * v }
+    assert_equal(d, q.array_data)
+  end
+
+  def test_find_index
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i = q.find_index(107)
+    assert_equal([2, 1], i)
+
+    i = q.find_index { |v| v > 106 }
+    assert_equal([2, 1], i)
+
+    i = q.find_index(300)
+    assert_nil(i)
+
+    i = q.find_index { |v| v > 206 }
+    assert_nil(i)
+  end
+
+  def test_select_find_index
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i = q.select_find_index([:all], 107)
+    assert_equal([2, 1], i)
+
+    i = q.select_find_index([:all, :all], 107)
+    assert_equal([2, 1], i)
+
+    i = q.select_find_index([0, :all], 107)
+    assert_nil(i)
+
+    i = q.select_find_index([1, :all], 107)
+    assert_nil(i)
+
+    i = q.select_find_index([2, :all], 107)
+    assert_equal([2, 1], i)
+
+    i = q.select_find_index([:all, 0], 107)
+    assert_nil(i)
+
+    i = q.select_find_index([:all, 1], 107)
+    assert_equal([2, 1], i)
+
+    i = q.select_find_index([:all, 2], 107)
+    assert_nil(i)
+  end
+
+  def test_find_indexes
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i = q.find_indexes(107)
+    assert_equal([[2, 1]], i)
+
+    i = q.find_indexes { |v| v == 107 }
+    assert_equal([[2, 1]], i)
+
+    i = q.find_indexes { |v| v > 106 }
+    assert_equal([[2, 1], [2, 2]], i)
+
+    i = q.find_indexes(307)
+    assert_equal([], i)
+
+    i = q.find_indexes { |v| v > 406 }
+    assert_equal([], i)
+  end
+
+  def test_select_find_indexes
+    q = FlexArray.new([3, 3]) {|i| i[0] * 3 + i[1] + 100}
+    i = q.select_find_indexes([:all], 107)
+    assert_equal([[2, 1]], i)
+
+    i = q.select_find_indexes([:all, :all], 107)
+    assert_equal([[2, 1]], i)
+
+    i = q.select_find_indexes([0, :all], 107)
+    assert_equal([], i)
+
+    i = q.select_find_indexes([1, :all], 107)
+    assert_equal([], i)
+
+    i = q.select_find_indexes([2, :all], 107)
+    assert_equal([[2, 1]], i)
+
+    i = q.select_find_indexes([:all, 0], 107)
+    assert_equal([], i)
+
+    i = q.select_find_indexes([:all, 1], 107)
+    assert_equal([[2, 1]], i)
+
+    i = q.select_find_indexes([:all, 2], 107)
+    assert_equal([], i)
+  end
+end