hbase-jruby 0.6.4-java → 0.7.0-java

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = '0.6.4'
+  VERSION = '0.7.0'
 end
 end

data/lib/hbase-jruby.rb

@@ -7,7 +7,6 @@ class HBase
 end
 
 require 'hbase-jruby/version'
-require 'hbase-jruby/dependency'
 require 'hbase-jruby/util'
 require 'hbase-jruby/byte_array'
 require 'hbase-jruby/cell'
@@ -24,4 +23,5 @@ require 'hbase-jruby/table/inspection'
 require 'hbase-jruby/table/checked_operation'
 require 'hbase-jruby/row'
 require 'hbase-jruby/hbase'
+require 'hbase-jruby/dependency'
 

data/test/helper.rb

@@ -1,7 +1,6 @@
 $VERBOSE = true
 
-require 'rubygems'
-require "test-unit"
+require 'minitest/autorun'
 require 'simplecov'
 SimpleCov.start
 
@@ -16,13 +15,11 @@ $rowkey = Time.now.to_i
 
 require "hbase-jruby"
 if jar = ENV['HBASE_JRUBY_TEST_JAR']
-  require jar
-elsif dist = ENV['HBASE_JRUBY_TEST_DIST']
-  HBase.resolve_dependency!(dist, :verbose => true)
+  $CLASSPATH << jar
 end
 HBase.log4j = { 'log4j.threshold' => 'ERROR' }
 
-class TestHBaseJRubyBase < Test::Unit::TestCase
+class TestHBaseJRubyBase < Minitest::Test
   TABLE = 'test_hbase_jruby'
   ZK    = ENV.fetch 'HBASE_JRUBY_TEST_ZK'
 

data/test/test_aggregation.rb

@@ -7,37 +7,37 @@ class TestAggregation < TestHBaseJRubyBase
   def test_aggregation
     omit 'AggregationClient is not found' unless @aggregation
 
-    (1..100).each do |idx|
-      @table.put idx, 'cf1:a' => idx, 'cf1:b' => idx * 2
-    end
+    range = 1..100
+    @table.put range.map { |idx|
+      { idx => { 'cf1:a' => idx, 'cf1:b' => idx * 2 } }
+    }.reduce(&:merge)
 
     assert_nil @table.enable_aggregation!
     assert_nil @table.enable_aggregation! # no prob!
 
     lci = org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter.new
+    scope = @table.range(range)
     [nil, :fixnum, :long, lci].each do |ci|
-      assert_equal 100,  @table.project('cf1:a').aggregate(:row_count, *[*ci].compact)
-      assert_equal 5050, @table.project('cf1:a').aggregate(:sum, *[*ci].compact)
-      assert_equal 1,    @table.project('cf1:a').aggregate(:min, *[*ci].compact)
-      assert_equal 100,  @table.project('cf1:a').aggregate(:max, *[*ci].compact)
-      assert_equal 50.5, @table.project('cf1:a').aggregate(:avg, *[*ci].compact)
-      assert_equal 28,   @table.project('cf1:a').aggregate(:std, *[*ci].compact).to_i # FIXME: 28 or 29?
+      assert_equal 100,  scope.project('cf1:a').aggregate(:row_count, *[*ci].compact)
+      assert_equal 5050, scope.project('cf1:a').aggregate(:sum, *[*ci].compact)
+      assert_equal 1,    scope.project('cf1:a').aggregate(:min, *[*ci].compact)
+      assert_equal 100,  scope.project('cf1:a').aggregate(:max, *[*ci].compact)
+      assert_equal 50.5, scope.project('cf1:a').aggregate(:avg, *[*ci].compact)
+      assert_equal 28,   scope.project('cf1:a').aggregate(:std, *[*ci].compact).to_i # FIXME: 28 or 29?
     end
 
     [%w[cf1:a cf1:b], %w[cf1]].each do |prj|
-      assert_equal 5050 * 3, @table.project(*prj).aggregate(:sum)
-      assert_equal 1,        @table.project(*prj).aggregate(:min)
-      assert_equal 200,      @table.project(*prj).aggregate(:max)
+      assert_equal 5050 * 3, scope.project(*prj).aggregate(:sum)
+      assert_equal 1,        scope.project(*prj).aggregate(:min)
+      assert_equal 200,      scope.project(*prj).aggregate(:max)
     end
 
     # No projection
