sixarm_ruby_ramp 4.2.3 → 4.2.4

data/test/sixarm_ruby_ramp_test/enumerable/each_test.rb

@@ -0,0 +1,337 @@
+# -*- coding: utf-8 -*-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/enumerable/each"
+
+class EnumerableEachTest < Minitest::Test
+
+  LIST = ["a", "b", "c", "d", "e", "f"]
+
+  ### #each_at
+
+  def test_each_at_with_numeric_positive
+    filter = 1
+    expect = ["b"]
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_numeric_negative
+    filter = -1
+    expect = ["f"]
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_enumerable_positives_asendining
+    filter = [1, 2]
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_enumerable_positives_descending
+    filter = [2, 1]
+    expect = ["c", "b"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_enumerable_negatives_ascending
+    filter = [-2, -1]
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_enumerable_negatives_descending
+    filter = [-1, -2]
+    expect = ["f", "e"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_range_positives_ascending
+    filter = 1..2
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_range_positives_descending
+    filter = 2..1
+    expect = []   # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_range_negatives_ascending
+    filter = -2..-1
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_with_range_negatives_descending
+    filter = -1..-2
+    expect = []  # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  ### #each_at_strategy_with_optimization_off
+
+  def test_each_at_strategy_with_optimization_off_with_numeric_positive
+    filter = [1]  # Note: must be wrapped in an array because the strategy presumes filter#include?.
+    expect = ["b"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_numeric_negative
+    filter = [-1]  # Note: must be wrapped in an array because the strategy 0 presumes filter#include?.
+    expect = ["f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_enumerable_positives_asendining
+    filter = [1, 2]
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_enumerable_positives_descending
+    filter = [2, 1]
+    expect = ["b", "c"]  # Note: order depends on LIST, not filter, because the strategy uses filter#include?.
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_enumerable_negatives_ascending
+    filter = [-2, -1]
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_enumerable_negatives_descending
+    filter = [-1, -2]
+    expect = ["e", "f"]  # Note: order depends on LIST, not filter, because the strategy uses filter#include?.
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_range_positives_ascending
+    filter = 1..2
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_range_positives_descending
+    filter = 2..1
+    expect = []   # Degenerate because filter#include? will always be false.
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_range_negatives_ascending
+    filter = -2..-1
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_off_with_range_negatives_descending
+    filter = -1..-2
+    expect = []  # Degenerate because filter#include? will always be false.
+    actual = []
+    LIST.each_at_strategy_with_optimization_off(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  ### #each_at_strategy_with_optimization_min
+
+  def test_each_at_strategy_with_optimization_min_with_numeric_positive
+    filter = [1]  # Note: must be wrapped in an array because the strategy presumes filter#each.
+    expect = ["b"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_numeric_negative
+    filter = [-1]  # Note: must be wrapped in an array because then strategy presumes filter#each.
+    expect = ["f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_enumerable_positives_asendining
+    filter = [1, 2]
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_enumerable_positives_descending
+    filter = [2, 1]
+    expect = ["c", "b"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_enumerable_negatives_ascending
+    filter = [-2, -1]
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_enumerable_negatives_descending
+    filter = [-1, -2]
+    expect = ["f", "e"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_range_positives_ascending
+    filter = 1..2
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_range_positives_descending
+    filter = 2..1
+    expect = []   # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_range_negatives_ascending
+    filter = -2..-1
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_min_with_range_negatives_descending
+    filter = -1..-2
+    expect = []  # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at_strategy_with_optimization_min(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  ### #each_at_strategy_with_optimization_max
+
+  def test_each_at_strategy_with_optimization_max_with_numeric_positive
+    filter = [1]  # Note: must be wrapped in an array because the strategy presumes filter#each.
+    expect = ["b"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_numeric_negative
+    filter = [-1]  # Note: must be wrapped in an array because then strategy presumes filter#each.
+    expect = ["f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_enumerable_positives_asendining
+    filter = [1, 2]
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_enumerable_positives_descending
+    filter = [2, 1]
+    expect = ["c", "b"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_enumerable_negatives_ascending
+    filter = [-2, -1]
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_enumerable_negatives_descending
+    filter = [-1, -2]
+    expect = ["f", "e"]  # Note: order depends on filter, not LIST, because the strategy uses filter#each.
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_range_positives_ascending
+    filter = 1..2
+    expect = ["b", "c"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_range_positives_descending
+    filter = 2..1
+    expect = []   # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_range_negatives_ascending
+    filter = -2..-1
+    expect = ["e", "f"]
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+  def test_each_at_strategy_with_optimization_max_with_range_negatives_descending
+    filter = -1..-2
+    expect = []  # Degenerate because filter#each will noop.
+    actual = []
+    LIST.each_at_strategy_with_optimization_max(filter){|o| actual << o}
+    assert_equal(expect, actual)
+  end
+
+end

data/test/sixarm_ruby_ramp_test/enumerable/map_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/enumerable/map"
 require "ostruct"
 

data/test/sixarm_ruby_ramp_test/enumerable/nitems_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/enumerable/nitems"
 
 class EnumerableNItemsTest < Minitest::Test

data/test/sixarm_ruby_ramp_test/enumerable/select_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/enumerable/select"
 
 class EnumerableSelectTest < Minitest::Test

data/test/sixarm_ruby_ramp_test/enumerable_test.rb

@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-require "set"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/enumerable"
 
 class EnumerableTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/file_test.rb

@@ -1,17 +1,15 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/file"
 
-
-class FileTestCase < Minitest::Test
+class FileTestClass < Minitest::Test
 
   def test_load_dir_files
     filename='/a/b/c.d'
     dirname=File.dirname(filename)
-    expect=File.join(dirname,'x','y','z')   
+    expect=File.join(dirname,'x','y','z')
     actual=File.joindir(filename,'x','y','z')
     assert_equal(expect,actual,"filename:#{filename} dirname:#{dirname}")
   end
 
 end
-

data/test/sixarm_ruby_ramp_test/fixnum_test.rb

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/fixnum"
 
 class FixnumTest < Minitest::Test
 
@@ -22,4 +21,3 @@ class FixnumTest < Minitest::Test
   end
 
 end
-

data/test/sixarm_ruby_ramp_test/hash_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/hash"
 
 class HashTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/integer/rbit_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/integer/rbit"
 
 class IntegerTest < Minitest::Test

data/test/sixarm_ruby_ramp_test/integer_test.rb

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/integer"
 
 class IntegerTest < Minitest::Test
 
@@ -12,8 +11,8 @@ class IntegerTest < Minitest::Test
   end
 
   def test_maps_with_index
-    expect=[0,1,2]
-    actual=3.maps{|i| i}
+    expect=[0,2,4]
+    actual=3.maps{|i| i * 2}
     assert_equal(expect,actual)
   end
 

data/test/sixarm_ruby_ramp_test/io_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/io"
 
 class IOTest < Minitest::Test
 
@@ -27,4 +27,3 @@ class IOTest < Minitest::Test
  end
 
 end
-

data/test/sixarm_ruby_ramp_test/kernel_test.rb

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/kernel"
 
 class KernelTest < Minitest::Test
 
   class TestMyMethodName
     def a
-      my_method_name  
+      my_method_name
     end
   end
 
@@ -18,7 +18,7 @@ class KernelTest < Minitest::Test
 
   class TestCallerMethodNameWithIndex0
     def a
-      caller_method_name(0)  
+      caller_method_name(0)
     end
   end
 
@@ -27,7 +27,7 @@ class KernelTest < Minitest::Test
       b
     end
     def b
-      caller_method_name(1) 
+      caller_method_name(1)
     end
   end
 
@@ -52,4 +52,3 @@ class KernelTest < Minitest::Test
   end
 
 end
-

data/test/sixarm_ruby_ramp_test/math_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/math"
 
 class MathTest < Minitest::Test
 
@@ -16,4 +16,3 @@ class MathTest < Minitest::Test
   end
 
 end
-

data/test/sixarm_ruby_ramp_test/nil_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/nil"
 
 class NilTest < Minitest::Test
 
@@ -13,4 +13,3 @@ class NilTest < Minitest::Test
  end
 
 end
-

data/test/sixarm_ruby_ramp_test/numeric_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/numeric"
 
 class NumericTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/object_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/object"
 
 class ObjectTest < Minitest::Test
 
@@ -10,4 +10,3 @@ class ObjectTest < Minitest::Test
  end
 
 end
-

data/test/sixarm_ruby_ramp_test/pairable_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/pairable"
 
 class PairableTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/process_test.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/process"
 
 class ProcessTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/string_test.rb

@@ -1,51 +1,41 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/string"
 
 class StringTest < Minitest::Test
 
-
   def test_capitalize_words
     assert_equal("Foo Goo Hoo","foo goo hoo".capitalize_words)
   end
 
-
   def test_words
     assert_equal(['foo','goo','hoo'],"foo goo hoo".words)
   end
 
-
   def test_split_tab
     assert_equal(['foo','goo','hoo'],"foo\tgoo\thoo".split_tab)
   end
 
-
   def test_split_tsv
     assert_equal([['a','b','c'],['d','e','f'],['g','h','i']],"a\tb\tc\nd\te\tf\ng\th\ti".split_tsv)
   end
 
-
   def test_xid
     assert_equal('foo_goo_hoo',"Foo GOO**_**Hoo".to_xid)
   end
 
-
   def test_lowcase
     assert_equal('foo_goo_hoo',"Foo GOO**_**Hoo".lowcase)
   end
 
-  
   def test_to_class
     assert_equal(String,'String'.to_class)
   end
 
-
   def test_to_class_nested
     assert_equal(FooModule::FooClass,'FooModule::FooClass'.to_class)
   end
 
-
   def test_increment
     assert_equal('5','4'.increment,               'number is entire string')
     assert_equal('5foo','4foo'.increment,         'number is leftmost')
@@ -55,7 +45,6 @@ class StringTest < Minitest::Test
     assert_equal('foobar','foobar'.increment,     'no number, so should be unchanged')
   end
 
-
   def test_decrement
     assert_equal('3','4'.decrement,               'number is entire string')
     assert_equal('3foo','4foo'.decrement,         'number is leftmost')
@@ -65,7 +54,6 @@ class StringTest < Minitest::Test
     assert_equal('foobar','foobar'.decrement,     'no number, so should be unchanged')
   end
 
-
   def test_prev_char
     assert_equal(["-",false,false] ,String.prev_char("-"))  #unchanged
     assert_equal(["5",true,false]  ,String.prev_char("6"))  #numeric typical
@@ -76,7 +64,6 @@ class StringTest < Minitest::Test
     assert_equal(["Z",true,true]   ,String.prev_char("A"))  #uppercase carry
   end
 
-
   def test_prev
     assert_equal('n-','n-'.prev)     # unchanged
     assert_equal('n5','n6'.prev)     # numeric typical
@@ -112,20 +99,8 @@ class StringTest < Minitest::Test
 
 end
 
-
 # For testing #to_class
 module FooModule #:nodoc: all
   class FooClass
   end
 end
-
-
-
-
-
-
-
-
-
-
-