rjb 1.0.0-mswin32

data/ext/rjb.h

@@ -0,0 +1,129 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005 arton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: rjb.h 2 2006-04-11 19:04:40Z arton $
+ * $Log: rjb.h,v $
+ * Revision 1.1  2005/01/16 17:36:10  arton
+ * Initial revision
+ *
+ *
+ */
+
+#ifndef RJB_H
+#define RJB_H
+
+#if !defined(COUNTOF)
+#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
+#endif
+
+#if !defined(_I64_MIN)
+#define _I64_MIN    (-9223372036854775807i64 - 1)
+#endif
+#if !defined(_I64_MAX)
+#define _I64_MAX      9223372036854775807i64
+#endif
+
+/* in rjb.c */
+extern VALUE loaded_classes;
+extern jmethodID class_getName;
+extern jclass j_throwable;
+extern jmethodID throwable_getMessage;
+extern JNIEnv* attach_current_thread(void);
+extern jclass find_class(JNIEnv* jenv, VALUE name);
+extern void release_string(JNIEnv *jenv, jstring str, const char* chrs);
+
+/* in rjbexception.c */
+extern VALUE get_exception_class(JNIEnv* jenv, jstring str);
+extern void check_exception(JNIEnv* jenv, int t);
+extern VALUE rjb_s_throw(int, VALUE*, VALUE);
+
+/* conversion functions */
+typedef void (*R2J)(JNIEnv*, VALUE, jvalue*, const char*, int);
+typedef VALUE (*J2R)(JNIEnv*, jvalue);
+typedef jarray (*R2JARRAY)(JNIEnv*, VALUE, const char*);
+typedef void (JNICALL *RELEASEARRAY)(JNIEnv*, jobject, void*, jint);
+typedef jlong (JNICALL *INVOKEAL)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jdouble (JNICALL *INVOKEAD)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jfloat (JNICALL *INVOKEAF)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jboolean (JNICALL *INVOKEAZ)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jshort (JNICALL *INVOKEAS)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jobject (JNICALL *INVOKEA)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef VALUE (*CONV)(JNIEnv*, void*);
+
+/*
+ * internal method class
+ */
+struct cls_constructor {
+    jmethodID id;
+    int arg_count;
+    R2J* arg_convert;
+    char* method_signature;
+    char  result_signature;
+    char  result_arraydepth;
+};
+
+struct cls_method {
+    struct cls_constructor basic;
+    ID name;
+    int static_method;
+    off_t method;
+    J2R result_convert;
+    /* overload only */
+    struct cls_method* next;
+};
+
+/*
+ * internal field class
+ */
+struct cls_field {
+    ID name;
+    jfieldID id;
+    char* field_signature;
+    char  result_signature;
+    char  result_arraydepth;
+    R2J arg_convert;
+    J2R value_convert;
+    int readonly;
+    int static_field;
+};
+
+/*
+ * Object instance
+ */
+struct jvi_data {
+    jclass klass; /* class */
+    jobject obj; /* instance */
+    st_table* methods;
+    st_table* fields;
+};
+
+/*
+ * Class instance
+ */
+struct jv_data {
+    struct jvi_data idata;
+    st_table* static_methods;
+    struct cls_constructor** constructors;
+};
+
+/*
+ * Bridge instance
+ */
+struct rj_bridge {
+    jobject bridge;
+    jobject proxy;
+    VALUE wrapped;
+};
+
+#endif

data/ext/rjbexception.c

