rubeus 0.0.8-java → 0.0.9-java

data/test/rubeus/extensions/java/awt/test_dimension.rb

@@ -4,64 +4,64 @@ require 'rubeus'
 
 # Test for Rubeus::Extensions::Java::Awt
 class TestDimension < Test::Unit::TestCase
-	include Rubeus::Awt
+  include Rubeus::Awt
 
-	# setup method
-	def setup
-	end
+  # setup method
+  def setup
+  end
 
-	# create with array size 0
-	def test_create_with_array_size_0
-		d = Dimension.create([])
+  # create with array size 0
+  def test_create_with_array_size_0
+    d = Dimension.create([])
 
-		assert_equal(0, d.width)
-		assert_equal(0, d.height)
-	end
+    assert_equal(0, d.width)
+    assert_equal(0, d.height)
+  end
 
-	# create with array size 1
-	def test_create_with_array_size_1
-		assert_raise(ArgumentError) do
-			d = Dimension.create([200])
-		end
-	end
+  # create with array size 1
+  def test_create_with_array_size_1
+    assert_raise(ArgumentError) do
+      d = Dimension.create([200])
+    end
+  end
 
-	# create with array size 2
-	def test_create_with_array_size_2
-		d = Dimension.create([200, 300])
+  # create with array size 2
+  def test_create_with_array_size_2
+    d = Dimension.create([200, 300])
 
-		assert_equal(200, d.width)
-		assert_equal(300, d.height)
-	end
+    assert_equal(200, d.width)
+    assert_equal(300, d.height)
+  end
 
-	# create with array size 3
-	def test_create_with_array_size_3
-		assert_raise(ArgumentError) do
-			d = Dimension.create([200, 300, 400])
-		end
-	end
+  # create with array size 3
+  def test_create_with_array_size_3
+    assert_raise(ArgumentError) do
+      d = Dimension.create([200, 300, 400])
+    end
+  end
 
-	# create with dimension object
-	def test_create_with_dimension
-		d = Dimension.create([300, 400])
-		d2 = Dimension.create(d)
+  # create with dimension object
+  def test_create_with_dimension
+    d = Dimension.create([300, 400])
+    d2 = Dimension.create(d)
 
-		assert_equal(d.width, d2.width)
-		assert_equal(d.height, d2.height)
-	end
+    assert_equal(d.width, d2.width)
+    assert_equal(d.height, d2.height)
+  end
 
-	# create with multiply expression
-	def test_create_with_multiply expression
-		d = Dimension.create("400 x 500")
+  # create with multiply expression
+  def test_create_with_multiply expression
+    d = Dimension.create("400 x 500")
 
-		assert_equal(400, d.width)
-		assert_equal(500, d.height)
-	end
+    assert_equal(400, d.width)
+    assert_equal(500, d.height)
+  end
 
-	# create with original constructor
-	def test_create_with_original_constructor
-		d = Dimension.create(600, 350)
+  # create with original constructor
+  def test_create_with_original_constructor
+    d = Dimension.create(600, 350)
 
-		assert_equal(600, d.width)
-		assert_equal(350, d.height)
-	end
+    assert_equal(600, d.width)
+    assert_equal(350, d.height)
+  end
 end

data/test/rubeus/extensions/java/sql/test_database_meta_data.rb

@@ -1,10 +1,12 @@
 require 'test/unit'
 require 'rubygems'
 require 'rubeus'
+# gem "activesupport"
+# require 'active_support/test_case'
 require 'test/rubeus/extensions/java/sql/test_sql_helper'
 
 # Test for lib/rubeus/extensions/java/sql/database_meta_data.rb
-class TestDatabaseMetaData < Test::Unit::TestCase
+class TestDatabaseMetaData < Test::Unit::TestCase # ActiveSupport::TestCase
   include TestSqlHelper
 
   def setup
@@ -21,18 +23,18 @@ class TestDatabaseMetaData < Test::Unit::TestCase
           DEPART_TIME TIME,
           DEST_AIRPORT CHAR(3),
           ARRIVE_TIME TIME,
