You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@netbeans.apache.org by GitBox <gi...@apache.org> on 2018/02/05 19:42:39 UTC
[GitHub] jlahoda closed pull request #405: Re-correcting positions used in java.completion tests to reflect curr?
jlahoda closed pull request #405: Re-correcting positions used in java.completion tests to reflect curr?
URL: https://github.com/apache/incubator-netbeans/pull/405
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask15FeaturesTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask15FeaturesTest.java
index 9aa06ef94..341bdf444 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask15FeaturesTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask15FeaturesTest.java
@@ -32,218 +32,218 @@ public JavaCompletionTask15FeaturesTest(String testName) {
// Java 1.5 generics tests -------------------------------------------------------
public void testEmptyFileBeforeTypingFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<", "empty.pass");
+ performTest("GenericsStart", 841, "<", "empty.pass");
}
public void testBeforeTypingFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<", "empty.pass");
+ performTest("GenericsNoTypeParams", 841, "<", "empty.pass");
}
public void testBeforeFirstTypeParam() throws Exception {
- performTest("Generics", 843, null, "empty.pass");
+ performTest("Generics", 842, null, "empty.pass");
}
public void testEmptyFileTypingFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<X", "empty.pass");
+ performTest("GenericsStart", 841, "<X", "empty.pass");
}
public void testTypingFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X", "empty.pass");
+ performTest("GenericsNoTypeParams", 841, "<X", "empty.pass");
}
public void testOnFirstTypeParam() throws Exception {
- performTest("Generics", 844, null, "empty.pass");
+ performTest("Generics", 843, null, "empty.pass");
}
public void testEmptyFileAfterTypingFirstTypeParamAndSpace() throws Exception {
- performTest("GenericsStart", 842, "<X ", "extendsKeyword.pass");
+ performTest("GenericsStart", 841, "<X ", "extendsKeyword.pass");
}
public void testAfterTypingFirstTypeParamAndSpace() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X ", "extendsKeyword.pass");
+ performTest("GenericsNoTypeParams", 841, "<X ", "extendsKeyword.pass");
}
public void testAfterFirstTypeParamAndSpace() throws Exception {
- performTest("Generics", 845, null, "extendsKeyword.pass");
+ performTest("Generics", 844, null, "extendsKeyword.pass");
}
public void testEmptyFileTypingExtendsInFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<X e", "extendsKeyword.pass");
+ performTest("GenericsStart", 841, "<X e", "extendsKeyword.pass");
}
public void testTypingExtendsInFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X e", "extendsKeyword.pass");
+ performTest("GenericsNoTypeParams", 841, "<X e", "extendsKeyword.pass");
}
public void testOnExtendsInFirstTypeParam() throws Exception {
- performTest("Generics", 846, null, "extendsKeyword.pass");
+ performTest("Generics", 845, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsInFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<X extends", "extendsKeyword.pass");
+ performTest("GenericsStart", 841, "<X extends", "extendsKeyword.pass");
}
public void testAfterTypingExtendsInFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X extends", "extendsKeyword.pass");
+ performTest("GenericsNoTypeParams", 841, "<X extends", "extendsKeyword.pass");
}
public void testAfterExtendsInFirstTypeParam() throws Exception {
- performTest("Generics", 852, null, "extendsKeyword.pass");
+ performTest("Generics", 851, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsAndSpaceInFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<X extends ", "javaLangContentAndTestClass.pass");
+ performTest("GenericsStart", 841, "<X extends ", "javaLangContentAndTestClass.pass");
}
public void testAfterTypingExtendsAndSpaceInFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X extends ", "javaLangContentAndTestClass.pass");
+ performTest("GenericsNoTypeParams", 841, "<X extends ", "javaLangContentAndTestClass.pass");
}
public void testAfterExtendsAndSpaceInFirstTypeParam() throws Exception {
- performTest("Generics", 853, null, "javaLangContentAndTestClass.pass");
+ performTest("Generics", 852, null, "javaLangContentAndTestClass.pass");
}
public void testEmptyFileAfterTypingBoundedFirstTypeParamAndSpace() throws Exception {
- performTest("GenericsStart", 842, "<X extends Number ", "empty.pass");
+ performTest("GenericsStart", 841, "<X extends Number ", "empty.pass");
}
public void testAfterTypingBoundedFirstTypeParamAndSpace() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X extends Number ", "empty.pass");
+ performTest("GenericsNoTypeParams", 841, "<X extends Number ", "empty.pass");
}
public void testAfterBoundedFirstTypeParamAndSpace() throws Exception {
- performTest("Generics", 859, " ", "empty.pass");
+ performTest("Generics", 858, " ", "empty.pass");
}
public void testEmptyFileAfterTypingFirstTypeParam() throws Exception {
- performTest("GenericsStart", 842, "<X extends Number,", "empty.pass");
+ performTest("GenericsStart", 841, "<X extends Number,", "empty.pass");
}
public void testAfterTypingFirstTypeParam() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X extends Number,", "empty.pass");
+ performTest("GenericsNoTypeParams", 841, "<X extends Number,", "empty.pass");
}
public void testAfterFirstTypeParam() throws Exception {
- performTest("Generics", 860, null, "empty.pass");
+ performTest("Generics", 859, null, "empty.pass");
}
public void testEmptyFileAfterTypingTypeParams() throws Exception {
- performTest("GenericsStart", 842, "<X extends Number, Y extends RuntimeException>", "extendsAndImplementsKeywords.pass");
+ performTest("GenericsStart", 841, "<X extends Number, Y extends RuntimeException>", "extendsAndImplementsKeywords.pass");
}
public void testAfterTypingTypeParams() throws Exception {
- performTest("GenericsNoTypeParams", 842, "<X extends Number, Y extends RuntimeException>", "extendsAndImplementsKeywords.pass");
+ performTest("GenericsNoTypeParams", 841, "<X extends Number, Y extends RuntimeException>", "extendsAndImplementsKeywords.pass");
}
public void testAfterTypeParams() throws Exception {
- performTest("Generics", 888, null, "extendsAndImplementsKeywords.pass");
+ performTest("Generics", 887, null, "extendsAndImplementsKeywords.pass");
}
public void testEmptyFileBeforeTypingFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <", "empty.pass");
+ performTest("MethodStart", 849, "public <", "empty.pass");
}
public void testBeforeTypingFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<", "empty.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<", "empty.pass");
}
public void testBeforeFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 858, null, "empty.pass");
+ performTest("GenericsMethod", 857, null, "empty.pass");
}
public void testEmptyFileTypingFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <X", "empty.pass");
+ performTest("MethodStart", 849, "public <X", "empty.pass");
}
public void testTypingFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X", "empty.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X", "empty.pass");
}
public void testOnFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 859, null, "empty.pass");
+ performTest("GenericsMethod", 858, null, "empty.pass");
}
public void testEmptyFileAfterTypingFirstMethodTypeParamAndSpace() throws Exception {
- performTest("MethodStart", 850, "public <X ", "extendsKeyword.pass");
+ performTest("MethodStart", 849, "public <X ", "extendsKeyword.pass");
}
public void testAfterTypingFirstMethodTypeParamAndSpace() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X ", "extendsKeyword.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X ", "extendsKeyword.pass");
}
public void testAfterFirstMethodTypeParamAndSpace() throws Exception {
- performTest("GenericsMethod", 860, null, "extendsKeyword.pass");
+ performTest("GenericsMethod", 859, null, "extendsKeyword.pass");
}
public void testEmptyFileTypingExtendsInFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <X e", "extendsKeyword.pass");
+ performTest("MethodStart", 849, "public <X e", "extendsKeyword.pass");
}
public void testTypingExtendsInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X e", "extendsKeyword.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X e", "extendsKeyword.pass");
}
public void testOnExtendsInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 861, null, "extendsKeyword.pass");
+ performTest("GenericsMethod", 860, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsInFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <X extends", "extendsKeyword.pass");
+ performTest("MethodStart", 849, "public <X extends", "extendsKeyword.pass");
}
public void testAfterTypingExtendsInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X extends", "extendsKeyword.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X extends", "extendsKeyword.pass");
}
public void testAfterExtendsInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 867, null, "extendsKeyword.pass");
+ performTest("GenericsMethod", 866, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsAndSpaceInFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <X extends ", "javaLangContentAndTestClass.pass");
+ performTest("MethodStart", 849, "public <X extends ", "javaLangContentAndTestClass.pass");
}
public void testAfterTypingExtendsAndSpaceInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X extends ", "javaLangContentAndTestClass.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X extends ", "javaLangContentAndTestClass.pass");
}
public void testAfterExtendsAndSpaceInFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 868, null, "javaLangContentAndTestClass.pass");
+ performTest("GenericsMethod", 867, null, "javaLangContentAndTestClass.pass");
}
public void testEmptyFileAfterTypingBoundedFirstMethodTypeParamAndSpace() throws Exception {
- performTest("MethodStart", 850, "public <X extends Number ", "empty.pass");
+ performTest("MethodStart", 849, "public <X extends Number ", "empty.pass");
}
public void testAfterTypingBoundedFirstMethodTypeParamAndSpace() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X extends Number ", "empty.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X extends Number ", "empty.pass");
}
public void testAfterBoundedFirstMethodTypeParamAndSpace() throws Exception {
- performTest("Generics", 874, " ", "empty.pass");
+ performTest("Generics", 873, " ", "empty.pass");
}
public void testEmptyFileAfterTypingFirstMethodTypeParam() throws Exception {
- performTest("MethodStart", 850, "public <X extends Number,", "empty.pass");
+ performTest("MethodStart", 849, "public <X extends Number,", "empty.pass");
}
public void testAfterTypingFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X extends Number,", "empty.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X extends Number,", "empty.pass");
}
public void testAfterFirstMethodTypeParam() throws Exception {
- performTest("GenericsMethod", 875, null, "empty.pass");
+ performTest("GenericsMethod", 874, null, "empty.pass");
}
public void testEmptyFileAfterTypingMethodTypeParams() throws Exception {
- performTest("MethodStart", 850, "public <X extends Number, Y extends RuntimeException>", "returnTypes.pass");
+ performTest("MethodStart", 849, "public <X extends Number, Y extends RuntimeException>", "returnTypes.pass");
}
public void testAfterTypingMethodTypeParams() throws Exception {
- performTest("GenericsMethodNoTypeParams", 857, "<X extends Number, Y extends RuntimeException>", "returnTypes.pass");
+ performTest("GenericsMethodNoTypeParams", 856, "<X extends Number, Y extends RuntimeException>", "returnTypes.pass");
}
public void testAfterMethodTypeParams() throws Exception {
- performTest("GenericsMethod", 903, null, "returnTypes.pass");
+ performTest("GenericsMethod", 902, null, "returnTypes.pass");
}
}
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask17FeaturesTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask17FeaturesTest.java
index b910a2b38..187c16962 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask17FeaturesTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask17FeaturesTest.java
@@ -33,87 +33,87 @@ public JavaCompletionTask17FeaturesTest(String testName) {
// Java 1.7 try-with-resources tests ---------------------------------------
public void testEmptyFileBeforeTypingVarResouce() throws Exception {
- performTest("TWRStart", 924, "try (", "finalAndAutoCloseables.pass", "1.7");
+ performTest("TWRStart", 923, "try (", "finalAndAutoCloseables.pass", "1.7");
}
public void testBeforeTypingVarResouce() throws Exception {
- performTest("TWRNoRes", 937, null, "finalAndAutoCloseables.pass", "1.7");
+ performTest("TWRNoRes", 936, null, "finalAndAutoCloseables.pass", "1.7");
}
public void testBeforeVarResouce() throws Exception {
- performTest("TWR", 937, null, "finalAndAutoCloseables.pass", "1.7");
+ performTest("TWR", 936, null, "finalAndAutoCloseables.pass", "1.7");
}
public void testEmptyFileTypingVarResouce() throws Exception {
- performTest("TWRStart", 924, "try (f", "finalKeyword.pass", "1.7");
+ performTest("TWRStart", 923, "try (f", "finalKeyword.pass", "1.7");
}
public void testTypingVarResouce() throws Exception {
- performTest("TWRNoRes", 937, "f", "finalKeyword.pass", "1.7");
+ performTest("TWRNoRes", 936, "f", "finalKeyword.pass", "1.7");
}
public void testOnVarResouce() throws Exception {
- performTest("TWR", 938, null, "finalKeyword.pass", "1.7");
+ performTest("TWR", 937, null, "finalKeyword.pass", "1.7");
}
public void testEmptyFileAfterFinalInResource() throws Exception {
- performTest("TWRStart", 924, "try (final ", "autoCloseables.pass", "1.7");
+ performTest("TWRStart", 923, "try (final ", "autoCloseables.pass", "1.7");
}
public void testTypingAfterFinalInResouce() throws Exception {
- performTest("TWRNoRes", 937, "final ", "autoCloseables.pass", "1.7");
+ performTest("TWRNoRes", 936, "final ", "autoCloseables.pass", "1.7");
}
public void testAfterFinalInResouce() throws Exception {
- performTest("TWR", 943, null, "autoCloseables.pass", "1.7");
+ performTest("TWR", 942, null, "autoCloseables.pass", "1.7");
}
public void testEmptyFileTypingTypeInVarResouce() throws Exception {
- performTest("TWRStart", 924, "try (final F", "autoCloseablesStartingWithF.pass", "1.7");
+ performTest("TWRStart", 923, "try (final F", "autoCloseablesStartingWithF.pass", "1.7");
}
public void testTypingTypeInVarResouce() throws Exception {
- performTest("TWRNoRes", 937, "final F", "autoCloseablesStartingWithF.pass", "1.7");
+ performTest("TWRNoRes", 936, "final F", "autoCloseablesStartingWithF.pass", "1.7");
}
public void testOnTypeInVarResouce() throws Exception {
- performTest("TWR", 944, null, "autoCloseablesStartingWithF.pass", "1.7");
+ performTest("TWR", 943, null, "autoCloseablesStartingWithF.pass", "1.7");
}
public void testEmptyFileBeforeTypingNameInVarResouce() throws Exception {
- performTest("TWRStart", 924, "try (final FileWriter ", "resourceNames.pass", "1.7");
+ performTest("TWRStart", 923, "try (final FileWriter ", "resourceNames.pass", "1.7");
}
public void testBeforeTypingNameInVarResouce() throws Exception {
- performTest("TWRNoRes", 937, "final FileWriter ", "resourceNames.pass", "1.7");
+ performTest("TWRNoRes", 936, "final FileWriter ", "resourceNames.pass", "1.7");
}
public void testBeforeNameInVarResouce() throws Exception {
- performTest("TWR", 954, null, "resourceNames.pass", "1.7");
+ performTest("TWR", 953, null, "resourceNames.pass", "1.7");
}
public void testEmptyFileAfterTypingNameInVarResouce() throws Exception {
- performTest("TWRStart", 924, "try (final FileWriter fw ", "empty.pass", "1.7");
+ performTest("TWRStart", 923, "try (final FileWriter fw ", "empty.pass", "1.7");
}
public void testAfterTypingNameInVarResouce() throws Exception {
- performTest("TWRNoRes", 937, "final FileWriter fw ", "empty.pass", "1.7");
+ performTest("TWRNoRes", 936, "final FileWriter fw ", "empty.pass", "1.7");
}
public void testAfterNameInVarResouce() throws Exception {
- performTest("TWR", 957, null, "empty.pass", "1.7");
+ performTest("TWR", 956, null, "empty.pass", "1.7");
}
public void testEmptyFileBeforeVarResouceInit() throws Exception {
- performTest("TWRStart", 924, "try (final FileWriter fw = ", "resourceInit.pass", "1.7");
+ performTest("TWRStart", 923, "try (final FileWriter fw = ", "resourceInit.pass", "1.7");
}
public void testBeforeTypingVarResouceInit() throws Exception {
- performTest("TWRNoRes", 937, "final FileWriter fw = ", "resourceInit.pass", "1.7");
+ performTest("TWRNoRes", 936, "final FileWriter fw = ", "resourceInit.pass", "1.7");
}
public void testBeforeVarResouceInit() throws Exception {
- performTest("TWR", 959, null, "resourceInit.pass", "1.7");
+ performTest("TWR", 958, null, "resourceInit.pass", "1.7");
}
static {
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask18FeaturesTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask18FeaturesTest.java
index c8b7f7776..42a84564e 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask18FeaturesTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask18FeaturesTest.java
@@ -33,305 +33,305 @@ public JavaCompletionTask18FeaturesTest(String testName) {
// Java 1.8 default method tests -------------------------------------------
public void testEmptyFileBeforeTypingDefaultModifier() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {", "interfaceMemberModifiersAndTypes.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {", "interfaceMemberModifiersAndTypes.pass", "1.8");
}
public void testBeforeTypingDefaultModifier() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, null, "interfaceMemberModifiersAndTypes.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, null, "interfaceMemberModifiersAndTypes.pass", "1.8");
}
public void testBeforeDefaultModifier() throws Exception {
- performTest("Interface", 847, null, "interfaceMemberModifiersAndTypes.pass", "1.8");
+ performTest("Interface", 846, null, "interfaceMemberModifiersAndTypes.pass", "1.8");
}
public void testEmptyFileTypingDefaultModifier() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {\nde", "defaultKeyword.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {\nde", "defaultKeyword.pass", "1.8");
}
public void testTypingDefaultModifier() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, "\nde", "defaultKeyword.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, "\nde", "defaultKeyword.pass", "1.8");
}
public void testOnDefaultModifier() throws Exception {
- performTest("Interface", 849, null, "defaultKeyword.pass", "1.8");
+ performTest("Interface", 848, null, "defaultKeyword.pass", "1.8");
}
public void testEmptyFileAfterTypingDefaultModifier() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {\ndefault ", "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {\ndefault ", "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
}
public void testAfterTypingDefaultModifier() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, "\ndefault ", "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, "\ndefault ", "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
}
public void testAfterDefaultModifier() throws Exception {
- performTest("Interface", 855, null, "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
+ performTest("Interface", 854, null, "interfaceMemberModifiersAndTypesWithoutDefaultAbstractAndStatic.pass", "1.8");
}
public void testEmptyFileAfterTypingStaticModifier() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {\nstatic ", "memberModifiersAndTypesWithoutStatic.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {\nstatic ", "memberModifiersAndTypesWithoutStatic.pass", "1.8");
}
public void testAfterTypingStaticModifier() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, "\nstatic ", "memberModifiersAndTypesWithoutStatic.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, "\nstatic ", "memberModifiersAndTypesWithoutStatic.pass", "1.8");
}
public void testAfterStaticModifier() throws Exception {
- performTest("Interface", 912, null, "memberModifiersAndTypesWithoutStatic.pass", "1.8");
+ performTest("Interface", 911, null, "memberModifiersAndTypesWithoutStatic.pass", "1.8");
}
public void testEmptyFileTypingDefaultMethodBody() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {\ndefault String name() {", "typesInterfaceMembersAndVars1.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {\ndefault String name() {", "typesInterfaceMembersAndVars1.pass", "1.8");
}
public void testTypingDefaultMethodBody() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, "\ndefault String name() {", "typesInterfaceMembersAndVars1.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, "\ndefault String name() {", "typesInterfaceMembersAndVars1.pass", "1.8");
}
public void testInsideDefaultMethodBody() throws Exception {
- performTest("Interface", 879, null, "typesInterfaceMembersAndVars.pass", "1.8");
+ performTest("Interface", 878, null, "typesInterfaceMembersAndVars.pass", "1.8");
}
public void testEmptyFileTypingStaticMethodBody() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test {\nstatic int length(String s) {", "typesStaticInterfaceMembersAndVars.pass", "1.8");
+ performTest("Empty", 808, "package test;\ninterface Test {\nstatic int length(String s) {", "typesStaticInterfaceMembersAndVars.pass", "1.8");
}
public void testTypingStaticMethodBody() throws Exception {
- performTest("SimpleInterfaceNoExtends", 841, "\nstatic int length(String s) {", "typesStaticInterfaceMembersAndVars.pass", "1.8");
+ performTest("SimpleInterfaceNoExtends", 840, "\nstatic int length(String s) {", "typesStaticInterfaceMembersAndVars.pass", "1.8");
}
public void testInsideStaticMethodBody() throws Exception {
- performTest("Interface", 943, null, "typesStaticInterfaceMembersAndVars.pass", "1.8");
+ performTest("Interface", 942, null, "typesStaticInterfaceMembersAndVars.pass", "1.8");
}
// Java 1.8 lambda expressions tests ---------------------------------------
public void testEmptyFileAfterTypingLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s ", "empty.pass", "1.8");
}
public void testAfterTypingLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s ", "empty.pass", "1.8");
}
public void testAfterLambdaParam() throws Exception {
- performTest("SimpleLambdaExpression", 1015, null, "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1014, null, "empty.pass", "1.8");
}
public void testEmptyFileAfterTypingTypeOfLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String ", "stringVarName.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String ", "stringVarName.pass", "1.8");
}
public void testAfterTypingTypeOfLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String ", "stringVarName.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String ", "stringVarName.pass", "1.8");
}
public void testAfterTypeOfLambdaParam() throws Exception {
- performTest("SimpleLambdaExpression", 1075, null, "stringVarName.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1074, null, "stringVarName.pass", "1.8");
}
public void testEmptyFileAfterTypingTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s ", "empty.pass", "1.8");
}
public void testAfterTypingTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s ", "empty.pass", "1.8");
}
public void testAfterTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpression", 1076, " ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1075, " ", "empty.pass", "1.8");
}
public void testEmptyFileTypingSecondLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((s,", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((s,", "empty.pass", "1.8");
}
public void testTypingSecondLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((s,", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((s,", "empty.pass", "1.8");
}
public void testBeforeSecondLambdaParam() throws Exception {
- performTest("SimpleLambdaExpression", 1041, ",", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1040, ",", "empty.pass", "1.8");
}
public void testEmptyFileTypingSecondTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s,", "lambdaParameterTypes.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s,", "lambdaParameterTypes.pass", "1.8");
}
public void testTypingSecondTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s,", "lambdaParameterTypes.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s,", "lambdaParameterTypes.pass", "1.8");
}
public void testBeforeSecondTypedLambdaParam() throws Exception {
- performTest("SimpleLambdaExpression", 1076, ",", "lambdaParameterTypes.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1075, ",", "lambdaParameterTypes.pass", "1.8");
}
public void testEmptyFileAfterTypingTypedLambdaParams() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s)", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s)", "empty.pass", "1.8");
}
public void testAfterTypingTypedLambdaParams() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s)", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s)", "empty.pass", "1.8");
}
public void testAfterTypedLambdaParams() throws Exception {
- performTest("SimpleLambdaExpression", 1077, null, "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1076, null, "empty.pass", "1.8");
}
public void testEmptyFileAfterTypingTypedLambdaParamsAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s) ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s) ", "empty.pass", "1.8");
}
public void testAfterTypingTypedLambdaParamsAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s) ", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s) ", "empty.pass", "1.8");
}
public void testAfterTypedLambdaParamsAndSpace() throws Exception {
- performTest("SimpleLambdaExpression", 1078, null, "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1077, null, "empty.pass", "1.8");
}
public void testEmptyFileAfterTypingLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s ->", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s ->", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypingLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s ->", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s ->", "lambdaSmartInt.pass", "1.8");
}
public void testAfterLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpression", 1017, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1016, null, "lambdaSmartInt.pass", "1.8");
}
public void testEmptyFileAfterTypingTypedLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s) ->", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s) ->", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypingTypedLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s) ->", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s) ->", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypedLambdaArrow() throws Exception {
- performTest("SimpleLambdaExpression", 1080, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1079, null, "lambdaSmartInt.pass", "1.8");
}
public void testEmptyFileAfterTypingLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s -> ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s -> ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypingLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s -> ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s -> ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpression", 1018, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1017, null, "lambdaSmartInt.pass", "1.8");
}
public void testEmptyFileAfterTypingTypedLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s) -> ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s) -> ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypingTypedLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s) -> ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s) -> ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterTypedLambdaArrowAndSpace() throws Exception {
- performTest("SimpleLambdaExpression", 1081, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1080, null, "lambdaSmartInt.pass", "1.8");
}
public void testEmptyFileAfterTypingLambdaExpression() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s -> s.length()", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s -> s.length()", "empty.pass", "1.8");
}
public void testAfterTypingLambdaExpression() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s -> s.length()", "empty.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s -> s.length()", "empty.pass", "1.8");
}
public void testAfterLambdaExpression() throws Exception {
- performTest("SimpleLambdaExpression", 1028, null, "empty.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1027, null, "empty.pass", "1.8");
}
public void testEmptyFileTypingLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s -> {", "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s -> {", "lambdaBodyContent.pass", "1.8");
}
public void testTypingLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s -> {", "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s -> {", "lambdaBodyContent.pass", "1.8");
}
public void testInsideOfLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpression", 1118, null, "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1117, null, "lambdaBodyContent.pass", "1.8");
}
public void testEmptyFileTypingTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s) -> {", "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s) -> {", "lambdaBodyContent.pass", "1.8");
}
public void testTypingTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s) -> {", "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s) -> {", "lambdaBodyContent.pass", "1.8");
}
public void testInsideOfTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpression", 1082, null, "lambdaBodyContent.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1081, null, "lambdaBodyContent.pass", "1.8");
}
public void testEmptyFileAfterLocalVarInLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s -> {int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s -> {int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
}
public void testTypingAfterLocalVarInLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s -> {int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s -> {int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
}
public void testAfterLocalVarInLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpression", 1082, "int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1081, "int i; ", "lambdaBodyContentWithLocalVar.pass", "1.8");
}
public void testEmptyFileTypingReturnFromLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test(s -> {return ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test(s -> {return ", "lambdaSmartInt.pass", "1.8");
}
public void testTypingReturnFromLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test(s -> {return ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test(s -> {return ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterReturnFromLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpression", 1125, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1124, null, "lambdaSmartInt.pass", "1.8");
}
public void testEmptyFileTypingReturnFromTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionStart", 1005, "t.test((String s) -> {return ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionStart", 1004, "t.test((String s) -> {return ", "lambdaSmartInt.pass", "1.8");
}
public void testTypingReturnFromTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpressionEmptyMethodBody", 1005, "t.test((String s) -> {return ", "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpressionEmptyMethodBody", 1004, "t.test((String s) -> {return ", "lambdaSmartInt.pass", "1.8");
}
public void testAfterReturnFromTypedLambdaBlock() throws Exception {
- performTest("SimpleLambdaExpression", 1089, null, "lambdaSmartInt.pass", "1.8");
+ performTest("SimpleLambdaExpression", 1088, null, "lambdaSmartInt.pass", "1.8");
}
public void testMoreCandidatesEmptyFileAfterTypingLambdaArrow() throws Exception {
- performTest("LambdaExpressionStart", 1103, "t.test(s ->", "lambdaExpression.pass", "1.8");
+ performTest("LambdaExpressionStart", 1102, "t.test(s ->", "lambdaExpression.pass", "1.8");
}
public void testMoreCandidatesAfterTypingLambdaArrow() throws Exception {
- performTest("LambdaExpressionEmptyMethodBody", 1103, "t.test(s ->", "lambdaExpression.pass", "1.8");
+ performTest("LambdaExpressionEmptyMethodBody", 1102, "t.test(s ->", "lambdaExpression.pass", "1.8");
}
public void testMoreCandidatesAfterLambdaArrow() throws Exception {
- performTest("LambdaExpression", 1123, null, "lambdaSmartInt2.pass", "1.8");
+ performTest("LambdaExpression", 1122, null, "lambdaSmartInt2.pass", "1.8");
}
public void testMoreCandidatesEmptyFileTypingReturnFromLambdaBlock() throws Exception {
- performTest("LambdaExpressionStart", 1103, "t.test(s -> {return ", "lambdaExpression.pass", "1.8");
+ performTest("LambdaExpressionStart", 1102, "t.test(s -> {return ", "lambdaExpression.pass", "1.8");
}
public void testMoreCandidatesTypingReturnFromLambdaBlock() throws Exception {
- performTest("LambdaExpressionEmptyMethodBody", 1103, "t.test(s -> {return ", "lambdaExpression.pass", "1.8");
+ performTest("LambdaExpressionEmptyMethodBody", 1102, "t.test(s -> {return ", "lambdaExpression.pass", "1.8");
}
public void testMoreCandidatesAfterReturnFromLambdaBlock() throws Exception {
- performTest("LambdaExpression", 1160, null, "lambdaSmartInt2.pass", "1.8");
+ performTest("LambdaExpression", 1159, null, "lambdaSmartInt2.pass", "1.8");
}
static {
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask19FeaturesTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask19FeaturesTest.java
index 9d62bba26..dfc961aee 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask19FeaturesTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTask19FeaturesTest.java
@@ -33,51 +33,51 @@ public JavaCompletionTask19FeaturesTest(String testName) {
// Java 1.9 try-with-resources tests -------------------------------------------
public void testEmptyFileBeforeTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRStart", 949, "try (", "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWRStart", 948, "try (", "resourcesAndAutoCloseables.pass", "1.9");
}
public void testBeforeTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRNoRes", 954, null, "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWRNoRes", 953, null, "resourcesAndAutoCloseables.pass", "1.9");
}
public void testBeforeExistingVarResouce() throws Exception {
- performTest("SimpleTWR", 982, null, "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWR", 981, null, "resourcesAndAutoCloseables.pass", "1.9");
}
public void testEmptyFileTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRStart", 949, "try (f", "finalKeyword.pass", "1.9");
+ performTest("SimpleTWRStart", 948, "try (f", "finalKeyword.pass", "1.9");
}
public void testTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRNoRes", 954, "f", "finalKeyword.pass", "1.9");
+ performTest("SimpleTWRNoRes", 953, "f", "finalKeyword.pass", "1.9");
}
public void testOnExistingVarResouce() throws Exception {
- performTest("SimpleTWR", 983, null, "finalKeyword.pass", "1.9");
+ performTest("SimpleTWR", 982, null, "finalKeyword.pass", "1.9");
}
public void testEmptyFileAfterTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRStart", 949, "try (fw ", "empty.pass", "1.9");
+ performTest("SimpleTWRStart", 948, "try (fw ", "empty.pass", "1.9");
}
public void testAfterTypingExistingVarResouce() throws Exception {
- performTest("SimpleTWRNoRes", 954, "fw ", "empty.pass", "1.9");
+ performTest("SimpleTWRNoRes", 953, "fw ", "empty.pass", "1.9");
}
public void testAfterExistingVarResouce() throws Exception {
- performTest("SimpleTWR", 984, " ", "empty.pass", "1.9");
+ performTest("SimpleTWR", 983, " ", "empty.pass", "1.9");
}
public void testEmptyFileBeforeTypingNewVarResouce() throws Exception {
- performTest("SimpleTWRStart", 949, "try (fw;", "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWRStart", 948, "try (fw;", "resourcesAndAutoCloseables.pass", "1.9");
}
public void testBeforeTypingNewVarResouce() throws Exception {
- performTest("SimpleTWRNoRes", 954, "fw;", "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWRNoRes", 953, "fw;", "resourcesAndAutoCloseables.pass", "1.9");
}
public void testBeforeNewVarResouce() throws Exception {
- performTest("SimpleTWR", 985, null, "resourcesAndAutoCloseables.pass", "1.9");
+ performTest("SimpleTWR", 984, null, "resourcesAndAutoCloseables.pass", "1.9");
}
static {
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskAdvancedTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskAdvancedTest.java
index bfe82a104..b1fab5a8c 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskAdvancedTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskAdvancedTest.java
@@ -32,918 +32,918 @@ public JavaCompletionTaskAdvancedTest(String testName) {
// constructor tests -------------------------------------------------------
public void testEmptyFileAfterTypingNew() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew ", "declaredTypes.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew ", "declaredTypes.pass");
}
public void testAfterTypingNew() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew ", "declaredTypes.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew ", "declaredTypes.pass");
}
public void testAfterNew() throws Exception {
- performTest("AdvancedMethodBody", 931, null, "declaredTypes.pass");
+ performTest("AdvancedMethodBody", 930, null, "declaredTypes.pass");
}
public void testEmptyFileTypingConstructorName() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew Str", "declaredTypesStartingWithStr.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew Str", "declaredTypesStartingWithStr.pass");
}
public void testTypingConstructorName() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew Str", "declaredTypesStartingWithStr.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew Str", "declaredTypesStartingWithStr.pass");
}
public void testOnConstructorName() throws Exception {
- performTest("AdvancedMethodBody", 934, null, "declaredTypesStartingWithStr.pass");
+ performTest("AdvancedMethodBody", 933, null, "declaredTypesStartingWithStr.pass");
}
public void testEmptyFileAfterTypingConstructorName() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String", "stringConstructors.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String", "stringConstructors.pass");
}
public void testAfterTypingConstructorName() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String", "stringConstructors.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String", "stringConstructors.pass");
}
public void testAfterConstructorName() throws Exception {
- performTest("AdvancedMethodBody", 937, null, "stringConstructors.pass");
+ performTest("AdvancedMethodBody", 936, null, "stringConstructors.pass");
}
public void testEmptyFileBeforeTypingConstructorParam() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(", "typesLocalMembersVarsAndSmartString.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(", "typesLocalMembersVarsAndSmartString.pass");
}
public void testBeforeTypingConstructorParam() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(", "typesLocalMembersVarsAndSmartString.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(", "typesLocalMembersVarsAndSmartString.pass");
}
public void testBeforeConstructorParam() throws Exception {
- performTest("AdvancedMethodBody", 938, null, "typesLocalMembersVarsAndSmartString.pass");
+ performTest("AdvancedMethodBody", 937, null, "typesLocalMembersVarsAndSmartString.pass");
}
public void testEmptyFileTypingConstructorParam() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(fie", "field.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(fie", "field.pass");
}
public void testTypingConstructorParam() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(fie", "field.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(fie", "field.pass");
}
public void testOnConstructorParam() throws Exception {
- performTest("AdvancedMethodBody", 942, null, "field.pass");
+ performTest("AdvancedMethodBody", 941, null, "field.pass");
}
public void testEmptyFileAfterTypingConstructorParam() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(field", "field.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(field", "field.pass");
}
public void testAfterTypingConstructorParam() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(field", "field.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(field", "field.pass");
}
public void testAfterConstructorParam() throws Exception {
- performTest("AdvancedMethodBody", 943, null, "field.pass");
+ performTest("AdvancedMethodBody", 942, null, "field.pass");
}
public void testEmptyFileAfterTypingConstructorParamAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(field ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(field ", "empty.pass");
}
public void testAfterTypingConstructorParamAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(field ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(field ", "empty.pass");
}
public void testAfterConstructorParamAndSpace() throws Exception {
- performTest("AdvancedMethodBody", 943, " ", "empty.pass");
+ performTest("AdvancedMethodBody", 942, " ", "empty.pass");
}
public void testEmptyFileAfterTypingConstructor() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(field)", "instanceOf.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(field)", "instanceOf.pass");
}
public void testAfterTypingConstructor() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(field)", "instanceOf.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(field)", "instanceOf.pass");
}
public void testAfterConstructor() throws Exception {
- performTest("AdvancedMethodBody", 944, null, "instanceOf.pass");
+ performTest("AdvancedMethodBody", 943, null, "instanceOf.pass");
}
public void testEmptyFileAfterTypingConstructorAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(field) ", "instanceOf.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(field) ", "instanceOf.pass");
}
public void testAfterTypingConstructorAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(field) ", "instanceOf.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(field) ", "instanceOf.pass");
}
public void testAfterConstructorAndSpace() throws Exception {
- performTest("AdvancedMethodBody", 944, " ", "instanceOf.pass");
+ performTest("AdvancedMethodBody", 943, " ", "instanceOf.pass");
}
public void testEmptyFileAfterTypingConstructorAndDot() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean b;\nnew String(field).", "stringContent.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean b;\nnew String(field).", "stringContent.pass");
}
public void testAfterTypingConstructorAndDot() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean b;\nnew String(field).", "stringContent.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean b;\nnew String(field).", "stringContent.pass");
}
public void testAfterConstructorAndDot() throws Exception {
- performTest("AdvancedMethodBody", 945, null, "stringContent.pass");
+ performTest("AdvancedMethodBody", 944, null, "stringContent.pass");
}
// primitive_type.class tests ----------------------------------------------
public void testEmptyFileAfterTypingPrimitiveTypeAndDot() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean.", "classKeyword.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean.", "classKeyword.pass");
}
public void testAfterTypingPrimitiveTypeAndDot() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean.", "classKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean.", "classKeyword.pass");
}
public void testAfterPrimitiveTypeAndDot() throws Exception {
- performTest("AdvancedMethodBody", 979, null, "classKeyword.pass");
+ performTest("AdvancedMethodBody", 978, null, "classKeyword.pass");
}
public void testEmptyFileTypingPrimitiveTypeDotClass() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean.c", "classKeyword.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean.c", "classKeyword.pass");
}
public void testTypingPrimitiveTypeDotClass() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean.c", "classKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean.c", "classKeyword.pass");
}
public void testOnPrimitiveTypeDotClass() throws Exception {
- performTest("AdvancedMethodBody", 980, null, "classKeyword.pass");
+ performTest("AdvancedMethodBody", 979, null, "classKeyword.pass");
}
public void testEmptyFileAfterTypingPrimitiveTypeDotClass() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "boolean.class", "classKeyword.pass");
+ performTest("SimpleMethodBodyStart", 898, "boolean.class", "classKeyword.pass");
}
public void testAfterTypingPrimitiveTypeDotClass() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "boolean.class", "classKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 898, "boolean.class", "classKeyword.pass");
}
public void testAfterPrimitiveTypeDotClass() throws Exception {
- performTest("AdvancedMethodBody", 984, null, "classKeyword.pass");
+ performTest("AdvancedMethodBody", 983, null, "classKeyword.pass");
}
// Boolean.FALSE.booleanValue() like tests ---------------------------------
public void testEmptyFileTypingBooleanValue() throws Exception {
- performTest("SimpleMethodBodyStart", 899, "Boolean.FALSE.boolean", "booleanValue.pass");
+ performTest("SimpleMethodBodyStart", 898, "Boolean.FALSE.boolean", "booleanValue.pass");
}
public void testTypingBooleanValue() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, "Boolean.FALSE.boolean", "booleanValue.pass");
+ performTest("SimpleEmptyMethodBody", 898, "Boolean.FALSE.boolean", "booleanValue.pass");
}
public void testOnBooleanValue() throws Exception {
- performTest("AdvancedMethodBody", 1008, null, "booleanValue.pass");
+ performTest("AdvancedMethodBody", 1007, null, "booleanValue.pass");
}
// Expression in field init tests ------------------------------------------
public void testEmptyFileTypingParenWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = (", "typesLocalMembersAndSmartNumber.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = (", "typesLocalMembersAndSmartNumber.pass");
}
public void testTypingParenWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = (", "typesLocalMembersAndSmartNumber.pass");
+ performTest("FieldNoInit", 923, " = (", "typesLocalMembersAndSmartNumber.pass");
}
public void testAfterParenWithinInitOfField() throws Exception {
- performTest("Field", 951, null, "typesLocalMembersAndSmartNumber.pass");
+ performTest("Field", 950, null, "typesLocalMembersAndSmartNumber.pass");
}
public void testEmptyFileTypingSecondParenWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((", "typesLocalMembersAndSmartNumber.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((", "typesLocalMembersAndSmartNumber.pass");
}
public void testTypingSecondParenWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((", "typesLocalMembersAndSmartNumber.pass");
+ performTest("FieldNoInit", 923, " = ((", "typesLocalMembersAndSmartNumber.pass");
}
public void testAfterSecondParenWithinInitOfField() throws Exception {
- performTest("Field", 952, null, "typesLocalMembersAndSmartNumber.pass");
+ performTest("Field", 951, null, "typesLocalMembersAndSmartNumber.pass");
}
public void testEmptyFileTypingSecondParenAndSpaceWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = (( ", "typesLocalMembersAndSmartNumber.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = (( ", "typesLocalMembersAndSmartNumber.pass");
}
public void testTypingSecondParenAndSpaceWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = (( ", "typesLocalMembersAndSmartNumber.pass");
+ performTest("FieldNoInit", 923, " = (( ", "typesLocalMembersAndSmartNumber.pass");
}
public void testAfterSecondParenAndSpaceWithinInitOfField() throws Exception {
- performTest("Field", 952, " ", "typesLocalMembersAndSmartNumber.pass");
+ performTest("Field", 951, " ", "typesLocalMembersAndSmartNumber.pass");
}
public void testEmptyFileTypingCastTypeWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number ", "empty.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number ", "empty.pass");
}
public void testTypingCastTypeWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number ", "empty.pass");
+ performTest("FieldNoInit", 923, " = ((Number ", "empty.pass");
}
public void testOnCastTypeWithinInitOfField() throws Exception {
- performTest("Field", 958, " ", "empty.pass");
+ performTest("Field", 957, " ", "empty.pass");
}
public void testEmptyFileAfterTypingCastTypeWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)", "typesAndLocalMembers1.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)", "typesAndLocalMembers1.pass");
}
public void testAfterTypingCastTypeWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number)", "typesAndLocalMembers1.pass");
+ performTest("FieldNoInit", 923, " = ((Number)", "typesAndLocalMembers1.pass");
}
public void testAfterCastTypeWithinInitOfField() throws Exception {
- performTest("Field", 959, null, "typesAndLocalMembers1.pass");
+ performTest("Field", 958, null, "typesAndLocalMembers1.pass");
}
public void testEmptyFileTypingCastAndSpaceWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number) ", "typesAndLocalMembers1.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number) ", "typesAndLocalMembers1.pass");
}
public void testTypingCastAndSpaceWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number) ", "typesAndLocalMembers1.pass");
+ performTest("FieldNoInit", 923, " = ((Number) ", "typesAndLocalMembers1.pass");
}
public void testAfterCastAndSpaceWithinInitOfField() throws Exception {
- performTest("Field", 959, " ", "typesAndLocalMembers1.pass");
+ performTest("Field", 958, " ", "typesAndLocalMembers1.pass");
}
public void testEmptyFileTypingCastAndMethodWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)h", "hashCode.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)h", "hashCode.pass");
}
public void testTypingCastAndMethodWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number)h", "hashCode.pass");
+ performTest("FieldNoInit", 923, " = ((Number)h", "hashCode.pass");
}
public void testOnCastAndMethodWithinInitOfField() throws Exception {
- performTest("Field", 960, null, "hashCode.pass");
+ performTest("Field", 959, null, "hashCode.pass");
}
public void testEmptyFileAfterTypingCastAndMethodWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode())", "instanceOf.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode())", "instanceOf.pass");
}
public void testAfterTypingCastAndMethodWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number)hashCode())", "instanceOf.pass");
+ performTest("FieldNoInit", 923, " = ((Number)hashCode())", "instanceOf.pass");
}
public void testAfterCastAndMethodWithinInitOfField() throws Exception {
- performTest("Field", 970, null, "instanceOf.pass");
+ performTest("Field", 969, null, "instanceOf.pass");
}
public void testEmptyFileAfterTypingCastWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).", "numberContent.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).", "numberContent.pass");
}
public void testAfterTypingCastWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 924, " = ((Number)hashCode()).", "numberContent.pass");
+ performTest("FieldNoInit", 923, " = ((Number)hashCode()).", "numberContent.pass");
}
public void testAfterCastWithinInitOfField() throws Exception {
- performTest("Field", 971, null, "numberContent.pass");
+ performTest("Field", 970, null, "numberContent.pass");
}
public void testEmptyFileBeforeTypingInstanceofWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num ", "instanceOf.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num ", "instanceOf.pass");
}
public void testBeforeTypingInstanceofWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 946, " = num ", "instanceOf.pass");
+ performTest("FieldNoInit", 945, " = num ", "instanceOf.pass");
}
public void testBeforeInstanceofWithinInitOfField() throws Exception {
- performTest("Field", 1010, null, "instanceOf.pass");
+ performTest("Field", 1009, null, "instanceOf.pass");
}
public void testEmptyFileTypingInstanceofWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num i", "instanceOf.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num i", "instanceOf.pass");
}
public void testTypingInstanceofWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 946, " = num i", "instanceOf.pass");
+ performTest("FieldNoInit", 945, " = num i", "instanceOf.pass");
}
public void testInstanceofWithinInitOfField() throws Exception {
- performTest("Field", 1011, null, "instanceOf.pass");
+ performTest("Field", 1010, null, "instanceOf.pass");
}
public void testEmptyFileAfterTypingInstanceofWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num instanceof ", "declaredTypes.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num instanceof ", "declaredTypes.pass");
}
public void testAfterTypingInstanceofWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 946, " = num instanceof ", "declaredTypes.pass");
+ performTest("FieldNoInit", 945, " = num instanceof ", "declaredTypes.pass");
}
public void testAfterInstanceofWithinInitOfField() throws Exception {
- performTest("Field", 1021, null, "declaredTypes.pass");
+ performTest("Field", 1020, null, "declaredTypes.pass");
}
public void testEmptyFileTypingInstanceofTypeWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num instanceof I", "javaLangContentStartingWithI.pass");
+ performTest("MethodStart", 849, "public static int staticField;\npublic int field;\npublic Number num = ((Number)hashCode()).intValue();\npublic boolean b = num instanceof I", "javaLangContentStartingWithI.pass");
}
public void testTypingInstanceofTypeWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 946, " = num instanceof I", "javaLangContentStartingWithI.pass");
+ performTest("FieldNoInit", 945, " = num instanceof I", "javaLangContentStartingWithI.pass");
}
public void testOnInstanceofTypeWithinInitOfField() throws Exception {
- performTest("Field", 1022, null, "javaLangContentStartingWithI.pass");
+ performTest("Field", 1021, null, "javaLangContentStartingWithI.pass");
}
// For loop tests ----------------------------------------------------------
public void testEmptyFileAfterTypingForKeywordAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for ", "empty.pass");
}
public void testAfterTypingForKeywordAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for ", "empty.pass");
}
public void testAfterForKeywordAndSpace() throws Exception {
- performTest("For", 912, null, "empty.pass");
+ performTest("For", 911, null, "empty.pass");
}
public void testEmptyFileAfterTypingForKeywordAndParen() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (", "typesLocalFieldsAndVars.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (", "typesLocalFieldsAndVars.pass");
}
public void testAfterTypingForKeywordAndParen() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (", "typesLocalFieldsAndVars.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (", "typesLocalFieldsAndVars.pass");
}
public void testAfterForKeywordAndParen() throws Exception {
- performTest("For", 913, null, "typesLocalFieldsAndVars.pass");
+ performTest("For", 912, null, "typesLocalFieldsAndVars.pass");
}
public void testEmptyFileAfterTypingForVarTypeAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int ", "intVarName.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int ", "intVarName.pass");
}
public void testAfterTypingForVarTypeAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int ", "intVarName.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int ", "intVarName.pass");
}
public void testAfterForVarTypeAndSpace() throws Exception {
- performTest("For", 917, null, "intVarName.pass");
+ performTest("For", 916, null, "intVarName.pass");
}
public void testEmptyFileAfterTypingForVarAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i ", "empty.pass");
}
public void testAfterTypingForVarAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i ", "empty.pass");
}
public void testAfterForVarAndSpace() throws Exception {
- performTest("For", 919, null, "empty.pass");
+ performTest("For", 918, null, "empty.pass");
}
public void testEmptyFileBeforTypingForVarInit() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = ", "typesLocalMembersVarsAndSmartInt.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = ", "typesLocalMembersVarsAndSmartInt.pass");
}
public void testBeforTypingForVarInit() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = ", "typesLocalMembersVarsAndSmartInt.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = ", "typesLocalMembersVarsAndSmartInt.pass");
}
public void testBeforeForVarInit() throws Exception {
- performTest("For", 921, null, "typesLocalMembersVarsAndSmartInt.pass");
+ performTest("For", 920, null, "typesLocalMembersVarsAndSmartInt.pass");
}
public void testEmptyFileAfterTypingForVarInitAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0 ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0 ", "empty.pass");
}
public void testAfterTypingForVarInitAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0 ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0 ", "empty.pass");
}
public void testAfterForVarInitAndSpace() throws Exception {
- performTest("For", 922, " ", "empty.pass");
+ performTest("For", 921, " ", "empty.pass");
}
public void testEmptyFileBeforTypingForCondition() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0;", "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0;", "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testBeforTypingForCondition() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0;", "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0;", "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testBeforeForCondition() throws Exception {
- performTest("For", 923, null, "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("For", 922, null, "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testEmptyFileBeforTypingForConditionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; ", "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; ", "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testBeforTypingForConditionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; ", "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; ", "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testBeforeForConditionAndSpace() throws Exception {
- performTest("For", 924, null, "typesLocalMembersVarsAndSmartBoolean.pass");
+ performTest("For", 923, null, "typesLocalMembersVarsAndSmartBoolean.pass");
}
public void testEmptyFileAfterTypingForConditionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a ", "empty.pass");
}
public void testAfterTypingForConditionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a ", "empty.pass");
}
public void testAfterForConditionAndSpace() throws Exception {
- performTest("For", 929, " ", "empty.pass");
+ performTest("For", 928, " ", "empty.pass");
}
public void testEmptyFileBeforTypingForUpdateExpression() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a;", "typesLocalMembersAndVars2.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a;", "typesLocalMembersAndVars2.pass");
}
public void testBeforTypingForUpdateExpression() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a;", "typesLocalMembersAndVars2.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a;", "typesLocalMembersAndVars2.pass");
}
public void testBeforeForUpdateExpression() throws Exception {
- performTest("For", 930, null, "typesLocalMembersAndVars2.pass");
+ performTest("For", 929, null, "typesLocalMembersAndVars2.pass");
}
public void testEmptyFileBeforTypingForUpdateExpressionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a; ", "typesLocalMembersAndVars2.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a; ", "typesLocalMembersAndVars2.pass");
}
public void testBeforTypingForUpdateExpressionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a; ", "typesLocalMembersAndVars2.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a; ", "typesLocalMembersAndVars2.pass");
}
public void testBeforeForUpdateExpressionAndSpace() throws Exception {
- performTest("For", 931, null, "typesLocalMembersAndVars2.pass");
+ performTest("For", 930, null, "typesLocalMembersAndVars2.pass");
}
public void testEmptyFileAfterTypingForUpdateExpressionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a; i++ ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a; i++ ", "empty.pass");
}
public void testAfterTypingForUpdateExpressionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0 ; i < a; i++ ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0 ; i < a; i++ ", "empty.pass");
}
public void testAfterForUpdateExpressionAndSpace() throws Exception {
- performTest("For", 934, " ", "empty.pass");
+ performTest("For", 933, " ", "empty.pass");
}
public void testEmptyFileAfterTypingForUpdateExpressionAndParen() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a; i++)", "methodBodyContentAfterFor.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a; i++)", "methodBodyContentAfterFor.pass");
}
public void testAfterTypingForUpdateExpressionAndParen() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a; i++)", "methodBodyContentAfterFor.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a; i++)", "methodBodyContentAfterFor.pass");
}
public void testAfterForUpdateExpressionAndParen() throws Exception {
- performTest("For", 935, null, "methodBodyContentAfterFor.pass");
+ performTest("For", 934, null, "methodBodyContentAfterFor.pass");
}
public void testEmptyFileAfterTypingForUpdateExpressionParenAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a; i++) ", "methodBodyContentAfterFor.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a; i++) ", "methodBodyContentAfterFor.pass");
}
public void testAfterTypingForUpdateExpressionParenAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a; i++) ", "methodBodyContentAfterFor.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a; i++) ", "methodBodyContentAfterFor.pass");
}
public void testAfterForUpdateExpressionParenAndSpace() throws Exception {
- performTest("For", 936, null, "methodBodyContentAfterFor.pass");
+ performTest("For", 935, null, "methodBodyContentAfterFor.pass");
}
public void testEmptyFileInsideForBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (int i = 0; i < a; i++) {\n", "blockContentAfterFor.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (int i = 0; i < a; i++) {\n", "blockContentAfterFor.pass");
}
public void testTypingInsideForBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (int i = 0; i < a; i++) {\n", "blockContentAfterFor.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (int i = 0; i < a; i++) {\n", "blockContentAfterFor.pass");
}
public void testInsideForBody() throws Exception {
- performTest("For", 937, null, "blockContentAfterFor.pass");
+ performTest("For", 936, null, "blockContentAfterFor.pass");
}
// For-each loop tests -----------------------------------------------------
public void testEmptyFileBeforTypingForEachExpression() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b :", "typesLocalMembersAndVars1.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b :", "typesLocalMembersAndVars1.pass");
}
public void testBeforTypingForEachExpression() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b :", "typesLocalMembersAndVars1.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b :", "typesLocalMembersAndVars1.pass");
}
public void testBeforeForEachExpression() throws Exception {
- performTest("ForEach", 921, null, "typesLocalMembersAndVars1.pass");
+ performTest("ForEach", 920, null, "typesLocalMembersAndVars1.pass");
}
public void testEmptyFileBeforTypingForEachExpressionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b : ", "typesLocalMembersAndVars1.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b : ", "typesLocalMembersAndVars1.pass");
}
public void testBeforTypingForEachExpressionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b : ", "typesLocalMembersAndVars1.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b : ", "typesLocalMembersAndVars1.pass");
}
public void testBeforeForEachExpressionAndSpace() throws Exception {
- performTest("ForEach", 922, null, "typesLocalMembersAndVars1.pass");
+ performTest("ForEach", 921, null, "typesLocalMembersAndVars1.pass");
}
public void testEmptyFileAfterTypingForEachExpressionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b : field.getBytes() ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b : field.getBytes() ", "empty.pass");
}
public void testAfterTypingForEachExpressionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b : field.getBytes() ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b : field.getBytes() ", "empty.pass");
}
public void testAfterForEachExpressionAndSpace() throws Exception {
- performTest("ForEach", 938, " ", "empty.pass");
+ performTest("ForEach", 937, " ", "empty.pass");
}
public void testEmptyFileAfterTypingForEachExpressionAndParen() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b : field.getBytes())", "methodBodyContentAfterForEach.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b : field.getBytes())", "methodBodyContentAfterForEach.pass");
}
public void testAfterTypingForEachExpressionAndParen() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b : field.getBytes())", "methodBodyContentAfterForEach.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b : field.getBytes())", "methodBodyContentAfterForEach.pass");
}
public void testAfterForEachExpressionAndParen() throws Exception {
- performTest("ForEach", 939, null, "methodBodyContentAfterForEach.pass");
+ performTest("ForEach", 938, null, "methodBodyContentAfterForEach.pass");
}
public void testEmptyFileAfterTypingForEachExpressionParenAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b : field.getBytes()) ", "methodBodyContentAfterForEach.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b : field.getBytes()) ", "methodBodyContentAfterForEach.pass");
}
public void testAfterTypingForEachExpressionParenAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b : field.getBytes()) ", "methodBodyContentAfterForEach.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b : field.getBytes()) ", "methodBodyContentAfterForEach.pass");
}
public void testAfterForEachExpressionParenAndSpace() throws Exception {
- performTest("ForEach", 940, null, "methodBodyContentAfterForEach.pass");
+ performTest("ForEach", 939, null, "methodBodyContentAfterForEach.pass");
}
public void testEmptyFileInsideForEachBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "for (Byte b : field.getBytes()) {\n", "blockContentAfterForEach.pass");
+ performTest("SimpleMethodBodyStart", 907, "for (Byte b : field.getBytes()) {\n", "blockContentAfterForEach.pass");
}
public void testTypingInsideForEachBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "for (Byte b : field.getBytes()) {\n", "blockContentAfterForEach.pass");
+ performTest("SimpleEmptyMethodBody", 907, "for (Byte b : field.getBytes()) {\n", "blockContentAfterForEach.pass");
}
public void testInsideForEachBody() throws Exception {
- performTest("ForEach", 941, null, "blockContentAfterForEach.pass");
+ performTest("ForEach", 940, null, "blockContentAfterForEach.pass");
}
// Switch-case statement tests ---------------------------------------------
public void testEmptyFileAfterTypingSwitchKeyword() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch", "switchKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch", "switchKeyword.pass");
}
public void testAfterTypingSwitchKeyword() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch", "switchKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch", "switchKeyword.pass");
}
public void testAfterSwitchKeyword() throws Exception {
- performTest("Switch", 914, null, "switchKeyword.pass");
+ performTest("Switch", 913, null, "switchKeyword.pass");
}
public void testEmptyFileAfterTypingSwitchKeywordAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch ", "empty.pass");
}
public void testAfterTypingSwitchKeywordAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch ", "empty.pass");
}
public void testAfterSwitchKeywordAndSpace() throws Exception {
- performTest("Switch", 915, null, "empty.pass");
+ performTest("Switch", 914, null, "empty.pass");
}
public void testEmptyFileAfterTypingSwitchKeywordAndParen() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (", "typesLocalMembersVarsAndSmartEnumAndInt.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (", "typesLocalMembersVarsAndSmartEnumAndInt.pass");
}
public void testAfterTypingSwitchKeywordAndParen() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (", "typesLocalMembersVarsAndSmartEnumAndInt.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (", "typesLocalMembersVarsAndSmartEnumAndInt.pass");
}
public void testAfterSwitchKeywordAndParen() throws Exception {
- performTest("Switch", 916, null, "typesLocalMembersVarsAndSmartEnumAndInt.pass");
+ performTest("Switch", 915, null, "typesLocalMembersVarsAndSmartEnumAndInt.pass");
}
public void testEmptyFileAfterTypingSwitchExpression() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a", "a.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a", "a.pass");
}
public void testAfterTypingSwitchExpression() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a", "a.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a", "a.pass");
}
public void testAfterSwitchExpression() throws Exception {
- performTest("Switch", 917, null, "a.pass");
+ performTest("Switch", 916, null, "a.pass");
}
public void testEmptyFileAfterTypingSwitchExpressionAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a ", "empty.pass");
}
public void testAfterTypingSwitchExpressionAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a ", "empty.pass");
}
public void testAfterSwitchExpressionAndSpace() throws Exception {
- performTest("Switch", 917, " ", "empty.pass");
+ performTest("Switch", 916, " ", "empty.pass");
}
public void testEmptyFileAfterTypingSwitchExpressionAndParen() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) ", "empty.pass");
}
public void testAfterTypingSwitchExpressionAndParen() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) ", "empty.pass");
}
public void testAfterSwitchExpressionAndParen() throws Exception {
- performTest("Switch", 918, null, "empty.pass");
+ performTest("Switch", 917, null, "empty.pass");
}
public void testEmptyFileInsideSwitchBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\n", "caseAndDefaultKeywords.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\n", "caseAndDefaultKeywords.pass");
}
public void testTypingInsideSwitchBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\n", "caseAndDefaultKeywords.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\n", "caseAndDefaultKeywords.pass");
}
public void testInsideSwitchBody() throws Exception {
- performTest("Switch", 933, null, "caseAndDefaultKeywords.pass");
+ performTest("Switch", 932, null, "caseAndDefaultKeywords.pass");
}
public void testEmptyFileAfterTypingCaseKeyword() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase", "caseKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase", "caseKeyword.pass");
}
public void testAfterTypingCaseKeyword() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase", "caseKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase", "caseKeyword.pass");
}
public void testAfterCaseKeyword() throws Exception {
- performTest("Switch", 937, null, "caseKeyword.pass");
+ performTest("Switch", 936, null, "caseKeyword.pass");
}
public void testEmptyFileAfterTypingCaseKeywordAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase ", "declaredTypesAndSmartInt.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase ", "declaredTypesAndSmartInt.pass");
}
public void testAfterTypingCaseKeywordAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase ", "declaredTypesAndSmartInt.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase ", "declaredTypesAndSmartInt.pass");
}
public void testAfterCaseKeywordAndSpace() throws Exception {
- performTest("Switch", 937, " ", "declaredTypesAndSmartInt.pass");
+ performTest("Switch", 936, " ", "declaredTypesAndSmartInt.pass");
}
public void testEmptyFileAfterTypingCaseKeywordAndColon() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase 0:", "methodBodyContentAfterCase.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase 0:", "methodBodyContentAfterCase.pass");
}
public void testAfterTypingCaseKeywordAndColon() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase 0:", "methodBodyContentAfterCase.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase 0:", "methodBodyContentAfterCase.pass");
}
public void testAfterCaseKeywordAndColon() throws Exception {
- performTest("Switch", 940, null, "methodBodyContentAfterCase.pass");
+ performTest("Switch", 939, null, "methodBodyContentAfterCase.pass");
}
public void testEmptyFileAfterTypingCaseKeywordAndColonAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase 0: ", "methodBodyContentAfterCase.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase 0: ", "methodBodyContentAfterCase.pass");
}
public void testAfterTypingCaseKeywordAndColonAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase 0: ", "methodBodyContentAfterCase.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase 0: ", "methodBodyContentAfterCase.pass");
}
public void testAfterCaseKeywordAndColonAndSpace() throws Exception {
- performTest("Switch", 941, null, "methodBodyContentAfterCase.pass");
+ performTest("Switch", 940, null, "methodBodyContentAfterCase.pass");
}
public void testEmptyFileAfterTypingVarInCaseBlock() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase 0:\nboolean b;\n", "methodBodyContentAfterCaseAndVar.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase 0:\nboolean b;\n", "methodBodyContentAfterCaseAndVar.pass");
}
public void testAfterTypingVarInCaseBlock() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase 0:\nboolean b;\n", "methodBodyContentAfterCaseAndVar.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase 0:\nboolean b;\n", "methodBodyContentAfterCaseAndVar.pass");
}
public void testAfterVarInCaseBlock() throws Exception {
- performTest("Switch", 968, null, "methodBodyContentAfterCaseAndVar.pass");
+ performTest("Switch", 967, null, "methodBodyContentAfterCaseAndVar.pass");
}
public void testEmptyFileAfterTypingBreakKeyword() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ncase 0:\nbreak", "breakKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ncase 0:\nbreak", "breakKeyword.pass");
}
public void testAfterTypingBreakKeyword() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ncase 0:\nbreak", "breakKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ncase 0:\nbreak", "breakKeyword.pass");
}
public void testAfterBreakKeyword() throws Exception {
- performTest("Switch", 989, null, "breakKeyword.pass");
+ performTest("Switch", 988, null, "breakKeyword.pass");
}
public void testEmptyFileAfterTypingDefaultKeyword() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ndefault", "defaultKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ndefault", "defaultKeyword.pass");
}
public void testAfterTypingDefaultKeyword() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ndefault", "defaultKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ndefault", "defaultKeyword.pass");
}
public void testAfterDefaultKeyword() throws Exception {
- performTest("Switch", 1010, null, "defaultKeyword.pass");
+ performTest("Switch", 1009, null, "defaultKeyword.pass");
}
public void testEmptyFileAfterTypingDefaultKeywordAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ndefault ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ndefault ", "empty.pass");
}
public void testAfterTypingDefaultKeywordAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ndefault ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ndefault ", "empty.pass");
}
public void testAfterDefaultKeywordAndSpace() throws Exception {
- performTest("Switch", 1010, " ", "empty.pass");
+ performTest("Switch", 1009, " ", "empty.pass");
}
public void testEmptyFileAfterTypingDefaultKeywordAndColon() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ndefault:", "methodBodyContentAfterDefault.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ndefault:", "methodBodyContentAfterDefault.pass");
}
public void testAfterTypingDefaultKeywordAndColon() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ndefault:", "methodBodyContentAfterDefault.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ndefault:", "methodBodyContentAfterDefault.pass");
}
public void testAfterDefaultKeywordAndColon() throws Exception {
- performTest("Switch", 1011, null, "methodBodyContentAfterDefault.pass");
+ performTest("Switch", 1010, null, "methodBodyContentAfterDefault.pass");
}
public void testEmptyFileAfterTypingDefaultKeywordAndColonAndSpace() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "switch (a) {\ndefault: ", "methodBodyContentAfterDefault.pass");
+ performTest("SimpleMethodBodyStart", 907, "switch (a) {\ndefault: ", "methodBodyContentAfterDefault.pass");
}
public void testAfterTypingDefaultKeywordAndColonAndSpace() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "switch (a) {\ndefault: ", "methodBodyContentAfterDefault.pass");
+ performTest("SimpleEmptyMethodBody", 907, "switch (a) {\ndefault: ", "methodBodyContentAfterDefault.pass");
}
public void testAfterDefaultKeywordAndColonAndSpace() throws Exception {
- performTest("Switch", 1011, null, "methodBodyContentAfterDefault.pass");
+ performTest("Switch", 1010, null, "methodBodyContentAfterDefault.pass");
}
// Static initializer tests ------------------------------------------------
public void testEmptyFileAfterTypingStaticKeyword() throws Exception {
- performTest("InitializersStart", 1030, "static", "staticKeyword.pass");
+ performTest("InitializersStart", 1029, "static", "staticKeyword.pass");
}
public void testAfterTypingStaticKeyword() throws Exception {
- performTest("Field", 1030, "static", "staticKeyword.pass");
+ performTest("Field", 1029, "static", "staticKeyword.pass");
}
public void testAfterStaticKeyword() throws Exception {
- performTest("Initializers", 1045, null, "staticKeyword.pass");
+ performTest("Initializers", 1044, null, "staticKeyword.pass");
}
public void testEmptyFileAfterTypingStaticKeywordAndSpace() throws Exception {
- performTest("InitializersStart", 1030, "static ", "memberModifiersAndTypesWithoutStatic.pass");
+ performTest("InitializersStart", 1029, "static ", "memberModifiersAndTypesWithoutStatic.pass");
}
public void testAfterTypingStaticKeywordAndSpace() throws Exception {
- performTest("Field", 1030, "static ", "memberModifiersAndTypesWithoutStatic.pass");
+ performTest("Field", 1029, "static ", "memberModifiersAndTypesWithoutStatic.pass");
}
public void testAfterStaticKeywordAndSpace() throws Exception {
- performTest("Initializers", 1046, null, "memberModifiersAndTypesWithoutStatic.pass");
+ performTest("Initializers", 1045, null, "memberModifiersAndTypesWithoutStatic.pass");
}
public void testEmptyFileTypingStaticBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "static {", "staticBlockContent.pass");
+ performTest("InitializersStart", 1029, "static {", "staticBlockContent.pass");
}
public void testTypingStaticBlockBody() throws Exception {
- performTest("Field", 1030, "static {", "staticBlockContent.pass");
+ performTest("Field", 1029, "static {", "staticBlockContent.pass");
}
public void testInStaticBlockBody() throws Exception {
- performTest("Initializers", 1047, null, "staticBlockContent.pass");
+ performTest("Initializers", 1046, null, "staticBlockContent.pass");
}
public void testEmptyFileTypingVarTypeInStaticBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "static {\nin", "intKeyword.pass");
+ performTest("InitializersStart", 1029, "static {\nin", "intKeyword.pass");
}
public void testTypingVarTypeInStaticBlockBody() throws Exception {
- performTest("Field", 1030, "static {\nin", "intKeyword.pass");
+ performTest("Field", 1029, "static {\nin", "intKeyword.pass");
}
public void testOnVarTypeInStaticBlockBody() throws Exception {
- performTest("Initializers", 1058, null, "intKeyword.pass");
+ performTest("Initializers", 1057, null, "intKeyword.pass");
}
public void testEmptyFileBeforeTypingVarInitInStaticBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "static {\nint i = ", "staticBlockTypesAndLocalMembers.pass");
+ performTest("InitializersStart", 1029, "static {\nint i = ", "staticBlockTypesAndLocalMembers.pass");
}
public void testBeforeTypingVarInitInStaticBlockBody() throws Exception {
- performTest("Field", 1030, "static {\nint i = ", "staticBlockTypesAndLocalMembers.pass");
+ performTest("Field", 1029, "static {\nint i = ", "staticBlockTypesAndLocalMembers.pass");
}
public void testBeforeVarInitInStaticBlockBody() throws Exception {
- performTest("Initializers", 1064, null, "staticBlockTypesAndLocalMembers.pass");
+ performTest("Initializers", 1063, null, "staticBlockTypesAndLocalMembers.pass");
}
public void testEmptyFileTypingVarInitInStaticBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "static {\nint i = f", "falseAndFloatKeywords.pass");
+ performTest("InitializersStart", 1029, "static {\nint i = f", "falseAndFloatKeywords.pass");
}
public void testTypingVarInitInStaticBlockBody() throws Exception {
- performTest("Field", 1030, "static {\nint i = f", "falseAndFloatKeywords.pass");
+ performTest("Field", 1029, "static {\nint i = f", "falseAndFloatKeywords.pass");
}
public void testOnVarInitInStaticBlockBody() throws Exception {
- performTest("Initializers", 1065, null, "falseAndFloatKeywords.pass");
+ performTest("Initializers", 1064, null, "falseAndFloatKeywords.pass");
}
// Instance initializer tests ----------------------------------------------
public void testEmptyFileTypingInitializerBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "{", "initBlockContent.pass");
+ performTest("InitializersStart", 1029, "{", "initBlockContent.pass");
}
public void testTypingInitializerBlockBody() throws Exception {
- performTest("Field", 1030, "{", "initBlockContent.pass");
+ performTest("Field", 1029, "{", "initBlockContent.pass");
}
public void testInInitializerBlockBody() throws Exception {
- performTest("Initializers", 1087, null, "initBlockContent.pass");
+ performTest("Initializers", 1086, null, "initBlockContent.pass");
}
public void testEmptyFileTypingVarTypeInInitializerBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "{\nbo", "booleanKeyword.pass");
+ performTest("InitializersStart", 1029, "{\nbo", "booleanKeyword.pass");
}
public void testTypingVarTypeInInitializerBlockBody() throws Exception {
- performTest("Field", 1030, "{\nbo", "booleanKeyword.pass");
+ performTest("Field", 1029, "{\nbo", "booleanKeyword.pass");
}
public void testOnVarTypeInInitializerBlockBody() throws Exception {
- performTest("Initializers", 1098, null, "booleanKeyword.pass");
+ performTest("Initializers", 1097, null, "booleanKeyword.pass");
}
public void testEmptyFileBeforeTypingVarInitInInitializerBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "{\nboolean b1 = ", "initBlockTypesAndLocalMembers.pass");
+ performTest("InitializersStart", 1029, "{\nboolean b1 = ", "initBlockTypesAndLocalMembers.pass");
}
public void testBeforeTypingVarInitInInitializerBlockBody() throws Exception {
- performTest("Field", 1030, "{\nboolean b1 = ", "initBlockTypesAndLocalMembers.pass");
+ performTest("Field", 1029, "{\nboolean b1 = ", "initBlockTypesAndLocalMembers.pass");
}
public void testBeforeVarInitInInitializerBlockBody() throws Exception {
- performTest("Initializers", 1109, null, "initBlockTypesAndLocalMembers.pass");
+ performTest("Initializers", 1108, null, "initBlockTypesAndLocalMembers.pass");
}
public void testEmptyFileTypingVarInitInInitializerBlockBody() throws Exception {
- performTest("InitializersStart", 1030, "{\nboolean b1 = b", "initBlockContentStartingWithB.pass");
+ performTest("InitializersStart", 1029, "{\nboolean b1 = b", "initBlockContentStartingWithB.pass");
}
public void testTypingVarInitInInitializerBlockBody() throws Exception {
- performTest("Field", 1030, "{\nboolean b1 = b", "initBlockContentStartingWithB.pass");
+ performTest("Field", 1029, "{\nboolean b1 = b", "initBlockContentStartingWithB.pass");
}
public void testOnVarInitInInitializerBlockBody() throws Exception {
- performTest("Initializers", 1110, null, "initBlockContentStartingWithB.pass");
+ performTest("Initializers", 1109, null, "initBlockContentStartingWithB.pass");
}
}
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskBasicTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskBasicTest.java
index a79776650..24a3e7cb6 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskBasicTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskBasicTest.java
@@ -32,1270 +32,1270 @@ public JavaCompletionTaskBasicTest(String testName) {
// file beginning tests ----------------------------------------------------
public void testEmptyFile() throws Exception {
- performTest("Empty", 809, null, "topLevelKeywords.pass");
+ performTest("Empty", 808, null, "topLevelKeywords.pass");
}
public void testFileBeginning() throws Exception {
- performTest("Simple", 809, null, "topLevelKeywords.pass");
+ performTest("Simple", 808, null, "topLevelKeywords.pass");
}
// package declaration tests -----------------------------------------------
public void testEmptyFileTypingPackageKeyword() throws Exception {
- performTest("Empty", 809, "p", "topLevelKeywordsStartingWithP.pass");
+ performTest("Empty", 808, "p", "topLevelKeywordsStartingWithP.pass");
}
public void testTypingPackageKeyword() throws Exception {
- performTest("SimpleNoPackage", 809, "p", "topLevelKeywordsStartingWithP.pass");
+ performTest("SimpleNoPackage", 808, "p", "topLevelKeywordsStartingWithP.pass");
}
public void testOnPackageKeyword() throws Exception {
- performTest("Simple", 811, null, "topLevelKeywordsStartingWithP.pass");
+ performTest("Simple", 810, null, "topLevelKeywordsStartingWithP.pass");
}
public void testEmptyFileAfterTypingPackageKeyword() throws Exception {
- performTest("Empty", 809, "package", "packageKeyword.pass");
+ performTest("Empty", 808, "package", "packageKeyword.pass");
}
public void testAfterTypingPackageKeyword() throws Exception {
- performTest("SimpleNoPackage", 809, "package", "packageKeyword.pass");
+ performTest("SimpleNoPackage", 808, "package", "packageKeyword.pass");
}
public void testAfterPackageKeyword() throws Exception {
- performTest("Simple", 817, null, "packageKeyword.pass");
+ performTest("Simple", 816, null, "packageKeyword.pass");
}
public void testEmptyFileBeforeTypingPackageId() throws Exception {
- performTest("Empty", 809, "package ", "empty.pass");
+ performTest("Empty", 808, "package ", "empty.pass");
}
public void testBeforeTypingPackageId() throws Exception {
- performTest("SimpleNoPackage", 809, "package ", "empty.pass");
+ performTest("SimpleNoPackage", 808, "package ", "empty.pass");
}
public void testBeforePackageId() throws Exception {
- performTest("Simple", 818, null, "empty.pass");
+ performTest("Simple", 817, null, "empty.pass");
}
public void testEmptyFileTypingPackageId() throws Exception {
- performTest("Empty", 809, "package t", "empty.pass");
+ performTest("Empty", 808, "package t", "empty.pass");
}
public void testTypingPackageId() throws Exception {
- performTest("SimpleNoPackage", 809, "package t", "empty.pass");
+ performTest("SimpleNoPackage", 808, "package t", "empty.pass");
}
public void testOnPackageId() throws Exception {
- performTest("Simple", 819, null, "empty.pass");
+ performTest("Simple", 818, null, "empty.pass");
}
public void testEmptyFileAfterTypingPackageId() throws Exception {
- performTest("Empty", 809, "package test", "empty.pass");
+ performTest("Empty", 808, "package test", "empty.pass");
}
public void testAfterTypingPackageId() throws Exception {
- performTest("SimpleNoPackage", 809, "package test", "empty.pass");
+ performTest("SimpleNoPackage", 808, "package test", "empty.pass");
}
public void testAfterPackageId() throws Exception {
- performTest("Simple", 822, null, "empty.pass");
+ performTest("Simple", 821, null, "empty.pass");
}
public void testEmptyFileAfterTypingPackageIdAndSpace() throws Exception {
- performTest("Empty", 809, "package test ", "empty.pass");
+ performTest("Empty", 808, "package test ", "empty.pass");
}
public void testAfterTypingPackageIdAndSpace() throws Exception {
- performTest("SimpleNoPackage", 809, "package test ", "empty.pass");
+ performTest("SimpleNoPackage", 808, "package test ", "empty.pass");
}
public void testAfterPackageIdAndSpace() throws Exception {
- performTest("Simple", 822, " ", "empty.pass");
+ performTest("Simple", 821, " ", "empty.pass");
}
public void testEmptyFileAfterTypingPackageDecl() throws Exception {
- performTest("Empty", 809, "package test;", "topLevelKeywordsWithoutPackage.pass");
+ performTest("Empty", 808, "package test;", "topLevelKeywordsWithoutPackage.pass");
}
public void testAfterTypingPackageDecl() throws Exception {
- performTest("SimpleNoPackage", 809, "package test;", "topLevelKeywordsWithoutPackage.pass");
+ performTest("SimpleNoPackage", 808, "package test;", "topLevelKeywordsWithoutPackage.pass");
}
public void testAfterPackageDecl() throws Exception {
- performTest("Simple", 823, null, "topLevelKeywordsWithoutPackage.pass");
+ performTest("Simple", 822, null, "topLevelKeywordsWithoutPackage.pass");
}
// import declaration tests ------------------------------------------------
public void testEmptyFileAfterTypingImportKeyword() throws Exception {
- performTest("Empty", 809, "import", "importKeyword.pass");
+ performTest("Empty", 808, "import", "importKeyword.pass");
}
public void testAfterTypingImportKeyword() throws Exception {
- performTest("Simple", 824, "import", "importKeyword.pass");
+ performTest("Simple", 823, "import", "importKeyword.pass");
}
public void testAfterImportKeyword() throws Exception {
- performTest("Import", 831, null, "importKeyword.pass");
+ performTest("Import", 830, null, "importKeyword.pass");
}
public void testEmptyFileBeforeTypingImportedPackage() throws Exception {
- performTest("Empty", 809, "import ", "staticKeywordAndAllPackages.pass");
+ performTest("Empty", 808, "import ", "staticKeywordAndAllPackages.pass");
}
public void testBeforeTypingImportedPackage() throws Exception {
- performTest("Simple", 824, "import ", "staticKeywordAndAllPackages.pass");
+ performTest("Simple", 823, "import ", "staticKeywordAndAllPackages.pass");
}
public void testBeforeImportedPackage() throws Exception {
- performTest("Import", 832, null, "staticKeywordAndAllPackages.pass");
+ performTest("Import", 831, null, "staticKeywordAndAllPackages.pass");
}
public void testEmptyFileTypingImportedPackage() throws Exception {
- performTest("Empty", 809, "import j", "packagesStartingWithJ.pass");
+ performTest("Empty", 808, "import j", "packagesStartingWithJ.pass");
}
public void testTypingImportedPackage() throws Exception {
- performTest("Simple", 824, "import j", "packagesStartingWithJ.pass");
+ performTest("Simple", 823, "import j", "packagesStartingWithJ.pass");
}
public void testOnImportedPackage() throws Exception {
- performTest("Import", 833, null, "packagesStartingWithJ.pass");
+ performTest("Import", 832, null, "packagesStartingWithJ.pass");
}
public void testEmptyFileTypingImportedPackageBeforeStar() throws Exception {
- performTest("Empty", 809, "import java.util.", "javaUtilContent.pass");
+ performTest("Empty", 808, "import java.util.", "javaUtilContent.pass");
}
public void testTypingImportedPackageBeforeStar() throws Exception {
- performTest("Simple", 824, "import java.util.", "javaUtilContent.pass");
+ performTest("Simple", 823, "import java.util.", "javaUtilContent.pass");
}
public void testOnImportedPackageBeforeStar() throws Exception {
- performTest("Import", 864, null, "javaUtilContent.pass");
+ performTest("Import", 863, null, "javaUtilContent.pass");
}
public void testEmptyFileAfterTypingImportedPackage() throws Exception {
- performTest("Empty", 809, "import java.util.*", "empty.pass");
+ performTest("Empty", 808, "import java.util.*", "empty.pass");
}
public void testAfterTypingImportedPackage() throws Exception {
- performTest("Simple", 824, "import java.util.*", "empty.pass");
+ performTest("Simple", 823, "import java.util.*", "empty.pass");
}
public void testAfterImportedPackage() throws Exception {
- performTest("Import", 865, null, "empty.pass");
+ performTest("Import", 864, null, "empty.pass");
}
public void testEmptyFileAfterTypingImportedClass() throws Exception {
- performTest("Empty", 809, "import java.awt.List", "list.pass");
+ performTest("Empty", 808, "import java.awt.List", "list.pass");
}
public void testAfterTypingImportedClass() throws Exception {
- performTest("Simple", 824, "import java.awt.List", "list.pass");
+ performTest("Simple", 823, "import java.awt.List", "list.pass");
}
public void testAfterImportedClass() throws Exception {
- performTest("Import", 845, null, "list.pass");
+ performTest("Import", 844, null, "list.pass");
}
public void testEmptyFileAfterTypingImportedClassAndSpace() throws Exception {
- performTest("Empty", 809, "import java.awt.List ", "empty.pass");
+ performTest("Empty", 808, "import java.awt.List ", "empty.pass");
}
public void testAfterTypingImportedClassAndSpace() throws Exception {
- performTest("Simple", 824, "import java.awt.List ", "empty.pass");
+ performTest("Simple", 823, "import java.awt.List ", "empty.pass");
}
public void testAfterImportedClassAndSpace() throws Exception {
- performTest("Import", 845, " ", "empty.pass");
+ performTest("Import", 844, " ", "empty.pass");
}
public void testEmptyFileAfterTypingImportStatement() throws Exception {
- performTest("Empty", 809, "import java.awt.List;", "topLevelKeywordsWithoutPackage.pass");
+ performTest("Empty", 808, "import java.awt.List;", "topLevelKeywordsWithoutPackage.pass");
}
public void testAfterTypingImportStatement() throws Exception {
- performTest("Simple", 824, "import java.awt.List;", "topLevelKeywordsWithoutPackage.pass");
+ performTest("Simple", 823, "import java.awt.List;", "topLevelKeywordsWithoutPackage.pass");
}
public void testAfterImportStatement() throws Exception {
- performTest("Import", 846, null, "topLevelKeywordsWithoutPackage.pass");
+ performTest("Import", 845, null, "topLevelKeywordsWithoutPackage.pass");
}
public void testEmptyFileTypingStaticImportKeyword() throws Exception {
- performTest("Empty", 809, "import st", "staticKeyword.pass");
+ performTest("Empty", 808, "import st", "staticKeyword.pass");
}
public void testTypingStaticImportKeyword() throws Exception {
- performTest("Simple", 824, "import st", "staticKeyword.pass");
+ performTest("Simple", 823, "import st", "staticKeyword.pass");
}
public void testOnStaticImportKeyword() throws Exception {
- performTest("Import", 876, null, "staticKeyword.pass");
+ performTest("Import", 875, null, "staticKeyword.pass");
}
public void testEmptyFileAfterTypingStaticImportKeyword() throws Exception {
- performTest("Empty", 809, "import static", "staticKeyword.pass");
+ performTest("Empty", 808, "import static", "staticKeyword.pass");
}
public void testAfterTypingStaticImportKeyword() throws Exception {
- performTest("Simple", 824, "import static", "staticKeyword.pass");
+ performTest("Simple", 823, "import static", "staticKeyword.pass");
}
public void testAfterStaticImportKeyword() throws Exception {
- performTest("Import", 880, null, "staticKeyword.pass");
+ performTest("Import", 879, null, "staticKeyword.pass");
}
public void testEmptyFileBeforeTypingStaticallyImportedClass() throws Exception {
- performTest("Empty", 809, "import static ", "allPackages.pass");
+ performTest("Empty", 808, "import static ", "allPackages.pass");
}
public void testBeforeTypingStaticallyImportedClass() throws Exception {
- performTest("Simple", 824, "import static ", "allPackages.pass");
+ performTest("Simple", 823, "import static ", "allPackages.pass");
}
public void testBeforeStaticallyImportedClass() throws Exception {
- performTest("Import", 881, null, "allPackages.pass");
+ performTest("Import", 880, null, "allPackages.pass");
}
public void testEmptyFileTypingImportedPackageAfterErrorInPackageDeclaration() throws Exception {
- performTest("Empty", 809, "package \nimport j", "packagesStartingWithJ.pass");
+ performTest("Empty", 808, "package \nimport j", "packagesStartingWithJ.pass");
}
public void testTypingStaticImportAfterErrorInPackageDeclaration() throws Exception {
- performTest("SimpleNoPackage", 809, "package \nimport ", "staticKeywordAndAllPackages.pass");
+ performTest("SimpleNoPackage", 808, "package \nimport ", "staticKeywordAndAllPackages.pass");
}
public void testTypingStaticImportAfterErrorInPreviousImportDeclaration() throws Exception {
- performTest("Simple", 824, "im\nimport ", "staticKeywordAndAllPackages.pass");
+ performTest("Simple", 823, "im\nimport ", "staticKeywordAndAllPackages.pass");
}
// class declaration tests -------------------------------------------------
public void testEmptyFileAfterTypingPublicKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic", "publicKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic", "publicKeyword.pass");
}
public void testAfterPublicKeyword() throws Exception {
- performTest("Simple", 831, null, "publicKeyword.pass");
+ performTest("Simple", 830, null, "publicKeyword.pass");
}
public void testTypingFinalClass() throws Exception {
- performTest("Simple", 831, " f", "finalKeyword.pass");
+ performTest("Simple", 830, " f", "finalKeyword.pass");
}
public void testAfterTypingFinalClass() throws Exception {
- performTest("Simple", 831, " final", "finalKeyword.pass");
+ performTest("Simple", 830, " final", "finalKeyword.pass");
}
public void testEmptyFileBeforeTypingClassKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic ", "classModifiersWithoutPublic.pass");
+ performTest("Empty", 808, "package test;\npublic ", "classModifiersWithoutPublic.pass");
}
public void testBeforeClassKeyword() throws Exception {
- performTest("Simple", 832, null, "classModifiersWithoutPublic.pass");
+ performTest("Simple", 831, null, "classModifiersWithoutPublic.pass");
}
public void testEmptyFileTypingClassKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic c", "classKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic c", "classKeyword.pass");
}
public void testOnClassKeyword() throws Exception {
- performTest("Simple", 833, null, "classKeyword.pass");
+ performTest("Simple", 832, null, "classKeyword.pass");
}
public void testEmptyFileAfterTypingClassKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class", "classKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class", "classKeyword.pass");
}
public void testAfterClassKeyword() throws Exception {
- performTest("Simple", 837, null, "classKeyword.pass");
+ performTest("Simple", 836, null, "classKeyword.pass");
}
public void testEmptyFileBeforeTypingClassName() throws Exception {
- performTest("Empty", 809, "package test;\npublic class ", "empty.pass");
+ performTest("Empty", 808, "package test;\npublic class ", "empty.pass");
}
public void testBeforeClassName() throws Exception {
- performTest("Simple", 838, null, "empty.pass");
+ performTest("Simple", 837, null, "empty.pass");
}
public void testEmptyFileTypingClassName() throws Exception {
- performTest("Empty", 809, "package test;\npublic class T", "empty.pass");
+ performTest("Empty", 808, "package test;\npublic class T", "empty.pass");
}
public void testOnClassName() throws Exception {
- performTest("Simple", 839, null, "empty.pass");
+ performTest("Simple", 838, null, "empty.pass");
}
public void testEmptyAfterFileTypingClassName() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test", "empty.pass");
+ performTest("Empty", 808, "package test;\npublic class Test", "empty.pass");
}
public void testAfterClassName() throws Exception {
- performTest("Simple", 842, null, "empty.pass");
+ performTest("Simple", 841, null, "empty.pass");
}
public void testEmptyFileBeforeTypingExtendsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test ", "extendsAndImplementsKeywords.pass");
+ performTest("Empty", 808, "package test;\npublic class Test ", "extendsAndImplementsKeywords.pass");
}
public void testBeforeTypingExtendsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, null, "extendsAndImplementsKeywords.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, null, "extendsAndImplementsKeywords.pass");
}
public void testBeforeExtendsKeyword() throws Exception {
- performTest("Simple", 843, null, "extendsAndImplementsKeywords.pass");
+ performTest("Simple", 842, null, "extendsAndImplementsKeywords.pass");
}
public void testEmptyFileTypingExtendsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test e", "extendsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test e", "extendsKeyword.pass");
}
public void testTypingExtendsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "e", "extendsKeyword.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "e", "extendsKeyword.pass");
}
public void testOnExtendsKeyword() throws Exception {
- performTest("Simple", 844, null, "extendsKeyword.pass");
+ performTest("Simple", 843, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends", "extendsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends", "extendsKeyword.pass");
}
public void testAfterTypingExtendsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "extends", "extendsKeyword.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "extends", "extendsKeyword.pass");
}
public void testAfterExtendsKeyword() throws Exception {
- performTest("Simple", 850, null, "extendsKeyword.pass");
+ performTest("Simple", 849, null, "extendsKeyword.pass");
}
public void testEmptyFileBeforeTypingExtendedObject() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends ", "javaLangClasses.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends ", "javaLangClasses.pass");
}
public void testBeforeTypingExtendedObject() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "extends ", "javaLangClasses.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "extends ", "javaLangClasses.pass");
}
public void testBeforeExtendedObject() throws Exception {
- performTest("Simple", 851, null, "javaLangClasses.pass");
+ performTest("Simple", 850, null, "javaLangClasses.pass");
}
public void testEmptyFileTypingExtendedObject() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends O", "javaLangClassesStartingWithO.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends O", "javaLangClassesStartingWithO.pass");
}
public void testTypingExtendedObject() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "extends O", "javaLangClassesStartingWithO.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "extends O", "javaLangClassesStartingWithO.pass");
}
public void testOnExtendedObject() throws Exception {
- performTest("Simple", 852, null, "javaLangClassesStartingWithO.pass");
+ performTest("Simple", 851, null, "javaLangClassesStartingWithO.pass");
}
public void testEmptyFileAfterTypingExtendedObject() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object", "object.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object", "object.pass");
}
public void testAfterTypingExtendedObject() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "extends Object", "object.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "extends Object", "object.pass");
}
public void testAfterExtendedObject() throws Exception {
- performTest("Simple", 857, null, "object.pass");
+ performTest("Simple", 856, null, "object.pass");
}
public void testEmptyFileBeforeTypingImplementsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object ", "implementsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object ", "implementsKeyword.pass");
}
public void testBeforeTypingImplementsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "extends Object ", "implementsKeyword.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "extends Object ", "implementsKeyword.pass");
}
public void testBeforeImplementsKeyword() throws Exception {
- performTest("Simple", 858, null, "implementsKeyword.pass");
+ performTest("Simple", 857, null, "implementsKeyword.pass");
}
public void testEmptyFileTypingImplementsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object i", "implementsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object i", "implementsKeyword.pass");
}
public void testTypingImplementsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "i", "implementsKeyword.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "i", "implementsKeyword.pass");
}
public void testOnImplementsKeyword() throws Exception {
- performTest("Simple", 859, null, "implementsKeyword.pass");
+ performTest("Simple", 858, null, "implementsKeyword.pass");
}
public void testEmptyFileAfteTypingImplementsKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements", "implementsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements", "implementsKeyword.pass");
}
public void testAfterTypingImplementsKeyword() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements", "implementsKeyword.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements", "implementsKeyword.pass");
}
public void testAfterImplementsKeyword() throws Exception {
- performTest("Simple", 868, null, "implementsKeyword.pass");
+ performTest("Simple", 867, null, "implementsKeyword.pass");
}
public void testEmptyFileBeforeTypingImplementedInterface() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements ", "javaLangInterfaces.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements ", "javaLangInterfaces.pass");
}
public void testBeforeTypingImplementedInterface() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements ", "javaLangInterfaces.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements ", "javaLangInterfaces.pass");
}
public void testBeforeImplementedInterface() throws Exception {
- performTest("Simple", 869, null, "javaLangInterfaces.pass");
+ performTest("Simple", 868, null, "javaLangInterfaces.pass");
}
public void testEmptyFileAfterTypingImplementedInterface() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements Cloneable", "cloneable.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements Cloneable", "cloneable.pass");
}
public void testAfterTypingImplementedInterface() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements Cloneable", "cloneable.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements Cloneable", "cloneable.pass");
}
public void testAfterImplementedInterface() throws Exception {
- performTest("Simple", 878, null, "cloneable.pass");
+ performTest("Simple", 877, null, "cloneable.pass");
}
public void testEmptyFileAfterTypingImplementedInterfaceAndSpace() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements Cloneable ", "empty.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements Cloneable ", "empty.pass");
}
public void testAfterTypingImplementedInterfaceAndSpace() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements Cloneable ", "empty.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements Cloneable ", "empty.pass");
}
public void testAfterImplementedInterfaceAndSpace() throws Exception {
- performTest("Simple", 878, " ", "empty.pass");
+ performTest("Simple", 877, " ", "empty.pass");
}
public void testEmptyFileAfterTypingFirstImplementedInterface() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements Cloneable, ", "javaLangInterfaces.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements Cloneable, ", "javaLangInterfaces.pass");
}
public void testAfterTypingFirstImplementedInterface() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements Cloneable, ", "javaLangInterfaces.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements Cloneable, ", "javaLangInterfaces.pass");
}
public void testAfterFirstImplementedInterface() throws Exception {
- performTest("Simple", 880, null, "javaLangInterfaces.pass");
+ performTest("Simple", 879, null, "javaLangInterfaces.pass");
}
public void testEmptyFileTypingSecondImplementedInterface() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test extends Object implements Cloneable, R", "javaLangInterfacesStartingWithR.pass");
+ performTest("Empty", 808, "package test;\npublic class Test extends Object implements Cloneable, R", "javaLangInterfacesStartingWithR.pass");
}
public void testTypingSecondImplementedInterface() throws Exception {
- performTest("SimpleNoExtendsAndImplements", 843, "implements Cloneable, R", "javaLangInterfacesStartingWithR.pass");
+ performTest("SimpleNoExtendsAndImplements", 842, "implements Cloneable, R", "javaLangInterfacesStartingWithR.pass");
}
public void testOnSecondImplementedInterface() throws Exception {
- performTest("Simple", 881, null, "javaLangInterfacesStartingWithR.pass");
+ performTest("Simple", 880, null, "javaLangInterfacesStartingWithR.pass");
}
public void testEmptyFileTypingClassBody() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test {", "memberModifiersTypesAndGenElements.pass");
+ performTest("Empty", 808, "package test;\npublic class Test {", "memberModifiersTypesAndGenElements.pass");
}
public void testInClassBody() throws Exception {
- performTest("Simple", 890, null, "memberModifiersTypesAndGenElements2.pass");
+ performTest("Simple", 889, null, "memberModifiersTypesAndGenElements2.pass");
}
public void testEmptyFileAfterTypingClassBody() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test {\n}", "classModifiersWithoutPublic.pass");
+ performTest("Empty", 808, "package test;\npublic class Test {\n}", "classModifiersWithoutPublic.pass");
}
public void testAfterClassBody() throws Exception {
- performTest("Simple", 892, null, "classModifiersWithoutPublic.pass");
+ performTest("Simple", 891, null, "classModifiersWithoutPublic.pass");
}
public void testEmptyFileAfterTypingIncompleteClassBodyAndSecondClassKeyword() throws Exception {
- performTest("Empty", 809, "package test;\npublic class Test {\nclass", "classKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic class Test {\nclass", "classKeyword.pass");
}
// interface declaration tests ---------------------------------------------
public void testEmptyFileAfterTypingIntefaceName() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test ", "extendsKeyword.pass");
+ performTest("Empty", 808, "package test;\ninterface Test ", "extendsKeyword.pass");
}
public void testAfterTypingIntefaceName() throws Exception {
- performTest("SimpleInterfaceNoExtends", 840, null, "extendsKeyword.pass");
+ performTest("SimpleInterfaceNoExtends", 839, null, "extendsKeyword.pass");
}
public void testAfterIntefaceName() throws Exception {
- performTest("SimpleInterface", 840, null, "extendsKeyword.pass");
+ performTest("SimpleInterface", 839, null, "extendsKeyword.pass");
}
public void testEmptyFileAfterTypingExtendsInInteface() throws Exception {
- performTest("Empty", 809, "package test;\ninterface Test extends ", "javaLangInterfaces.pass");
+ performTest("Empty", 808, "package test;\ninterface Test extends ", "javaLangInterfaces.pass");
}
public void testAfterTypingExtendsInInterface() throws Exception {
- performTest("SimpleInterfaceNoExtends", 840, "extends ", "javaLangInterfaces.pass");
+ performTest("SimpleInterfaceNoExtends", 839, "extends ", "javaLangInterfaces.pass");
}
public void testAfterExtendsInInteface() throws Exception {
- performTest("SimpleInterface", 848, null, "javaLangInterfaces.pass");
+ performTest("SimpleInterface", 847, null, "javaLangInterfaces.pass");
}
// enum declaration tests --------------------------------------------------
public void testEmptyFileAfterTypingEnumName() throws Exception {
- performTest("Empty", 809, "package test;\npublic enum Test ", "implementsKeyword.pass");
+ performTest("Empty", 808, "package test;\npublic enum Test ", "implementsKeyword.pass");
}
public void testAfterTypingEnumName() throws Exception {
- performTest("SimpleEnumNoImplements", 842, null, "implementsKeyword.pass");
+ performTest("SimpleEnumNoImplements", 841, null, "implementsKeyword.pass");
}
public void testAfterEnumName() throws Exception {
- performTest("SimpleEnum", 842, null, "implementsKeyword.pass");
+ performTest("SimpleEnum", 841, null, "implementsKeyword.pass");
}
public void testEmptyFileAfterTypingImplementsInEnum() throws Exception {
- performTest("Empty", 809, "package test;\npublic enum Test implements ", "javaLangInterfaces.pass");
+ performTest("Empty", 808, "package test;\npublic enum Test implements ", "javaLangInterfaces.pass");
}
public void testAfterTypingImplementsInEnum() throws Exception {
- performTest("SimpleEnumNoImplements", 853, null, "javaLangInterfaces.pass");
+ performTest("SimpleEnumNoImplements", 852, null, "javaLangInterfaces.pass");
}
public void testAfterImplementsInEnum() throws Exception {
- performTest("SimpleEnum", 853, null, "javaLangInterfaces.pass");
+ performTest("SimpleEnum", 852, null, "javaLangInterfaces.pass");
}
// method declaration tests -------------------------------------------------
public void testEmptyFileTypingPublicKeywordInMethodDecl() throws Exception {
- performTest("MethodStart", 850, "p", "memberModifiersStartingWithP.pass");
+ performTest("MethodStart", 849, "p", "memberModifiersStartingWithP.pass");
}
public void testOnPublicKeywordInMethodDecl() throws Exception {
- performTest("Method", 851, null, "memberModifiersStartingWithP.pass");
+ performTest("Method", 850, null, "memberModifiersStartingWithP.pass");
}
public void testEmptyFileAfterTypingPublicKeywordInMethodDecl() throws Exception {
- performTest("MethodStart", 850, "public", "publicKeyword.pass");
+ performTest("MethodStart", 849, "public", "publicKeyword.pass");
}
public void testAfterPublicKeywordInMethodDecl() throws Exception {
- performTest("Method", 856, null, "publicKeyword.pass");
+ performTest("Method", 855, null, "publicKeyword.pass");
}
public void testTypingStaticMethodDecl() throws Exception {
- performTest("Method", 856, " sta", "staticKeyword.pass");
+ performTest("Method", 855, " sta", "staticKeyword.pass");
}
public void testAfterTypingStaticMethodDecl() throws Exception {
- performTest("Method", 856, " static", "staticKeyword.pass");
+ performTest("Method", 855, " static", "staticKeyword.pass");
}
public void testEmptyFileBeforeTypingReturnValue() throws Exception {
- performTest("MethodStart", 850, "public ", "memberModifiersAndTypesWithoutPublic.pass");
+ performTest("MethodStart", 849, "public ", "memberModifiersAndTypesWithoutPublic.pass");
}
public void testBeforeReturnValue() throws Exception {
- performTest("Method", 857, null, "memberModifiersAndTypesWithoutPublic.pass");
+ performTest("Method", 856, null, "memberModifiersAndTypesWithoutPublic.pass");
}
public void testEmptyFileTypingReturnValue() throws Exception {
- performTest("MethodStart", 850, "public voi", "voidKeyword.pass");
+ performTest("MethodStart", 849, "public voi", "voidKeyword.pass");
}
public void testOnReturnValue() throws Exception {
- performTest("Method", 860, null, "voidKeyword.pass");
+ performTest("Method", 859, null, "voidKeyword.pass");
}
public void testEmptyFileAfterTypingReturnValue() throws Exception {
- performTest("MethodStart", 850, "public void", "voidKeyword.pass");
+ performTest("MethodStart", 849, "public void", "voidKeyword.pass");
}
public void testAfterReturnValue() throws Exception {
- performTest("Method", 861, null, "voidKeyword.pass");
+ performTest("Method", 860, null, "voidKeyword.pass");
}
public void testEmptyFileBeforeTypingMethodName() throws Exception {
- performTest("MethodStart", 850, "public void ", "empty.pass");
+ performTest("MethodStart", 849, "public void ", "empty.pass");
}
public void testBeforeMethodName() throws Exception {
- performTest("Method", 862, null, "empty.pass");
+ performTest("Method", 861, null, "empty.pass");
}
public void testEmptyFileTypingMethodName() throws Exception {
- performTest("MethodStart", 850, "public void o", "empty.pass");
+ performTest("MethodStart", 849, "public void o", "empty.pass");
}
public void testOnMethodName() throws Exception {
- performTest("Method", 863, null, "empty.pass");
+ performTest("Method", 862, null, "empty.pass");
}
public void testEmptyFileAfterTypingMethodName() throws Exception {
- performTest("MethodStart", 850, "public void op", "empty.pass");
+ performTest("MethodStart", 849, "public void op", "empty.pass");
}
public void testAfterMethodName() throws Exception {
- performTest("Method", 864, null, "empty.pass");
+ performTest("Method", 863, null, "empty.pass");
}
public void testEmptyFileBeforeTypingFirstParameter() throws Exception {
- performTest("MethodStart", 850, "public void op(", "parameterTypes.pass");
+ performTest("MethodStart", 849, "public void op(", "parameterTypes.pass");
}
public void testBeforeTypingFirstParameter() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, null, "parameterTypes.pass");
+ performTest("MethodNoParamsAndThrows", 864, null, "parameterTypes.pass");
}
public void testBeforeFirstParameter() throws Exception {
- performTest("Method", 865, null, "parameterTypes.pass");
+ performTest("Method", 864, null, "parameterTypes.pass");
}
public void testEmptyFileTypingFirstParameterType() throws Exception {
- performTest("MethodStart", 850, "public void op(i", "intKeyword.pass");
+ performTest("MethodStart", 849, "public void op(i", "intKeyword.pass");
}
public void testTypingFirstParameterType() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "i", "intKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 864, "i", "intKeyword.pass");
}
public void testOnFirstParameterType() throws Exception {
- performTest("Method", 866, null, "intKeyword.pass");
+ performTest("Method", 865, null, "intKeyword.pass");
}
public void testEmptyFileAfterTypingFirstParameterType() throws Exception {
- performTest("MethodStart", 850, "public void op(int", "intKeyword.pass");
+ performTest("MethodStart", 849, "public void op(int", "intKeyword.pass");
}
public void testAfterTypingFirstParameterType() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int", "intKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int", "intKeyword.pass");
}
public void testAfterFirstParameterType() throws Exception {
- performTest("Method", 868, null, "intKeyword.pass");
+ performTest("Method", 867, null, "intKeyword.pass");
}
public void testEmptyFileBeforeTypingFirstParameterName() throws Exception {
- performTest("MethodStart", 850, "public void op(int ", "intVarName.pass");
+ performTest("MethodStart", 849, "public void op(int ", "intVarName.pass");
}
public void testBeforeTypingFirstParameterName() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int ", "intVarName.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int ", "intVarName.pass");
}
public void testBeforeFirstParameterName() throws Exception {
- performTest("Method", 869, null, "intVarName.pass");
+ performTest("Method", 868, null, "intVarName.pass");
}
public void testEmptyFileTypingFirstParameterName() throws Exception {
- performTest("MethodStart", 850, "public void op(int a", "empty.pass");
+ performTest("MethodStart", 849, "public void op(int a", "empty.pass");
}
public void testTypingFirstParameterName() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a", "empty.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a", "empty.pass");
}
public void testOnFirstParameterName() throws Exception {
- performTest("Method", 870, null, "empty.pass");
+ performTest("Method", 869, null, "empty.pass");
}
public void testEmptyFileAfterTypingFirstParameterNameAndSpace() throws Exception {
- performTest("MethodStart", 850, "public void op(int a ", "empty.pass");
+ performTest("MethodStart", 849, "public void op(int a ", "empty.pass");
}
public void testAfterTypingFirstParameterNameAndSpace() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a ", "empty.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a ", "empty.pass");
}
public void testAfterFirstParameterNameAndSpace() throws Exception {
- performTest("Method", 870, " ", "empty.pass");
+ performTest("Method", 869, " ", "empty.pass");
}
public void testEmptyFileBeforeTypingSecondParameter() throws Exception {
- performTest("MethodStart", 850, "public void op(int a,", "parameterTypes.pass");
+ performTest("MethodStart", 849, "public void op(int a,", "parameterTypes.pass");
}
public void testBeforeTypingSecondParameter() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a,", "parameterTypes.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a,", "parameterTypes.pass");
}
public void testBeforeSecondParameter() throws Exception {
- performTest("Method", 871, null, "parameterTypes.pass");
+ performTest("Method", 870, null, "parameterTypes.pass");
}
public void testEmptyFileTypingSecondParameterType() throws Exception {
- performTest("MethodStart", 850, "public void op(int a, bo", "booleanKeyword.pass");
+ performTest("MethodStart", 849, "public void op(int a, bo", "booleanKeyword.pass");
}
public void testTypingSecondParameterType() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a, bo", "booleanKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a, bo", "booleanKeyword.pass");
}
public void testOnSecondParameterType() throws Exception {
- performTest("Method", 874, null, "booleanKeyword.pass");
+ performTest("Method", 873, null, "booleanKeyword.pass");
}
public void testEmptyFileAfterTypingSecondParameterType() throws Exception {
- performTest("MethodStart", 850, "public void op(int a, boolean", "booleanKeyword.pass");
+ performTest("MethodStart", 849, "public void op(int a, boolean", "booleanKeyword.pass");
}
public void testAfterTypingSecondParameterType() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a, boolean", "booleanKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a, boolean", "booleanKeyword.pass");
}
public void testAfterSecondParameterType() throws Exception {
- performTest("Method", 879, null, "booleanKeyword.pass");
+ performTest("Method", 878, null, "booleanKeyword.pass");
}
public void testEmptyFileBeforeTypingSecondParameterName() throws Exception {
- performTest("MethodStart", 850, "public void op(int a, boolean ", "booleanVarName.pass");
+ performTest("MethodStart", 849, "public void op(int a, boolean ", "booleanVarName.pass");
}
public void testBeforeTypingSecondParameterName() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a, boolean ", "booleanVarName.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a, boolean ", "booleanVarName.pass");
}
public void testBeforeSecondParameterName() throws Exception {
- performTest("Method", 880, null, "booleanVarName.pass");
+ performTest("Method", 879, null, "booleanVarName.pass");
}
public void testEmptyFileTypingSecondParameterName() throws Exception {
- performTest("MethodStart", 850, "public void op(int a, boolean b", "booleanVarName.pass");
+ performTest("MethodStart", 849, "public void op(int a, boolean b", "booleanVarName.pass");
}
public void testTypingSecondParameterName() throws Exception {
- performTest("MethodNoParamsAndThrows", 865, "int a, boolean b", "booleanVarName.pass");
+ performTest("MethodNoParamsAndThrows", 864, "int a, boolean b", "booleanVarName.pass");
}
public void testOnSecondParameterName() throws Exception {
- performTest("Method", 881, null, "booleanVarName.pass");
+ performTest("Method", 880, null, "booleanVarName.pass");
}
public void testEmptyFileBeforeTypingThrowsKeyword() throws Exception {
- performTest("MethodStart", 850, "public void op() ", "throwsKeyword.pass");
+ performTest("MethodStart", 849, "public void op() ", "throwsKeyword.pass");
}
public void testBeforeTypingThrowsKeyword() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, " ", "throwsKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 865, " ", "throwsKeyword.pass");
}
public void testBeforeThrowsKeyword() throws Exception {
- performTest("Method", 883, null, "throwsKeyword.pass");
+ performTest("Method", 882, null, "throwsKeyword.pass");
}
public void testEmptyFileTypingThrowsKeyword() throws Exception {
- performTest("MethodStart", 850, "public void op() t", "throwsKeyword.pass");
+ performTest("MethodStart", 849, "public void op() t", "throwsKeyword.pass");
}
public void testTypingThrowsKeyword() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, " t", "throwsKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 865, " t", "throwsKeyword.pass");
}
public void testOnThrowsKeyword() throws Exception {
- performTest("Method", 884, null, "throwsKeyword.pass");
+ performTest("Method", 883, null, "throwsKeyword.pass");
}
public void testEmptyAfterFileTypingThrowsKeyword() throws Exception {
- performTest("MethodStart", 850, "public void op() throws", "throwsKeyword.pass");
+ performTest("MethodStart", 849, "public void op() throws", "throwsKeyword.pass");
}
public void testAfterTypingThrowsKeyword() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, " throws", "throwsKeyword.pass");
+ performTest("MethodNoParamsAndThrows", 865, " throws", "throwsKeyword.pass");
}
public void testAfterThrowsKeyword() throws Exception {
- performTest("Method", 889, null, "throwsKeyword.pass");
+ performTest("Method", 888, null, "throwsKeyword.pass");
}
public void testEmptyFileBeforeTypingThrownException() throws Exception {
- performTest("MethodStart", 850, "public void op() throws ", "javaLangThrowables.pass");
+ performTest("MethodStart", 849, "public void op() throws ", "javaLangThrowables.pass");
}
public void testBeforeTypingThrownException() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws ", "javaLangThrowables.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws ", "javaLangThrowables.pass");
}
public void testBeforeThrownException() throws Exception {
- performTest("Method", 890, null, "javaLangThrowables.pass");
+ performTest("Method", 889, null, "javaLangThrowables.pass");
}
public void testEmptyFileTypingThrownException() throws Exception {
- performTest("MethodStart", 850, "public void op() throws N", "javaLangThrowablesStartingWithN.pass");
+ performTest("MethodStart", 849, "public void op() throws N", "javaLangThrowablesStartingWithN.pass");
}
public void testTypingThrownException() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws N", "javaLangThrowablesStartingWithN.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws N", "javaLangThrowablesStartingWithN.pass");
}
public void testOnThrownException() throws Exception {
- performTest("Method", 891, null, "javaLangThrowablesStartingWithN.pass");
+ performTest("Method", 890, null, "javaLangThrowablesStartingWithN.pass");
}
public void testEmptyFileAfterTypingThrownException() throws Exception {
- performTest("MethodStart", 850, "public void op() throws NullPointerException", "nullPointerException.pass");
+ performTest("MethodStart", 849, "public void op() throws NullPointerException", "nullPointerException.pass");
}
public void testAfterTypingThrownException() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws NullPointerException", "nullPointerException.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws NullPointerException", "nullPointerException.pass");
}
public void testAfterThrownException() throws Exception {
- performTest("Method", 910, null, "nullPointerException.pass");
+ performTest("Method", 909, null, "nullPointerException.pass");
}
public void testEmptyFileAfterTypingThrownExceptionAndSpace() throws Exception {
- performTest("MethodStart", 850, "public void op() throws NullPointerException ", "empty.pass");
+ performTest("MethodStart", 849, "public void op() throws NullPointerException ", "empty.pass");
}
public void testAfterTypingThrownExceptionAndSpace() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws NullPointerException ", "empty.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws NullPointerException ", "empty.pass");
}
public void testAfterThrownExceptionAndSpace() throws Exception {
- performTest("Method", 910, " ", "empty.pass");
+ performTest("Method", 909, " ", "empty.pass");
}
public void testEmptyFileBeforeTypingSecondThrownException() throws Exception {
- performTest("MethodStart", 850, "public void op() throws NullPointerException, ", "javaLangThrowables.pass");
+ performTest("MethodStart", 849, "public void op() throws NullPointerException, ", "javaLangThrowables.pass");
}
public void testBeforeTypingSecondThrownException() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws NullPointerException, ", "javaLangThrowables.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws NullPointerException, ", "javaLangThrowables.pass");
}
public void testBeforeSecondThrownExceptionAndSpace() throws Exception {
- performTest("Method", 912, null, "javaLangThrowables.pass");
+ performTest("Method", 911, null, "javaLangThrowables.pass");
}
public void testEmptyFileTypingSecondThrownException() throws Exception {
- performTest("MethodStart", 850, "public void op() throws NullPointerException, I", "javaLangThrowablesStartingWithI.pass");
+ performTest("MethodStart", 849, "public void op() throws NullPointerException, I", "javaLangThrowablesStartingWithI.pass");
}
public void testTypingSecondThrownException() throws Exception {
- performTest("MethodNoParamsAndThrows", 866, "throws NullPointerException, I", "javaLangThrowablesStartingWithI.pass");
+ performTest("MethodNoParamsAndThrows", 865, "throws NullPointerException, I", "javaLangThrowablesStartingWithI.pass");
}
public void testOnSecondThrownException() throws Exception {
- performTest("Method", 913, null, "javaLangThrowablesStartingWithI.pass");
+ performTest("Method", 912, null, "javaLangThrowablesStartingWithI.pass");
}
public void testEmptyFileAfterTypingMethodBody() throws Exception {
- performTest("MethodStart", 850, "public void op() {\n}", "memberModifiersTypesAndGenElements.pass");
+ performTest("MethodStart", 849, "public void op() {\n}", "memberModifiersTypesAndGenElements.pass");
}
public void testAfterMethodBody() throws Exception {
- performTest("Method", 941, null, "memberModifiersTypesAndGenElements.pass");
+ performTest("Method", 940, null, "memberModifiersTypesAndGenElements.pass");
}
public void testEmptyFileAfterTypingIncompleteMethodBodyAndPublicKeyword() throws Exception {
- performTest("MethodStart", 850, "public void op() {\npublic", "empty.pass");
+ performTest("MethodStart", 849, "public void op() {\npublic", "empty.pass");
}
public void testEmptyFileAfterTypingIncompleteMethodBodyAndPublicKeywordAndSpace() throws Exception {
- performTest("MethodStart", 850, "public void op() {\npublic ", "memberModifiersAndTypesWithoutPublic.pass");
+ performTest("MethodStart", 849, "public void op() {\npublic ", "memberModifiersAndTypesWithoutPublic.pass");
}
// field declaration tests -------------------------------------------------
public void testEmptyFileAfterTypingFieldNameAndSpace() throws Exception {
- performTest("MethodStart", 850, "public int field ", "empty.pass");
+ performTest("MethodStart", 849, "public int field ", "empty.pass");
}
public void testAfterTypingFieldNameAndSpace() throws Exception {
- performTest("FieldNoInit", 866, " ", "empty.pass");
+ performTest("FieldNoInit", 865, " ", "empty.pass");
}
public void testAfterFieldNameAndSpace() throws Exception {
- performTest("Field", 867, null, "empty.pass");
+ performTest("Field", 866, null, "empty.pass");
}
public void testEmptyFileAfterTypingAssignmentInField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField = 10;\npublic int field =", "typesLocalMembersAndSmartInt.pass");
+ performTest("MethodStart", 849, "public static int staticField = 10;\npublic int field =", "typesLocalMembersAndSmartInt.pass");
}
public void testAfterTypingAssignmentInField() throws Exception {
- performTest("FieldNoInit", 866, " =", "typesLocalMembersAndSmartInt.pass");
+ performTest("FieldNoInit", 865, " =", "typesLocalMembersAndSmartInt.pass");
}
public void testAfterAssignmentInField() throws Exception {
- performTest("Field", 868, null, "typesLocalMembersAndSmartInt.pass");
+ performTest("Field", 867, null, "typesLocalMembersAndSmartInt.pass");
}
public void testEmptyFileBeforeTypingInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField = 10;\npublic int field = ", "typesLocalMembersAndSmartInt.pass");
+ performTest("MethodStart", 849, "public static int staticField = 10;\npublic int field = ", "typesLocalMembersAndSmartInt.pass");
}
public void testBeforeTypingInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = ", "typesLocalMembersAndSmartInt.pass");
+ performTest("FieldNoInit", 865, " = ", "typesLocalMembersAndSmartInt.pass");
}
public void testBeforeInitOfField() throws Exception {
- performTest("Field", 869, null, "typesLocalMembersAndSmartInt.pass");
+ performTest("Field", 868, null, "typesLocalMembersAndSmartInt.pass");
}
public void testEmptyFileBeforeTypingInitOfStaticField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField = ", "typesAndStaticLocalMembers.pass");
+ performTest("MethodStart", 849, "public static int staticField = ", "typesAndStaticLocalMembers.pass");
}
public void testBeforeTypingInitOfStaticField() throws Exception {
- performTest("FieldNoInit", 901, " = ", "typesAndStaticLocalMembers.pass");
+ performTest("FieldNoInit", 900, " = ", "typesAndStaticLocalMembers.pass");
}
public void testBeforeInitOfStaticField() throws Exception {
- performTest("Field", 922, null, "typesAndStaticLocalMembers.pass");
+ performTest("Field", 921, null, "typesAndStaticLocalMembers.pass");
}
public void testEmptyFileTypingInitOfField() throws Exception {
- performTest("MethodStart", 850, "public int field = ha", "intHashCode.pass");
+ performTest("MethodStart", 849, "public int field = ha", "intHashCode.pass");
}
public void testTypingInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = ha", "intHashCode.pass");
+ performTest("FieldNoInit", 865, " = ha", "intHashCode.pass");
}
public void testOnInitOfField() throws Exception {
- performTest("Field", 871, null, "intHashCode.pass");
+ performTest("Field", 870, null, "intHashCode.pass");
}
public void testEmptyFileTypingMethodInvocationWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField = 10;\npublic int field = hashCode(", "typesAndLocalMembers.pass");
+ performTest("MethodStart", 849, "public static int staticField = 10;\npublic int field = hashCode(", "typesAndLocalMembers.pass");
}
public void testTypingMethodInvocationWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = hashCode(", "typesAndLocalMembers.pass");
+ performTest("FieldNoInit", 865, " = hashCode(", "typesAndLocalMembers.pass");
}
public void testOnMethodInvocationWithinInitOfField() throws Exception {
- performTest("Field", 878, null, "typesAndLocalMembers.pass");
+ performTest("Field", 877, null, "typesAndLocalMembers.pass");
}
public void testEmptyFileAfterTypingMethodInvocationWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public int field = hashCode()", "empty.pass");
+ performTest("MethodStart", 849, "public int field = hashCode()", "empty.pass");
}
public void testAfterTypingMethodInvocationWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = hashCode()", "empty.pass");
+ performTest("FieldNoInit", 865, " = hashCode()", "empty.pass");
}
public void testAfterMethodInvocationWithinInitOfField() throws Exception {
- performTest("Field", 879, null, "empty.pass");
+ performTest("Field", 878, null, "empty.pass");
}
public void testEmptyFileAfterTypingOperatorWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public static int staticField = 10;\npublic int field = hashCode() /", "typesLocalMembersAndSmartPrimitives.pass");
+ performTest("MethodStart", 849, "public static int staticField = 10;\npublic int field = hashCode() /", "typesLocalMembersAndSmartPrimitives.pass");
}
public void testAfterTypingOperatorWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = hashCode() /", "typesLocalMembersAndSmartPrimitives.pass");
+ performTest("FieldNoInit", 865, " = hashCode() /", "typesLocalMembersAndSmartPrimitives.pass");
}
public void testAfterOperatorWithinInitOfField() throws Exception {
- performTest("Field", 881, null, "typesLocalMembersAndSmartPrimitives.pass");
+ performTest("Field", 880, null, "typesLocalMembersAndSmartPrimitives.pass");
}
public void testEmptyFileAfterTypingConstantWithinInitOfField() throws Exception {
- performTest("MethodStart", 850, "public int field = hashCode() / 10", "empty.pass");
+ performTest("MethodStart", 849, "public int field = hashCode() / 10", "empty.pass");
}
public void testAfterTypingConstantWithinInitOfField() throws Exception {
- performTest("FieldNoInit", 866, " = hashCode() / 10", "empty.pass");
+ performTest("FieldNoInit", 865, " = hashCode() / 10", "empty.pass");
}
public void testAfterConstantWithinInitOfField() throws Exception {
- performTest("Field", 884, null, "empty.pass");
+ performTest("Field", 883, null, "empty.pass");
}
public void testEmptyFileAfterTypingFieldDeclaration() throws Exception {
- performTest("MethodStart", 850, "public int field = hashCode() / 10;", "memberModifiersTypesAndGenElements3.pass");
+ performTest("MethodStart", 849, "public int field = hashCode() / 10;", "memberModifiersTypesAndGenElements3.pass");
}
public void testAfterFieldDeclaration() throws Exception {
- performTest("Field", 885, null, "memberModifiersTypesAndGenElements4.pass");
+ performTest("Field", 884, null, "memberModifiersTypesAndGenElements4.pass");
}
public void testTypingStaticFieldAfterErrorInPreviousFieldDeclaration() throws Exception {
- performTest("MethodStart", 850, "public int \npublic sta", "staticKeyword.pass");
+ performTest("MethodStart", 849, "public int \npublic sta", "staticKeyword.pass");
}
public void testTypingStaticFieldAfterErrorInPreviousFieldInitialization() throws Exception {
- performTest("MethodStart", 850, "public int field = has\npublic sta", "staticKeyword.pass");
+ performTest("MethodStart", 849, "public int field = has\npublic sta", "staticKeyword.pass");
}
// basic method body tests -------------------------------------------------
public void testEmptyFileTypingMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 899, null, "methodBodyContent.pass");
+ performTest("SimpleMethodBodyStart", 898, null, "methodBodyContent.pass");
}
public void testTypingMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 899, null, "methodBodyContent.pass");
+ performTest("SimpleEmptyMethodBody", 898, null, "methodBodyContent.pass");
}
public void testInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 899, null, "methodBodyContent.pass");
+ performTest("SimpleMethodBody", 898, null, "methodBodyContent.pass");
}
public void testEmptyFileTypingLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "bo", "booleanKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "bo", "booleanKeyword.pass");
}
public void testTypingLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "bo", "booleanKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "bo", "booleanKeyword.pass");
}
public void testLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 910, null, "booleanKeyword.pass");
+ performTest("SimpleMethodBody", 909, null, "booleanKeyword.pass");
}
public void testEmptyFileAfterTypingLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean", "booleanKeyword.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean", "booleanKeyword.pass");
}
public void testAfterTypingLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean", "booleanKeyword.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean", "booleanKeyword.pass");
}
public void testAfterLocalVariableTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 915, null, "booleanKeyword.pass");
+ performTest("SimpleMethodBody", 914, null, "booleanKeyword.pass");
}
public void testEmptyFileBeforeTypingLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean ", "booleanVarName.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean ", "booleanVarName.pass");
}
public void testBeforeTypingLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean ", "booleanVarName.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean ", "booleanVarName.pass");
}
public void testBeforeLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 916, null, "booleanVarName.pass");
+ performTest("SimpleMethodBody", 915, null, "booleanVarName.pass");
}
public void testEmptyFileTypingLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b", "booleanVarName.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b", "booleanVarName.pass");
}
public void testTypingLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b", "booleanVarName.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b", "booleanVarName.pass");
}
public void testOnLocalVariableNameInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 917, null, "booleanVarName.pass");
+ performTest("SimpleMethodBody", 916, null, "booleanVarName.pass");
}
public void testEmptyFileAfterTypingLocalVariableNameAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b ", "empty.pass");
}
public void testAfterTypingLocalVariableNameAndSpaceInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b ", "empty.pass");
}
public void testAfterLocalVariableNameAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 917, " ", "empty.pass");
+ performTest("SimpleMethodBody", 916, " ", "empty.pass");
}
public void testEmptyFileAfterTypingLocalVariableInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;", "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;", "methodBodyContentAndLocalVar.pass");
}
public void testAfterTypingLocalVariableInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;", "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;", "methodBodyContentAndLocalVar.pass");
}
public void testAfterLocalVariableInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 918, null, "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleMethodBody", 917, null, "methodBodyContentAndLocalVar.pass");
}
public void testEmptyFileTypingTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "Sy", "system.pass");
+ performTest("SimpleMethodBodyStart", 907, "Sy", "system.pass");
}
public void testTypingTypeInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "Sy", "system.pass");
+ performTest("SimpleEmptyMethodBody", 907, "Sy", "system.pass");
}
public void testTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 922, null, "system.pass");
+ performTest("SimpleMethodBody", 921, null, "system.pass");
}
public void testEmptyFileAfterTypingTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System", "system.pass");
+ performTest("SimpleMethodBodyStart", 907, "System", "system.pass");
}
public void testAfterTypingTypeInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System", "system.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System", "system.pass");
}
public void testAfterTypeInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 926, null, "system.pass");
+ performTest("SimpleMethodBody", 925, null, "system.pass");
}
public void testEmptyFileAfterTypingTypeAndDotInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.", "systemContent.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.", "systemContent.pass");
}
public void testAfterTypingTypeAndDotInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.", "systemContent.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.", "systemContent.pass");
}
public void testAfterTypeAndDotInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 927, null, "systemContent.pass");
+ performTest("SimpleMethodBody", 926, null, "systemContent.pass");
}
public void testEmptyFileTypingFieldAccessInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.o", "systemOut.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.o", "systemOut.pass");
}
public void testTypingFieldAccessInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.o", "systemOut.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.o", "systemOut.pass");
}
public void testFieldAccessInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 928, null, "systemOut.pass");
+ performTest("SimpleMethodBody", 927, null, "systemOut.pass");
}
public void testEmptyFileAfterTypingFieldAccessInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.out", "systemOut.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.out", "systemOut.pass");
}
public void testAfterTypingFieldAccessInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.out", "systemOut.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.out", "systemOut.pass");
}
public void testAfterFieldAccessInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 930, null, "systemOut.pass");
+ performTest("SimpleMethodBody", 929, null, "systemOut.pass");
}
public void testEmptyFileAfterTypingFieldAccessAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.out ", "instanceOf.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.out ", "instanceOf.pass");
}
public void testAfterTypingFieldAccessAndSpaceInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.out ", "instanceOf.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.out ", "instanceOf.pass");
}
public void testAfterFieldAccessAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 930, " ", "instanceOf.pass");
+ performTest("SimpleMethodBody", 929, " ", "instanceOf.pass");
}
public void testEmptyFileAfterTypingFieldAccessAndDotInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.out.", "systemOutContent.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.out.", "systemOutContent.pass");
}
public void testAfterTypingFieldAccessAndDotInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.out.", "systemOutContent.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.out.", "systemOutContent.pass");
}
public void testAfterFieldAccessAndDotInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 931, null, "systemOutContent.pass");
+ performTest("SimpleMethodBody", 930, null, "systemOutContent.pass");
}
public void testEmptyFileTypingMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(", "typesLocalMembersVarsAndSmarts.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(", "typesLocalMembersVarsAndSmarts.pass");
}
public void testTypingMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(", "typesLocalMembersVarsAndSmarts.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(", "typesLocalMembersVarsAndSmarts.pass");
}
public void testMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 939, null, "typesLocalMembersVarsAndSmarts.pass");
+ performTest("SimpleMethodBody", 938, null, "typesLocalMembersVarsAndSmarts.pass");
}
public void testEmptyFileTypingMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b", "typesLocalMembersVarsAndSmartsStartingWithB.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b", "typesLocalMembersVarsAndSmartsStartingWithB.pass");
}
public void testTypingMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b", "typesLocalMembersVarsAndSmartsStartingWithB.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b", "typesLocalMembersVarsAndSmartsStartingWithB.pass");
}
public void testOnMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 940, null, "typesLocalMembersVarsAndSmartsStartingWithB.pass");
+ performTest("SimpleMethodBody", 939, null, "typesLocalMembersVarsAndSmartsStartingWithB.pass");
}
public void testEmptyFileTypingMethodInvocationParameterAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "System.out.println(b ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "System.out.println(b ", "empty.pass");
}
public void testTypingMethodInvocationParameterAndSpaceInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "System.out.println(b ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "System.out.println(b ", "empty.pass");
}
public void testAfterMethodInvocationParameterAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 940, " ", "empty.pass");
+ performTest("SimpleMethodBody", 939, " ", "empty.pass");
}
public void testEmptyFileBeforeTypingSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b, ", "typesLocalMembersAndVars.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b, ", "typesLocalMembersAndVars.pass");
}
public void testBeforeTypingSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b, ", "typesLocalMembersAndVars.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b, ", "typesLocalMembersAndVars.pass");
}
public void testBeforeSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 940, ", ", "typesLocalMembersAndVars.pass");
+ performTest("SimpleMethodBody", 939, ", ", "typesLocalMembersAndVars.pass");
}
public void testEmptyFileTypingSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b, b", "typesLocalMembersAndVarsStartingWithB.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b, b", "typesLocalMembersAndVarsStartingWithB.pass");
}
public void testTypingSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b, b", "typesLocalMembersAndVarsStartingWithB.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b, b", "typesLocalMembersAndVarsStartingWithB.pass");
}
public void testOnSecondMethodInvocationParameterInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 940, ", b", "typesLocalMembersAndVarsStartingWithB.pass");
+ performTest("SimpleMethodBody", 939, ", b", "typesLocalMembersAndVarsStartingWithB.pass");
}
public void testEmptyFileAfterTypingMethodInvocationParametersInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b)", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b)", "empty.pass");
}
public void testAfterTypingMethodInvocationParametersInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b)", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b)", "empty.pass");
}
public void testAfteMethodInvocationParametersInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 941, null, "empty.pass");
+ performTest("SimpleMethodBody", 940, null, "empty.pass");
}
public void testEmptyFileAfterTypingMethodInvocationParametersAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b) ", "empty.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b) ", "empty.pass");
}
public void testAfterTypingMethodInvocationParametersAndSpaceInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b) ", "empty.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b) ", "empty.pass");
}
public void testAfteMethodInvocationParametersAndSpaceInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 941, " ", "empty.pass");
+ performTest("SimpleMethodBody", 940, " ", "empty.pass");
}
public void testEmptyFileAfterTypingMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleMethodBodyStart", 908, "boolean b;\nSystem.out.println(b);", "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleMethodBodyStart", 907, "boolean b;\nSystem.out.println(b);", "methodBodyContentAndLocalVar.pass");
}
public void testAfterTypingMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleEmptyMethodBody", 908, "boolean b;\nSystem.out.println(b);", "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleEmptyMethodBody", 907, "boolean b;\nSystem.out.println(b);", "methodBodyContentAndLocalVar.pass");
}
public void testAfteMethodInvocationInMethodBody() throws Exception {
- performTest("SimpleMethodBody", 942, null, "methodBodyContentAndLocalVar.pass");
+ performTest("SimpleMethodBody", 941, null, "methodBodyContentAndLocalVar.pass");
}
}
diff --git a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskElementCreatingTest.java b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskElementCreatingTest.java
index 6dcdf8f17..928946631 100644
--- a/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskElementCreatingTest.java
+++ b/java.completion/test/unit/src/org/netbeans/modules/java/completion/JavaCompletionTaskElementCreatingTest.java
@@ -30,99 +30,99 @@ public JavaCompletionTaskElementCreatingTest(String testName) {
}
public void testUnimplementedMethod() throws Exception {
- performTest("UnimplementedMethod", 895, "", "UnimplementedMethod.pass");
+ performTest("UnimplementedMethod", 894, "", "UnimplementedMethod.pass");
}
public void testOverrideAbstractList() throws Exception {
- performTest("OverrideAbstractList", 928, "", "OverrideAbstractList.pass");
+ performTest("OverrideAbstractList", 927, "", "OverrideAbstractList.pass");
}
/**
* Checks that cc: offers just one size() for override, but offers size() for both implement AND override.
*/
public void testOverrideAbstractListAbstract() throws Exception {
- performTest("OverrideAbstractListAbstract", 936, "", "OverrideAbstractListAbstract.pass");
+ performTest("OverrideAbstractListAbstract", 935, "", "OverrideAbstractListAbstract.pass");
}
/** CC should not offer overriding private method from superclass */
public void testOverridePrivateMethod() throws Exception {
- performTest("OverridePrivateMethod", 899, "cl", "OverridePrivateMethod.pass");
+ performTest("OverridePrivateMethod", 898, "cl", "OverridePrivateMethod.pass");
}
/** CC should not offer overriding package private method from superclass in a different package */
public void testOverridePackagePrivateMethod() throws Exception {
- performTest("OverridePackagePrivateMethod", 918, "add", "OverridePackagePrivateMethod.pass");
+ performTest("OverridePackagePrivateMethod", 917, "add", "OverridePackagePrivateMethod.pass");
}
public void testOverrideAbstractListWithPrefix() throws Exception {
- performTest("OverrideAbstractList", 928, "to", "OverrideAbstractListWithPrefix.pass");
+ performTest("OverrideAbstractList", 927, "to", "OverrideAbstractListWithPrefix.pass");
}
public void testOverrideFinalize() throws Exception {
- performTest("OverrideAbstractList", 928, "fin", "OverrideFinalize.pass");
+ performTest("OverrideAbstractList", 927, "fin", "OverrideFinalize.pass");
}
public void testOverrideAbstractList2a() throws Exception {
- performTest("OverrideAbstractList2", 949, "ad", "OverrideAbstractList2a.pass");
+ performTest("OverrideAbstractList2", 948, "ad", "OverrideAbstractList2a.pass");
}
public void testOverrideAbstractList2b() throws Exception {
- performTest("OverrideAbstractList2", 949, "ge", "OverrideAbstractList2b.pass");
+ performTest("OverrideAbstractList2", 948, "ge", "OverrideAbstractList2b.pass");
}
public void testOverrideAbstractList3a() throws Exception {
- performTest("OverrideAbstractList3", 936, "ad", "OverrideAbstractList3a.pass");
+ performTest("OverrideAbstractList3", 935, "ad", "OverrideAbstractList3a.pass");
}
public void testOverrideAbstractList3b() throws Exception {
- performTest("OverrideAbstractList3", 936, "ge", "OverrideAbstractList3b.pass");
+ performTest("OverrideAbstractList3", 935, "ge", "OverrideAbstractList3b.pass");
}
public void testOverrideTypedException1() throws Exception {
- performTest("OverrideTypedException", 1019, "tes", "OverrideTypedException.pass");
+ performTest("OverrideTypedException", 1018, "tes", "OverrideTypedException.pass");
}
public void testOverrideTypedException2() throws Exception {
- performTest("OverrideTypedException", 1115, "tes", "OverrideTypedException.pass");
+ performTest("OverrideTypedException", 1114, "tes", "OverrideTypedException.pass");
}
public void testOverrideInInnerClass() throws Exception {
- performTest("OverrideInInnerClass", 995, "pai", "OverrideInInnerClass.pass");
+ performTest("OverrideInInnerClass", 994, "pai", "OverrideInInnerClass.pass");
}
public void testOverrideInInnerClassUnresolvable() throws Exception {
- performTest("OverrideInInnerClassUnresolvable", 967, "pai", "empty.pass");
+ performTest("OverrideInInnerClassUnresolvable", 966, "pai", "empty.pass");
}
public void testCreateConstructorTest() throws Exception {
- performTest("CreateConstructorTest", 1059, "", "CreateConstructorTest.pass");
+ performTest("CreateConstructorTest", 1058, "", "CreateConstructorTest.pass");
}
public void testCreateConstructorTestInnerClass() throws Exception {
- performTest("CreateConstructorTest", 1244, "", "CreateConstructorTestInnerClass.pass");
+ performTest("CreateConstructorTest", 1243, "", "CreateConstructorTestInnerClass.pass");
}
public void testCreateConstructorWithConstructors() throws Exception {
- performTest("CreateConstructorWithConstructors", 1210, "", "CreateConstructorWithConstructors.pass");
+ performTest("CreateConstructorWithConstructors", 1209, "", "CreateConstructorWithConstructors.pass");
}
public void testCreateConstructorWithConstructorsInnerClass() throws Exception {
- performTest("CreateConstructorWithConstructors", 1477, "", "CreateConstructorWithConstructorsInnerClass.pass");
+ performTest("CreateConstructorWithConstructors", 1476, "", "CreateConstructorWithConstructorsInnerClass.pass");
}
public void testCreateConstructorWithDefaultConstructor() throws Exception {
- performTest("CreateConstructorWithDefaultConstructor", 1162, "", "CreateConstructorWithDefaultConstructor.pass");
+ performTest("CreateConstructorWithDefaultConstructor", 1161, "", "CreateConstructorWithDefaultConstructor.pass");
}
public void testCreateConstructorWithDefaultConstructorInnerClass() throws Exception {
- performTest("CreateConstructorWithDefaultConstructor", 1370, "", "CreateConstructorWithDefaultConstructorInnerClass.pass");
+ performTest("CreateConstructorWithDefaultConstructor", 1369, "", "CreateConstructorWithDefaultConstructorInnerClass.pass");
}
public void testCreateConstructorNonDefaultConstructor() throws Exception {
- performTest("CreateConstructorNonDefaultConstructor", 1189, "", "CreateConstructorNonDefaultConstructor.pass");
+ performTest("CreateConstructorNonDefaultConstructor", 1188, "", "CreateConstructorNonDefaultConstructor.pass");
}
public void testCreateConstructorNonDefaultConstructorInnerClass() throws Exception {
- performTest("CreateConstructorNonDefaultConstructor", 1434, "", "CreateConstructorNonDefaultConstructorInnerClass.pass");
+ performTest("CreateConstructorNonDefaultConstructor", 1433, "", "CreateConstructorNonDefaultConstructorInnerClass.pass");
}
}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@netbeans.apache.org
For additional commands, e-mail: notifications-help@netbeans.apache.org
For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists