open-autonomous-connection/luaj
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Add unit tests for varargs

Browse Source
This commit is contained in:
James Roseborough
2012-09-18 03:55:51 +00:00
parent 8f3f4dfb2a
commit ef94aa3abb
4 changed files with 109 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/org/luaj/vm2/LuaClosure.java
View File

@@ -170,10 +170,10 @@ public class LuaClosure extends LuaFunction {
} }
public final Varargs invoke(Varargs varargs) { public final Varargs invoke(Varargs varargs) {
return onInvoke( varargs ).eval(); return onInvoke(varargs).eval();
} }
public Varargs onInvoke(Varargs varargs) { public final Varargs onInvoke(Varargs varargs) {
LuaValue[] stack = new LuaValue[p.maxstacksize]; LuaValue[] stack = new LuaValue[p.maxstacksize];
for ( int i=0; i<p.numparams; i++ ) for ( int i=0; i<p.numparams; i++ )
stack[i] = varargs.arg(i+1); stack[i] = varargs.arg(i+1);

2
src/core/org/luaj/vm2/LuaValue.java
View File

@@ -3506,7 +3506,7 @@ public class LuaValue extends Varargs {
* <p> * <p>
* This may return a {@link TailcallVarargs} to be evaluated by the client. * This may return a {@link TailcallVarargs} to be evaluated by the client.
* <p> * <p>
* This should not be called directly, instead use on of the call invocation functions. * This should not be called directly, instead use one of the call invocation functions.
* *
* @param args the arguments to the call invocation. * @param args the arguments to the call invocation.
* @return Varargs the return values, possible a TailcallVarargs. * @return Varargs the return values, possible a TailcallVarargs.

16
src/core/org/luaj/vm2/Varargs.java
View File

@@ -623,12 +623,8 @@ public abstract class Varargs {
if (start == 1) if (start == 1)
return this; return this;
if (start > v.length) if (start > v.length)
return LuaValue.NONE; return r.subargs(start - v.length);
if (start == v.length) return LuaValue.varargsOf(v, start - 1, v.length - (start - 1), r);
return v[v.length - 1];
if (start == v.length - 1)
return new PairVarargs(v[v.length - 2], v[v.length - 1]);
return new ArrayPartVarargs(v, start - 1, v.length - (start - 1));
} }
} }
@@ -686,12 +682,8 @@ public abstract class Varargs {
if (start == 1) if (start == 1)
return this; return this;
if (start > length) if (start > length)
return LuaValue.NONE; return more.subargs(start - length);
if (start == length) return LuaValue.varargsOf(v, offset + start - 1, length - (start - 1), more);
return v[offset + length - 1];
if (start == length - 1)
return new PairVarargs(v[offset + length - 2], v[offset + length - 1]);
return new ArrayPartVarargs(v, offset + start - 1, length - (start - 1));
} }
} }
} }

171
test/junit/org/luaj/vm2/VarargsTest.java
View File

@@ -105,78 +105,111 @@ public class VarargsTest extends TestCase {
expectNegSubargsError(NONE); expectNegSubargsError(NONE);
expectNegSubargsError(NIL); expectNegSubargsError(NIL);
} }
static void standardTestsA_G(Varargs a_g) {
expectEquals(A_G, a_g);
expectEquals(A_G, a_g.subargs(1));
expectEquals(C_G, a_g.subargs(3).subargs(1));
expectEquals(E_G, a_g.subargs(5));
expectEquals(E_G, a_g.subargs(5).subargs(1));
expectEquals(FG, a_g.subargs(6));
expectEquals(FG, a_g.subargs(6).subargs(1));
expectEquals(G, a_g.subargs(7));
expectEquals(G, a_g.subargs(7).subargs(1));
expectEquals(NONE, a_g.subargs(8));
expectEquals(NONE, a_g.subargs(8).subargs(1));
standardTestsC_G(A_G.subargs(3));
}
static void standardTestsC_G(Varargs c_g) {
expectEquals(C_G, c_g.subargs(1));
expectEquals(E_G, c_g.subargs(3));
expectEquals(E_G, c_g.subargs(3).subargs(1));
expectEquals(FG, c_g.subargs(4));
expectEquals(FG, c_g.subargs(4).subargs(1));
expectEquals(G, c_g.subargs(5));
expectEquals(G, c_g.subargs(5).subargs(1));
expectEquals(NONE, c_g.subargs(6));
expectEquals(NONE, c_g.subargs(6).subargs(1));
standardTestsE_G(c_g.subargs(3));
}
static void standardTestsE_G(Varargs e_g) {
expectEquals(E_G, e_g.subargs(1));
expectEquals(FG, e_g.subargs(2));
expectEquals(FG, e_g.subargs(2).subargs(1));
expectEquals(G, e_g.subargs(3));
expectEquals(G, e_g.subargs(3).subargs(1));
expectEquals(NONE, e_g.subargs(4));
expectEquals(NONE, e_g.subargs(4).subargs(1));
standardTestsFG(e_g.subargs(2));
}
static void standardTestsFG(Varargs fg) {
expectEquals(FG, fg.subargs(1));
expectEquals(G, fg.subargs(2));
expectEquals(G, fg.subargs(2).subargs(1));
expectEquals(NONE, fg.subargs(3));
expectEquals(NONE, fg.subargs(3).subargs(1));
}
static void standardTestsNone(Varargs none) {
expectEquals(NONE, none.subargs(1));
expectEquals(NONE, none.subargs(2));
}
public void testVarargsSubargs() { public void testVarargsSubargs() {
expectEquals(A_G, A_G.subargs(1)); standardTestsA_G(A_G);
expectEquals(A_G, A_G_alt.subargs(1)); standardTestsA_G(A_G_alt);
expectEquals(C_G, A_G.subargs(3)); standardTestsC_G(C_G);
expectEquals(C_G, A_G_alt.subargs(3)); standardTestsC_G(C_G_alt);
expectEquals(C_G, A_G.subargs(3).subargs(1)); standardTestsE_G(E_G);
expectEquals(C_G, A_G_alt.subargs(3).subargs(1)); standardTestsE_G(E_G_alt);
expectEquals(E_G, A_G.subargs(5)); standardTestsFG(FG);
expectEquals(E_G, A_G_alt.subargs(5)); standardTestsFG(FG_alt);
expectEquals(E_G, A_G.subargs(5).subargs(1)); standardTestsNone(NONE);
expectEquals(E_G, A_G_alt.subargs(5).subargs(1)); }
expectEquals(FG, A_G.subargs(6));
expectEquals(FG, A_G_alt.subargs(6)); public void testVarargsMore() {
expectEquals(FG, A_G.subargs(6).subargs(1)); Varargs a_g;
expectEquals(FG, A_G_alt.subargs(6).subargs(1)); a_g = LuaValue.varargsOf(new LuaValue[] { A, }, LuaValue.varargsOf( new LuaValue[] { B, C, D, E, F, G }));
expectEquals(G, A_G.subargs(7)); standardTestsA_G(a_g);
expectEquals(G, A_G_alt.subargs(7)); a_g = LuaValue.varargsOf(new LuaValue[] { A, B, }, LuaValue.varargsOf( new LuaValue[] { C, D, E, F, G }));
expectEquals(G, A_G.subargs(7).subargs(1)); standardTestsA_G(a_g);
expectEquals(G, A_G_alt.subargs(7).subargs(1)); a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, }, LuaValue.varargsOf( new LuaValue[] { D, E, F, G }));
expectEquals(NONE, A_G.subargs(8)); standardTestsA_G(a_g);
expectEquals(NONE, A_G_alt.subargs(8)); a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, D, }, LuaValue.varargsOf(E, F, G));
expectEquals(NONE, A_G.subargs(8).subargs(1)); standardTestsA_G(a_g);
expectEquals(NONE, A_G_alt.subargs(8).subargs(1)); a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, D, E }, LuaValue.varargsOf( F, G ));
standardTestsA_G(a_g);
a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, D, E, F, }, G );
standardTestsA_G(a_g);
}
public void testPairVarargsMore() {
Varargs a_g = new Varargs.PairVarargs(A,
new Varargs.PairVarargs(B,
new Varargs.PairVarargs(C,
new Varargs.PairVarargs(D,
new Varargs.PairVarargs(E,
new Varargs.PairVarargs(F, G))))));
standardTestsA_G(a_g);
}
expectEquals(C_G, C_G.subargs(1)); public void testArrayPartMore() {
expectEquals(C_G, C_G_alt.subargs(1)); Varargs a_g;
expectEquals(E_G, C_G.subargs(3)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 1, new Varargs.ArrayPartVarargs(Z_H_array, 2, 6));
expectEquals(E_G, C_G_alt.subargs(3)); standardTestsA_G(a_g);
expectEquals(E_G, C_G.subargs(3).subargs(1)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 2, new Varargs.ArrayPartVarargs(Z_H_array, 3, 5));
expectEquals(E_G, C_G_alt.subargs(3).subargs(1)); standardTestsA_G(a_g);
expectEquals(FG, C_G.subargs(4)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 3, new Varargs.ArrayPartVarargs(Z_H_array, 4, 4));
expectEquals(FG, C_G_alt.subargs(4)); standardTestsA_G(a_g);
expectEquals(FG, C_G.subargs(4).subargs(1)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 4, new Varargs.ArrayPartVarargs(Z_H_array, 5, 3));
expectEquals(FG, C_G_alt.subargs(4).subargs(1)); standardTestsA_G(a_g);
expectEquals(G, C_G.subargs(5)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 5, new Varargs.ArrayPartVarargs(Z_H_array, 6, 2));
expectEquals(G, C_G_alt.subargs(5)); standardTestsA_G(a_g);
expectEquals(G, C_G.subargs(5).subargs(1)); a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 6, new Varargs.ArrayPartVarargs(Z_H_array, 7, 1));
expectEquals(G, C_G_alt.subargs(5).subargs(1)); standardTestsA_G(a_g);
expectEquals(NONE, C_G.subargs(6));
expectEquals(NONE, C_G_alt.subargs(6));
expectEquals(NONE, C_G.subargs(6).subargs(1));
expectEquals(NONE, C_G_alt.subargs(6).subargs(1));
expectEquals(E_G, E_G.subargs(1));
expectEquals(E_G, E_G_alt.subargs(1));
expectEquals(FG, E_G.subargs(2));
expectEquals(FG, E_G_alt.subargs(2));
expectEquals(FG, E_G.subargs(2).subargs(1));
expectEquals(FG, E_G_alt.subargs(2).subargs(1));
expectEquals(G, E_G.subargs(3));
expectEquals(G, E_G_alt.subargs(3));
expectEquals(G, E_G.subargs(3).subargs(1));
expectEquals(G, E_G_alt.subargs(3).subargs(1));
expectEquals(NONE, E_G.subargs(4));
expectEquals(NONE, E_G_alt.subargs(4));
expectEquals(NONE, E_G.subargs(4).subargs(1));
expectEquals(NONE, E_G_alt.subargs(4).subargs(1));
expectEquals(FG, FG.subargs(1));
expectEquals(FG, FG_alt.subargs(1));
expectEquals(G, FG.subargs(2));
expectEquals(G, FG_alt.subargs(2));
expectEquals(G, FG.subargs(2).subargs(1));
expectEquals(G, FG_alt.subargs(2).subargs(1));
expectEquals(NONE, FG.subargs(3));
expectEquals(NONE, FG_alt.subargs(3));
expectEquals(NONE, FG.subargs(3).subargs(1));
expectEquals(NONE, FG_alt.subargs(3).subargs(1));
expectEquals(NONE, NONE.subargs(1));
expectEquals(NONE, NONE.subargs(2));
} }
static void expectNegSubargsError(Varargs v) { static void expectNegSubargsError(Varargs v) {