// :tabSize=2:indentSize=2:noTabs=false:folding=explicit:collapseFolds=1:
import java.lang.reflect.Constructor ;
import java.lang.reflect.* ;
import java.util.Map ;
import java.util.Set ;
import java.util.HashMap;
public class RJavaTools_Test {
private static class ExampleClass {
public ExampleClass( Object o1, String o2, boolean o3, boolean o4){}
public ExampleClass( Object o1, String o2, boolean o3){}
public ExampleClass(){}
}
/* so that we can check about access to private fields and methods */
private int bogus = 0 ;
private int getBogus(){ return bogus ; }
private static int staticbogus ;
private static int getStaticBogus(){ return staticbogus ; }
public int x = 0 ;
public static int static_x = 0;
public int getX(){ return x ; }
public static int getStaticX(){ return static_x ; }
public void setX( Integer x ){ this.x = x.intValue(); }
// {{{ main
public static void main( String[] args){
try{
runtests() ;
} catch( TestException e){
fails( e ) ;
System.exit(1);
}
}
public static void runtests() throws TestException {
System.out.println( "Testing RJavaTools.getConstructor" ) ;
constructors() ;
success() ;
System.out.println( "Testing RJavaTools.classHasField" ) ;
classhasfield() ;
success();
System.out.println( "Testing RJavaTools.classHasMethod" ) ;
classhasmethod() ;
success() ;
System.out.println( "Testing RJavaTools.classHasClass" ) ;
classhasclass() ;
success();
System.out.println( "Testing RJavaTools.hasField" ) ;
hasfield() ;
success();
System.out.println( "Testing RJavaTools.hasClass" ) ;
hasclass() ;
success();
System.out.println( "Testing RJavaTools.getClass" ) ;
getclass() ;
success() ;
System.out.println( "Testing RJavaTools.hasMethod" ) ;
hasmethod() ;
success() ;
System.out.println( "Testing RJavaTools.isStatic" ) ;
isstatic() ;
success() ;
System.out.println( "Testing RJavaTools.getCompletionName" ) ;
getcompletionname() ;
success();
System.out.println( "Testing RJavaTools.getFieldNames" ) ;
getfieldnames() ;
success() ;
System.out.println( "Testing RJavaTools.getMethodNames" ) ;
getmethodnames() ;
success() ;
System.out.println( "Testing RJavaTools.getStaticFields" ) ;
getstaticfields() ;
success() ;
System.out.println( "Testing RJavaTools.getStaticMethods" ) ;
getstaticmethods() ;
success() ;
System.out.println( "Testing RJavaTools.getStaticClasses" ) ;
getstaticclasses() ;
success() ;
System.out.println( "Testing RJavaTools.invokeMethod" ) ;
invokemethod() ;
success() ;
System.out.println( "Testing RJavaTools.getFieldTypeName" ) ;
getfieldtypename();
success() ;
System.out.println( "Testing RJavaTools.getMethod" ) ;
System.out.println( "NOT YET AVAILABLE" ) ;
System.out.println( "Testing RJavaTools.newInstance" ) ;
System.out.println( "NOT YET AVAILABLE" ) ;
}
// }}}
// {{{ fails
private static void fails( TestException e ){
System.err.println( "\n" ) ;
e.printStackTrace() ;
System.err.println( "FAILED" ) ;
}
// }}}
// {{{ success
private static void success(){
System.out.println( "PASSED" ) ;
}
// }}}
// {{{ @Test getFieldNames
private static void getfieldnames() throws TestException{
String[] names;
// {{{ getFieldNames(DummyPoint, false) -> c('x', 'y' )
System.out.print( " * getFieldNames(DummyPoint, false)" ) ;
names = RJavaTools.getFieldNames( DummyPoint.class, false ) ;
if( names.length != 2 ){
throw new TestException( "getFieldNames(DummyPoint, false).length != 2" ) ;
}
for( int i=0; i<2; i++){
if( !( "x".equals(names[i]) || "y".equals(names[i] ) ) ){
throw new TestException( "getFieldNames(DummyPoint, false).length != c('x','y') " ) ;
}
}
System.out.println( " : ok " ) ;
// }}}
// {{{ getFieldNames(Point, true ) --> character(0)
System.out.print( " * getFieldNames(DummyPoint, true )" ) ;
names = RJavaTools.getFieldNames( DummyPoint.class, true ) ;
if( names.length != 0 ){
throw new TestException( "getFieldNames(DummyPoint, true ) != character(0)" );
}
System.out.println( " : ok " ) ;
// }}}
// {{{ getFieldNames(RJavaTools_Test, true ) --> static_x
System.out.print( " * getFieldNames(RJavaTools_Test, true )" ) ;
names = RJavaTools.getFieldNames( RJavaTools_Test.class, true ) ;
if( names.length != 1 ){
throw new TestException( "getFieldNames(RJavaTools_Test, true ).length != 1" );
}
if( ! "static_x".equals( names[0] ) ){
throw new TestException( "getFieldNames(RJavaTools_Test, true )[0] != 'static_x' " );
}
System.out.println( " : ok " ) ;
// }}}
// {{{ getFieldNames(RJavaTools_Test, false ) --> c('x', 'static_x')
System.out.print( " * getFieldNames(RJavaTools_Test, false )" ) ;
names = RJavaTools.getFieldNames( RJavaTools_Test.class, false ) ;
if( names.length != 2 ){
throw new TestException( "getFieldNames(RJavaTools_Test, false ).length != 2" );
}
for( int i=0; i<2; i++){
if( ! ( "x".equals( names[i] ) || "static_x".equals(names[i]) ) ){
throw new TestException( "getFieldNames(RJavaTools_Test, false ) != c('x', 'static_x') " );
}
}
System.out.println( " : ok " ) ;
// }}}
}
// }}}
// {{{ @Test getMethodNames
private static void getmethodnames() throws TestException{
String[] names ;
String[] expected ;
int cpt = 0;
// {{{ getMethodNames(RJavaTools_Test, true) -> c('getStaticX()', 'main(', 'runtests' )
System.out.print( " * getMethodNames(RJavaTools_Test, true)" ) ;
names = RJavaTools.getMethodNames( RJavaTools_Test.class, true ) ;
if( names.length != 3 ){
throw new TestException( "getMethodNames(RJavaTools_Test, true).length != 3 (" + names.length + ")" ) ;
}
expected= new String[]{ "getStaticX()", "main(", "runtests()" };
cpt = 0;
for( int i=0; i character(0) )
System.out.print( " * getMethodNames(Object, true)" ) ;
names = RJavaTools.getMethodNames( Object.class, true ) ;
if( names.length != 0 ){
throw new TestException( "getMethodNames(Object, true).length != 0 (" + names.length + ")" ) ;
}
System.out.println( " : ok " ) ;
// }}}
// {{{ getMethodNames(RJavaTools_Test, false) %contains% { "getX()", "getStaticX()", "setX(", "main(" }
System.out.print( " * getMethodNames(RJavaTools_Test, false)" ) ;
names = RJavaTools.getMethodNames( RJavaTools_Test.class, false ) ;
cpt = 0;
expected = new String[]{ "getX()", "getStaticX()", "setX(", "main(" };
for( int i=0; i false
try{
System.out.print( " * isStatic(RJavaTools_Test.x)" ) ;
f = RJavaTools_Test.class.getField("x") ;
if( RJavaTools.isStatic( f) ){
throw new TestException( "isStatic(RJavaTools_Test.x) == true" ) ;
}
System.out.println( " = false : ok " ) ;
} catch( NoSuchFieldException e){
throw new TestException( e.getMessage() ) ;
}
// }}}
// {{{ isStatic(RJavaTools_Test.getX) -> true
try{
System.out.print( " * isStatic(RJavaTools_Test.getX() )" ) ;
m = RJavaTools_Test.class.getMethod("getX", (Class[])null ) ;
if( RJavaTools.isStatic( m ) ){
throw new TestException( "isStatic(RJavaTools_Test.getX() ) == false" ) ;
}
System.out.println( " = false : ok " ) ;
} catch( NoSuchMethodException e){
throw new TestException( e.getMessage() ) ;
}
// }}}
// {{{ isStatic(RJavaTools_Test.static_x) -> true
try{
System.out.print( " * isStatic(RJavaTools_Test.static_x)" ) ;
f = RJavaTools_Test.class.getField("static_x") ;
if( ! RJavaTools.isStatic( f) ){
throw new TestException( "isStatic(RJavaTools_Test.static_x) == false" ) ;
}
System.out.println( " = true : ok " ) ;
} catch( NoSuchFieldException e){
throw new TestException( e.getMessage() ) ;
}
// }}}
// {{{ isStatic(RJavaTools_Test.getStaticX) -> true
try{
System.out.print( " * isStatic(RJavaTools_Test.getStaticX() )" ) ;
m = RJavaTools_Test.class.getMethod("getStaticX", (Class[])null ) ;
if( ! RJavaTools.isStatic( m ) ){
throw new TestException( "isStatic(RJavaTools_Test.getStaticX() ) == false" ) ;
}
System.out.println( " = true : ok " ) ;
} catch( NoSuchMethodException e){
throw new TestException( e.getMessage() ) ;
}
// }}}
/* classes */
// {{{ isStatic(RJavaTools_Test.TestException) -> true
System.out.print( " * isStatic(RJavaTools_Test.TestException )" ) ;
Class cl = RJavaTools_Test.TestException.class ;
if( ! RJavaTools.isStatic( cl ) ){
throw new TestException( "isStatic(RJavaTools_Test.TestException) == false" ) ;
}
System.out.println( " = true : ok " ) ;
// }}}
// {{{ isStatic(RJavaTools_Test.DummyNonStaticClass) -> false
System.out.print( " * isStatic(RJavaTools_Test.DummyNonStaticClass )" ) ;
cl = RJavaTools_Test.DummyNonStaticClass.class ;
if( RJavaTools.isStatic( cl ) ){
throw new TestException( "isStatic(RJavaTools_Test.DummyNonStaticClass) == true" ) ;
}
System.out.println( " = false : ok " ) ;
// }}}
}
// }}}
// {{{ @Test constructors
private static void constructors() throws TestException {
/* constructors */
Constructor cons ;
boolean error ;
// {{{ getConstructor( String, null )
System.out.print( " * getConstructor( String, null )" ) ;
try{
cons = RJavaTools.getConstructor( String.class, (Class[])null, (boolean[])null ) ;
} catch( Exception e ){
throw new TestException( "getConstructor( String, null )" ) ;
}
System.out.println( " : ok " ) ;
// }}}
// {{{ getConstructor( Integer, { String.class } )
System.out.print( " * getConstructor( Integer, { String.class } )" ) ;
try{
cons = RJavaTools.getConstructor( Integer.class, new Class[]{ String.class }, new boolean[]{false} ) ;
} catch( Exception e){
throw new TestException( "getConstructor( Integer, { String.class } )" ) ;
}
System.out.println( " : ok " ) ;
// }}}
// disabled for now
// // {{{ getConstructor( JButton, { String.class, ImageIcon.class } )
// System.out.print( " * getConstructor( JButton, { String.class, ImageIcon.class } )" ) ;
// try{
// cons = RJavaTools.getConstructor( JButton.class,
// new Class[]{ String.class, ImageIcon.class },
// new boolean[]{ false, false} ) ;
// } catch( Exception e){
// throw new TestException( "getConstructor( JButton, { String.class, ImageIcon.class } )" ) ;
// }
// System.out.println( " : ok " ) ;
// // }}}
// {{{ getConstructor( Integer, null ) -> exception
error = false ;
System.out.print( " * getConstructor( Integer, null )" ) ;
try{
cons = RJavaTools.getConstructor( Integer.class, (Class[])null, (boolean[])null ) ;
} catch( Exception e){
error = true ;
}
if( !error ){
throw new TestException( "getConstructor( Integer, null ) did not generate error" ) ;
}
System.out.println( " -> exception : ok " ) ;
// }}}
// disabled for now
// // {{{ getConstructor( JButton, { String.class, JButton.class } ) -> exception
// error = false ;
// System.out.print( " * getConstructor( JButton, { String.class, JButton.class } )" ) ;
// try{
// cons = RJavaTools.getConstructor( JButton.class,
// new Class[]{ String.class, JButton.class },
// new boolean[]{ false, false } ) ;
// } catch( Exception e){
// error = true ;
// }
// if( !error ){
// throw new TestException( "getConstructor( JButton, { String.class, JButton.class } ) did not generate error" ) ;
// }
// System.out.println( " -> exception : ok " ) ;
// // }}}
Object o1 = null ;
Object o2 = null ;
ExampleClass foo = new ExampleClass(o1,(String)o2,false) ;
// {{{ getConstructor( ExampleClass, { null, null, false }
error = false ;
System.out.print( " * getConstructor( ExampleClass, {Object.class, Object.class, boolean}) : " ) ;
try{
cons = RJavaTools.getConstructor( ExampleClass.class,
new Class[]{ Object.class, Object.class, Boolean.TYPE},
new boolean[]{ true, true, false} );
} catch(Exception e){
error = true ;
e.printStackTrace() ;
}
if( error ){
throw new TestException( "getConstructor( ExampleClass, {Object.class, Object.class, boolean}) : exception " ) ;
}
System.out.println( " ok" ) ;
// }}}
}
// }}}
// {{{ @Test methods
private static void methods() throws TestException{
}
// }}}
// {{{ @Test hasfields
private static void hasfield() throws TestException{
DummyPoint p = new DummyPoint() ;
System.out.println( " java> DummyPoint p = new DummyPoint()" ) ;
System.out.print( " * hasField( p, 'x' ) " ) ;
if( !RJavaTools.hasField( p, "x" ) ){
throw new TestException( " hasField( DummyPoint, 'x' ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * hasField( p, 'iiiiiiiiiiiii' ) " ) ;
if( RJavaTools.hasField( p, "iiiiiiiiiiiii" ) ){
throw new TestException( " hasField( DummyPoint, 'iiiiiiiiiiiii' ) == true" ) ;
}
System.out.println( " false : ok" ) ;
/* testing a private field */
RJavaTools_Test ob = new RJavaTools_Test();
System.out.print( " * testing a private field " ) ;
if( RJavaTools.hasField( ob, "bogus" ) ){
throw new TestException( " hasField returned true on private field" ) ;
}
System.out.println( " false : ok" ) ;
}
// }}}
// {{{ @Test hasmethod
private static void hasmethod() throws TestException{
DummyPoint p = new DummyPoint() ;
System.out.println( " java> DummyPoint p = new DummyPoint()" ) ;
System.out.print( " * hasMethod( p, 'move' ) " ) ;
if( !RJavaTools.hasMethod( p, "move" ) ){
throw new TestException( " hasField( DummyPoint, 'move' ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * hasMethod( p, 'iiiiiiiiiiiii' ) " ) ;
if( RJavaTools.hasMethod( p, "iiiiiiiiiiiii" ) ){
throw new TestException( " hasMethod( Point, 'iiiiiiiiiiiii' ) == true" ) ;
}
System.out.println( " false : ok" ) ;
/* testing a private method */
RJavaTools_Test ob = new RJavaTools_Test();
System.out.print( " * testing a private method " ) ;
if( RJavaTools.hasField( ob, "getBogus" ) ){
throw new TestException( " hasMethod returned true on private method" ) ;
}
System.out.println( " false : ok" ) ;
}
// }}}
// {{{ @Test hasclass
private static void hasclass() throws TestException{
RJavaTools_Test ob = new RJavaTools_Test();
System.out.print( " * hasClass( RJavaTools_Test, 'TestException' ) " ) ;
if( ! RJavaTools.hasClass( ob, "TestException" ) ){
throw new TestException( " hasClass( RJavaTools_Test, 'TestException' ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * hasClass( RJavaTools_Test, 'DummyNonStaticClass' ) " ) ;
if( ! RJavaTools.hasClass( ob, "DummyNonStaticClass" ) ){
throw new TestException( " hasClass( RJavaTools_Test, 'DummyNonStaticClass' ) == false" ) ;
}
System.out.println( " true : ok" ) ;
}
// }}}
// {{{ @Test hasclass
private static void getclass() throws TestException{
Class cl ;
System.out.print( " * getClass( RJavaTools_Test, 'TestException', true ) " ) ;
cl = RJavaTools.getClass( RJavaTools_Test.class, "TestException", true );
if( cl != RJavaTools_Test.TestException.class ){
throw new TestException( " getClass( RJavaTools_Test, 'TestException', true ) != TestException" ) ;
}
System.out.println( " : ok" ) ;
System.out.print( " * getClass( RJavaTools_Test, 'DummyNonStaticClass', true ) " ) ;
cl = RJavaTools.getClass( RJavaTools_Test.class, "DummyNonStaticClass", true );
if( cl != null ){
throw new TestException( " getClass( RJavaTools_Test, 'DummyNonStaticClass', true ) != null" ) ;
}
System.out.println( " : ok" ) ;
System.out.print( " * getClass( RJavaTools_Test, 'DummyNonStaticClass', false ) " ) ;
cl = RJavaTools.getClass( RJavaTools_Test.class, "DummyNonStaticClass", false );
if( cl != RJavaTools_Test.DummyNonStaticClass.class ){
throw new TestException( " getClass( RJavaTools_Test, 'DummyNonStaticClass', true ) != null" ) ;
}
System.out.println( " : ok" ) ;
}
// }}}
// {{{ @Test classhasfield
private static void classhasfield() throws TestException{
}
// }}}
// {{{ @Test classhasclass
private static void classhasclass() throws TestException{
System.out.print( " * classHasClass( RJavaTools_Test, 'TestException', true ) " ) ;
if( ! RJavaTools.classHasClass( RJavaTools_Test.class , "TestException", true ) ){
throw new TestException( " classHasClass( RJavaTools_Test, 'TestException', true ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * classHasClass( RJavaTools_Test, 'DummyNonStaticClass', true ) " ) ;
if( RJavaTools.classHasClass( RJavaTools_Test.class , "DummyNonStaticClass", true ) ){
throw new TestException( " classHasClass( RJavaTools_Test, 'DummyNonStaticClass', true ) == true" ) ;
}
System.out.println( " false : ok" ) ;
System.out.print( " * classHasClass( RJavaTools_Test, 'DummyNonStaticClass', false ) " ) ;
if( ! RJavaTools.classHasClass( RJavaTools_Test.class , "DummyNonStaticClass", false ) ){
throw new TestException( " classHasClass( RJavaTools_Test, 'DummyNonStaticClass', false ) == false" ) ;
}
System.out.println( " true : ok" ) ;
}
// }}}
// {{{ @Test classhasmethod
private static void classhasmethod() throws TestException{
System.out.print( " * classHasMethod( RJavaTools_Test, 'getX', false ) " ) ;
if( ! RJavaTools.classHasMethod( RJavaTools_Test.class, "getX", false ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getX', false ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * classHasMethod( RJavaTools_Test, 'getStaticX', false ) " ) ;
if( ! RJavaTools.classHasMethod( RJavaTools_Test.class, "getStaticX", false ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getStaticX', false ) == false" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * classHasMethod( RJavaTools_Test, 'getX', true ) " ) ;
if( RJavaTools.classHasMethod( RJavaTools_Test.class, "getX", true ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getX', true ) == true (non static method)" ) ;
}
System.out.println( " false : ok" ) ;
System.out.print( " * classHasMethod( RJavaTools_Test, 'getStaticX', true ) " ) ;
if( ! RJavaTools.classHasMethod( RJavaTools_Test.class, "getStaticX", true ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getStaticX', true ) == false (static)" ) ;
}
System.out.println( " true : ok" ) ;
System.out.print( " * classHasMethod( RJavaTools_Test, 'getBogus', false ) " ) ;
if( RJavaTools.classHasMethod( RJavaTools_Test.class, "getBogus", false ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getBogus', false ) == true (private method)" ) ;
}
System.out.println( " false : ok" ) ;
System.out.print( " * classHasMethod( RJavaTools_Test, 'getStaticBogus', true ) " ) ;
if( RJavaTools.classHasMethod( RJavaTools_Test.class, "getStaticBogus", true ) ){
throw new TestException( " classHasMethod( RJavaTools_Test, 'getBogus', true ) == true (private method)" ) ;
}
System.out.println( " false : ok" ) ;
}
// }}}
// {{{ @Test getstaticfields
private static void getstaticfields() throws TestException{
Field[] f ;
System.out.print( " * getStaticFields( RJavaTools_Test ) " ) ;
f = RJavaTools.getStaticFields( RJavaTools_Test.class ) ;
if( f.length != 1 ){
throw new TestException( " getStaticFields( RJavaTools_Test ).length != 1" ) ;
}
if( ! "static_x".equals( f[0].getName() ) ){
throw new TestException( " getStaticFields( RJavaTools_Test )[0] != 'static_x'" ) ;
}
System.out.println( " : ok" ) ;
System.out.print( " * getStaticFields( Object ) " ) ;
f = RJavaTools.getStaticFields( Object.class ) ;
if( f != null ){
throw new TestException( " getStaticFields( Object ) != null" ) ;
}
System.out.println( " : ok" ) ;
}
// }}}
// {{{ @Test getstaticmethods
private static void getstaticmethods() throws TestException{
Method[] m ;
// {{{ getStaticMethods( RJavaTools_Test )
System.out.print( " * getStaticMethods( RJavaTools_Test ) " ) ;
m = RJavaTools.getStaticMethods( RJavaTools_Test.class ) ;
String[] expected = new String[]{ "getStaticX" , "main", "runtests" };
int count = 0;
if( m.length != expected.length ){
throw new TestException( " getStaticMethods( RJavaTools_Test ).length != 2" ) ;
}
for( int i=0; i