@@ -0,0 +1,130 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005,2006 arton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: rjbexception.c 10 2006-07-16 04:15:47Z arton $
+ */
+
+#include "ruby.h"
+#include "st.h"
+#include "jniwrap.h"
+#include "riconv.h"
+#include "rjb.h"
+
+/*
+ * handle Java exception
+ *  At this time, the Java exception is defined without the package name.
+ *  This design may change in future release.
+ */
+VALUE get_exception_class(JNIEnv* jenv, jstring str)
+{
+    VALUE rexp;
+    char* pcls;
+    VALUE cname;
+    const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+    char* clsname = ALLOCA_N(char, strlen(p) + 1);
+    strcpy(clsname, p);
+    release_string(jenv, str, p);
+    pcls = strrchr(clsname, '.');
+    if (pcls)
+    {
+	pcls++;
+    }
+    else
+    {
+	pcls = clsname;
+    }
+    cname = rb_str_new2(pcls);
+    rexp = rb_hash_aref(loaded_classes, cname);
+    if (rexp == Qnil)
+    {
+	rexp = rb_define_class(pcls, rb_eStandardError);
+	st_insert(RHASH(loaded_classes)->tbl, cname, rexp);
+    }
+    return rexp;
+}
+
+/*
+ * throw newly created exception with supplied message.
+ */
+VALUE rjb_s_throw(int argc, VALUE* argv, VALUE self)
+{
+    VALUE klass;
+    VALUE message;
+    JNIEnv* jenv = attach_current_thread();
+    if (rb_scan_args(argc, argv, "11", &klass, &message) == 2)
+    {
+        jclass excep = find_class(jenv, klass);
+	if (excep == NULL)
+	{
+	    rb_raise(rb_eRuntimeError, "`%s' not found", StringValueCStr(klass));
+        }
+	(*jenv)->ThrowNew(jenv, excep, StringValueCStr(message));
+    }
+    else
+    {
+        struct jvi_data* ptr;
+	Data_Get_Struct(klass, struct jvi_data, ptr);
+	if (!(*jenv)->IsInstanceOf(jenv, ptr->obj, j_throwable))
+	{
+	    rb_raise(rb_eRuntimeError, "arg1 must be a throwable");
+	}
+	else
+	{
+  	    (*jenv)->Throw(jenv, ptr->obj);
+	}
+    }
+    return Qnil;
+}
+
+void check_exception(JNIEnv* jenv, int t)
+{
+    jthrowable exp = (*jenv)->ExceptionOccurred(jenv);
+    if (exp)
+    {
+	VALUE rexp = Qnil;
+        if (RTEST(ruby_verbose))
+	{
+	    (*jenv)->ExceptionDescribe(jenv);
+	}
+	(*jenv)->ExceptionClear(jenv);
+//        if (t)
+        if(1)
+	{
+ 	    char* msg = "unknown exception";
+	    jclass cls = (*jenv)->GetObjectClass(jenv, exp);
+ 	    jstring str = (*jenv)->CallObjectMethod(jenv, exp, throwable_getMessage);
+	    if (str)
+	    {
+	        const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+		msg = ALLOCA_N(char, strlen(p) + 1);
+		strcpy(msg, p);
+		release_string(jenv, str, p);
+	    }
+	    str = (*jenv)->CallObjectMethod(jenv, cls, class_getName);
+	    if (str)
+	    {
+		rexp = get_exception_class(jenv, str);
+	    }
+	    if (rexp == Qnil)
+	    {
+		rb_raise(rb_eRuntimeError, "%s", msg);
+	    }
+	    else
+	    {
+		rb_raise(rexp, msg);
+	    }
+        }
+    }
+}
+

data/lib/rjb.rb

@@ -0,0 +1,22 @@
+=begin
+  Copyright(c) 2006 arton
+=end
+
+require 'rbconfig'
+
+module RjbConf
+  dir = File.join(File.dirname(File.dirname(__FILE__)), 'data')
+  if File.exist?(dir)
+    datadir = dir
+  else
+    datadir = Config::CONFIG['datadir']
+  end
+  BRIDGE_FILE = File.join(datadir, 'rjb', 'jp', 'co', 'infoseek', 'hp',
+                          'arton', 'rjb', 'RBridge.class')
+  unless File.exist?(BRIDGE_FILE)
+    raise 'bridge file not found'
+  end
+end
+
+require 'rjbcore'
+

data/readme.sj

@@ -0,0 +1,27 @@
+����
+�E���炩���ߊ‹��ϐ���JAVA_HOME��ݒ肵�Ă����Ă��������B
+�E���̏ꍇ�AJAVA_HOME�́AJ2SDK�̃C���X�g�[���f�B���N�g���̕K�v������܂��B
+�E���炩���ߊ‹��ϐ�PATH��$JAVA_HOME/bin��ݒ肵�Ă����Ă��������B
+�EWindows�̏ꍇ�APATH�ɂ�%PATH%;%JAVA_HOME%bin��ݒ肷�邱�ƂɂȂ�܂��B
+�Eruby1.8�ȍ~�����s�ł���悤��PATH��ݒ肵�Ă����Ă��������B
+
+�C���X�g�[�����@
+1. unzip rjb-*
+2. cd rjb-*
+3. ruby setup.rb config
+4. ruby setup.rb setup
+5. sudo ruby setup.rb install
+   Windows�ł́A�قƂ�ǂ̏ꍇ�ŏ���sudo�͕s�v�ł��B�u�قƂ�ǂ̏ꍇ�v�ɊY�����Ȃ��ꍇ�͉����K�v���͂킩���Ă���͂��ł��̂Ő����͏ȗ����܂��B
+
+���s��
+�E���炩���ߊ‹��ϐ���JAVA_HOME��ݒ肵�Ă����Ă��������B
+�E���̏ꍇ�AJAVA_HOME�́AJ2SDK�̃C���X�g�[���f�B���N�g���̕K�v������܂��B
+�ELinux�Ɋւ��Ă�LD_LIBRARY_PATH�ɁAjava2�̋��L�I�u�W�F�N�g�f�B���N�g����ݒ肵�Ă����K�v������܂��B
+
+�e�X�g�����‹�
+Windows2000 SP4-ruby1.8.2-j2se1.5.0, Solaris9-ruby1.8.0-j2se1.4.2, Linux 2.4.26-ruby-1.8.1-j2se1.4.2
+
+�A����
+artonx@yahoo.co.jp
+http://arton.no-ip.info/collabo/backyard/?RjbQandA (�L�����ɂ�diary�փc�b�R�~�����Ă��������j
+

data/readme.txt

@@ -0,0 +1,28 @@
+Rjb is Ruby-Java bridge using Java Native Interface.
+
+How to install
+
+you need to install Java2 sdk, and setup JAVA_HOME enviromental varible except for OS X.
+I assume that OS X's JAVA_HOME is fixed as '/System/Library/Frameworks/JavaVM.framework'.
+
+then,
+
+ruby setup.rb config
+ruby setup.rb setup
+
+(in Unix)
+sudo ruby setup.rb install
+or
+(in win32)
+ruby setup.rb install
+
+How to test
+in Win32
+cd test
+ruby test.rb
+
+in Unix
+see test/readme.unix 
+you must set LD_LIBRARY_PATH environmental variable to run rjb.
+
+artonx@yahoo.co.jp

data/samples/filechooser.rb

@@ -0,0 +1,46 @@
+require 'rjb'
+
+Rjb::load
+
+SwingUtilities = Rjb::import('javax.swing.SwingUtilities')
+JThread = Rjb::import('java.lang.Thread')
+JFileChooser = Rjb::import('javax.swing.JFileChooser')
+class Run
+  def initialize(&block)
+    @block = block
+  end
+  def run
+puts 'go-hello'
+    @block.call
+puts 'ret-hello'
+  end
+end
+
+class FileChooser
+  @@klass = JFileChooser
+  def initialize(ext = '*', desc = 'any files')
+    @selected = nil
+  end
+
+  def show()
+    run = Rjb::bind(Run.new do
+puts 'hello'
+		      @selected = nil
+		      chooser = @@klass.new()
+puts 'hello'
+		      ret = chooser.showOpenDialog(nil)
+puts 'hello'
+		      if ret == @@klass.APPROVE_OPTION 
+			@selected = chooser.getSelectedFile
+		      end
+		    end, 'java.lang.Runnable')
+    SwingUtilities.invokeAndWait(run)
+  end
+  attr_reader :selected
+end
+
+f = FileChooser.new
+if f.show == 0
+  puts f.selected.getAbsolutePath
+end
+puts 'bye'

data/test/gctest.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'rjb'
+
+class TestRjbGC < Test::Unit::TestCase
+  include Rjb
+  def setup
+    load(nil, ['-verbose:gc'])
+  end
+
+  def tearDown
+    unload
+  end
+
+  def test_gc
+    stringBuffer = import('java.lang.StringBuffer')
+    (0..1000).each do |i|
+      sb = stringBuffer.new
+      (0..1000).each do |j|
+	sb.append('                                                        ')
+      end
+      GC.start
+    end
+  end
+end

data/test/test.rb

@@ -0,0 +1,394 @@
+require 'test/unit'
+require 'rjb'
+
+puts "start RJB(#{Rjb::VERSION}) test"
+class TestRjb < Test::Unit::TestCase
+  include Rjb
+  def setup
+    load('.')
+  end
+
+  def tearDown
+    unload
+  end
+
+  def test_metaclass
+    cls = import('java.lang.Class')
+    assert_equal('java.lang.Class', cls._classname)
+    assert_equal('java.lang.Class', cls.getName)
+    assert_equal(17, cls.getModifiers)
+  end
+
+  def test_scalar
+    cls = import('java.lang.String')
+    assert_equal('java.lang.Class', cls._classname)
+    assert_equal('class java.lang.String', cls.toString)
+    str = cls.new
+    assert_equal('java.lang.String', str._classname)
+    assert_equal(0, str.length)
+    assert_equal('', str.toString)
+    str = cls.new_with_sig('Ljava.lang.String;', "abcde")
+    # result integer
+    assert_equal(5, str.length)
+    # result string
+    assert_equal('abcde', str.toString)
+    # argument test
+    # char
+    assert_equal('abxde', str.replace(?c, ?x))
+    # string
+    assert_equal('abdxe', str.replaceAll('cd', 'dx'))
+    # int
+    assert_equal('bc', str.substring(1, 3))
+    assert_equal('e', str.substring(4))
+    # float with static
+    assert_equal('5.23', cls._invoke('valueOf', 'F', 5.23))
+    assert_equal('25.233', cls._invoke('valueOf', 'D', 25.233))
+    # rjb object (String)
+    str2 = cls.new_with_sig('Ljava.lang.String;', 'fghijk')
+    assert_equal('abcdefghijk', str.concat(str2))
+    # rjb object other (implicit toString call is Rjb feature)
+    jint = import('java.lang.Integer')
+    i = jint.new_with_sig('I', 35901)
+    assert_equal('abcde35901', str.concat(i))
+    # result boolean and argument is rjb object
+    assert_equal(false, i.equals(str))
+    assert_equal(false, str.equals(i))
+    assert_equal(true, str.equals("abcde"))
+    assert_equal(true, str.equals(str))
+    # long
+    lng = import('java.lang.Long')
+    l = lng.new_with_sig('J', -9223372036854775808)
+    assert_equal(-9223372036854775808, l.longValue)
+    l = lng.new_with_sig('J', 9223372036854775807)
+    assert_equal(9223372036854775807, l.longValue)
+    # double
+    dbl = import('java.lang.Double')
+    d = dbl.new_with_sig('D', 1234.5678901234567890)
+    assert_equal(1234.5678901234567890, d.doubleValue)
+    # byte
+    byt = import('java.lang.Byte')
+    b = byt.new_with_sig('B', 13)
+    assert_equal(13, b.byteValue)
+    # float
+    flt = import('java.lang.Float')
+    f = flt.new_with_sig('F', 13.5)
+    assert_equal(13.5, f.floatValue)
+    # short
+    sht = import('java.lang.Short')
+    s = sht.new_with_sig('S', 1532)
+    assert_equal(1532, s.shortValue)
+    chr = import('java.lang.Character')
+    c = chr.new_with_sig('C', ?A)
+    assert_equal(?A, c.charValue)
+  end
+
+  def test_array
+    cls = import('java.lang.String')
+    str = cls.new_with_sig('[C', [?a, ?b, ?c, ?d, ?e, ?c, ?f, ?c, ?g])
+    assert_equal('abcdecfcg', str.toString)
+    # conv string array
+    splt = str.split('c')
+    assert(Array === splt)
+    assert_equal(4, splt.size)
+    assert_equal('ab', splt[0])
+    assert_equal('g', splt[3])
+    # conv byte array to (ruby)string
+    ba = str.getBytes
+    assert_equal('abcdecfcg', ba)
+    # conv char array to array(int)
+    ca = str.toCharArray
+    assert_equal([?a, ?b, ?c, ?d, ?e, ?c, ?f, ?c, ?g], ca)
+  end
+
+  def test_importobj()
+    sys = import('java.lang.System')
+    props = sys.getProperties
+    assert_equal('java.util.Properties', props._classname)
+    if /cygwin/ =~ RUBY_PLATFORM # patch for dirty environment
+      assert_equal(Dir::pwd, %x[cygpath -u #{props.getProperty('user.dir').gsub('\\', '/')}].chop)
+    else
+      assert_equal(Dir::pwd, props.getProperty('user.dir').gsub('\\', '/'))
+    end
+    boolean = import('java.lang.Boolean')
+    assert_equal(boolean.valueOf(true).booleanValue(), true)
+    assert_equal(boolean.valueOf(false).booleanValue(), false)
+    assert_equal(boolean.valueOf('true').booleanValue(), true)
+    assert_equal(boolean.valueOf('false').booleanValue(), false)
+  end
+
+  def test_importobjarray()
+    jarray = import('java.util.ArrayList')
+    a = jarray.new()
+    jint = import('java.lang.Integer')
+    a.add(jint.new_with_sig('I', 1))
+    a.add(jint.new_with_sig('I', 2))
+    a.add(jint.new_with_sig('I', 3))
+    oa = a.toArray
+    assert_equal(3, oa.size)
+    assert_equal(1, oa[0].intValue)
+    assert_equal(2, oa[1].intValue)    
+    assert_equal(3, oa[2].intValue)    
+  end
+
+  def test_kjconv()
+    $KCODE = 'euc'
+    cls = import('java.lang.String')
+    euc_kj = "\xb4\xc1\xbb\xfa\xa5\xc6\xa5\xad\xa5\xb9\xa5\xc8"
+    s = cls.new(euc_kj)
+    assert_equal(s.toString(), euc_kj)
+    $KCODE = 'sjis'
+    sjis_kj = "\x8a\xbf\x8e\x9a\x83\x65\x83\x4c\x83\x58\x83\x67"
+    s = cls.new(sjis_kj)
+    assert_equal(s.toString(), sjis_kj)
+  end
+
+  def test_constants()
+    lng = import('java.lang.Long')
+    assert_equal(0x7fffffffffffffff, lng.MAX_VALUE)
+    assert_equal(-9223372036854775808, lng.MIN_VALUE)
+  end
+
+  class TestIter
+    def initialize()
+      @i = 5
+    end
+    def hasNext()
+      @i > 0
+    end
+    def next()
+      @i -= 1
+      @i.to_s
+    end
+  end
+
+  def test_newobject()
+    it = TestIter.new
+    it = bind(it, 'java.util.Iterator')
+    test = import('jp.co.infoseek.hp.arton.rjb.Test')
+    a = test.new
+    assert("43210", a.concat(it))
+  end
+
+  class TestComparator
+    def compare(o1, o2)
+      o1.to_i - o2.to_i
+    end
+    def equals(o)
+      o == self
+    end
+  end
+
+  def test_comparator
+    cp = TestComparator.new
+    cp = bind(cp, 'java.util.Comparator')
+    test = import('jp.co.infoseek.hp.arton.rjb.Test')
+    a = test.new
+    assert(0, a.check(cp, 123, 123))
+    assert(5, a.check(cp, 81, 76))
+    assert(-5, a.check(cp, 76, 81))
+  end
+
+  # assert_raise is useless in this test, because NumberFormatException may be defined in
+  # its block.
+  def test_exception()
+    it = import('java.lang.Integer')
+    begin
+      it.parseInt('blabla')
+      flunk('no exception')
+    rescue NumberFormatException => e
+      # OK
+    end
+  end
+
+  class TestIterator
+    def initialize(tp)
+      @type = tp
+    end
+    def hasNext()
+      true
+    end
+    def next()
+      if @type == 0
+	Rjb::throw('java.util.NoSuchElementException', 'test exception')
+      elsif @type == 1
+	Rjb::throw(Rjb::import('java.util.NoSuchElementException').new('instance test'))
+      end
+    end
+  end
+
+  def test_throw()
+    it = TestIterator.new(0)
+    it = bind(it, 'java.util.Iterator')
+    test = import('jp.co.infoseek.hp.arton.rjb.Test')
+    a = test.new
+    begin
+      a.concat(it)
+      flunk('no exception')
+    rescue NoSuchElementException => e
+      assert_equal('test exception', e.message)
+    end
+  end
+
+  def test_instance_throw()
+    it = TestIterator.new(1)
+    it = bind(it, 'java.util.Iterator')
+    test = import('jp.co.infoseek.hp.arton.rjb.Test')
+    a = test.new
+    begin
+      a.concat(it)
+      flunk('no exception')
+    rescue NoSuchElementException => e
+      assert_equal('instance test', e.message)
+    end
+  end
+
+  def test_null_string()
+    sys = import('java.lang.System')
+    begin
+      sys.getProperty(nil)
+      flunk('no exception')
+    rescue NullPointerException => e
+      assert(true)
+    rescue RuntimeError => e
+      flunk(e.message)
+    end
+  end
+
+  def test_throw_error()
+    begin
+      throw(self)
+      flunk('no exception')
+    rescue TypeError => e
+    end
+    begin
+      throw(import('java.lang.String').new('a'))
+      flunk('no exception')
+    rescue RuntimeError => e
+      assert_equal('arg1 must be a throwable', e.message)
+    end
+    begin
+      throw('java.lang.NoSuchException', 'test')
+      flunk('no excpetion')
+    rescue RuntimeError => e
+      assert_equal("`java.lang.NoSuchException' not found", e.message)
+    end
+  end
+
+  def test_field()
+    point = import('java.awt.Point')
+    pnt = point.new(11, 13)
+    assert_equal(11, pnt.x)
+    assert_equal(13, pnt.y)
+    pnt.x = 32
+    assert_equal(32, pnt.x)
+  end
+
+  def test_instancemethod_from_class()
+    begin
+      cls = import('java.lang.String')
+      assert_equal('true', cls.valueOf(true))
+      cls.length
+      flunk('no exception')
+    rescue RuntimeError => e
+      assert_equal('instance method `length\' for class', e.message)
+    end
+  end
+
+  def test_instancefield_from_class()
+    point = import('java.awt.Point')
+    begin
+      point.x
+      flunk('no exception')
+    rescue RuntimeError => e
+      assert_equal('instance field `x\' for class', e.message)
+    end
+    begin
+      point.x = 30
+    rescue RuntimeError => e
+      assert_equal('instance field `x\' for class', e.message)
+    end
+  end
+
+  def test_static_derived_method()
+    ext = import('jp.co.infoseek.hp.arton.rjb.ExtBase')
+    assert_equal("sVal", ext.getSVal)
+  end
+
+  def test_capitalized_method()
+    bs = import('jp.co.infoseek.hp.arton.rjb.Base')
+    assert_equal("val", bs.val)
+    assert_equal("Val", bs.Val)
+  end
+
+  def test_underscored_constant()
+    bs = import('jp.co.infoseek.hp.arton.rjb.Base')
+    assert_equal(5, bs._NUMBER_FIVE)
+  end
+
+  def test_passingclass()
+    ibs = import('jp.co.infoseek.hp.arton.rjb.IBase')
+    bs = import('jp.co.infoseek.hp.arton.rjb.Base')
+    assert_equal('interface jp.co.infoseek.hp.arton.rjb.IBase', bs.intf(ibs))
+  end
+
+  def test_fornamehook()
+    # j2se class
+    cls = import('java.lang.Class')
+    c = cls.forName('java.lang.Class')
+    assert_equal(cls, c)
+    # user class
+    bs = import('jp.co.infoseek.hp.arton.rjb.Base')
+    b = cls.forName('jp.co.infoseek.hp.arton.rjb.Base')
+    assert_equal(bs, b)
+    # class java's Class#forName and convert result to imported class
+    loader = Rjb::import('java.lang.ClassLoader')
+    b = cls.forName('jp.co.infoseek.hp.arton.rjb.Base', true, loader.getSystemClassLoader)
+    assert_equal(bs, b)
+    b = cls.forName('jp.co.infoseek.hp.arton.rjb.IBase', true, loader.getSystemClassLoader)
+    assert(b.isInterface)
+  end
+
+  def test_send_array_of_arrays()
+    test = import('jp.co.infoseek.hp.arton.rjb.Test').new
+    a = test.joinStringArray([['ab', 'cd'], ['ef', 'gh']])
+    assert_equal(['ab', 'cd', 'ef', 'gh'], a)
+    a = test.joinIntArray([[1, 2, 3], [4, 5, 6]])
+    a.collect! {|e| e.intValue }
+    assert_equal([1, 2, 3, 4, 5, 6], a)
+    r = [[[ 1, 2], [2, 3] ], [[ 3, 4], [5, 6]], [[7, 8], [1, 3]]]
+    a = test.throughIntArray(r)
+    assert_equal(a, r)
+  end
+
+  def test_import_and_instanciate()
+    b = import('jp.co.infoseek.hp.arton.rjb.Base')
+    assert_equal('hello', b.new.getInstanceVar())
+  end
+
+  def test_array_of_arrays()
+    jversion = import('java.lang.System').getProperty('java.version')
+    if /^1\.5/ =~ jversion
+      method = import('java.lang.reflect.Method')
+    end
+    test = import('jp.co.infoseek.hp.arton.rjb.Test').new
+    a = test.getStringArrayOfArrays()
+    assert_equal("abc", a[0][0])
+    assert_equal("def", a[0][1])
+    assert_equal("123", a[1][0])
+    assert_equal("456", a[1][1])
+
+    ints = test.getIntArrayOfArrays()
+    assert_equal(2, ints.size )
+    assert_equal([1,2,3], ints[0] )
+    assert_equal([[1,2,3],[4,5,6]], ints )
+
+    sized = test.getSizedArray()
+    assert_equal("find me",sized[0][1][2][3])
+
+    mixed = test.getMixedArray()
+    assert_equal(12,mixed[0][0][0].intValue)
+    assert_equal("another string",mixed[1][0][1].toString)
+    assert_equal([],mixed[2])
+  end
+end
+