Major refactor of luajava type coercion logic, and method selection logic.
This commit is contained in:
James Roseborough
@@ -32,6 +32,7 @@ import org.luaj.vm2.compiler.DumpLoadEndianIntTest;
|
||||
import org.luaj.vm2.compiler.RegressionTests;
|
||||
import org.luaj.vm2.compiler.SimpleTests;
|
||||
import org.luaj.vm2.lib.jse.LuaJavaCoercionTest;
|
||||
import org.luaj.vm2.lib.jse.LuajavaClassMembersTest;
|
||||
import org.luaj.vm2.vm1.Luajvm1CompatibilityTest;
|
||||
|
||||
public class AllTests {
|
||||
@@ -72,6 +73,7 @@ public class AllTests {
|
||||
|
||||
// library tests
|
||||
TestSuite lib = new TestSuite("Library Tests");
|
||||
lib.addTestSuite(LuajavaClassMembersTest.class);
|
||||
lib.addTestSuite(LuaJavaCoercionTest.class);
|
||||
lib.addTestSuite(RequireClassTest.class);
|
||||
suite.addTest(lib);
|
||||
|
||||
@@ -33,10 +33,10 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
|
||||
public void testLuaIntToJavaInt() {
|
||||
LuaInteger i = LuaInteger.valueOf(777);
|
||||
Object o = CoerceLuaToJava.coerceArg(i, int.class);
|
||||
Object o = CoerceLuaToJava.coerce(i, int.class);
|
||||
assertEquals( Integer.class, o.getClass() );
|
||||
assertEquals( 777, ((Number)o).intValue() );
|
||||
o = CoerceLuaToJava.coerceArg(i, Integer.class);
|
||||
o = CoerceLuaToJava.coerce(i, Integer.class);
|
||||
assertEquals( Integer.class, o.getClass() );
|
||||
assertEquals( new Integer(777), o );
|
||||
}
|
||||
@@ -50,7 +50,7 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
|
||||
public void testLuaStringToJavaString() {
|
||||
LuaString s = LuaValue.valueOf("777");
|
||||
Object o = CoerceLuaToJava.coerceArg(s, String.class);
|
||||
Object o = CoerceLuaToJava.coerce(s, String.class);
|
||||
assertEquals( String.class, o.getClass() );
|
||||
assertEquals( "777", o );
|
||||
}
|
||||
@@ -58,8 +58,7 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
public void testJavaIntArrayToLuaTable() {
|
||||
int[] i = { 222, 333 };
|
||||
LuaValue v = CoerceJavaToLua.coerce(i);
|
||||
assertEquals( LuaUserdata.class, v.getClass() );
|
||||
assertNotNull( v.getmetatable() );
|
||||
assertEquals( JavaArray.class, v.getClass() );
|
||||
assertEquals( LuaInteger.valueOf(222), v.get(ONE) );
|
||||
assertEquals( LuaInteger.valueOf(333), v.get(TWO) );
|
||||
assertEquals( TWO, v.get(LENGTH));
|
||||
@@ -90,7 +89,7 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
t.set(1, LuaInteger.valueOf(222) );
|
||||
t.set(2, LuaInteger.valueOf(333) );
|
||||
int[] i = null;
|
||||
Object o = CoerceLuaToJava.coerceArg(t, int[].class);
|
||||
Object o = CoerceLuaToJava.coerce(t, int[].class);
|
||||
assertEquals( int[].class, o.getClass() );
|
||||
i = (int[]) o;
|
||||
assertEquals( 2, i.length );
|
||||
@@ -98,48 +97,52 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
assertEquals( 333, i[1] );
|
||||
}
|
||||
|
||||
|
||||
public void testArrayParamScoring() {
|
||||
public void testIntArrayScoringTables() {
|
||||
int a = 5;
|
||||
LuaValue la = LuaInteger.valueOf(a);
|
||||
LuaTable tb = new LuaTable();
|
||||
tb.set( 1, la );
|
||||
LuaTable tc = new LuaTable();
|
||||
tc.set( 1, tb );
|
||||
|
||||
int saa = CoerceLuaToJava.getCoercion(int.class).score(la);
|
||||
int sab = CoerceLuaToJava.getCoercion(int[].class).score(la);
|
||||
int sac = CoerceLuaToJava.getCoercion(int[][].class).score(la);
|
||||
assertTrue( saa < sab );
|
||||
assertTrue( saa < sac );
|
||||
int sba = CoerceLuaToJava.getCoercion(int.class).score(tb);
|
||||
int sbb = CoerceLuaToJava.getCoercion(int[].class).score(tb);
|
||||
int sbc = CoerceLuaToJava.getCoercion(int[][].class).score(tb);
|
||||
assertTrue( sbb < sba );
|
||||
assertTrue( sbb < sbc );
|
||||
int sca = CoerceLuaToJava.getCoercion(int.class).score(tc);
|
||||
int scb = CoerceLuaToJava.getCoercion(int[].class).score(tc);
|
||||
int scc = CoerceLuaToJava.getCoercion(int[][].class).score(tc);
|
||||
assertTrue( scc < sca );
|
||||
assertTrue( scc < scb );
|
||||
}
|
||||
|
||||
public void testIntArrayScoringUserdata() {
|
||||
int a = 5;
|
||||
int[] b = { 44, 66 };
|
||||
int[][] c = { { 11, 22 }, { 33, 44 } };
|
||||
LuaValue la = LuaInteger.valueOf(a);
|
||||
LuaTable tb = new LuaTable();
|
||||
LuaTable tc = new LuaTable();
|
||||
LuaValue va = CoerceJavaToLua.coerce(a);
|
||||
LuaValue vb = CoerceJavaToLua.coerce(b);
|
||||
LuaValue vc = CoerceJavaToLua.coerce(c);
|
||||
tc.set( 1, new LuaTable() );
|
||||
|
||||
int saa = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(la), new Class[] { int.class } );
|
||||
int sab = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(la), new Class[] { int[].class } );
|
||||
int sac = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(la), new Class[] { int[][].class } );
|
||||
assertTrue( saa < sab );
|
||||
assertTrue( saa < sac );
|
||||
int sba = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tb), new Class[] { int.class } );
|
||||
int sbb = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tb), new Class[] { int[].class } );
|
||||
int sbc = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tb), new Class[] { int[][].class } );
|
||||
assertTrue( sbb < sba );
|
||||
assertTrue( sbb < sbc );
|
||||
int sca = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tc), new Class[] { int.class } );
|
||||
int scb = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tc), new Class[] { int[].class } );
|
||||
int scc = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(tc), new Class[] { int[][].class } );
|
||||
assertTrue( scc < sca );
|
||||
assertTrue( scc < scb );
|
||||
|
||||
int vaa = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(va), new Class[] { int.class } );
|
||||
int vab = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(va), new Class[] { int[].class } );
|
||||
int vac = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(va), new Class[] { int[][].class } );
|
||||
|
||||
int vaa = CoerceLuaToJava.getCoercion(int.class).score(va);
|
||||
int vab = CoerceLuaToJava.getCoercion(int[].class).score(va);
|
||||
int vac = CoerceLuaToJava.getCoercion(int[][].class).score(va);
|
||||
assertTrue( vaa < vab );
|
||||
assertTrue( vaa < vac );
|
||||
int vba = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vb), new Class[] { int.class } );
|
||||
int vbb = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vb), new Class[] { int[].class } );
|
||||
int vbc = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vb), new Class[] { int[][].class } );
|
||||
int vba = CoerceLuaToJava.getCoercion(int.class).score(vb);
|
||||
int vbb = CoerceLuaToJava.getCoercion(int[].class).score(vb);
|
||||
int vbc = CoerceLuaToJava.getCoercion(int[][].class).score(vb);
|
||||
assertTrue( vbb < vba );
|
||||
assertTrue( vbb < vbc );
|
||||
int vca = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vc), new Class[] { int.class } );
|
||||
int vcb = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vc), new Class[] { int[].class } );
|
||||
int vcc = CoerceLuaToJava.scoreParamTypes( LuajavaLib.paramsSignatureOf(vc), new Class[] { int[][].class } );
|
||||
int vca = CoerceLuaToJava.getCoercion(int.class).score(vc);
|
||||
int vcb = CoerceLuaToJava.getCoercion(int[].class).score(vc);
|
||||
int vcc = CoerceLuaToJava.getCoercion(int[][].class).score(vc);
|
||||
assertTrue( vcc < vca );
|
||||
assertTrue( vcc < vcb );
|
||||
}
|
||||
@@ -151,27 +154,30 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
public String sample(int[][] a) { return "int-array-array-args "+a[0][0]+","+a[0][1]+","+a[1][0]+","+a[1][1]; }
|
||||
}
|
||||
|
||||
|
||||
public void testIntArrayParameterMatching() {
|
||||
public void testMatchVoidArgs() {
|
||||
LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
|
||||
|
||||
// get sample field, call with no arguments
|
||||
LuaValue result = v.method("sample");
|
||||
assertEquals( "void-args", result.toString() );
|
||||
|
||||
// get sample field, call with one arguments
|
||||
}
|
||||
|
||||
public void testMatchIntArgs() {
|
||||
LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
|
||||
LuaValue arg = CoerceJavaToLua.coerce(new Integer(123));
|
||||
result = v.method("sample",arg);
|
||||
LuaValue result = v.method("sample",arg);
|
||||
assertEquals( "int-args 123", result.toString() );
|
||||
|
||||
// get sample field, call with array argument
|
||||
arg = CoerceJavaToLua.coerce(new int[]{345,678});
|
||||
result = v.method("sample",arg);
|
||||
}
|
||||
|
||||
public void testMatchIntArrayArgs() {
|
||||
LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
|
||||
LuaValue arg = CoerceJavaToLua.coerce(new int[]{345,678});
|
||||
LuaValue result = v.method("sample",arg);
|
||||
assertEquals( "int-array-args 345,678", result.toString() );
|
||||
|
||||
// get sample field, call with two-d array argument
|
||||
arg = CoerceJavaToLua.coerce(new int[][]{{22,33},{44,55}});
|
||||
result = v.method("sample",arg);
|
||||
}
|
||||
|
||||
public void testMatchIntArrayArrayArgs() {
|
||||
LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
|
||||
LuaValue arg = CoerceJavaToLua.coerce(new int[][]{{22,33},{44,55}});
|
||||
LuaValue result = v.method("sample",arg);
|
||||
assertEquals( "int-array-array-args 22,33,44,55", result.toString() );
|
||||
}
|
||||
|
||||
@@ -188,7 +194,8 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
}
|
||||
|
||||
public void testExceptionMessage() {
|
||||
String script = "return pcall( luajava.bindClass( \""+SomeClass.class.getName()+"\").someMethod )";
|
||||
String script = "local c = luajava.bindClass( \""+SomeClass.class.getName()+"\" )\n" +
|
||||
"return pcall( c.someMethod, c )";
|
||||
Varargs vresult = _G.get("loadstring").call(LuaValue.valueOf(script)).invoke(LuaValue.NONE);
|
||||
LuaValue status = vresult.arg1();
|
||||
LuaValue message = vresult.arg(2);
|
||||
@@ -198,7 +205,7 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
}
|
||||
|
||||
public void testLuaErrorCause() {
|
||||
String script = "luajava.bindClass( \""+SomeClass.class.getName()+"\").someMethod()";
|
||||
String script = "luajava.bindClass( \""+SomeClass.class.getName()+"\"):someMethod()";
|
||||
LuaValue chunk = _G.get("loadstring").call(LuaValue.valueOf(script));
|
||||
try {
|
||||
chunk.invoke(LuaValue.NONE);
|
||||
@@ -267,16 +274,20 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
assertEquals( "152415787532388367501905199875019052100", sc );
|
||||
}
|
||||
|
||||
public static class A {
|
||||
public interface IA {}
|
||||
public interface IB extends IA {}
|
||||
public interface IC extends IB {}
|
||||
|
||||
public static class A implements IA {
|
||||
}
|
||||
public static class B extends A{
|
||||
public static class B extends A implements IB {
|
||||
public String set( Object x ) { return "set(Object) "; }
|
||||
public String set( String x ) { return "set(String) "+x; }
|
||||
public String set( A x ) { return "set(A) "; }
|
||||
public String set( B x ) { return "set(B) "; }
|
||||
public String set( C x ) { return "set(C) "; }
|
||||
public String set( byte x ) { return "set(byte) "+x; }
|
||||
public String set( char x ) { return "set(char) "+x; }
|
||||
public String set( char x ) { return "set(char) "+(int)x; }
|
||||
public String set( short x ) { return "set(short) "+x; }
|
||||
public String set( int x ) { return "set(int) "+x; }
|
||||
public String set( long x ) { return "set(long) "+x; }
|
||||
@@ -288,7 +299,7 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
public String setr( long x ) { return "setr(long) "+x; }
|
||||
public String setr( int x ) { return "setr(int) "+x; }
|
||||
public String setr( short x ) { return "setr(short) "+x; }
|
||||
public String setr( char x ) { return "setr(char) "+x; }
|
||||
public String setr( char x ) { return "setr(char) "+(int)x; }
|
||||
public String setr( byte x ) { return "setr(byte) "+x; }
|
||||
public String setr( C x ) { return "setr(C) "; }
|
||||
public String setr( B x ) { return "setr(B) "; }
|
||||
@@ -298,18 +309,21 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
|
||||
public Object getObject() { return new Object(); }
|
||||
public String getString() { return "abc"; }
|
||||
public byte[] getbytearray() { return new byte[] { 1, 2, 3 }; }
|
||||
public A getA() { return new A(); }
|
||||
public B getB() { return new B(); }
|
||||
public C getC() { return new C(); }
|
||||
public byte getbyte() { return 1; }
|
||||
public char getchar() { return 2; }
|
||||
public short getshort() { return 3; }
|
||||
public int getint() { return 4; }
|
||||
public long getlong() { return 5; }
|
||||
public char getchar() { return 65000; }
|
||||
public short getshort() { return -32000; }
|
||||
public int getint() { return 100000; }
|
||||
public long getlong() { return 50000000000L; }
|
||||
public float getfloat() { return 6.5f; }
|
||||
public double getdouble() { return 7.5; }
|
||||
public double getdouble() { return Math.PI; }
|
||||
}
|
||||
public static class C extends B {
|
||||
public static class C extends B implements IC {
|
||||
}
|
||||
public static class D extends C implements IA {
|
||||
}
|
||||
|
||||
public void testOverloadedJavaMethodObject() { doOverloadedMethodTest( "Object", "" ); }
|
||||
@@ -318,12 +332,12 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
public void testOverloadedJavaMethodB() { doOverloadedMethodTest( "B", "" ); }
|
||||
public void testOverloadedJavaMethodC() { doOverloadedMethodTest( "C", "" ); }
|
||||
public void testOverloadedJavaMethodByte() { doOverloadedMethodTest( "byte", "1" ); }
|
||||
public void testOverloadedJavaMethodChar() { doOverloadedMethodTest( "char", "2" ); }
|
||||
public void testOverloadedJavaMethodShort() { doOverloadedMethodTest( "short", "3" ); }
|
||||
public void testOverloadedJavaMethodInt() { doOverloadedMethodTest( "int", "4" ); }
|
||||
public void testOverloadedJavaMethodLong() { doOverloadedMethodTest( "long", "5" ); }
|
||||
public void testOverloadedJavaMethodChar() { doOverloadedMethodTest( "char", "65000" ); }
|
||||
public void testOverloadedJavaMethodShort() { doOverloadedMethodTest( "short", "-32000" ); }
|
||||
public void testOverloadedJavaMethodInt() { doOverloadedMethodTest( "int", "100000" ); }
|
||||
public void testOverloadedJavaMethodLong() { doOverloadedMethodTest( "long", "50000000000" ); }
|
||||
public void testOverloadedJavaMethodFloat() { doOverloadedMethodTest( "float", "6.5" ); }
|
||||
public void testOverloadedJavaMethodDouble() { doOverloadedMethodTest( "double", "7.5" ); }
|
||||
public void testOverloadedJavaMethodDouble() { doOverloadedMethodTest( "double", "3.141592653589793" ); }
|
||||
|
||||
private void doOverloadedMethodTest( String typename, String value ) {
|
||||
String script =
|
||||
@@ -344,5 +358,50 @@ public class LuaJavaCoercionTest extends TestCase {
|
||||
assertEquals( "set("+typename+") "+value, sb );
|
||||
assertEquals( "setr("+typename+") "+value, sc );
|
||||
}
|
||||
|
||||
public void testClassInheritanceLevels() {
|
||||
assertEquals( 0, CoerceLuaToJava.inheritanceLevels(Object.class, Object.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(Object.class, String.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(Object.class, A.class) );
|
||||
assertEquals( 2, CoerceLuaToJava.inheritanceLevels(Object.class, B.class) );
|
||||
assertEquals( 3, CoerceLuaToJava.inheritanceLevels(Object.class, C.class) );
|
||||
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(A.class, Object.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(A.class, String.class) );
|
||||
assertEquals( 0, CoerceLuaToJava.inheritanceLevels(A.class, A.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(A.class, B.class) );
|
||||
assertEquals( 2, CoerceLuaToJava.inheritanceLevels(A.class, C.class) );
|
||||
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(B.class, Object.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(B.class, String.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(B.class, A.class) );
|
||||
assertEquals( 0, CoerceLuaToJava.inheritanceLevels(B.class, B.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(B.class, C.class) );
|
||||
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(C.class, Object.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(C.class, String.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(C.class, A.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(C.class, B.class) );
|
||||
assertEquals( 0, CoerceLuaToJava.inheritanceLevels(C.class, C.class) );
|
||||
}
|
||||
|
||||
public void testInterfaceInheritanceLevels() {
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(IA.class, A.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(IB.class, B.class) );
|
||||
assertEquals( 2, CoerceLuaToJava.inheritanceLevels(IA.class, B.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(IC.class, C.class) );
|
||||
assertEquals( 2, CoerceLuaToJava.inheritanceLevels(IB.class, C.class) );
|
||||
assertEquals( 3, CoerceLuaToJava.inheritanceLevels(IA.class, C.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(IA.class, D.class) );
|
||||
assertEquals( 2, CoerceLuaToJava.inheritanceLevels(IC.class, D.class) );
|
||||
assertEquals( 3, CoerceLuaToJava.inheritanceLevels(IB.class, D.class) );
|
||||
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(IB.class, A.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(IC.class, A.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(IC.class, B.class) );
|
||||
assertEquals( CoerceLuaToJava.SCORE_UNCOERCIBLE, CoerceLuaToJava.inheritanceLevels(IB.class, IA.class) );
|
||||
assertEquals( 1, CoerceLuaToJava.inheritanceLevels(IA.class, IB.class) );
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
226
test/junit/org/luaj/vm2/lib/jse/LuajavaClassMembersTest.java
Normal file
226
test/junit/org/luaj/vm2/lib/jse/LuajavaClassMembersTest.java
Normal file
@@ -0,0 +1,226 @@
|
||||
package org.luaj.vm2.lib.jse;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.luaj.vm2.LuaError;
|
||||
import org.luaj.vm2.LuaValue;
|
||||
|
||||
public class LuajavaClassMembersTest extends TestCase {
|
||||
public static class A {
|
||||
protected A() {}
|
||||
}
|
||||
public static class B extends A {
|
||||
public byte m_byte_field;
|
||||
public int m_int_field;
|
||||
public double m_double_field;
|
||||
public String m_string_field;
|
||||
|
||||
protected B() {}
|
||||
public B(int i) { m_int_field = i; }
|
||||
|
||||
public String setString( String x ) { return "setString(String) "+x; }
|
||||
public String getString() { return "abc"; }
|
||||
public int getint() { return 100000; }
|
||||
|
||||
public String uniq() { return "uniq()"; }
|
||||
public String uniqs(String s) { return "uniqs(string:"+s+")"; }
|
||||
public String uniqi(int i) { return "uniqi(int:"+i+")"; }
|
||||
public String uniqsi(String s, int i) { return "uniqsi(string:"+s+",int:"+i+")"; }
|
||||
public String uniqis(int i, String s) { return "uniqis(int:"+i+",string:"+s+")"; }
|
||||
|
||||
public String pick() { return "pick()"; }
|
||||
public String pick(String s) { return "pick(string:"+s+")"; }
|
||||
public String pick(int i) { return "pick(int:"+i+")"; }
|
||||
public String pick(String s, int i) { return "pick(string:"+s+",int:"+i+")"; }
|
||||
public String pick(int i, String s) { return "pick(int:"+i+",string:"+s+")"; }
|
||||
|
||||
public static String staticpick() { return "static-pick()"; }
|
||||
public static String staticpick(String s) { return "static-pick(string:"+s+")"; }
|
||||
public static String staticpick(int i) { return "static-pick(int:"+i+")"; }
|
||||
public static String staticpick(String s, int i) { return "static-pick(string:"+s+",int:"+i+")"; }
|
||||
public static String staticpick(int i, String s) { return "static-pick(int:"+i+",string:"+s+")"; }
|
||||
}
|
||||
public static class C extends B {
|
||||
public C() {}
|
||||
public C(String s) { m_string_field = s; }
|
||||
public C(int i) { m_int_field = i; }
|
||||
public C(String s, int i) { m_string_field = s; m_int_field = i; }
|
||||
public int getint() { return 200000; }
|
||||
|
||||
public String pick(String s) { return "class-c-pick(string:"+s+")"; }
|
||||
public String pick(int i) { return "class-c-pick(int:"+i+")"; }
|
||||
}
|
||||
|
||||
static LuaValue ZERO = LuaValue.ZERO;
|
||||
static LuaValue ONE = LuaValue.ONE;
|
||||
static LuaValue PI = LuaValue.valueOf(Math.PI);
|
||||
static LuaValue THREE = LuaValue.valueOf(3);
|
||||
static LuaValue NUMS = LuaValue.valueOf(123);
|
||||
static LuaValue ABC = LuaValue.valueOf("abc");
|
||||
static LuaValue SOMEA = CoerceJavaToLua.coerce(new A());
|
||||
static LuaValue SOMEB = CoerceJavaToLua.coerce(new B());
|
||||
static LuaValue SOMEC = CoerceJavaToLua.coerce(new C());
|
||||
|
||||
public void testSetByteField() {
|
||||
B b = new B();
|
||||
JavaInstance i = new JavaInstance(b);
|
||||
i.set("m_byte_field", ONE ); assertEquals( 1, b.m_byte_field ); assertEquals( ONE, i.get("m_byte_field") );
|
||||
i.set("m_byte_field", PI ); assertEquals( 3, b.m_byte_field ); assertEquals( THREE, i.get("m_byte_field") );
|
||||
i.set("m_byte_field", ABC ); assertEquals( 0, b.m_byte_field ); assertEquals( ZERO, i.get("m_byte_field") );
|
||||
}
|
||||
public void testSetDoubleField() {
|
||||
B b = new B();
|
||||
JavaInstance i = new JavaInstance(b);
|
||||
i.set("m_double_field", ONE ); assertEquals( 1., b.m_double_field ); assertEquals( ONE, i.get("m_double_field") );
|
||||
i.set("m_double_field", PI ); assertEquals( Math.PI, b.m_double_field ); assertEquals( PI, i.get("m_double_field") );
|
||||
i.set("m_double_field", ABC ); assertEquals( 0., b.m_double_field ); assertEquals( ZERO, i.get("m_double_field") );
|
||||
}
|
||||
public void testNoFactory() {
|
||||
JavaClass c = JavaClass.forClass(A.class);
|
||||
try {
|
||||
c.call();
|
||||
fail( "did not throw lua error as expected" );
|
||||
} catch ( LuaError e ) {
|
||||
}
|
||||
}
|
||||
public void testUniqueFactoryCoercible() {
|
||||
JavaClass c = JavaClass.forClass(B.class);
|
||||
assertEquals( JavaClass.class, c.getClass() );
|
||||
LuaValue constr = c.get("new");
|
||||
assertEquals( JavaConstructor.class, constr.getClass() );
|
||||
LuaValue v = constr.call(NUMS);
|
||||
Object b = v.touserdata();
|
||||
assertEquals( B.class, b.getClass() );
|
||||
assertEquals( 123, ((B)b).m_int_field );
|
||||
Object b0 = constr.call().touserdata();
|
||||
assertEquals( B.class, b0.getClass() );
|
||||
assertEquals( 0, ((B)b0).m_int_field );
|
||||
}
|
||||
public void testUniqueFactoryUncoercible() {
|
||||
JavaClass f = JavaClass.forClass(B.class);
|
||||
LuaValue constr = f.get("new");
|
||||
assertEquals( JavaConstructor.class, constr.getClass() );
|
||||
try {
|
||||
LuaValue v = constr.call(LuaValue.userdataOf(new Object()));
|
||||
Object b = v.touserdata();
|
||||
// fail( "did not throw lua error as expected" );
|
||||
assertEquals( 0, ((B)b).m_int_field );
|
||||
} catch ( LuaError e ) {
|
||||
}
|
||||
}
|
||||
public void testOverloadedFactoryCoercible() {
|
||||
JavaClass f = JavaClass.forClass(C.class);
|
||||
LuaValue constr = f.get("new");
|
||||
assertEquals( JavaConstructor.Overload.class, constr.getClass() );
|
||||
Object c = constr.call().touserdata();
|
||||
Object ci = constr.call(LuaValue.valueOf(123)).touserdata();
|
||||
Object cs = constr.call(LuaValue.valueOf("abc")).touserdata();
|
||||
Object csi = constr.call( LuaValue.valueOf("def"), LuaValue.valueOf(456) ).touserdata();
|
||||
assertEquals( C.class, c.getClass() );
|
||||
assertEquals( C.class, ci.getClass() );
|
||||
assertEquals( C.class, cs.getClass() );
|
||||
assertEquals( C.class, csi.getClass() );
|
||||
assertEquals( null, ((C)c).m_string_field );
|
||||
assertEquals( 0, ((C)c).m_int_field );
|
||||
assertEquals( "abc", ((C)cs).m_string_field );
|
||||
assertEquals( 0, ((C)cs).m_int_field );
|
||||
assertEquals( null, ((C)ci).m_string_field );
|
||||
assertEquals( 123, ((C)ci).m_int_field );
|
||||
assertEquals( "def", ((C)csi).m_string_field );
|
||||
assertEquals( 456, ((C)csi).m_int_field );
|
||||
}
|
||||
public void testOverloadedFactoryUncoercible() {
|
||||
JavaClass f = JavaClass.forClass(C.class);
|
||||
try {
|
||||
Object c = f.call(LuaValue.userdataOf(new Object()));
|
||||
// fail( "did not throw lua error as expected" );
|
||||
assertEquals( 0, ((C)c).m_int_field );
|
||||
assertEquals( null, ((C)c).m_string_field );
|
||||
} catch ( LuaError e ) {
|
||||
}
|
||||
}
|
||||
|
||||
public void testNoAttribute() {
|
||||
JavaClass f = JavaClass.forClass(A.class);
|
||||
LuaValue v = f.get("bogus");
|
||||
assertEquals( v, LuaValue.NIL );
|
||||
try {
|
||||
f.set("bogus",ONE);
|
||||
fail( "did not throw lua error as expected" );
|
||||
} catch ( LuaError e ) {}
|
||||
}
|
||||
public void testFieldAttributeCoercible() {
|
||||
JavaInstance i = new JavaInstance(new B());
|
||||
i.set("m_int_field", ONE ); assertEquals( 1, i.get("m_int_field").toint() );
|
||||
i.set("m_int_field", THREE ); assertEquals( 3, i.get("m_int_field").toint() );
|
||||
i = new JavaInstance(new C());
|
||||
i.set("m_int_field", ONE ); assertEquals( 1, i.get("m_int_field").toint() );
|
||||
i.set("m_int_field", THREE ); assertEquals( 3, i.get("m_int_field").toint() );
|
||||
}
|
||||
public void testUniqueMethodAttributeCoercible() {
|
||||
B b = new B();
|
||||
JavaInstance ib = new JavaInstance(b);
|
||||
LuaValue b_getString = ib.get("getString");
|
||||
LuaValue b_getint = ib.get("getint");
|
||||
assertEquals( JavaMethod.class, b_getString.getClass() );
|
||||
assertEquals( JavaMethod.class, b_getint.getClass() );
|
||||
assertEquals( "abc", b_getString.call(SOMEB).tojstring() );
|
||||
assertEquals( 100000, b_getint.call(SOMEB).toint());
|
||||
assertEquals( "abc", b_getString.call(SOMEC).tojstring() );
|
||||
assertEquals( 200000, b_getint.call(SOMEC).toint());
|
||||
}
|
||||
public void testUniqueMethodAttributeArgsCoercible() {
|
||||
B b = new B();
|
||||
JavaInstance ib = new JavaInstance(b);
|
||||
LuaValue uniq = ib.get("uniq");
|
||||
LuaValue uniqs = ib.get("uniqs");
|
||||
LuaValue uniqi = ib.get("uniqi");
|
||||
LuaValue uniqsi = ib.get("uniqsi");
|
||||
LuaValue uniqis = ib.get("uniqis");
|
||||
assertEquals( JavaMethod.class, uniq.getClass() );
|
||||
assertEquals( JavaMethod.class, uniqs.getClass() );
|
||||
assertEquals( JavaMethod.class, uniqi.getClass() );
|
||||
assertEquals( JavaMethod.class, uniqsi.getClass() );
|
||||
assertEquals( JavaMethod.class, uniqis.getClass() );
|
||||
assertEquals( "uniq()", uniq.call(SOMEB).tojstring() );
|
||||
assertEquals( "uniqs(string:abc)", uniqs.call(SOMEB,ABC).tojstring() );
|
||||
assertEquals( "uniqi(int:1)", uniqi.call(SOMEB,ONE).tojstring() );
|
||||
assertEquals( "uniqsi(string:abc,int:1)", uniqsi.call(SOMEB,ABC,ONE).tojstring() );
|
||||
assertEquals( "uniqis(int:1,string:abc)", uniqis.call(SOMEB,ONE,ABC).tojstring() );
|
||||
assertEquals( "uniqis(int:1,string:abc)", uniqis.invoke(LuaValue.varargsOf(new LuaValue[] {SOMEB,ONE,ABC,ONE})).arg1().tojstring() );
|
||||
}
|
||||
public void testOverloadedMethodAttributeCoercible() {
|
||||
B b = new B();
|
||||
JavaInstance ib = new JavaInstance(b);
|
||||
LuaValue p = ib.get("pick");
|
||||
assertEquals( "pick()", p.call(SOMEB).tojstring() );
|
||||
assertEquals( "pick(string:abc)", p.call(SOMEB,ABC).tojstring() );
|
||||
assertEquals( "pick(int:1)", p.call(SOMEB,ONE).tojstring() );
|
||||
assertEquals( "pick(string:abc,int:1)", p.call(SOMEB,ABC,ONE).tojstring() );
|
||||
assertEquals( "pick(int:1,string:abc)", p.call(SOMEB,ONE,ABC).tojstring() );
|
||||
assertEquals( "pick(int:1,string:abc)", p.invoke(LuaValue.varargsOf(new LuaValue[] {SOMEB,ONE,ABC,ONE})).arg1().tojstring() );
|
||||
}
|
||||
public void testUnboundOverloadedMethodAttributeCoercible() {
|
||||
B b = new B();
|
||||
JavaInstance ib = new JavaInstance(b);
|
||||
LuaValue p = ib.get("pick");
|
||||
assertEquals( JavaMethod.Overload.class, p.getClass() );
|
||||
assertEquals( "pick()", p.call(SOMEC).tojstring() );
|
||||
assertEquals( "class-c-pick(string:abc)", p.call(SOMEC,ABC).tojstring() );
|
||||
assertEquals( "class-c-pick(int:1)", p.call(SOMEC,ONE).tojstring() );
|
||||
assertEquals( "pick(string:abc,int:1)", p.call(SOMEC,ABC,ONE).tojstring() );
|
||||
assertEquals( "pick(int:1,string:abc)", p.call(SOMEC,ONE,ABC).tojstring() );
|
||||
assertEquals( "pick(int:1,string:abc)", p.invoke(LuaValue.varargsOf(new LuaValue[] {SOMEC,ONE,ABC,ONE})).arg1().tojstring() );
|
||||
}
|
||||
public void testOverloadedStaticMethodAttributeCoercible() {
|
||||
B b = new B();
|
||||
JavaInstance ib = new JavaInstance(b);
|
||||
LuaValue p = ib.get("staticpick");
|
||||
assertEquals( "static-pick()", p.call(SOMEB).tojstring() );
|
||||
assertEquals( "static-pick(string:abc)", p.call(SOMEB,ABC).tojstring() );
|
||||
assertEquals( "static-pick(int:1)", p.call(SOMEB,ONE).tojstring() );
|
||||
assertEquals( "static-pick(string:abc,int:1)", p.call(SOMEB,ABC,ONE).tojstring() );
|
||||
assertEquals( "static-pick(int:1,string:abc)", p.call(SOMEB,ONE,ABC).tojstring() );
|
||||
assertEquals( "static-pick(int:1,string:abc)", p.invoke(LuaValue.varargsOf(new LuaValue[] {SOMEB,ONE,ABC,ONE})).arg1().tojstring() );
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user