-    assert_raise(ArgumentError) { @table.aggregate(:sum) }
-    assert_raise(ArgumentError) { @table.scoped.aggregate(:sum) }
+    assert_raises(ArgumentError) { @table.aggregate(:sum) }
+    assert_raises(ArgumentError) { scope.aggregate(:sum) }
 
     # Invalid type
-    assert_raise(ArgumentError) { @table.project('cf1:a').aggregate(:sum, :float) }
-
-    @table.drop!
+    assert_raises(ArgumentError) { scope.project('cf1:a').aggregate(:sum, :double) }
   end
 end
 

data/test/test_byte_array.rb

@@ -3,7 +3,7 @@
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 
-class TestByteArray < Test::Unit::TestCase
+class TestByteArray < Minitest::Test
   def test_order
     [
       [(1..100).to_a, :fixnum],
@@ -66,7 +66,7 @@ class TestByteArray < Test::Unit::TestCase
     assert_equal 100, ba[0, 8].decode(:fixnum)
     assert_equal 200, ba[8...16].as(:fixnum)
     assert_equal "Hello", ba[16, 5].decode(:string)
-    assert_equal 3.14, ba[21..-1].decode(:float)
+    assert_equal 3.14, ba[21..-1].decode(:double)
     assert_equal "H", ba[16].chr
   end
 
@@ -78,29 +78,29 @@ class TestByteArray < Test::Unit::TestCase
     assert_equal 22, ba.length
     assert_equal 200, ba.shift(:fixnum)
     assert_equal 14, ba.length
-    assert_raise(ArgumentError) { ba.shift(:string) }
+    assert_raises(ArgumentError) { ba.shift(:string) }
     assert_equal "Hello", ba.shift(:string, 5)
     assert_equal 9, ba.length
     assert_equal false, ba.shift(:boolean)
     assert_equal 8, ba.length
-    assert_equal 3.14, ba.shift(:float)
+    assert_equal 3.14, ba.shift(:double)
     assert_equal 0, ba.length
 
-    assert_raise(ArgumentError) { ba.shift(:fixnum) }
+    assert_raises(ArgumentError) { ba.shift(:fixnum) }
   end
 
   def test_short_int
     assert_equal 1,  HBase::ByteArray(:byte => 12).length
     assert_equal 12, HBase::ByteArray(:byte => 12).decode(:byte)
-    assert_raise(RangeError) { HBase::ByteArray(:byte => 128) }
+    assert_raises(RangeError) { HBase::ByteArray(:byte => 128) }
 
     assert_equal 2,     HBase::ByteArray(:short => 12345).length
     assert_equal 12345, HBase::ByteArray(:short => 12345).as(:short)
-    assert_raise(RangeError) { HBase::ByteArray( :short => 1 << 16 ) }
+    assert_raises(RangeError) { HBase::ByteArray( :short => 1 << 16 ) }
 
     assert_equal 4,     HBase::ByteArray(:int => 12345).length
     assert_equal 12345, HBase::ByteArray(:int => 12345).decode(:int)
-    assert_raise(RangeError) { HBase::ByteArray.new( :int => 1 << 32 ) }
+    assert_raises(RangeError) { HBase::ByteArray.new( :int => 1 << 32 ) }
 
     ba = HBase::ByteArray( {:int => 10000}, 20000, {:short => 30000}, "Hello" )
     assert_equal 10000, ba[0, 4].as(:int)
@@ -140,7 +140,7 @@ class TestByteArray < Test::Unit::TestCase
     assert_equal 200, ba.shift(:long)
     assert_equal 300, ba.shift(:int)
     assert_equal "Hello", ba.shift(:string, 5)
-    assert_equal 3.14, ba.shift(:float)
+    assert_equal 3.14, ba.shift(:double)
   end
 
   def test_to_s

data/test/test_cell.rb

@@ -14,13 +14,14 @@ class TestCell < TestHBaseJRubyBase
       'value'                   => :string,
       :value                    => :symbol,
       123                       => :fixnum,
-      123.456                   => :float,
+      123.456                   => :double,
       true                      => :boolean,
       false                     => :boolean,
       BigDecimal.new("123.456") => :bigdecimal,
       { :int   => 10240 }       => :int,
       { :short => 1024 }        => :short,
-      { :byte  => 100 }         => :byte
+      { :byte  => 100 }         => :byte,
+      { :float => 123.0 }       => :float
     }.each do |value, type|
       kv = KeyValue.new("rowkey".to_java_bytes, "hello".to_java_bytes, "world".to_java_bytes, ts, Util.to_bytes(value))
       cell = HBase::Cell.new(@table, kv) # FIXME