-          MEAL CHAR(1) CONSTRAINT MEAL_CONSTRAINT 
+          MEAL CHAR(1) CONSTRAINT MEAL_CONSTRAINT
           CHECK (MEAL IN ('B', 'L', 'D', 'S')),
           PRIMARY KEY (FLIGHT_ID, SEGMENT_NUMBER)
           );
         CREATE TABLE FLTAVAIL(
-          FLIGHT_ID CHAR(6) NOT NULL, 
-          SEGMENT_NUMBER INT NOT NULL, 
-          FLIGHT_DATE DATE NOT NULL, 
+          FLIGHT_ID CHAR(6) NOT NULL,
+          SEGMENT_NUMBER INT NOT NULL,
+          FLIGHT_DATE DATE NOT NULL,
           ECONOMY_SEATS_TAKEN INT,
           BUSINESS_SEATS_TAKEN INT,
-          FIRSTCLASS_SEATS_TAKEN INT, 
-          CONSTRAINT FLTAVAIL_PK PRIMARY KEY (FLIGHT_ID, SEGMENT_NUMBER), 
+          FIRSTCLASS_SEATS_TAKEN INT,
+          CONSTRAINT FLTAVAIL_PK PRIMARY KEY (FLIGHT_ID, SEGMENT_NUMBER),
           CONSTRAINT FLTS_FK
           FOREIGN KEY (FLIGHT_ID, SEGMENT_NUMBER)
           REFERENCES Flights (FLIGHT_ID, SEGMENT_NUMBER)
@@ -62,7 +64,7 @@ class TestDatabaseMetaData < Test::Unit::TestCase
       EOS
     end
   end
-  
+
   def teardown
     teardown_connection
   end
@@ -79,24 +81,33 @@ class TestDatabaseMetaData < Test::Unit::TestCase
   rescue => e
     puts e.to_s
     puts e.backtrace.join("\n  ")
-     raise e
+    raise e
+  end
+
+  def test_table_inspect_with_downcase
+    tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
+    assert_equal "#<Rubeus::Jdbc::Table flights(flight_id,segment_number,orig_airport,depart_time,dest_airport,arrive_time,meal)>", tables['flights'].inspect
+    assert_equal "#<Rubeus::Jdbc::Table fltavail(flight_id,segment_number,flight_date,economy_seats_taken,business_seats_taken,firstclass_seats_taken)>", tables['fltavail'].inspect
+    assert_equal "#<Rubeus::Jdbc::Table cities(id,city_name)>", tables['cities'].inspect
+    assert_equal "#<Rubeus::Jdbc::Table metropolitan(hotel_id,hotel_name,city_id)>", tables['metropolitan'].inspect
+    assert_equal "#<Rubeus::Jdbc::Table test1(id,name)>", tables['test1'].inspect
   end
-  
+
   def assert_column(table, name, type, size, nullable)
     column = table.columns[name]
     assert_not_nil column, "column '#{name}' not found"
-    assert_equal(java.sql.Types.const_get(type.to_s.upcase), column.data_type, 
+    assert_equal(java.sql.Types.const_get(type.to_s.upcase), column.data_type,
       "column '#{name}' type expected #{java.sql.Types.const_get(type.to_s.upcase).inspect} but #{column.data_type.inspect}")
-    assert_equal(size, column.size, 
+    assert_equal(size, column.size,
       "column '#{name}' size expected #{size.inspect} but #{column.size.inspect}")
-    assert_equal(nullable, column.nullable?, 
+    assert_equal(nullable, column.nullable?,
       "column '#{name}' nullable expected #{nullable.inspect} but #{column.nullable?.inspect}")
-    assert_equal(nullable ? 
-      java.sql.DatabaseMetaData.columnNullable : 
+    assert_equal(nullable ?
+      java.sql.DatabaseMetaData.columnNullable :
       java.sql.DatabaseMetaData.columnNoNulls, column.nullable)
     assert_equal column, table[name]
   end
-  
+
   def test_table_object_columns
     tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
     #
@@ -109,6 +120,13 @@ class TestDatabaseMetaData < Test::Unit::TestCase
     assert_column(flights, 'dest_airport', :char, 3, true)
     assert_column(flights, 'arrive_time', :time, 8, true)
     assert_column(flights, 'meal', :char, 1, true)
+    assert_equal "#<Rubeus::Jdbc::Column flight_id CHAR(6) NOT NULL>", flights.columns["flight_id"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column segment_number INTEGER(10) NOT NULL>", flights.columns["segment_number"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column orig_airport CHAR(3) NULL>", flights.columns["orig_airport"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column depart_time TIME(8) NULL>", flights.columns["depart_time"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column dest_airport CHAR(3) NULL>", flights.columns["dest_airport"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column arrive_time TIME(8) NULL>", flights.columns["arrive_time"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column meal CHAR(1) NULL>", flights.columns["meal"].inspect
     #
     assert_not_nil fltavail = tables['fltavail']
     assert_equal 6, fltavail.columns.length
@@ -118,39 +136,52 @@ class TestDatabaseMetaData < Test::Unit::TestCase
     assert_column(fltavail, 'economy_seats_taken', :integer, 10, true)
     assert_column(fltavail, 'business_seats_taken', :integer, 10, true)
     assert_column(fltavail, 'firstclass_seats_taken', :integer, 10, true)
+    assert_equal "#<Rubeus::Jdbc::Column flight_id CHAR(6) NOT NULL>", fltavail.columns["flight_id"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column segment_number INTEGER(10) NOT NULL>", fltavail.columns["segment_number"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column flight_date DATE(10) NOT NULL>", fltavail.columns["flight_date"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column economy_seats_taken INTEGER(10) NULL>", fltavail.columns["economy_seats_taken"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column business_seats_taken INTEGER(10) NULL>", fltavail.columns["business_seats_taken"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column firstclass_seats_taken INTEGER(10) NULL>", fltavail.columns["firstclass_seats_taken"].inspect
     #
     assert_not_nil ctiies = tables['cities']
     assert_equal 2, ctiies.columns.length
     assert_column(ctiies, 'id', :integer, 10, false)
     assert_column(ctiies, 'city_name', :varchar, 50, true)
+    assert_equal "#<Rubeus::Jdbc::Column id INTEGER(10) NOT NULL>", ctiies.columns["id"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column city_name VARCHAR(50) NULL>", ctiies.columns["city_name"].inspect
     #
     assert_not_nil metropolitan = tables['metropolitan']
     assert_equal 3, metropolitan.columns.length
     assert_column(metropolitan, 'hotel_id', :integer, 10, false)
     assert_column(metropolitan, 'hotel_name', :varchar, 40, false)
     assert_column(metropolitan, 'city_id', :integer, 10, true)
+    assert_equal "#<Rubeus::Jdbc::Column hotel_id INTEGER(10) NOT NULL>", metropolitan.columns["hotel_id"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column hotel_name VARCHAR(40) NOT NULL>", metropolitan.columns["hotel_name"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column city_id INTEGER(10) NULL>", metropolitan.columns["city_id"].inspect
     #
     assert_not_nil test1 = tables['test1']
     assert_equal 2, test1.columns.length
     assert_column(test1, 'id', :integer, 10, false)
     assert_column(test1, 'name', :varchar, 60, true)
+    assert_equal "#<Rubeus::Jdbc::Column id INTEGER(10) NOT NULL>", test1.columns["id"].inspect
+    assert_equal "#<Rubeus::Jdbc::Column name VARCHAR(60) NULL>", test1.columns["name"].inspect
   rescue => e
     puts e.to_s
     puts e.backtrace.join("\n  ")
     raise e
   end
-  
+
   def assert_pk(table, names)
-    assert_equal names.length, table.primary_keys.length
-    assert_equal names, table.pks.map{|k| k.name}
-    assert_equal names, table.primary_keys.map{|k| k.name}
     assert_equal names, table.pk_names
     assert_equal names, table.primary_key_names
     names.each_with_index do |name, index|
-      assert_equal name, table.primary_keys[name].name
-      assert_equal index + 1, table.primary_keys[name].seq
+      assert_equal table.columns[name], table.primary_key.columns[index]
+      assert_equal table.columns[name], table.primary_key.columns[name]
+      assert_equal table.columns[name], table.primary_key_columns[index]
       assert_equal table.columns[name], table.primary_key_columns[name]
+      assert_equal table.columns[name], table.pk_columns[index]
       assert_equal table.columns[name], table.pk_columns[name]
+      assert_equal name, table.primary_key[index]
     end
     case names.length
     when 0
@@ -161,20 +192,22 @@ class TestDatabaseMetaData < Test::Unit::TestCase
       assert_equal nil, table.pk_column
       assert_equal nil, table.primary_key_column
     when 1
-      assert_equal table.pks.first, table.pk
-      assert_equal table.pks.first, table.primary_key
       assert_equal table.pk_names.first, table.pk_name
       assert_equal table.pk_names.first, table.primary_key_name
       assert_equal table.pk_columns.first, table.pk_column
       assert_equal table.pk_columns.first, table.primary_key_column
     else
-      assert_equal table.pks, table.pk
-      assert_equal table.pks, table.primary_key
       assert_equal table.pk_names, table.pk_name
       assert_equal table.pk_names, table.primary_key_name
       assert_equal table.pk_columns, table.pk_column
       assert_equal table.pk_columns, table.primary_key_column
     end
+    if names.length > 0
+      assert_equal names.length, table.primary_key.length
+      assert_equal names, table.primary_key.column_names
+      assert_equal names, table.pk.column_names
+      assert_equal "#<Rubeus::Jdbc::PrimaryKey #{table.name}(#{names.join(',')})>", table.primary_key.inspect
+    end
     table.columns.each do |column|
       if table.pk_names.include?(column.name)
         assert_equal true, column.primary_key?, "#{table.name}.#{column.name} shoud be one of pk"
@@ -185,7 +218,7 @@ class TestDatabaseMetaData < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_table_objects_pk
     tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
     assert_pk(tables['flights'], %w(flight_id segment_number))
@@ -194,40 +227,48 @@ class TestDatabaseMetaData < Test::Unit::TestCase
     assert_pk(tables['metropolitan'], %w(hotel_id))
     assert_pk(tables['test1'], [])
   end
-  
+
   def assert_index(table, index_name, key_names, asc_descs)
     assert_equal key_names, table.indexes[index_name].keys.map{|k| k.name}
     assert_equal asc_descs, table.indexes[index_name].keys.map{|k| k.asc?}
   end
-  
+
   def test_table_objects_index
     tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
     # assert_equal %w(idx_flight_01 idx_flight_02 idx_flight_03), tables['flights'].indexes.map{|idx| idx.name}
     # assert_equal 3, tables['flights'].indexes.length
-    assert_index(tables['flights'], 'idx_flight_01', %w(orig_airport), [true])
-    assert_index(tables['flights'], 'idx_flight_02', %w(orig_airport depart_time), [true, false])
-    assert_index(tables['flights'], 'idx_flight_03', %w(dest_airport arrive_time), [true, false])
+    t = tables['flights']
+    assert_index(t, 'idx_flight_01', %w(orig_airport), [true])
+    assert_index(t, 'idx_flight_02', %w(orig_airport depart_time), [true, false])
+    assert_index(t, 'idx_flight_03', %w(dest_airport arrive_time), [true, false])
+    assert_equal "#<Rubeus::Jdbc::Index flights.idx_flight_01(orig_airport)>", t.indexes['idx_flight_01'].inspect
+    assert_equal "#<Rubeus::Jdbc::Index flights.idx_flight_02(orig_airport,depart_time DESC)>", t.indexes['idx_flight_02'].inspect
+    assert_equal "#<Rubeus::Jdbc::Index flights.idx_flight_03(dest_airport,arrive_time DESC)>", t.indexes['idx_flight_03'].inspect
+
     # assert_equal 0, tables['fltavail'].indexes.length
-    
+
     # assert_equal 1, tables['cities'].indexes.length
     assert_index(tables['cities'], 'idx_cities_01', %w(city_name), [true])
+    assert_equal "#<Rubeus::Jdbc::Index cities.idx_cities_01(city_name)>", tables['cities'].indexes['idx_cities_01'].inspect
+
     # assert_equal 1, tables['metropolitan'].indexes.length
     assert_index(tables['metropolitan'], 'idx_metropolitan_01', %w(city_id hotel_name), [true, true])
+    assert_equal "#<Rubeus::Jdbc::Index metropolitan.idx_metropolitan_01(city_id,hotel_name)>", tables['metropolitan'].indexes['idx_metropolitan_01'].inspect
 
     # assert_equal 0, tables['test1'].indexes.length
   end
-  
+
   def assert_fk(fk_name, pktable, pkcolumn_names, fktable, fkcolumn_names)
     imported_key = fktable.imported_keys[fk_name]
     exported_key = pktable.exported_keys[fk_name]
     assert_equal fk_name, imported_key.name
     assert_equal fk_name, exported_key.name
-    
+
     assert_equal pktable.name, imported_key.pktable.name
     assert_equal fktable.name, imported_key.fktable.name
     assert_equal pktable.name, exported_key.pktable.name
     assert_equal fktable.name, exported_key.fktable.name
-    
+
     assert_equal pkcolumn_names.length, imported_key.length
     assert_equal fkcolumn_names.length, exported_key.length
     assert_equal imported_key.length, exported_key.length
@@ -243,15 +284,20 @@ class TestDatabaseMetaData < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_table_objects_imported_keys_and_exported_keys
     tables = @con.meta_data.tables(:schema => "APP", :name_case => :downcase)
-    assert_fk('flts_fk', 
+    assert_fk('flts_fk',
       tables['flights'], %w(flight_id segment_number),
       tables['fltavail'], %w(flight_id segment_number))
-    assert_fk('metro_fk', 
+    assert_equal("#<Rubeus::Jdbc::ForeignKey flts_fk fltavail(flight_id,segment_number)=>flights(flight_id,segment_number)>",
+      tables['fltavail'].foreign_keys['flts_fk'].inspect)
+
+    assert_fk('metro_fk',
       tables['cities'], %w(id),
       tables['metropolitan'], %w(city_id))
+    assert_equal("#<Rubeus::Jdbc::ForeignKey metro_fk metropolitan(city_id)=>cities(id)>",
+      tables['metropolitan'].foreign_keys['metro_fk'].inspect)
   end
-  
+
 end

data/test/rubeus/extensions/java/sql/test_driver_manager.rb

@@ -12,7 +12,6 @@ class TestDriverManager < Test::Unit::TestCase
     assert_nothing_raised do
       @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
     end
-
     if @con
       assert_equal(false, @con.closed?)
       @con.close
@@ -33,5 +32,13 @@ class TestDriverManager < Test::Unit::TestCase
     end
     assert_nil(con)
   end
-end
 
+  def test_mysql_loader_entry
+    entry = Rubeus::Jdbc::DriverManager::Loader.entries.detect{|entry| entry.name == "MySQL"}
+    assert entry
+    assert_equal 1, entry.patterns.length
+    driver_name = entry.driver_for("jdbc:mysql://127.0.0.1")
+    assert_equal "com.mysql.jdbc.Driver",  driver_name
+  end
+
+end

data/test/rubeus/extensions/java/sql/test_sql_helper.rb

@@ -6,7 +6,7 @@ module TestSqlHelper
   def teardown_connection
     @con.close
   end
-  
+
   def close_if_no_statement(statement = nil)
     must_be_closed = statement.nil?
     statement ||= @con.create_statement
@@ -16,7 +16,7 @@ module TestSqlHelper
       statement.close if must_be_closed
     end
   end
-  
+
   def drop_table_if_exist(table_name, statement = nil)
     close_if_no_statement(statement) do |stmt|
       begin
@@ -26,7 +26,7 @@ module TestSqlHelper
       end
     end
   end
-  
+
   def create_table_after_drop(create_ddl, statement = nil)
     create_ddls = create_ddl.split(/\;/mi).map{|ddl| ddl.strip }.select{|ddl| !(ddl.nil? || ddl.empty?) }
     table_names = create_ddls.map{|ddl| ddl.scan(/^\s*CREATE TABLE\s+?(.+?)[\s\($]/mi)}
@@ -39,5 +39,5 @@ module TestSqlHelper
       end
     end
   end
-  
+
 end

data/test/rubeus/reflection/test_method_modifier.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+require File.expand_path('../../rubeus_test.jar', File.dirname(__FILE__))
+
+class TestMethodModifier < Test::Unit::TestCase
+  include Rubeus::Reflection
+
+  VariousMethods = jp.rubybizcommons.rubeus.test.reflection.VariousMethods
+
+  def test_static?
+    [java.lang.String, java.lang.Object, java.lang.Class, VariousMethods].each do |klass|
+      klass.java_class.java_class_methods.each do |m|
+        assert_equal true, m.static?
+      end
+      klass.java_class.java_instance_methods.each do |m|
+        assert_equal false, m.static?
+      end
+    end
+  end
+
+  def test_abstract?
+    m = java.util.AbstractList.java_class.declared_instance_methods.detect{|m| m.name == "get"}
+    assert_equal true, m.abstract?
+    m = java.util.AbstractList.java_class.declared_instance_methods.detect{|m| m.name == "add"}
+    assert_equal false, m.abstract?
+  end
+
+  ALL_METHOD_NAMES = %w[main
+     staticPublicStrictfp staticProtectedFinal staticPackageSynchronized staticPrivate
+     publicStrictfp protectedFinal packageSynchronized privateFinal]
+
+  def assert_modifier_syms(method_name, expected_syms)
+    m = (VariousMethods.java_class.declared_instance_methods.detect{|m| m.name == method_name} ||
+      VariousMethods.java_class.declared_class_methods.detect{|m| m.name == method_name})
+    assert_equal expected_syms.map(&:to_s).sort, m.modifier_symbols.map(&:to_s).sort
+  end
+
+  def test_modifier_symbols
+    assert_modifier_syms("main", [:public, :static])
+#    assert_modifier_syms("staticPublicStrictfp "    , [:static, :public, :strict  ])
+    assert_modifier_syms("staticProtectedFinal"     , [:static, :protected, :final])
+    assert_modifier_syms("staticPackageSynchronized", [:static, :synchronized     ])
+    assert_modifier_syms("staticPrivate"            , [:static, :private          ])
+    assert_modifier_syms("publicStrictfp"     , [:public, :strict  ])
+    assert_modifier_syms("protectedFinal"     , [:protected, :final])
+    assert_modifier_syms("packageSynchronized", [:synchronized     ])
+    assert_modifier_syms("privateFinal"       , [:private, :final  ])
+  end
+
+  def test_public?
+    each_java_methods do |m|
+      assert_equal %w[main staticPublicStrictfp publicStrictfp].include?(m.name), m.public?
+    end
+  end
+
+  def test_protected?
+    each_java_methods do |m|
+      assert_equal %w[staticProtectedFinal protectedFinal].include?(m.name), m.protected?
+    end
+  end
+
+  def test_package_scope?
+    each_java_methods do |m|
+      assert_equal %w[staticPackageSynchronized packageSynchronized].include?(m.name), m.package_scope?
+    end
+  end
+
+  def test_private?
+    each_java_methods do |m|
+      assert_equal %w[staticPrivate privateFinal].include?(m.name), m.private?
+    end
+  end
+
+  def test_final?
+    each_java_methods do |m|
+      assert_equal %w[staticProtectedFinal protectedFinal privateFinal].include?(m.name), m.final?
+    end
+  end
+
+  def test_strict?
+    each_java_methods do |m|
+      assert_equal %w[main staticPublicStrictfp publicStrictfp].include?(m.name), m.public?
+    end
+  end
+
+  def test_synchronized?
+    each_java_methods do |m|
+      assert_equal %w[staticPackageSynchronized packageSynchronized].include?(m.name), m.synchronized?
+    end
+  end
+
+
+
+  private
+
+  def each_java_methods(&block)
+    unless @test_methods
+      selector = lambda{|m| ALL_METHOD_NAMES.include?(m.name)}
+      @test_methods =
+        VariousMethods.java_class.declared_instance_methods.select(&selector) +
+        VariousMethods.java_class.declared_class_methods.select(&selector)
+    end
+    @test_methods.each(&block)
+  end
+
+end