hbase-jruby 0.6.4-java → 0.7.0-java

data/test/test_table.rb

@@ -80,7 +80,7 @@ class TestTable < TestHBaseJRubyBase
     assert_equal 'a',    @table.get(row1).string('cf1:b')
     assert_equal 'a',    String.from_java_bytes(@table.get(row1).raw('cf1:b'))
     assert_equal 'a',    @table.get(row1).byte_array('cf1:b').as(:string)
-    assert_equal 3.14,   @table.get(row1).float('cf1:c')
+    assert_equal 3.14,   @table.get(row1).double('cf1:c')
     assert_equal true,   @table.get(row1).boolean('cf1:d')
     assert_equal :sym,   @table.get(row1).symbol('cf1:f')
     assert_equal BigDecimal.new("123.456"), @table.get(row1).bigdecimal('cf1:g')
@@ -97,7 +97,7 @@ class TestTable < TestHBaseJRubyBase
     assert_equal %w[a b],       @table.versions(:all).get(row1).strings('cf1:b').values
     assert_equal %w[a b],       @table.versions(:all).get(row1).raws('cf1:b').values.map { |v| String.from_java_bytes v }
     assert_equal %w[a b],       @table.versions(:all).get(row1).byte_arrays('cf1:b').values.map { |v| v.as :string }
-    assert_equal [3.14, 6.28],  @table.versions(:all).get(row1).floats('cf1:c').values
+    assert_equal [3.14, 6.28],  @table.versions(:all).get(row1).doubles('cf1:c').values
     assert_equal [true, false], @table.versions(:all).get(row1).booleans('cf1:d').values
     assert_equal [:sym, :bol],  @table.versions(:all).get(row1).symbols('cf1:f').values
     assert_equal [
@@ -117,7 +117,7 @@ class TestTable < TestHBaseJRubyBase
     # multi-get
     assert_equal [row1, row2, row3], @table.get([row1, row2, row3]).map { |r| r.rowkey :string }
     assert_equal [1, 2, 4         ], @table.get([row1, row2, row3]).map { |r| r.fixnum('cf1:a') }
-    assert_equal [3.14, 6.28, 6.28], @table.get([row1, row2, row3]).map { |r| r.float('cf1:c') }
+    assert_equal [3.14, 6.28, 6.28], @table.get([row1, row2, row3]).map { |r| r.double('cf1:c') }
     assert_equal [nil, nil        ], @table.get(['xxx', 'yyy'])
 
     # Unavailable columns
@@ -135,16 +135,16 @@ class TestTable < TestHBaseJRubyBase
   # Put added after a delete is overshadowed if its timestamp is older than than that of the tombstone
   # https://issues.apache.org/jira/browse/HBASE-2847
   def test_put_delete_put
+    skip "https://issues.apache.org/jira/browse/HBASE-2847"
+
     rowkey = next_rowkey
-    pend("https://issues.apache.org/jira/browse/HBASE-2847") do
-      data = { 'cf1:pdp' => { 1250000000000 => 'A1' } }
-      @table.put rowkey => data
-      assert_equal 'A1', @table.get(rowkey).string('cf1:pdp')
-      @table.delete rowkey
-      assert_nil @table.get(rowkey)
-      @table.put rowkey => data
-      assert_equal 'A1', @table.get(rowkey).string('cf1:pdp')
-    end
+    data = { 'cf1:pdp' => { 1250000000000 => 'A1' } }
+    @table.put rowkey => data
+    assert_equal 'A1', @table.get(rowkey).string('cf1:pdp')
+    @table.delete rowkey
+    assert_nil @table.get(rowkey)
+    @table.put rowkey => data
+    assert_equal 'A1', @table.get(rowkey).string('cf1:pdp')
   end
 
   def test_put_timestamp
@@ -339,8 +339,8 @@ class TestTable < TestHBaseJRubyBase
   end
 
   def test_check
-    assert_raise(ArgumentError) { @table.check(1, :a => 1, :b => 2) }
-    assert_raise(ArgumentError) { @table.check(1) }
+    assert_raises(ArgumentError) { @table.check(1, :a => 1, :b => 2) }
+    assert_raises(ArgumentError) { @table.check(1) }
   end
 
   def test_check_and_put
@@ -453,7 +453,7 @@ class TestTable < TestHBaseJRubyBase
     assert_equal nil,     row.string('cf1:c')
     assert_equal nil,     row['cf1:c']
     assert_equal true,    row.boolean('cf1:z')
-    assert_equal nil,     row.float('cf2:d')
+    assert_equal nil,     row.double('cf2:d')
     assert_equal nil,     row['cf2:d']
 
     @table.mutate(rk) { |m| } # Nothing
@@ -462,7 +462,7 @@ class TestTable < TestHBaseJRubyBase
   end
 
   def test_invalid_column_key
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @table.put next_rowkey, :some_column => 1
     }
   end
@@ -543,8 +543,8 @@ class TestTable < TestHBaseJRubyBase
   end
 
   def test_thread_local_cache
-    cached = @hbase[TABLE, :cache => true]
-    not_cached = @hbase[TABLE]
+    cached = @hbase[TABLE]
+    not_cached = @hbase[TABLE, :column_cache => 0]
 
     cached.put     next_rowkey, 'cf1:abc' => 100
     not_cached.put next_rowkey, 'cf1:def' => 100
@@ -555,5 +555,18 @@ class TestTable < TestHBaseJRubyBase
     # FIXME closing not_cached will also remove the cache
     assert_nil Thread.current[:hbase_jruby][@hbase][TABLE.to_sym]
   end
+
+  def test_thread_local_cache_limit
+    times = 20
+    cached = @hbase[TABLE, :column_cache => times]
+    times.times do |i|
+      cached.put next_rowkey, [:cf1, i] => 100
+    end
+    assert_equal times, Thread.current[:hbase_jruby][@hbase][TABLE.to_sym][:columns].length
+    assert_equal [:cf1, 0],
+      Thread.current[:hbase_jruby][@hbase][TABLE.to_sym][:columns].values.map { |triple|
+        triple[0, 2].zip([:symbol, :fixnum]).map { |(val, type)| HBase::Util.from_bytes type, val }
+      }. sort.first
+  end
 end
 

data/test/test_table_admin.rb

@@ -4,40 +4,39 @@ $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 
 class TestTableAdmin < TestHBaseJRubyBase
-  def teardown
-    @table.drop! if @table.exists?
-  end
-
   def test_create_table_symbol_string
-    t = @hbase.table(:test_hbase_jruby_create_table)
+    t = @hbase.table("hbase_jruby_#{__method__}")
     t.drop! if t.exists?
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       t.create! :cf, :splits => :xxx
     end
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       t.create! :cf => { 1 => 2 }
     end
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       t.create! :cf, { 1 => 2 }
     end
 
-    [ :cf, 'cf', {:cf => {}} ].each do |cf|
-      assert_false t.exists?
-      t.create! cf
-      assert t.exists?
-      t.drop!
-
-    end
+    [ :cf, 'cf', {:cf => {}} ].map.with_index { |cf, idx|
+      Thread.new do
+        name = "hbase_jruby_#{__method__}_#{idx}"
+        table = @hbase[name]
+        assert_equal false, table.exists?
+        table.create! cf
+        assert table.exists?
+        table.drop!
+      end
+    }.each(&:join)
   end
 
   def test_disable_and_drop
     @table.disable!
     @table.disable!
     @table.drop!
-    assert_false @table.exists?
+    assert_equal false, @table.exists?
   end
 
   def test_create_table_props
@@ -55,17 +54,17 @@ class TestTableAdmin < TestHBaseJRubyBase
   end
 
   def test_create_table_invalid_input
-    @table.drop!
-    assert_raise(ArgumentError) do
-      @table.create! 3.14
+    table = @hbase[:hbase_jruby_xxx]
+    assert_raises(ArgumentError) do
+      table.create! 3.14
     end
 
-    assert_raise(ArgumentError) do
-      @table.create! :cf1 => { :bloom => 'by beach house' }
+    assert_raises(ArgumentError) do
+      table.create! :cf1 => { :bloom => 'by beach house' }
     end
 
-    assert_raise(ArgumentError) do
-      @table.create! :cf1 => { :bloomfilter => :xxx }
+    assert_raises(ArgumentError) do
+      table.create! :cf1 => { :bloomfilter => :xxx }
     end
   end
 
@@ -89,10 +88,10 @@ class TestTableAdmin < TestHBaseJRubyBase
 # end
 
   def test_table_properties
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       @table.alter! :hello => :world
     end
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       # Splits not allowed
       @table.alter! :readonly => :true, :splits => [1, 2, 3]
     end
@@ -104,8 +103,7 @@ class TestTableAdmin < TestHBaseJRubyBase
     @table.alter!(
       :max_filesize       => max_fs,
       :memstore_flushsize => mem_fs,
-      :readonly           => false,
-      :deferred_log_flush => true
+      :readonly           => false
     ) do |p, t|
       progress = p
       total = t
@@ -116,7 +114,6 @@ class TestTableAdmin < TestHBaseJRubyBase
     assert_equal max_fs, @table.descriptor.get_max_file_size
     assert_equal mem_fs, @table.descriptor.get_mem_store_flush_size
     assert_equal false,  @table.descriptor.is_read_only
-    assert_equal true,   @table.descriptor.is_deferred_log_flush
 
     @table.drop!
   end
@@ -128,14 +125,21 @@ class TestTableAdmin < TestHBaseJRubyBase
     @table.add_family! :cf4, {}
     assert @table.descriptor.getFamilies.map(&:getNameAsString).include?('cf4')
 
-    # TODO: test more props
     @table.alter_family! :cf4, :versions => 10
-    assert_equal 10, @table.descriptor.getFamilies.select { |cf| cf.getNameAsString == 'cf4' }.first.getMaxVersions
+    assert_equal 10, @table.descriptor.getFamily('cf4'.to_java_bytes).getMaxVersions
+
+    @table.alter_family! :cf4, :bloomfilter => :rowcol,
+                               :config => { 'foo' => 'bar' }
+    assert_equal 'ROWCOL', @table.descriptor.getFamily('cf4'.to_java_bytes).getBloomFilterType.to_s
+    assert_equal 10, @table.descriptor.getFamily('cf4'.to_java_bytes).getMaxVersions
+
+    # Method not available on 0.94
+    assert_equal 'bar', @table.descriptor.getFamily('cf4'.to_java_bytes).getConfigurationValue('foo')
 
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @table.alter_family! :cf4, :hello => 'world'
     }
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @table.alter_family! :cf4, :bloomfilter => :xxx
     }
 
@@ -143,18 +147,23 @@ class TestTableAdmin < TestHBaseJRubyBase
   end
 
   def test_add_coprocessor!
+    coproc = 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
+
+    if @table.has_coprocessor? coproc
+      @table.remove_coprocessor! coproc
+    end
+
     omit "AggregationClient not found" unless @aggregation
 
-    coproc = 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
-    assert_false @table.has_coprocessor? coproc
-    assert_raise(ArgumentError) {
+    assert_equal false, @table.has_coprocessor?(coproc)
+    assert_raises(ArgumentError) {
       # :path is missing
       @table.add_coprocessor! coproc, :priority => 100
     }
     @table.add_coprocessor! coproc
     assert @table.has_coprocessor? coproc
 
-    @table.remove_coprocessor! 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
+    @table.remove_coprocessor! coproc
     assert !@table.has_coprocessor?(coproc)
 
     @table.drop!
@@ -165,12 +174,6 @@ class TestTableAdmin < TestHBaseJRubyBase
     @table.drop!
     assert @table.inspect.is_a?(String)
 
-    gz = begin
-           org.apache.hadoop.hbase.io.hfile.Compression::Algorithm::GZ
-         rescue Exception
-           org.apache.hadoop.hbase.io.compress.Compression::Algorithm::GZ
-         end
-
     table_props = {
       :max_filesize       => 512 * 1024 ** 2,
       :memstore_flushsize => 64 * 1024 ** 2,
@@ -189,92 +192,99 @@ class TestTableAdmin < TestHBaseJRubyBase
     [
       'GZ',
       :gz,
-      gz
-    ].each do |cmp|
-      @table.create!({
-          :cf => {
-            :blockcache          => true,
-            :blocksize           => 128 * 1024,
-            :bloomfilter         => :row, # as Symbol
-            :compression         => cmp,  # as String, Symbol, java.lang.Enum
-            :compression_compact => cmp,  # as String, Symbol, java.lang.Enum
-          # TODO
-          # :data_block_encoding => :diff,
-          # :encode_on_disk      => true,
-          # :keep_deleted_cells  => true,
-            :in_memory           => true,
-            :min_versions        => 5,
-            :replication_scope   => 0,
-            :ttl                 => 100,
-            :versions            => 10,
-            'whatever'           => 'works',
-          }
-        }, table_props)
-
-      # Initial region count
-      regions = @table.regions
-      assert_equal 5, regions.count
-
-      # Table properties
-      props = @table.properties
-      assert props[:deferred_log_flush] || props[:durability] == 'ASYNC_WAL'
-      assert_equal false,           props[:readonly]
-      assert_equal 64 * 1024 ** 2,  props[:memstore_flushsize]
-      assert_equal 512 * 1024 ** 2, props[:max_filesize]
-      assert_equal 'world',         props['hello']
-      assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
-                                    props[:split_policy]
-
-      rprops = @table.raw_properties
-      assert rprops['DEFERRED_LOG_FLUSH'] == 'true' || rprops['DURABILITY'] == 'ASYNC_WAL'
-
-      assert_equal false.to_s,             rprops['READONLY']
-      assert_equal((64 * 1024 ** 2).to_s,  rprops['MEMSTORE_FLUSHSIZE'])
-      assert_equal((512 * 1024 ** 2).to_s, rprops['MAX_FILESIZE'])
-      assert_equal 'world',                rprops['hello']
-      assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
-                                           rprops['SPLIT_POLICY']
-
-      # Column family properties
-      cf = @table.families['cf']
-      assert_equal 'ROW',  cf[:bloomfilter]
-      assert_equal 0,      cf[:replication_scope]
-      assert_equal 10,     cf[:versions]
-      assert_equal 'GZ',   cf[:compression]
-      assert_equal 5,      cf[:min_versions]
-      assert_equal 100,    cf[:ttl]
-      assert_equal 131072, cf[:blocksize]
-      assert_equal true,   cf[:in_memory]
-      assert_equal true,   cf[:blockcache]
-      assert_equal 'works', cf['whatever']
-
-      rcf = @table.raw_families['cf']
-      assert_equal 'ROW',       rcf['BLOOMFILTER']
-      assert_equal 0.to_s,      rcf['REPLICATION_SCOPE']
-      assert_equal 10.to_s,     rcf['VERSIONS']
-      assert_equal 'GZ',        rcf['COMPRESSION']
-      assert_equal 5.to_s,      rcf['MIN_VERSIONS']
-      assert_equal 100.to_s,    rcf['TTL']
-      assert_equal 131072.to_s, rcf['BLOCKSIZE']
-      assert_equal true.to_s,   rcf['IN_MEMORY']
-      assert_equal true.to_s,   rcf['BLOCKCACHE']
-      assert_equal 'works',     rcf['whatever']
-
-      @table.put 31, 'cf:a' => 100
-      @table.put 37, 'cf:a' => 100
-      @table.split!(35)
-      wait_for_regions 6
-
-      @table.put 39, 'cf:a' => 100
-      @table.split!(38)
-      wait_for_regions 7
-
-      regions = @table.regions
-      assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:start_key] }.compact.sort
-      assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:end_key] }.compact.sort
-
-      @table.drop!
-    end
+      begin
+        org.apache.hadoop.hbase.io.hfile.Compression::Algorithm::GZ
+      rescue Exception
+        org.apache.hadoop.hbase.io.compress.Compression::Algorithm::GZ
+      end
+    ].map.with_index { |cmp, idx|
+      Thread.new do
+        table = @hbase["hbase_jruby_#{__method__}_#{idx}"]
+        table.create!({
+            :cf => {
+              :blockcache          => true,
+              :blocksize           => 128 * 1024,
+              :bloomfilter         => :row, # as Symbol
+              :compression         => cmp,  # as String, Symbol, java.lang.Enum
+              :compression_compact => cmp,  # as String, Symbol, java.lang.Enum
+            # TODO
+            # :data_block_encoding => :diff,
+            # :encode_on_disk      => true,
+            # :keep_deleted_cells  => true,
+              :in_memory           => true,
+              :min_versions        => 5,
+              :replication_scope   => 0,
+              :ttl                 => 100,
+              :versions            => 10,
+              'whatever'           => 'works',
+            }
+          }, table_props)
+
+        # Initial region count
+        regions = table.regions
+        assert_equal 5, regions.count
+
+        # Table properties
+        props = table.properties
+        assert props[:deferred_log_flush] || props[:durability] == 'ASYNC_WAL'
+        assert_equal false,           props[:readonly]
+        assert_equal 64 * 1024 ** 2,  props[:memstore_flushsize]
+        assert_equal 512 * 1024 ** 2, props[:max_filesize]
+        assert_equal 'world',         props['hello']
+        assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
+                                      props[:split_policy]
+
+        rprops = table.raw_properties
+        assert rprops['DEFERRED_LOG_FLUSH'] == 'true' || rprops['DURABILITY'] == 'ASYNC_WAL'
+
+        assert_equal false.to_s,             rprops['READONLY']
+        assert_equal((64 * 1024 ** 2).to_s,  rprops['MEMSTORE_FLUSHSIZE'])
+        assert_equal((512 * 1024 ** 2).to_s, rprops['MAX_FILESIZE'])
+        assert_equal 'world',                rprops['hello']
+        assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
+                                             rprops['SPLIT_POLICY']
+
+        # Column family properties
+        cf = table.families['cf']
+        assert_equal 'ROW',  cf[:bloomfilter]
+        assert_equal 0,      cf[:replication_scope]
+        assert_equal 10,     cf[:versions]
+        assert_equal 'GZ',   cf[:compression]
+        assert_equal 5,      cf[:min_versions]
+        assert_equal 100,    cf[:ttl]
+        assert_equal 131072, cf[:blocksize]
+        assert_equal true,   cf[:in_memory]
+        assert_equal true,   cf[:blockcache]
+        assert_equal 'works', cf['whatever']
+
+        rcf = table.raw_families['cf']
+        assert_equal 'ROW',       rcf['BLOOMFILTER']
+        assert_equal 0.to_s,      rcf['REPLICATION_SCOPE']
+        assert_equal 10.to_s,     rcf['VERSIONS']
+        assert_equal 'GZ',        rcf['COMPRESSION']
+        assert_equal 5.to_s,      rcf['MIN_VERSIONS']
+        assert_equal 100.to_s,    rcf['TTL']
+        assert_equal 131072.to_s, rcf['BLOCKSIZE']
+        assert_equal true.to_s,   rcf['IN_MEMORY']
+        assert_equal true.to_s,   rcf['BLOCKCACHE']
+        assert_equal 'works',     rcf['whatever']
+
+        table.put 31, 'cf:a' => 100
+        table.put 37, 'cf:a' => 100
+        table.split!(35)
+        wait_for_regions table, 6
+
+        table.put 39, 'cf:a' => 100
+        table.split!(38)
+        wait_for_regions table, 7
+
+        regions = table.regions
+        assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:start_key] }.compact.sort
+        assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:end_key] }.compact.sort
+
+        table.drop!
+      end
+    }.each(&:join)
   end
 
   def test_snapshots
