Gitiles
Code Review Sign In
git.eclipse.org / objectteams / org.eclipse.objectteams / 35705382a6f7cdbb3cbfd09226493a668fd3ade8 / . / testplugins / org.eclipse.objectteams.otdt.tests / otjld / org / eclipse / objectteams / otdt / tests / otjld / roleplaying / LiftingAndLowering.java
blob: e5383069e105687dc355819d10eb922a1ea60e8e [file] [log] [blame]
/**********************************************************************
* This file is part of "Object Teams Development Tooling"-Software
*
* Copyright 2004, 2020 IT Service Omikron GmbH and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
* $Id$
*
* Please visit http://www.eclipse.org/objectteams for updates and contact.
*
* Contributors:
* Thomas Dudziak - Initial API and implementation
* Stephan Herrmann - Initial API and implementation
**********************************************************************/
package org.eclipse.objectteams.otdt.tests.otjld.roleplaying;
import java.util.Map;
import junit.framework.Test;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.objectteams.otdt.core.ext.WeavingScheme;
import org.eclipse.objectteams.otdt.tests.otjld.AbstractOTJLDTest;
@SuppressWarnings("unchecked")
public class LiftingAndLowering extends AbstractOTJLDTest {
public LiftingAndLowering(String name) {
super(name);
}
// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which does not belong to the class are skipped...
static {
// TESTS_NAMES = new String[] { "test2215_arrayLifting7"};
// TESTS_NUMBERS = new int[] { 1459 };
// TESTS_RANGE = new int[] { 1097, -1 };
}
public static Test suite() {
return buildComparableTestSuite(testClass());
}
public static Class testClass() {
return LiftingAndLowering.class;
}
// a role is lowered to the base class that it is played by
// 2.2.1-otjld-lowering-to-baseclass-1
public void test221_loweringToBaseclass1() {
runConformTest(
new String[] {
"T221ltb1Main.java",
"\n" +
"public class T221ltb1Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb1 t = new Team221ltb1();\n" +
" T221ltb1 o = new T221ltb1();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb1.java",
"\n" +
"public class T221ltb1 {\n" +
" String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb1.java",
"\n" +
"public team class Team221ltb1 {\n" +
"\n" +
" public class Role221ltb1 playedBy T221ltb1 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T221ltb1 as Role221ltb1 obj) {\n" +
" T221ltb1 o = obj;\n" +
"\n" +
" return o.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered to the base class that it is played by
// 2.2.1-otjld-lowering-to-baseclass-2
public void test221_loweringToBaseclass2() {
runConformTest(
new String[] {
"T221ltb2Main.java",
"\n" +
"public class T221ltb2Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb2 t = new Team221ltb2();\n" +
" T221ltb2 o = new T221ltb2();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb2.java",
"\n" +
"public class T221ltb2 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb2.java",
"\n" +
"public team class Team221ltb2 {\n" +
"\n" +
" public class Role221ltb2 playedBy T221ltb2 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T221ltb2 as Role221ltb2 obj) {\n" +
" final T221ltb2 o = obj;\n" +
"\n" +
" return o.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered to the base class that it is played by
// 2.2.1-otjld-lowering-to-baseclass-3
public void test221_loweringToBaseclass3() {
runConformTest(
new String[] {
"T221ltb3Main.java",
"\n" +
"public class T221ltb3Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb3 t = new Team221ltb3();\n" +
" T221ltb3 o = new T221ltb3();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb3.java",
"\n" +
"public class T221ltb3 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb3.java",
"\n" +
"public team class Team221ltb3 {\n" +
"\n" +
" public class Role221ltb3 playedBy T221ltb3 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T221ltb3 as Role221ltb3 obj) {\n" +
" return getValueInternal(obj);\n" +
" }\n" +
"\n" +
" private String getValueInternal(T221ltb3 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered to the base class that it is played by
// 2.2.1-otjld-lowering-to-baseclass-4
public void test221_loweringToBaseclass4() {
runConformTest(
new String[] {
"T221ltb4Main.java",
"\n" +
"public class T221ltb4Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb4_2 t = new Team221ltb4_2();\n" +
" T221ltb4 o = new T221ltb4();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb4.java",
"\n" +
"public class T221ltb4 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb4_1.java",
"\n" +
"public team class Team221ltb4_1 {\n" +
"\n" +
" public class Role221ltb4 playedBy T221ltb4 {}\n" +
"\n" +
" public String getValue(T221ltb4 as Role221ltb4 obj) {\n" +
" return getValueInternal(obj);\n" +
" }\n" +
"\n" +
" private String getValueInternal(final T221ltb4 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb4_2.java",
"\n" +
"public team class Team221ltb4_2 extends Team221ltb4_1 {\n" +
"\n" +
" public class Role221ltb4 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered via a field to the base class of its explicit superrole
// 2.2.1-otjld-lowering-to-baseclass-5
public void test221_loweringToBaseclass5() {
runConformTest(
new String[] {
"T221ltb5Main.java",
"\n" +
"public class T221ltb5Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb5 t = new Team221ltb5();\n" +
" T221ltb5 o = new T221ltb5();\n" +
"\n" +
" t.setValue(o);\n" +
" System.out.print(t.getAttr());\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb5.java",
"\n" +
"public class T221ltb5 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb5.java",
"\n" +
"public team class Team221ltb5 {\n" +
" private T221ltb5 attr;\n" +
"\n" +
" public class Role221ltb5_1 playedBy T221ltb5 {}\n" +
"\n" +
" public class Role221ltb5_2 extends Role221ltb5_1 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public void setValue(T221ltb5 as Role221ltb5_2 obj) {\n" +
" attr = obj;\n" +
" }\n" +
"\n" +
" public String getAttr() {\n" +
" return attr.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by
// 2.2.1-otjld-lowering-to-baseclass-6
public void test221_loweringToBaseclass6() {
runConformTest(
new String[] {
"T221ltb6Main.java",
"\n" +
"public class T221ltb6Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb6 t = new Team221ltb6();\n" +
" T221ltb6_2 o = new T221ltb6_2();\n" +
"\n" +
" System.out.print(t.getBase(o).getValue());\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb6_1.java",
"\n" +
"public class T221ltb6_1 {\n" +
" protected String getValue() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb6_2.java",
"\n" +
"public class T221ltb6_2 extends T221ltb6_1 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb6.java",
"\n" +
"public team class Team221ltb6 {\n" +
" public class Role221ltb6 playedBy T221ltb6_1 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public T221ltb6_1 getBase(T221ltb6_2 as Role221ltb6 obj) {\n" +
" return obj;\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by - call returns null!
// 2.2.1-otjld-lowering-to-baseclass-7
public void test221_loweringToBaseclass7() {
runConformTest(
new String[] {
"T221ltb7Main.java",
"\n" +
"public class T221ltb7Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb7 t = new Team221ltb7();\n" +
" if (t.getBase() == null)\n" +
" System.out.print(\"OK\");\n" +
" else \n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb7_1.java",
"\n" +
"public class T221ltb7_1 {}\n" +
" \n",
"Team221ltb7.java",
"\n" +
"public team class Team221ltb7 {\n" +
" public class Role221ltb7 playedBy T221ltb7_1 {}\n" +
" \n" +
" private Role221ltb7 theRole = null;\n" +
" public T221ltb7_1 getBase() {\n" +
" return theRole;\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by - call returns null!
// 2.2.1-otjld-lowering-to-baseclass-8
public void test221_loweringToBaseclass8() {
runConformTest(
new String[] {
"T221ltb8Main.java",
"\n" +
"public class T221ltb8Main {\n" +
" public static void main(String[] args) {\n" +
" final Team221ltb8 t = new Team221ltb8();\n" +
" if (t.getR().getBase() == null)\n" +
" System.out.print(\"OK\");\n" +
" else \n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb8_1.java",
"\n" +
"public class T221ltb8_1 {}\n" +
" \n",
"Team221ltb8.java",
"\n" +
"public team class Team221ltb8 {\n" +
" public class Role221ltb8 playedBy T221ltb8_1 {\n" +
" private Role221ltb8 theRole = null;\n" +
" public T221ltb8_1 getBase() {\n" +
" return theRole;\n" +
" }\n" +
" } \n" +
" public Role221ltb8 getR() { \n" +
" return new Role221ltb8(new T221ltb8_1());\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by - call returns null!
// 2.2.1-otjld-lowering-to-baseclass-9
public void test221_loweringToBaseclass9() {
runConformTest(
new String[] {
"T221ltb9Main.java",
"\n" +
"public class T221ltb9Main {\n" +
" public static void main(String[] args) {\n" +
" final Team221ltb9 t = new Team221ltb9();\n" +
" if (t.getR().getBases() == null)\n" +
" System.out.print(\"OK\");\n" +
" else \n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb9_1.java",
"\n" +
"public class T221ltb9_1 {}\n" +
" \n",
"Team221ltb9.java",
"\n" +
"public team class Team221ltb9 {\n" +
" public class Role221ltb9 playedBy T221ltb9_1 {\n" +
" private Role221ltb9[] theRoles = null;\n" +
" public T221ltb9_1[] getBases() {\n" +
" return theRoles;\n" +
" }\n" +
" } \n" +
" public Role221ltb9 getR() { \n" +
" return new Role221ltb9(new T221ltb9_1());\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by - call returns null!
// 2.2.1-otjld-lowering-to-baseclass-10
public void test221_loweringToBaseclass10() {
runConformTest(
new String[] {
"T221ltb10Main.java",
"\n" +
"public class T221ltb10Main {\n" +
" public static void main(String[] args) {\n" +
" final Team221ltb10 t = new Team221ltb10();\n" +
" if (t.getR().getBases()[0] == null)\n" +
" System.out.print(\"OK\");\n" +
" else \n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb10_1.java",
"\n" +
"public class T221ltb10_1 {}\n" +
" \n",
"Team221ltb10.java",
"\n" +
"public team class Team221ltb10 {\n" +
" public class Role221ltb10 playedBy T221ltb10_1 {\n" +
" private Role221ltb10[] theRoles = new Role221ltb10[]{null};\n" +
" public T221ltb10_1[] getBases() {\n" +
" return theRoles;\n" +
" }\n" +
" } \n" +
" public Role221ltb10 getR() { \n" +
" return new Role221ltb10(new T221ltb10_1());\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is lowered in a return statement to the base class that it is played by - bound super-role exists
// 2.2.1-otjld-lowering-to-baseclass-11
public void test221_loweringToBaseclass11() {
runConformTest(
new String[] {
"T221ltb11Main.java",
"\n" +
"public class T221ltb11Main {\n" +
" public static void main(String[] args) {\n" +
" Team221ltb11 t = new Team221ltb11();\n" +
" T221ltb11_2 o = new T221ltb11_2();\n" +
"\n" +
" System.out.print(t.getBase(o).getValue());\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb11_1.java",
"\n" +
"public class T221ltb11_1 {\n" +
" protected String getValue() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb11_2.java",
"\n" +
"public class T221ltb11_2 extends T221ltb11_1 {\n" +
" protected String getValue() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team221ltb11.java",
"\n" +
"public team class Team221ltb11 {\n" +
" public class Role221ltb11_1 playedBy T221ltb11_1 {\n" +
" }\n" +
" public class Role221ltb11_2 extends Role221ltb11_1 playedBy T221ltb11_2 {\n" +
" protected abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
" public class Role221ltb11_3 {\n" +
" protected T221ltb11_2 getBase(Role221ltb11_2 role) {\n" +
" return role;\n" +
" }\n" +
" }\n" +
"\n" +
" public T221ltb11_1 getBase(T221ltb11_2 as Role221ltb11_2 obj) {\n" +
" Role221ltb11_3 r = new Role221ltb11_3();\n" +
" return r.getBase(obj);\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// the enclosing nested team is lowered
// 2.2.1-otjld-lowering-to-baseclass-12
public void test221_loweringToBaseclass12() {
runConformTest(
new String[] {
"Team221ltb12.java",
"\n" +
"public team class Team221ltb12 {\n" +
" protected team class Mid playedBy T221ltb12 {\n" +
" protected class Inner {\n" +
" protected void test() {\n" +
" doTest(Mid.this);\n" +
" }\n" +
" void doTest(T221ltb12 t) {\n" +
" t.print();\n" +
" }\n" +
" }\n" +
" protected void test() {\n" +
" new Inner().test();\n" +
" }\n" +
" }\n" +
" void test() {\n" +
" new Mid(new T221ltb12()).test();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb12().test();\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb12.java",
"\n" +
"public class T221ltb12 {\n" +
" void print() { System.out.print(\"OK\"); }\n" +
"}\n" +
" \n"
},
"OK");
}
// the enclosing nested team is lowered - via assignment
// 2.2.1-otjld-lowering-to-baseclass-13
public void test221_loweringToBaseclass13() {
runConformTest(
new String[] {
"Team221ltb13.java",
"\n" +
"public team class Team221ltb13 {\n" +
" protected team class Mid playedBy T221ltb13 {\n" +
" protected class Inner {\n" +
" protected void test() {\n" +
" T221ltb13 that = Mid.this;\n" +
" doTest(that);\n" +
" }\n" +
" void doTest(T221ltb13 t) {\n" +
" t.print();\n" +
" }\n" +
" }\n" +
" protected void test() {\n" +
" new Inner().test();\n" +
" }\n" +
" }\n" +
" void test() {\n" +
" new Mid(new T221ltb13()).test();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb13().test();\n" +
" }\n" +
"}\n" +
" \n",
"T221ltb13.java",
"\n" +
"public class T221ltb13 {\n" +
" void print() { System.out.print(\"OK\"); }\n" +
"}\n" +
" \n"
},
"OK");
}
// a foreach loop over an iterable needs to lower elements
public void test221_loweringToBaseclass14() {
runConformTest(
new String[] {
"Team221ltb14.java",
"import java.util.*;\n" +
"public team class Team221ltb14 {\n" +
" protected class R playedBy T221ltb14 {\n" +
" protected R() { base(); }\n" +
" }\n" +
" void test() {\n" +
" List<R> roles = new ArrayList<R>();\n" +
" roles.add(new R());\n" +
" for (T221ltb14 b : roles)\n" +
" b.foo();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new Team221ltb14().test();\n" +
" }\n" +
"}\n",
"T221ltb14.java",
"public class T221ltb14 {\n" +
" void foo() {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n",
},
"OK");
}
// a foreach loop over an array needs to lower elements
public void test221_loweringToBaseclass15() {
runConformTest(
new String[] {
"Team221ltb15.java",
"import java.util.*;\n" +
"public team class Team221ltb15 {\n" +
" protected class R playedBy T221ltb15 {\n" +
" protected R() { base(); }\n" +
" }\n" +
" void test() {\n" +
" R[] roles = new R[] {new R()};\n" +
" for (T221ltb15 b : roles)\n" +
" b.foo();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new Team221ltb15().test();\n" +
" }\n" +
"}\n",
"T221ltb15.java",
"public class T221ltb15 {\n" +
" void foo() {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n",
},
"OK");
}
// a foreach loop over an iterable needs to lower elements (role-of-role)
public void test221_loweringToBaseclass16() {
runConformTest(
new String[] {
"Team221ltb16_2.java",
"import java.util.*;\n" +
"public team class Team221ltb16_2 {\n" +
" final Team221ltb16_1 t = new Team221ltb16_1();\n" +
" protected class R playedBy R1<@t> {\n" +
" protected R() { base(); }\n" +
" }\n" +
" void test1() {\n" +
" R r = new R();\n" +
" test2(r);\n" +
" }\n" +
" void test2(R1<@t> b) {\n" +
" b.foo();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new Team221ltb16_2().test1();\n" +
" }\n" +
"}\n",
"Team221ltb16_1.java",
"public team class Team221ltb16_1 {\n" +
" public class R1 {\n" +
" public void foo() {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
" }\n" +
"}\n",
},
"OK");
}
// Bug 335628 - [compiler] lowering in array initializer
public void test221_loweringToBaseclass17 () {
runConformTest(
new String[] {
"Team221ltb17.java",
"public team class Team221ltb17 {\n" +
" protected class R playedBy T221ltb17 {\n" +
" protected R() { base(); }\n" +
" }\n" +
" void test() {\n" +
" R r = new R();\n" +
" T221ltb17[] bases = new T221ltb17[] { r };\n" +
" for (int i = 0; i < bases.length; i++) {\n" +
" bases[i].print();\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb17().test();\n" +
" }\n" +
"}\n",
"T221ltb17.java",
"public class T221ltb17 {\n" +
" public void print() {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n"
},
"OK");
}
// Bug 335628 - [compiler] lowering in array initializer
public void test221_loweringToBaseclass18 () {
runConformTest(
new String[] {
"Team221ltb18.java",
"public team class Team221ltb18 {\n" +
" protected class R playedBy T221ltb18 {\n" +
" protected R() { base(); }\n" +
" }\n" +
" void test() {\n" +
" R r = new R();\n" +
" T221ltb18[][] bases = new T221ltb18[][] { { r } };\n" +
" for (int i = 0; i < bases.length; i++)\n" +
" for (int k = 0; k < bases[i].length; k++)\n" +
" bases[i][k].print();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb18().test();\n" +
" }\n" +
"}\n",
"T221ltb18.java",
"public class T221ltb18 {\n" +
" public void print() {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n"
},
"OK");
}
// Bug 355253 - warnings regarding synthetic variables _OT$unlowerd$123
// syntactically known to be non-null
public void test221_loweringToBaseclass19 () {
Map options = getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
runConformTest(
true /* flushOutputDir*/,
new String[] {
"Team221ltb19.java",
"public team class Team221ltb19 {\n" +
" protected class R playedBy T221ltb19 {\n" +
" protected R() { base(); }\n" +
" protected void test() {\n" +
" T221ltb19.accept(this);\n" +
" }\n" +
" }\n" +
" T221ltb19 aBase;\n" +
" void test() {\n" +
" new R().test();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb19().test();\n" +
" }\n" +
"}\n",
"T221ltb19.java",
"public class T221ltb19 {\n" +
" public static void accept(T221ltb19 inst) {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n"
},
null, // libs
options,
"", // compiler log
"OK",
"",
JavacTestOptions.EclipseJustification.EclipseWarningConfiguredAsError);
}
// Bug 355253 - warnings regarding synthetic variables _OT$unlowerd$123
// known to be non-null by analysis
public void test221_loweringToBaseclass20 () {
Map options = getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
runConformTest(
true /* flushOutputDir*/,
new String[] {
"Team221ltb20.java",
"public team class Team221ltb20 {\n" +
" protected class R playedBy T221ltb20 {\n" +
" protected R() { base(); }\n" +
" protected void test() {\n" +
" R r = this;" +
" T221ltb20.accept(r);\n" +
" }\n" +
" }\n" +
" T221ltb20 aBase;\n" +
" void test() {\n" +
" new R().test();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team221ltb20().test();\n" +
" }\n" +
"}\n",
"T221ltb20.java",
"public class T221ltb20 {\n" +
" public static void accept(T221ltb20 inst) {\n" +
" System.out.println(\"OK\");\n" +
" }\n" +
"}\n"
},
null, // libs
options,
"", // compiler log
"OK",
"",
JavacTestOptions.EclipseJustification.EclipseWarningConfiguredAsError);
}
// a role is lowered to a class that is not its base class
// 2.2.2-otjld-lowering-to-non-baseclass-1
public void test222_loweringToNonBaseclass1() {
runNegativeTest(
new String[] {
"T222ltnb1_1.java",
"\n" +
"public class T222ltnb1_1 {}\n" +
" \n",
"T222ltnb1_2.java",
"\n" +
"public class T222ltnb1_2 {}\n" +
" \n",
"Team222ltnb1.java",
"\n" +
"public team class Team222ltnb1 {\n" +
"\n" +
" public class Role222ltnb1 playedBy T222ltnb1_1 {}\n" +
"\n" +
" public String getValue(T222ltnb1_1 as Role222ltnb1 obj) {\n" +
" T222ltnb1_2 o = obj;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a role is lowered to a class that is a subclass of its base class
// 2.2.2-otjld-lowering-to-non-baseclass-2
public void test222_loweringToNonBaseclass2() {
runNegativeTest(
new String[] {
"T222ltnb2_1.java",
"\n" +
"public class T222ltnb2_1 {}\n" +
" \n",
"T222ltnb2_2.java",
"\n" +
"public class T222ltnb2_2 extends T222ltnb2_1 {}\n" +
" \n",
"Team222ltnb2.java",
"\n" +
"public team class Team222ltnb2 {\n" +
"\n" +
" public class Role222ltnb2 playedBy T222ltnb2_1 {}\n" +
"\n" +
" public T222ltnb2_2 getBase(T222ltnb2_1 as Role222ltnb2 obj) {\n" +
" return obj;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// lowering of a role object for the same base object produces the same base class object
// 2.2.3-otjld-lowering-produces-same-object-1
public void test223_loweringProducesSameObject1() {
runConformTest(
new String[] {
"T223lpso1Main.java",
"\n" +
"public class T223lpso1Main {\n" +
" public static void main(String[] args) {\n" +
" Team223lpso1 t = new Team223lpso1();\n" +
" T223lpso1_2 o = new T223lpso1_2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T223lpso1_1.java",
"\n" +
"public interface T223lpso1_1 {}\n" +
" \n",
"T223lpso1_2.java",
"\n" +
"public class T223lpso1_2 implements T223lpso1_1 {}\n" +
" \n",
"Team223lpso1.java",
"\n" +
"public team class Team223lpso1 {\n" +
"\n" +
" public class Role223lpso1 playedBy T223lpso1_2 {}\n" +
"\n" +
" public String test(T223lpso1_2 as Role223lpso1 obj) {\n" +
" T223lpso1_1 loweredA = obj;\n" +
" T223lpso1_2 loweredB = obj;\n" +
"\n" +
" if ((loweredA == loweredB) &&\n" +
" loweredA.equals(loweredB) &&\n" +
" (loweredA.hashCode() == loweredB.hashCode())) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// lowering of a role object for the same base object produces the same base class object
// 2.2.3-otjld-lowering-produces-same-object-2
public void test223_loweringProducesSameObject2() {
runConformTest(
new String[] {
"T223lpso2Main.java",
"\n" +
"public class T223lpso2Main {\n" +
" public static void main(String[] args) {\n" +
" Team223lpso2 t = new Team223lpso2();\n" +
" T223lpso2_2 o = new T223lpso2_2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T223lpso2_1.java",
"\n" +
"public class T223lpso2_1 {}\n" +
" \n",
"T223lpso2_2.java",
"\n" +
"public class T223lpso2_2 extends T223lpso2_1 {}\n" +
" \n",
"Team223lpso2.java",
"\n" +
"public team class Team223lpso2 {\n" +
"\n" +
" public class Role223lpso2_1 playedBy T223lpso2_1 {}\n" +
" public class Role223lpso2_2 extends Role223lpso2_1 playedBy T223lpso2_2 {}\n" +
"\n" +
" private T223lpso2_1 liftAndLower1(T223lpso2_1 as Role223lpso2_1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" private T223lpso2_1 liftAndLower2(T223lpso2_2 as Role223lpso2_2 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T223lpso2_2 obj) {\n" +
" T223lpso2_1 loweredA = liftAndLower1(obj);\n" +
" T223lpso2_1 loweredB = liftAndLower2(obj);\n" +
"\n" +
" if ((loweredA == loweredB) &&\n" +
" loweredA.equals(loweredB) &&\n" +
" (loweredA.hashCode() == loweredB.hashCode())) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role cannot be compared to its lowered self
// 2.2.4-otjld-role-not-equal-to-baseobject-1
public void test224_roleNotEqualToBaseobject1() {
runNegativeTest(
new String[] {
"T224rnetb1.java",
"\n" +
"public class T224rnetb1 {}\n" +
" \n",
"Team224rnetb1.java",
"\n" +
"public team class Team224rnetb1 {\n" +
"\n" +
" public class Role224rnetb1 playedBy T224rnetb1 {}\n" +
"\n" +
" public boolean test(T224rnetb1 as Role224rnetb1 obj) {\n" +
" T224rnetb1 lowered = obj;\n" +
"\n" +
" return lowered == obj;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a role cannot be compared to its lowered self (instanceof)
// 2.2.4-otjld-role-not-equal-to-baseobject-1a
public void test224_roleNotEqualToBaseobject1a() {
runNegativeTest(
new String[] {
"T224rnetb1a.java",
"\n" +
"public class T224rnetb1a {}\n" +
" \n",
"Team224rnetb1a.java",
"\n" +
"public team class Team224rnetb1a {\n" +
"\n" +
" public class Role224rnetb1a playedBy T224rnetb1a {}\n" +
"\n" +
" public boolean test(T224rnetb1a as Role224rnetb1a obj) {\n" +
" return obj instanceof T224rnetb1a;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a role cannot be casted to its lowered self
// 2.2.4-otjld-role-not-equal-to-baseobject-1b
public void test224_roleNotEqualToBaseobject1b() {
runNegativeTest(
new String[] {
"T224rnetb1b.java",
"\n" +
"public class T224rnetb1b {}\n" +
" \n",
"Team224rnetb1b.java",
"\n" +
"public team class Team224rnetb1b {\n" +
"\n" +
" public class Role224rnetb1b playedBy T224rnetb1b {}\n" +
"\n" +
" public T224rnetb1b test(T224rnetb1b as Role224rnetb1b obj) {\n" +
" return (T224rnetb1b)obj;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a role is not equal to its lowered self
// 2.2.4-otjld-role-not-equal-to-baseobject-2
public void test224_roleNotEqualToBaseobject2() {
runConformTest(
new String[] {
"T224rnetb2Main.java",
"\n" +
"public class T224rnetb2Main {\n" +
" public static void main(String[] args) {\n" +
" Team224rnetb2 t = new Team224rnetb2();\n" +
" T224rnetb2 o = new T224rnetb2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T224rnetb2.java",
"\n" +
"public class T224rnetb2 {}\n" +
" \n",
"Team224rnetb2.java",
"\n" +
"public team class Team224rnetb2 {\n" +
"\n" +
" public class Role224rnetb2 playedBy T224rnetb2 {}\n" +
"\n" +
" public String test(T224rnetb2 as Role224rnetb2 obj) {\n" +
" T224rnetb2 lowered = obj;\n" +
"\n" +
" if (lowered.equals(obj) ||\n" +
" (lowered.hashCode() == obj.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is not equal to its lowered self
// 2.2.4-otjld-role-not-equal-to-baseobject-3
public void test224_roleNotEqualToBaseobject3() {
runConformTest(
new String[] {
"T224rnetb3Main.java",
"\n" +
"public class T224rnetb3Main {\n" +
" public static void main(String[] args) {\n" +
" Team224rnetb3_2 t = new Team224rnetb3_2();\n" +
" T224rnetb3_2 o = new T224rnetb3_2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T224rnetb3_1.java",
"\n" +
"public class T224rnetb3_1 {}\n" +
" \n",
"T224rnetb3_2.java",
"\n" +
"public class T224rnetb3_2 extends T224rnetb3_1 {}\n" +
" \n",
"Team224rnetb3_1.java",
"\n" +
"public team class Team224rnetb3_1 {\n" +
"\n" +
" protected class Role224rnetb3_1 playedBy T224rnetb3_1 {}\n" +
"}\n" +
" \n",
"Team224rnetb3_2.java",
"\n" +
"public team class Team224rnetb3_2 extends Team224rnetb3_1 {\n" +
"\n" +
" public class Role224rnetb3_2 extends Role224rnetb3_1 playedBy T224rnetb3_2 {}\n" +
"\n" +
" public String test(T224rnetb3_2 as Role224rnetb3_2 obj) {\n" +
" T224rnetb3_1 lowered = obj;\n" +
"\n" +
" if (lowered.equals(obj) ||\n" +
" (lowered.hashCode() == obj.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// the type of a lowering assignment expression is the base class
// 2.2.5-otjld-type-of-lowering-assignment-1
public void test225_typeOfLoweringAssignment1() {
runConformTest(
new String[] {
"T225tola1Main.java",
"\n" +
"public class T225tola1Main {\n" +
" public static void main(String[] args) {\n" +
" Team225tola1 t = new Team225tola1();\n" +
" T225tola1 o = new T225tola1();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T225tola1.java",
"\n" +
"public class T225tola1 {}\n" +
" \n",
"Team225tola1.java",
"\n" +
"public team class Team225tola1 {\n" +
"\n" +
" public class Role225tola1 playedBy T225tola1 {}\n" +
"\n" +
" public String test(T225tola1 as Role225tola1 obj) {\n" +
" T225tola1 lowered;\n" +
"\n" +
" if ((lowered = obj).getClass() == T225tola1.class) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// the type of a lowering assignment expression is the base class
// 2.2.5-otjld-type-of-lowering-assignment-2
public void test225_typeOfLoweringAssignment2() {
runConformTest(
new String[] {
"T225tola2Main.java",
"\n" +
"public class T225tola2Main {\n" +
" public static void main(String[] args) {\n" +
" Team225tola2_2 t = new Team225tola2_2();\n" +
" T225tola2_2 o = new T225tola2_2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T225tola2_1.java",
"\n" +
"public abstract class T225tola2_1 {}\n" +
" \n",
"T225tola2_2.java",
"\n" +
"public class T225tola2_2 extends T225tola2_1 {}\n" +
" \n",
"Team225tola2_1.java",
"\n" +
"public team class Team225tola2_1 {\n" +
"\n" +
" public class Role225tola2_1 playedBy T225tola2_1 {}\n" +
"}\n" +
" \n",
"Team225tola2_2.java",
"\n" +
"public team class Team225tola2_2 extends Team225tola2_1 {\n" +
"\n" +
" public class Role225tola2_2 extends Role225tola2_1 playedBy T225tola2_2 {}\n" +
"\n" +
" public String test(T225tola2_2 as Role225tola2_2 obj) {\n" +
" Role225tola2_1 r = obj;\n" +
" T225tola2_1 lowered;\n" +
"\n" +
" if ((lowered = r).getClass() == T225tola2_2.class) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base class object is lifted to a role via a method parameter
// 2.2.6-otjld-lifting-1
public void test226_lifting1() {
runConformTest(
new String[] {
"T226l1Main.java",
"\n" +
"public class T226l1Main {\n" +
" public static void main(String[] args) {\n" +
" Team226l1 t = new Team226l1();\n" +
" T226l1 o = new T226l1();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T226l1.java",
"\n" +
"public class T226l1 {\n" +
" public String getValue() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team226l1.java",
"\n" +
"public team class Team226l1 {\n" +
"\n" +
" public class Role226l1 playedBy T226l1 {\n" +
" public abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T226l1 as Role226l1 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base class object is lifted to a role via a final method parameter
// 2.2.6-otjld-lifting-2
public void test226_lifting2() {
runConformTest(
new String[] {
"T226l2Main.java",
"\n" +
"public class T226l2Main {\n" +
" public static void main(String[] args) {\n" +
" Team226l2 t = new Team226l2();\n" +
" T226l2_1 o = new T226l2_2();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T226l2_1.java",
"\n" +
"public abstract class T226l2_1 {\n" +
" public abstract String getValue();\n" +
"}\n" +
" \n",
"T226l2_2.java",
"\n" +
"public class T226l2_2 extends T226l2_1 {\n" +
" public String getValue() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team226l2.java",
"\n" +
"public team class Team226l2 {\n" +
"\n" +
" public class Role226l2_1 playedBy T226l2_1 {\n" +
" public abstract String getValue();\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role226l2_2 extends Role226l2_1 {}\n" +
"\n" +
" public String getValue(final T226l2_1 as Role226l2_2 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base class object is lifted to a role via a return statement
// 2.2.6-otjld-lifting-3
public void test226_lifting3() {
runConformTest(
new String[] {
"T226l3Main.java",
"\n" +
"public class T226l3Main {\n" +
" public static void main(String[] args) {\n" +
" Team226l3_2 t = new Team226l3_2();\n" +
" T226l3 o = new T226l3();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T226l3.java",
"\n" +
"public class T226l3 {\n" +
" public T226l3 getInstance() {\n" +
" return new T226l3();\n" +
" }\n" +
" public String getValue() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team226l3_1.java",
"\n" +
"public team class Team226l3_1 {\n" +
"\n" +
" public class Role226l3 playedBy T226l3 {\n" +
" public abstract String getValue();\n" +
" public abstract Role226l3 getInstance();\n" +
"\n" +
" String getValue() -> String getValue() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" Role226l3 getInstance() -> T226l3 getInstance();\n" +
" }\n" +
"}\n" +
" \n",
"Team226l3_2.java",
"\n" +
"public team class Team226l3_2 extends Team226l3_1 {\n" +
" public String getValue(T226l3 as Role226l3 obj) {\n" +
" return obj.getInstance().getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base class object is lifted to a role that it does not play
// 2.2.7-otjld-lifting-to-unplaying-role-1
public void test227_liftingToUnplayingRole1() {
runNegativeTest(
new String[] {
"T227ltur1_1.java",
"\n" +
"public class T227ltur1_1 {}\n" +
" \n",
"T227ltur1_2.java",
"\n" +
"public class T227ltur1_2 {}\n" +
" \n",
"Team227ltur1.java",
"\n" +
"public team class Team227ltur1 {\n" +
"\n" +
" public class Role227ltur1 playedBy T227ltur1_1 {}\n" +
"\n" +
" public void test (T227ltur1_2 as Role227ltur1 obj) {}\n" +
"}\n" +
" \n"
},
null);
}
// a base class object is lifted to a role that it does not play
// 2.2.7-otjld-lifting-to-unplaying-role-2
public void test227_liftingToUnplayingRole2() {
runNegativeTest(
new String[] {
"T227ltur2_1.java",
"\n" +
"public class T227ltur2_1 {}\n" +
" \n",
"T227ltur2_2.java",
"\n" +
"public class T227ltur2_2 extends T227ltur2_1 {}\n" +
" \n",
"Team227ltur2.java",
"\n" +
"public team class Team227ltur2 {\n" +
"\n" +
" public class Role227ltur2 playedBy T227ltur2_2 {}\n" +
"\n" +
" public void test (T227ltur2_1 as Role227ltur2 obj) {}\n" +
"}\n" +
" \n"
},
null);
}
// subsequent lifting of the same base class object produces the same role object
// 2.2.8-otjld-lifting-produces-same-role-1
public void test228_liftingProducesSameRole1() {
runConformTest(
new String[] {
"T228lpsr1Main.java",
"\n" +
"public class T228lpsr1Main {\n" +
" public static void main(String[] args) {\n" +
" Team228lpsr1_2 t = new Team228lpsr1_2();\n" +
" T228lpsr1_2 o = new T228lpsr1_2();\n" +
"\n" +
" System.out.print(t.test(o, o));\n" +
" }\n" +
"}\n" +
" \n",
"T228lpsr1_1.java",
"\n" +
"public class T228lpsr1_1 {}\n" +
" \n",
"T228lpsr1_2.java",
"\n" +
"public class T228lpsr1_2 extends T228lpsr1_1 {}\n" +
" \n",
"Team228lpsr1_1.java",
"\n" +
"public team class Team228lpsr1_1 {\n" +
" public class Role228lpsr1_1 playedBy T228lpsr1_1 {}\n" +
"}\n" +
" \n",
"Team228lpsr1_2.java",
"\n" +
"public team class Team228lpsr1_2 extends Team228lpsr1_1 {\n" +
"\n" +
" public class Role228lpsr1_2 extends Role228lpsr1_1 playedBy T228lpsr1_2 {}\n" +
"\n" +
" public String test(T228lpsr1_1 as Role228lpsr1_1 objA, T228lpsr1_2 as Role228lpsr1_2 objB) {\n" +
" if ((objA == objB) &&\n" +
" objA.equals(objB) &&\n" +
" (objA.hashCode() == objB.hashCode())) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// subsequent lifting of the same base class object produces the same role object
// 2.2.8-otjld-lifting-produces-same-role-2
public void test228_liftingProducesSameRole2() {
runConformTest(
new String[] {
"T228lpsr2Main.java",
"\n" +
"public class T228lpsr2Main {\n" +
" public static void main(String[] args) {\n" +
" Team228lpsr2 t = new Team228lpsr2();\n" +
" T228lpsr2_2 o = new T228lpsr2_2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T228lpsr2_1.java",
"\n" +
"public abstract class T228lpsr2_1 {}\n" +
" \n",
"T228lpsr2_2.java",
"\n" +
"public class T228lpsr2_2 extends T228lpsr2_1 {\n" +
" protected T228lpsr2_2 self() {\n" +
" return this;\n" +
" }\n" +
"}\n" +
" \n",
"Team228lpsr2.java",
"\n" +
"public team class Team228lpsr2 {\n" +
"\n" +
" public class Role228lpsr2_1 playedBy T228lpsr2_1 {}\n" +
" public class Role228lpsr2_2 playedBy T228lpsr2_2 {\n" +
" public abstract Role228lpsr2_1 toRole1();\n" +
" Role228lpsr2_1 toRole1() -> T228lpsr2_2 self();\n" +
" }\n" +
"\n" +
" private Role228lpsr2_1 toRole1(T228lpsr2_1 as Role228lpsr2_1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" private Role228lpsr2_2 toRole2(T228lpsr2_2 as Role228lpsr2_2 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T228lpsr2_2 obj) {\n" +
" Role228lpsr2_1 roleA = toRole1(obj);\n" +
" Role228lpsr2_1 roleB = toRole2(obj).toRole1();\n" +
"\n" +
" if ((roleA == roleB) &&\n" +
" roleA.equals(roleB) &&\n" +
" (roleA.hashCode() == roleB.hashCode())) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// lifting of the same base class object to roles related by implicit inheritance does produce different role objcts (as of their hashCode)
// 2.2.9-otjld-different-context-lifting-1
public void test229_differentContextLifting1() {
runConformTest(
new String[] {
"T229dcl1Main.java",
"\n" +
"public class T229dcl1Main {\n" +
" @SuppressWarnings(\"ambiguouslowering\") // equals could eat either: role or base\n" +
" public static void main(String[] args) {\n" +
" final Team229dcl1_1 t1 = new Team229dcl1_1();\n" +
" final Team229dcl1_2 t2 = new Team229dcl1_2();\n" +
" T229dcl1 o = new T229dcl1();\n" +
" Role229dcl1<@t1> r1 = t1.toRole(o);\n" +
" Role229dcl1<@t2> r2 = t2.toRole(o);\n" +
"\n" +
" if (/* statically wrong; (r1 == r2) || */\n" +
" r1.equals(r2) ||\n" +
" (r1.hashCode() == r2.hashCode())) {\n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
" else\n" +
" {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"T229dcl1.java",
"\n" +
"public class T229dcl1 {}\n" +
" \n",
"Team229dcl1_1.java",
"\n" +
"public team class Team229dcl1_1 {\n" +
" public class Role229dcl1 playedBy T229dcl1 {}\n" +
"\n" +
" public Role229dcl1 toRole(T229dcl1 as Role229dcl1 obj) {\n" +
" return obj;\n" +
" }\n" +
"}\n" +
" \n",
"Team229dcl1_2.java",
"\n" +
"public team class Team229dcl1_2 extends Team229dcl1_1 {\n" +
"}\n" +
" \n"
},
"OK");
}
// lifting of the same base class object to unrelated roles produces different role objcts
// 2.2.9-otjld-different-context-lifting-2
public void test229_differentContextLifting2() {
runConformTest(
new String[] {
"T229lpsr2Main.java",
"\n" +
"public class T229lpsr2Main {\n" +
" public static void main(String[] args) {\n" +
" Team229dcl2 t = new Team229dcl2();\n" +
" T229dcl2 o = new T229dcl2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T229dcl2.java",
"\n" +
"public class T229dcl2 {}\n" +
" \n",
"Team229dcl2.java",
"\n" +
"public team class Team229dcl2 {\n" +
" public class Role229dcl2_1 playedBy T229dcl2 {}\n" +
" public class Role229dcl2_2 playedBy T229dcl2 {}\n" +
"\n" +
" private Role229dcl2_1 toRole1(T229dcl2 as Role229dcl2_1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" private Role229dcl2_2 toRole2(T229dcl2 as Role229dcl2_2 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T229dcl2 obj) {\n" +
" Role229dcl2_1 r1 = toRole1(obj);\n" +
" Role229dcl2_2 r2 = toRole2(obj);\n" +
"\n" +
" if (r1.equals(r2) ||\n" +
" (r1.hashCode() == r2.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// lifting of the same base class object to related roles produces the same role objct
// 2.2.9-otjld-different-context-lifting-3
public void test229_differentContextLifting3() {
runConformTest(
new String[] {
"T229lpsr3Main.java",
"\n" +
"public class T229lpsr3Main {\n" +
" public static void main(String[] args) {\n" +
" Team229dcl3 t = new Team229dcl3();\n" +
" T229dcl3 o = new T229dcl3();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T229dcl3.java",
"\n" +
"public class T229dcl3 {}\n" +
" \n",
"Team229dcl3.java",
"\n" +
"public team class Team229dcl3 {\n" +
" public class Role229dcl3_1 playedBy T229dcl3 {}\n" +
" public class Role229dcl3_2 extends Role229dcl3_1 {}\n" +
"\n" +
" private Role229dcl3_1 toRole1(T229dcl3 as Role229dcl3_1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" private Role229dcl3_2 toRole2(T229dcl3 as Role229dcl3_2 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T229dcl3 obj) {\n" +
" Role229dcl3_1 r1 = toRole1(obj);\n" +
" Role229dcl3_2 r2 = toRole2(obj);\n" +
"\n" +
" if (r1 == r2) {\n" +
" return \"OK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// compare instances of different teams
// 2.2.9-otjld-different-context-lifting-5
public void test229_differentContextLifting5() {
runConformTest(
new String[] {
"T229lpsr1Main.java",
"\n" +
"public class T229lpsr1Main {\n" +
" @SuppressWarnings(\"ambiguouslowering\") // equals could eat either: role or base\n" +
" public static void main(String[] args) {\n" +
" final Team229dcl5_1 t1 = new Team229dcl5_1();\n" +
" final Team229dcl5_2 t2 = new Team229dcl5_2();\n" +
" T229dcl5 o = new T229dcl5();\n" +
" Role229dcl5<@t1> r1 = t1.toRole(o);\n" +
" Role229dcl5<@t2> r2 = t2.toRole(o);\n" +
"\n" +
" if ((r1 == r2) || \n" +
" r1.equals(r2) ||\n" +
" (r1.hashCode() == r2.hashCode())) {\n" +
" System.out.print(\"NOTOK\");\n" +
" }\n" +
" else\n" +
" {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"T229dcl5.java",
"\n" +
"public class T229dcl5 {}\n" +
" \n",
"Team229dcl5_1.java",
"\n" +
"public team class Team229dcl5_1 {\n" +
" public class Role229dcl5 playedBy T229dcl5 {}\n" +
"\n" +
" public Role229dcl5 toRole(T229dcl5 as Role229dcl5 obj) {\n" +
" return obj;\n" +
" }\n" +
"}\n" +
" \n",
"Team229dcl5_2.java",
"\n" +
"public team class Team229dcl5_2 extends Team229dcl5_1 {\n" +
"}\n" +
" \n"
},
"OK");
}
// a base object is not equal to its lifted self
// 2.2.10-otjld-baseobject-not-equal-to-roleobject-1
public void test2210_baseobjectNotEqualToRoleobject1() {
runConformTest(
new String[] {
"T2210bnetr1Main.java",
"\n" +
"public class T2210bnetr1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2210bnetr1 t = new Team2210bnetr1();\n" +
" T2210bnetr1 o = new T2210bnetr1();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2210bnetr1.java",
"\n" +
"public class T2210bnetr1 {}\n" +
" \n",
"Team2210bnetr1.java",
"\n" +
"public team class Team2210bnetr1 {\n" +
" public class Role2210bnetr1 playedBy T2210bnetr1 {}\n" +
"\n" +
" private Role2210bnetr1 toRole(T2210bnetr1 as Role2210bnetr1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T2210bnetr1 obj) {\n" +
" Role2210bnetr1 r = toRole(obj);\n" +
"\n" +
" if (r.equals(obj) ||\n" +
" (r.hashCode() == obj.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base object is not equal to its lifted self
// 2.2.10-otjld-baseobject-not-equal-to-roleobject-2
public void test2210_baseobjectNotEqualToRoleobject2() {
runConformTest(
new String[] {
"T2210bnetr2Main.java",
"\n" +
"public class T2210bnetr2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2210bnetr2 t = new Team2210bnetr2();\n" +
" T2210bnetr2 o = new T2210bnetr2();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2210bnetr2.java",
"\n" +
"public class T2210bnetr2 {}\n" +
" \n",
"Team2210bnetr2.java",
"\n" +
"public team class Team2210bnetr2 {\n" +
" public class Role2210bnetr2_1 playedBy T2210bnetr2 {}\n" +
" public class Role2210bnetr2_2 extends Role2210bnetr2_1 {}\n" +
"\n" +
" private Role2210bnetr2_2 toRole(T2210bnetr2 as Role2210bnetr2_2 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T2210bnetr2 obj) {\n" +
" Role2210bnetr2_2 r = toRole(obj);\n" +
"\n" +
" if (r.equals(obj) ||\n" +
" (r.hashCode() == obj.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base object is not equal to its lifted self
// 2.2.10-otjld-baseobject-not-equal-to-roleobject-3
public void test2210_baseobjectNotEqualToRoleobject3() {
runConformTest(
new String[] {
"T2210bnetr3Main.java",
"\n" +
"public class T2210bnetr3Main {\n" +
" public static void main(String[] args) {\n" +
" Team2210bnetr3_2 t = new Team2210bnetr3_2();\n" +
" T2210bnetr3 o = new T2210bnetr3();\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2210bnetr3.java",
"\n" +
"public class T2210bnetr3 {}\n" +
" \n",
"Team2210bnetr3_1.java",
"\n" +
"public team class Team2210bnetr3_1 {\n" +
" public class Role2210bnetr3 playedBy T2210bnetr3 {}\n" +
"}\n" +
" \n",
"Team2210bnetr3_2.java",
"\n" +
"public team class Team2210bnetr3_2 extends Team2210bnetr3_1 {\n" +
" private Role2210bnetr3 toRole(T2210bnetr3 as Role2210bnetr3 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test(T2210bnetr3 obj) {\n" +
" Role2210bnetr3 r = toRole(obj);\n" +
"\n" +
" if (r.equals(obj) ||\n" +
" (r.hashCode() == obj.hashCode())) {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a base object is tried to lift via an assignment expression
// 2.2.11-otjld-lifting-via-assignment-1
public void test2211_liftingViaAssignment1() {
runNegativeTest(
new String[] {
"T2211lva1.java",
"\n" +
"public class T2211lva1 {}\n" +
" \n",
"Team2211lva1.java",
"\n" +
"public team class Team2211lva1 {\n" +
" public class Role2211lva1 playedBy T2211lva1 {}\n" +
"\n" +
" public void test(T2211lva1 obj) {\n" +
" Role2211lva1 r = obj;\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a base object is tried to lift via an assignment expression
// 2.2.11-otjld-lifting-via-assignment-2
public void test2211_liftingViaAssignment2() {
runNegativeTest(
new String[] {
"T2211lva2.java",
"\n" +
"public class T2211lva2 {}\n" +
" \n",
"Team2211lva2.java",
"\n" +
"public team class Team2211lva2 {\n" +
" public class Role2211lva2_1 playedBy T2211lva2 {}\n" +
" public class Role2211lva2_2 extends Role2211lva2_1 {}\n" +
"\n" +
" private Role2211lva2_2 r = new T2211lva2();\n" +
"}\n" +
" \n"
},
null);
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-1a
public void test2212_arrayLoweringToBaseclass1a() {
runConformTest(
new String[] {
"T2212altb1aMain.java",
"\n" +
"public class T2212altb1aMain {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb1a t = new Team2212altb1a();\n" +
" T2212altb1a o = new T2212altb1a();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb1a[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb1a.java",
"\n" +
"public class T2212altb1a {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb1a.java",
"\n" +
"public team class Team2212altb1a {\n" +
"\n" +
" public class Role2212altb1a playedBy T2212altb1a {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" // alternate (newer) syntax\n" +
" public String getValue(T2212altb1a[] as Role2212altb1a[] objs) {\n" +
" T2212altb1a[] o = objs;\n" +
"\n" +
" return o[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-1
public void test2212_arrayLoweringToBaseclass1() {
runConformTest(
new String[] {
"T2212altb1Main.java",
"\n" +
"public class T2212altb1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb1 t = new Team2212altb1();\n" +
" T2212altb1 o = new T2212altb1();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb1[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb1.java",
"\n" +
"public class T2212altb1 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb1.java",
"\n" +
"public team class Team2212altb1 {\n" +
"\n" +
" public class Role2212altb1 playedBy T2212altb1 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T2212altb1 as Role2212altb1 objs[]) {\n" +
" T2212altb1[] o = objs;\n" +
"\n" +
" return o[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-2
public void test2212_arrayLoweringToBaseclass2() {
runConformTest(
new String[] {
"T2212tb2Main.java",
"\n" +
"public class T2212tb2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb2 t = new Team2212altb2();\n" +
" T2212altb2 o = new T2212altb2();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb2[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb2.java",
"\n" +
"public class T2212altb2 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb2.java",
"\n" +
"public team class Team2212altb2 {\n" +
"\n" +
" public class Role2212altb2 playedBy T2212altb2 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T2212altb2 as Role2212altb2 objs[]) {\n" +
" final T2212altb2[] o = objs;\n" +
"\n" +
" return o[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-3
public void test2212_arrayLoweringToBaseclass3() {
runConformTest(
new String[] {
"T2212tb3Main.java",
"\n" +
"public class T2212tb3Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb3 t = new Team2212altb3();\n" +
" T2212altb3_2 o = new T2212altb3_2();\n" +
"\n" +
" t.setValues(new T2212altb3_2[]{o});\n" +
" System.out.print(t);\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb3_1.java",
"\n" +
"public class T2212altb3_1 {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb3_2.java",
"\n" +
"public class T2212altb3_2 extends T2212altb3_1 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb3.java",
"\n" +
"public team class Team2212altb3 {\n" +
" private T2212altb3_1[] o;\n" +
"\n" +
" public class Role2212altb3 playedBy T2212altb3_2 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public void setValues(T2212altb3_2 as Role2212altb3 objs[]) {\n" +
" o = objs;\n" +
" }\n" +
"\n" +
" public String toString()\n" +
" {\n" +
" return o[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-4
public void test2212_arrayLoweringToBaseclass4() {
runConformTest(
new String[] {
"T2212tb4Main.java",
"\n" +
"public class T2212tb4Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb4_2 t = new Team2212altb4_2();\n" +
" T2212altb4 o = new T2212altb4();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb4[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb4.java",
"\n" +
"public class T2212altb4 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb4_1.java",
"\n" +
"public team class Team2212altb4_1 {\n" +
"\n" +
" public class Role2212altb4 playedBy T2212altb4 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb4_2.java",
"\n" +
"public team class Team2212altb4_2 extends Team2212altb4_1 {\n" +
"\n" +
" public String getValue(T2212altb4 as Role2212altb4 objs[]) {\n" +
" return getValueInternal(objs);\n" +
" }\n" +
"\n" +
" private String getValueInternal(T2212altb4[] objs) {\n" +
" return objs[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-5
public void test2212_arrayLoweringToBaseclass5() {
runConformTest(
new String[] {
"T2212tb5Main.java",
"\n" +
"public class T2212tb5Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb5_2 t = new Team2212altb5_2();\n" +
" T2212altb5 o = new T2212altb5();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb5[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb5.java",
"\n" +
"public class T2212altb5 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb5_1.java",
"\n" +
"public team class Team2212altb5_1 {\n" +
"\n" +
" public class Role2212altb5_1 playedBy T2212altb5 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb5_2.java",
"\n" +
"public team class Team2212altb5_2 extends Team2212altb5_1 {\n" +
"\n" +
" public class Role2212altb5_2 extends Role2212altb5_1 {}\n" +
"\n" +
" public String getValue(T2212altb5 as Role2212altb5_2 objs[]) {\n" +
" return getValueInternal(objs);\n" +
" }\n" +
"\n" +
" private String getValueInternal(final T2212altb5[] objs) {\n" +
" return objs[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by
// 2.2.12-otjld-array-lowering-to-baseclass-6
public void test2212_arrayLoweringToBaseclass6() {
runConformTest(
new String[] {
"T2212tb6Main.java",
"\n" +
"public class T2212tb6Main {\n" +
" public static void main(String[] args) {\n" +
" Team2212altb6 t = new Team2212altb6();\n" +
" T2212altb6 o = new T2212altb6();\n" +
"\n" +
" System.out.print(t.getValue(new T2212altb6[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb6.java",
"\n" +
"public class T2212altb6 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2212altb6.java",
"\n" +
"public team class Team2212altb6 {\n" +
"\n" +
" public class Role2212altb6 playedBy T2212altb6 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"NOTOK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String getValue(T2212altb6 as Role2212altb6 objs[]) {\n" +
" return convert(objs)[0].toString();\n" +
" }\n" +
"\n" +
" private T2212altb6[] convert(Role2212altb6[] objs) {\n" +
" return objs;\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is lowered to an array of the base class that it is played by -- base call
// 2.2.12-otjld-array-lowering-to-baseclass-7
public void test2212_arrayLoweringToBaseclass7() {
runConformTest(
new String[] {
"Team2212altb7.java",
"\n" +
"public team class Team2212altb7 {\n" +
" protected class R playedBy T2212altb7 {\n" +
" callin void intercept(R[] rs) {\n" +
" rs[0].print();\n" +
" base.intercept(rs);\n" +
" }\n" +
" void intercept(R[] rs) <- replace void test(T2212altb7[] ts) \n" +
" with { rs <- ts }\n" +
" void print() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2212altb7().activate();\n" +
" T2212altb7 b = new T2212altb7();\n" +
" b.test(new T2212altb7[]{b});\n" +
" }\n" +
"}\n" +
" \n",
"T2212altb7.java",
"\n" +
"public class T2212altb7 {\n" +
" void test(T2212altb7[] ts) {\n" +
" ts[0].print();\n" +
" }\n" +
" void print() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
"} \n" +
" \n"
},
"OK");
}
// Bug 329374 - Implicit Lowering of a Role Array as return results in compiler error
public void test2212_arrayLoweringToBaseclass8() {
compileOrder = new String[][] {{"T2212altb8_1.java", "T2212altb8_2.java", "Team2212altb8.java"}, {"T2212altb8Main.java"}};
runConformTest(
new String[] {
"T2212altb8Main.java",
"public class T2212altb8Main {\n"+
" public static void main(String[] args){\n"+
" Team2212altb8 t = new Team2212altb8();\n"+
" T2212altb8_2 b = new T2212altb8_2();\n"+
" T2212altb8_1[] as = t.getAs(b);\n"+
" }\n" +
"}\n",
"T2212altb8_1.java",
"public class T2212altb8_1 {}\n",
"T2212altb8_2.java",
"public class T2212altb8_2 {}\n",
"Team2212altb8.java",
"public team class Team2212altb8 {\n" +
" protected class RoleA playedBy T2212altb8_1 {\n" +
" }\n" +
" protected class RoleB playedBy T2212altb8_2 {\n" +
" protected RoleA[] getAs(){\n" +
" return new RoleA[0];\n" +
" }\n" +
" }\n" +
" public RoleA[] getAs(T2212altb8_2 as RoleB rb) {\n" +
" return rb.getAs();\n" +
" }\n" +
"}\n"
});
}
public void test2212_arrayLoweringToBaseclass9() {
runConformTest(
new String[] {
"Team2214altb9.java",
"import java.util.*;\n" +
"public team class Team2214altb9 {\n" +
" protected class R playedBy T2214altb9 { protected R() { base(); } }\n" +
" T2214altb9[] toBaseArray(List<R> roles) {\n" +
" return roles.toArray(new R[roles.size()]);\n" +
" }\n" +
" void test() {\n" +
" List<R> roles = new ArrayList<R>();\n" +
" roles.add(new R());\n" +
" T2214altb9[] bases = toBaseArray(roles);\n" +
" System.out.println(bases[0].getClass().getName());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2214altb9().test();\n" +
" }\n" +
"}\n",
"T2214altb9.java",
"public class T2214altb9 {\n" +
"}\n"
},
"T2214altb9");
}
public void test2212_arrayLowering_inConditionalExpression1() {
runConformTest(
new String[] {
"Team2214alice1.java",
"import java.util.*;\n" +
"public team class Team2214alice1 {\n" +
" protected class R playedBy T2214alice1 { protected R() { base(); } }\n" +
" T2214alice1[] toBaseArray(List<R> roles) {\n" +
" return roles != null ? roles.toArray(new R[roles.size()]) : new R[0];\n" +
" }\n" +
" void test() {\n" +
" List<R> roles = new ArrayList<R>();\n" +
" roles.add(new R());\n" +
" T2214alice1[] bases = toBaseArray(roles);\n" +
" System.out.println(bases[0].getClass().getName());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2214alice1().test();\n" +
" }\n" +
"}\n",
"T2214alice1.java",
"public class T2214alice1 {\n" +
"}\n"
},
"T2214alice1");
}
// lowering of a role object array for the same base objects produces the an equal object array
// 2.2.14-otjld-array-lowering-produces-equal-object-1
public void test2214_arrayLoweringProducesEqualObject1() {
runConformTest(
new String[] {
"T2214alpeo1Main.java",
"\n" +
"public class T2214alpeo1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2214alpeo1 t = new Team2214alpeo1();\n" +
" T2214alpeo1 o = new T2214alpeo1();\n" +
"\n" +
" System.out.print(t.test(new T2214alpeo1[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2214alpeo1.java",
"\n" +
"public class T2214alpeo1 {}\n" +
" \n",
"Team2214alpeo1.java",
"\n" +
"public team class Team2214alpeo1 {\n" +
"\n" +
" public class Role2214alpeo1 playedBy T2214alpeo1 {}\n" +
"\n" +
" public String test(T2214alpeo1 as Role2214alpeo1 obj[]) {\n" +
" T2214alpeo1[] loweredA = obj;\n" +
" T2214alpeo1[] loweredB = obj;\n" +
"\n" +
" if (loweredA == loweredB) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (!java.util.Arrays.equals(loweredA, loweredB)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (loweredA.hashCode() == loweredB.hashCode()) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// lowering of a role object array for the same base objects produces an equal object array
// 2.2.14-otjld-array-lowering-produces-equal-object-2
public void test2214_arrayLoweringProducesEqualObject2() {
runConformTest(
new String[] {
"T2214alpeo2Main.java",
"\n" +
"public class T2214alpeo2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2214alpeo2_2 t = new Team2214alpeo2_2();\n" +
" T2214alpeo2_2 o = new T2214alpeo2_2();\n" +
"\n" +
" System.out.print(t.test(new T2214alpeo2_2[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2214alpeo2_1.java",
"\n" +
"public class T2214alpeo2_1 {}\n" +
" \n",
"T2214alpeo2_2.java",
"\n" +
"public class T2214alpeo2_2 extends T2214alpeo2_1 {}\n" +
" \n",
"Team2214alpeo2_1.java",
"\n" +
"public team class Team2214alpeo2_1 {\n" +
"\n" +
" public class Role2214alpeo2_1 playedBy T2214alpeo2_1 {}\n" +
"}\n" +
" \n",
"Team2214alpeo2_2.java",
"\n" +
"public team class Team2214alpeo2_2 extends Team2214alpeo2_1 {\n" +
"\n" +
" public class Role2214alpeo2_2 extends Role2214alpeo2_1 playedBy T2214alpeo2_2 {}\n" +
"\n" +
" public String test(T2214alpeo2_2 as Role2214alpeo2_2 obj[]) {\n" +
" T2214alpeo2_1[] loweredA = obj;\n" +
" T2214alpeo2_2[] loweredB = obj;\n" +
"\n" +
" if (loweredA == loweredB) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (!java.util.Arrays.equals(loweredA, loweredB)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (loweredA.hashCode() == loweredB.hashCode()) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects is lifted to a role array
// 2.2.15-otjld-array-lifting-1
public void test2215_arrayLifting1() {
runConformTest(
new String[] {
"T2215al1Main.java",
"\n" +
"public class T2215al1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2215al1 t = new Team2215al1();\n" +
" T2215al1 o = new T2215al1();\n" +
"\n" +
" System.out.print(t.test(new T2215al1[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2215al1.java",
"\n" +
"public class T2215al1 {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2215al1.java",
"\n" +
"public team class Team2215al1 {\n" +
"\n" +
" public class Role2215al1 playedBy T2215al1 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String test(T2215al1 as Role2215al1 obj[]) {\n" +
" return obj[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects is lifted to a role array
// 2.2.15-otjld-array-lifting-2
public void test2215_arrayLifting2() {
runConformTest(
new String[] {
"T2215al2Main.java",
"\n" +
"public class T2215al2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2215al2_2 t = new Team2215al2_2();\n" +
" T2215al2 o = new T2215al2();\n" +
"\n" +
" System.out.print(t.test(new T2215al2[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2215al2.java",
"\n" +
"public class T2215al2 {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2215al2_1.java",
"\n" +
"public team class Team2215al2_1 {\n" +
" public class Role2215al2_1 playedBy T2215al2 {}\n" +
"}\n" +
" \n",
"Team2215al2_2.java",
"\n" +
"public team class Team2215al2_2 extends Team2215al2_1 {\n" +
"\n" +
" public class Role2215al2_2 extends Role2215al2_1 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String test(T2215al2 as Role2215al2_2 obj[]) {\n" +
" return obj[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects is lifted to a role array
// 2.2.15-otjld-array-lifting-3
public void test2215_arrayLifting3() {
runConformTest(
new String[] {
"T2215al3Main.java",
"\n" +
"public class T2215al3Main {\n" +
" public static void main(String[] args) {\n" +
" Team2215al3 t = new Team2215al3();\n" +
" T2215al3 o = new T2215al3();\n" +
"\n" +
" System.out.print(t.test(new T2215al3[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2215al3.java",
"\n" +
"public class T2215al3 {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2215al3.java",
"\n" +
"public team class Team2215al3 {\n" +
" public class Role2215al3_1 playedBy T2215al3 {}\n" +
"\n" +
" public class Role2215al3_2 playedBy T2215al3 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String test(T2215al3 as Role2215al3_1 obj[]) {\n" +
" return getValue(obj);\n" +
" }\n" +
"\n" +
" private String getValue(T2215al3 as Role2215al3_2 obj[]) {\n" +
" return obj[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects (inner class) is lifted to a role array
// 2.2.15-otjld-array-lifting-4
public void test2215_arrayLifting4() {
runConformTest(
new String[] {
"T2215al4Main.java",
"\n" +
"public class T2215al4Main {\n" +
" public static void main(String[] args) {\n" +
" Team2215al4 t = new Team2215al4();\n" +
" T2215al4 o = new T2215al4();\n" +
" T2215al4.Inner i= o.new Inner();\n" +
"\n" +
" System.out.print(t.test(new T2215al4.Inner[]{i}));\n" +
" }\n" +
"}\n" +
" \n",
"T2215al4.java",
"\n" +
"public class T2215al4 {\n" +
" public class Inner {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"Team2215al4.java",
"\n" +
"public team class Team2215al4 {\n" +
"\n" +
" public class Role2215al4 playedBy T2215al4.Inner {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
"\n" +
" public String test(T2215al4.Inner as Role2215al4 obj[]) {\n" +
" return obj[0].toString();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects is lifted to an array of nested roles
public void test2215_arrayLifting5() {
runConformTest(
new String[] {
"T2215al5Main.java",
"\n" +
"public class T2215al5Main {\n" +
" public static void main(String[] args) {\n" +
" final Team2215al5 t = new Team2215al5();\n" +
" T2215al5 o = new T2215al5();\n" +
" Mid<@t> mid = new Mid<@t>();\n" +
" System.out.print(mid.test(new T2215al5[]{o}));\n" +
" }\n" +
"}\n" +
" \n",
"T2215al5.java",
"\n" +
"public class T2215al5 {\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n" +
" \n",
"Team2215al5.java",
"\n" +
"public team class Team2215al5 {\n" +
" public team class Mid {\n" +
" public class Role2215al5 playedBy T2215al5 {\n" +
" public abstract String toString();\n" +
" String toString() -> String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
" public String test(T2215al5 as Role2215al5 obj[]) {\n" +
" return obj[0].toString();\n" +
" }\n" +
" }\n" +
"\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base class objects is lifted to an array of nested roles - location: callout return
// witness for broken bytecode: ifc-part of array lifter was not found, but silently generated a problem method for the caller
public void test2215_arrayLifting6() {
runConformTest(
new String[] {
"T2215al6Main.java",
"\n" +
"public class T2215al6Main {\n" +
" public static void main(String[] args) {\n" +
" final Team2215al6 t = new Team2215al6();\n" +
" T2215al6_2 o = new T2215al6_2();\n" +
" t.test(o);\n" +
" }\n" +
"}\n",
"T2215al6_1.java",
"\n" +
"public class T2215al6_1 {\n" +
" @Override\n" +
" public String toString() {\n" +
" return \"NOTOK\";\n" +
" }\n" +
"}\n",
"T2215al6_2.java",
"\n" +
"public class T2215al6_2 {\n" +
" public T2215al6_1[] getOthers() { return new T2215al6_1[]{ new T2215al6_1()}; }\n" +
"}\n",
"Team2215al6.java",
"\n" +
"public team class Team2215al6 {\n" +
" public team class Mid playedBy T2215al6_2 {\n" +
" public class Role2215al6 playedBy T2215al6_1 {\n" +
" String toString() => String toString() with {\n" +
" result <- \"OK\"\n" +
" }\n" +
" }\n" +
" Role2215al6[] getOthers() -> T2215al6_1[] getOthers();\n" +
" protected void test() {\n" +
" System.out.print(getOthers()[0].toString());\n" +
" }\n" +
" }\n" +
" public void test(T2215al6_2 as Mid m) {\n" +
" m.test();\n" +
" }\n" +
"}\n"
},
"OK");
}
// an array of base class objects is lifted to an array of nested roles - location: callin return
public void test2215_arrayLifting7() {
runConformTest(
new String[] {
"T2215al7Main.java",
"\n" +
"public class T2215al7Main {\n" +
" public static void main(String[] args) {\n" +
" final Team2215al7 t = new Team2215al7();\n" +
" t.activate();\n" +
" T2215al7_2 o = new T2215al7_2();\n" +
" System.out.print(o.getOthers()[0]);\n" +
" }\n" +
"}\n",
"T2215al7_1.java",
"\n" +
"public class T2215al7_1 {\n" +
" @Override\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n",
"T2215al7_2.java",
"\n" +
"public class T2215al7_2 {\n" +
" public T2215al7_1[] getOthers() { return new T2215al7_1[0]; }\n" +
"}\n",
"Team2215al7.java",
"\n" +
"public team class Team2215al7 {\n" +
" public team class Mid playedBy T2215al7_2 {\n" +
" public class Role2215al7 playedBy T2215al7_1 {\n" +
" protected Role2215al7() {\n" +
" base();\n" +
" }\n" +
" }\n" +
" Role2215al7[] getOthers() <- replace T2215al7_1[] getOthers();\n" +
" callin Role2215al7[] getOthers() {\n" +
" System.out.print(base.getOthers().length);\n" +
" return new Role2215al7[]{ new Role2215al7() };\n" +
" }\n" +
" }\n" +
"}\n"
},
"0OK");
}
// an array of base class objects is lifted to an array of a role class that is not played by that base class
// 2.2.16-otjld-array-lifting-to-unrelated-role-1
public void test2216_arrayLiftingToUnrelatedRole1() {
runNegativeTest(
new String[] {
"T2216altur1.java",
"\n" +
"public class T2216altur1 {}\n" +
" \n",
"Team2216altur1.java",
"\n" +
"public team class Team2216altur1 {\n" +
" public class Role2216altur1 {}\n" +
"\n" +
" public void test(T2216altur1 as Role2216altur1 obj[]) {}\n" +
"}\n" +
" \n"
},
null);
}
// an array of base class objects is lifted to an array of a role class that is not played by that base class
// 2.2.16-otjld-array-lifting-to-unrelated-role-2
public void test2216_arrayLiftingToUnrelatedRole2() {
runNegativeTest(
new String[] {
"p1/T2216altur2.java",
"\n" +
"package p1;\n" +
"public class T2216altur2 {}\n" +
" \n",
"p1/Team2216altur2_1.java",
"\n" +
"package p1;\n" +
"public team class Team2216altur2_1 {\n" +
" // shadows the class within this package\n" +
" protected class T2216altur2 {}\n" +
" public class Role2216altur2 playedBy T2216altur2 {}\n" +
"}\n" +
" \n",
"p2/Team2216altur2_2.java",
"\n" +
"package p2;\n" +
"public team class Team2216altur2_2 extends p1.Team2216altur2_1 {\n" +
" public void test(T2216altur2 as Role2216altur2 obj[]) {}\n" +
"}\n" +
" \n"
},
null);
}
// the lifting of an array of base objects produces equal role object arrays (but not the same)
// 2.2.17-otjld-array-lifting-produces-equal-object-1
public void test2217_arrayLiftingProducesEqualObject1() {
runConformTest(
new String[] {
"T2217alpeo1Main.java",
"\n" +
"public class T2217alpeo1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2217alpeo1 t = new Team2217alpeo1();\n" +
" T2217alpeo1 o = new T2217alpeo1();\n" +
"\n" +
" System.out.print(t.test(o, o));\n" +
" }\n" +
"}\n" +
" \n",
"T2217alpeo1.java",
"\n" +
"public class T2217alpeo1 {\n" +
" public T2217alpeo1[] getObjects() {\n" +
" return new T2217alpeo1[]{this};\n" +
" }\n" +
"}\n" +
" \n",
"Team2217alpeo1.java",
"\n" +
"public team class Team2217alpeo1 {\n" +
" public class Role2217alpeo1_1 playedBy T2217alpeo1 {}\n" +
"\n" +
" public class Role2217alpeo1_2 playedBy T2217alpeo1 {\n" +
" public abstract Role2217alpeo1_1[] getObjects();\n" +
" Role2217alpeo1_1[] getObjects() -> T2217alpeo1[] getObjects();\n" +
" }\n" +
"\n" +
" public String test(T2217alpeo1 as Role2217alpeo1_2 objA, T2217alpeo1 as Role2217alpeo1_2 objB) {\n" +
" Role2217alpeo1_1[] liftedA = objA.getObjects();\n" +
" Role2217alpeo1_1[] liftedB = objB.getObjects();\n" +
"\n" +
" if (liftedA == liftedB) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (!liftedA.equals(liftedB)) {\n" +
" if (liftedA.length != liftedB.length)\n" +
" return \"NOTOK 2a\";\n" +
" for (int i=0; i<liftedA.length; i++){\n" +
" if (liftedA[i] != liftedB[i])\n" +
" return \"NOTOK 2b\";\n" +
" }\n" +
" return \"OK\";\n" +
" }\n" +
" else if (liftedA.hashCode() != liftedB.hashCode()) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// the lifting of an array of base objects produces equal role object arrays (but not the same)
// 2.2.17-otjld-array-lifting-produces-equal-object-2
public void test2217_arrayLiftingProducesEqualObject2() {
runConformTest(
new String[] {
"T2217alpeo2Main.java",
"\n" +
"public class T2217alpeo2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2217alpeo2 t = new Team2217alpeo2();\n" +
" T2217alpeo2_2[] o = { new T2217alpeo2_2() };\n" +
"\n" +
" System.out.print(t.test(o, o));\n" +
" }\n" +
"}\n" +
" \n",
"T2217alpeo2_1.java",
"\n" +
"public class T2217alpeo2_1 {}\n" +
" \n",
"T2217alpeo2_2.java",
"\n" +
"public class T2217alpeo2_2 extends T2217alpeo2_1 {}\n" +
" \n",
"Team2217alpeo2.java",
"\n" +
"public team class Team2217alpeo2 {\n" +
" public class Role2217alpeo2_1 playedBy T2217alpeo2_1 {}\n" +
"\n" +
" public class Role2217alpeo2_2 extends Role2217alpeo2_1 {}\n" +
"\n" +
" public String test(T2217alpeo2_1 as Role2217alpeo2_2 objA[], T2217alpeo2_2 as Role2217alpeo2_2 objB[]) {\n" +
"\n" +
" if (objA == objB) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (!objA.equals(objB)) {\n" +
" if (objA.length != objB.length)\n" +
" return \"NOTOK 2a\";\n" +
" for (int i=0; i<objA.length; i++){\n" +
" if (objA[i] != objB[i])\n" +
" return \"NOTOK 2b\";\n" +
" }\n" +
" if (java.util.Arrays.equals(objA, objB))\n" +
" return \"OK\";\n" +
" return \"NOTOK 2c\";\n" +
" }\n" +
" else if (objA.hashCode() != objB.hashCode()) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"NOTOK 4\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base objects is not equal to its lifted self
// 2.2.18-otjld-basearray-not-equal-to-rolearray-1
public void test2218_basearrayNotEqualToRolearray1() {
runConformTest(
new String[] {
"T2218bnetr1Main.java",
"\n" +
"public class T2218bnetr1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2218bnetr1 t = new Team2218bnetr1();\n" +
"\n" +
" System.out.print(t.test());\n" +
" }\n" +
"}\n" +
" \n",
"T2218bnetr1.java",
"\n" +
"public class T2218bnetr1 {}\n" +
" \n",
"Team2218bnetr1.java",
"\n" +
"public team class Team2218bnetr1 {\n" +
" public class Role2218bnetr1_1 playedBy T2218bnetr1 {}\n" +
"\n" +
" public class Role2218bnetr1_2 extends Role2218bnetr1_1 {}\n" +
"\n" +
" private Role2218bnetr1_2[] convert(T2218bnetr1 as Role2218bnetr1_2 obj[]) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test() {\n" +
" T2218bnetr1[] obj = { new T2218bnetr1() };\n" +
" Role2218bnetr1_2[] lifted = convert(obj);\n" +
"\n" +
" if (obj.equals(lifted)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (obj.hashCode() == lifted.hashCode()) {\n" +
" return \"NOTOK 2\";\n" +
" }\n" +
" else if (java.util.Arrays.equals(obj, lifted)) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of base objects is not equal to its lifted self
// 2.2.18-otjld-basearray-not-equal-to-rolearray-2
public void test2218_basearrayNotEqualToRolearray2() {
runConformTest(
new String[] {
"T2218bnetr2Main.java",
"\n" +
"public class T2218bnetr2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2218bnetr2 t = new Team2218bnetr2();\n" +
"\n" +
" System.out.print(t.test());\n" +
" }\n" +
"}\n" +
" \n",
"T2218bnetr2_1.java",
"\n" +
"public class T2218bnetr2_1 {}\n" +
" \n",
"T2218bnetr2_2.java",
"\n" +
"public class T2218bnetr2_2 extends T2218bnetr2_1 {}\n" +
" \n",
"Team2218bnetr2.java",
"\n" +
"public team class Team2218bnetr2 {\n" +
" public class Role2218bnetr2_1 playedBy T2218bnetr2_1 {}\n" +
"\n" +
" public class Role2218bnetr2_2 playedBy T2218bnetr2_2 {}\n" +
"\n" +
" private Role2218bnetr2_1[] toRole1(T2218bnetr2_1 as Role2218bnetr2_1 obj[]) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" private Role2218bnetr2_2[] toRole2(T2218bnetr2_2 as Role2218bnetr2_2 obj[]) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test() {\n" +
" T2218bnetr2_1[] obj = toRole2(new T2218bnetr2_2[]{ new T2218bnetr2_2() });\n" +
" Role2218bnetr2_1[] lifted = toRole1(obj);\n" +
"\n" +
" if (obj.equals(lifted)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (obj.hashCode() == lifted.hashCode()) {\n" +
" return \"NOTOK 2\";\n" +
" }\n" +
" else if (java.util.Arrays.equals(obj, lifted)) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is not equal to its lowered self
// 2.2.19-otjld-rolearray-equal-to-lowered-1
public void test2219_rolearrayEqualToLowered1() {
runConformTest(
new String[] {
"T2219bnetr1Main.java",
"\n" +
"public class T2219bnetr1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2219bnetr1 t = new Team2219bnetr1();\n" +
"\n" +
" System.out.print(t.test());\n" +
" }\n" +
"}\n" +
" \n",
"T2219bnetr1.java",
"\n" +
"public class T2219bnetr1 {}\n" +
" \n",
"Team2219bnetr1.java",
"\n" +
"public team class Team2219bnetr1 {\n" +
" public class Role2219bnetr1 playedBy T2219bnetr1 {}\n" +
"\n" +
" private Role2219bnetr1[] toRole(T2219bnetr1 as Role2219bnetr1 obj[]) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public String test() {\n" +
" Role2219bnetr1[] obj = toRole(new T2219bnetr1[]{ new T2219bnetr1() });\n" +
" T2219bnetr1[] lowered = obj;\n" +
"\n" +
" if (obj.equals(lowered)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (obj.hashCode() == lowered.hashCode()) {\n" +
" return \"NOTOK 2\";\n" +
" }\n" +
" else if (java.util.Arrays.equals(obj, lowered)) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an array of role objects is not equal to its lowered self
// 2.2.19-otjld-rolearray-equal-to-lowered-2
public void test2219_rolearrayEqualToLowered2() {
runConformTest(
new String[] {
"T2219bnetr2Main.java",
"\n" +
"public class T2219bnetr2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2219bnetr2_2 t = new Team2219bnetr2_2();\n" +
"\n" +
" System.out.print(t.test());\n" +
" }\n" +
"}\n" +
" \n",
"T2219bnetr2_1.java",
"\n" +
"public class T2219bnetr2_1 {}\n" +
" \n",
"T2219bnetr2_2.java",
"\n" +
"public class T2219bnetr2_2 extends T2219bnetr2_1 {}\n" +
" \n",
"Team2219bnetr2_1.java",
"\n" +
"public team class Team2219bnetr2_1 {\n" +
" public class Role2219bnetr2 playedBy T2219bnetr2_2 {}\n" +
"}\n" +
" \n",
"Team2219bnetr2_2.java",
"\n" +
"public team class Team2219bnetr2_2 extends Team2219bnetr2_1 {\n" +
" private Role2219bnetr2[] obj;\n" +
"\n" +
" private void init(T2219bnetr2_2 as Role2219bnetr2 obj[]) {\n" +
" this.obj = obj;\n" +
" }\n" +
"\n" +
" public String test() {\n" +
" init(new T2219bnetr2_2[]{ new T2219bnetr2_2() });\n" +
"\n" +
" T2219bnetr2_1[] lowered = obj;\n" +
"\n" +
" if (obj.equals(lowered)) {\n" +
" return \"NOTOK 1\";\n" +
" }\n" +
" else if (obj.hashCode() == lowered.hashCode()) {\n" +
" return \"NOTOK 2\";\n" +
" }\n" +
" else if (java.util.Arrays.equals(obj, lowered)) {\n" +
" return \"NOTOK 3\";\n" +
" }\n" +
" else\n" +
" {\n" +
" return \"OK\";\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role class has an initializeRole method with a signature that is not as required 2.2h
// 2.2.20-otjld_obsolete-initializeRole-with-different-signature-1
public void _obsolete_test2220_initializeRoleWithDifferentSignature1() {
runConformTest(
new String[] {
"T2220iwds1Main.java",
"\n" +
"public class T2220iwds1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2220iwds1 t = new Team2220iwds1();\n" +
" T2220iwds1 o = new T2220iwds1();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2220iwds1.java",
"\n" +
"public class T2220iwds1 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2220iwds1.java",
"\n" +
"public team class Team2220iwds1 {\n" +
" public class Role2220iwds1 playedBy T2220iwds1 {\n" +
" private int value = 0;\n" +
"\n" +
" public void initializeRole() {\n" +
" value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2220iwds1 as Role2220iwds1 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"0");
}
// a role class has an initializeRole method with a signature that is not as required 2.2h
// 2.2.20-otjld_obsolete-initializeRole-with-different-signature-2
public void _obsolete_test2220_initializeRoleWithDifferentSignature2() {
runConformTest(
new String[] {
"T2220iwds2Main.java",
"\n" +
"public class T2220iwds2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2220iwds2 t = new Team2220iwds2();\n" +
" T2220iwds2 o = new T2220iwds2();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2220iwds2.java",
"\n" +
"public class T2220iwds2 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2220iwds2.java",
"\n" +
"public team class Team2220iwds2 {\n" +
" public class Role2220iwds2 playedBy T2220iwds2 {\n" +
" private int value = 0;\n" +
"\n" +
" void initializeRole() {\n" +
" value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2220iwds2 as Role2220iwds2 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"0");
}
// a role class has an initializeRole method with a signature that is not as required 2.2h
// 2.2.20-otjld_obsolete-initializeRole-with-different-signature-3
public void _obsolete_test2220_initializeRoleWithDifferentSignature3() {
runConformTest(
new String[] {
"T2220iwds3Main.java",
"\n" +
"public class T2220iwds3Main {\n" +
" public static void main(String[] args) {\n" +
" Team2220iwds3 t = new Team2220iwds3();\n" +
" T2220iwds3 o = new T2220iwds3();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2220iwds3.java",
"\n" +
"public class T2220iwds3 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2220iwds3.java",
"\n" +
"public team class Team2220iwds3 {\n" +
" public class Role2220iwds3 playedBy T2220iwds3 {\n" +
" private int value = 0;\n" +
"\n" +
" private void initializeRole() {\n" +
" value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2220iwds3 as Role2220iwds3 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"0");
}
// a role class has an initializeRole method with a signature that is not as required 2.2h
// 2.2.20-otjld_obsolete-initializeRole-with-different-signature-4
public void _obsolete_test2220_initializeRoleWithDifferentSignature4() {
runConformTest(
new String[] {
"T2220iwds4Main.java",
"\n" +
"public class T2220iwds4Main {\n" +
" public static void main(String[] args) {\n" +
" Team2220iwds4 t = new Team2220iwds4();\n" +
" T2220iwds4 o = new T2220iwds4();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2220iwds4.java",
"\n" +
"public class T2220iwds4 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2220iwds4.java",
"\n" +
"public team class Team2220iwds4 {\n" +
" public class Role2220iwds4 playedBy T2220iwds4 {\n" +
" private int value = 0;\n" +
"\n" +
" protected int initializeRole() {\n" +
" value++;\n" +
" return value;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2220iwds4 as Role2220iwds4 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"0");
}
// a role class has an initializeRole method with a signature that is not as required 2.2h
// 2.2.20-otjld_obsolete-initializeRole-with-different-signature-5
public void _obsolete_test2220_initializeRoleWithDifferentSignature5() {
runConformTest(
new String[] {
"T2220iwds5Main.java",
"\n" +
"public class T2220iwds5Main {\n" +
" public static void main(String[] args) {\n" +
" Team2220iwds5 t = new Team2220iwds5();\n" +
" T2220iwds5 o = new T2220iwds5();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2220iwds5.java",
"\n" +
"public class T2220iwds5 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2220iwds5.java",
"\n" +
"public team class Team2220iwds5 {\n" +
" public class Role2220iwds5 playedBy T2220iwds5 {\n" +
" private int value = 0;\n" +
"\n" +
" protected void initializeRole(int arg) {\n" +
" value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2220iwds5 as Role2220iwds5 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"0");
}
// a role class has an initializeRole method that is called exactly once during subsequent lifting of the same base object in the same team
// 2.2.22-otjld-role-with-initializeRole-method-1
public void test2222_roleWithInitializeRoleMethod1() {
runConformTest(
new String[] {
"T2222rwim1Main.java",
"\n" +
"public class T2222rwim1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2222rwim1 t = new Team2222rwim1();\n" +
" T2222rwim1 o = new T2222rwim1();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2222rwim1.java",
"\n" +
"public class T2222rwim1 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2222rwim1.java",
"\n" +
"public team class Team2222rwim1 {\n" +
" private int value = 0;\n" +
" public class Role2222rwim1 playedBy T2222rwim1 {\n" +
"\n" +
" public Role2222rwim1(T2222rwim1 b) {\n" +
" Team2222rwim1.this.value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- Team2222rwim1.this.value\n" +
" }\n" +
" }\n" +
"\n" +
" private Role2222rwim1 toRole(T2222rwim1 as Role2222rwim1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public int getValue(T2222rwim1 obj) {\n" +
" final Role2222rwim1 lifted1 = toRole(obj);\n" +
" T2222rwim1 lowered = lifted1;\n" +
" Role2222rwim1 lifted2 = toRole(lowered);\n" +
"\n" +
" return lifted2.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"1");
}
// a role class has an initializeRole method that is called twice during subsequent lifting of the same base object to different roles in the same team
// 2.2.22-otjld-role-with-initializeRole-method-2
public void test2222_roleWithInitializeRoleMethod2() {
runConformTest(
new String[] {
"T2222rwim2Main.java",
"\n" +
"public class T2222rwim2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2222rwim2 t = new Team2222rwim2();\n" +
" T2222rwim2 o = new T2222rwim2();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2222rwim2.java",
"\n" +
"public class T2222rwim2 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2222rwim2.java",
"\n" +
"public team class Team2222rwim2 {\n" +
" private int value = 0;\n" +
"\n" +
" public class Role2222rwim2_1 playedBy T2222rwim2 {\n" +
"\n" +
" Role2222rwim2_1(T2222rwim2 b) {\n" +
" Team2222rwim2.this.value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- Team2222rwim2.this.value\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2222rwim2_2 playedBy T2222rwim2 {\n" +
"\n" +
" Role2222rwim2_2(T2222rwim2 b) {\n" +
" Team2222rwim2.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" private Role2222rwim2_1 role;\n" +
"\n" +
" private Role2222rwim2_1 toRole(T2222rwim2 as Role2222rwim2_1 obj) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public int getValue(T2222rwim2 as Role2222rwim2_2 obj) {\n" +
" T2222rwim2 lowered = obj;\n" +
"\n" +
" // this should produce a different role object (of type Role2222rwim2_1) -> two calls to initializeRole\n" +
" role = toRole(obj); \n" +
" return role.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"2");
}
// each class in a role hierarchy has its own default constructor, all of which are invoked
// 2.2.23-otjld-role-hierarchy-with-initializeRole-methods
public void test2223_roleHierarchyWithInitializeRoleMethods() {
runConformTest(
new String[] {
"T2223rhwimMain.java",
"\n" +
"public class T2223rhwimMain {\n" +
" public static void main(String[] args) {\n" +
" Team2223rhwim t = new Team2223rhwim();\n" +
" T2223rhwim_2 o = new T2223rhwim_2();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2223rhwim_1.java",
"\n" +
"public class T2223rhwim_1 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"T2223rhwim_2.java",
"\n" +
"public class T2223rhwim_2 extends T2223rhwim_1 {}\n" +
" \n",
"Team2223rhwim.java",
"\n" +
"public team class Team2223rhwim {\n" +
" protected int value = 0;\n" +
"\n" +
" public abstract class Role2223rhwim_1 {\n" +
" Role2223rhwim_1() {\n" +
" Team2223rhwim.this.value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" }\n" +
"\n" +
" public class Role2223rhwim_2 extends Role2223rhwim_1 playedBy T2223rhwim_2 {\n" +
" Role2223rhwim_2(T2223rhwim_2 b) {\n" +
" Team2223rhwim.this.value++;\n" +
" }\n" +
" int getValue() -> int getValue() with {\n" +
" result <- Team2223rhwim.this.value\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2223rhwim_3 extends Role2223rhwim_2 {\n" +
" Role2223rhwim_3(T2223rhwim_2 b) {\n" +
" Team2223rhwim.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2223rhwim_2 as Role2223rhwim_3 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"3");
}
// a role hierarchy with initializeRole methods containing super-calls
// 2.2.24-otjld-role-hierarchy-with-initializeRole-methods
public void test2224_roleHierarchyWithInitializeRoleMethods() {
runConformTest(
new String[] {
"T2224rhwimMain.java",
"\n" +
"public class T2224rhwimMain {\n" +
" public static void main(String[] args) {\n" +
" Team2224rhwim_2 t = new Team2224rhwim_2();\n" +
" T2224rhwim o = new T2224rhwim();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2224rhwim.java",
"\n" +
"public class T2224rhwim {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2224rhwim_1.java",
"\n" +
"public team class Team2224rhwim_1 {\n" +
" protected int value = 0;\n" +
"\n" +
" public class Role2224rhwim_1 playedBy T2224rhwim {\n" +
" Role2224rhwim_1(T2224rhwim b) {\n" +
" Team2224rhwim_1.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2224rhwim_2 extends Role2224rhwim_1 {\n" +
" // does not inherit lifting constructor\n" +
" }\n" +
"}\n" +
" \n",
"Team2224rhwim_2.java",
"\n" +
"public team class Team2224rhwim_2 extends Team2224rhwim_1 {\n" +
" public class Role2224rhwim_2 {\n" +
" // overrides public default constructor\n" +
" public Role2224rhwim_2(T2224rhwim b) {\n" +
" tsuper(b);\n" +
" Team2224rhwim_2.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2224rhwim_3 extends Role2224rhwim_2 {\n" +
" // overrides public constructor\n" +
" public Role2224rhwim_3(T2224rhwim b) {\n" +
" super(b);\n" +
" Team2224rhwim_2.this.value++;\n" +
" }\n" +
"\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- Team2224rhwim_2.this.value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2224rhwim as Role2224rhwim_3 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"3");
}
// the default lifting constructor is public so must all overrides
// 2.2.24-otjld-restricting-constructor-visibility
public void test2224_restrictingConstructorVisibility() {
runNegativeTest(
new String[] {
"T2224rhwim2.java",
"\n" +
"public class T2224rhwim2 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2224rhwim2_1.java",
"\n" +
"public team class Team2224rhwim2_1 {\n" +
" protected int value = 0;\n" +
"\n" +
" public class Role2224rhwim2_1 playedBy T2224rhwim2 {\n" +
" Role2224rhwim2_1(T2224rhwim2 b) {\n" +
" Team2224rhwim2_1.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2224rhwim2_2 extends Role2224rhwim2_1 {\n" +
" // should inherit the initializeRole method\n" +
" }\n" +
"}\n" +
" \n",
"Team2224rhwim2_2.java",
"\n" +
"public team class Team2224rhwim2_2 extends Team2224rhwim2_1 {\n" +
" public class Role2224rhwim2_2 {\n" +
" // try to override public default constructor\n" +
" Role2224rhwim2_2(T2224rhwim2 b) {\n" +
" tsuper(b);\n" +
" Team2224rhwim2_2.this.value++;\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
null);
}
// a role class inherited the initializeRole method which is called exactly once during lifting
// 2.2.25-otjld-inherited-initializeRole-method
public void test2225_inheritedInitializeRoleMethod() {
runConformTest(
new String[] {
"T2225iimMain.java",
"\n" +
"public class T2225iimMain {\n" +
" public static void main(String[] args) {\n" +
" Team2225iim_2 t = new Team2225iim_2();\n" +
" T2225iim o = new T2225iim();\n" +
"\n" +
" System.out.print(t.getValue(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2225iim.java",
"\n" +
"public class T2225iim {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2225iim_1.java",
"\n" +
"public team class Team2225iim_1 {\n" +
" protected int value = 0;\n" +
"\n" +
" public class Role2225iim_1 playedBy T2225iim {\n" +
" Role2225iim_1(T2225iim b) {\n" +
" Team2225iim_1.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2225iim_2 extends Role2225iim_1 {}\n" +
"}\n" +
" \n",
"Team2225iim_2.java",
"\n" +
"public team class Team2225iim_2 extends Team2225iim_1 {\n" +
" public class Role2225iim_3 extends Role2225iim_2 {\n" +
" public abstract int getValue();\n" +
" int getValue() -> int getValue() with {\n" +
" result <- Team2225iim_2.this.value\n" +
" }\n" +
" }\n" +
"\n" +
" public int getValue(T2225iim as Role2225iim_3 obj) {\n" +
" return obj.getValue();\n" +
" }\n" +
"}\n" +
" \n"
},
"1");
}
// an array of base class objects is lifted to a role array, and for each lifted base object the initializeRole method is called
// 2.2.27-otjld-array-lifting-calls-initializeRole-1
public void test2227_arrayLiftingCallsInitializeRole1() {
runConformTest(
new String[] {
"T2227alci1Main.java",
"\n" +
"public class T2227alci1Main {\n" +
" public static void main(String[] args) {\n" +
" Team2227alci1 t = new Team2227alci1();\n" +
" T2227alci1[] o = { new T2227alci1(), new T2227alci1(), new T2227alci1() };\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2227alci1.java",
"\n" +
"public class T2227alci1 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"Team2227alci1.java",
"\n" +
"public team class Team2227alci1 {\n" +
" protected int value = 0;\n" +
"\n" +
" public class Role2227alci1_1 playedBy T2227alci1 {\n" +
" Role2227alci1_1(T2227alci1 b) {\n" +
" Team2227alci1.this.value++;\n" +
" }\n" +
" }\n" +
"\n" +
" public class Role2227alci1_2 extends Role2227alci1_1 {}\n" +
"\n" +
" private Role2227alci1_2[] toRoles(T2227alci1 as Role2227alci1_2 obj[]) {\n" +
" return obj;\n" +
" }\n" +
"\n" +
" public int test(T2227alci1 as Role2227alci1_2 obj[]) {\n" +
" T2227alci1[] lowered = obj;\n" +
" Role2227alci1_2[] lifted = toRoles(lowered);\n" +
"\n" +
" return value;\n" +
" }\n" +
"}\n" +
" \n"
},
"3");
}
// an array of base class objects is lifted to a role array, and for each lifted base object the initializeRole method is called
// 2.2.27-otjld-array-lifting-calls-initializeRole-2
public void test2227_arrayLiftingCallsInitializeRole2() {
runConformTest(
new String[] {
"T2227alci2Main.java",
"\n" +
"public class T2227alci2Main {\n" +
" public static void main(String[] args) {\n" +
" Team2227alci2_2 t = new Team2227alci2_2();\n" +
" T2227alci2_1[] o = { new T2227alci2_1(), new T2227alci2_2(), new T2227alci2_1() };\n" +
"\n" +
" System.out.print(t.test(o));\n" +
" }\n" +
"}\n" +
" \n",
"T2227alci2_1.java",
"\n" +
"public class T2227alci2_1 {\n" +
" public int getValue() {\n" +
" return 0;\n" +
" }\n" +
"}\n" +
" \n",
"T2227alci2_2.java",
"\n" +
"public class T2227alci2_2 extends T2227alci2_1 {}\n" +
" \n",
"Team2227alci2_1.java",
"\n" +
"public team class Team2227alci2_1 {\n" +
" protected int value = 0;\n" +
"\n" +
" public class Role2227alci2_1 playedBy T2227alci2_1 {\n" +
" Role2227alci2_1(T2227alci2_1 b) {\n" +
" Team2227alci2_1.this.value++;\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"Team2227alci2_2.java",
"\n" +
"public team class Team2227alci2_2 extends Team2227alci2_1 {\n" +
" public class Role2227alci2_2 extends Role2227alci2_1 playedBy T2227alci2_2 {}\n" +
"\n" +
" public int test(T2227alci2_1 as Role2227alci2_1 obj[]) {\n" +
" return value;\n" +
" }\n" +
"}\n" +
" \n"
},
"3");
}
// a constructor declares a parameter with lifting
// 2.2.28-otjld-declared-lifting-in-construtor-1
public void test2228_declaredLiftingInConstrutor1() {
runConformTest(
new String[] {
"Team2228dlic1.java",
"\n" +
"public team class Team2228dlic1 {\n" +
" String val=\"O\";\n" +
" protected class R playedBy T2228dlic1 {\n" +
" protected String getVa() {\n" +
" return val;\n" +
" }\n" +
" protected abstract String getLue();\n" +
" getLue -> getter;\n" +
" }\n" +
" public Team2228dlic1 (T2228dlic1 as R r) {\n" +
" System.out.print(r.getVa()+r.getLue());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic1(new T2228dlic1());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic1.java",
"\n" +
"public class T2228dlic1 {\n" +
" public String getter() { return \"K\"; }\n" +
"}\n" +
" \n"
},
"OK");
}
// a constructor declares a parameter with lifting
// 2.2.28-otjld-declared-lifting-in-construtor-2
public void test2228_declaredLiftingInConstrutor2() {
runConformTest(
new String[] {
"Team2228dlic2_2.java",
"\n" +
"public team class Team2228dlic2_2 extends Team2228dlic2_1 {\n" +
" public Team2228dlic2_2 (T2228dlic2 as R r) {\n" +
" super(r);\n" +
" System.out.print(r.getLue());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic2_2(new T2228dlic2());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic2.java",
"\n" +
"public class T2228dlic2 {\n" +
" public String getter() { return \"K\"; }\n" +
"}\n" +
" \n",
"Team2228dlic2_1.java",
"\n" +
"public team class Team2228dlic2_1 {\n" +
" String val=\"O\";\n" +
" protected class R playedBy T2228dlic2 {\n" +
" protected String getVa() {\n" +
" return val;\n" +
" }\n" +
" abstract public String getLue();\n" +
" getLue -> getter;\n" +
" }\n" +
" public Team2228dlic2_1 (T2228dlic2 as R r) {\n" +
" System.out.print(r.getVa());\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a constructor declares a parameter with lifting - invoking super with role type
// 2.2.28-otjld-declared-lifting-in-construtor-3
public void test2228_declaredLiftingInConstrutor3() {
runConformTest(
new String[] {
"Team2228dlic3_2.java",
"\n" +
"public team class Team2228dlic3_2 extends Team2228dlic3_1 {\n" +
" public Team2228dlic3_2 (T2228dlic3 as R r) {\n" +
" super(r);\n" +
" System.out.print(r.getLue());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic3_2(new T2228dlic3());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic3.java",
"\n" +
"public class T2228dlic3 {\n" +
" public String getter() { return \"K\"; }\n" +
"}\n" +
" \n",
"Team2228dlic3_1.java",
"\n" +
"public team class Team2228dlic3_1 {\n" +
" String val=\"O\";\n" +
" protected class R playedBy T2228dlic3 {\n" +
" protected String getVa() {\n" +
" return val;\n" +
" }\n" +
" abstract public String getLue();\n" +
" getLue -> getter;\n" +
" }\n" +
" public Team2228dlic3_1 (R r) {\n" +
" System.out.print(r.getVa());\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a constructor uses a parameter with declared lifting, but the base type is invalid
// WITNESS for error reported in TPX-204 (fixed somewhere between 0.7.5 and 0.7.11)
// 2.2.28-otjld-declared-lifting-in-construtor-4
public void test2228_declaredLiftingInConstrutor4() {
runNegativeTest(
new String[] {
"T2228dlic4.java",
" public class T2228dlic4 {} \n",
"Team2228dlic4_2.java",
"\n" +
"public team class Team2228dlic4_2 {\n" +
" protected class R playedBy T2228dlic4 {}\n" +
" private Team2228dlic4_2(Erroneous as R o) { }\n" +
"} \n" +
" \n"
},
null);
}
// a constructor with declared lifting calls super with a role across several levels
// 2.2.28-otjld-declared-lifting-in-constructor-5
// Bug 326052 [compiler] problems with team ctors with declared lifting in specific inheritance situations
public void test2228_declaredLiftingInConstructor5() {
runConformTest(
new String[] {
"Team2228dlic5_3.java",
"\n" +
"public team class Team2228dlic5_3 extends Team2228dlic5_2 {\n" +
" public class R2 extends R playedBy T2228dlic5 {}\n" +
" public Team2228dlic5_3(T2228dlic5 as R2 r) {\n" +
" super(r);\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic5_3(new T2228dlic5());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic5.java",
"\n" +
"public class T2228dlic5 {} \n" +
" \n",
"Team2228dlic5_1.java",
"\n" +
"public abstract team class Team2228dlic5_1 {\n" +
" protected abstract class R {\n" +
" protected abstract void test();\n" +
" }\n" +
" protected Team2228dlic5_1(R r) {\n" +
" r.test();\n" +
" }\n" +
"} \n" +
" \n",
"Team2228dlic5_2.java",
"\n" +
"public team class Team2228dlic5_2 extends Team2228dlic5_1 {\n" +
" protected class R {\n" +
" protected void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" protected Team2228dlic5_2(R r) {\n" +
" super(r);\n" +
" }\n" +
"} \n" +
" \n"
},
"OK");
}
// a constructor with declared lifting calls super with a role across several levels
// witness for AssertionError during bytecode copy
// 2.2.28-otjld-declared-lifting-in-constructor-5f
public void test2228_declaredLiftingInConstructor5f() {
runNegativeTest(
new String[] {
"Team2228dlic5f_1.java",
"\n" +
"public abstract team class Team2228dlic5f_1 {\n" +
" protected abstract class R {\n" +
" abstract void test();\n" +
" }\n" +
" protected Team2228dlic5f_1(R r) {\n" +
" r.test(); // not visible, causes this ctor and all clients to fail\n" +
" }\n" +
"}\n" +
" \n",
"T2228dlic5f.java",
"\n" +
"public class T2228dlic5f {}\n" +
" \n"
},
"----------\n" +
"1. ERROR in Team2228dlic5f_1.java (at line 7)\n" +
" r.test(); // not visible, causes this ctor and all clients to fail\n" +
" ^^^^\n" +
"The method test() from the role type Team2228dlic5f_1.R is not visible (OTJLD 1.2.1(e)).\n" +
"----------\n",
null/*classLibs*/,
false/*shouldFlushOutputDirectory*/,
null/*customOptions*/,
true/*generateOutput*/,
false/*showCategory*/,
false/*showWarningToken*/);
runConformTest(
new String[] {
"Team2228dlic5f_2.java",
"\n" +
"public team class Team2228dlic5f_2 extends Team2228dlic5f_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" protected Team2228dlic5f_2(R r) {\n" +
" super(r);\n" +
" }\n" +
"}\n" +
" \n",
"Team2228dlic5f_3.java",
"\n" +
"public team class Team2228dlic5f_3 extends Team2228dlic5f_2 {\n" +
" public class R2 extends R playedBy T2228dlic5f {}\n" +
" public Team2228dlic5f_3(T2228dlic5f as R2 r) {\n" +
" super(r);\n" +
" }\n" +
"}\n" +
" \n"
},
""/*expectedCompilerOutput*/,
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
null/*vmArguments*/);
}
// a constructor with declared lifting calls super with a role across several levels - compiling in one go should not trigger compiler limitation (can't find super call)
// 2.2.28-otjld-declared-lifting-in-constructor-5g
public void test2228_declaredLiftingInConstructor5g() {
runConformTest(
new String[] {
"Team2228dlic5g_3.java",
"\n" +
"public team class Team2228dlic5g_3 extends Team2228dlic5g_2 {\n" +
" public class R2 extends R playedBy T2228dlic5g {}\n" +
" public Team2228dlic5g_3(T2228dlic5g as R2 r) {\n" +
" super(r);\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic5g_3(new T2228dlic5g());\n" +
" }\n" +
"}\n" +
" \n",
"T2228dlic5g.java",
"\n" +
"public class T2228dlic5g {}\n" +
" \n",
"Team2228dlic5g_1.java",
"\n" +
"public abstract team class Team2228dlic5g_1 {\n" +
" protected abstract class R {\n" +
" abstract protected void test();\n" +
" }\n" +
" protected Team2228dlic5g_1(R r) {\n" +
" r.test();\n" +
" }\n" +
"}\n" +
" \n",
"Team2228dlic5g_2.java",
"\n" +
"public team class Team2228dlic5g_2 extends Team2228dlic5g_1 {\n" +
" protected class R {\n" +
" protected void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" protected Team2228dlic5g_2(R r) {\n" +
" super(r);\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a constructor with declared lifting calls super with a role across several levels -- unsupported data flow
// 2.2.28-otjld-declared-lifting-in-constructor-6
// Bug 326052 [compiler] problems with team ctors with declared lifting in specific inheritance situations
public void _test2228_declaredLiftingInConstructor6() {
runConformTest(
new String[] {
"Team2228dlic6_3.java",
"\n" +
"public team class Team2228dlic6_3 extends Team2228dlic6_2 {\n" +
" public class R2 extends R playedBy T2228dlic6 {}\n" +
" public Team2228dlic6_3(T2228dlic6 as R2 r) {\n" +
" super(r);\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new Team2228dlic6_3(new T2228dlic6());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic6.java",
"\n" +
"public class T2228dlic6 {} \n" +
" \n",
"Team2228dlic6_1.java",
"\n" +
"public abstract team class Team2228dlic6_1 {\n" +
" protected abstract class R {\n" +
" protected abstract void test();\n" +
" }\n" +
" protected Team2228dlic6_1(R r) {\n" +
" r.test();\n" +
" }\n" +
"} \n" +
" \n",
"Team2228dlic6_2.java",
"\n" +
"public team class Team2228dlic6_2 extends Team2228dlic6_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" protected void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" protected R id() { return this; }\n" +
" }\n" +
" protected Team2228dlic6_2(R r) {\n" +
" super(r.id());\n" +
" }\n" +
"} \n" +
" \n"
},
"OK");
}
// a constructor with declared lifting calls super with a role across several levels -- unsupported data flow
// 2.2.28-otjld-declared-lifting-in-constructor-6l
public void test2228_declaredLiftingInConstructor6l() {
runConformTest(
new String[] {
"T2228dlic6l.java",
"\n" +
"public class T2228dlic6l {} \n" +
" \n",
"Team2228dlic6l_1.java",
"\n" +
"public abstract team class Team2228dlic6l_1 {\n" +
" protected abstract class R {\n" +
" protected abstract void test();\n" +
" }\n" +
" protected Team2228dlic6l_1(R r) {\n" +
" r.test();\n" +
" }\n" +
"} \n" +
" \n",
"Team2228dlic6l_2.java",
"\n" +
"public team class Team2228dlic6l_2 extends Team2228dlic6l_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" protected void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" protected R id() { return this; }\n" +
" }\n" +
" protected Team2228dlic6l_2(R r) {\n" +
" super(r.id());\n" +
" }\n" +
"} \n" +
" \n"
});
runNegativeTest(
new String[] {
"Team2228dlic6l_3.java",
"\n" +
"public team class Team2228dlic6l_3 extends Team2228dlic6l_2 {\n" +
" public class R2 extends R playedBy T2228dlic6l {}\n" +
" public Team2228dlic6l_3(T2228dlic6l as R2 r) {\n" +
" super(r);\n" +
" }\n" +
"}\n"
},
(this.weavingScheme == WeavingScheme.OTDRE || this.complianceLevel < ClassFileConstants.JDK1_8
?
"----------\n" +
"1. ERROR in Team2228dlic6l_3.java (at line 4)\n" +
" public Team2228dlic6l_3(T2228dlic6l as R2 r) {\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Compiler limitation: This constructor seems to request lifting of an argument. However, the self call in Team2228dlic6l_2(R) of class Team2228dlic6l_2 passes its arguments in an unexpected way. Cannot perform required transitive byte-code translation.\n" +
"----------\n"
:
"----------\n" +
"1. WARNING in Team2228dlic6l_3.java (at line 3)\n" +
" public class R2 extends R playedBy T2228dlic6l {}\n" +
" ^^^^^^^^^^^\n" +
"Base class T2228dlic6l has class file version 52 which cannot be handled by the traditional OTRE based on BCEL. Please consider using the ASM based OTDRE instead.\n" +
"----------\n" +
"2. ERROR in Team2228dlic6l_3.java (at line 4)\n" +
" public Team2228dlic6l_3(T2228dlic6l as R2 r) {\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Compiler limitation: This constructor seems to request lifting of an argument. However, the self call in Team2228dlic6l_2(R) of class Team2228dlic6l_2 passes its arguments in an unexpected way. Cannot perform required transitive byte-code translation.\n" +
"----------\n"
),
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/);
}
// a constructor with declared lifting calls super with a role across several levels --
// this version generated ICE("Binary method has no code attribute")
// 2.2.28-otjld-declared-lifting-in-constructor-6f
public void test2228_declaredLiftingInConstructor6f() {
runNegativeTest(
new String[] {
"Team2228dlic6f_3.java",
"\n" +
"public team class Team2228dlic6f_3 extends Team2228dlic6f_2 {\n" +
" public class R2 extends R playedBy T2228dlic6f {}\n" +
" public Team2228dlic6f_3(T2228dlic6f as R2 r) {\n" +
" super(r);\n" +
" }\n" +
"}\n" +
" \n",
"T2228dlic6f.java",
"\n" +
"public class T2228dlic6f {}\n" +
" \n",
"Team2228dlic6f_1.java",
"\n" +
"public abstract team class Team2228dlic6f_1 {\n" +
" protected abstract class R {\n" +
" abstract void test();\n" +
" }\n" +
" protected Team2228dlic6f_1(R r) {\n" +
" r.test(); // not visible \n" +
" }\n" +
"}\n" +
" \n",
"Team2228dlic6f_2.java",
"\n" +
"public team class Team2228dlic6f_2 extends Team2228dlic6f_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" R id() { return this; }\n" +
" }\n" +
" protected Team2228dlic6f_2(R r) {\n" +
" super(r.id()); // not visible\n" +
" }\n" +
"}\n" +
" \n"
},
"----------\n" +
"1. ERROR in Team2228dlic6f_1.java (at line 7)\n" +
" r.test(); // not visible \n" +
" ^^^^\n" +
"The method test() from the role type Team2228dlic6f_1.R is not visible (OTJLD 1.2.1(e)).\n" +
"----------\n" +
"----------\n" +
"1. ERROR in Team2228dlic6f_2.java (at line 12)\n" +
" super(r.id()); // not visible\n" +
" ^^\n" +
"The method id() from the role type Team2228dlic6f_2.R is not visible (OTJLD 1.2.1(e)).\n" +
"----------\n");
}
// a constructor with declared lifting calls super with a role across several levels -- unsupported data flow
// 2.2.28-otjld-declared-lifting-in-constructor-7
// Bug 326052 [compiler] problems with team ctors with declared lifting in specific inheritance situations
public void _test2228_declaredLiftingInConstructor7() {
runConformTest(
new String[] {
"Team2228dlic7_3.java",
"\n" +
"public team class Team2228dlic7_3 extends Team2228dlic7_2 {\n" +
" public class R2 extends R playedBy T2228dlic7 {}\n" +
" public Team2228dlic7_3(T2228dlic7 as R2 r) {\n" +
" super(r);\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic7_3(new T2228dlic7());\n" +
" }\n" +
"} \n" +
" \n",
"T2228dlic7.java",
"\n" +
"public class T2228dlic7 {} \n" +
" \n",
"Team2228dlic7_1.java",
"\n" +
"public abstract team class Team2228dlic7_1 {\n" +
" protected abstract class R {\n" +
" protected abstract void test();\n" +
" }\n" +
" protected Team2228dlic7_1(int dummy, R r) {\n" +
" r.test();\n" +
" }\n" +
"} \n" +
" \n",
"Team2228dlic7_2.java",
"\n" +
"public team class Team2228dlic7_2 extends Team2228dlic7_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" public void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" protected Team2228dlic7_2(R r) {\n" +
" super(1, r);\n" +
" }\n" +
"} \n" +
" \n"
},
"OK");
}
// a constructor with declared lifting calls super with a role across several levels -- unsupported data flow
// 2.2.28-otjld-declared-lifting-in-constructor-7l
public void test2228_declaredLiftingInConstructor7l() {
runConformTest(
new String[] {
"T2228dlic7l.java",
"\n" +
"public class T2228dlic7l {} \n" +
" \n",
"Team2228dlic7l_1.java",
"\n" +
"public abstract team class Team2228dlic7l_1 {\n" +
" protected abstract class R {\n" +
" protected abstract void test();\n" +
" }\n" +
" protected Team2228dlic7l_1(int dummy, R r) {\n" +
" r.test();\n" +
" }\n" +
"} \n" +
" \n",
"Team2228dlic7l_2.java",
"\n" +
"public team class Team2228dlic7l_2 extends Team2228dlic7l_1 {\n" +
" @Override\n" +
" protected class R {\n" +
" @Override\n" +
" public void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" R id() { return this; }\n" +
" }\n" +
" protected Team2228dlic7l_2(R r) {\n" +
" super(1, r);\n" +
" }\n" +
"} \n" +
" \n"
},
"",
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
null/*vmArguments*/);
runNegativeTest(
new String[] {
"Team2228dlic7l_3.java",
"\n" +
"public team class Team2228dlic7l_3 extends Team2228dlic7l_2 {\n" +
" public class R2 extends R playedBy T2228dlic7l {}\n" +
" public Team2228dlic7l_3(T2228dlic7l as R2 r) {\n" +
" super(r);\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic7l_3(new T2228dlic7l());\n" +
" }\n" +
"} \n" +
" \n"
},
(this.weavingScheme == WeavingScheme.OTDRE || this.complianceLevel < ClassFileConstants.JDK1_8
?
"----------\n" +
"1. ERROR in Team2228dlic7l_3.java (at line 4)\n" +
" public Team2228dlic7l_3(T2228dlic7l as R2 r) {\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Compiler limitation: This constructor seems to request lifting of an argument. However, the self call in Team2228dlic7l_2(R) of class Team2228dlic7l_2 passes its arguments in an unexpected way. Cannot perform required transitive byte-code translation.\n" +
"----------\n"
:
"1. WARNING in Team2228dlic7l_3.java (at line 3)\n" +
" public class R2 extends R playedBy T2228dlic7l {}\n" +
" ^^^^^^^^^^^\n" +
"Base class T2228dlic7l has class file version 52 which cannot be handled by the traditional OTRE based on BCEL. Please consider using the ASM based OTDRE instead.\n" +
"----------\n" +
"2. ERROR in Team2228dlic7l_3.java (at line 4)\n" +
" public Team2228dlic7l_3(T2228dlic7l as R2 r) {\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Compiler limitation: This constructor seems to request lifting of an argument. However, the self call in Team2228dlic7l_2(R) of class Team2228dlic7l_2 passes its arguments in an unexpected way. Cannot perform required transitive byte-code translation.\n" +
"----------\n"
),
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/);
}
// two roles are lifted, witness for a former AIOOBE in AnchorMapping
// 2.2.28-otjld-declared-lifting-in-constructor-8
public void test2228_declaredLiftingInConstructor8() {
runConformTest(
new String[] {
"Team2228dlic8_2.java",
"\n" +
"public team class Team2228dlic8_2 extends Team2228dlic8_1 {\n" +
" protected class R1 playedBy T2228dlic8_1 {\n" +
" test1 -> test1;\n" +
" }\n" +
" protected class R2 playedBy T2228dlic8_2 {\n" +
" test2 -> test2;\n" +
" }\n" +
" public Team2228dlic8_2(T2228dlic8_1 as R1 r1, T2228dlic8_2 as R2 r2) {\n" +
" super(r1, r2);\n" +
" }\n" +
" // shorter ctor just to confuse the compiler:\n" +
" public Team2228dlic8_2(T2228dlic8_1 as R1 r1) {\n" +
" super(r1);\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2228dlic8_2(new T2228dlic8_1(), new T2228dlic8_2());\n" +
" }\n" +
"}\n" +
" \n",
"T2228dlic8_1.java",
"\n" +
"public class T2228dlic8_1 {\n" +
" void test1() { System.out.print(\"OKI\"); }\n" +
"}\n" +
" \n",
"T2228dlic8_2.java",
"\n" +
"public class T2228dlic8_2 {\n" +
" void test2() { System.out.print(\"DOKI\"); }\n" +
"}\n" +
" \n",
"Team2228dlic8_1.java",
"\n" +
"public team class Team2228dlic8_1 {\n" +
" abstract protected class R1 {\n" +
" abstract protected void test1();\n" +
" }\n" +
" abstract protected class R2 {\n" +
" abstract protected void test2();\n" +
" }\n" +
" public Team2228dlic8_1(R1 r1, R2 r2) {\n" +
" r1.test1();\n" +
" r2.test2();\n" +
" }\n" +
" // shorter ctor just to confuse the compiler:\n" +
" public Team2228dlic8_1(R1 r1) {\n" +
" r1.test1();\n" +
" }\n" +
"}\n" +
" \n"
},
"OKIDOKI");
}
// a role is explicitly lowered
// 2.2.29-otjld-explicit-lowering-1
public void test2229_explicitLowering1() {
runConformTest(
new String[] {
"Team2229el1.java",
"\n" +
"public team class Team2229el1 {\n" +
" public class R implements ILowerable playedBy T2229el1 {\n" +
" }\n" +
" public Team2229el1 () {\n" +
" R r = new R(new T2229el1(\"OK\"));\n" +
" T2229el1 t = (T2229el1)r.lower();\n" +
" System.out.print(t.getValue());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2229el1();\n" +
" }\n" +
"}\n" +
" \n",
"T2229el1.java",
"\n" +
"public class T2229el1 {\n" +
" private String val = null;\n" +
" public T2229el1(String v) { val = v; }\n" +
" String getValue() { return val; }\n" +
"}\n" +
" \n"
},
"OK");
}
// explicit lowering has the type of the bound base class
// 2.2.29-otjld-explicit-lowering-2
public void test2229_explicitLowering2() {
runConformTest(
new String[] {
"Team2229el2.java",
"\n" +
"public team class Team2229el2 {\n" +
" protected class R1 implements ILowerable playedBy T2229el2_1 {\n" +
" protected R1(String v) {\n" +
" base(v);\n" +
" }\n" +
" }\n" +
" protected class R2 implements ILowerable playedBy T2229el2_1 {\n" +
" protected R2(String v) {\n" +
" base(v);\n" +
" }\n" +
" }\n" +
" void test(T2229el2_2 target) {\n" +
" R1 r1 = new R1(\"O\");\n" +
" R2 r2 = new R2(\"K\");\n" +
" target.test(r1.lower());\n" +
" target.test(r2.lower());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2229el2().test(new T2229el2_2());\n" +
" }\n" +
"}\n" +
" \n",
"T2229el2_1.java",
"\n" +
"public class T2229el2_1 {\n" +
" String val;\n" +
" public T2229el2_1(String v) { this.val = v; }\n" +
" public void print() { System.out.print(this.val); }\n" +
"}\n" +
" \n",
"T2229el2_2.java",
"\n" +
"public class T2229el2_2 {\n" +
" public void test(T2229el2_1 arg) {\n" +
" arg.print();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// an abstract bound role implements ILowerable
// 2.2.29-otjld-explicit-lowering-3
public void test2229_explicitLowering3() {
runConformTest(
new String[] {
"Team2229el3.java",
"\n" +
"public team class Team2229el3 {\n" +
" protected abstract class R0 implements ILowerable { }\n" +
" protected class R1 extends R0 implements ILowerable playedBy T2229el3 {\n" +
" public String toString() { return \"Wrong\"; }\n" +
" }\n" +
" public void test(T2229el3 as R0 r) {\n" +
" System.out.print(r.lower());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Team2229el3 t = new Team2229el3();\n" +
" t.test(new T2229el3());\n" +
" }\n" +
"}\n" +
" \n",
"T2229el3.java",
"\n" +
"public class T2229el3 {\n" +
" public String toString() { return \"OK\"; }\n" +
"}\n" +
" \n"
},
"OK");
}
// Bug 391290 - Internal compiler error/Corrupt byte code
// witness for "tsuper has corrupt byte code" regarding call to _OT$getBase()
public void test2229_explicitLowering4() {
runConformTest(
new String[] {
"Team2229el4_2.java",
"public team class Team2229el4_2 extends Team2229el4_1 {\n" +
" public static void main(String[] args) {\n" +
" new Team2229el4_2().test(new T2229el4());\n" +
" }\n" +
"}\n",
"Team2229el4_1.java",
"public team class Team2229el4_1 {\n" +
" protected class R implements ILowerable playedBy T2229el4 {\n" +
" protected void test() {\n" +
" this.lower().bar();\n" +
" }\n" +
" }\n" +
" void test(T2229el4 as R r) { r.test(); }\n" +
"}\n",
"T2229el4.java",
"public class T2229el4 {\n" +
" void bar() { System.out.print(\"OK\"); }\n" +
"}\n"
},
"OK");
}
// Bug 391290 - Internal compiler error/Corrupt byte code
// positive case involving copy-inherited call to _OT$getBase()
public void test2229_explicitLowering4b() {
runConformTest(
new String[] {
"Team2229el4b_2.java",
"public team class Team2229el4b_2 extends Team2229el4b_1 {\n" +
" public static void main(String[] args) {\n" +
" new Team2229el4b_2().test(new T2229el4b());\n" +
" }\n" +
"}\n",
"Team2229el4b_1.java",
"public team class Team2229el4b_1 {" +
" protected team class Mid {\n" +
" protected class R playedBy T2229el4b {\n" +
" }\n" +
" protected void test(T2229el4b as R r) { " +
" T2229el4b b = r;\n" +
" b.bar();\n" +
" }\n" +
" }\n" +
" public void test(T2229el4b b) {\n" +
" new Mid().test(b);\n" +
" }\n" +
"}\n",
"T2229el4b.java",
"public class T2229el4b {\n" +
" void bar() { System.out.print(\"OK\"); }\n" +
"}\n",
},
"OK");
}
// a static team method tries to lift its parameter
// 2.2.30-otjld-declared-lifting-in-static-method
public void test2230_declaredLiftingInStaticMethod() {
runNegativeTestMatching(
new String[] {
"Team2230dlism.java",
"\n" +
"public team class Team2230dlism {\n" +
" protected class R playedBy T2230dlism {}\n" +
" static void erroneous(T2230dlism as R o) {}\n" +
"}\n" +
" \n",
"T2230dlism.java",
"\n" +
"public class T2230dlism {\n" +
"} \n" +
" \n"
},
"----------\n" +
"1. ERROR in Team2230dlism.java (at line 4)\n" +
" static void erroneous(T2230dlism as R o) {}\n" +
" ^^^^^^^^^^^^^^^\n" +
"Illegal type for argument o: declared lifting not allowed in static methods (OTJLD 2.3.2(a)).\n" +
"----------\n");
}
// a base object should be lifting before its ctor has finished (was TPX-487)
// 2.2.31-otjld-lifting-uninitialized-object-1
public void test2231_liftingUninitializedObject1() {
runConformTest(
new String[] {
"Team2231luo1.java",
"\n" +
"public team class Team2231luo1 {\n" +
" protected class R playedBy T2231luo1_2 {\n" +
" void test() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" test <- after test;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Team2231luo1 t = new Team2231luo1();\n" +
" t.activate();\n" +
" new T2231luo1_2();\n" +
" }\n" +
"}\n" +
" \n",
"T2231luo1_1.java",
"\n" +
"public class T2231luo1_1 {\n" +
" void test() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" T2231luo1_1() {\n" +
" test(); // dynamic call within ctor!\n" +
" }\n" +
"}\n" +
" \n",
"T2231luo1_2.java",
"\n" +
"public class T2231luo1_2 extends T2231luo1_1 {}\n" +
" \n"
},
"OK");
}
// a base object should be lifting before its ctor has finished - replace
// 2.2.31-otjld-lifting-uninitialized-object-2
public void test2231_liftingUninitializedObject2() {
runConformTest(
new String[] {
"Team2231luo2.java",
"\n" +
"public team class Team2231luo2 {\n" +
" protected class R playedBy T2231luo2_2 {\n" +
" callin void test() {\n" +
" base.test();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" test <- replace test;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Team2231luo2 t = new Team2231luo2();\n" +
" t.activate();\n" +
" new T2231luo2_2().test();\n" +
" }\n" +
"}\n" +
" \n",
"T2231luo2_1.java",
"\n" +
"public class T2231luo2_1 {\n" +
" void test() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" T2231luo2_1() {\n" +
" test(); // dynamic call within ctor!\n" +
" }\n" +
"}\n" +
" \n",
"T2231luo2_2.java",
"\n" +
"public class T2231luo2_2 extends T2231luo2_1 {}\n" +
" \n"
},
"OKOK");
}
// an abstract role class is bound to an abstract base class
// 2.2.32-otjld-lifting-to-abstract-role-1
public void test2232_liftingToAbstractRole1() {
runConformTest(
new String[] {
"Team2232ltar1.java",
"import org.objectteams.LiftingFailedException;\n" +
"@SuppressWarnings(\"abstractrelevantrole\")\n" +
"public team class Team2232ltar1 {\n" +
" protected abstract class R1 playedBy T2232ltar1_1 {\n" +
" void test() -> void test();\n" +
" }\n" +
" protected class R2 extends R1 playedBy T2232ltar1_2 { }\n" +
" Team2232ltar1(T2232ltar1_1 as R1 r) throws LiftingFailedException {\n" +
" r.test();\n" +
" }\n" +
" public static void main(String[] args) throws LiftingFailedException {\n" +
" new Team2232ltar1(new T2232ltar1_2());\n" +
" }\n" +
"}\n" +
" \n",
"T2232ltar1_1.java",
"\n" +
"public abstract class T2232ltar1_1 {\n" +
" public abstract void test();\n" +
"}\n" +
" \n",
"T2232ltar1_2.java",
"\n" +
"public class T2232ltar1_2 extends T2232ltar1_1 {\n" +
" public void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a role is explicitly created to a class that could not be produced by smart lifting, subsequent lifting callin fails
// 2.2.33-otjld-explicit-creation-breaks-lifting-1
public void test2233_explicitCreationBreaksLifting1() {
runConformTest(
new String[] {
"Team2233ecbl1.java",
"\n" +
"public team class Team2233ecbl1 {\n" +
" protected class R0 playedBy T2233ecbl1 {\n" +
" }\n" +
" protected class R1 extends R0 {\n" +
" void rm() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
" Team2233ecbl1 (T2233ecbl1 b) {\n" +
" this.activate();\n" +
" new R0(b); // only effect: insert role into cache!\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" T2233ecbl1 b = new T2233ecbl1();\n" +
" new Team2233ecbl1(b);\n" +
" try {\n" +
" b.bm();\n" +
" } catch (org.objectteams.WrongRoleException wre) {\n" +
" System.out.print(\"Caught\");\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"T2233ecbl1.java",
"\n" +
"public class T2233ecbl1 {\n" +
" void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
"}\n" +
" \n"
},
"OCaught");
}
// a nested team uses declared lifting, regular base class
// 2.2.34-otjld-declared-lifting-in-nested-team-1
public void test2234_declaredLiftingInNestedTeam1() {
runConformTest(
new String[] {
"Team2234dlint1.java",
"\n" +
"public team class Team2234dlint1 {\n" +
" public team class Inner {\n" +
" protected class R playedBy T2234dlint1 {\n" +
" void test() -> void test();\n" +
" }\n" +
" public void test(T2234dlint1 as R o) {\n" +
" o.test();\n" +
" }\n" +
" }\n" +
" void test() {\n" +
" new Inner().test(new T2234dlint1());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2234dlint1().test();\n" +
" }\n" +
"}\n" +
" \n",
"T2234dlint1.java",
"\n" +
"public class T2234dlint1 {\n" +
" public void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a nested team uses declared lifting, base class is role of outer team
// 2.2.34-otjld-declared-lifting-in-nested-team-2
public void test2234_declaredLiftingInNestedTeam2() {
runConformTest(
new String[] {
"Team2234dlint2.java",
"\n" +
"public team class Team2234dlint2 {\n" +
" protected class OuterRole {\n" +
" public void test() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" public team class Inner {\n" +
" protected class R playedBy OuterRole {\n" +
" void test() -> void test();\n" +
" }\n" +
" public void test(OuterRole as R o) {\n" +
" o.test();\n" +
" }\n" +
" }\n" +
" void test() {\n" +
" new Inner().test(new OuterRole());\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2234dlint2().test();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a method call could be resolved both with and without lowering - role type is more specific than lowered base
// 2.2.35-otjld-ambiguous-lowering-1
public void test2235_ambiguousLowering1() {
runConformTest(
new String[] {
"Team2235al1.java",
"\n" +
"public team class Team2235al1 {\n" +
" protected class R playedBy T2235al1 { }\n" +
" void test() {\n" +
" m1(new R(new T2235al1()));\n" +
" }\n" +
" void m1(T2235al1 b) {\n" +
" System.out.print(\"with lowering\");\n" +
" }\n" +
" void m1(R r) {\n" +
" System.out.print(\"without lowering\");\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Team2235al1 t = new Team2235al1();\n" +
" t.test();\n" +
" }\n" +
"}\n" +
" \n",
"T2235al1.java",
"\n" +
"public class T2235al1 {}\n" +
" \n"
},
"without lowering");
}
// a lifting participant creates roles using a custom constructor
// 2.2.36-otjld-lifting-participant-1
public void test2236_liftingParticipant1() {
Map customOptions = getCompilerOptions();
customOptions.put(CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation, CompilerOptions.DISABLED);
runConformTest(
new String[] {
"Team2236lp1.java",
"\n" +
"public team class Team2236lp1 {\n" +
" protected class R playedBy T2236lp1_1 {\n" +
" int n;\n" +
" public R(T2236lp1_1 b, int n) {\n" +
" this(b);\n" +
" this.n = n;\n" +
" }\n" +
" public void identify() {\n" +
" System.out.print(this.n);\n" +
" }\n" +
" }\n" +
" protected class R2 extends R playedBy T2236lp1_2 {\n" +
" }\n" +
" void test(T2236lp1_1 as R o) {\n" +
" o.identify();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Team2236lp1 t = new Team2236lp1();\n" +
" t.test(new T2236lp1_1());\n" +
" t.test(new T2236lp1_1());\n" +
" T2236lp1_1 b = new T2236lp1_1();\n" +
" t.test(b);\n" +
" t.test(b);\n" +
" t.test(new T2236lp1_1());\n" +
" t.test(new T2236lp1_2());\n" +
" }\n" +
"}\n" +
" \n",
"T2236lp1_1.java",
"\n" +
"public class T2236lp1_1 {\n" +
"}\n" +
" \n",
"T2236lp1_2.java",
"\n" +
"public class T2236lp1_2 extends T2236lp1_1 {\n" +
"}\n" +
" \n",
"lifter/T2236lp1Lifter.java",
"\n" +
"package lifter;\n" +
"import org.objectteams.ITeam;\n" +
"import java.lang.reflect.Constructor;\n" +
"public class T2236lp1Lifter implements org.objectteams.ILiftingParticipant {\n" +
" int count = 1;\n" +
" public Object createRole(ITeam teamInstance, Object base, String roleClassName) {\n" +
" try {\n" +
" Class<?> rc = Class.forName(roleClassName);\n" +
" Constructor<?>[] ctors = rc.getDeclaredConstructors();\n" +
" for (Constructor<?> ctor : ctors)\n" +
" if (ctor.getParameterTypes().length == 3)\n" +
" return ctor.newInstance(new Object[]{teamInstance, base, count++});\n" +
"\n" +
" } catch (Exception e) {\n" +
" e.printStackTrace();\n" +
" }\n" +
" return null;\n" +
" }\n" +
"}\n" +
" \n"
},
"123340",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
new String[] { "-Dot.lifting.participant=lifter.T2236lp1Lifter"}/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// a lifting participant creates a layered role using a custom constructor
// 2.2.36-otjld-lifting-participant-2
public void test2236_liftingParticipant2() {
Map customOptions = getCompilerOptions();
customOptions.put(CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation, CompilerOptions.DISABLED);
runConformTest(
new String[] {
"Team2236lp2_2.java",
"\n" +
"public team class Team2236lp2_2 {\n" +
" final Team2236lp2_1 otherTeam = new Team2236lp2_1();\n" +
" \n" +
" protected class R playedBy RLower1<@otherTeam> {\n" +
" int n;\n" +
" public R(RLower1<@otherTeam> b, int n) {\n" +
" this(b);\n" +
" this.n = n;\n" +
" }\n" +
" public void identify() {\n" +
" System.out.print(this.n);\n" +
" }\n" +
" identify <- after bm;\n" +
" }\n" +
" protected class R2 extends R playedBy RLower2<@otherTeam> {\n" +
" }\n" +
" protected void test(RLower1<@otherTeam> as R o) {\n" +
" o.identify();\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new Team2236lp2_2().runTests();\n" +
" }\n" +
" public void runTests() {\n" +
" test(new RLower1<@otherTeam>());\n" +
" test(new RLower1<@otherTeam>());\n" +
" RLower1<@otherTeam> b = new RLower1<@otherTeam>();\n" +
" test(b);\n" +
" test(b);\n" +
" test(new RLower1<@otherTeam>());\n" +
" test(new RLower2<@otherTeam>());\n" +
" this.activate();\n" +
" new Team2236lp2_1().new RLower1().bm(); // LiftingVetoException prevents callin\n" +
" }\n" +
"}\n" +
" \n",
"Team2236lp2_1.java",
"\n" +
"public team class Team2236lp2_1 {\n" +
" public class RLower1 { public void bm() {} }\n" +
" public class RLower2 extends RLower1 {}\n" +
"}\n" +
" \n",
"lifter/T2236lp2Lifter.java",
"\n" +
"package lifter;\n" +
"import org.objectteams.ITeam;\n" +
"import java.lang.reflect.Constructor;\n" +
"public class T2236lp2Lifter implements org.objectteams.ILiftingParticipant {\n" +
" int count = 1;\n" +
" public Object createRole(ITeam teamInstance, Object base, String roleClassName) {\n" +
" if (!roleClassName.startsWith(\"Team2236lp2_2$__OT__R\"))\n" +
" System.err.println(\"wrong role class name \"+roleClassName);\n" +
" try {\n" +
" Class<?> rc = Class.forName(roleClassName);\n" +
" Constructor<?>[] ctors = rc.getDeclaredConstructors();\n" +
" for (Constructor<?> ctor : ctors)\n" +
" if (ctor.getParameterTypes().length == 3)\n" +
" return ctor.newInstance(new Object[]{teamInstance, base, count++});\n" +
"\n" +
" } catch (Exception e) {\n" +
" e.printStackTrace();\n" +
" }\n" +
" return null;\n" +
" }\n" +
"}\n" +
" \n"
},
"123340",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
new String[]{ "-Dot.lifting.participant=lifter.T2236lp2Lifter" }/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
public void test2237_instantiationPolicy1() {
runConformTest(
true/*flushOutputDir*/,
new String[] {
"Team2237ip1.java",
"import static org.objectteams.InstantiationPolicy.*;\n" +
"import org.objectteams.Instantiation;\n" +
"public team class Team2237ip1 {\n" +
" @Instantiation(ALWAYS)\n" +
" protected class R playedBy T2237ip1 {\n" +
" protected void test() -> void test();\n" +
" equals => equals;\n" +
" hashCode => hashCode;\n" +
" }\n" +
" public void test(T2237ip1 as R o) {\n" +
" o.test();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" Team2237ip1 t = new Team2237ip1();\n" +
" T2237ip1 b = new T2237ip1();\n" +
" t.test(b);\n" +
" t.test(b);\n" +
" System.out.print(t.getAllRoles().length);\n" +
" }\n" +
"}\n",
"T2237ip1.java",
"public class T2237ip1 {\n" +
" void test() { System.out.print(\"OK\"); }\n" +
"}\n",
},
"", // explicitly check no warnings
"OKOK0",
"",
null/*no excuce*/);
}
public void test2237_instantiationPolicy2() {
runConformTest(
true/*flushOutputDir*/,
new String[] {
"Team2237ip2.java",
"import static org.objectteams.InstantiationPolicy.*;\n" +
"import org.objectteams.Instantiation;\n" +
"public team class Team2237ip2 {\n" +
" @Instantiation(ONDEMAND)\n" +
" protected class R playedBy T2237ip2 {\n" +
" protected void test() -> void test();\n" +
" }\n" +
" public void test(T2237ip2 as R o) {\n" +
" o.test();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" Team2237ip2 t = new Team2237ip2();\n" +
" T2237ip2 b = new T2237ip2();\n" +
" t.test(b);\n" +
" t.test(b);\n" +
" System.out.print(t.getAllRoles().length);\n" +
" }\n" +
"}\n",
"T2237ip2.java",
"public class T2237ip2 {\n" +
" void test() { System.out.print(\"OK\"); }\n" +
"}\n",
},
"",
"OKOK1",
"",
null/*no excuce*/);
}
public void test2237_instantiationPolicy3() {
runNegativeTest(
new String[] {
"NotATeam2237ip3.java",
"import static org.objectteams.InstantiationPolicy.*;\n" +
"import org.objectteams.Instantiation;\n" +
"public class NotATeam2237ip3 {\n" +
" @Instantiation(ONDEMAND)\n" +
" protected class R {\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in NotATeam2237ip3.java (at line 4)\n" +
" @Instantiation(ONDEMAND)\n" +
" ^^^^^^^^^^^^^^\n" +
"Annotation \'@Instantiation\' can only be applied to role classes (OTJLD 2.3.1(d)).\n" +
"----------\n");
}
public void test2237_instantiationPolicy4() {
runNegativeTest(
new String[] {
"Team2237ip4.java",
"import static org.objectteams.InstantiationPolicy.*;\n" +
"import org.objectteams.Instantiation;\n" +
"public team class Team2237ip4 {\n" +
" @Instantiation(ALWAYS)\n" +
" protected class R {\n" +
" int val = 0;\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. WARNING in Team2237ip4.java (at line 5)\n" +
" protected class R {\n" +
" ^\n" +
"Roles with InstantiationPolicy \'ALWAYS\' should define equals() and hashCode() methods (OTJLD 2.3.1(d)).\n" +
"----------\n" +
"2. WARNING in Team2237ip4.java (at line 6)\n" +
" int val = 0;\n" +
" ^^^\n" +
"Fields are discouraged in roles with InstantiationPolicy \'ALWAYS\' (OTJLD 2.3.1(d)).\n" +
"----------\n");
}
// [compiler] resolve error re lifting constructor with implicit playedBy refinement
public void testBug400833() {
runConformTest(
new String[] {
"to/TOuter.java",
"package to;\n" +
"\n" +
"\n" +
"import base tb.TB1;\n" +
"import base tb.TB2;\n" +
"\n" +
"public team class TOuter {\n" +
" public team class T1 playedBy TB1 {\n" +
" protected class R playedBy B<@base> { }\n" +
" /* added method */\n" +
" public void test() {\n" +
" new R(new B<@base>()); // works!\n" +
" }\n" +
" }\n" +
" public team class T2 extends T1 playedBy TB2 {\n" +
" @Override\n" +
" protected class R playedBy B<@base> { }\n" +
" @Override\n" +
" public void test() {\n" +
" new R(new B<@base>()); // error!\n" +
" }\n" +
" }\n" +
" void test(TB2 as T2 t2) {\n" +
" t2.test();\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new TOuter().test(new tb.TB2());\n" +
" }\n" +
"}\n",
"tb/TB2.java",
"package tb;\n" +
"public team class TB2 extends TB1 {\n" +
" @Override public class B {\n" +
" public B() { System.out.print(\"OK\"); }\n" +
" }\n" +
"}\n",
"tb/TB1.java",
"package tb;\n" +
"public team class TB1 {\n" +
" public class B {}\n" +
"}\n",
},
"OK");
}
// [otdre] SneakyException spoils catching of LiftingVetoException
public void testBug479687() {
runConformTest(
new String[] {
"MyTeam.java",
"import org.objectteams.LiftingVetoException;\n" +
"public team class MyTeam {\n" +
" protected class R playedBy MyBase {\n" +
" void throwingMethod() throws LiftingVetoException {\n" +
" throw new LiftingVetoException();\n" +
" }\n" +
" throwingMethod <- before baseMethod;\n" +
" }\n" +
" public static void main(String... args) {\n" +
" new MyTeam().activate();\n" +
" new MyBase().baseMethod();\n" +
" }\n" +
"}\n",
"MyBase.java",
"public class MyBase {\n" +
" void baseMethod() {\n" +
" System.out.print(\"base\");\n" +
" }\n" +
"}\n"
},
"base");
}
}