merge in new runtime test mechanism

antlr4-maven-plugin/pom.xml

@@ -50,9 +50,9 @@
 
   <!-- ============================================================================= -->
 
-  <!-- What are we depedent on for the Mojos to execute? We need the plugin 
-    API itself and of course we need the ANTLR Tool and runtime and any of their 
-    dependencies, which we inherit. The Tool itself provides us with all the 
+  <!-- What are we depedent on for the Mojos to execute? We need the plugin
+    API itself and of course we need the ANTLR Tool and runtime and any of their
+    dependencies, which we inherit. The Tool itself provides us with all the
     dependencies, so we need only name it here. -->
   <dependencies>
 
@@ -78,8 +78,8 @@
       <artifactId>plexus-build-api</artifactId>
       <version>0.0.7</version>
     </dependency>
-    <!-- The version of ANTLR tool that this version of the plugin controls. 
-      We have decided that this should be in lockstep with ANTLR itself, other 
+    <!-- The version of ANTLR tool that this version of the plugin controls.
+      We have decided that this should be in lockstep with ANTLR itself, other
       than -1 -2 -3 etc patch releases. -->
     <dependency>
       <groupId>org.antlr</groupId>

pom.xml

@@ -75,6 +75,9 @@
     <module>tool</module>
     <module>antlr4-maven-plugin</module>
     <module>tool-testsuite</module>
+    <module>runtime-testsuite/annotations</module>
+    <module>runtime-testsuite/processors</module>
+    <module>runtime-testsuite-legacy</module>
     <module>runtime-testsuite</module>
   </modules>
 

runtime-testsuite-legacy/pom.xml

@@ -0,0 +1,114 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.antlr</groupId>
+		<artifactId>antlr4-master</artifactId>
+		<version>4.6-SNAPSHOT</version>
+	</parent>
+	<artifactId>antlr4-runtime-testsuite-legacy</artifactId>
+	<name>ANTLR 4 Legacy Runtime Test Generator</name>
+	<description>Legacy collection of tests for ANTLR 4 Runtime libraries.</description>
+
+	<prerequisites>
+		<maven>3.0</maven>
+	</prerequisites>
+
+	<inceptionYear>2009</inceptionYear>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.antlr</groupId>
+			<artifactId>ST4</artifactId>
+			<version>4.0.8</version>
+		</dependency>
+		<dependency>
+			<groupId>org.antlr</groupId>
+			<artifactId>antlr4</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.antlr</groupId>
+			<artifactId>antlr4-runtime</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.11</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.seleniumhq.selenium</groupId>
+			<artifactId>selenium-java</artifactId>
+			<version>2.46.0</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-server</artifactId>
+			<version>8.1.16.v20140903</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<sourceDirectory>src</sourceDirectory>
+		<!--
+		<testSourceDirectory>test</testSourceDirectory>
+		-->
+		<resources>
+			<resource>
+				<directory>resources</directory>
+			</resource>
+			<resource>
+				<directory>../runtime</directory>
+			</resource>
+		</resources>
+	</build>
+
+	<profiles>
+		<profile>
+			<id>gen</id>
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>org.codehaus.mojo</groupId>
+						<artifactId>exec-maven-plugin</artifactId>
+						<version>1.4.0</version>
+						<executions>
+							<execution>
+								<phase>generate-test-sources</phase>
+								<goals>
+									<goal>java</goal>
+								</goals>
+								<configuration>
+									<mainClass>org.antlr.v4.testgen.TestGenerator</mainClass>
+									<arguments>
+										<argument>${basedir}/..</argument>
+									</arguments>
+								</configuration>
+							</execution>
+						</executions>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
+		<profile>
+			<id>tests</id>
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>org.apache.maven.plugins</groupId>
+						<artifactId>maven-surefire-plugin</artifactId>
+						<configuration>
+							<includes>
+								<include>**/Test*.java</include>
+							</includes>
+						</configuration>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
+	</profiles>
+</project>

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/TestInfo.stg