data/test/test_hbase.rb

@@ -34,19 +34,19 @@ class TestHBase < TestHBaseJRubyBase
     assert @hbase.closed?
     assert table.closed?
 
-    assert_raise(RuntimeError) { @hbase.list }
-    assert_raise(RuntimeError) { table.exists? }
-    assert_raise(RuntimeError) { table.drop! }
+    assert_raises(RuntimeError) { @hbase.list }
+    assert_raises(RuntimeError) { table.exists? }
+    assert_raises(RuntimeError) { table.drop! }
     # ...
 
     # get, delete, put, delete_row, increment, each
-    assert_raise(RuntimeError) { table.first }
-    assert_raise(RuntimeError) { table.get :key }
-    assert_raise(RuntimeError) { table.put :key => {'cf1:a' => 100} }
-    assert_raise(RuntimeError) { table.delete :key }
-    assert_raise(RuntimeError) { table.delete_row :key }
-    assert_raise(RuntimeError) { table.increment :key, 'cf1:a' => 1 }
-    assert_raise(RuntimeError) { table.project('cf1:a').aggregate(:row_count) }
+    assert_raises(RuntimeError) { table.first }
+    assert_raises(RuntimeError) { table.get :key }
+    assert_raises(RuntimeError) { table.put :key => {'cf1:a' => 100} }
+    assert_raises(RuntimeError) { table.delete :key }
+    assert_raises(RuntimeError) { table.delete_row :key }
+    assert_raises(RuntimeError) { table.increment :key, 'cf1:a' => 1 }
+    assert_raises(RuntimeError) { table.project('cf1:a').aggregate(:row_count) }
 
     # Reconnect and check
     @hbase = connect
@@ -109,13 +109,13 @@ class TestHBase < TestHBaseJRubyBase
     hbase2.close
 
     # Connection is already closed
-    assert_raise(RuntimeError) { hbase2[TABLE] }
-    assert_raise(RuntimeError) { table.htable  }
+    assert_raises(RuntimeError) { hbase2[TABLE] }
+    assert_raises(RuntimeError) { table.htable  }
   end
 
   def test_reset_pool
     hbase2 = HBase.new @hbase.config
-    omit_unless(hbase2.use_table_pool?) do
+    if hbase2.use_table_pool?
       table  = hbase2[TABLE]
 
       htable = table.htable

data/test/test_schema.rb

@@ -16,7 +16,7 @@ class TestSchema < TestHBaseJRubyBase
   def test_invalid_schema_type
     @hbase.schema = { @table.name => { :cf1 => { :a => 'string' } } }
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       @hbase.schema = { @table.name => { :cf1 => { :a => :xxx } } }
     end
   end
@@ -28,7 +28,7 @@ class TestSchema < TestHBaseJRubyBase
           :a    => :fixnum,
           :b    => :symbol,
           :c    => :int,
-          /^d/i => :float,
+          /^d/i => :double,
           'd2'  => :short,
         },
         # Every column from cf2 is :string
@@ -36,7 +36,7 @@ class TestSchema < TestHBaseJRubyBase
 
         # cf3:f is a 8-byte integer
         :cf3 => { :f => :fixnum },
-        'cf3:g' => :float
+        'cf3:g' => :double
       }
     }
 
@@ -135,8 +135,8 @@ class TestSchema < TestHBaseJRubyBase
         :name   => :string,
         :age    => :fixnum,
         :sex    => :symbol,
-        :height => :float,
-        :weight => :float,
+        :height => :double,
+        :weight => :double,
         :alive  => :boolean
       },
       :cf2 => {
@@ -188,7 +188,7 @@ class TestSchema < TestHBaseJRubyBase
         :year     => :short,
         :pages    => :int,
         :price    => :bigdecimal,
-        :weight   => :float,
+        :weight   => :double,
         :in_print => :boolean,
         :image    => :raw
       },
@@ -331,7 +331,7 @@ class TestSchema < TestHBaseJRubyBase
     table.mutate(rk) do |m|
       m.delete :comment1, :comment2
       m.put :comment3 => 'nice', :comment4 => 'great'
-      assert_raise(ArgumentError) {
+      assert_raises(ArgumentError) {
         m.put :some_unknown_column => 'perfect'
       }
     end
@@ -397,7 +397,7 @@ class TestSchema < TestHBaseJRubyBase
     }
 
     rk = next_rowkey
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @table.put rk, :a => nil, :b => nil, :c => nil, 'cf1:z' => nil
     }
     @table.put rk, :a => nil, :b => nil, :c => nil, :d => 'yo', 'cf1:z' => 1000
@@ -425,7 +425,7 @@ class TestSchema < TestHBaseJRubyBase
     assert_equal 100, @table.get(rk)['cf1:a']
 
     @hbase.schema.delete @table.name
-    assert_raise(ArgumentError) { @table.get(rk)[:a] }
+    assert_raises(ArgumentError) { @table.get(rk)[:a] }
     assert_equal true, HBase::Util.java_bytes?(@table.get(rk)['cf1:a'])
     assert_equal 100,  HBase::Util.from_bytes(:fixnum, @table.get(rk)['cf1:a'])
   end

data/test/test_scoped.rb

@@ -5,57 +5,57 @@ require 'helper'
 
 class TestScoped < TestHBaseJRubyBase
   def test_invalid_limit
-    assert_raise(ArgumentError) { @table.limit }
-    assert_raise(ArgumentError) { @table.limit(-1) }
-    assert_raise(ArgumentError) { @table.limit("hello") }
+    assert_raises(ArgumentError) { @table.limit }
+    assert_raises(ArgumentError) { @table.limit(-1) }
+    assert_raises(ArgumentError) { @table.limit("hello") }
   end
 
   def test_invalid_versions
-    assert_raise(ArgumentError) { @table.versions }
-    assert_raise(ArgumentError) { @table.versions(0) }
-    assert_raise(ArgumentError) { @table.versions("hello") }
+    assert_raises(ArgumentError) { @table.versions }
+    assert_raises(ArgumentError) { @table.versions(0) }
+    assert_raises(ArgumentError) { @table.versions("hello") }
   end
 
   def test_invalid_batch
-    assert_raise(ArgumentError) { @table.batch }
-    assert_raise(ArgumentError) { @table.batch(0) }
-    assert_raise(ArgumentError) { @table.batch("hello") }
+    assert_raises(ArgumentError) { @table.batch }
+    assert_raises(ArgumentError) { @table.batch(0) }
+    assert_raises(ArgumentError) { @table.batch("hello") }
   end
 
   def test_invalid_range
-    assert_raise(ArgumentError) { @table.range }
-    assert_raise(ArgumentError) { @table.range(:xxx => 'row1') }
-    assert_raise(ArgumentError) { @table.range({}) }
-    assert_raise(ArgumentError) { @table.range(1, 2, 3) }
-    assert_raise(ArgumentError) { @table.range(nil, nil) }
-    assert_raise(ArgumentError) { @table.range(1..3, 4..5) }
+    assert_raises(ArgumentError) { @table.range }
+    assert_raises(ArgumentError) { @table.range(:xxx => 'row1') }
+    assert_raises(ArgumentError) { @table.range({}) }
+    assert_raises(ArgumentError) { @table.range(1, 2, 3) }
+    assert_raises(ArgumentError) { @table.range(nil, nil) }
+    assert_raises(ArgumentError) { @table.range(1..3, 4..5) }
   end
 
   def test_invalid_project
-    assert_raise(ArgumentError) { @table.project(:offset => 'a', :limit => 10).to_a }
-    assert_raise(ArgumentError) { @table.project(:offset => 10, :limit => 'a').to_a }
+    assert_raises(ArgumentError) { @table.project(:offset => 'a', :limit => 10).to_a }
+    assert_raises(ArgumentError) { @table.project(:offset => 10, :limit => 'a').to_a }
 
     @table.project(:offset => 100) # Fine yet
     @table.project(:limit => 10)
-    assert_raise(ArgumentError) { @table.project(:offset => 100).to_a }
-    assert_raise(ArgumentError) { @table.project(:limit  => 10).to_a }
-    assert_raise(ArgumentError) { @table.project(:offset => -1) }
-    assert_raise(ArgumentError) { @table.project(:limit  => -1) }
-    assert_raise(ArgumentError) { @table.project(:offset => :a) }
-    assert_raise(ArgumentError) { @table.project(:limit  => :a) }
-    assert_raise(ArgumentError) { @table.project(:xxx    => 1) }
+    assert_raises(ArgumentError) { @table.project(:offset => 100).to_a }
+    assert_raises(ArgumentError) { @table.project(:limit  => 10).to_a }
+    assert_raises(ArgumentError) { @table.project(:offset => -1) }
+    assert_raises(ArgumentError) { @table.project(:limit  => -1) }
+    assert_raises(ArgumentError) { @table.project(:offset => :a) }
+    assert_raises(ArgumentError) { @table.project(:limit  => :a) }
+    assert_raises(ArgumentError) { @table.project(:xxx    => 1) }
   end
 
   def test_invalid_filter
-    assert_raise(ArgumentError) { @table.filter(3.14) }
-    assert_raise(ArgumentError) { @table.filter('cf1:a' => { :xxx => 50 }) }
-    assert_raise(ArgumentError) { @table.filter('cf1:a' => { :eq => { 1 => 2 } }) }
+    assert_raises(ArgumentError) { @table.filter(3.14) }
+    assert_raises(ArgumentError) { @table.filter('cf1:a' => { :xxx => 50 }) }
+    assert_raises(ArgumentError) { @table.filter('cf1:a' => { :eq => { 1 => 2 } }) }
   end
 
   def test_each_and_count
-    (101..150).each do |i|
-      @table.put(i, 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3)
-    end
+    @table.put (101..150).map { |i|
+      { i => { 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3 } }
+    }.reduce(&:merge)
 
     assert_instance_of HBase::Scoped, @table.scoped
     assert_instance_of Enumerator, @table.each
@@ -154,16 +154,24 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_filter_operator_and_short_int
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @table.filter('cf1:a' => { :long  => 100, :gt => 10 })
     }
   end
 
   def test_scan
     insert = lambda do
-      (40..70).each do |i|
-        @table.put(i, 'cf1:a' => i, 'cf2:b' => i * 2, 'cf3:c' => i * 3, 'cf3:d' => 'dummy', 'cf3:e' => 3.14)
-      end
+      @table.put (40..70).map { |i|
+        {
+          i => {
+            'cf1:a' => i,
+            'cf2:b' => i * 2,
+            'cf3:c' => i * 3,
+            'cf3:d' => 'dummy',
+            'cf3:e' => 3.14
+          }
+        }
+      }.reduce(&:merge)
     end
     insert.call
 
@@ -246,29 +254,20 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_scan_on_non_string_rowkey
-    (1..20).each do |rk|
-      @table.put rk, 'cf1:a' => rk
-    end
+    @table.put (1..20).map { |rk| { rk => { 'cf1:a' => rk } } }.reduce(:merge)
     assert_equal 9, @table.range(1..9).count
     assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9], @table.range(1..9).map { |row| row.rowkey :fixnum }
     assert_equal 8, @table.range(1...9).count
 
-    @table.truncate!
-
-    (1..20).each do |rk|
-      @table.put rk.to_s, 'cf1:a' => rk
-    end
+    @table.put (1..20).map { |rk| { rk.to_s => { 'cf1:a' => rk } } }.reduce(:merge)
     assert_equal 20, @table.range('1'..'9').count
     assert_equal %w[1 10 11 12 13 14 15 16 17 18 19 2 20 3 4 5 6 7 8 9], @table.range('1'..'9').map { |e| e.rowkey :string }
-
     assert_equal 19, @table.range('1'...'9').count
 
-    @table.truncate!
+    @table.delete_row *(1..20).map { |i| [i, i.to_s] }.flatten
+
     data = { 'cf1:1' => 1 } # doesn't matter
-    (1..15).each do |i|
-      @table.put i, data
-      @table.put i.to_s, data
-    end
+    @table.put (1..15).map { |i| { i => data, i.to_s => data } }.reduce(:merge)
 
     assert_equal [1, 2, 3], @table.range(1..3).map { |r| r.rowkey :fixnum }
     assert_equal %w[1 10 11 12 13 14 15 2 3], @table.range('1'..'3').map { |r| r.rowkey :string }
@@ -293,7 +292,7 @@ class TestScoped < TestHBaseJRubyBase
     assert_instance_of org.apache.hadoop.hbase.client.UnmodifyableHTableDescriptor, @table.descriptor
 
     # Should be read-only