@@ -310,10 +320,10 @@ class TestTableAdmin < TestHBaseJRubyBase
   end
 
 private
-  def wait_for_regions rnum, max_tries = 30
+  def wait_for_regions table, rnum, max_tries = 30
     sleep 5
     max_tries.times do |i|
-      if @table.regions.count == rnum && @table.regions.all? { |r| r[:online] }
+      if table.regions.count == rnum && table.regions.all? { |r| r[:online] }
         return
       end
       sleep 1

data/test/test_util.rb

@@ -4,11 +4,11 @@ $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 require 'bigdecimal'
 
-class TestUtil < Test::Unit::TestCase
+class TestUtil < Minitest::Test
   Util = HBase::Util
 
   def test_bytea_conversion
-    assert_raise(ArgumentError) { Util.to_bytes(10 ** 30) }
+    assert_raises(ArgumentError) { Util.to_bytes(10 ** 30) }
 
     [:fixnum, :long].each do |type|
       assert_equal 100, Util.from_bytes( type, Util.to_bytes(100) )
@@ -18,13 +18,18 @@ class TestUtil < Test::Unit::TestCase
     assert_equal 100, Util.from_bytes( :byte,  Util.to_bytes(:byte => 100) )
     assert_equal 100, Util.from_bytes( :short, Util.to_bytes(:short => 100) )
     assert_equal 100, Util.from_bytes( :int, Util.to_bytes(:int => 100) )