@@ -0,0 +1,111 @@
+file(className, descriptors) ::= <<
+package org.antlr.v4.test.runtime.xxx.tests.junk;
+
+import org.antlr.v4.runtime.misc.Pair;
+import org.antlr.v4.test.runtime.CommentHasStringValue;
+import org.antlr.v4.test.runtime.xxx.*;
+import org.antlr.v4.test.runtime.xxx.tests.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class <className> {
+	<descriptors; separator="\n\n">
+}
+>>
+
+rig(targetName, groupName, go, subdir) ::= <<
+package org.antlr.v4.test.runtime.xxx.tests.<subdir:{s|<s>.}><targetName; format="lower">;
+
+import org.antlr.v4.test.runtime.xxx.RuntimeTestDescriptor;
+import org.antlr.v4.test.runtime.xxx.XXXBaseTest;
+import org.antlr.v4.test.runtime.xxx.descriptors.*;
+import org.junit.*;
+import org.junit.runner.*;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class Test<groupName> extends XXXBaseTest {
+	public Test<groupName>(RuntimeTestDescriptor descriptor) {
+		super(descriptor,new Base<targetName>Test());
+	}
+
+	<if(go)>
+	@BeforeClass
+	public static void groupSetUp() throws Exception { BaseGoTest.groupSetUp(); }
+
+	@AfterClass
+	public static void groupTearDown() throws Exception { BaseGoTest.groupTearDown(); }
+	<endif>
+
+	@Parameterized.Parameters(name="{0}")
+	public static RuntimeTestDescriptor[] getAllTestDescriptors() {
+		return XXXBaseTest.getRuntimeTestDescriptors(<groupName>Descriptors.class, "<targetName>");
+	}
+}
+>>
+
+descriptor(testName, TestType, Input, LongInput, Errors, LongErrors, Rule, Output, LongOutput,
+           grammar, slaveGrammars, grammarName, LongAfterGrammar) ::= <<
+public static class <testName> extends Base<TestType>TestDescriptor {
+	<if(LongInput)>
+	/**
+	<LongInput>
+	 */
+	@CommentHasStringValue
+	public String input;<\n>
+	<else>
+	public String input = "<Input>";
+	<endif>
+	<if(LongOutput)>
+	/**
+	<LongOutput>
+	 */
+	@CommentHasStringValue
+	public String output;<\n>
+	<else>
+	public String output = "<Output>";
+	<endif>
+	<if(LongErrors)>
+	/**
+	<LongErrors>
+	 */
+	@CommentHasStringValue
+	public String errors;<\n>
+	<else>
+	public String errors = "<Errors>";
+	<endif>
+	public String startRule = "<Rule>";
+	public String grammarName = "<grammarName>";
+
+	<if(LongAfterGrammar)>
+	/**
+	<LongAfterGrammar>
+	 */
+	@CommentHasStringValue
+	public String afterGrammar;
+	<endif>
+
+	/**
+	 <grammar>
+	 */
+	@CommentHasStringValue
+	public String grammar;
+
+	<if(slaveGrammars)>
+	<slaveGrammars:{sg |
+/**
+<sg.grammar>
+ */
+@CommentHasStringValue
+public String slaveGrammar<sg.name>;
+	}>
+	@Override
+	public List\<Pair\<String, String>\> getSlaveGrammars() {
+		List\<Pair\<String,String>\> slaves = new ArrayList\<Pair\<String, String>\>();
+		<slaveGrammars:{sg | slaves.add(new Pair\<String, String>("<sg.name>",slaveGrammar<sg.name>));<\n>}>
+		return slaves;
+	\}
+	<endif>
+}
+>>

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/cpp/Cpp.test.stg

@@ -1,169 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.cpp;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseCppTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> = <writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-<if(test.AfterGrammar)>
-	<test.AfterGrammar>
-<endif>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-	<test.AfterGrammar>
-
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.slaveIsLexer)>Parser<endif>", "<if(test.slaveIsLexer)><first(test.slaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= "std::cout \<\< <s> \<\< std::endl;"
 write(s) ::= "std::cout \<\< <s>;"
 writeList(s) ::= << std::cout \<\< <s; separator=" \<\< "> \<\< std::endl;>>
@@ -251,7 +85,7 @@ protected:
     }
 
   };
-  
+
 public:
   virtual std::unique_ptr\<Token> nextToken() override {
     if (dynamic_cast\<PositionAdjustingLexerATNSimulator *>(_interpreter) == nullptr) {
@@ -444,8 +278,3 @@ Invoke_pred(v) ::= <<pred(<v>)>>
 ContextRuleFunction(ctx, rule) ::= "<ctx>-><rule>"
 StringType() ::= "std::string"
 ContextMember(ctx, subctx, member) ::= "<ctx>-><subctx>-><member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/csharp/CSharp.test.stg

@@ -1,159 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.csharp;
-
-import org.junit.Test;
-import org.junit.Ignore;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<Console.WriteLine(<s>);>>
 write(s) ::= <<Console.Write(<s>);>>
 writeList(s) ::= <<Console.WriteLine(<s; separator="+">);>>
@@ -453,8 +297,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/go/Go.test.stg

@@ -1,160 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.go;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(parserpkgdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(parserpkgdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
->>
-
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(parserpkgdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(parserpkgdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
-		"<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Timeout"))>
-(timeout = <test.Options.("Timeout")>)
-<endif>
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<fmt.Println(<s>)>>
 write(s) ::= <<fmt.Print(<s>)>>
 writeList(s) ::= <<fmt.Print(<s; separator="+">);>>
@@ -493,8 +336,3 @@ Invoke_pred(v) ::= <<pred(<v>)>>
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member; format={cap}>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/java/Java.test.stg

@@ -1,169 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.java;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-<if(test.AfterGrammar)>
-	<test.AfterGrammar>
-<endif>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-	<test.AfterGrammar>
-
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Timeout"))>
-(timeout = <test.Options.("Timeout")>)
-<endif>
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-
-
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<System.out.println(<s>);>>
 write(s) ::= <<System.out.print(<s>);>>
 writeList(s) ::= <<System.out.println(<s; separator="+">);>>
@@ -462,7 +296,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/javascript/chrome/Chrome.test.stg

@@ -1,158 +1,3 @@
-IgnoredTests ::= [
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.javascript.chrome;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
-	                          "<grammar>Listener", "<grammar>Visitor",
-	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
-                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
-	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
 
 write(s) ::= <<document.getElementById('output').value += <s>;>>
@@ -434,9 +279,7 @@ Declare_pred() ::= <<this.pred = function(v) {
 
 Invoke_pred(v) ::= <<this.pred(<v>)>>
 
-ParserToken(t) ::= "Parser.<t>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]
+ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
+StringType() ::= "String"
+ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
+ParserPropertyCall(p, call) ::= "<p>.<call>"

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/javascript/explorer/Explorer.test.stg

@@ -0,0 +1,294 @@
+writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
+write(s) ::= <<document.getElementById('output').value += <s>;>>
+writeList(s) ::= <<document.getElementById('output').value += <s; separator="+">;>>
+
+False() ::= "false"
+
+True() ::= "true"
+
+Not(v) ::= "!<v>"
+
+Assert(s) ::= ""
+
+Cast(t,v) ::= "<v>"
+
+Append(a,b) ::= "<a> + <b>"
+
+Concat(a,b) ::= "<a><b>"
+
+DeclareLocal(s,v) ::= "var <s> = <v>;"
+
+AssertIsList(v) ::= <<if ( !(v instanceof Array) ) {throw "value is not an array";}>>
+
+AssignLocal(s,v) ::= "<s> = <v>;"
+
+InitIntMember(n,v) ::= <%this.<n> = <v>;%>
+
+InitBooleanMember(n,v) ::= <%this.<n> = <v>;%>
+
+GetMember(n) ::= <%this.<n>%>
+
+SetMember(n,v) ::= <%this.<n> = <v>;%>
+
+AddMember(n,v) ::= <%this.<n> += <v>;%>
+
+PlusMember(v,n) ::= <%<v> + this.<n>%>
+
+MemberEquals(n,v) ::= <%this.<n> === <v>%>
+
+ModMemberEquals(n,m,v) ::= <%this.<n> % <m> === <v>%>
+
+ModMemberNotEquals(n,m,v) ::= <%this.<n> % <m> != <v>%>
+
+DumpDFA() ::= "this.dumpDFA();"
+
+Pass() ::= ""
+
+StringList() ::= "list"
+
+BuildParseTrees() ::= "this.buildParseTrees = true;"
+
+BailErrorStrategy() ::= <%this._errHandler = new antlr4.error.BailErrorStrategy();%>
+
+ToStringTree(s) ::= <%<s>.toStringTree(null, this)%>
+
+Column() ::= "this.column"
+
+Text() ::= "this.text"
+
+ValEquals(a,b) ::= <%<a>===<b>%>
+
+TextEquals(a) ::= <%this.text==="<a>"%>
+
+PlusText(a) ::= <%"<a>" + this.text%>
+
+InputText() ::= "this._input.getText()"
+
+LTEquals(i, v) ::= <%this._input.LT(<i>).text===<v>%>
+
+LANotEquals(i, v) ::= <%this._input.LA(<i>)!=<v>%>
+
+TokenStartColumnEquals(i) ::= <%this._tokenStartColumn===<i>%>
+
+ImportListener(X) ::= <<
+@parser::header {
+var <X>Listener = require('./<X>Listener').<X>Listener;
+}
+>>
+
+GetExpectedTokenNames() ::= "this.getExpectedTokens().toString(this.literalNames)"
+
+RuleInvocationStack() ::= "antlr4.Utils.arrayToString(this.getRuleInvocationStack())"
+
+LL_EXACT_AMBIG_DETECTION() ::= <<this._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;>>
+
+ParserToken(parser, token) ::= <%<parser>.<token>%>
+
+Production(p) ::= <%<p>%>
+
+Result(r) ::= <%<r>%>
+
+ParserPropertyMember() ::= <<
+@members {
+this.Property = function() {
+    return true;
+}
+}
+>>
+
+ParserPropertyCall(p, call) ::= "<p>.<call>"
+
+PositionAdjustingLexer() ::= <<
+
+PositionAdjustingLexer.prototype.resetAcceptPosition = function(index, line, column) {
+	this._input.seek(index);
+	this.line = line;
+	this.column = column;
+	this._interp.consume(this._input);
+};
+
+PositionAdjustingLexer.prototype.nextToken = function() {
+	if (!("resetAcceptPosition" in this._interp)) {
+		var lexer = this;
+		this._interp.resetAcceptPosition = function(index, line, column) { lexer.resetAcceptPosition(index, line, column); };
+	}
+	return antlr4.Lexer.prototype.nextToken.call(this);
+};
+
+PositionAdjustingLexer.prototype.emit = function() {
+	switch(this._type) {
+	case PositionAdjustingLexer.TOKENS:
+		this.handleAcceptPositionForKeyword("tokens");
+		break;
+	case PositionAdjustingLexer.LABEL:
+		this.handleAcceptPositionForIdentifier();
+		break;
+	}
+	return antlr4.Lexer.prototype.emit.call(this);
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForIdentifier = function() {
+	var tokenText = this.text;
+	var identifierLength = 0;
+	while (identifierLength \< tokenText.length &&
+		PositionAdjustingLexer.isIdentifierChar(tokenText[identifierLength])
+	) {
+		identifierLength += 1;
+	}
+	if (this._input.index > this._tokenStartCharIndex + identifierLength) {
+		var offset = identifierLength - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+				this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.prototype.handleAcceptPositionForKeyword = function(keyword) {
+	if (this._input.index > this._tokenStartCharIndex + keyword.length) {
+		var offset = keyword.length - 1;
+		this._interp.resetAcceptPosition(this._tokenStartCharIndex + offset,
+			this._tokenStartLine, this._tokenStartColumn + offset);
+		return true;
+	} else {
+		return false;
+	}
+};
+
+PositionAdjustingLexer.isIdentifierChar = function(c) {
+	return c.match(/^[0-9a-zA-Z_]+$/);
+}
+
+>>
+
+BasicListener(X) ::= <<
+@parser::members {
+this.LeafListener = function() {
+    this.visitTerminal = function(node) {
+    	document.getElementById('output').value += node.symbol.text + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+}
+>>
+
+WalkListener(s) ::= <<
+var walker = new antlr4.tree.ParseTreeWalker();
+walker.walk(new this.LeafListener(), <s>);
+>>
+
+TreeNodeWithAltNumField(X) ::= <<
+@parser::header {
+MyRuleNode = function(parent, invokingState) {
+	antlr4.ParserRuleContext.call(this, parent, invokingState);
+	this.altNum = 0;
+	return this;
+};
+
+MyRuleNode.prototype = Object.create(antlr4.ParserRuleContext.prototype);
+MyRuleNode.prototype.constructor = MyRuleNode;
+}
+>>
+
+TokenGetterListener(X) ::= <<
+@parser::members {
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.INT(0).symbol.text + ' ' + ctx.INT(1).symbol.text + ' ' + antlr4.Utils.arrayToString(ctx.INT());
+        } else {
+            str = ctx.ID().symbol.toString();
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+}
+>>
+
+RuleGetterListener(X) ::= <<
+@parser::members {
+this.LeafListener = function() {
+    this.exitA = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===2) {
+            str = ctx.b(0).start.text + ' ' + ctx.b(1).start.text + ' ' + ctx.b()[0].start.text;
+        } else {
+            str = ctx.b(0).start.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+}
+>>
+
+
+LRListener(X) ::= <<
+@parser::members {
+this.LeafListener = function() {
+    this.exitE = function(ctx) {
+    	var str;
+        if(ctx.getChildCount()===3) {
+            str = ctx.e(0).start.text + ' ' + ctx.e(1).start.text + ' ' + ctx.e()[0].start.text;
+        } else {
+            str = ctx.INT().symbol.text;
+        }
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+}
+>>
+
+LRWithLabelsListener(X) ::= <<
+@parser::members {
+this.LeafListener = function() {
+    this.exitCall = function(ctx) {
+    	var str = ctx.e().start.text + ' ' + ctx.eList();
+    	document.getElementById('output').value += str + '\\n';
+    };
+    this.exitInt = function(ctx) {
+        var str = ctx.INT().symbol.text;
+    	document.getElementById('output').value += str + '\\n';
+    };
+    return this;
+};
+this.LeafListener.prototype = Object.create(<X>Listener.prototype);
+this.LeafListener.prototype.constructor = this.LeafListener;
+}
+>>
+
+DeclareContextListGettersFunction() ::= <<
+	function foo() {
+		var s = new SContext();
+	    var a = s.a();
+	    var b = s.b();
+    };
+>>
+
+Declare_foo() ::= "this.foo = function() {document.getElementById('output').value += 'foo' + '\\n';};"
+
+Invoke_foo() ::= "this.foo();"
+
+Declare_pred() ::= <<this.pred = function(v) {
+	document.getElementById('output').value += 'eval=' + v.toString() + '\\n';
+	return v;
+};
+>>
+
+Invoke_pred(v) ::= <<this.pred(<v>)>>
+ParserTokenType(t) ::= "Parser.<t>"
+ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
+StringType() ::= "String"
+ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/javascript/firefox/Firefox.test.stg

@@ -1,158 +1,3 @@
-IgnoredTests ::= [
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.javascript.firefox;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
-	                          "<grammar>Listener", "<grammar>Visitor",
-	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
-                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
-	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
 write(s) ::= <<document.getElementById('output').value += <s>;>>
 writeList(s) ::= <<document.getElementById('output').value += <s; separator="+">;>>
@@ -449,8 +294,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/javascript/node/Node.test.stg

@@ -1,158 +1,3 @@
-IgnoredTests ::= [
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.javascript.node;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
-	                          "<grammar>Listener", "<grammar>Visitor",
-	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
-                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
-	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<console.log(<s>);>>
 write(s) ::= <<process.stdout.write(<s>);>>
 writeList(s) ::= <<console.log(<s; separator="+">);>>
@@ -542,8 +387,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/javascript/safari/Safari.test.stg

@@ -1,158 +1,3 @@
-IgnoredTests ::= [
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.javascript.safari;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BaseTest {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}<\n>
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-	<test.afterGrammar>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar>Parser", "<grammar>Lexer",
-	                          "<grammar>Listener", "<grammar>Visitor",
-	                          "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-    }>
-}
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser",
-                      "<test.grammar.grammarName>Listener", "<test.grammar.grammarName>Visitor",
-	                  "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<document.getElementById('output').value += <s> + '\\n';>>
 write(s) ::= <<document.getElementById('output').value += <s>;>>
 writeList(s) ::= <<document.getElementById('output').value += <s; separator="+">;>>
@@ -448,8 +293,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/python2/Python2.test.stg

@@ -1,169 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.python2;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BasePython2Test {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-<if(test.AfterGrammar)>
-	<test.AfterGrammar>
-<endif>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-	<test.AfterGrammar>
-
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.slaveIsLexer)>Parser<endif>", "<if(test.slaveIsLexer)><first(test.slaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<print(<s>)>>
 write(s) ::= <<print(<s>,end='')>>
 writeList(s) ::= <<print(<s: {v | str(<v>)}; separator="+">)>>
@@ -437,8 +271,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/python3/Python3.test.stg

@@ -1,169 +1,3 @@
-IgnoredTests ::= [
-	"Visitors.Basic": true,
-	"Visitors.LR": true,
-	"Visitors.LRWithLabels": true,
-	"Visitors.RuleGetters_1": true,
-	"Visitors.RuleGetters_2": true,
-	"Visitors.TokenGetters_1": true,
-	"Visitors.TokenGetters_2": true,
-	default: false
-]
-
-TestFile(file) ::= <<
-/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
-package org.antlr.v4.test.runtime.python3;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-<if(file.Options.("ImportErrorQueue"))>
-import org.antlr.v4.test.runtime.java.ErrorQueue;
-<endif>
-<if(file.Options.("ImportGrammar"))>
-import org.antlr.v4.tool.Grammar;
-<endif>
-
-@SuppressWarnings("unused")
-public class Test<file.name> extends BasePython3Test {
-
-	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
-
-}
->>
-
-LexerTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-<if(test.AfterGrammar)>
-	<test.AfterGrammar>
-<endif>
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeLexerTestMethod(test) ::= <<
-<LexerTestMethod(test)>
->>
-
-ParserTestMethod(test) ::= <<
-/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
-<testAnnotations(test)>
-public void test<test.name>() throws Exception {
-	mkdir(tmpdir);
-
-<test.SlaveGrammars:{grammar |
-	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
-<if(test.Options.("SlaveIsLexer"))>
-	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
-<else>
-	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
-<endif>
-	}; separator="\n">
-<test.Grammar:{grammar |
-	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
-
-	<test.AfterGrammar>
-
-	String input =<writeStringLiteral(test.Input)>;
-	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.slaveIsLexer)>Parser<endif>", "<if(test.slaveIsLexer)><first(test.slaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
-
-	assertEquals(<writeStringLiteral(test.Output)>, found);
-	<if(!isEmpty.(test.Errors))>
-	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-	}>
-}
-
->>
-
-CompositeParserTestMethod(test) ::= <<
-<ParserTestMethod(test)>
->>
-
-AbstractParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-String test<test.name>(String input) throws Exception {
-	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
-	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
-}
-
->>
-
-ConcreteParserTestMethod(test) ::= <<
-/* this file and method are generated, any edit will be overwritten by the next generation */
-@Test
-public void test<test.name>() throws Exception {
-	String found = test<test.baseName>("<test.input>");
-	assertEquals("<test.expectedOutput>", found);
-	<if(test.expectedErrors)>
-	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
-	<else>
-	assertNull(this.stderrDuringParse);
-	<endif>
-}
-
->>
-
-testAnnotations(test) ::= <%
-@Test
-<if(test.Options.("Ignore"))>
-<\n>@Ignore(<writeStringLiteral(test.Options.("Ignore"))>)
-<elseif(IgnoredTests.(({<file.name>.<test.name>})))>
-<\n>@Ignore(<writeStringLiteral(IgnoredTests.(({<file.name>.<test.name>})))>)
-<endif>
-%>
-
-buildStringLiteral(text, variable) ::= <<
-StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
-<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
-String <variable> = <variable>Builder.toString();
->>
-
-writeStringLiteral(text) ::= <%
-<if(isEmpty.(text))>
-""
-<else>
-<writeLines(lines.(text))>
-<endif>
-%>
-
-writeLines(textLines) ::= <%
-<if(rest(textLines))>
-<textLines:{line|
-<\n>		"<escape.(line)>}; separator="\" +">"
-<else>
-"<escape.(first(textLines))>"
-<endif>
-%>
-
-string(text) ::= <<
-"<escape.(text)>"
->>
-
-writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
-
 writeln(s) ::= <<print(<s>)>>
 write(s) ::= <<print(<s>,end='')>>
 writeList(s) ::= <<print(<s: {v | str(<v>)}; separator="+">)>>
@@ -422,8 +256,3 @@ ParserTokenType(t) ::= "Parser.<t>"
 ContextRuleFunction(ctx, rule) ::= "<ctx>.<rule>"
 StringType() ::= "String"
 ContextMember(ctx, subctx, member) ::= "<ctx>.<subctx>.<member>"
-
-isEmpty ::= [
-	"": true,
-	default: false
-]

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorInvokesDelegateRule.stg

@@ -22,7 +22,7 @@ Errors() ::= ""
 
 masterGrammar(grammarName, slaveGrammarName) ::= <<
 lexer grammar <grammarName>;
-import <slaveGrammarName>;
+import S;
 B : 'b';
 WS : (' '|'\n') -> skip ;
 >>

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/templates/CompositeLexers/LexerDelegatorRuleOverridesDelegate.stg

@@ -20,7 +20,7 @@ Errors() ::= ""
 
 masterGrammar(grammarName, slaveGrammarName) ::= <<
 lexer grammar <grammarName>;
-import <slaveGrammarName>;
+import S;
 A : 'a' B {<writeln("\"M.A\"")>} ;
 WS : (' '|'\n') -> skip ;
 >>

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/templates/CompositeParsers/ImportLexerWithOnlyFragmentRules.stg

@@ -25,7 +25,7 @@ Errors() ::= ""
 
 masterGrammar(grammarName, slaveGrammarName) ::= <<
 grammar <grammarName>;
-import <slaveGrammarName; separator=", ">;
+import Unicode;
 
 program : 'test' 'test';
 

runtime-testsuite-legacy/resources/org/antlr/v4/test/runtime/templates/JUnitGen.stg

@@ -0,0 +1,156 @@
+TestFile(file) ::= <<
+/* This file is generated by TestGenerator, any edits will be overwritten by the next generation. */
+package org.antlr.v4.test.runtime.<if(file.targetSubdir)><file.targetSubdir>.<endif><file.target; format="lower">;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import org.antlr.v4.test.runtime.java.ErrorQueue;
+import org.antlr.v4.tool.Grammar;
+
+@SuppressWarnings("unused")
+public class Test<file.name> extends Base<file.target>Test {
+
+	<file.tests:{test | <test>}; separator="\n", wrap, anchor>
+
+}
+>>
+
+LexerTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+@Test
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> = <writeStringLiteral(test.SlaveGrammars.(grammar))>;
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+	}; separator="\n">
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+<if(test.AfterGrammar)>
+	<test.AfterGrammar>
+<endif>
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execLexer("<grammar>.g4", grammar, "<grammar><if(test.Options.("CombinedGrammar"))>Lexer<endif>", input, <writeBoolean(test.Options.("ShowDFA"))>);
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}>
+}
+
+>>
+
+CompositeLexerTestMethod(test) ::= <<
+<LexerTestMethod(test)>
+>>
+
+ParserTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+@Test
+public void test<test.name>() throws Exception {
+	mkdir(tmpdir);
+
+<test.SlaveGrammars:{grammar |
+	String slave_<grammar> =<writeStringLiteral(test.SlaveGrammars.(grammar))>;
+<if(test.Options.("SlaveIsLexer"))>
+	rawGenerateAndBuildRecognizer("<grammar>.g4", slave_<grammar>, null, "<grammar>");
+<else>
+	writeFile(tmpdir, "<grammar>.g4", slave_<grammar>);
+<endif>
+	}; separator="\n">
+
+<test.Grammar:{grammar |
+	<buildStringLiteral(test.Grammar.(grammar), "grammar")>
+
+	<test.AfterGrammar>
+
+	String input =<writeStringLiteral(test.Input)>;
+	String found = execParser("<grammar>.g4", grammar, "<grammar><if(!test.SlaveIsLexer)>Parser<endif>", "<if(test.SlaveIsLexer)><first(test.SlaveGrammars).grammarName><else><grammar>Lexer<endif>", "<grammar>Listener", "<grammar>Visitor", "<test.Rule>", input, <writeBoolean(test.Options.("Debug"))>);
+
+	assertEquals(<writeStringLiteral(test.Output)>, found);
+	<if(!isEmpty.(test.Errors))>
+	assertEquals(<writeStringLiteral(test.Errors)>, this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}>
+}
+
+>>
+
+IgnoredTestMethod(test) ::= <<
+/* This file and method are generated by TestGenerator, any edits will be overwritten by the next generation. */
+@Test
+@Ignore("true")
+public void test<test.name>() throws Exception {
+}
+
+>>
+
+CompositeParserTestMethod(test) ::= <<
+<ParserTestMethod(test)>
+>>
+
+AbstractParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+String test<test.name>(String input) throws Exception {
+	String grammar = <test.grammar.lines:{ line | "<line>};separator="\\n\" +\n", wrap, anchor>";
+	return execParser("<test.grammar.grammarName>.g4", grammar, "<test.grammar.grammarName>Parser", "<test.grammar.grammarName>Lexer", "<test.startRule>", input, <test.debug>);
+}
+
+>>
+
+ConcreteParserTestMethod(test) ::= <<
+/* this file and method are generated, any edit will be overwritten by the next generation */
+@Test
+public void test<test.name>() throws Exception {
+	String found = test<test.baseName>("<test.input>");
+	assertEquals("<test.expectedOutput>", found);
+	<if(test.expectedErrors)>
+	assertEquals("<test.expectedErrors>", this.stderrDuringParse);
+	<else>
+	assertNull(this.stderrDuringParse);
+	<endif>
+}
+
+>>
+
+buildStringLiteral(text, variable) ::= <<
+StringBuilder <variable>Builder = new StringBuilder(<strlen.(text)>);
+<lines.(text):{line|<variable>Builder.append("<escape.(line)>");}; separator="\n">
+String <variable> = <variable>Builder.toString();
+>>
+
+writeStringLiteral(text) ::= <%
+<if(isEmpty.(text))>
+""
+<else>
+<writeLines(lines.(text))>
+<endif>
+%>
+
+writeLines(textLines) ::= <%
+<if(rest(textLines))>
+<textLines:{line|
+<\n>		"<escape.(line)>}; separator="\" +">"
+<else>
+"<escape.(first(textLines))>"
+<endif>
+%>
+
+writeBoolean(o) ::= "<if(o && !isEmpty.(o))>true<else>false<endif>"
+
+string(text) ::= <<
+"<escape.(text)>"
+>>
+
+isEmpty ::= [
+	"": true,
+	default: false
+]