-    assert_raise {
+    assert_raises(java.lang.UnsupportedOperationException) {
       @table.descriptor.setMaxFileSize 100 * 1024 ** 2
     }
   end
@@ -307,16 +306,17 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_null_filter
-    10.times do |i|
+    @table.put 10.times.map { |i|
       if i % 2 == 0
-        @table.put i, 'cf1:col1' => true
+        { i => { 'cf1:col1' => true } }
       else
-        @table.put i, 'cf1:col2' => true
+        { i => { 'cf1:col2' => true } }
       end
-    end
-    20.times do |i|
-      @table.put i + 10, 'cf1:col1' => 100, 'cf1:col2' => 100
-    end
+    }.reduce(&:merge)
+
+    @table.put 20.times.map { |i|
+      { i + 10 => { 'cf1:col1' => 100, 'cf1:col2' => 100 } }
+    }.reduce(&:merge)
 
     assert_equal 30, @table.count
     assert_equal 30, @table.filter('cf1:what' => nil).count
@@ -365,9 +365,9 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_prefix_filter
-    ('aa'..'zz').each do |rk|
-      @table.put rk, 'cf1:a' => 1
-    end
+    @table.put ('aa'..'zz').map { |rk|
+      { rk => { 'cf1:a' => 1 } }
+    }.reduce(&:merge)
 
     assert_equal 26, @table.range(:prefix => 'c').count
     assert_equal  1, @table.range(:prefix => 'cc').count
@@ -412,9 +412,9 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_while
-    (0...100).each do |idx|
-      @table.put idx, 'cf1:a' => idx % 10, 'cf2:b' => 'Hello'
-    end
+    @table.put (0...100).map { |idx|
+      { idx => { 'cf1:a' => idx % 10, 'cf2:b' => 'Hello' } }
+    }.reduce(&:merge)
 
     assert_equal 20, @table.filter('cf1:a' => { :lte => 1 }, 'cf2:b' => 'Hello').count
     assert_equal 2,  @table.while( 'cf1:a' => { :lte => 1 }, 'cf2:b' => 'Hello').count
@@ -425,17 +425,18 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_min_max
-    (0...100).each do |idx|
+    (0...20).each do |idx|
       @table.put idx, 'cf1:a' => 1
-      assert_equal 0,   @table.to_a.reverse.min.rowkey(:fixnum)
-      assert_equal idx, @table.to_a.reverse.max.rowkey(:fixnum)
+      rows = @table.to_a
+      assert_equal 0,   rows.reverse.min.rowkey(:fixnum)
+      assert_equal idx, rows.reverse.max.rowkey(:fixnum)
     end
   end
 
   def test_regex
-    ('aa'..'zz').each do |rowkey|
-      @table.put rowkey, 'cf1:a' => rowkey
-    end
+    @table.put ('aa'..'zz').map { |rowkey|
+      { rowkey => { 'cf1:a' => rowkey } }
+    }.reduce(&:merge)
 
     assert_equal  1, @table.filter('cf1:a' => /gg/).count
     assert_equal  1, @table.filter('cf1:a' => /GG/i).count
@@ -451,11 +452,13 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_java_bytes_prefix
-    (1..100).each do |i|
-      (1..100).each do |j|
-        @table.put((HBase::ByteArray(i) + HBase::ByteArray(j)).to_java_bytes, 'cf1:a' => i * j)
-      end
-    end
+    @table.put(
+      (1..100).map { |i|
+        (1..100).map { |j|
+          { (HBase::ByteArray(i) + HBase::ByteArray(j)).to_java_bytes => { 'cf1:a' => i * j } }
+        }
+      }.flatten.reduce(&:merge)
+    )
 
     assert_equal 100, @table.range(:prefix => HBase::ByteArray(50)).count
     assert_equal 100, @table.range(:prefix => HBase::ByteArray(50).to_java_bytes).count
@@ -508,9 +511,9 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_with_java_scan
-    ('a'..'z').each do |rk|
-      @table.put rk, 'cf1:a' => 1
-    end
+    @table.put ('a'..'z').map { |rk|
+      { rk => { 'cf1:a' => 1 } }
+    }.reduce(&:merge)
 
     assert_equal 2, @table.with_java_scan { |scan|
       scan.setStartRow HBase::Util.to_bytes 'a'
@@ -548,9 +551,9 @@ class TestScoped < TestHBaseJRubyBase
   def test_count_options
     # TODO how to confirm?
 
-    (101..150).each do |i|
-      @table.put(i, 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3)
-    end
+    @table.put (101..150).map { |i|
+      { i => { 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3 } }
+    }.reduce(&:merge)
 
     assert_equal 50, @table.count(:cache_blocks => false)
     assert_equal 50, @table.count(:cache_blocks => true)