-    assert_raise(ArgumentError) { Util.to_bytes(:short => "Hello") }
-    assert_raise(ArgumentError) { Util.to_bytes(:xxx => 100) }
-    assert_raise(ArgumentError) { Util.to_bytes(:short => 100, :int => 200) }
+    assert_raises(ArgumentError) { Util.to_bytes(:short => "Hello") }
+    assert_raises(ArgumentError) { Util.to_bytes(:xxx => 100) }
+    assert_raises(ArgumentError) { Util.to_bytes(:short => 100, :int => 200) }
 
     [:float, :double].each do |type|
-      assert_equal 3.14, Util.from_bytes( type, Util.to_bytes(3.14) )
+      assert_equal 314, (Util.from_bytes( type, Util.to_bytes(type => 3.14) ) * 100).to_i
     end
+    assert_equal 4, Util.to_bytes(:float => 3.14).length
+    assert_equal 8, Util.to_bytes(:double => 3.14).length
+    assert_equal 314, (Util.from_bytes(:float, Util.to_bytes(:float => 3.14)) * 100).to_i
+    assert_equal 3.14, Util.from_bytes(:double, Util.to_bytes(:double => 3.14))
+
     [:string, :str].each do |type|
       assert_equal "Hello", Util.from_bytes( type, Util.to_bytes("Hello") )
       assert_equal "Hello", Util.from_bytes( type, Util.to_bytes(HBase::ByteArray("Hello")) )
@@ -53,8 +58,8 @@ class TestUtil < Test::Unit::TestCase
     assert_instance_of HBase::ByteArray, byte_array
     assert_equal "1234", byte_array.as(:string)
 
-    assert_raise(ArgumentError) { Util.from_bytes(:xxx, [].to_java(Java::byte)) }
-    assert_raise(ArgumentError) { Util.to_bytes({}) }
+    assert_raises(ArgumentError) { Util.from_bytes(:xxx, [].to_java(Java::byte)) }
+    assert_raises(ArgumentError) { Util.to_bytes({}) }
   end
 
   def test_parse_column_name
@@ -74,8 +79,8 @@ class TestUtil < Test::Unit::TestCase
 
     assert_equal [:abc, :def],   parse_to_str([:abc, :def], :symbol)
 
-    assert_raise(ArgumentError) { Util.parse_column_name(nil) }
-    assert_raise(ArgumentError) { Util.parse_column_name('') }
+    assert_raises(ArgumentError) { Util.parse_column_name(nil) }
+    assert_raises(ArgumentError) { Util.parse_column_name('') }
 
     assert_equal nil, Util.from_bytes(:string, nil)
   end
@@ -86,7 +91,7 @@ class TestUtil < Test::Unit::TestCase
 
   def test_java_bytes
     ["Hello", 1234, :symbol].each do |v|
-      assert_false Util.java_bytes?(v)
+      assert_equal false, Util.java_bytes?(v)
     end
 
     ["Hello".to_java_bytes, Util.to_bytes(1234), Util.to_bytes(:symbol)].each do |v|

metadata

@@ -1,25 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: hbase-jruby
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.0
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2015-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: yard
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   prerelease: false
@@ -28,12 +28,12 @@ dependencies:
   name: simplecov
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   prerelease: false
@@ -45,7 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -92,17 +92,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
 summary: A JRuby binding for HBase
@@ -117,3 +117,4 @@ test_files:
 - test/test_table.rb
 - test/test_table_admin.rb
 - test/test_util.rb
+has_rdoc: