Cleanup Tests with JUnit5 and move to different modules

luaj-test/pom.xml

@@ -26,8 +26,20 @@
 			<version>${project.version}</version>
 		</dependency>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.microemu</groupId>
+			<artifactId>microemulator</artifactId>
+			<version>2.0.4</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.microemu</groupId>
+			<artifactId>microemu-jsr-75</artifactId>
+			<version>2.0.4</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>

luaj-test/src/test/java/org/luaj/CompatibiltyTest.java

@@ -19,10 +19,19 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.TestSuite;
+package org.luaj;
 
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.luaj.vm2.LuaBoolean;
+import org.luaj.vm2.LuaFunction;
+import org.luaj.vm2.LuaNil;
+import org.luaj.vm2.LuaNumber;
+import org.luaj.vm2.LuaString;
+import org.luaj.vm2.LuaThread;
+import org.luaj.vm2.LuaValue;
 import org.luaj.vm2.luajc.LuaJC;
 
 /**
@@ -31,24 +40,21 @@ import org.luaj.vm2.luajc.LuaJC;
  * Results are compared for exact match with the installed C-based lua
  * environment.
  */
-public class CompatibiltyTest extends TestSuite {
+public class CompatibiltyTest {
 
-	private static final String dir = "";
-
-	abstract protected static class CompatibiltyTestSuite extends ScriptDrivenTest {
+	abstract static class CompatibiltyTestCase extends PlatformTestCase {
 		LuaValue savedStringMetatable;
 
-		protected CompatibiltyTestSuite(PlatformType platform) {
-			super(platform, dir);
-		}
-
-		protected void setUp() throws Exception {
+		@BeforeEach
+		@Override
+		protected void setUp() {
 			savedStringMetatable = LuaString.s_metatable;
+			setBaseDir("compatibility");
 			super.setUp();
 		}
 
-		protected void tearDown() throws Exception {
-			super.tearDown();
+		@AfterEach
+		protected void tearDown() {
 			LuaNil.s_metatable = null;
 			LuaBoolean.s_metatable = null;
 			LuaNumber.s_metatable = null;
@@ -57,79 +63,94 @@ public class CompatibiltyTest extends TestSuite {
 			LuaString.s_metatable = savedStringMetatable;
 		}
 
-		public void testBaseLib() { runTest("baselib"); }
+		@Test
+		void testBaseLib() { runTest("baselib"); }
 
-		public void testCoroutineLib() { runTest("coroutinelib"); }
+		@Test
+		void testCoroutineLib() { runTest("coroutinelib"); }
 
-		public void testDebugLib() { runTest("debuglib"); }
+		@Test
+		void testDebugLib() { runTest("debuglib"); }
 
-		public void testErrors() { runTest("errors"); }
+		@Test
+		void testErrors() { runTest("errors"); }
 
-		public void testFunctions() { runTest("functions"); }
+		@Test
+		void testFunctions() { runTest("functions"); }
 
-		public void testIoLib() { runTest("iolib"); }
+		@Test
+		void testIoLib() { runTest("iolib"); }
 
-		public void testManyUpvals() { runTest("manyupvals"); }
+		@Test
+		void testManyUpvals() { runTest("manyupvals"); }
 
-		public void testMathLib() { runTest("mathlib"); }
+		@Test
+		void testMathLib() { runTest("mathlib"); }
 
-		public void testMetatags() { runTest("metatags"); }
+		@Test
+		void testMetatags() { runTest("metatags"); }
 
-		public void testOsLib() { runTest("oslib"); }
+		@Test
+		void testOsLib() { runTest("oslib"); }
 
-		public void testStringLib() { runTest("stringlib"); }
+		@Test
+		void testStringLib() { runTest("stringlib"); }
 
-		public void testTableLib() { runTest("tablelib"); }
+		@Test
+		void testTableLib() { runTest("tablelib"); }
 
-		public void testTailcalls() { runTest("tailcalls"); }
+		@Test
+		void testTailcalls() { runTest("tailcalls"); }
 
-		public void testUpvalues() { runTest("upvalues"); }
+		@Test
+		void testUpvalues() { runTest("upvalues"); }
 
-		public void testVm() { runTest("vm"); }
+		@Test
+		void testVm() { runTest("vm"); }
 	}
 
-	public static TestSuite suite() {
-		TestSuite suite = new TestSuite("Compatibility Tests");
-		suite.addTest(new TestSuite(JseCompatibilityTest.class, "JSE Compatibility Tests"));
-		suite.addTest(new TestSuite(JmeCompatibilityTest.class, "JME Compatibility Tests"));
-		suite.addTest(new TestSuite(LuaJCCompatibilityTest.class, "LuaJC Compatibility Tests"));
-		return suite;
-	}
+	@Nested
+	public static class JmeCompatibilityTest extends CompatibiltyTestCase {
 
-	public static class JmeCompatibilityTest extends CompatibiltyTestSuite {
-		public JmeCompatibilityTest() {
-			super(ScriptDrivenTest.PlatformType.JME);
-		}
-
-		protected void setUp() throws Exception {
+		@BeforeEach
+		@Override
+		protected void setUp() {
+			setPlatform(PlatformTestCase.PlatformType.JME);
 			System.setProperty("JME", "true");
 			super.setUp();
 		}
+
+		// Emulator cannot create files for writing
+		@Override
+		void testIoLib() {}
 	}
 
-	public static class JseCompatibilityTest extends CompatibiltyTestSuite {
-		public JseCompatibilityTest() {
-			super(ScriptDrivenTest.PlatformType.JSE);
-		}
+	@Nested
+	public static class JseCompatibilityTest extends CompatibiltyTestCase {
 
-		protected void setUp() throws Exception {
-			super.setUp();
+		@BeforeEach
+		@Override
+		protected void setUp() {
+			setPlatform(PlatformTestCase.PlatformType.JSE);
 			System.setProperty("JME", "false");
+			super.setUp();
 		}
 	}
 
-	public static class LuaJCCompatibilityTest extends CompatibiltyTestSuite {
-		public LuaJCCompatibilityTest() {
-			super(ScriptDrivenTest.PlatformType.LUAJIT);
-		}
+	@Nested
+	public static class LuaJCCompatibilityTest extends CompatibiltyTestCase {
 
-		protected void setUp() throws Exception {
-			super.setUp();
+		@BeforeEach
+		@Override
+		protected void setUp() {
+			setPlatform(PlatformTestCase.PlatformType.LUAJIT);
 			System.setProperty("JME", "false");
+			super.setUp();
 			LuaJC.install(globals);
 		}
 
 		// not supported on this platform - don't test
-		public void testDebugLib() {}
+		@Override
+		void testDebugLib() {}
 	}
 }

luaj-test/src/test/java/org/luaj/CompilerTest.java

@@ -0,0 +1,95 @@
+package org.luaj;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class CompilerTest extends CompilingTestCase {
+
+	@BeforeEach
+	@Override
+	protected void setUp() {
+		setBaseDir("lua5.2.1-tests");
+		super.setUp();
+	}
+
+	@Test
+	void testAll() { doTest("all"); }
+
+	@Test
+	void testApi() { doTest("api"); }
+
+	@Test
+	void testAttrib() { doTest("attrib"); }
+
+	@Test
+	void testBig() { doTest("big"); }
+
+	@Test
+	void testBitwise() { doTest("bitwise"); }
+
+	@Test
+	void testCalls() { doTest("calls"); }
+
+	@Test
+	void testChecktable() { doTest("checktable"); }
+
+	@Test
+	void testClosure() { doTest("closure"); }
+
+	@Test
+	void testCode() { doTest("code"); }
+
+	@Test
+	void testConstruct() { doTest("constructs"); }
+
+	@Test
+	void testCoroutine() { doTest("coroutine"); }
+
+	@Test
+	void testDb() { doTest("db"); }
+
+	@Test
+	void testErrors() { doTest("errors"); }
+
+	@Test
+	void testEvents() { doTest("events"); }
+
+	@Test
+	void testFiles() { doTest("files"); }
+
+	@Test
+	void testGc() { doTest("gc"); }
+
+	@Test
+	void testGoto() { doTest("goto"); }
+
+	@Test
+	void testLiterals() { doTest("literals"); }
+
+	@Test
+	void testLocals() { doTest("locals"); }
+
+	@Test
+	void testMain() { doTest("main"); }
+
+	@Test
+	void testMath() { doTest("math"); }
+
+	@Test
+	void testNextvar() { doTest("nextvar"); }
+
+	@Test
+	void testPm() { doTest("pm"); }
+
+	@Test
+	void testSort() { doTest("sort"); }
+
+	@Test
+	void testStrings() { doTest("strings"); }
+
+	@Test
+	void testVararg() { doTest("vararg"); }
+
+	@Test
+	void testVerybig() { doTest("verybig"); }
+}

luaj-test/src/test/java/org/luaj/CompilingTestCase.java

@@ -0,0 +1,53 @@
+package org.luaj;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import org.luaj.vm2.Print;
+import org.luaj.vm2.Prototype;
+import org.luaj.vm2.compiler.DumpState;
+
+abstract class CompilingTestCase extends ResourcesTestCase {
+
+	protected void doTest(String name) {
+		try {
+			// compile in memory
+			Prototype p = globals.loadPrototype(inputStreamOfLua(name), "@" + name + ".lua", "bt");
+			String actual = protoToString(p);
+
+			// load expected value from jar
+			Prototype e = globals.loadPrototype(inputStreamOfBytecode(name), name, "b");
+			String expected = protoToString(e);
+
+			// compare results
+			assertEquals(expected, actual);
+
+			// dump into memory
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DumpState.dump(p, baos, false);
+			ByteArrayInputStream dumped = new ByteArrayInputStream(baos.toByteArray());
+
+			// re-undump
+			Prototype p2 = globals.loadPrototype(dumped, name, "b");
+			String actual2 = protoToString(p2);
+
+			// compare again
+			assertEquals(actual, actual2);
+
+		} catch (Exception e) {
+			fail(e.toString());
+		}
+	}
+
+	private String protoToString(Prototype p) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		PrintStream ps = new PrintStream(baos);
+		Print.ps = ps;
+		Print.printFunction(p, true);
+		return baos.toString();
+	}
+}

luaj-test/src/test/java/org/luaj/ErrorsTest.java

@@ -19,31 +19,34 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  ******************************************************************************/
-package org.luaj.vm2;
+package org.luaj;
 
 import java.io.IOException;
 import java.io.InputStream;
 
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
 /**
  * Test argument type check errors
  * 
  * Results are compared for exact match with the installed C-based lua
  * environment.
  */
-public class ErrorsTest extends ScriptDrivenTest {
+class ErrorsTest extends PlatformTestCase {
 
-	private static final String dir = "errors/";
-
-	public ErrorsTest() {
-		super(ScriptDrivenTest.PlatformType.JSE, dir);
-	}
-
-	protected void setUp() throws Exception {
+	@BeforeEach
+	@Override
+	protected void setUp() {
+		setBaseDir("errors");
+		setPlatform(PlatformTestCase.PlatformType.JSE);
 		super.setUp();
 	}
 
-	public void testBaseLibArgs() {
+	@Test
+	void testBaseLibArgs() {
 		globals.STDIN = new InputStream() {
+			@Override
 			public int read() throws IOException {
 				return -1;
 			}
@@ -51,20 +54,28 @@ public class ErrorsTest extends ScriptDrivenTest {
 		runTest("baselibargs");
 	}
 
-	public void testCoroutineLibArgs() { runTest("coroutinelibargs"); }
+	@Test
+	void testCoroutineLibArgs() { runTest("coroutinelibargs"); }
 
-	public void testDebugLibArgs() { runTest("debuglibargs"); }
+	@Test
+	void testDebugLibArgs() { runTest("debuglibargs"); }
 
-	public void testIoLibArgs() { runTest("iolibargs"); }
+	@Test
+	void testIoLibArgs() { runTest("iolibargs"); }
 
-	public void testMathLibArgs() { runTest("mathlibargs"); }
+	@Test
+	void testMathLibArgs() { runTest("mathlibargs"); }
 
-	public void testModuleLibArgs() { runTest("modulelibargs"); }
+	@Test
+	void testModuleLibArgs() { runTest("modulelibargs"); }
 
-	public void testOperators() { runTest("operators"); }
+	@Test
+	void testOperators() { runTest("operators"); }
 
-	public void testStringLibArgs() { runTest("stringlibargs"); }
+	@Test
+	void testStringLibArgs() { runTest("stringlibargs"); }
 
-	public void testTableLibArgs() { runTest("tablelibargs"); }
+	@Test
+	void testTableLibArgs() { runTest("tablelibargs"); }
 
 }

luaj-test/src/test/java/org/luaj/LuaParserTest.java

@@ -0,0 +1,20 @@
+package org.luaj;
+
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.luaj.vm2.parser.LuaParser;
+
+public class LuaParserTest extends CompilerTest {
+
+	@Override
+	protected void doTest(String name) {
+		try {
+			LuaParser parser = new LuaParser(inputStreamOfLua(name), ISO_8859_1);
+			parser.Chunk();
+		} catch (Exception e) {
+			fail(e.getMessage());
+			e.printStackTrace();
+		}
+	}
+}

luaj-test/src/test/java/org/luaj/PlatformTestCase.java

@@ -19,135 +19,62 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  ******************************************************************************/
-package org.luaj.vm2;
+package org.luaj;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
-import java.net.MalformedURLException;
-import java.net.URL;
 
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.ResourceFinder;
+import org.junit.jupiter.api.BeforeEach;
+import org.luaj.vm2.Globals;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.lib.jme.JmePlatform;
+import org.luaj.vm2.lib.jse.JsePlatform;
 import org.luaj.vm2.lib.jse.JseProcess;
 import org.luaj.vm2.luajc.LuaJC;
 
-abstract public class ScriptDrivenTest extends TestCase implements ResourceFinder {
+abstract class PlatformTestCase extends ResourcesTestCase {
 	public static final boolean nocompile = "true".equals(System.getProperty("nocompile"));
 
 	public enum PlatformType {
 		JME, JSE, LUAJIT,
 	}
 
-	private final PlatformType platform;
-	private final String       subdir;
-	protected Globals          globals;
-
-	static final String zipdir  = "test/lua/";
-	static final String zipfile = "luaj3.0-tests.zip";
-
-	protected ScriptDrivenTest(PlatformType platform, String subdir) {
-		this.platform = platform;
-		this.subdir = subdir;
-		initGlobals();
-	}
+	private PlatformType platform;
 
 	private void initGlobals() {
 		switch (platform) {
 		default:
 		case JSE:
 		case LUAJIT:
-			globals = org.luaj.vm2.lib.jse.JsePlatform.debugGlobals();
+			globals = JsePlatform.debugGlobals();
 			break;
 		case JME:
-			globals = org.luaj.vm2.lib.jme.JmePlatform.debugGlobals();
+			globals = JmePlatform.debugGlobals();
 			break;
 		}
 	}
 
-	protected void setUp() throws Exception {
-		super.setUp();
+	@BeforeEach
+	@Override
+	protected void setUp() {
 		initGlobals();
-		globals.finder = this;
-	}
-
-	// ResourceFinder implementation.
-	public InputStream findResource(String filename) {
-		InputStream is = findInPlainFile(filename);
-		if (is != null)
-			return is;
-		is = findInPlainFileAsResource("", filename);
-		if (is != null)
-			return is;
-		is = findInPlainFileAsResource("/", filename);
-		if (is != null)
-			return is;
-		is = findInZipFileAsPlainFile(filename);
-		if (is != null)
-			return is;
-		is = findInZipFileAsResource("", filename);
-		if (is != null)
-			return is;
-		is = findInZipFileAsResource("/", filename);
-		return is;
-	}
-
-	private InputStream findInPlainFileAsResource(String prefix, String filename) {
-		return getClass().getResourceAsStream(prefix+subdir+filename);
-	}
-
-	private InputStream findInPlainFile(String filename) {
-		try {
-			File f = new File(zipdir+subdir+filename);
-			if (f.exists())
-				return new FileInputStream(f);
-		} catch (IOException ioe) {
-			ioe.printStackTrace();
-		}
-		return null;
-	}
-
-	private InputStream findInZipFileAsPlainFile(String filename) {
-		URL zip;
-		File file = new File(zipdir+zipfile);
-		try {
-			if (file.exists()) {
-				zip = file.toURI().toURL();
-				String path = "jar:" + zip.toExternalForm() + "!/" + subdir + filename;
-				URL url = new URL(path);
-				return url.openStream();
-			}
-		} catch (MalformedURLException e) {
-			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// Ignore and return null.
-		} catch (IOException ioe) {
-			ioe.printStackTrace();
-		}
-		return null;
-	}
-
-	private InputStream findInZipFileAsResource(String prefix, String filename) {
-		URL zip = null;
-		zip = getClass().getResource(zipfile);
-		if (zip != null)
+		globals.finder = filename -> {
 			try {
-				String path = "jar:" + zip.toExternalForm() + "!/" + subdir + filename;
-				URL url = new URL(path);
-				return url.openStream();
-			} catch (IOException ioe) {
-				ioe.printStackTrace();
+				return inputStreamOfFile(filename);
+			} catch (IOException e) {
+				return null;
 			}
-		return null;
+		};
 	}
 
-	// */
+	protected void setPlatform(PlatformType platform) { this.platform = platform; }
+
 	protected void runTest(String testName) {
 		try {
 			// override print()
@@ -179,8 +106,8 @@ abstract public class ScriptDrivenTest extends TestCase implements ResourceFinde
 		}
 	}
 
-	protected LuaValue loadScript(String name, Globals globals) throws IOException {
-		InputStream script = this.findResource(name + ".lua");
+	private LuaValue loadScript(String name, Globals globals) throws IOException {
+		InputStream script = inputStreamOfLua(name);
 		if (script == null)
 			fail("Could not load script for test case: " + name);
 		try {
@@ -205,7 +132,7 @@ abstract public class ScriptDrivenTest extends TestCase implements ResourceFinde
 	}
 
 	private String getExpectedOutput(final String name) throws IOException, InterruptedException {
-		InputStream output = this.findResource(name + ".out");
+		InputStream output = inputStreamOfResult(name);
 		if (output != null)
 			try {
 				return readString(output);
@@ -219,7 +146,7 @@ abstract public class ScriptDrivenTest extends TestCase implements ResourceFinde
 	}
 
 	private String executeLuaProcess(String name) throws IOException, InterruptedException {
-		InputStream script = findResource(name + ".lua");
+		InputStream script = inputStreamOfLua(name);
 		if (script == null)
 			throw new IOException("Failed to find source file " + script);
 		try {
@@ -233,7 +160,7 @@ abstract public class ScriptDrivenTest extends TestCase implements ResourceFinde
 		}
 	}
 
-	public static String collectProcessOutput(String[] cmd, final InputStream input)
+	private static String collectProcessOutput(String[] cmd, final InputStream input)
 		throws IOException, InterruptedException {
 		Runtime r = Runtime.getRuntime();
 		final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -241,7 +168,7 @@ abstract public class ScriptDrivenTest extends TestCase implements ResourceFinde
 		return new String(baos.toByteArray());
 	}
 
-	private String readString(InputStream is) throws IOException {
+	private static String readString(InputStream is) throws IOException {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		copy(is, baos);
 		return new String(baos.toByteArray());

luaj-test/src/test/java/org/luaj/RegressionsTest.java

@@ -0,0 +1,47 @@
+package org.luaj;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Framework to add regression tests as problem areas are found.
+ * 
+ * To add a new regression test: 1) run "unpack.sh" in the project root 2) add a
+ * new "lua" file in the "regressions" subdirectory 3) run "repack.sh" in the
+ * project root 4) add a line to the source file naming the new test
+ * 
+ * After adding a test, check in the zip file rather than the individual
+ * regression test files.
+ * 
+ * @author jrosebor
+ */
+class RegressionsTest extends CompilingTestCase {
+
+	@BeforeEach
+	@Override
+	protected void setUp() {
+		setBaseDir("regressions");
+		super.setUp();
+	}
+
+	@Test
+	void testModulo() { doTest("modulo"); }
+
+	@Test
+	void testConstruct() { doTest("construct"); }
+
+	@Test
+	void testBigAttrs() { doTest("bigattr"); }
+
+	@Test
+	void testControlChars() { doTest("controlchars"); }
+
+	@Test
+	void testComparators() { doTest("comparators"); }
+
+	@Test
+	void testMathRandomseed() { doTest("mathrandomseed"); }
+
+	@Test
+	void testVarargs() { doTest("varargs"); }
+}

luaj-test/src/test/java/org/luaj/ResourcesTestCase.java

@@ -0,0 +1,38 @@
+package org.luaj;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.luaj.vm2.Globals;
+import org.luaj.vm2.lib.jse.JsePlatform;
+
+abstract class ResourcesTestCase {
+
+	private String baseDir;
+
+	protected Globals globals;
+
+	@BeforeEach
+	protected void setUp() {
+		globals = JsePlatform.standardGlobals();
+	}
+
+	protected void setBaseDir(String baseDir) { this.baseDir = baseDir; }
+
+	protected InputStream inputStreamOfFile(String file) throws IOException {
+		return getClass().getClassLoader().getResourceAsStream(baseDir + "/" + file);
+	}
+
+	protected InputStream inputStreamOfLua(String name) throws IOException {
+		return inputStreamOfFile(name + ".lua");
+	}
+
+	protected InputStream inputStreamOfResult(String name) throws IOException {
+		return inputStreamOfFile(name + ".out");
+	}
+
+	protected InputStream inputStreamOfBytecode(String name) throws IOException {
+		return inputStreamOfFile(name + ".lc");
+	}
+}

luaj-test/src/test/java/org/luaj/math/MathLibComparisonTest.java

@@ -1,26 +1,30 @@
-package org.luaj.vm2;
+package org.luaj.math;
 
-import junit.framework.TestCase;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.luaj.vm2.LuaError;
+import org.luaj.vm2.LuaValue;
 import org.luaj.vm2.lib.jme.JmePlatform;
 import org.luaj.vm2.lib.jse.JsePlatform;
 
-public class MathLibTest extends TestCase {
+class MathLibComparisonTest {
 
 	private LuaValue j2se;
 	private LuaValue j2me;
 	private boolean  supportedOnJ2me;
 
-	public MathLibTest() {
+	@BeforeEach
+	protected void setUp() {
 		j2se = JsePlatform.standardGlobals().get("math");
 		j2me = JmePlatform.standardGlobals().get("math");
-	}
-
-	protected void setUp() throws Exception {
 		supportedOnJ2me = true;
 	}
 
-	public void testMathDPow() {
+	@Test
+	void testMathDPow() {
 		assertEquals(1, j2mepow(2, 0), 0);
 		assertEquals(2, j2mepow(2, 1), 0);
 		assertEquals(8, j2mepow(2, 3), 0);
@@ -47,26 +51,30 @@ public class MathLibTest extends TestCase {
 		return j2me.get("pow").call(LuaValue.valueOf(x), LuaValue.valueOf(y)).todouble();
 	}
 
-	public void testAbs() {
+	@Test
+	void testAbs() {
 		tryMathOp("abs", 23.45);
 		tryMathOp("abs", -23.45);
 	}
 
-	public void testCos() {
+	@Test
+	void testCos() {
 		tryTrigOps("cos");
 	}
 
-	public void testCosh() {
+	@Test
+	void testCosh() {
 		supportedOnJ2me = false;
 		tryTrigOps("cosh");
 	}
 
-	public void testDeg() {
+	@Test
+	void testDeg() {
 		tryTrigOps("deg");
 	}
 
-	public void testExp() {
-		//supportedOnJ2me = false;
+	@Test
+	void testExp() {
 		tryMathOp("exp", 0);
 		tryMathOp("exp", 0.1);
 		tryMathOp("exp", .9);
@@ -78,7 +86,8 @@ public class MathLibTest extends TestCase {
 		tryMathOp("exp", -9);
 	}
 
-	public void testLog() {
+	@Test
+	void testLog() {
 		supportedOnJ2me = false;
 		tryMathOp("log", 0.1);
 		tryMathOp("log", .9);
@@ -90,7 +99,8 @@ public class MathLibTest extends TestCase {
 		tryMathOp("log", -9);
 	}
 
-	public void testRad() {
+	@Test
+	void testRad() {
 		tryMathOp("rad", 0);
 		tryMathOp("rad", 0.1);
 		tryMathOp("rad", .9);
@@ -106,16 +116,19 @@ public class MathLibTest extends TestCase {
 		tryMathOp("rad", -100);
 	}
 
-	public void testSin() {
+	@Test
+	void testSin() {
 		tryTrigOps("sin");
 	}
 
-	public void testSinh() {
+	@Test
+	void testSinh() {
 		supportedOnJ2me = false;
 		tryTrigOps("sinh");
 	}
 
-	public void testSqrt() {
+	@Test
+	void testSqrt() {
 		tryMathOp("sqrt", 0);
 		tryMathOp("sqrt", 0.1);
 		tryMathOp("sqrt", .9);
@@ -125,25 +138,30 @@ public class MathLibTest extends TestCase {
 		tryMathOp("sqrt", 100);
 	}
 
-	public void testTan() {
+	@Test
+	void testTan() {
 		tryTrigOps("tan");
 	}
 
-	public void testTanh() {
+	@Test
+	void testTanh() {
 		supportedOnJ2me = false;
 		tryTrigOps("tanh");
 	}
 
-	public void testAtan2() {
+	@Test
+	void testAtan2() {
 		supportedOnJ2me = false;
 		tryDoubleOps("atan2", false);
 	}
 
-	public void testFmod() {
+	@Test
+	void testFmod() {
 		tryDoubleOps("fmod", false);
 	}
 
-	public void testPow() {
+	@Test
+	void testPow() {
 		tryDoubleOps("pow", true);
 	}
 

luaj-test/src/test/java/org/luaj/vm2/AllTests.java

@@ -1,109 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.luaj.vm2.WeakTableTest.WeakKeyTableTest;
-import org.luaj.vm2.WeakTableTest.WeakKeyValueTableTest;
-import org.luaj.vm2.WeakTableTest.WeakValueTableTest;
-import org.luaj.vm2.compiler.CompilerUnitTests;
-import org.luaj.vm2.compiler.DumpLoadEndianIntTest;
-import org.luaj.vm2.compiler.LuaParserTests;
-import org.luaj.vm2.compiler.RegressionTests;
-import org.luaj.vm2.compiler.SimpleTests;
-import org.luaj.vm2.lib.jse.JsePlatformTest;
-import org.luaj.vm2.lib.jse.LuaJavaCoercionTest;
-import org.luaj.vm2.lib.jse.LuajavaAccessibleMembersTest;
-import org.luaj.vm2.lib.jse.LuajavaClassMembersTest;
-import org.luaj.vm2.lib.jse.OsLibTest;
-import org.luaj.vm2.script.ScriptEngineTests;
-
-public class AllTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite("All Tests for Luaj-vm2");
-
-		// vm tests
-		TestSuite vm = new TestSuite("VM Tests");
-		vm.addTestSuite(TypeTest.class);
-		vm.addTestSuite(UnaryBinaryOperatorsTest.class);
-		vm.addTestSuite(MetatableTest.class);
-		vm.addTestSuite(LuaOperationsTest.class);
-		vm.addTestSuite(StringTest.class);
-		vm.addTestSuite(OrphanedThreadTest.class);
-		vm.addTestSuite(VarargsTest.class);
-		vm.addTestSuite(LoadOrderTest.class);
-		suite.addTest(vm);
-
-		// table tests
-		TestSuite table = new TestSuite("Table Tests");
-		table.addTestSuite(TableTest.class);
-		table.addTestSuite(TableHashTest.class);
-		table.addTestSuite(WeakValueTableTest.class);
-		table.addTestSuite(WeakKeyTableTest.class);
-		table.addTestSuite(WeakKeyValueTableTest.class);
-		suite.addTest(table);
-
-		// bytecode compilers regression tests
-		TestSuite bytecodetests = FragmentsTest.suite();
-		suite.addTest(bytecodetests);
-
-		// I/O tests
-		TestSuite io = new TestSuite("I/O Tests");
-		io.addTestSuite(BufferedStreamTest.class);
-		io.addTestSuite(UTF8StreamTest.class);
-		suite.addTest(io);
-
-		// prototype compiler
-		TestSuite compiler = new TestSuite("Lua Compiler Tests");
-		compiler.addTestSuite(CompilerUnitTests.class);
-		compiler.addTestSuite(DumpLoadEndianIntTest.class);
-		compiler.addTestSuite(LuaParserTests.class);
-		compiler.addTestSuite(RegressionTests.class);
-		compiler.addTestSuite(SimpleTests.class);
-		suite.addTest(compiler);
-
-		// library tests
-		TestSuite lib = new TestSuite("Library Tests");
-		lib.addTestSuite(JsePlatformTest.class);
-		lib.addTestSuite(LuajavaAccessibleMembersTest.class);
-		lib.addTestSuite(LuajavaClassMembersTest.class);
-		lib.addTestSuite(LuaJavaCoercionTest.class);
-		lib.addTestSuite(RequireClassTest.class);
-		lib.addTestSuite(OsLibTest.class);
-		suite.addTest(lib);
-
-		// Script engine tests.
-		TestSuite script = ScriptEngineTests.suite();
-		suite.addTest(script);
-
-		// compatiblity tests
-		TestSuite compat = CompatibiltyTest.suite();
-		suite.addTest(compat);
-		compat.addTestSuite(ErrorsTest.class);
-
-		return suite;
-	}
-
-}

luaj-test/src/test/java/org/luaj/vm2/BufferedStreamTest.java

@@ -1,114 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.io.ByteArrayInputStream;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals.BufferedStream;
-
-public class BufferedStreamTest extends TestCase {
-
-	public BufferedStreamTest() {}
-
-	private BufferedStream NewBufferedStream(int buflen, String contents) {
-		return new BufferedStream(buflen, new ByteArrayInputStream(contents.getBytes()));
-	}
-
-	protected void setUp() throws Exception {
-		super.setUp();
-	}
-
-	public void testReadEmptyStream() throws java.io.IOException {
-		BufferedStream bs = NewBufferedStream(4, "");
-		assertEquals(-1, bs.read());
-		assertEquals(-1, bs.read(new byte[10]));
-		assertEquals(-1, bs.read(new byte[10], 0, 10));
-	}
-
-	public void testReadByte() throws java.io.IOException {
-		BufferedStream bs = NewBufferedStream(2, "abc");
-		assertEquals('a', bs.read());
-		assertEquals('b', bs.read());
-		assertEquals('c', bs.read());
-		assertEquals(-1, bs.read());
-	}
-
-	public void testReadByteArray() throws java.io.IOException {
-		byte[] array = new byte[3];
-		BufferedStream bs = NewBufferedStream(4, "abcdef");
-		assertEquals(3, bs.read(array));
-		assertEquals("abc", new String(array));
-		assertEquals(1, bs.read(array));
-		assertEquals("d", new String(array, 0, 1));
-		assertEquals(2, bs.read(array));
-		assertEquals("ef", new String(array, 0, 2));
-		assertEquals(-1, bs.read());
-	}
-
-	public void testReadByteArrayOffsetLength() throws java.io.IOException {
-		byte[] array = new byte[10];
-		BufferedStream bs = NewBufferedStream(8, "abcdefghijklmn");
-		assertEquals(4, bs.read(array, 0, 4));
-		assertEquals("abcd", new String(array, 0, 4));
-		assertEquals(4, bs.read(array, 2, 8));
-		assertEquals("efgh", new String(array, 2, 4));
-		assertEquals(6, bs.read(array, 0, 10));
-		assertEquals("ijklmn", new String(array, 0, 6));
-		assertEquals(-1, bs.read());
-	}
-
-	public void testMarkOffsetBeginningOfStream() throws java.io.IOException {
-		byte[] array = new byte[4];
-		BufferedStream bs = NewBufferedStream(8, "abcdefghijkl");
-		assertEquals(true, bs.markSupported());
-		bs.mark(4);
-		assertEquals(4, bs.read(array));
-		assertEquals("abcd", new String(array));
-		bs.reset();
-		assertEquals(4, bs.read(array));
-		assertEquals("abcd", new String(array));
-		assertEquals(4, bs.read(array));
-		assertEquals("efgh", new String(array));
-		assertEquals(4, bs.read(array));
-		assertEquals("ijkl", new String(array));
-		assertEquals(-1, bs.read());
-	}
-
-	public void testMarkOffsetMiddleOfStream() throws java.io.IOException {
-		byte[] array = new byte[4];
-		BufferedStream bs = NewBufferedStream(8, "abcdefghijkl");
-		assertEquals(true, bs.markSupported());
-		assertEquals(4, bs.read(array));
-		assertEquals("abcd", new String(array));
-		bs.mark(4);
-		assertEquals(4, bs.read(array));
-		assertEquals("efgh", new String(array));
-		bs.reset();
-		assertEquals(4, bs.read(array));
-		assertEquals("efgh", new String(array));
-		assertEquals(4, bs.read(array));
-		assertEquals("ijkl", new String(array));
-		assertEquals(-1, bs.read());
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/FragmentsTest.java

@@ -1,401 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.io.Reader;
-import java.io.StringReader;
-
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-import org.luaj.vm2.lib.jse.JsePlatform;
-import org.luaj.vm2.luajc.LuaJC;
-
-/**
- * Test compilation of various fragments that have caused problems for jit
- * compiling during development.
- *
- */
-public class FragmentsTest extends TestSuite {
-
-	static final int TEST_TYPE_LUAC  = 0;
-	static final int TEST_TYPE_LUAJC = 1;
-
-	public static class JseFragmentsTest extends FragmentsTestCase {
-		public JseFragmentsTest() { super(TEST_TYPE_LUAC); }
-	}
-
-	public static class LuaJCFragmentsTest extends FragmentsTestCase {
-		public LuaJCFragmentsTest() { super(TEST_TYPE_LUAJC); }
-	}
-
-	public static TestSuite suite() {
-		TestSuite suite = new TestSuite("Compiler Fragments Tests");
-		suite.addTest(new TestSuite(JseFragmentsTest.class, "JSE Fragments Tests"));
-		suite.addTest(new TestSuite(LuaJCFragmentsTest.class, "LuaJC Fragments Tests"));
-		return suite;
-	}
-
-	abstract protected static class FragmentsTestCase extends TestCase {
-
-		final int TEST_TYPE;
-
-		protected FragmentsTestCase(int testType) {
-			this.TEST_TYPE = testType;
-		}
-
-		public void runFragment(Varargs expected, String script) {
-			try {
-				String name = getName();
-				Globals globals = JsePlatform.debugGlobals();
-				Reader reader = new StringReader(script);
-				LuaValue chunk;
-				switch (TEST_TYPE) {
-				case TEST_TYPE_LUAJC:
-					LuaJC.install(globals);
-					chunk = globals.load(reader, name);
-					break;
-				default:
-					Prototype p = globals.compilePrototype(reader, name);
-					chunk = new LuaClosure(p, globals);
-					Print.print(p);
-					break;
-				}
-				Varargs actual = chunk.invoke();
-				assertEquals(expected.narg(), actual.narg());
-				for (int i = 1; i <= actual.narg(); i++)
-					assertEquals(expected.arg(i), actual.arg(i));
-			} catch (Exception e) {
-				// TODO Auto-generated catch block
-				e.printStackTrace();
-				fail(e.toString());
-			}
-		}
-
-		public void testFirstArgNilExtended() {
-			runFragment(LuaValue.NIL, "function f1(a) print( 'f1:', a ) return a end\n" + "b = f1()\n" + "return b");
-		}
-
-		public void testSimpleForloop() {
-			runFragment(LuaValue.valueOf(77),
-				"for n,p in ipairs({77}) do\n" + "	print('n,p',n,p)\n" + "   return p\n" + "end\n");
-
-		}
-
-		public void testForloopParamUpvalues() {
-			runFragment(LuaValue.varargsOf(new LuaValue[] { LuaValue.valueOf(77), LuaValue.valueOf(1) }),
-				"for n,p in ipairs({77}) do\n" + "	print('n,p',n,p)\n" + "	foo = function()\n" + "		return p,n\n"
-					+ "	end\n" + "	return foo()\n" + "end\n");
-
-		}
-
-		public void testArgVarargsUseBoth() {
-			runFragment(
-				LuaValue
-					.varargsOf(new LuaValue[] { LuaValue.valueOf("a"), LuaValue.valueOf("b"), LuaValue.valueOf("c") }),
-				"function v(arg,...)\n" + "	return arg,...\n" + "end\n" + "return v('a','b','c')\n");
-		}
-
-		public void testArgParamUseNone() {
-			runFragment(LuaValue.valueOf("string"),
-				"function v(arg,...)\n" + "	return type(arg)\n" + "end\n" + "return v('abc')\n");
-		}
-
-		public void testSetlistVarargs() {
-			runFragment(LuaValue.valueOf("abc"),
-				"local f = function() return 'abc' end\n" + "local g = { f() }\n" + "return g[1]\n");
-		}
-
-		public void testSelfOp() {
-			runFragment(LuaValue.valueOf("bcd"), "local s = 'abcde'\n" + "return s:sub(2,4)\n");
-		}
-
-		public void testSetListWithOffsetAndVarargs() {
-			runFragment(LuaValue.valueOf(1003), "local bar = {1000, math.sqrt(9)}\n" + "return bar[1]+bar[2]\n");
-		}
-
-		public void testMultiAssign() {
-			// arargs evaluations are all done before assignments 
-			runFragment(
-				LuaValue
-					.varargsOf(new LuaValue[] { LuaValue.valueOf(111), LuaValue.valueOf(111), LuaValue.valueOf(111) }),
-				"a,b,c = 1,10,100\n" + "a,b,c = a+b+c, a+b+c, a+b+c\n" + "return a,b,c\n");
-		}
-
-		public void testUpvalues() {
-			runFragment(LuaValue.valueOf(999),
-				"local a = function(x)\n" + "  return function(y)\n" + "    return x + y\n" + "  end\n" + "end\n"
-					+ "local b = a(222)\n" + "local c = b(777)\n" + "print( 'c=', c )\n" + "return c\n");
-		}
-
-		public void testNonAsciiStringLiterals() {
-			runFragment(LuaValue.valueOf("7,8,12,10,9,11,133,222"), "local a='\\a\\b\\f\\n\\t\\v\\133\\222'\n"
-				+ "local t={string.byte(a,1,#a)}\n" + "return table.concat(t,',')\n");
-		}
-
-		public void testControlCharStringLiterals() {
-			runFragment(LuaValue.valueOf("97,0,98,18,99,18,100,18,48,101"), "local a='a\\0b\\18c\\018d\\0180e'\n"
-				+ "local t={string.byte(a,1,#a)}\n" + "return table.concat(t,',')\n");
-		}
-
-		public void testLoopVarNames() {
-			runFragment(LuaValue.valueOf(" 234,1,aa 234,2,bb"),
-				"local w = ''\n" + "function t()\n" + "	for f,var in ipairs({'aa','bb'}) do\n" + "		local s = 234\n"
-					+ "		w = w..' '..s..','..f..','..var\n" + "	end\n" + "end\n" + "t()\n" + "return w\n");
-
-		}
-
-		public void testForLoops() {
-			runFragment(LuaValue.valueOf("12345 357 963"),
-				"local s,t,u = '','',''\n" + "for m=1,5 do\n" + "	s = s..m\n" + "end\n" + "for m=3,7,2 do\n"
-					+ "	t = t..m\n" + "end\n" + "for m=9,3,-3 do\n" + "	u = u..m\n" + "end\n"
-					+ "return s..' '..t..' '..u\n");
-		}
-
-		public void testLocalFunctionDeclarations() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("function"), LuaValue.valueOf("nil")),
-				"local function aaa()\n" + "	return type(aaa)\n" + "end\n" + "local bbb = function()\n"
-					+ "	return type(bbb)\n" + "end\n" + "return aaa(),bbb()\n");
-		}
-
-		public void testNilsInTableConstructor() {
-			runFragment(LuaValue.valueOf("1=111 2=222 3=333 "),
-				"local t = { 111, 222, 333, nil, nil }\n" + "local s = ''\n" + "for i,v in ipairs(t) do \n"
-					+ "	s=s..tostring(i)..'='..tostring(v)..' '\n" + "end\n" + "return s\n");
-
-		}
-
-		public void testUnreachableCode() {
-			runFragment(LuaValue.valueOf(66),
-				"local function foo(x) return x * 2 end\n" + "local function bar(x, y)\n" + "	if x==y then\n"
-					+ "		return y\n" + "	else\n" + "		return foo(x)\n" + "	end\n" + "end\n"
-					+ "return bar(33,44)\n");
-
-		}
-
-		public void testVarargsWithParameters() {
-			runFragment(LuaValue.valueOf(222),
-				"local func = function(t,...)\n" + "	return (...)\n" + "end\n" + "return func(111,222,333)\n");
-		}
-
-		public void testNoReturnValuesPlainCall() {
-			runFragment(LuaValue.TRUE, "local testtable = {}\n" + "return pcall( function() testtable[1]=2 end )\n");
-		}
-
-		public void testVarargsInTableConstructor() {
-			runFragment(LuaValue.valueOf(222), "local function foo() return 111,222,333 end\n"
-				+ "local t = {'a','b',c='c',foo()}\n" + "return t[4]\n");
-		}
-
-		public void testVarargsInFirstArg() {
-			runFragment(LuaValue.valueOf(123), "function aaa(x) return x end\n" + "function bbb(y) return y end\n"
-				+ "function ccc(z) return z end\n" + "return ccc( aaa(bbb(123)), aaa(456) )\n");
-		}
-
-		public void testSetUpvalueTableInitializer() {
-			runFragment(LuaValue.valueOf("b"), "local aliases = {a='b'}\n" + "local foo = function()\n"
-				+ "	return aliases\n" + "end\n" + "return foo().a\n");
-		}
-
-		public void testLoadNilUpvalue() {
-			runFragment(LuaValue.NIL, "tostring = function() end\n" + "local pc \n" + "local pcall = function(...)\n"
-				+ "	pc(...)\n" + "end\n" + "return NIL\n");
-		}
-
-		public void testUpvalueClosure() {
-			runFragment(LuaValue.NIL, "print()\n" + "local function f2() end\n" + "local function f3()\n"
-				+ "	return f3\n" + "end\n" + "return NIL\n");
-		}
-
-		public void testUninitializedUpvalue() {
-			runFragment(LuaValue.NIL, "local f\n" + "do\n" + "	function g()\n" + "		print(f())\n" + "	end\n"
-				+ "end\n" + "return NIL\n");
-		}
-
-		public void testTestOpUpvalues() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf(1), LuaValue.valueOf(2), LuaValue.valueOf(3)),
-				"print( nil and 'T' or 'F' )\n" + "local a,b,c = 1,2,3\n" + "function foo()\n" + "	return a,b,c\n"
-					+ "end\n" + "return foo()\n");
-		}
-
-		public void testTestSimpleBinops() {
-			runFragment(
-				LuaValue.varargsOf(
-					new LuaValue[] { LuaValue.FALSE, LuaValue.FALSE, LuaValue.TRUE, LuaValue.TRUE, LuaValue.FALSE }),
-				"local a,b,c = 2,-2.5,0\n" + "return (a==c), (b==c), (a==a), (a>c), (b>0)\n");
-		}
-
-		public void testNumericForUpvalues() {
-			runFragment(LuaValue.valueOf(8), "for i = 3,4 do\n" + "	i = i + 5\n" + "	local a = function()\n"
-				+ "		return i\n" + "	end\n" + "	return a()\n" + "end\n");
-		}
-
-		public void testNumericForUpvalues2() {
-			runFragment(LuaValue.valueOf("222 222"),
-				"local t = {}\n" + "local template = [[123 456]]\n" + "for i = 1,2 do\n"
-					+ "	t[i] = template:gsub('%d', function(s)\n" + "		return i\n" + "	end)\n" + "end\n"
-					+ "return t[2]\n");
-		}
-
-		public void testReturnUpvalue() {
-			runFragment(LuaValue.varargsOf(new LuaValue[] { LuaValue.ONE, LuaValue.valueOf(5), }), "local a = 1\n"
-				+ "local b\n" + "function c()\n" + "	b=5\n" + "	return a\n" + "end\n" + "return c(),b\n");
-		}
-
-		public void testUninitializedAroundBranch() {
-			runFragment(LuaValue.valueOf(333),
-				"local state\n" + "if _G then\n" + "    state = 333\n" + "end\n" + "return state\n");
-		}
-
-		public void testLoadedNilUpvalue() {
-			runFragment(LuaValue.NIL, "local a = print()\n" + "local b = c and { d = e }\n" + "local f\n"
-				+ "local function g()\n" + "	return f\n" + "end\n" + "return g()\n");
-		}
-
-		public void testUpvalueInFirstSlot() {
-			runFragment(LuaValue.valueOf("foo"), "local p = {'foo'}\n" + "bar = function()\n" + "	return p \n"
-				+ "end\n" + "for i,key in ipairs(p) do\n" + "	print()\n" + "end\n" + "return bar()[1]");
-		}
-
-		public void testReadOnlyAndReadWriteUpvalues() {
-			runFragment(LuaValue.varargsOf(new LuaValue[] { LuaValue.valueOf(333), LuaValue.valueOf(222) }),
-				"local a = 111\n" + "local b = 222\n" + "local c = function()\n" + "	a = a + b\n"
-					+ "	return a,b\n" + "end\n" + "return c()\n");
-		}
-
-		public void testNestedUpvalues() {
-			runFragment(
-				LuaValue.varargsOf(new LuaValue[] { LuaValue.valueOf(5), LuaValue.valueOf(8), LuaValue.valueOf(9) }),
-				"local x = 3\n" + "local y = 5\n" + "local function f()\n" + "   return y\n" + "end\n"
-					+ "local function g(x1, y1)\n" + "   x = x1\n" + "   y = y1\n" + "	return x,y\n" + "end\n"
-					+ "return f(), g(8,9)\n" + "\n");
-		}
-
-		public void testLoadBool() {
-			runFragment(LuaValue.NONE, "print( type(foo)=='string' )\n" + "local a,b\n" + "if print() then\n"
-				+ "	b = function()\n" + "		return a\n" + "	end\n" + "end\n");
-		}
-
-		public void testBasicForLoop() {
-			runFragment(LuaValue.valueOf(2), "local data\n" + "for i = 1, 2 do\n" + "     data = i\n" + "end\n"
-				+ "local bar = function()\n" + "	return data\n" + "end\n" + "return bar()\n");
-		}
-
-		public void testGenericForMultipleValues() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf(3), LuaValue.valueOf(2), LuaValue.valueOf(1)),
-				"local iter = function() return 1,2,3,4 end\n" + "local foo  = function() return iter,5 end\n"
-					+ "for a,b,c in foo() do\n" + "    return c,b,a\n" + "end\n");
-		}
-
-		public void testPhiUpvalue() {
-			runFragment(LuaValue.valueOf(6), "local a = foo or 0\n" + "local function b(c)\n"
-				+ "	if c > a then a = c end\n" + "	return a\n" + "end\n" + "b(6)\n" + "return a\n");
-		}
-
-		public void testAssignReferUpvalues() {
-			runFragment(LuaValue.valueOf(123), "local entity = 234\n" + "local function c()\n" + "    return entity\n"
-				+ "end\n" + "entity = (a == b) and 123\n" + "if entity then\n" + "    return entity\n" + "end\n");
-		}
-
-		public void testSimpleRepeatUntil() {
-			runFragment(LuaValue.valueOf(5),
-				"local a\n" + "local w\n" + "repeat\n" + "	a = w\n" + "until not a\n" + "return 5\n");
-		}
-
-		public void testLoopVarUpvalues() {
-			runFragment(LuaValue.valueOf("b"),
-				"local env = {}\n" + "for a,b in pairs(_G) do\n" + "	c = function()\n" + "		return b\n"
-					+ "	end\n" + "end\n" + "local e = env\n" + "local f = {a='b'}\n" + "for k,v in pairs(f) do\n"
-					+ "	return env[k] or v\n" + "end\n");
-		}
-
-		public void testPhiVarUpvalue() {
-			runFragment(LuaValue.valueOf(2), "local a = 1\n" + "local function b()\n" + "    a = a + 1\n"
-				+ "    return function() end\n" + "end\n" + "for i in b() do\n" + "	a = 3\n" + "end\n" + "return a\n");
-		}
-
-		public void testUpvaluesInElseClauses() {
-			runFragment(LuaValue.valueOf(111),
-				"if a then\n" + "   foo(bar)\n" + "elseif _G then\n" + "    local x = 111\n" + "    if d then\n"
-					+ "        foo(bar)\n" + "    else\n" + "    	local y = function()\n" + "    		return x\n"
-					+ "        end\n" + "    	return y()\n" + "    end\n" + "end\n");
-		}
-
-		public void testUpvalueInDoBlock() {
-			runFragment(LuaValue.NONE,
-				"do\n" + "	local x = 10\n" + "	function g()\n" + "		return x\n" + "	end\n" + "end\n" + "g()\n");
-		}
-
-		public void testNullError() {
-			runFragment(LuaValue.varargsOf(LuaValue.FALSE, LuaValue.NIL), "return pcall(error)\n");
-		}
-
-		public void testFindWithOffset() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf(8), LuaValue.valueOf(5)), "string = \"abcdef:ghi\"\n"
-				+ "substring = string:sub(3)\n" + "idx = substring:find(\":\")\n" + "return #substring, idx\n");
-		}
-
-		public void testErrorArgIsString() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("string"), LuaValue.valueOf("c")),
-				"a,b = pcall(error, 'c'); return type(b), b\n");
-		}
-
-		public void testErrorArgIsNil() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("nil"), LuaValue.NIL),
-				"a,b = pcall(error); return type(b), b\n");
-		}
-
-		public void testErrorArgIsTable() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("table"), LuaValue.valueOf("d")),
-				"a,b = pcall(error, {c='d'}); return type(b), b.c\n");
-		}
-
-		public void testErrorArgIsNumber() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("string"), LuaValue.valueOf("1")),
-				"a,b = pcall(error, 1); return type(b), b\n");
-		}
-
-		public void testErrorArgIsBool() {
-			runFragment(LuaValue.varargsOf(LuaValue.valueOf("boolean"), LuaValue.TRUE),
-				"a,b = pcall(error, true); return type(b), b\n");
-		}
-
-		public void testBalancedMatchOnEmptyString() {
-			runFragment(LuaValue.NIL, "return (\"\"):match(\"%b''\")\n");
-		}
-
-		public void testReturnValueForTableRemove() {
-			runFragment(LuaValue.NONE, "return table.remove({ })");
-		}
-
-		public void testTypeOfTableRemoveReturnValue() {
-			runFragment(LuaValue.valueOf("nil"), "local k = table.remove({ }) return type(k)");
-		}
-
-		public void testVarargBugReport() {
-			runFragment(
-				LuaValue.varargsOf(new LuaValue[] { LuaValue.valueOf(1), LuaValue.valueOf(2), LuaValue.valueOf(3) }),
-				"local i = function(...) return ... end\n" + "local v1, v2, v3 = i(1, 2, 3)\n" + "return v1, v2, v3");
-
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/LoadOrderTest.java

@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.io.InputStream;
-import java.io.Reader;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.jse.JsePlatform;
-import org.luaj.vm2.server.Launcher;
-import org.luaj.vm2.server.LuajClassLoader;
-
-// Tests using class loading orders that have caused problems for some use cases.
-public class LoadOrderTest extends TestCase {
-
-	public void testLoadGlobalsFirst() {
-		Globals g = JsePlatform.standardGlobals();
-		assertNotNull(g);
-	}
-
-	public void testLoadStringFirst() {
-		LuaString BAR = LuaString.valueOf("bar");
-		assertNotNull(BAR);
-	}
-
-	public static class TestLauncherLoadStringFirst implements Launcher {
-		// Static initializer that causes LuaString->LuaValue->LuaString
-		private static final LuaString FOO = LuaString.valueOf("foo");
-
-		public Object[] launch(String script, Object[] arg) {
-			return new Object[] { FOO };
-		}
-
-		public Object[] launch(InputStream script, Object[] arg) {
-			return null;
-		}
-
-		public Object[] launch(Reader script, Object[] arg) {
-			return null;
-		}
-	}
-
-	public void testClassLoadsStringFirst() throws Exception {
-		Launcher launcher = LuajClassLoader.NewLauncher(TestLauncherLoadStringFirst.class);
-		Object[] results = launcher.launch("foo", null);
-		assertNotNull(results);
-	}
-
-}

luaj-test/src/test/java/org/luaj/vm2/LuaOperationsTest.java

@@ -1,180 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.io.Reader;
-import java.io.StringReader;
-import java.lang.reflect.InvocationTargetException;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.TypeTest.MyData;
-import org.luaj.vm2.compiler.LuaC;
-import org.luaj.vm2.lib.ZeroArgFunction;
-
-public class LuaOperationsTest extends TestCase {
-
-	private final int    sampleint          = 77;
-	private final long   samplelong         = 123400000000L;
-	private final double sampledouble       = 55.25;
-	private final String samplestringstring = "abcdef";
-	private final String samplestringint    = String.valueOf(sampleint);
-	private final String samplestringlong   = String.valueOf(samplelong);
-	private final String samplestringdouble = String.valueOf(sampledouble);
-	private final Object sampleobject       = new Object();
-	private final MyData sampledata         = new MyData();
-
-	private final LuaValue    somenil      = LuaValue.NIL;
-	private final LuaValue    sometrue     = LuaValue.TRUE;
-	private final LuaValue    somefalse    = LuaValue.FALSE;
-	private final LuaValue    zero         = LuaValue.ZERO;
-	private final LuaValue    intint       = LuaValue.valueOf(sampleint);
-	private final LuaValue    longdouble   = LuaValue.valueOf(samplelong);
-	private final LuaValue    doubledouble = LuaValue.valueOf(sampledouble);
-	private final LuaValue    stringstring = LuaValue.valueOf(samplestringstring);
-	private final LuaValue    stringint    = LuaValue.valueOf(samplestringint);
-	private final LuaValue    stringlong   = LuaValue.valueOf(samplestringlong);
-	private final LuaValue    stringdouble = LuaValue.valueOf(samplestringdouble);
-	private final LuaTable    table        = LuaValue
-		.listOf(new LuaValue[] { LuaValue.valueOf("aaa"), LuaValue.valueOf("bbb") });
-	private final LuaValue    somefunc     = new ZeroArgFunction() {
-												public LuaValue call() { return NONE; }
-											};
-	private final LuaThread   thread       = new LuaThread(new Globals(), somefunc);
-	private final Prototype   proto        = new Prototype(1);
-	private final LuaClosure  someclosure  = new LuaClosure(proto, table);
-	private final LuaUserdata userdataobj  = LuaValue.userdataOf(sampleobject);
-	private final LuaUserdata userdatacls  = LuaValue.userdataOf(sampledata);
-
-	private void throwsLuaError(String methodName, Object obj) {
-		try {
-			LuaValue.class.getMethod(methodName).invoke(obj);
-			fail("failed to throw LuaError as required");
-		} catch (InvocationTargetException e) {
-			if (!(e.getTargetException() instanceof LuaError))
-				fail("not a LuaError: " + e.getTargetException());
-			return; // pass
-		} catch (Exception e) {
-			fail("bad exception: " + e);
-		}
-	}
-
-	private void throwsLuaError(String methodName, Object obj, Object arg) {
-		try {
-			LuaValue.class.getMethod(methodName, LuaValue.class).invoke(obj, arg);
-			fail("failed to throw LuaError as required");
-		} catch (InvocationTargetException e) {
-			if (!(e.getTargetException() instanceof LuaError))
-				fail("not a LuaError: " + e.getTargetException());
-			return; // pass
-		} catch (Exception e) {
-			fail("bad exception: " + e);
-		}
-	}
-
-	public void testLen() {
-		throwsLuaError("len", somenil);
-		throwsLuaError("len", sometrue);
-		throwsLuaError("len", somefalse);
-		throwsLuaError("len", zero);
-		throwsLuaError("len", intint);
-		throwsLuaError("len", longdouble);
-		throwsLuaError("len", doubledouble);
-		assertEquals(LuaInteger.valueOf(samplestringstring.length()), stringstring.len());
-		assertEquals(LuaInteger.valueOf(samplestringint.length()), stringint.len());
-		assertEquals(LuaInteger.valueOf(samplestringlong.length()), stringlong.len());
-		assertEquals(LuaInteger.valueOf(samplestringdouble.length()), stringdouble.len());
-		assertEquals(LuaInteger.valueOf(2), table.len());
-		throwsLuaError("len", somefunc);
-		throwsLuaError("len", thread);
-		throwsLuaError("len", someclosure);
-		throwsLuaError("len", userdataobj);
-		throwsLuaError("len", userdatacls);
-	}
-
-	public void testLength() {
-		throwsLuaError("length", somenil);
-		throwsLuaError("length", sometrue);
-		throwsLuaError("length", somefalse);
-		throwsLuaError("length", zero);
-		throwsLuaError("length", intint);
-		throwsLuaError("length", longdouble);
-		throwsLuaError("length", doubledouble);
-		assertEquals(samplestringstring.length(), stringstring.length());
-		assertEquals(samplestringint.length(), stringint.length());
-		assertEquals(samplestringlong.length(), stringlong.length());
-		assertEquals(samplestringdouble.length(), stringdouble.length());
-		assertEquals(2, table.length());
-		throwsLuaError("length", somefunc);
-		throwsLuaError("length", thread);
-		throwsLuaError("length", someclosure);
-		throwsLuaError("length", userdataobj);
-		throwsLuaError("length", userdatacls);
-	}
-
-	public Prototype createPrototype(String script, String name) {
-		try {
-			Globals globals = org.luaj.vm2.lib.jse.JsePlatform.standardGlobals();
-			Reader reader = new StringReader(script);
-			return globals.compilePrototype(reader, name);
-		} catch (Exception e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-			fail(e.toString());
-			return null;
-		}
-	}
-
-	public void testFunctionClosureThreadEnv() {
-
-		// set up suitable environments for execution
-		LuaValue aaa = LuaValue.valueOf("aaa");
-		LuaValue eee = LuaValue.valueOf("eee");
-		final Globals globals = org.luaj.vm2.lib.jse.JsePlatform.standardGlobals();
-		LuaTable newenv = LuaValue.tableOf(new LuaValue[] { LuaValue.valueOf("a"), LuaValue.valueOf("aaa"),
-				LuaValue.valueOf("b"), LuaValue.valueOf("bbb"), });
-		LuaTable mt = LuaValue.tableOf(new LuaValue[] { LuaValue.INDEX, globals });
-		newenv.setmetatable(mt);
-		globals.set("a", aaa);
-		newenv.set("a", eee);
-
-		// function tests
-		{
-			LuaFunction f = new ZeroArgFunction() {
-				public LuaValue call() { return globals.get("a"); }
-			};
-			assertEquals(aaa, f.call());
-		}
-
-		// closure tests
-		{
-			Prototype p = createPrototype("return a\n", "closuretester");
-			LuaClosure c = new LuaClosure(p, globals);
-
-			// Test that a clusure with a custom enviroment uses that environment.
-			assertEquals(aaa, c.call());
-			c = new LuaClosure(p, newenv);
-			assertEquals(newenv, c.upValues[0].getValue());
-			assertEquals(eee, c.call());
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/MetatableTest.java

@@ -1,362 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.TypeTest.MyData;
-import org.luaj.vm2.lib.StringLib;
-import org.luaj.vm2.lib.ThreeArgFunction;
-import org.luaj.vm2.lib.TwoArgFunction;
-import org.luaj.vm2.lib.ZeroArgFunction;
-
-public class MetatableTest extends TestCase {
-
-	private final String samplestring = "abcdef";
-	private final Object sampleobject = new Object();
-	private final MyData sampledata   = new MyData();
-
-	private final LuaValue    string     = LuaValue.valueOf(samplestring);
-	private final LuaTable    table      = LuaValue.tableOf();
-	private final LuaFunction function   = new ZeroArgFunction() {
-												public LuaValue call() { return NONE; }
-											};
-	private final LuaThread   thread     = new LuaThread(new Globals(), function);
-	private final LuaClosure  closure    = new LuaClosure(new Prototype(), new LuaTable());
-	private final LuaUserdata userdata   = LuaValue.userdataOf(sampleobject);
-	private final LuaUserdata userdatamt = LuaValue.userdataOf(sampledata, table);
-
-	protected void setUp() throws Exception {
-		// needed for metatable ops to work on strings
-		new StringLib();
-	}
-
-	protected void tearDown() throws Exception {
-		super.tearDown();
-		LuaBoolean.s_metatable = null;
-		LuaFunction.s_metatable = null;
-		LuaNil.s_metatable = null;
-		LuaNumber.s_metatable = null;
-//		LuaString.s_metatable = null;
-		LuaThread.s_metatable = null;
-	}
-
-	public void testGetMetatable() {
-		assertEquals(null, LuaValue.NIL.getmetatable());
-		assertEquals(null, LuaValue.TRUE.getmetatable());
-		assertEquals(null, LuaValue.ONE.getmetatable());
-//		assertEquals( null, string.getmetatable() );
-		assertEquals(null, table.getmetatable());
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-		assertEquals(null, userdata.getmetatable());
-		assertEquals(table, userdatamt.getmetatable());
-	}
-
-	public void testSetMetatable() {
-		LuaValue mt = LuaValue.tableOf();
-		assertEquals(null, table.getmetatable());
-		assertEquals(null, userdata.getmetatable());
-		assertEquals(table, userdatamt.getmetatable());
-		assertEquals(table, table.setmetatable(mt));
-		assertEquals(userdata, userdata.setmetatable(mt));
-		assertEquals(userdatamt, userdatamt.setmetatable(mt));
-		assertEquals(mt, table.getmetatable());
-		assertEquals(mt, userdata.getmetatable());
-		assertEquals(mt, userdatamt.getmetatable());
-
-		// these all get metatable behind-the-scenes
-		assertEquals(null, LuaValue.NIL.getmetatable());
-		assertEquals(null, LuaValue.TRUE.getmetatable());
-		assertEquals(null, LuaValue.ONE.getmetatable());
-//		assertEquals( null, string.getmetatable() );
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-		LuaNil.s_metatable = mt;
-		assertEquals(mt, LuaValue.NIL.getmetatable());
-		assertEquals(null, LuaValue.TRUE.getmetatable());
-		assertEquals(null, LuaValue.ONE.getmetatable());
-//		assertEquals( null, string.getmetatable() );
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-		LuaBoolean.s_metatable = mt;
-		assertEquals(mt, LuaValue.TRUE.getmetatable());
-		assertEquals(null, LuaValue.ONE.getmetatable());
-//		assertEquals( null, string.getmetatable() );
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-		LuaNumber.s_metatable = mt;
-		assertEquals(mt, LuaValue.ONE.getmetatable());
-		assertEquals(mt, LuaValue.valueOf(1.25).getmetatable());
-//		assertEquals( null, string.getmetatable() );
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-//		LuaString.s_metatable = mt;
-//		assertEquals( mt, string.getmetatable() );
-		assertEquals(null, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		assertEquals(null, closure.getmetatable());
-		LuaFunction.s_metatable = mt;
-		assertEquals(mt, function.getmetatable());
-		assertEquals(null, thread.getmetatable());
-		LuaThread.s_metatable = mt;
-		assertEquals(mt, thread.getmetatable());
-	}
-
-	public void testMetatableIndex() {
-		assertEquals(table, table.setmetatable(null));
-		assertEquals(userdata, userdata.setmetatable(null));
-		assertEquals(userdatamt, userdatamt.setmetatable(null));
-		assertEquals(LuaValue.NIL, table.get(1));
-		assertEquals(LuaValue.NIL, userdata.get(1));
-		assertEquals(LuaValue.NIL, userdatamt.get(1));
-
-		// empty metatable
-		LuaValue mt = LuaValue.tableOf();
-		assertEquals(table, table.setmetatable(mt));
-		assertEquals(userdata, userdata.setmetatable(mt));
-		LuaBoolean.s_metatable = mt;
-		LuaFunction.s_metatable = mt;
-		LuaNil.s_metatable = mt;
-		LuaNumber.s_metatable = mt;
-//		LuaString.s_metatable = mt;
-		LuaThread.s_metatable = mt;
-		assertEquals(mt, table.getmetatable());
-		assertEquals(mt, userdata.getmetatable());
-		assertEquals(mt, LuaValue.NIL.getmetatable());
-		assertEquals(mt, LuaValue.TRUE.getmetatable());
-		assertEquals(mt, LuaValue.ONE.getmetatable());
-// 		assertEquals( StringLib.instance, string.getmetatable() );
-		assertEquals(mt, function.getmetatable());
-		assertEquals(mt, thread.getmetatable());
-
-		// plain metatable
-		LuaValue abc = LuaValue.valueOf("abc");
-		mt.set(LuaValue.INDEX, LuaValue.listOf(new LuaValue[] { abc }));
-		assertEquals(abc, table.get(1));
-		assertEquals(abc, userdata.get(1));
-		assertEquals(abc, LuaValue.NIL.get(1));
-		assertEquals(abc, LuaValue.TRUE.get(1));
-		assertEquals(abc, LuaValue.ONE.get(1));
-// 		assertEquals( abc, string.get(1) );
-		assertEquals(abc, function.get(1));
-		assertEquals(abc, thread.get(1));
-
-		// plain metatable
-		mt.set(LuaValue.INDEX, new TwoArgFunction() {
-			public LuaValue call(LuaValue arg1, LuaValue arg2) {
-				return LuaValue.valueOf(arg1.typename() + "[" + arg2.tojstring() + "]=xyz");
-			}
-
-		});
-		assertEquals("table[1]=xyz", table.get(1).tojstring());
-		assertEquals("userdata[1]=xyz", userdata.get(1).tojstring());
-		assertEquals("nil[1]=xyz", LuaValue.NIL.get(1).tojstring());
-		assertEquals("boolean[1]=xyz", LuaValue.TRUE.get(1).tojstring());
-		assertEquals("number[1]=xyz", LuaValue.ONE.get(1).tojstring());
-		//	assertEquals( "string[1]=xyz",   string.get(1).tojstring() );
-		assertEquals("function[1]=xyz", function.get(1).tojstring());
-		assertEquals("thread[1]=xyz", thread.get(1).tojstring());
-	}
-
-	public void testMetatableNewIndex() {
-		// empty metatable
-		LuaValue mt = LuaValue.tableOf();
-		assertEquals(table, table.setmetatable(mt));
-		assertEquals(userdata, userdata.setmetatable(mt));
-		LuaBoolean.s_metatable = mt;
-		LuaFunction.s_metatable = mt;
-		LuaNil.s_metatable = mt;
-		LuaNumber.s_metatable = mt;
-//		LuaString.s_metatable = mt;
-		LuaThread.s_metatable = mt;
-
-		// plain metatable
-		final LuaValue fallback = LuaValue.tableOf();
-		LuaValue abc = LuaValue.valueOf("abc");
-		mt.set(LuaValue.NEWINDEX, fallback);
-		table.set(2, abc);
-		userdata.set(3, abc);
-		LuaValue.NIL.set(4, abc);
-		LuaValue.TRUE.set(5, abc);
-		LuaValue.ONE.set(6, abc);
-// 		string.set(7,abc);
-		function.set(8, abc);
-		thread.set(9, abc);
-		assertEquals(abc, fallback.get(2));
-		assertEquals(abc, fallback.get(3));
-		assertEquals(abc, fallback.get(4));
-		assertEquals(abc, fallback.get(5));
-		assertEquals(abc, fallback.get(6));
-// 		assertEquals( abc, StringLib.instance.get(7) );
-		assertEquals(abc, fallback.get(8));
-		assertEquals(abc, fallback.get(9));
-
-		// metatable with function call
-		mt.set(LuaValue.NEWINDEX, new ThreeArgFunction() {
-			public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
-				fallback.rawset(arg2, LuaValue.valueOf("via-func-" + arg3));
-				return NONE;
-			}
-
-		});
-		table.set(12, abc);
-		userdata.set(13, abc);
-		LuaValue.NIL.set(14, abc);
-		LuaValue.TRUE.set(15, abc);
-		LuaValue.ONE.set(16, abc);
-// 		string.set(17,abc);
-		function.set(18, abc);
-		thread.set(19, abc);
-		LuaValue via = LuaValue.valueOf("via-func-abc");
-		assertEquals(via, fallback.get(12));
-		assertEquals(via, fallback.get(13));
-		assertEquals(via, fallback.get(14));
-		assertEquals(via, fallback.get(15));
-		assertEquals(via, fallback.get(16));
-//		assertEquals( via, StringLib.instance.get(17) );
-		assertEquals(via, fallback.get(18));
-		assertEquals(via, fallback.get(19));
-	}
-
-	private void checkTable(LuaValue t, LuaValue aa, LuaValue bb, LuaValue cc, LuaValue dd, LuaValue ee, LuaValue ff,
-		LuaValue gg, LuaValue ra, LuaValue rb, LuaValue rc, LuaValue rd, LuaValue re, LuaValue rf, LuaValue rg) {
-		assertEquals(aa, t.get("aa"));
-		assertEquals(bb, t.get("bb"));
-		assertEquals(cc, t.get("cc"));
-		assertEquals(dd, t.get("dd"));
-		assertEquals(ee, t.get("ee"));
-		assertEquals(ff, t.get("ff"));
-		assertEquals(gg, t.get("gg"));
-		assertEquals(ra, t.rawget("aa"));
-		assertEquals(rb, t.rawget("bb"));
-		assertEquals(rc, t.rawget("cc"));
-		assertEquals(rd, t.rawget("dd"));
-		assertEquals(re, t.rawget("ee"));
-		assertEquals(rf, t.rawget("ff"));
-		assertEquals(rg, t.rawget("gg"));
-	}
-
-	private LuaValue makeTable(String key1, String val1, String key2, String val2) {
-		return LuaValue.tableOf(new LuaValue[] { LuaValue.valueOf(key1), LuaValue.valueOf(val1), LuaValue.valueOf(key2),
-				LuaValue.valueOf(val2), });
-	}
-
-	public void testRawsetMetatableSet() {
-		// set up tables
-		LuaValue m = makeTable("aa", "aaa", "bb", "bbb");
-		m.set(LuaValue.INDEX, m);
-		m.set(LuaValue.NEWINDEX, m);
-		LuaValue s = makeTable("cc", "ccc", "dd", "ddd");
-		LuaValue t = makeTable("cc", "ccc", "dd", "ddd");
-		t.setmetatable(m);
-		LuaValue aaa = LuaValue.valueOf("aaa");
-		LuaValue bbb = LuaValue.valueOf("bbb");
-		LuaValue ccc = LuaValue.valueOf("ccc");
-		LuaValue ddd = LuaValue.valueOf("ddd");
-		LuaValue ppp = LuaValue.valueOf("ppp");
-		LuaValue qqq = LuaValue.valueOf("qqq");
-		LuaValue rrr = LuaValue.valueOf("rrr");
-		LuaValue sss = LuaValue.valueOf("sss");
-		LuaValue ttt = LuaValue.valueOf("ttt");
-		LuaValue www = LuaValue.valueOf("www");
-		LuaValue xxx = LuaValue.valueOf("xxx");
-		LuaValue yyy = LuaValue.valueOf("yyy");
-		LuaValue zzz = LuaValue.valueOf("zzz");
-		LuaValue nil = LuaValue.NIL;
-
-		// check initial values
-		//             values via "bet()"           values via "rawget()"
-		checkTable(s, nil, nil, ccc, ddd, nil, nil, nil, nil, nil, ccc, ddd, nil, nil, nil);
-		checkTable(t, aaa, bbb, ccc, ddd, nil, nil, nil, nil, nil, ccc, ddd, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-
-		// rawset()
-		s.rawset("aa", www);
-		checkTable(s, www, nil, ccc, ddd, nil, nil, nil, www, nil, ccc, ddd, nil, nil, nil);
-		checkTable(t, aaa, bbb, ccc, ddd, nil, nil, nil, nil, nil, ccc, ddd, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-		s.rawset("cc", xxx);
-		checkTable(s, www, nil, xxx, ddd, nil, nil, nil, www, nil, xxx, ddd, nil, nil, nil);
-		checkTable(t, aaa, bbb, ccc, ddd, nil, nil, nil, nil, nil, ccc, ddd, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-		t.rawset("bb", yyy);
-		checkTable(s, www, nil, xxx, ddd, nil, nil, nil, www, nil, xxx, ddd, nil, nil, nil);
-		checkTable(t, aaa, yyy, ccc, ddd, nil, nil, nil, nil, yyy, ccc, ddd, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-		t.rawset("dd", zzz);
-		checkTable(s, www, nil, xxx, ddd, nil, nil, nil, www, nil, xxx, ddd, nil, nil, nil);
-		checkTable(t, aaa, yyy, ccc, zzz, nil, nil, nil, nil, yyy, ccc, zzz, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-
-		// set() invoking metatables
-		s.set("ee", ppp);
-		checkTable(s, www, nil, xxx, ddd, ppp, nil, nil, www, nil, xxx, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, zzz, nil, nil, nil, nil, yyy, ccc, zzz, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-		s.set("cc", qqq);
-		checkTable(s, www, nil, qqq, ddd, ppp, nil, nil, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, zzz, nil, nil, nil, nil, yyy, ccc, zzz, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, nil, nil, aaa, bbb, nil, nil, nil, nil, nil);
-		t.set("ff", rrr);
-		checkTable(s, www, nil, qqq, ddd, ppp, nil, nil, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, zzz, nil, rrr, nil, nil, yyy, ccc, zzz, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, nil, aaa, bbb, nil, nil, nil, rrr, nil);
-		t.set("dd", sss);
-		checkTable(s, www, nil, qqq, ddd, ppp, nil, nil, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, sss, nil, rrr, nil, nil, yyy, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, nil, aaa, bbb, nil, nil, nil, rrr, nil);
-		m.set("gg", ttt);
-		checkTable(s, www, nil, qqq, ddd, ppp, nil, nil, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, sss, nil, rrr, ttt, nil, yyy, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, ttt, aaa, bbb, nil, nil, nil, rrr, ttt);
-
-		// make s fall back to t
-		s.setmetatable(LuaValue.tableOf(new LuaValue[] { LuaValue.INDEX, t, LuaValue.NEWINDEX, t }));
-		checkTable(s, www, yyy, qqq, ddd, ppp, rrr, ttt, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, sss, nil, rrr, ttt, nil, yyy, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, ttt, aaa, bbb, nil, nil, nil, rrr, ttt);
-		s.set("aa", www);
-		checkTable(s, www, yyy, qqq, ddd, ppp, rrr, ttt, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, yyy, ccc, sss, nil, rrr, ttt, nil, yyy, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, ttt, aaa, bbb, nil, nil, nil, rrr, ttt);
-		s.set("bb", zzz);
-		checkTable(s, www, zzz, qqq, ddd, ppp, rrr, ttt, www, nil, qqq, ddd, ppp, nil, nil);
-		checkTable(t, aaa, zzz, ccc, sss, nil, rrr, ttt, nil, zzz, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, ttt, aaa, bbb, nil, nil, nil, rrr, ttt);
-		s.set("ee", xxx);
-		checkTable(s, www, zzz, qqq, ddd, xxx, rrr, ttt, www, nil, qqq, ddd, xxx, nil, nil);
-		checkTable(t, aaa, zzz, ccc, sss, nil, rrr, ttt, nil, zzz, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, rrr, ttt, aaa, bbb, nil, nil, nil, rrr, ttt);
-		s.set("ff", yyy);
-		checkTable(s, www, zzz, qqq, ddd, xxx, yyy, ttt, www, nil, qqq, ddd, xxx, nil, nil);
-		checkTable(t, aaa, zzz, ccc, sss, nil, yyy, ttt, nil, zzz, ccc, sss, nil, nil, nil);
-		checkTable(m, aaa, bbb, nil, nil, nil, yyy, ttt, aaa, bbb, nil, nil, nil, yyy, ttt);
-
-	}
-
-}

luaj-test/src/test/java/org/luaj/vm2/OrphanedThreadTest.java

@@ -1,164 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2012 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.lang.ref.WeakReference;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.OneArgFunction;
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-public class OrphanedThreadTest extends TestCase {
-
-	Globals       globals;
-	LuaThread     luathread;
-	WeakReference luathr_ref;
-	LuaValue      function;
-	WeakReference func_ref;
-
-	protected void setUp() throws Exception {
-		LuaThread.thread_orphan_check_interval = 5;
-		globals = JsePlatform.standardGlobals();
-	}
-
-	protected void tearDown() {
-		LuaThread.thread_orphan_check_interval = 30000;
-	}
-
-	public void testCollectOrphanedNormalThread() throws Exception {
-		function = new NormalFunction(globals);
-		doTest(LuaValue.TRUE, LuaValue.ZERO);
-	}
-
-	public void testCollectOrphanedEarlyCompletionThread() throws Exception {
-		function = new EarlyCompletionFunction(globals);
-		doTest(LuaValue.TRUE, LuaValue.ZERO);
-	}
-
-	public void testCollectOrphanedAbnormalThread() throws Exception {
-		function = new AbnormalFunction(globals);
-		doTest(LuaValue.FALSE, LuaValue.valueOf("abnormal condition"));
-	}
-
-	public void testCollectOrphanedClosureThread() throws Exception {
-		String script = "print('in closure, arg is '..(...))\n" + "arg = coroutine.yield(1)\n"
-			+ "print('in closure.2, arg is '..arg)\n" + "arg = coroutine.yield(0)\n"
-			+ "print('leakage in closure.3, arg is '..arg)\n" + "return 'done'\n";
-		function = globals.load(script, "script");
-		doTest(LuaValue.TRUE, LuaValue.ZERO);
-	}
-
-	public void testCollectOrphanedPcallClosureThread() throws Exception {
-		String script = "f = function(x)\n" + "  print('in pcall-closure, arg is '..(x))\n"
-			+ "  arg = coroutine.yield(1)\n" + "  print('in pcall-closure.2, arg is '..arg)\n"
-			+ "  arg = coroutine.yield(0)\n" + "  print('leakage in pcall-closure.3, arg is '..arg)\n"
-			+ "  return 'done'\n" + "end\n" + "print( 'pcall-closre.result:', pcall( f, ... ) )\n";
-		function = globals.load(script, "script");
-		doTest(LuaValue.TRUE, LuaValue.ZERO);
-	}
-
-	public void testCollectOrphanedLoadCloasureThread() throws Exception {
-		String script = "t = { \"print \", \"'hello, \", \"world'\", }\n" + "i = 0\n" + "arg = ...\n"
-			+ "f = function()\n" + "	i = i + 1\n" + "   print('in load-closure, arg is', arg, 'next is', t[i])\n"
-			+ "   arg = coroutine.yield(1)\n" + "	return t[i]\n" + "end\n" + "load(f)()\n";
-		function = globals.load(script, "script");
-		doTest(LuaValue.TRUE, LuaValue.ONE);
-	}
-
-	private void doTest(LuaValue status2, LuaValue value2) throws Exception {
-		luathread = new LuaThread(globals, function);
-		luathr_ref = new WeakReference(luathread);
-		func_ref = new WeakReference(function);
-		assertNotNull(luathr_ref.get());
-
-		// resume two times
-		Varargs a = luathread.resume(LuaValue.valueOf("foo"));
-		assertEquals(LuaValue.ONE, a.arg(2));
-		assertEquals(LuaValue.TRUE, a.arg1());
-		a = luathread.resume(LuaValue.valueOf("bar"));
-		assertEquals(value2, a.arg(2));
-		assertEquals(status2, a.arg1());
-
-		// drop strong references
-		luathread = null;
-		function = null;
-
-		// gc
-		for (int i = 0; i < 100 && (luathr_ref.get() != null || func_ref.get() != null); i++) {
-			Runtime.getRuntime().gc();
-			Thread.sleep(5);
-		}
-
-		// check reference
-		assertNull(luathr_ref.get());
-		assertNull(func_ref.get());
-	}
-
-	static class NormalFunction extends OneArgFunction {
-		final Globals globals;
-
-		public NormalFunction(Globals globals) {
-			this.globals = globals;
-		}
-
-		public LuaValue call(LuaValue arg) {
-			System.out.println("in normal.1, arg is " + arg);
-			arg = globals.yield(ONE).arg1();
-			System.out.println("in normal.2, arg is " + arg);
-			arg = globals.yield(ZERO).arg1();
-			System.out.println("in normal.3, arg is " + arg);
-			return NONE;
-		}
-	}
-
-	static class EarlyCompletionFunction extends OneArgFunction {
-		final Globals globals;
-
-		public EarlyCompletionFunction(Globals globals) {
-			this.globals = globals;
-		}
-
-		public LuaValue call(LuaValue arg) {
-			System.out.println("in early.1, arg is " + arg);
-			arg = globals.yield(ONE).arg1();
-			System.out.println("in early.2, arg is " + arg);
-			return ZERO;
-		}
-	}
-
-	static class AbnormalFunction extends OneArgFunction {
-		final Globals globals;
-
-		public AbnormalFunction(Globals globals) {
-			this.globals = globals;
-		}
-
-		public LuaValue call(LuaValue arg) {
-			System.out.println("in abnormal.1, arg is " + arg);
-			arg = globals.yield(ONE).arg1();
-			System.out.println("in abnormal.2, arg is " + arg);
-			error("abnormal condition");
-			return ZERO;
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/RequireClassTest.java

@@ -1,83 +0,0 @@
-package org.luaj.vm2;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.jse.JsePlatform;
-import org.luaj.vm2.require.RequireSampleClassCastExcep;
-import org.luaj.vm2.require.RequireSampleLoadLuaError;
-import org.luaj.vm2.require.RequireSampleLoadRuntimeExcep;
-
-public class RequireClassTest extends TestCase {
-
-	private LuaTable globals;
-	private LuaValue require;
-
-	public void setUp() {
-		globals = JsePlatform.standardGlobals();
-		require = globals.get("require");
-	}
-
-	public void testLoadClass() {
-		LuaValue result = globals.load(new org.luaj.vm2.require.RequireSampleSuccess());
-		assertEquals("require-sample-success-", result.tojstring());
-	}
-
-	public void testRequireClassSuccess() {
-		LuaValue result = require.call(LuaValue.valueOf("org.luaj.vm2.require.RequireSampleSuccess"));
-		assertEquals("require-sample-success-org.luaj.vm2.require.RequireSampleSuccess", result.tojstring());
-		result = require.call(LuaValue.valueOf("org.luaj.vm2.require.RequireSampleSuccess"));
-		assertEquals("require-sample-success-org.luaj.vm2.require.RequireSampleSuccess", result.tojstring());
-	}
-
-	public void testRequireClassLoadLuaError() {
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleLoadLuaError.class.getName()));
-			fail("incorrectly loaded class that threw lua error");
-		} catch (LuaError le) {
-			assertEquals("sample-load-lua-error", le.getMessage());
-		}
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleLoadLuaError.class.getName()));
-			fail("incorrectly loaded class that threw lua error");
-		} catch (LuaError le) {
-			assertEquals("loop or previous error loading module '" + RequireSampleLoadLuaError.class.getName() + "'",
-				le.getMessage());
-		}
-	}
-
-	public void testRequireClassLoadRuntimeException() {
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleLoadRuntimeExcep.class.getName()));
-			fail("incorrectly loaded class that threw runtime exception");
-		} catch (RuntimeException le) {
-			assertEquals("sample-load-runtime-exception", le.getMessage());
-		}
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleLoadRuntimeExcep.class.getName()));
-			fail("incorrectly loaded class that threw runtime exception");
-		} catch (LuaError le) {
-			assertEquals(
-				"loop or previous error loading module '" + RequireSampleLoadRuntimeExcep.class.getName() + "'",
-				le.getMessage());
-		}
-	}
-
-	public void testRequireClassClassCastException() {
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleClassCastExcep.class.getName()));
-			fail("incorrectly loaded class that threw class cast exception");
-		} catch (LuaError le) {
-			String msg = le.getMessage();
-			if (msg.indexOf("not found") < 0)
-				fail("expected 'not found' message but got " + msg);
-		}
-		try {
-			LuaValue result = require.call(LuaValue.valueOf(RequireSampleClassCastExcep.class.getName()));
-			fail("incorrectly loaded class that threw class cast exception");
-		} catch (LuaError le) {
-			String msg = le.getMessage();
-			if (msg.indexOf("not found") < 0)
-				fail("expected 'not found' message but got " + msg);
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/StringTest.java

@@ -1,380 +0,0 @@
-package org.luaj.vm2;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.UnsupportedEncodingException;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-public class StringTest extends TestCase {
-
-	protected void setUp() throws Exception {
-		JsePlatform.standardGlobals();
-	}
-
-	public void testToInputStream() throws IOException {
-		LuaString str = LuaString.valueOf("Hello");
-
-		InputStream is = str.toInputStream();
-
-		assertEquals('H', is.read());
-		assertEquals('e', is.read());
-		assertEquals(2, is.skip(2));
-		assertEquals('o', is.read());
-		assertEquals(-1, is.read());
-
-		assertTrue(is.markSupported());
-
-		is.reset();
-
-		assertEquals('H', is.read());
-		is.mark(4);
-
-		assertEquals('e', is.read());
-		is.reset();
-		assertEquals('e', is.read());
-
-		LuaString substr = str.substring(1, 4);
-		assertEquals(3, substr.length());
-
-		is.close();
-		is = substr.toInputStream();
-
-		assertEquals('e', is.read());
-		assertEquals('l', is.read());
-		assertEquals('l', is.read());
-		assertEquals(-1, is.read());
-
-		is = substr.toInputStream();
-		is.reset();
-
-		assertEquals('e', is.read());
-	}
-
-	private static final String userFriendly(String s) {
-		StringBuffer sb = new StringBuffer();
-		for (int i = 0, n = s.length(); i < n; i++) {
-			int c = s.charAt(i);
-			if (c < ' ' || c >= 0x80) {
-				sb.append("\\u" + Integer.toHexString(0x10000+c).substring(1));
-			} else {
-				sb.append((char) c);
-			}
-		}
-		return sb.toString();
-	}
-
-	public void testUtf820482051() throws UnsupportedEncodingException {
-		int i = 2048;
-		char[] c = { (char) (i+0), (char) (i+1), (char) (i+2), (char) (i+3) };
-		String before = new String(c) + " " + i + "-" + (i+4);
-		LuaString ls = LuaString.valueOf(before);
-		String after = ls.tojstring();
-		assertEquals(userFriendly(before), userFriendly(after));
-	}
-
-	public void testUtf8() {
-		for (int i = 4; i < 0xffff; i += 4) {
-			char[] c = { (char) (i+0), (char) (i+1), (char) (i+2), (char) (i+3) };
-			String before = new String(c) + " " + i + "-" + (i+4);
-			LuaString ls = LuaString.valueOf(before);
-			String after = ls.tojstring();
-			assertEquals(userFriendly(before), userFriendly(after));
-		}
-		char[] c = { (char) (1), (char) (2), (char) (3) };
-		String before = new String(c) + " 1-3";
-		LuaString ls = LuaString.valueOf(before);
-		String after = ls.tojstring();
-		assertEquals(userFriendly(before), userFriendly(after));
-	}
-
-	public void testSpotCheckUtf8() throws UnsupportedEncodingException {
-		byte[] bytes = { (byte) 194, (byte) 160, (byte) 194, (byte) 161, (byte) 194, (byte) 162, (byte) 194, (byte) 163,
-				(byte) 194, (byte) 164 };
-		String expected = new String(bytes, "UTF8");
-		String actual = LuaString.valueOf(bytes).tojstring();
-		char[] d = actual.toCharArray();
-		assertEquals(160, d[0]);
-		assertEquals(161, d[1]);
-		assertEquals(162, d[2]);
-		assertEquals(163, d[3]);
-		assertEquals(164, d[4]);
-		assertEquals(expected, actual);
-	}
-
-	public void testNullTerminated() {
-		char[] c = { 'a', 'b', 'c', '\0', 'd', 'e', 'f' };
-		String before = new String(c);
-		LuaString ls = LuaString.valueOf(before);
-		String after = ls.tojstring();
-		assertEquals(userFriendly("abc\0def"), userFriendly(after));
-	}
-
-	public void testRecentStringsCacheDifferentHashcodes() {
-		final byte[] abc = { 'a', 'b', 'c' };
-		final byte[] xyz = { 'x', 'y', 'z' };
-		final LuaString abc1 = LuaString.valueOf(abc);
-		final LuaString xyz1 = LuaString.valueOf(xyz);
-		final LuaString abc2 = LuaString.valueOf(abc);
-		final LuaString xyz2 = LuaString.valueOf(xyz);
-		final int mod = LuaString.RECENT_STRINGS_CACHE_SIZE;
-		assertTrue(abc1.hashCode()%mod != xyz1.hashCode()%mod);
-		assertSame(abc1, abc2);
-		assertSame(xyz1, xyz2);
-	}
-
-	public void testRecentStringsCacheHashCollisionCacheHit() {
-		final byte[] abc = { 'a', 'b', 'c' };
-		final byte[] lyz = { 'l', 'y', 'z' }; // chosen to have hash collision with 'abc'
-		final LuaString abc1 = LuaString.valueOf(abc);
-		final LuaString abc2 = LuaString.valueOf(abc); // in cache: 'abc'
-		final LuaString lyz1 = LuaString.valueOf(lyz);
-		final LuaString lyz2 = LuaString.valueOf(lyz); // in cache: 'lyz'
-		final int mod = LuaString.RECENT_STRINGS_CACHE_SIZE;
-		assertEquals(abc1.hashCode()%mod, lyz1.hashCode()%mod);
-		assertNotSame(abc1, lyz1);
-		assertFalse(abc1.equals(lyz1));
-		assertSame(abc1, abc2);
-		assertSame(lyz1, lyz2);
-	}
-
-	public void testRecentStringsCacheHashCollisionCacheMiss() {
-		final byte[] abc = { 'a', 'b', 'c' };
-		final byte[] lyz = { 'l', 'y', 'z' }; // chosen to have hash collision with 'abc'
-		final LuaString abc1 = LuaString.valueOf(abc);
-		final LuaString lyz1 = LuaString.valueOf(lyz); // in cache: 'abc'
-		final LuaString abc2 = LuaString.valueOf(abc); // in cache: 'lyz'
-		final LuaString lyz2 = LuaString.valueOf(lyz); // in cache: 'abc'
-		final int mod = LuaString.RECENT_STRINGS_CACHE_SIZE;
-		assertEquals(abc1.hashCode()%mod, lyz1.hashCode()%mod);
-		assertNotSame(abc1, lyz1);
-		assertFalse(abc1.equals(lyz1));
-		assertNotSame(abc1, abc2);
-		assertNotSame(lyz1, lyz2);
-	}
-
-	public void testRecentStringsLongStrings() {
-		byte[] abc = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes();
-		assertTrue(abc.length > LuaString.RECENT_STRINGS_MAX_LENGTH);
-		LuaString abc1 = LuaString.valueOf(abc);
-		LuaString abc2 = LuaString.valueOf(abc);
-		assertNotSame(abc1, abc2);
-	}
-
-	public void testRecentStringsUsingJavaStrings() {
-		final String abc = "abc";
-		final String lyz = "lyz"; // chosen to have hash collision with 'abc'
-		final String xyz = "xyz";
-
-		final LuaString abc1 = LuaString.valueOf(abc);
-		final LuaString abc2 = LuaString.valueOf(abc);
-		final LuaString lyz1 = LuaString.valueOf(lyz);
-		final LuaString lyz2 = LuaString.valueOf(lyz);
-		final LuaString xyz1 = LuaString.valueOf(xyz);
-		final LuaString xyz2 = LuaString.valueOf(xyz);
-		final int mod = LuaString.RECENT_STRINGS_CACHE_SIZE;
-		assertEquals(abc1.hashCode()%mod, lyz1.hashCode()%mod);
-		assertFalse(abc1.hashCode()%mod == xyz1.hashCode()%mod);
-		assertSame(abc1, abc2);
-		assertSame(lyz1, lyz2);
-		assertSame(xyz1, xyz2);
-
-		final LuaString abc3 = LuaString.valueOf(abc);
-		final LuaString lyz3 = LuaString.valueOf(lyz);
-		final LuaString xyz3 = LuaString.valueOf(xyz);
-
-		final LuaString abc4 = LuaString.valueOf(abc);
-		final LuaString lyz4 = LuaString.valueOf(lyz);
-		final LuaString xyz4 = LuaString.valueOf(xyz);
-		assertNotSame(abc3, abc4); // because of hash collision
-		assertNotSame(lyz3, lyz4); // because of hash collision
-		assertSame(xyz3, xyz4); // because hashes do not collide
-	}
-
-	public void testLongSubstringGetsOldBacking() {
-		LuaString src = LuaString.valueOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
-		LuaString sub1 = src.substring(10, 40);
-		assertSame(src.m_bytes, sub1.m_bytes);
-		assertEquals(sub1.m_offset, 10);
-		assertEquals(sub1.m_length, 30);
-	}
-
-	public void testShortSubstringGetsNewBacking() {
-		LuaString src = LuaString.valueOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
-		LuaString sub1 = src.substring(10, 20);
-		LuaString sub2 = src.substring(10, 20);
-		assertEquals(sub1.m_offset, 0);
-		assertEquals(sub1.m_length, 10);
-		assertSame(sub1, sub2);
-		assertFalse(src.m_bytes == sub1.m_bytes);
-	}
-
-	public void testShortSubstringOfVeryLongStringGetsNewBacking() {
-		LuaString src = LuaString.valueOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-			+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
-		LuaString sub1 = src.substring(10, 50);
-		LuaString sub2 = src.substring(10, 50);
-		assertEquals(sub1.m_offset, 0);
-		assertEquals(sub1.m_length, 40);
-		assertFalse(sub1 == sub2);
-		assertFalse(src.m_bytes == sub1.m_bytes);
-	}
-
-	public void testIndexOfByteInSubstring() {
-		LuaString str = LuaString.valueOf("abcdef:ghi");
-		LuaString sub = str.substring(2, 10);
-		assertEquals(10, str.m_length);
-		assertEquals(8, sub.m_length);
-		assertEquals(0, str.m_offset);
-		assertEquals(2, sub.m_offset);
-
-		assertEquals(6, str.indexOf((byte) ':', 0));
-		assertEquals(6, str.indexOf((byte) ':', 2));
-		assertEquals(6, str.indexOf((byte) ':', 6));
-		assertEquals(-1, str.indexOf((byte) ':', 7));
-		assertEquals(-1, str.indexOf((byte) ':', 9));
-		assertEquals(9, str.indexOf((byte) 'i', 0));
-		assertEquals(9, str.indexOf((byte) 'i', 2));
-		assertEquals(9, str.indexOf((byte) 'i', 9));
-		assertEquals(-1, str.indexOf((byte) 'z', 0));
-		assertEquals(-1, str.indexOf((byte) 'z', 2));
-		assertEquals(-1, str.indexOf((byte) 'z', 9));
-
-		assertEquals(4, sub.indexOf((byte) ':', 0));
-		assertEquals(4, sub.indexOf((byte) ':', 2));
-		assertEquals(4, sub.indexOf((byte) ':', 4));
-		assertEquals(-1, sub.indexOf((byte) ':', 5));
-		assertEquals(-1, sub.indexOf((byte) ':', 7));
-		assertEquals(7, sub.indexOf((byte) 'i', 0));
-		assertEquals(7, sub.indexOf((byte) 'i', 2));
-		assertEquals(7, sub.indexOf((byte) 'i', 7));
-		assertEquals(-1, sub.indexOf((byte) 'z', 0));
-		assertEquals(-1, sub.indexOf((byte) 'z', 2));
-		assertEquals(-1, sub.indexOf((byte) 'z', 7));
-	}
-
-	public void testIndexOfPatternInSubstring() {
-		LuaString str = LuaString.valueOf("abcdef:ghi");
-		LuaString sub = str.substring(2, 10);
-		assertEquals(10, str.m_length);
-		assertEquals(8, sub.m_length);
-		assertEquals(0, str.m_offset);
-		assertEquals(2, sub.m_offset);
-
-		LuaString pat = LuaString.valueOf(":");
-		LuaString i = LuaString.valueOf("i");
-		LuaString xyz = LuaString.valueOf("xyz");
-
-		assertEquals(6, str.indexOf(pat, 0));
-		assertEquals(6, str.indexOf(pat, 2));
-		assertEquals(6, str.indexOf(pat, 6));
-		assertEquals(-1, str.indexOf(pat, 7));
-		assertEquals(-1, str.indexOf(pat, 9));
-		assertEquals(9, str.indexOf(i, 0));
-		assertEquals(9, str.indexOf(i, 2));
-		assertEquals(9, str.indexOf(i, 9));
-		assertEquals(-1, str.indexOf(xyz, 0));
-		assertEquals(-1, str.indexOf(xyz, 2));
-		assertEquals(-1, str.indexOf(xyz, 9));
-
-		assertEquals(4, sub.indexOf(pat, 0));
-		assertEquals(4, sub.indexOf(pat, 2));
-		assertEquals(4, sub.indexOf(pat, 4));
-		assertEquals(-1, sub.indexOf(pat, 5));
-		assertEquals(-1, sub.indexOf(pat, 7));
-		assertEquals(7, sub.indexOf(i, 0));
-		assertEquals(7, sub.indexOf(i, 2));
-		assertEquals(7, sub.indexOf(i, 7));
-		assertEquals(-1, sub.indexOf(xyz, 0));
-		assertEquals(-1, sub.indexOf(xyz, 2));
-		assertEquals(-1, sub.indexOf(xyz, 7));
-	}
-
-	public void testLastIndexOfPatternInSubstring() {
-		LuaString str = LuaString.valueOf("abcdef:ghi");
-		LuaString sub = str.substring(2, 10);
-		assertEquals(10, str.m_length);
-		assertEquals(8, sub.m_length);
-		assertEquals(0, str.m_offset);
-		assertEquals(2, sub.m_offset);
-
-		LuaString pat = LuaString.valueOf(":");
-		LuaString i = LuaString.valueOf("i");
-		LuaString xyz = LuaString.valueOf("xyz");
-
-		assertEquals(6, str.lastIndexOf(pat));
-		assertEquals(9, str.lastIndexOf(i));
-		assertEquals(-1, str.lastIndexOf(xyz));
-
-		assertEquals(4, sub.lastIndexOf(pat));
-		assertEquals(7, sub.lastIndexOf(i));
-		assertEquals(-1, sub.lastIndexOf(xyz));
-	}
-
-	public void testIndexOfAnyInSubstring() {
-		LuaString str = LuaString.valueOf("abcdef:ghi");
-		LuaString sub = str.substring(2, 10);
-		assertEquals(10, str.m_length);
-		assertEquals(8, sub.m_length);
-		assertEquals(0, str.m_offset);
-		assertEquals(2, sub.m_offset);
-
-		LuaString ghi = LuaString.valueOf("ghi");
-		LuaString ihg = LuaString.valueOf("ihg");
-		LuaString ijk = LuaString.valueOf("ijk");
-		LuaString kji = LuaString.valueOf("kji");
-		LuaString xyz = LuaString.valueOf("xyz");
-		LuaString ABCdEFGHIJKL = LuaString.valueOf("ABCdEFGHIJKL");
-		LuaString EFGHIJKL = ABCdEFGHIJKL.substring(4, 12);
-		LuaString CdEFGHIJ = ABCdEFGHIJKL.substring(2, 10);
-		assertEquals(4, EFGHIJKL.m_offset);
-		assertEquals(2, CdEFGHIJ.m_offset);
-
-		assertEquals(7, str.indexOfAny(ghi));
-		assertEquals(7, str.indexOfAny(ihg));
-		assertEquals(9, str.indexOfAny(ijk));
-		assertEquals(9, str.indexOfAny(kji));
-		assertEquals(-1, str.indexOfAny(xyz));
-		assertEquals(3, str.indexOfAny(CdEFGHIJ));
-		assertEquals(-1, str.indexOfAny(EFGHIJKL));
-
-		assertEquals(5, sub.indexOfAny(ghi));
-		assertEquals(5, sub.indexOfAny(ihg));
-		assertEquals(7, sub.indexOfAny(ijk));
-		assertEquals(7, sub.indexOfAny(kji));
-		assertEquals(-1, sub.indexOfAny(xyz));
-		assertEquals(1, sub.indexOfAny(CdEFGHIJ));
-		assertEquals(-1, sub.indexOfAny(EFGHIJKL));
-	}
-
-	public void testMatchShortPatterns() {
-		LuaValue[] args = { LuaString.valueOf("%bxy") };
-		LuaString _ = LuaString.valueOf("");
-
-		LuaString a = LuaString.valueOf("a");
-		LuaString ax = LuaString.valueOf("ax");
-		LuaString axb = LuaString.valueOf("axb");
-		LuaString axby = LuaString.valueOf("axby");
-		LuaString xbya = LuaString.valueOf("xbya");
-		LuaString bya = LuaString.valueOf("bya");
-		LuaString xby = LuaString.valueOf("xby");
-		LuaString axbya = LuaString.valueOf("axbya");
-		LuaValue nil = LuaValue.NIL;
-
-		assertEquals(nil, _.invokemethod("match", args));
-		assertEquals(nil, a.invokemethod("match", args));
-		assertEquals(nil, ax.invokemethod("match", args));
-		assertEquals(nil, axb.invokemethod("match", args));
-		assertEquals(xby, axby.invokemethod("match", args));
-		assertEquals(xby, xbya.invokemethod("match", args));
-		assertEquals(nil, bya.invokemethod("match", args));
-		assertEquals(xby, xby.invokemethod("match", args));
-		assertEquals(xby, axbya.invokemethod("match", args));
-		assertEquals(xby, axbya.substring(0, 4).invokemethod("match", args));
-		assertEquals(nil, axbya.substring(0, 3).invokemethod("match", args));
-		assertEquals(xby, axbya.substring(1, 5).invokemethod("match", args));
-		assertEquals(nil, axbya.substring(2, 5).invokemethod("match", args));
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/TableHashTest.java

@@ -1,319 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.LuaString;
-import org.luaj.vm2.LuaTable;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.TwoArgFunction;
-
-/**
- * Tests for tables used as lists.
- */
-public class TableHashTest extends TestCase {
-
-	protected LuaTable new_Table() {
-		return new LuaTable();
-	}
-
-	protected LuaTable new_Table(int n, int m) {
-		return new LuaTable(n, m);
-	}
-
-	public void testSetRemove() {
-		LuaTable t = new_Table();
-
-		assertEquals(0, t.getHashLength());
-		assertEquals(0, t.length());
-		assertEquals(0, t.keyCount());
-
-		String[] keys = { "abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "wxy", "z01", "cd", "ef", "g", "hi", "jk",
-				"lm", "no", "pq", "rs", };
-		int[] capacities = { 0, 2, 2, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 32, 32, 32 };
-		for (int i = 0; i < keys.length; ++i) {
-			assertEquals(capacities[i], t.getHashLength());
-			String si = "Test Value! " + i;
-			t.set(keys[i], si);
-			assertEquals(0, t.length());
-			assertEquals(i+1, t.keyCount());
-		}
-		assertEquals(capacities[keys.length], t.getHashLength());
-		for (int i = 0; i < keys.length; ++i) {
-			LuaValue vi = LuaString.valueOf("Test Value! " + i);
-			assertEquals(vi, t.get(keys[i]));
-			assertEquals(vi, t.get(LuaString.valueOf(keys[i])));
-			assertEquals(vi, t.rawget(keys[i]));
-			assertEquals(vi, t.rawget(keys[i]));
-		}
-
-		// replace with new values
-		for (int i = 0; i < keys.length; ++i) {
-			t.set(keys[i], LuaString.valueOf("Replacement Value! " + i));
-			assertEquals(0, t.length());
-			assertEquals(keys.length, t.keyCount());
-			assertEquals(capacities[keys.length], t.getHashLength());
-		}
-		for (int i = 0; i < keys.length; ++i) {
-			LuaValue vi = LuaString.valueOf("Replacement Value! " + i);
-			assertEquals(vi, t.get(keys[i]));
-		}
-
-		// remove
-		for (int i = 0; i < keys.length; ++i) {
-			t.set(keys[i], LuaValue.NIL);
-			assertEquals(0, t.length());
-			assertEquals(keys.length-i-1, t.keyCount());
-			if (i < keys.length-1)
-				assertEquals(capacities[keys.length], t.getHashLength());
-			else
-				assertTrue(0 <= t.getHashLength());
-		}
-		for (int i = 0; i < keys.length; ++i) {
-			assertEquals(LuaValue.NIL, t.get(keys[i]));
-		}
-	}
-
-	public void testIndexMetatag() {
-		LuaTable t = new_Table();
-		LuaTable mt = new_Table();
-		LuaTable fb = new_Table();
-
-		// set basic values
-		t.set("ppp", "abc");
-		t.set(123, "def");
-		mt.set(LuaValue.INDEX, fb);
-		fb.set("qqq", "ghi");
-		fb.set(456, "jkl");
-
-		// check before setting metatable
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("nil", t.get("qqq").tojstring());
-		assertEquals("nil", t.get(456).tojstring());
-		assertEquals("nil", fb.get("ppp").tojstring());
-		assertEquals("nil", fb.get(123).tojstring());
-		assertEquals("ghi", fb.get("qqq").tojstring());
-		assertEquals("jkl", fb.get(456).tojstring());
-		assertEquals("nil", mt.get("ppp").tojstring());
-		assertEquals("nil", mt.get(123).tojstring());
-		assertEquals("nil", mt.get("qqq").tojstring());
-		assertEquals("nil", mt.get(456).tojstring());
-
-		// check before setting metatable
-		t.setmetatable(mt);
-		assertEquals(mt, t.getmetatable());
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("ghi", t.get("qqq").tojstring());
-		assertEquals("jkl", t.get(456).tojstring());
-		assertEquals("nil", fb.get("ppp").tojstring());
-		assertEquals("nil", fb.get(123).tojstring());
-		assertEquals("ghi", fb.get("qqq").tojstring());
-		assertEquals("jkl", fb.get(456).tojstring());
-		assertEquals("nil", mt.get("ppp").tojstring());
-		assertEquals("nil", mt.get(123).tojstring());
-		assertEquals("nil", mt.get("qqq").tojstring());
-		assertEquals("nil", mt.get(456).tojstring());
-
-		// set metatable to metatable without values
-		t.setmetatable(fb);
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("nil", t.get("qqq").tojstring());
-		assertEquals("nil", t.get(456).tojstring());
-
-		// set metatable to null
-		t.setmetatable(null);
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("nil", t.get("qqq").tojstring());
-		assertEquals("nil", t.get(456).tojstring());
-	}
-
-	public void testIndexFunction() {
-		final LuaTable t = new_Table();
-		final LuaTable mt = new_Table();
-
-		final TwoArgFunction fb = new TwoArgFunction() {
-			public LuaValue call(LuaValue tbl, LuaValue key) {
-				assertEquals(tbl, t);
-				return valueOf("from mt: " + key);
-			}
-		};
-
-		// set basic values
-		t.set("ppp", "abc");
-		t.set(123, "def");
-		mt.set(LuaValue.INDEX, fb);
-
-		// check before setting metatable
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("nil", t.get("qqq").tojstring());
-		assertEquals("nil", t.get(456).tojstring());
-
-		// check before setting metatable
-		t.setmetatable(mt);
-		assertEquals(mt, t.getmetatable());
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("from mt: qqq", t.get("qqq").tojstring());
-		assertEquals("from mt: 456", t.get(456).tojstring());
-
-		// use raw set
-		t.rawset("qqq", "alt-qqq");
-		t.rawset(456, "alt-456");
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("alt-qqq", t.get("qqq").tojstring());
-		assertEquals("alt-456", t.get(456).tojstring());
-
-		// remove using raw set
-		t.rawset("qqq", LuaValue.NIL);
-		t.rawset(456, LuaValue.NIL);
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("from mt: qqq", t.get("qqq").tojstring());
-		assertEquals("from mt: 456", t.get(456).tojstring());
-
-		// set metatable to null
-		t.setmetatable(null);
-		assertEquals("abc", t.get("ppp").tojstring());
-		assertEquals("def", t.get(123).tojstring());
-		assertEquals("nil", t.get("qqq").tojstring());
-		assertEquals("nil", t.get(456).tojstring());
-	}
-
-	public void testNext() {
-		final LuaTable t = new_Table();
-		assertEquals(LuaValue.NIL, t.next(LuaValue.NIL));
-
-		// insert array elements
-		t.set(1, "one");
-		assertEquals(LuaValue.valueOf(1), t.next(LuaValue.NIL).arg(1));
-		assertEquals(LuaValue.valueOf("one"), t.next(LuaValue.NIL).arg(2));
-		assertEquals(LuaValue.NIL, t.next(LuaValue.ONE));
-		t.set(2, "two");
-		assertEquals(LuaValue.valueOf(1), t.next(LuaValue.NIL).arg(1));
-		assertEquals(LuaValue.valueOf("one"), t.next(LuaValue.NIL).arg(2));
-		assertEquals(LuaValue.valueOf(2), t.next(LuaValue.ONE).arg(1));
-		assertEquals(LuaValue.valueOf("two"), t.next(LuaValue.ONE).arg(2));
-		assertEquals(LuaValue.NIL, t.next(LuaValue.valueOf(2)));
-
-		// insert hash elements
-		t.set("aa", "aaa");
-		assertEquals(LuaValue.valueOf(1), t.next(LuaValue.NIL).arg(1));
-		assertEquals(LuaValue.valueOf("one"), t.next(LuaValue.NIL).arg(2));
-		assertEquals(LuaValue.valueOf(2), t.next(LuaValue.ONE).arg(1));
-		assertEquals(LuaValue.valueOf("two"), t.next(LuaValue.ONE).arg(2));
-		assertEquals(LuaValue.valueOf("aa"), t.next(LuaValue.valueOf(2)).arg(1));
-		assertEquals(LuaValue.valueOf("aaa"), t.next(LuaValue.valueOf(2)).arg(2));
-		assertEquals(LuaValue.NIL, t.next(LuaValue.valueOf("aa")));
-		t.set("bb", "bbb");
-		assertEquals(LuaValue.valueOf(1), t.next(LuaValue.NIL).arg(1));
-		assertEquals(LuaValue.valueOf("one"), t.next(LuaValue.NIL).arg(2));
-		assertEquals(LuaValue.valueOf(2), t.next(LuaValue.ONE).arg(1));
-		assertEquals(LuaValue.valueOf("two"), t.next(LuaValue.ONE).arg(2));
-		assertEquals(LuaValue.valueOf("aa"), t.next(LuaValue.valueOf(2)).arg(1));
-		assertEquals(LuaValue.valueOf("aaa"), t.next(LuaValue.valueOf(2)).arg(2));
-		assertEquals(LuaValue.valueOf("bb"), t.next(LuaValue.valueOf("aa")).arg(1));
-		assertEquals(LuaValue.valueOf("bbb"), t.next(LuaValue.valueOf("aa")).arg(2));
-		assertEquals(LuaValue.NIL, t.next(LuaValue.valueOf("bb")));
-	}
-
-	public void testLoopWithRemoval() {
-		final LuaTable t = new_Table();
-
-		t.set(LuaValue.valueOf(1), LuaValue.valueOf("1"));
-		t.set(LuaValue.valueOf(3), LuaValue.valueOf("3"));
-		t.set(LuaValue.valueOf(8), LuaValue.valueOf("4"));
-		t.set(LuaValue.valueOf(17), LuaValue.valueOf("5"));
-		t.set(LuaValue.valueOf(26), LuaValue.valueOf("6"));
-		t.set(LuaValue.valueOf(35), LuaValue.valueOf("7"));
-		t.set(LuaValue.valueOf(42), LuaValue.valueOf("8"));
-		t.set(LuaValue.valueOf(60), LuaValue.valueOf("10"));
-		t.set(LuaValue.valueOf(63), LuaValue.valueOf("11"));
-
-		Varargs entry = t.next(LuaValue.NIL);
-		while ( !entry.isnil(1) ) {
-			LuaValue k = entry.arg1();
-			LuaValue v = entry.arg(2);
-			if ((k.toint() & 1) == 0) {
-				t.set(k, LuaValue.NIL);
-			}
-			entry = t.next(k);
-		}
-
-		int numEntries = 0;
-		entry = t.next(LuaValue.NIL);
-		while ( !entry.isnil(1) ) {
-			LuaValue k = entry.arg1();
-			// Only odd keys should remain
-			assertTrue((k.toint() & 1) == 1);
-			numEntries++;
-			entry = t.next(k);
-		}
-		assertEquals(5, numEntries);
-	}
-
-	public void testLoopWithRemovalAndSet() {
-		final LuaTable t = new_Table();
-
-		t.set(LuaValue.valueOf(1), LuaValue.valueOf("1"));
-		t.set(LuaValue.valueOf(3), LuaValue.valueOf("3"));
-		t.set(LuaValue.valueOf(8), LuaValue.valueOf("4"));
-		t.set(LuaValue.valueOf(17), LuaValue.valueOf("5"));
-		t.set(LuaValue.valueOf(26), LuaValue.valueOf("6"));
-		t.set(LuaValue.valueOf(35), LuaValue.valueOf("7"));
-		t.set(LuaValue.valueOf(42), LuaValue.valueOf("8"));
-		t.set(LuaValue.valueOf(60), LuaValue.valueOf("10"));
-		t.set(LuaValue.valueOf(63), LuaValue.valueOf("11"));
-
-		Varargs entry = t.next(LuaValue.NIL);
-		Varargs entry2 = entry;
-		while ( !entry.isnil(1) ) {
-			LuaValue k = entry.arg1();
-			LuaValue v = entry.arg(2);
-			if ((k.toint() & 1) == 0) {
-				t.set(k, LuaValue.NIL);
-			} else {
-				t.set(k, v.tonumber());
-				entry2 = t.next(entry2.arg1());
-			}
-			entry = t.next(k);
-		}
-
-		int numEntries = 0;
-		entry = t.next(LuaValue.NIL);
-		while ( !entry.isnil(1) ) {
-			LuaValue k = entry.arg1();
-			// Only odd keys should remain
-			assertTrue((k.toint() & 1) == 1);
-			assertTrue(entry.arg(2).type() == LuaValue.TNUMBER);
-			numEntries++;
-			entry = t.next(k);
-		}
-		assertEquals(5, numEntries);
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/TableTest.java

@@ -1,412 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.util.ArrayList;
-import java.util.Vector;
-
-import junit.framework.TestCase;
-
-public class TableTest extends TestCase {
-
-	protected LuaTable new_Table() {
-		return new LuaTable();
-	}
-
-	protected LuaTable new_Table(int n, int m) {
-		return new LuaTable(n, m);
-	}
-
-	private int keyCount(LuaTable t) {
-		return keys(t).length;
-	}
-
-	private LuaValue[] keys(LuaTable t) {
-		ArrayList<LuaValue> l = new ArrayList<LuaValue>();
-		LuaValue k = LuaValue.NIL;
-		while ( true ) {
-			Varargs n = t.next(k);
-			if ((k = n.arg1()).isnil())
-				break;
-			l.add(k);
-		}
-		return l.toArray(new LuaValue[t.length()]);
-	}
-
-	public void testInOrderIntegerKeyInsertion() {
-		LuaTable t = new_Table();
-
-		for (int i = 1; i <= 32; ++i) {
-			t.set(i, LuaValue.valueOf("Test Value! " + i));
-		}
-
-		// Ensure all keys are still there.
-		for (int i = 1; i <= 32; ++i) {
-			assertEquals("Test Value! " + i, t.get(i).tojstring());
-		}
-
-		// Ensure capacities make sense
-		assertEquals(0, t.getHashLength());
-
-		assertTrue(t.getArrayLength() >= 32);
-		assertTrue(t.getArrayLength() <= 64);
-
-	}
-
-	public void testRekeyCount() {
-		LuaTable t = new_Table();
-
-		// NOTE: This order of insertion is important.
-		t.set(3, LuaInteger.valueOf(3));
-		t.set(1, LuaInteger.valueOf(1));
-		t.set(5, LuaInteger.valueOf(5));
-		t.set(4, LuaInteger.valueOf(4));
-		t.set(6, LuaInteger.valueOf(6));
-		t.set(2, LuaInteger.valueOf(2));
-
-		for (int i = 1; i < 6; ++i) {
-			assertEquals(LuaInteger.valueOf(i), t.get(i));
-		}
-
-		assertTrue(t.getArrayLength() >= 3);
-		assertTrue(t.getArrayLength() <= 12);
-		assertTrue(t.getHashLength() <= 3);
-	}
-
-	public void testOutOfOrderIntegerKeyInsertion() {
-		LuaTable t = new_Table();
-
-		for (int i = 32; i > 0; --i) {
-			t.set(i, LuaValue.valueOf("Test Value! " + i));
-		}
-
-		// Ensure all keys are still there.
-		for (int i = 1; i <= 32; ++i) {
-			assertEquals("Test Value! " + i, t.get(i).tojstring());
-		}
-
-		// Ensure capacities make sense
-		assertEquals(32, t.getArrayLength());
-		assertEquals(0, t.getHashLength());
-	}
-
-	public void testStringAndIntegerKeys() {
-		LuaTable t = new_Table();
-
-		for (int i = 0; i < 10; ++i) {
-			LuaString str = LuaValue.valueOf(String.valueOf(i));
-			t.set(i, str);
-			t.set(str, LuaInteger.valueOf(i));
-		}
-
-		assertTrue(t.getArrayLength() >= 8); // 1, 2, ..., 9
-		assertTrue(t.getArrayLength() <= 16);
-		assertTrue(t.getHashLength() >= 11); // 0, "0", "1", ..., "9"
-		assertTrue(t.getHashLength() <= 33);
-
-		LuaValue[] keys = keys(t);
-
-		int intKeys = 0;
-		int stringKeys = 0;
-
-		assertEquals(20, keys.length);
-		for (int i = 0; i < keys.length; ++i) {
-			LuaValue k = keys[i];
-
-			if (k instanceof LuaInteger) {
-				final int ik = k.toint();
-				assertTrue(ik >= 0 && ik < 10);
-				final int mask = 1<<ik;
-				assertTrue((intKeys & mask) == 0);
-				intKeys |= mask;
-			} else if (k instanceof LuaString) {
-				final int ik = Integer.parseInt(k.strvalue().tojstring());
-				assertEquals(String.valueOf(ik), k.strvalue().tojstring());
-				assertTrue(ik >= 0 && ik < 10);
-				final int mask = 1<<ik;
-				assertTrue("Key \"" + ik + "\" found more than once", (stringKeys & mask) == 0);
-				stringKeys |= mask;
-			} else {
-				fail("Unexpected type of key found");
-			}
-		}
-
-		assertEquals(0x03FF, intKeys);
-		assertEquals(0x03FF, stringKeys);
-	}
-
-	public void testBadInitialCapacity() {
-		LuaTable t = new_Table(0, 1);
-
-		t.set("test", LuaValue.valueOf("foo"));
-		t.set("explode", LuaValue.valueOf("explode"));
-		assertEquals(2, keyCount(t));
-	}
-
-	public void testRemove0() {
-		LuaTable t = new_Table(2, 0);
-
-		t.set(1, LuaValue.valueOf("foo"));
-		t.set(2, LuaValue.valueOf("bah"));
-		assertNotSame(LuaValue.NIL, t.get(1));
-		assertNotSame(LuaValue.NIL, t.get(2));
-		assertEquals(LuaValue.NIL, t.get(3));
-
-		t.set(1, LuaValue.NIL);
-		t.set(2, LuaValue.NIL);
-		t.set(3, LuaValue.NIL);
-		assertEquals(LuaValue.NIL, t.get(1));
-		assertEquals(LuaValue.NIL, t.get(2));
-		assertEquals(LuaValue.NIL, t.get(3));
-	}
-
-	public void testRemove1() {
-		LuaTable t = new_Table(0, 1);
-
-		t.set("test", LuaValue.valueOf("foo"));
-		t.set("explode", LuaValue.NIL);
-		t.set(42, LuaValue.NIL);
-		t.set(new_Table(), LuaValue.NIL);
-		t.set("test", LuaValue.NIL);
-		assertEquals(0, keyCount(t));
-
-		t.set(10, LuaInteger.valueOf(5));
-		t.set(10, LuaValue.NIL);
-		assertEquals(0, keyCount(t));
-	}
-
-	public void testRemove2() {
-		LuaTable t = new_Table(0, 1);
-
-		t.set("test", LuaValue.valueOf("foo"));
-		t.set("string", LuaInteger.valueOf(10));
-		assertEquals(2, keyCount(t));
-
-		t.set("string", LuaValue.NIL);
-		t.set("three", LuaValue.valueOf(3.14));
-		assertEquals(2, keyCount(t));
-
-		t.set("test", LuaValue.NIL);
-		assertEquals(1, keyCount(t));
-
-		t.set(10, LuaInteger.valueOf(5));
-		assertEquals(2, keyCount(t));
-
-		t.set(10, LuaValue.NIL);
-		assertEquals(1, keyCount(t));
-
-		t.set("three", LuaValue.NIL);
-		assertEquals(0, keyCount(t));
-	}
-
-	public void testShrinkNonPowerOfTwoArray() {
-		LuaTable t = new_Table(6, 2);
-
-		t.set(1, "one");
-		t.set(2, "two");
-		t.set(3, "three");
-		t.set(4, "four");
-		t.set(5, "five");
-		t.set(6, "six");
-
-		t.set("aa", "aaa");
-		t.set("bb", "bbb");
-
-		t.set(3, LuaValue.NIL);
-		t.set(4, LuaValue.NIL);
-		t.set(6, LuaValue.NIL);
-
-		t.set("cc", "ccc");
-		t.set("dd", "ddd");
-
-		assertEquals(4, t.getArrayLength());
-		assertTrue(t.getHashLength() < 10);
-		assertEquals(5, t.hashEntries);
-		assertEquals("one", t.get(1).tojstring());
-		assertEquals("two", t.get(2).tojstring());
-		assertEquals(LuaValue.NIL, t.get(3));
-		assertEquals(LuaValue.NIL, t.get(4));
-		assertEquals("five", t.get(5).tojstring());
-		assertEquals(LuaValue.NIL, t.get(6));
-		assertEquals("aaa", t.get("aa").tojstring());
-		assertEquals("bbb", t.get("bb").tojstring());
-		assertEquals("ccc", t.get("cc").tojstring());
-		assertEquals("ddd", t.get("dd").tojstring());
-	}
-
-	public void testInOrderLuaLength() {
-		LuaTable t = new_Table();
-
-		for (int i = 1; i <= 32; ++i) {
-			t.set(i, LuaValue.valueOf("Test Value! " + i));
-			assertEquals(i, t.length());
-		}
-	}
-
-	public void testOutOfOrderLuaLength() {
-		LuaTable t = new_Table();
-
-		for (int j = 8; j < 32; j += 8) {
-			for (int i = j; i > 0; --i) {
-				t.set(i, LuaValue.valueOf("Test Value! " + i));
-			}
-			assertEquals(j, t.length());
-		}
-	}
-
-	public void testStringKeysLuaLength() {
-		LuaTable t = new_Table();
-
-		for (int i = 1; i <= 32; ++i) {
-			t.set("str-" + i, LuaValue.valueOf("String Key Test Value! " + i));
-			assertEquals(0, t.length());
-		}
-	}
-
-	public void testMixedKeysLuaLength() {
-		LuaTable t = new_Table();
-
-		for (int i = 1; i <= 32; ++i) {
-			t.set("str-" + i, LuaValue.valueOf("String Key Test Value! " + i));
-			t.set(i, LuaValue.valueOf("Int Key Test Value! " + i));
-			assertEquals(i, t.length());
-		}
-	}
-
-	private static final void compareLists(LuaTable t, Vector v) {
-		int n = v.size();
-		assertEquals(v.size(), t.length());
-		for (int j = 0; j < n; j++) {
-			Object vj = v.elementAt(j);
-			Object tj = t.get(j+1).tojstring();
-			vj = ((LuaString) vj).tojstring();
-			assertEquals(vj, tj);
-		}
-	}
-
-	public void testInsertBeginningOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-
-		for (int i = 1; i <= 32; ++i) {
-			LuaString test = LuaValue.valueOf("Test Value! " + i);
-			t.insert(1, test);
-			v.insertElementAt(test, 0);
-			compareLists(t, v);
-		}
-	}
-
-	public void testInsertEndOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-
-		for (int i = 1; i <= 32; ++i) {
-			LuaString test = LuaValue.valueOf("Test Value! " + i);
-			t.insert(0, test);
-			v.insertElementAt(test, v.size());
-			compareLists(t, v);
-		}
-	}
-
-	public void testInsertMiddleOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-
-		for (int i = 1; i <= 32; ++i) {
-			LuaString test = LuaValue.valueOf("Test Value! " + i);
-			int m = i/2;
-			t.insert(m+1, test);
-			v.insertElementAt(test, m);
-			compareLists(t, v);
-		}
-	}
-
-	private static final void prefillLists(LuaTable t, Vector v) {
-		for (int i = 1; i <= 32; ++i) {
-			LuaString test = LuaValue.valueOf("Test Value! " + i);
-			t.insert(0, test);
-			v.insertElementAt(test, v.size());
-		}
-	}
-
-	public void testRemoveBeginningOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-		prefillLists(t, v);
-		for (int i = 1; i <= 32; ++i) {
-			t.remove(1);
-			v.removeElementAt(0);
-			compareLists(t, v);
-		}
-	}
-
-	public void testRemoveEndOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-		prefillLists(t, v);
-		for (int i = 1; i <= 32; ++i) {
-			t.remove(0);
-			v.removeElementAt(v.size()-1);
-			compareLists(t, v);
-		}
-	}
-
-	public void testRemoveMiddleOfList() {
-		LuaTable t = new_Table();
-		Vector v = new Vector();
-		prefillLists(t, v);
-		for (int i = 1; i <= 32; ++i) {
-			int m = v.size()/2;
-			t.remove(m+1);
-			v.removeElementAt(m);
-			compareLists(t, v);
-		}
-	}
-
-	public void testRemoveWhileIterating() {
-		LuaTable t = LuaValue.tableOf(
-			new LuaValue[] { LuaValue.valueOf("a"), LuaValue.valueOf("aa"), LuaValue.valueOf("b"),
-					LuaValue.valueOf("bb"), LuaValue.valueOf("c"), LuaValue.valueOf("cc"), LuaValue.valueOf("d"),
-					LuaValue.valueOf("dd"), LuaValue.valueOf("e"), LuaValue.valueOf("ee"), },
-			new LuaValue[] { LuaValue.valueOf("11"), LuaValue.valueOf("22"), LuaValue.valueOf("33"),
-					LuaValue.valueOf("44"), LuaValue.valueOf("55"), });
-		// Find expected order after removal.
-		java.util.List<String> expected = new java.util.ArrayList<String>();
-		Varargs n;
-		int i;
-		for (n = t.next(LuaValue.NIL), i = 0; !n.arg1().isnil(); n = t.next(n.arg1()), ++i) {
-			if (i%2 == 0)
-				expected.add(n.arg1() + "=" + n.arg(2));
-		}
-		// Remove every other key while iterating over the table.
-		for (n = t.next(LuaValue.NIL), i = 0; !n.arg1().isnil(); n = t.next(n.arg1()), ++i) {
-			if (i%2 != 0)
-				t.set(n.arg1(), LuaValue.NIL);
-		}
-		// Iterate over remaining table, and form list of entries still in table.
-		java.util.List<String> actual = new java.util.ArrayList<String>();
-		for (n = t.next(LuaValue.NIL); !n.arg1().isnil(); n = t.next(n.arg1())) {
-			actual.add(n.arg1() + "=" + n.arg(2));
-		}
-		assertEquals(expected, actual);
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/UTF8StreamTest.java

@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-public class UTF8StreamTest extends TestCase {
-
-	public void testUtf8CharsInStream() {
-		String script = "x = \"98\u00b0: today's temp!\"\n" + "print('x = ', x)\n" + "return x";
-		Globals globals = JsePlatform.standardGlobals();
-		LuaValue chunk = globals.load(script);
-		LuaValue result = chunk.call();
-		String str = result.tojstring();
-		assertEquals("98\u00b0: today's temp!", str);
-	}
-
-}

luaj-test/src/test/java/org/luaj/vm2/VarargsTest.java

@@ -1,226 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2012 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import junit.framework.TestCase;
-
-/**
- * Tests of basic unary and binary operators on main value types.
- */
-public class VarargsTest extends TestCase {
-
-	static LuaValue   A         = LuaValue.valueOf("a");
-	static LuaValue   B         = LuaValue.valueOf("b");
-	static LuaValue   C         = LuaValue.valueOf("c");
-	static LuaValue   D         = LuaValue.valueOf("d");
-	static LuaValue   E         = LuaValue.valueOf("e");
-	static LuaValue   F         = LuaValue.valueOf("f");
-	static LuaValue   G         = LuaValue.valueOf("g");
-	static LuaValue   H         = LuaValue.valueOf("h");
-	static LuaValue   Z         = LuaValue.valueOf("z");
-	static LuaValue   NIL       = LuaValue.NIL;
-	static Varargs    A_G       = LuaValue.varargsOf(new LuaValue[] { A, B, C, D, E, F, G });
-	static Varargs    B_E       = LuaValue.varargsOf(new LuaValue[] { B, C, D, E });
-	static Varargs    C_G       = LuaValue.varargsOf(new LuaValue[] { C, D, E, F, G });
-	static Varargs    C_E       = LuaValue.varargsOf(new LuaValue[] { C, D, E });
-	static Varargs    DE        = LuaValue.varargsOf(new LuaValue[] { D, E });
-	static Varargs    E_G       = LuaValue.varargsOf(new LuaValue[] { E, F, G });
-	static Varargs    FG        = LuaValue.varargsOf(new LuaValue[] { F, G });
-	static LuaValue[] Z_H_array = { Z, A, B, C, D, E, F, G, H };
-	static Varargs    A_G_alt   = new Varargs.ArrayPartVarargs(Z_H_array, 1, 7);
-	static Varargs    B_E_alt   = new Varargs.ArrayPartVarargs(Z_H_array, 2, 4);
-	static Varargs    C_G_alt   = new Varargs.ArrayPartVarargs(Z_H_array, 3, 5);
-	static Varargs    C_E_alt   = new Varargs.ArrayPartVarargs(Z_H_array, 3, 3);
-	static Varargs    C_E_alt2  = LuaValue.varargsOf(C, D, E);
-	static Varargs    DE_alt    = new Varargs.PairVarargs(D, E);
-	static Varargs    DE_alt2   = LuaValue.varargsOf(D, E);
-	static Varargs    E_G_alt   = new Varargs.ArrayPartVarargs(Z_H_array, 5, 3);
-	static Varargs    FG_alt    = new Varargs.PairVarargs(F, G);
-	static Varargs    NONE      = LuaValue.NONE;
-
-	static void expectEquals(Varargs x, Varargs y) {
-		assertEquals(x.narg(), y.narg());
-		assertEquals(x.arg1(), y.arg1());
-		assertEquals(x.arg(0), y.arg(0));
-		assertEquals(x.arg(-1), y.arg(-1));
-		assertEquals(x.arg(2), y.arg(2));
-		assertEquals(x.arg(3), y.arg(3));
-		for (int i = 4; i < x.narg()+2; ++i)
-			assertEquals(x.arg(i), y.arg(i));
-	}
-
-	public void testSanity() {
-		expectEquals(A_G, A_G);
-		expectEquals(A_G_alt, A_G_alt);
-		expectEquals(A_G, A_G_alt);
-		expectEquals(B_E, B_E_alt);
-		expectEquals(C_G, C_G_alt);
-		expectEquals(C_E, C_E_alt);
-		expectEquals(C_E, C_E_alt2);
-		expectEquals(DE, DE_alt);
-		expectEquals(DE, DE_alt2);
-		expectEquals(E_G, E_G_alt);
-		expectEquals(FG, FG_alt);
-		expectEquals(FG_alt, FG_alt);
-		expectEquals(A, A);
-		expectEquals(NONE, NONE);
-		expectEquals(NIL, NIL);
-	}
-
-	public void testNegativeIndices() {
-		expectNegSubargsError(A_G);
-		expectNegSubargsError(A_G_alt);
-		expectNegSubargsError(B_E);
-		expectNegSubargsError(B_E_alt);
-		expectNegSubargsError(C_G);
-		expectNegSubargsError(C_G_alt);
-		expectNegSubargsError(C_E);
-		expectNegSubargsError(C_E_alt);
-		expectNegSubargsError(C_E_alt2);
-		expectNegSubargsError(DE);
-		expectNegSubargsError(DE_alt);
-		expectNegSubargsError(DE_alt2);
-		expectNegSubargsError(E_G);
-		expectNegSubargsError(FG);
-		expectNegSubargsError(A);
-		expectNegSubargsError(NONE);
-		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() {
-		standardTestsA_G(A_G);
-		standardTestsA_G(A_G_alt);
-		standardTestsC_G(C_G);
-		standardTestsC_G(C_G_alt);
-		standardTestsE_G(E_G);
-		standardTestsE_G(E_G_alt);
-		standardTestsFG(FG);
-		standardTestsFG(FG_alt);
-		standardTestsNone(NONE);
-	}
-
-	public void testVarargsMore() {
-		Varargs a_g;
-		a_g = LuaValue.varargsOf(new LuaValue[] { A, }, LuaValue.varargsOf(new LuaValue[] { B, C, D, E, F, G }));
-		standardTestsA_G(a_g);
-		a_g = LuaValue.varargsOf(new LuaValue[] { A, B, }, LuaValue.varargsOf(new LuaValue[] { C, D, E, F, G }));
-		standardTestsA_G(a_g);
-		a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, }, LuaValue.varargsOf(new LuaValue[] { D, E, F, G }));
-		standardTestsA_G(a_g);
-		a_g = LuaValue.varargsOf(new LuaValue[] { A, B, C, D, }, LuaValue.varargsOf(E, F, G));
-		standardTestsA_G(a_g);
-		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);
-	}
-
-	public void testArrayPartMore() {
-		Varargs a_g;
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 1, new Varargs.ArrayPartVarargs(Z_H_array, 2, 6));
-		standardTestsA_G(a_g);
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 2, new Varargs.ArrayPartVarargs(Z_H_array, 3, 5));
-		standardTestsA_G(a_g);
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 3, new Varargs.ArrayPartVarargs(Z_H_array, 4, 4));
-		standardTestsA_G(a_g);
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 4, new Varargs.ArrayPartVarargs(Z_H_array, 5, 3));
-		standardTestsA_G(a_g);
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 5, new Varargs.ArrayPartVarargs(Z_H_array, 6, 2));
-		standardTestsA_G(a_g);
-		a_g = new Varargs.ArrayPartVarargs(Z_H_array, 1, 6, new Varargs.ArrayPartVarargs(Z_H_array, 7, 1));
-		standardTestsA_G(a_g);
-	}
-
-	static void expectNegSubargsError(Varargs v) {
-		String expected_msg = "bad argument #1: start must be > 0";
-		try {
-			v.subargs(0);
-			fail("Failed to throw exception for index 0");
-		} catch (LuaError e) {
-			assertEquals(expected_msg, e.getMessage());
-		}
-		try {
-			v.subargs(-1);
-			fail("Failed to throw exception for index -1");
-		} catch (LuaError e) {
-			assertEquals(expected_msg, e.getMessage());
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/WeakTableTest.java

@@ -1,265 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2;
-
-import java.lang.ref.WeakReference;
-
-abstract public class WeakTableTest extends TableTest {
-
-	public static class MyData {
-		public final int value;
-
-		public MyData(int value) {
-			this.value = value;
-		}
-
-		public int hashCode() {
-			return value;
-		}
-
-		public boolean equals(Object o) {
-			return (o instanceof MyData) && ((MyData) o).value == value;
-		}
-
-		public String toString() {
-			return "mydata-" + value;
-		}
-	}
-
-	static void collectGarbage() {
-		Runtime rt = Runtime.getRuntime();
-		rt.gc();
-		try {
-			Thread.sleep(20);
-			rt.gc();
-			Thread.sleep(20);
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-		rt.gc();
-	}
-
-	public static class WeakValueTableTest extends WeakTableTest {
-		protected LuaTable new_Table() { return WeakTable.make(false, true); }
-
-		protected LuaTable new_Table(int n, int m) { return WeakTable.make(false, true); }
-
-		public void testWeakValuesTable() {
-			LuaTable t = new_Table();
-
-			Object obj = new Object();
-			LuaTable tableValue = new LuaTable();
-			LuaString stringValue = LuaString.valueOf("this is a test");
-			LuaTable tableValue2 = new LuaTable();
-
-			t.set("table", tableValue);
-			t.set("userdata", LuaValue.userdataOf(obj, null));
-			t.set("string", stringValue);
-			t.set("string2", LuaValue.valueOf("another string"));
-			t.set(1, tableValue2);
-			assertTrue("table must have at least 4 elements", t.getHashLength() >= 4);
-			assertTrue("array part must have 1 element", t.getArrayLength() >= 1);
-
-			// check that table can be used to get elements 
-			assertEquals(tableValue, t.get("table"));
-			assertEquals(stringValue, t.get("string"));
-			assertEquals(obj, t.get("userdata").checkuserdata());
-			assertEquals(tableValue2, t.get(1));
-
-			// nothing should be collected, since we have strong references here
-			collectGarbage();
-
-			// check that elements are still there 
-			assertEquals(tableValue, t.get("table"));
-			assertEquals(stringValue, t.get("string"));
-			assertEquals(obj, t.get("userdata").checkuserdata());
-			assertEquals(tableValue2, t.get(1));
-
-			// drop our strong references
-			obj = null;
-			tableValue = null;
-			tableValue2 = null;
-			stringValue = null;
-
-			// Garbage collection should cause weak entries to be dropped.
-			collectGarbage();
-
-			// check that they are dropped
-			assertEquals(LuaValue.NIL, t.get("table"));
-			assertEquals(LuaValue.NIL, t.get("userdata"));
-			assertEquals(LuaValue.NIL, t.get(1));
-			assertFalse("strings should not be in weak references", t.get("string").isnil());
-		}
-	}
-
-	public static class WeakKeyTableTest extends WeakTableTest {
-		protected LuaTable new_Table() { return WeakTable.make(true, false); }
-
-		protected LuaTable new_Table(int n, int m) { return WeakTable.make(true, false); }
-
-		public void testWeakKeysTable() {
-			LuaTable t = WeakTable.make(true, false);
-
-			LuaValue key = LuaValue.userdataOf(new MyData(111));
-			LuaValue val = LuaValue.userdataOf(new MyData(222));
-
-			// set up the table
-			t.set(key, val);
-			assertEquals(val, t.get(key));
-			System.gc();
-			assertEquals(val, t.get(key));
-
-			// drop key and value references, replace them with new ones
-			WeakReference origkey = new WeakReference(key);
-			WeakReference origval = new WeakReference(val);
-			key = LuaValue.userdataOf(new MyData(111));
-			val = LuaValue.userdataOf(new MyData(222));
-
-			// new key and value should be interchangeable (feature of this test class)
-			assertEquals(key, origkey.get());
-			assertEquals(val, origval.get());
-			assertEquals(val, t.get(key));
-			assertEquals(val, t.get((LuaValue) origkey.get()));
-			assertEquals(origval.get(), t.get(key));
-
-			// value should not be reachable after gc
-			collectGarbage();
-			assertEquals(null, origkey.get());
-			assertEquals(LuaValue.NIL, t.get(key));
-			collectGarbage();
-			assertEquals(null, origval.get());
-		}
-
-		public void testNext() {
-			LuaTable t = WeakTable.make(true, true);
-
-			LuaValue key = LuaValue.userdataOf(new MyData(111));
-			LuaValue val = LuaValue.userdataOf(new MyData(222));
-			LuaValue key2 = LuaValue.userdataOf(new MyData(333));
-			LuaValue val2 = LuaValue.userdataOf(new MyData(444));
-			LuaValue key3 = LuaValue.userdataOf(new MyData(555));
-			LuaValue val3 = LuaValue.userdataOf(new MyData(666));
-
-			// set up the table
-			t.set(key, val);
-			t.set(key2, val2);
-			t.set(key3, val3);
-
-			// forget one of the keys
-			key2 = null;
-			val2 = null;
-			collectGarbage();
-
-			// table should have 2 entries
-			int size = 0;
-			for (LuaValue k = t.next(LuaValue.NIL).arg1(); !k.isnil(); k = t.next(k).arg1()) {
-				size++;
-			}
-			assertEquals(2, size);
-		}
-	}
-
-	public static class WeakKeyValueTableTest extends WeakTableTest {
-		protected LuaTable new_Table() { return WeakTable.make(true, true); }
-
-		protected LuaTable new_Table(int n, int m) { return WeakTable.make(true, true); }
-
-		public void testWeakKeysValuesTable() {
-			LuaTable t = WeakTable.make(true, true);
-
-			LuaValue key = LuaValue.userdataOf(new MyData(111));
-			LuaValue val = LuaValue.userdataOf(new MyData(222));
-			LuaValue key2 = LuaValue.userdataOf(new MyData(333));
-			LuaValue val2 = LuaValue.userdataOf(new MyData(444));
-			LuaValue key3 = LuaValue.userdataOf(new MyData(555));
-			LuaValue val3 = LuaValue.userdataOf(new MyData(666));
-
-			// set up the table
-			t.set(key, val);
-			t.set(key2, val2);
-			t.set(key3, val3);
-			assertEquals(val, t.get(key));
-			assertEquals(val2, t.get(key2));
-			assertEquals(val3, t.get(key3));
-			System.gc();
-			assertEquals(val, t.get(key));
-			assertEquals(val2, t.get(key2));
-			assertEquals(val3, t.get(key3));
-
-			// drop key and value references, replace them with new ones
-			WeakReference origkey = new WeakReference(key);
-			WeakReference origval = new WeakReference(val);
-			WeakReference origkey2 = new WeakReference(key2);
-			WeakReference origval2 = new WeakReference(val2);
-			WeakReference origkey3 = new WeakReference(key3);
-			WeakReference origval3 = new WeakReference(val3);
-			key = LuaValue.userdataOf(new MyData(111));
-			val = LuaValue.userdataOf(new MyData(222));
-			key2 = LuaValue.userdataOf(new MyData(333));
-			// don't drop val2, or key3
-			val3 = LuaValue.userdataOf(new MyData(666));
-
-			// no values should be reachable after gc
-			collectGarbage();
-			assertEquals(null, origkey.get());
-			assertEquals(null, origval.get());
-			assertEquals(null, origkey2.get());
-			assertEquals(null, origval3.get());
-			assertEquals(LuaValue.NIL, t.get(key));
-			assertEquals(LuaValue.NIL, t.get(key2));
-			assertEquals(LuaValue.NIL, t.get(key3));
-
-			// all originals should be gone after gc, then access
-			val2 = null;
-			key3 = null;
-			collectGarbage();
-			assertEquals(null, origval2.get());
-			assertEquals(null, origkey3.get());
-		}
-
-		public void testReplace() {
-			LuaTable t = WeakTable.make(true, true);
-
-			LuaValue key = LuaValue.userdataOf(new MyData(111));
-			LuaValue val = LuaValue.userdataOf(new MyData(222));
-			LuaValue key2 = LuaValue.userdataOf(new MyData(333));
-			LuaValue val2 = LuaValue.userdataOf(new MyData(444));
-			LuaValue key3 = LuaValue.userdataOf(new MyData(555));
-			LuaValue val3 = LuaValue.userdataOf(new MyData(666));
-
-			// set up the table
-			t.set(key, val);
-			t.set(key2, val2);
-			t.set(key3, val3);
-
-			LuaValue val4 = LuaValue.userdataOf(new MyData(777));
-			t.set(key2, val4);
-
-			// table should have 3 entries
-			int size = 0;
-			for (LuaValue k = t.next(LuaValue.NIL).arg1(); !k.isnil() && size < 1000; k = t.next(k).arg1()) {
-				size++;
-			}
-			assertEquals(3, size);
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/AbstractUnitTests.java

@@ -1,122 +0,0 @@
-package org.luaj.vm2.compiler;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.PrintStream;
-import java.net.MalformedURLException;
-import java.net.URL;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals;
-import org.luaj.vm2.LoadState;
-import org.luaj.vm2.Print;
-import org.luaj.vm2.Prototype;
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-abstract public class AbstractUnitTests extends TestCase {
-
-	private final String dir;
-	private final String jar;
-	private Globals      globals;
-
-	public AbstractUnitTests(String zipdir, String zipfile, String dir) {
-		URL zip = null;
-		zip = getClass().getResource(zipfile);
-		if (zip == null) {
-			File file = new File(zipdir + "/" + zipfile);
-			try {
-				if (file.exists())
-					zip = file.toURI().toURL();
-			} catch (MalformedURLException e) {
-				e.printStackTrace();
-			}
-		}
-		if (zip == null)
-			throw new RuntimeException("not found: " + zipfile);
-		this.jar = "jar:" + zip.toExternalForm() + "!/";
-		this.dir = dir;
-	}
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		globals = JsePlatform.standardGlobals();
-	}
-
-	protected String pathOfFile(String file) {
-		return jar + dir + "/" + file;
-	}
-
-	protected InputStream inputStreamOfPath(String path) throws IOException {
-		URL url = new URL(path);
-		return url.openStream();
-	}
-
-	protected InputStream inputStreamOfFile(String file) throws IOException {
-		return inputStreamOfPath(pathOfFile(file));
-	}
-
-	protected void doTest(String file) {
-		try {
-			// load source from jar
-			String path = pathOfFile(file);
-			byte[] lua = bytesFromJar(path);
-
-			// compile in memory
-			InputStream is = new ByteArrayInputStream(lua);
-			Prototype p = globals.loadPrototype(is, "@" + file, "bt");
-			String actual = protoToString(p);
-
-			// load expected value from jar
-			byte[] luac = bytesFromJar(path.substring(0, path.length()-4) + ".lc");
-			Prototype e = loadFromBytes(luac, file);
-			String expected = protoToString(e);
-
-			// compare results
-			assertEquals(expected, actual);
-
-			// dump into memory
-			ByteArrayOutputStream baos = new ByteArrayOutputStream();
-			DumpState.dump(p, baos, false);
-			byte[] dumped = baos.toByteArray();
-
-			// re-undump
-			Prototype p2 = loadFromBytes(dumped, file);
-			String actual2 = protoToString(p2);
-
-			// compare again
-			assertEquals(actual, actual2);
-
-		} catch (IOException e) {
-			fail(e.toString());
-		}
-	}
-
-	protected byte[] bytesFromJar(String path) throws IOException {
-		InputStream is = inputStreamOfPath(path);
-		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		byte[] buffer = new byte[2048];
-		int n;
-		while ( (n = is.read(buffer)) >= 0 )
-			baos.write(buffer, 0, n);
-		is.close();
-		return baos.toByteArray();
-	}
-
-	protected Prototype loadFromBytes(byte[] bytes, String script) throws IOException {
-		InputStream is = new ByteArrayInputStream(bytes);
-		return globals.loadPrototype(is, script, "b");
-	}
-
-	protected String protoToString(Prototype p) {
-		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		PrintStream ps = new PrintStream(baos);
-		Print.ps = ps;
-		new Print().printFunction(p, true);
-		return baos.toString();
-	}
-
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/CompilerUnitTests.java

@@ -1,62 +0,0 @@
-package org.luaj.vm2.compiler;
-
-public class CompilerUnitTests extends AbstractUnitTests {
-
-	public CompilerUnitTests() {
-		super("test/lua", "luaj3.0-tests.zip", "lua5.2.1-tests");
-	}
-
-	public void testAll() { doTest("all.lua"); }
-
-	public void testApi() { doTest("api.lua"); }
-
-	public void testAttrib() { doTest("attrib.lua"); }
-
-	public void testBig() { doTest("big.lua"); }
-
-	public void testBitwise() { doTest("bitwise.lua"); }
-
-	public void testCalls() { doTest("calls.lua"); }
-
-	public void testChecktable() { doTest("checktable.lua"); }
-
-	public void testClosure() { doTest("closure.lua"); }
-
-	public void testCode() { doTest("code.lua"); }
-
-	public void testConstruct() { doTest("constructs.lua"); }
-
-	public void testCoroutine() { doTest("coroutine.lua"); }
-
-	public void testDb() { doTest("db.lua"); }
-
-	public void testErrors() { doTest("errors.lua"); }
-
-	public void testEvents() { doTest("events.lua"); }
-
-	public void testFiles() { doTest("files.lua"); }
-
-	public void testGc() { doTest("gc.lua"); }
-
-	public void testGoto() { doTest("goto.lua"); }
-
-	public void testLiterals() { doTest("literals.lua"); }
-
-	public void testLocals() { doTest("locals.lua"); }
-
-	public void testMain() { doTest("main.lua"); }
-
-	public void testMath() { doTest("math.lua"); }
-
-	public void testNextvar() { doTest("nextvar.lua"); }
-
-	public void testPm() { doTest("pm.lua"); }
-
-	public void testSort() { doTest("sort.lua"); }
-
-	public void testStrings() { doTest("strings.lua"); }
-
-	public void testVararg() { doTest("vararg.lua"); }
-
-	public void testVerybig() { doTest("verybig.lua"); }
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/DumpLoadEndianIntTest.java

@@ -1,139 +0,0 @@
-package org.luaj.vm2.compiler;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.Reader;
-import java.io.StringReader;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals;
-import org.luaj.vm2.LoadState;
-import org.luaj.vm2.LuaClosure;
-import org.luaj.vm2.LuaFunction;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.Prototype;
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-public class DumpLoadEndianIntTest extends TestCase {
-	private static final String SAVECHUNKS = "SAVECHUNKS";
-
-	private static final boolean SHOULDPASS  = true;
-	private static final boolean SHOULDFAIL  = false;
-	private static final String  mixedscript = "return tostring(1234)..'-#!-'..tostring(23.75)";
-	private static final String  intscript   = "return tostring(1234)..'-#!-'..tostring(23)";
-	private static final String  withdoubles = "1234-#!-23.75";
-	private static final String  withints    = "1234-#!-23";
-
-	private Globals globals;
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		globals = JsePlatform.standardGlobals();
-		DumpState.ALLOW_INTEGER_CASTING = false;
-	}
-
-	public void testBigDoubleCompile() {
-		doTest(false, DumpState.NUMBER_FORMAT_FLOATS_OR_DOUBLES, false, mixedscript, withdoubles, withdoubles,
-			SHOULDPASS);
-		doTest(false, DumpState.NUMBER_FORMAT_FLOATS_OR_DOUBLES, true, mixedscript, withdoubles, withdoubles,
-			SHOULDPASS);
-	}
-
-	public void testLittleDoubleCompile() {
-		doTest(true, DumpState.NUMBER_FORMAT_FLOATS_OR_DOUBLES, false, mixedscript, withdoubles, withdoubles,
-			SHOULDPASS);
-		doTest(true, DumpState.NUMBER_FORMAT_FLOATS_OR_DOUBLES, true, mixedscript, withdoubles, withdoubles,
-			SHOULDPASS);
-	}
-
-	public void testBigIntCompile() {
-		DumpState.ALLOW_INTEGER_CASTING = true;
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, false, mixedscript, withdoubles, withints, SHOULDPASS);
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, true, mixedscript, withdoubles, withints, SHOULDPASS);
-		DumpState.ALLOW_INTEGER_CASTING = false;
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, false, mixedscript, withdoubles, withints, SHOULDFAIL);
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, true, mixedscript, withdoubles, withints, SHOULDFAIL);
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, false, intscript, withints, withints, SHOULDPASS);
-		doTest(false, DumpState.NUMBER_FORMAT_INTS_ONLY, true, intscript, withints, withints, SHOULDPASS);
-	}
-
-	public void testLittleIntCompile() {
-		DumpState.ALLOW_INTEGER_CASTING = true;
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, false, mixedscript, withdoubles, withints, SHOULDPASS);
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, true, mixedscript, withdoubles, withints, SHOULDPASS);
-		DumpState.ALLOW_INTEGER_CASTING = false;
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, false, mixedscript, withdoubles, withints, SHOULDFAIL);
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, true, mixedscript, withdoubles, withints, SHOULDFAIL);
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, false, intscript, withints, withints, SHOULDPASS);
-		doTest(true, DumpState.NUMBER_FORMAT_INTS_ONLY, true, intscript, withints, withints, SHOULDPASS);
-	}
-
-	public void testBigNumpatchCompile() {
-		doTest(false, DumpState.NUMBER_FORMAT_NUM_PATCH_INT32, false, mixedscript, withdoubles, withdoubles,
-			SHOULDPASS);
-		doTest(false, DumpState.NUMBER_FORMAT_NUM_PATCH_INT32, true, mixedscript, withdoubles, withdoubles, SHOULDPASS);
-	}
-
-	public void testLittleNumpatchCompile() {
-		doTest(true, DumpState.NUMBER_FORMAT_NUM_PATCH_INT32, false, mixedscript, withdoubles, withdoubles, SHOULDPASS);
-		doTest(true, DumpState.NUMBER_FORMAT_NUM_PATCH_INT32, true, mixedscript, withdoubles, withdoubles, SHOULDPASS);
-	}
-
-	public void doTest(boolean littleEndian, int numberFormat, boolean stripDebug, String script,
-		String expectedPriorDump, String expectedPostDump, boolean shouldPass) {
-		try {
-
-			// compile into prototype
-			Reader reader = new StringReader(script);
-			Prototype p = globals.compilePrototype(reader, "script");
-
-			// double check script result before dumping
-			LuaFunction f = new LuaClosure(p, globals);
-			LuaValue r = f.call();
-			String actual = r.tojstring();
-			assertEquals(expectedPriorDump, actual);
-
-			// dump into bytes
-			ByteArrayOutputStream baos = new ByteArrayOutputStream();
-			try {
-				DumpState.dump(p, baos, stripDebug, numberFormat, littleEndian);
-				if (!shouldPass)
-					fail("dump should not have succeeded");
-			} catch (Exception e) {
-				if (shouldPass)
-					fail("dump threw " + e);
-				else
-					return;
-			}
-			byte[] dumped = baos.toByteArray();
-
-			// load again using compiler
-			InputStream is = new ByteArrayInputStream(dumped);
-			f = globals.load(is, "dumped", "b", globals).checkfunction();
-			r = f.call();
-			actual = r.tojstring();
-			assertEquals(expectedPostDump, actual);
-
-			// write test chunk
-			if (System.getProperty(SAVECHUNKS) != null && script.equals(mixedscript)) {
-				new File("build").mkdirs();
-				String filename = "build/test-" + (littleEndian? "little-": "big-")
-					+ (numberFormat == DumpState.NUMBER_FORMAT_FLOATS_OR_DOUBLES? "double-"
-						: numberFormat == DumpState.NUMBER_FORMAT_INTS_ONLY? "int-"
-							: numberFormat == DumpState.NUMBER_FORMAT_NUM_PATCH_INT32? "numpatch4-": "???-")
-					+ (stripDebug? "nodebug-": "debug-") + "bin.lua";
-				FileOutputStream fos = new FileOutputStream(filename);
-				fos.write(dumped);
-				fos.close();
-			}
-
-		} catch (IOException e) {
-			fail(e.toString());
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/LuaParserTests.java

@@ -1,28 +0,0 @@
-package org.luaj.vm2.compiler;
-
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.parser.LuaParser;
-
-public class LuaParserTests extends CompilerUnitTests {
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		LuaValue.valueOf(true);
-	}
-
-	protected void doTest(String file) {
-		try {
-			InputStream is = inputStreamOfFile(file);
-			Reader r = new InputStreamReader(is, "ISO-8859-1");
-			LuaParser parser = new LuaParser(r);
-			parser.Chunk();
-		} catch (Exception e) {
-			fail(e.getMessage());
-			e.printStackTrace();
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/RegressionTests.java

@@ -1,34 +0,0 @@
-package org.luaj.vm2.compiler;
-
-/**
- * Framework to add regression tests as problem areas are found.
- * 
- * To add a new regression test: 1) run "unpack.sh" in the project root 2) add a
- * new "lua" file in the "regressions" subdirectory 3) run "repack.sh" in the
- * project root 4) add a line to the source file naming the new test
- * 
- * After adding a test, check in the zip file rather than the individual
- * regression test files.
- * 
- * @author jrosebor
- */
-public class RegressionTests extends AbstractUnitTests {
-
-	public RegressionTests() {
-		super("test/lua", "luaj3.0-tests.zip", "regressions");
-	}
-
-	public void testModulo() { doTest("modulo.lua"); }
-
-	public void testConstruct() { doTest("construct.lua"); }
-
-	public void testBigAttrs() { doTest("bigattr.lua"); }
-
-	public void testControlChars() { doTest("controlchars.lua"); }
-
-	public void testComparators() { doTest("comparators.lua"); }
-
-	public void testMathRandomseed() { doTest("mathrandomseed.lua"); }
-
-	public void testVarargs() { doTest("varargs.lua"); }
-}

luaj-test/src/test/java/org/luaj/vm2/compiler/SimpleTests.java

@@ -1,84 +0,0 @@
-package org.luaj.vm2.compiler;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals;
-import org.luaj.vm2.LuaDouble;
-import org.luaj.vm2.LuaInteger;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.jse.JsePlatform;
-
-public class SimpleTests extends TestCase {
-
-	private Globals globals;
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		globals = JsePlatform.standardGlobals();
-	}
-
-	private void doTest(String script) {
-		try {
-			LuaValue c = globals.load(script, "script");
-			c.call();
-		} catch (Exception e) {
-			fail("i/o exception: " + e);
-		}
-	}
-
-	public void testTrivial() {
-		String s = "print( 2 )\n";
-		doTest(s);
-	}
-
-	public void testAlmostTrivial() {
-		String s = "print( 2 )\n" + "print( 3 )\n";
-		doTest(s);
-	}
-
-	public void testSimple() {
-		String s = "print( 'hello, world' )\n" + "for i = 2,4 do\n" + "	print( 'i', i )\n" + "end\n";
-		doTest(s);
-	}
-
-	public void testBreak() {
-		String s = "a=1\n" + "while true do\n" + "  if a>10 then\n" + "     break\n" + "  end\n" + "  a=a+1\n"
-			+ "  print( a )\n" + "end\n";
-		doTest(s);
-	}
-
-	public void testShebang() {
-		String s = "#!../lua\n" + "print( 2 )\n";
-		doTest(s);
-	}
-
-	public void testInlineTable() {
-		String s = "A = {g=10}\n" + "print( A )\n";
-		doTest(s);
-	}
-
-	public void testEqualsAnd() {
-		String s = "print( 1 == b and b )\n";
-		doTest(s);
-	}
-
-	private static final int[]    samehash = { 0, 1, -1, 2, -2, 4, 8, 16, 32, Integer.MAX_VALUE, Integer.MIN_VALUE };
-	private static final double[] diffhash = { .5, 1, 1.5, 1, .5, 1.5, 1.25, 2.5 };
-
-	public void testDoubleHashCode() {
-		for (int i = 0; i < samehash.length; i++) {
-			LuaValue j = LuaInteger.valueOf(samehash[i]);
-			LuaValue d = LuaDouble.valueOf(samehash[i]);
-			int hj = j.hashCode();
-			int hd = d.hashCode();
-			assertEquals(hj, hd);
-		}
-		for (int i = 0; i < diffhash.length; i += 2) {
-			LuaValue c = LuaValue.valueOf(diffhash[i+0]);
-			LuaValue d = LuaValue.valueOf(diffhash[i+1]);
-			int hc = c.hashCode();
-			int hd = d.hashCode();
-			assertTrue("hash codes are same: " + hc, hc != hd);
-		}
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/JsePlatformTest.java

@@ -1,20 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.Varargs;
-
-public class JsePlatformTest extends TestCase {
-	public void testLuaMainPassesArguments() {
-		Globals globals = JsePlatform.standardGlobals();
-		LuaValue chunk = globals.load("return #arg, arg.n, arg[2], arg[1]");
-		Varargs results = JsePlatform.luaMain(chunk, new String[] { "aaa", "bbb" });
-		assertEquals(results.narg(), 4);
-		assertEquals(results.arg(1), LuaValue.valueOf(2));
-		assertEquals(results.arg(2), LuaValue.valueOf(2));
-		assertEquals(results.arg(3), LuaValue.valueOf("bbb"));
-		assertEquals(results.arg(4), LuaValue.valueOf("aaa"));
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/LuaJavaCoercionTest.java

@@ -1,492 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.LuaError;
-import org.luaj.vm2.LuaInteger;
-import org.luaj.vm2.LuaString;
-import org.luaj.vm2.LuaTable;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.Varargs;
-import org.luaj.vm2.lib.MathLib;
-
-public class LuaJavaCoercionTest extends TestCase {
-
-	private static LuaValue  globals;
-	private static LuaValue  ZERO   = LuaValue.ZERO;
-	private static LuaValue  ONE    = LuaValue.ONE;
-	private static LuaValue  TWO    = LuaValue.valueOf(2);
-	private static LuaValue  THREE  = LuaValue.valueOf(3);
-	private static LuaString LENGTH = LuaString.valueOf("length");
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		globals = JsePlatform.standardGlobals();
-	}
-
-	public void testJavaIntToLuaInt() {
-		Integer i = Integer.valueOf(777);
-		LuaValue v = CoerceJavaToLua.coerce(i);
-		assertEquals(LuaInteger.class, v.getClass());
-		assertEquals(777, v.toint());
-	}
-
-	public void testLuaIntToJavaInt() {
-		LuaInteger i = LuaInteger.valueOf(777);
-		Object o = CoerceLuaToJava.coerce(i, int.class);
-		assertEquals(Integer.class, o.getClass());
-		assertEquals(777, ((Number) o).intValue());
-		o = CoerceLuaToJava.coerce(i, Integer.class);
-		assertEquals(Integer.class, o.getClass());
-		assertEquals(new Integer(777), o);
-	}
-
-	public void testJavaStringToLuaString() {
-		String s = new String("777");
-		LuaValue v = CoerceJavaToLua.coerce(s);
-		assertEquals(LuaString.class, v.getClass());
-		assertEquals("777", v.toString());
-	}
-
-	public void testLuaStringToJavaString() {
-		LuaString s = LuaValue.valueOf("777");
-		Object o = CoerceLuaToJava.coerce(s, String.class);
-		assertEquals(String.class, o.getClass());
-		assertEquals("777", o);
-	}
-
-	public void testJavaClassToLuaUserdata() {
-		LuaValue va = CoerceJavaToLua.coerce(ClassA.class);
-		LuaValue va1 = CoerceJavaToLua.coerce(ClassA.class);
-		LuaValue vb = CoerceJavaToLua.coerce(ClassB.class);
-		assertSame(va, va1);
-		assertNotSame(va, vb);
-		LuaValue vi = CoerceJavaToLua.coerce(new ClassA());
-		assertNotSame(va, vi);
-		assertTrue(vi.isuserdata());
-		assertTrue(vi.isuserdata(ClassA.class));
-		assertFalse(vi.isuserdata(ClassB.class));
-		LuaValue vj = CoerceJavaToLua.coerce(new ClassB());
-		assertNotSame(vb, vj);
-		assertTrue(vj.isuserdata());
-		assertFalse(vj.isuserdata(ClassA.class));
-		assertTrue(vj.isuserdata(ClassB.class));
-	}
-
-	static class ClassA {
-	}
-
-	static class ClassB {
-	}
-
-	public void testJavaIntArrayToLuaTable() {
-		int[] i = { 222, 333 };
-		LuaValue v = CoerceJavaToLua.coerce(i);
-		assertEquals(JavaArray.class, v.getClass());
-		assertEquals(LuaInteger.valueOf(222), v.get(ONE));
-		assertEquals(LuaInteger.valueOf(333), v.get(TWO));
-		assertEquals(TWO, v.get(LENGTH));
-		assertEquals(LuaValue.NIL, v.get(THREE));
-		assertEquals(LuaValue.NIL, v.get(ZERO));
-		v.set(ONE, LuaInteger.valueOf(444));
-		v.set(TWO, LuaInteger.valueOf(555));
-		assertEquals(444, i[0]);
-		assertEquals(555, i[1]);
-		assertEquals(LuaInteger.valueOf(444), v.get(ONE));
-		assertEquals(LuaInteger.valueOf(555), v.get(TWO));
-		try {
-			v.set(ZERO, LuaInteger.valueOf(777));
-			fail("array bound exception not thrown");
-		} catch (LuaError lee) {
-			// expected
-		}
-		try {
-			v.set(THREE, LuaInteger.valueOf(777));
-			fail("array bound exception not thrown");
-		} catch (LuaError lee) {
-			// expected
-		}
-	}
-
-	public void testLuaTableToJavaIntArray() {
-		LuaTable t = new LuaTable();
-		t.set(1, LuaInteger.valueOf(222));
-		t.set(2, LuaInteger.valueOf(333));
-		int[] i = null;
-		Object o = CoerceLuaToJava.coerce(t, int[].class);
-		assertEquals(int[].class, o.getClass());
-		i = (int[]) o;
-		assertEquals(2, i.length);
-		assertEquals(222, i[0]);
-		assertEquals(333, i[1]);
-	}
-
-	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 va = CoerceJavaToLua.coerce(a);
-		LuaValue vb = CoerceJavaToLua.coerce(b);
-		LuaValue vc = CoerceJavaToLua.coerce(c);
-
-		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.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.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);
-	}
-
-	public static class SampleClass {
-		public String sample() { return "void-args"; }
-
-		public String sample(int a) { return "int-args " + a; }
-
-		public String sample(int[] a) { return "int-array-args " + a[0] + "," + a[1]; }
-
-		public String sample(int[][] a) {
-			return "int-array-array-args " + a[0][0] + "," + a[0][1] + "," + a[1][0] + "," + a[1][1];
-		}
-	}
-
-	public void testMatchVoidArgs() {
-		LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
-		LuaValue result = v.method("sample");
-		assertEquals("void-args", result.toString());
-	}
-
-	public void testMatchIntArgs() {
-		LuaValue v = CoerceJavaToLua.coerce(new SampleClass());
-		LuaValue arg = CoerceJavaToLua.coerce(new Integer(123));
-		LuaValue result = v.method("sample", arg);
-		assertEquals("int-args 123", result.toString());
-	}
-
-	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());
-	}
-
-	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());
-	}
-
-	public static final class SomeException extends RuntimeException {
-		public SomeException(String message) {
-			super(message);
-		}
-	}
-
-	public static final class SomeClass {
-		public static void someMethod() {
-			throw new SomeException("this is some message");
-		}
-	}
-
-	public void testExceptionMessage() {
-		String script = "local c = luajava.bindClass( \"" + SomeClass.class.getName() + "\" )\n"
-			+ "return pcall( c.someMethod, c )";
-		Varargs vresult = globals.get("load").call(LuaValue.valueOf(script)).invoke(LuaValue.NONE);
-		LuaValue status = vresult.arg1();
-		LuaValue message = vresult.arg(2);
-		assertEquals(LuaValue.FALSE, status);
-		int index = message.toString().indexOf("this is some message");
-		assertTrue("bad message: " + message, index >= 0);
-	}
-
-	public void testLuaErrorCause() {
-		String script = "luajava.bindClass( \"" + SomeClass.class.getName() + "\"):someMethod()";
-		LuaValue chunk = globals.get("load").call(LuaValue.valueOf(script));
-		try {
-			chunk.invoke(LuaValue.NONE);
-			fail("call should not have succeeded");
-		} catch (LuaError lee) {
-			Throwable c = lee.getCause();
-			assertEquals(SomeException.class, c.getClass());
-		}
-	}
-
-	public interface VarArgsInterface {
-		public String varargsMethod(String a, String... v);
-
-		public String arrayargsMethod(String a, String[] v);
-	}
-
-	public void testVarArgsProxy() {
-		String script = "return luajava.createProxy( \"" + VarArgsInterface.class.getName() + "\", \n" + "{\n"
-			+ "	varargsMethod = function(a,...)\n" + "		return table.concat({a,...},'-')\n" + "	end,\n"
-			+ "	arrayargsMethod = function(a,array)\n" + "		return tostring(a)..(array and \n"
-			+ "			('-'..tostring(array.length)\n" + "			..'-'..tostring(array[1])\n"
-			+ "			..'-'..tostring(array[2])\n" + "			) or '-nil')\n" + "	end,\n" + "} )\n";
-		Varargs chunk = globals.get("load").call(LuaValue.valueOf(script));
-		if (!chunk.arg1().toboolean())
-			fail(chunk.arg(2).toString());
-		LuaValue result = chunk.arg1().call();
-		Object u = result.touserdata();
-		VarArgsInterface v = (VarArgsInterface) u;
-		assertEquals("foo", v.varargsMethod("foo"));
-		assertEquals("foo-bar", v.varargsMethod("foo", "bar"));
-		assertEquals("foo-bar-etc", v.varargsMethod("foo", "bar", "etc"));
-		assertEquals("foo-0-nil-nil", v.arrayargsMethod("foo", new String[0]));
-		assertEquals("foo-1-bar-nil", v.arrayargsMethod("foo", new String[] { "bar" }));
-		assertEquals("foo-2-bar-etc", v.arrayargsMethod("foo", new String[] { "bar", "etc" }));
-		assertEquals("foo-3-bar-etc", v.arrayargsMethod("foo", new String[] { "bar", "etc", "etc" }));
-		assertEquals("foo-nil", v.arrayargsMethod("foo", null));
-	}
-
-	public void testBigNum() {
-		String script = "bigNumA = luajava.newInstance('java.math.BigDecimal','12345678901234567890');\n"
-			+ "bigNumB = luajava.newInstance('java.math.BigDecimal','12345678901234567890');\n"
-			+ "bigNumC = bigNumA:multiply(bigNumB);\n" +
-			//"print(bigNumA:toString())\n" +
-			//"print(bigNumB:toString())\n" +
-			//"print(bigNumC:toString())\n" +
-			"return bigNumA:toString(), bigNumB:toString(), bigNumC:toString()";
-		Varargs chunk = globals.get("load").call(LuaValue.valueOf(script));
-		if (!chunk.arg1().toboolean())
-			fail(chunk.arg(2).toString());
-		Varargs results = chunk.arg1().invoke();
-		int nresults = results.narg();
-		String sa = results.tojstring(1);
-		String sb = results.tojstring(2);
-		String sc = results.tojstring(3);
-		assertEquals(3, nresults);
-		assertEquals("12345678901234567890", sa);
-		assertEquals("12345678901234567890", sb);
-		assertEquals("152415787532388367501905199875019052100", sc);
-	}
-
-	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 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) " + (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; }
-
-		public String set(float x) { return "set(float) " + x; }
-
-		public String set(double x) { return "set(double) " + x; }
-
-		public String setr(double x) { return "setr(double) " + x; }
-
-		public String setr(float x) { return "setr(float) " + x; }
-
-		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) " + (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) "; }
-
-		public String setr(A x) { return "setr(A) "; }
-
-		public String setr(String x) { return "setr(String) " + x; }
-
-		public String setr(Object x) { return "setr(Object) "; }
-
-		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 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 Math.PI; }
-	}
-
-	public static class C extends B implements IC {
-	}
-
-	public static class D extends C implements IA {
-	}
-
-	public void testOverloadedJavaMethodObject() { doOverloadedMethodTest("Object", ""); }
-
-	public void testOverloadedJavaMethodString() { doOverloadedMethodTest("String", "abc"); }
-
-	public void testOverloadedJavaMethodA() { doOverloadedMethodTest("A", ""); }
-
-	public void testOverloadedJavaMethodB() { doOverloadedMethodTest("B", ""); }
-
-	public void testOverloadedJavaMethodC() { doOverloadedMethodTest("C", ""); }
-
-	public void testOverloadedJavaMethodByte() { doOverloadedMethodTest("byte", "1"); }
-
-	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", "3.141592653589793"); }
-
-	private void doOverloadedMethodTest(String typename, String value) {
-		String script = "local a = luajava.newInstance('" + B.class.getName() + "');\n" + "local b = a:set(a:get"
-			+ typename + "())\n" + "local c = a:setr(a:get" + typename + "())\n" + "return b,c";
-		Varargs chunk = globals.get("load").call(LuaValue.valueOf(script));
-		if (!chunk.arg1().toboolean())
-			fail(chunk.arg(2).toString());
-		Varargs results = chunk.arg1().invoke();
-		int nresults = results.narg();
-		assertEquals(2, nresults);
-		LuaValue b = results.arg(1);
-		LuaValue c = results.arg(2);
-		String sb = b.tojstring();
-		String sc = c.tojstring();
-		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));
-	}
-
-	public void testCoerceJavaToLuaLuaValue() {
-		assertSame(LuaValue.NIL, CoerceJavaToLua.coerce(LuaValue.NIL));
-		assertSame(LuaValue.ZERO, CoerceJavaToLua.coerce(LuaValue.ZERO));
-		assertSame(LuaValue.ONE, CoerceJavaToLua.coerce(LuaValue.ONE));
-		assertSame(LuaValue.INDEX, CoerceJavaToLua.coerce(LuaValue.INDEX));
-		LuaTable table = LuaValue.tableOf();
-		assertSame(table, CoerceJavaToLua.coerce(table));
-	}
-
-	public void testCoerceJavaToLuaByeArray() {
-		byte[] bytes = "abcd".getBytes();
-		LuaValue value = CoerceJavaToLua.coerce(bytes);
-		assertEquals(LuaString.class, value.getClass());
-		assertEquals(LuaValue.valueOf("abcd"), value);
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/LuajavaAccessibleMembersTest.java

@@ -1,57 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-import junit.framework.TestCase;
-
-import org.luaj.vm2.Globals;
-import org.luaj.vm2.LuaValue;
-
-public class LuajavaAccessibleMembersTest extends TestCase {
-
-	private Globals globals;
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		globals = JsePlatform.standardGlobals();
-	}
-
-	private String invokeScript(String script) {
-		try {
-			LuaValue c = globals.load(script, "script");
-			return c.call().tojstring();
-		} catch (Exception e) {
-			fail("exception: " + e);
-			return "failed";
-		}
-	}
-
-	public void testAccessFromPrivateClassImplementedMethod() {
-		assertEquals("privateImpl-aaa-interface_method(bar)",
-			invokeScript("b = luajava.newInstance('" + TestClass.class.getName() + "');"
-				+ "a = b:create_PrivateImpl('aaa');" + "return a:interface_method('bar');"));
-	}
-
-	public void testAccessFromPrivateClassPublicMethod() {
-		assertEquals("privateImpl-aaa-public_method", invokeScript("b = luajava.newInstance('"
-			+ TestClass.class.getName() + "');" + "a = b:create_PrivateImpl('aaa');" + "return a:public_method();"));
-	}
-
-	public void testAccessFromPrivateClassGetPublicField() {
-		assertEquals("aaa", invokeScript("b = luajava.newInstance('" + TestClass.class.getName() + "');"
-			+ "a = b:create_PrivateImpl('aaa');" + "return a.public_field;"));
-	}
-
-	public void testAccessFromPrivateClassSetPublicField() {
-		assertEquals("foo", invokeScript("b = luajava.newInstance('" + TestClass.class.getName() + "');"
-			+ "a = b:create_PrivateImpl('aaa');" + "a.public_field = 'foo';" + "return a.public_field;"));
-	}
-
-	public void testAccessFromPrivateClassPublicConstructor() {
-		assertEquals("privateImpl-constructor", invokeScript("b = luajava.newInstance('" + TestClass.class.getName()
-			+ "');" + "c = b:get_PrivateImplClass();" + "return luajava.new(c);"));
-	}
-
-	public void testAccessPublicEnum() {
-		assertEquals("class org.luaj.vm2.lib.jse.TestClass$SomeEnum",
-			invokeScript("b = luajava.newInstance('" + TestClass.class.getName() + "');" + "return b.SomeEnum"));
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/LuajavaClassMembersTest.java

@@ -1,295 +0,0 @@
-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 + ")"; }
-
-		public static class D {
-			public static String name() { return "name-of-D"; }
-		}
-	}
-
-	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());
-	}
-
-	public void testGetInnerClass() {
-		C c = new C();
-		JavaInstance ic = new JavaInstance(c);
-		LuaValue d = ic.get("D");
-		assertFalse(d.isnil());
-		assertSame(d, JavaClass.forClass(C.D.class));
-		LuaValue e = ic.get("E");
-		assertTrue(e.isnil());
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/OsLibTest.java

@@ -1,110 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.OsLib;
-import org.luaj.vm2.lib.jme.JmePlatform;
-
-import junit.framework.TestCase;
-
-public class OsLibTest extends TestCase {
-
-	LuaValue jme_lib;
-	LuaValue jse_lib;
-	double   time;
-
-	public void setUp() {
-		jse_lib = JsePlatform.standardGlobals().get("os");
-		;
-		jme_lib = JmePlatform.standardGlobals().get("os");
-		;
-		time = new java.util.Date(2001-1900, 7, 23, 14, 55, 02).getTime()/1000.0;
-	}
-
-	void t(String format, String expected) {
-		String actual = jme_lib.get("date").call(LuaValue.valueOf(format), LuaValue.valueOf(time)).tojstring();
-		assertEquals(expected, actual);
-	}
-
-	public void testStringDateChars() { t("foo", "foo"); }
-
-	public void testStringDate_a() { t("%a", "Thu"); }
-
-	public void testStringDate_A() { t("%A", "Thursday"); }
-
-	public void testStringDate_b() { t("%b", "Aug"); }
-
-	public void testStringDate_B() { t("%B", "August"); }
-
-	public void testStringDate_c() { t("%c", "Thu Aug 23 14:55:02 2001"); }
-
-	public void testStringDate_d() { t("%d", "23"); }
-
-	public void testStringDate_H() { t("%H", "14"); }
-
-	public void testStringDate_I() { t("%I", "02"); }
-
-	public void testStringDate_j() { t("%j", "235"); }
-
-	public void testStringDate_m() { t("%m", "08"); }
-
-	public void testStringDate_M() { t("%M", "55"); }
-
-	public void testStringDate_p() { t("%p", "PM"); }
-
-	public void testStringDate_S() { t("%S", "02"); }
-
-	public void testStringDate_U() { t("%U", "33"); }
-
-	public void testStringDate_w() { t("%w", "4"); }
-
-	public void testStringDate_W() { t("%W", "34"); }
-
-	public void testStringDate_x() { t("%x", "08/23/01"); }
-
-	public void testStringDate_X() { t("%X", "14:55:02"); }
-
-	public void testStringDate_y() { t("%y", "01"); }
-
-	public void testStringDate_Y() { t("%Y", "2001"); }
-
-	public void testStringDate_Pct() { t("%%", "%"); }
-
-	static final double DAY = 24.*3600.;
-
-	public void testStringDate_UW_neg4() { time -= 4*DAY; t("%c %U %W", "Sun Aug 19 14:55:02 2001 33 33"); }
-
-	public void testStringDate_UW_neg3() { time -= 3*DAY; t("%c %U %W", "Mon Aug 20 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_neg2() { time -= 2*DAY; t("%c %U %W", "Tue Aug 21 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_neg1() { time -= DAY; t("%c %U %W", "Wed Aug 22 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_pos0() { time += 0; t("%c %U %W", "Thu Aug 23 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_pos1() { time += DAY; t("%c %U %W", "Fri Aug 24 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_pos2() { time += 2*DAY; t("%c %U %W", "Sat Aug 25 14:55:02 2001 33 34"); }
-
-	public void testStringDate_UW_pos3() { time += 3*DAY; t("%c %U %W", "Sun Aug 26 14:55:02 2001 34 34"); }
-
-	public void testStringDate_UW_pos4() { time += 4*DAY; t("%c %U %W", "Mon Aug 27 14:55:02 2001 34 35"); }
-
-	public void testJseOsGetenvForEnvVariables() {
-		LuaValue USER = LuaValue.valueOf("USER");
-		LuaValue jse_user = jse_lib.get("getenv").call(USER);
-		LuaValue jme_user = jme_lib.get("getenv").call(USER);
-		assertFalse(jse_user.isnil());
-		assertTrue(jme_user.isnil());
-		System.out.println("User: " + jse_user);
-	}
-
-	public void testJseOsGetenvForSystemProperties() {
-		System.setProperty("test.key.foo", "test.value.bar");
-		LuaValue key = LuaValue.valueOf("test.key.foo");
-		LuaValue value = LuaValue.valueOf("test.value.bar");
-		LuaValue jse_value = jse_lib.get("getenv").call(key);
-		LuaValue jme_value = jme_lib.get("getenv").call(key);
-		assertEquals(value, jse_value);
-		assertEquals(value, jme_value);
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/TestClass.java

@@ -1,31 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-public class TestClass {
-	private static class PrivateImpl implements TestInterface {
-		public String public_field;
-
-		public PrivateImpl() {
-			this.public_field = "privateImpl-constructor";
-		}
-
-		PrivateImpl(String f) {
-			this.public_field = f;
-		}
-
-		public String public_method() { return "privateImpl-" + public_field + "-public_method"; }
-
-		public String interface_method(String x) {
-			return "privateImpl-" + public_field + "-interface_method(" + x + ")";
-		}
-
-		public String toString() { return public_field; }
-	}
-
-	public TestInterface create_PrivateImpl(String f) { return new PrivateImpl(f); }
-
-	public Class get_PrivateImplClass() { return PrivateImpl.class; }
-
-	public enum SomeEnum {
-		ValueOne, ValueTwo,
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/lib/jse/TestInterface.java

@@ -1,5 +0,0 @@
-package org.luaj.vm2.lib.jse;
-
-public interface TestInterface {
-	String interface_method(String x);
-}

luaj-test/src/test/java/org/luaj/vm2/require/RequireSampleClassCastExcep.java

@@ -1,18 +0,0 @@
-package org.luaj.vm2.require;
-
-import org.luaj.vm2.LuaValue;
-
-/**
- * This should fail while trying to load via "require() because it is not a
- * LibFunction"
- * 
- */
-public class RequireSampleClassCastExcep {
-
-	public RequireSampleClassCastExcep() {
-	}
-
-	public LuaValue call() {
-		return LuaValue.valueOf("require-sample-class-cast-excep");
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/require/RequireSampleLoadLuaError.java

@@ -1,20 +0,0 @@
-package org.luaj.vm2.require;
-
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.ZeroArgFunction;
-
-/**
- * This should fail while trying to load via "require()" because it throws a
- * LuaError
- * 
- */
-public class RequireSampleLoadLuaError extends ZeroArgFunction {
-
-	public RequireSampleLoadLuaError() {
-	}
-
-	public LuaValue call() {
-		error("sample-load-lua-error");
-		return LuaValue.valueOf("require-sample-load-lua-error");
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/require/RequireSampleLoadRuntimeExcep.java

@@ -1,19 +0,0 @@
-package org.luaj.vm2.require;
-
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.ZeroArgFunction;
-
-/**
- * This should fail while trying to load via "require()" because it throws a
- * RuntimeException
- * 
- */
-public class RequireSampleLoadRuntimeExcep extends ZeroArgFunction {
-
-	public RequireSampleLoadRuntimeExcep() {
-	}
-
-	public LuaValue call() {
-		throw new RuntimeException("sample-load-runtime-exception");
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/require/RequireSampleSuccess.java

@@ -1,19 +0,0 @@
-package org.luaj.vm2.require;
-
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.TwoArgFunction;
-
-/**
- * This should succeed as a library that can be loaded dynamically via
- * "require()"
- */
-public class RequireSampleSuccess extends TwoArgFunction {
-
-	public RequireSampleSuccess() {
-	}
-
-	public LuaValue call(LuaValue modname, LuaValue env) {
-		env.checkglobals();
-		return LuaValue.valueOf("require-sample-success-" + modname.tojstring());
-	}
-}

luaj-test/src/test/java/org/luaj/vm2/script/ScriptEngineTests.java

@@ -1,334 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2013 Luaj.org. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-package org.luaj.vm2.script;
-
-import java.io.CharArrayReader;
-import java.io.CharArrayWriter;
-import java.io.Reader;
-
-import javax.script.Bindings;
-import javax.script.Compilable;
-import javax.script.CompiledScript;
-import javax.script.ScriptContext;
-import javax.script.ScriptEngine;
-import javax.script.ScriptEngineFactory;
-import javax.script.ScriptEngineManager;
-import javax.script.ScriptException;
-import javax.script.SimpleBindings;
-
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-import org.luaj.vm2.LuaFunction;
-import org.luaj.vm2.LuaValue;
-import org.luaj.vm2.lib.OneArgFunction;
-
-public class ScriptEngineTests extends TestSuite {
-
-	public static TestSuite suite() {
-		TestSuite suite = new TestSuite("Script Engine Tests");
-		suite.addTest(new TestSuite(LookupEngineTestCase.class, "Lookup Engine"));
-		suite.addTest(new TestSuite(DefaultBindingsTest.class, "Default Bindings"));
-		suite.addTest(new TestSuite(SimpleBindingsTest.class, "Simple Bindings"));
-		suite.addTest(new TestSuite(CompileClosureTest.class, "Compile Closure"));
-		suite.addTest(new TestSuite(CompileNonClosureTest.class, "Compile NonClosure"));
-		suite.addTest(new TestSuite(UserContextTest.class, "User Context"));
-		suite.addTest(new TestSuite(WriterTest.class, "Writer"));
-		return suite;
-	}
-
-	public static class LookupEngineTestCase extends TestCase {
-		public void testGetEngineByExtension() {
-			ScriptEngine e = new ScriptEngineManager().getEngineByExtension(".lua");
-			assertNotNull(e);
-			assertEquals(LuaScriptEngine.class, e.getClass());
-		}
-
-		public void testGetEngineByName() {
-			ScriptEngine e = new ScriptEngineManager().getEngineByName("luaj");
-			assertNotNull(e);
-			assertEquals(LuaScriptEngine.class, e.getClass());
-		}
-
-		public void testGetEngineByMimeType() {
-			ScriptEngine e = new ScriptEngineManager().getEngineByMimeType("text/lua");
-			assertNotNull(e);
-			assertEquals(LuaScriptEngine.class, e.getClass());
-		}
-
-		public void testFactoryMetadata() {
-			ScriptEngine e = new ScriptEngineManager().getEngineByName("luaj");
-			ScriptEngineFactory f = e.getFactory();
-			assertEquals("Luaj", f.getEngineName());
-			assertEquals("Luaj 0.0", f.getEngineVersion());
-			assertEquals("lua", f.getLanguageName());
-			assertEquals("5.2", f.getLanguageVersion());
-		}
-	}
-
-	public static class DefaultBindingsTest extends EngineTestCase {
-		protected Bindings createBindings() {
-			return e.createBindings();
-		}
-	}
-
-	public static class SimpleBindingsTest extends EngineTestCase {
-		protected Bindings createBindings() {
-			return new SimpleBindings();
-		}
-	}
-
-	public static class CompileClosureTest extends DefaultBindingsTest {
-		protected void setUp() throws Exception {
-			System.setProperty("org.luaj.luajc", "false");
-			super.setUp();
-		}
-
-		public void testCompiledFunctionIsClosure() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("return 'foo'");
-			LuaValue value = ((LuaScriptEngine.LuajCompiledScript) cs).function;
-			assertTrue(value.isclosure());
-		}
-	}
-
-	public static class CompileNonClosureTest extends DefaultBindingsTest {
-		protected void setUp() throws Exception {
-			System.setProperty("org.luaj.luajc", "true");
-			super.setUp();
-		}
-
-		public void testCompiledFunctionIsNotClosure() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("return 'foo'");
-			LuaValue value = ((LuaScriptEngine.LuajCompiledScript) cs).function;
-			assertFalse(value.isclosure());
-		}
-	}
-
-	abstract public static class EngineTestCase extends TestCase {
-		protected ScriptEngine e;
-		protected Bindings     b;
-
-		abstract protected Bindings createBindings();
-
-		protected void setUp() throws Exception {
-			this.e = new ScriptEngineManager().getEngineByName("luaj");
-			this.b = createBindings();
-		}
-
-		public void testSqrtIntResult() throws ScriptException {
-			e.put("x", 25);
-			e.eval("y = math.sqrt(x)");
-			Object y = e.get("y");
-			assertEquals(5, y);
-		}
-
-		public void testOneArgFunction() throws ScriptException {
-			e.put("x", 25);
-			e.eval("y = math.sqrt(x)");
-			Object y = e.get("y");
-			assertEquals(5, y);
-			e.put("f", new OneArgFunction() {
-				public LuaValue call(LuaValue arg) {
-					return LuaValue.valueOf(arg.toString() + "123");
-				}
-			});
-			Object r = e.eval("return f('abc')");
-			assertEquals("abc123", r);
-		}
-
-		public void testCompiledScript() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = math.sqrt(x); return y");
-			b.put("x", 144);
-			assertEquals(12, cs.eval(b));
-		}
-
-		public void testBuggyLuaScript() {
-			try {
-				e.eval("\n\nbuggy lua code\n\n");
-			} catch (ScriptException se) {
-				assertEquals("eval threw javax.script.ScriptException: [string \"script\"]:3: syntax error",
-					se.getMessage());
-				return;
-			}
-			fail("buggy script did not throw ScriptException as expected.");
-		}
-
-		public void testScriptRedirection() throws ScriptException {
-			Reader input = new CharArrayReader("abcdefg\nhijk".toCharArray());
-			CharArrayWriter output = new CharArrayWriter();
-			CharArrayWriter errors = new CharArrayWriter();
-			String script = "print(\"string written using 'print'\")\n"
-				+ "io.write(\"string written using 'io.write()'\\n\")\n"
-				+ "io.stdout:write(\"string written using 'io.stdout:write()'\\n\")\n"
-				+ "io.stderr:write(\"string written using 'io.stderr:write()'\\n\")\n"
-				+ "io.write([[string read using 'io.stdin:read(\"*l\")':]]..io.stdin:read(\"*l\")..\"\\n\")\n";
-
-			// Evaluate script with redirection set
-			e.getContext().setReader(input);
-			e.getContext().setWriter(output);
-			e.getContext().setErrorWriter(errors);
-			e.eval(script);
-			final String expectedOutput = "string written using 'print'\n" + "string written using 'io.write()'\n"
-				+ "string written using 'io.stdout:write()'\n" + "string read using 'io.stdin:read(\"*l\")':abcdefg\n";
-			assertEquals(expectedOutput, output.toString());
-			final String expectedErrors = "string written using 'io.stderr:write()'\n";
-			assertEquals(expectedErrors, errors.toString());
-
-			// Evaluate script with redirection reset
-			output.reset();
-			errors.reset();
-			// e.getContext().setReader(null); // This will block if using actual STDIN
-			e.getContext().setWriter(null);
-			e.getContext().setErrorWriter(null);
-			e.eval(script);
-			assertEquals("", output.toString());
-			assertEquals("", errors.toString());
-		}
-
-		public void testBindingJavaInt() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = x; return 'x '..type(x)..' '..tostring(x)\n");
-			b.put("x", 111);
-			assertEquals("x number 111", cs.eval(b));
-			assertEquals(111, b.get("y"));
-		}
-
-		public void testBindingJavaDouble() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = x; return 'x '..type(x)..' '..tostring(x)\n");
-			b.put("x", 125.125);
-			assertEquals("x number 125.125", cs.eval(b));
-			assertEquals(125.125, b.get("y"));
-		}
-
-		public void testBindingJavaString() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = x; return 'x '..type(x)..' '..tostring(x)\n");
-			b.put("x", "foo");
-			assertEquals("x string foo", cs.eval(b));
-			assertEquals("foo", b.get("y"));
-		}
-
-		public void testBindingJavaObject() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = x; return 'x '..type(x)..' '..tostring(x)\n");
-			b.put("x", new SomeUserClass());
-			assertEquals("x userdata some-user-value", cs.eval(b));
-			assertEquals(SomeUserClass.class, b.get("y").getClass());
-		}
-
-		public void testBindingJavaArray() throws ScriptException {
-			CompiledScript cs = ((Compilable) e)
-				.compile("y = x; return 'x '..type(x)..' '..#x..' '..x[1]..' '..x[2]\n");
-			b.put("x", new int[] { 777, 888 });
-			assertEquals("x userdata 2 777 888", cs.eval(b));
-			assertEquals(int[].class, b.get("y").getClass());
-		}
-
-		public void testBindingLuaFunction() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("y = function(x) return 678 + x end; return 'foo'");
-			assertEquals("foo", cs.eval(b).toString());
-			assertTrue(b.get("y") instanceof LuaFunction);
-			assertEquals(LuaValue.valueOf(801), ((LuaFunction) b.get("y")).call(LuaValue.valueOf(123)));
-		}
-
-		public void testUserClasses() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("x = x or luajava.newInstance('java.lang.String', 'test')\n"
-				+ "return 'x ' ..  type(x) .. ' ' .. tostring(x)\n");
-			assertEquals("x string test", cs.eval(b));
-			b.put("x", new SomeUserClass());
-			assertEquals("x userdata some-user-value", cs.eval(b));
-		}
-
-		public void testReturnMultipleValues() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("return 'foo', 'bar'\n");
-			Object o = cs.eval();
-			assertEquals(Object[].class, o.getClass());
-			Object[] array = (Object[]) o;
-			assertEquals(2, array.length);
-			assertEquals("foo", array[0]);
-			assertEquals("bar", array[1]);
-		}
-	}
-
-	public static class SomeUserClass {
-		public String toString() {
-			return "some-user-value";
-		}
-	}
-
-	public static class UserContextTest extends TestCase {
-		protected ScriptEngine  e;
-		protected Bindings      b;
-		protected ScriptContext c;
-
-		public void setUp() {
-			this.e = new ScriptEngineManager().getEngineByName("luaj");
-			this.c = new LuajContext();
-			this.b = c.getBindings(ScriptContext.ENGINE_SCOPE);
-		}
-
-		public void testUncompiledScript() throws ScriptException {
-			b.put("x", 144);
-			assertEquals(12, e.eval("z = math.sqrt(x); return z", b));
-			assertEquals(12, b.get("z"));
-			assertEquals(null, e.getBindings(ScriptContext.ENGINE_SCOPE).get("z"));
-			assertEquals(null, e.getBindings(ScriptContext.GLOBAL_SCOPE).get("z"));
-
-			b.put("x", 25);
-			assertEquals(5, e.eval("z = math.sqrt(x); return z", c));
-			assertEquals(5, b.get("z"));
-			assertEquals(null, e.getBindings(ScriptContext.ENGINE_SCOPE).get("z"));
-			assertEquals(null, e.getBindings(ScriptContext.GLOBAL_SCOPE).get("z"));
-		}
-
-		public void testCompiledScript() throws ScriptException {
-			CompiledScript cs = ((Compilable) e).compile("z = math.sqrt(x); return z");
-
-			b.put("x", 144);
-			assertEquals(12, cs.eval(b));
-			assertEquals(12, b.get("z"));
-
-			b.put("x", 25);
-			assertEquals(5, cs.eval(c));
-			assertEquals(5, b.get("z"));
-		}
-	}
-
-	public static class WriterTest extends TestCase {
-		protected ScriptEngine e;
-		protected Bindings     b;
-
-		public void setUp() {
-			this.e = new ScriptEngineManager().getEngineByName("luaj");
-			this.b = e.getBindings(ScriptContext.ENGINE_SCOPE);
-		}
-
-		public void testWriter() throws ScriptException {
-			CharArrayWriter output = new CharArrayWriter();
-			CharArrayWriter errors = new CharArrayWriter();
-			e.getContext().setWriter(output);
-			e.getContext().setErrorWriter(errors);
-			e.eval("io.write( [[line]] )");
-			assertEquals("line", output.toString());
-			e.eval("io.write( [[ one\nline two\n]] )");
-			assertEquals("line one\nline two\n", output.toString());
-			output.reset();
-		}
-	}
-}