Google Git
Sign in
eclipse / objectteams / org.eclipse.objectteams / d0fe02bf25ba6512f929ef41e20aed6913b9a433 / . / testplugins / org.eclipse.objectteams.otdt.tests / otjld / org / eclipse / objectteams / otdt / tests / otjld / regression / DevelopmentExamples.java
blob: 746effedab0a82386c38216253f9edd58370eccb [file] [log] [blame]
/**********************************************************************
* This file is part of "Object Teams Development Tooling"-Software
*
* Copyright 2005-2016 Berlin Institute of Technology, Germany.
*
* 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:
* Berlin Institute of Technology - Initial API and implementation
**********************************************************************/
package org.eclipse.objectteams.otdt.tests.otjld.regression;
import java.util.Map;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.objectteams.otdt.core.ext.WeavingScheme;
import org.eclipse.objectteams.otdt.tests.otjld.AbstractOTJLDTest;
import junit.framework.Test;
/**
* @author Christine Hundt
* @author Stephan Herrmann
*/
@SuppressWarnings("unchecked")
public class DevelopmentExamples extends AbstractOTJLDTest {
public DevelopmentExamples(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[] { "testX12_resultLifting2"};
// TESTS_NUMBERS = new int[] { 1459 };
// TESTS_RANGE = new int[] { 1097, -1 };
}
public static Test suite() {
return buildComparableTestSuite(testClass());
}
public static Class testClass() {
return DevelopmentExamples.class;
}
// corner cases for callin with inheritance
// X.1.1-otjld-binding-inheritance-1
public void testX11_bindingInheritance1() {
runConformTest(
new String[] {
"test1/X11bi1Main.java",
"\n" +
"package test1;\n" +
"public class X11bi1Main {\n" +
" public static void main (String[] args) {\n" +
" new SubSubTeam().activate();\n" +
" //new CallinSuper().activate();\n" +
" //new CallinSub(\"t1\").activate();\n" +
" //new CallinSub(\"t2\").activate();\n" +
" //new ExtremeSub().activate(); // runntime-error: what is wrong with this??\n" +
" System.out.println((new B1(3)).getInt());\n" +
" B1 b = new B1(0);\n" +
" b.setPublicInt(1);\n" +
" System.out.println(\"--------------------------------------\");\n" +
" b.nop();\n" +
" System.out.println(\"--------------------------------------\");\n" +
" b.nop(1);\n" +
" System.out.println(\"--------------------------------------\");\n" +
" B2 b2 = new B2(\"Heiligabend\");\n" +
" //SubOfB2 b2 = new SubOfB2(\"Heiligabend\");\n" +
" b2.print(\"Geschenk\");\n" +
" //new CallinSuper().activate();\n" +
" //b.setInt(1);\n" +
" System.out.println(\"-------------------- Test for Base-Subclassing ---------------\");\n" +
" Person p = new Person(\"Ishi\");\n" +
" p.goToWork();\n" +
" System.out.println(\"---- just one sub base (Man) is effected by a callin ------\");\n" +
" System.out.println(\"---- defined in a sub role (BWLStudent):-----------------------\");\n" +
" Woman w = new Woman(\"Yukiko\");\n" +
" Man m = new Man(\"Tanaka\");\n" +
" w.goToWork();\n" +
" m.goToWork();\n" +
" System.out.println(\"----- callins are effective even for inherited base methods in sub bases: ------\");\n" +
" p.haveFun();\n" +
" w.haveFun();\n" +
" System.out.println(\"----- callins are inherited to neither redefinded nor rebound base methods: --\");\n" +
" p.performWorkstep();\n" +
" w.performWorkstep();\n" +
" }\n" +
"}\n" +
" \n",
"test1/B1.java",
"\n" +
"package test1;\n" +
"public class B1 {\n" +
" private int _value;\n" +
" public B1(int i) {\n" +
" _value = i;\n" +
" }\n" +
" public int getInt() {\n" +
" System.out.println(\"B1.getInt() called!\");\n" +
" return _value;\n" +
" }\n" +
" private void setInt(int i) {\n" +
" System.out.println(\"B1.setInt(\"+i+\") called!\");\n" +
" _value = i;\n" +
" }\n" +
" public void setPublicInt(int i) {\n" +
" setInt(i);\n" +
" }\n" +
" public void nop() {\n" +
" System.out.println(\"B1.nop() called!\");\n" +
" }\n" +
" public void nop(int i) {\n" +
" System.out.println(\"B1.nop(int) called!\");\n" +
" }\n" +
"}\n" +
" \n",
"test1/B2.java",
"\n" +
"package test1;\n" +
"import java.util.Date;\n" +
"public class B2 {\n" +
" private Date _date;\n" +
" @SuppressWarnings(\"unused\")\n" +
" private String _name;\n" +
" public B2(String name) {\n" +
" _date = new Date();\n" +
" _name = name;\n" +
" }\n" +
" public Date getDate(boolean update) {\n" +
" if (update)\n" +
" return new Date();\n" +
" return _date; // date of creation\n" +
" }\n" +
" public void print(String s) {\n" +
" System.out.print(\"B2.print: \" + s + \"\\n\");\n" +
" }\n" +
"}\n" +
" \n",
"test1/Person.java",
"\n" +
"package test1;\n" +
"public class Person {\n" +
" private String _name;\n" +
" public Person(String name) {\n" +
" _name = name;\n" +
" }\n" +
" public void goToWork() {\n" +
" System.out.println(\"Person.goToWork()\");\n" +
" }\n" +
" public void performWorkstep() {\n" +
" System.out.println(\"Person.performWorkstep()\");\n" +
" }\n" +
" public void haveFun() {\n" +
" System.out.println(\"Person.haveFun()\");\n" +
" }\n" +
" public String getName() {\n" +
" return _name;\n" +
" }\n" +
"}\n" +
" \n",
"test1/Woman.java",
"\n" +
"package test1;\n" +
"public class Woman extends Person {\n" +
" public Woman(String name) {\n" +
" super(name);\n" +
" }\n" +
" @Override\n" +
" public void goToWork() {\n" +
" System.out.println(\"She (\"+getName()+\") gose to work.\");\n" +
" }\n" +
" /*\n" +
" public void haveFun() {\n" +
" super.haveFun();\n" +
" }*/\n" +
" /*\n" +
" public void performWorkstep() {\n" +
" System.out.println(\"Woman.performWorkstep\");\n" +
" }*/\n" +
"}\n" +
" \n",
"test1/Man.java",
"\n" +
"package test1;\n" +
"public class Man extends Person {\n" +
" public Man(String name) {\n" +
" super(name);\n" +
" }\n" +
" @Override\n" +
" public void goToWork() {\n" +
" System.out.println(\"He (\"+getName()+\") gose to work.\");\n" +
" }\n" +
"}\n" +
" \n",
"test1/CallinSuper.java",
"\n" +
"package test1;\n" +
"public team class CallinSuper {\n" +
" public void superTeamMethod() {\n" +
" }\n" +
" public class Role playedBy B1 {\n" +
" callin void hook () {\n" +
" System.out.println(/*getName()+\": \"+*/\"CallinSuper.Role.hook()\");\n" +
" base.hook();\n" +
" }\n" +
" //hook <- replace getInt;\n" +
" //void hook() <- replace int getInt() with {}\n" +
" callin void check(int i) {\n" +
" System.out.println(\"CallinSuper.Role.check(\"+i+\")\");\n" +
" if (i<0)\n" +
" throw new Error(\"only positive numbers allowed!!\");\n" +
" base.check(i);\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\")\n" +
" check <- replace setInt;\n" +
" }\n" +
" public class Role3 {//playedBy B2 \n" +
" callin void format(String s) {\n" +
" System.out.println(\"CallinSuper.Role3.format: \" + s.toUpperCase());\n" +
" base.format(\"von CallinSuper.Role3\");\n" +
" }\n" +
" //format <- replace print;\n" +
" }\n" +
" public class Student playedBy Person {\n" +
" callin void doHomework() {\n" +
" System.out.println(\"Stundent.doHomework()\");\n" +
" base.doHomework();\n" +
" }\n" +
" void doHomework() <- replace void performWorkstep();\n" +
" callin void enterClassroom() {\n" +
" System.out.println(\"Stundent.enterClassroom()\");\n" +
" base.enterClassroom();\n" +
" }\n" +
" }\n" +
" public class BWLStudent extends Student playedBy Man {\n" +
" void enterClassroom() <- replace void goToWork();\n" +
" }\n" +
" // -> Binding-Error: base-call impossible!\n" +
" public class JugglingStudent extends Student playedBy Woman {\n" +
" void enterClassroom() <- replace void haveFun();\n" +
" } //\n" +
"}\n" +
" \n",
"test1/CallinSub.java",
"\n" +
"package test1;\n" +
"public team class CallinSub extends CallinSuper {\n" +
"/*\n" +
" public CallinSub(String name) {\n" +
" super(name);\n" +
" }\n" +
"*/\n" +
" public class Role2 extends Role {\n" +
" @Override\n" +
" callin void hook () {\n" +
" System.out.println(/*getName()+\": \"+*/ \"CallinSub.Role2.hook()\");\n" +
" base.hook();\n" +
" //tsuper.hook(); // compiler: cannot resolve symbol <- okay\n" +
" super.hook();\n" +
" }\n" +
" // this works well:\n" +
" //void hook() <- replace void nop();\n" +
"// hook <- getInt;\n" +
" @Override\n" +
" void hook() <- replace int getInt();\n" +
" //void hook() <- void nop() with {}\n" +
" @Override\n" +
" callin void check(int i) {\n" +
" System.out.println(\"CallinSub.Role2.check(\"+i+\")\");\n" +
" base.check(i);\n" +
" super.check(i);\n" +
" }\n" +
" //check <- setInt;\n" +
" /*/ compiler-error:\n" +
" void check(int i) <- void nop() with {\n" +
" i <- 0\n" +
" }//*/\n" +
" }\n" +
" @Override\n" +
" public class Role3 playedBy B2 {\n" +
" @Override @SuppressWarnings(\"basecall\")\n" + // two basecalls (one is indirect)
" callin void format(String s) {\n" +
" System.out.println(\"CallinSub.Role3.format: \" + insertChars(\" \", s));\n" +
" base.format(\"von CallinSub.Role3\");\n" +
" tsuper.format(s);\n" +
" }\n" +
" //format <- replace print;\n" +
" String insertChars(String insert, String s) {\n" +
" char[] chrs = s.toCharArray();\n" +
" String result =\"\";\n" +
" for (int i=0; i<chrs.length; i++) {\n" +
" String tmp = chrs[i]+insert;\n" +
" result = result.concat(tmp);\n" +
" }\n" +
" return result;\n" +
" }\n" +
" }\n" +
"/*\n" +
" public class Role4 extends Role3 {\n" +
" callin void format(String s) {\n" +
" System.out.println(\"CallinSub.Role4.format: \" + s);\n" +
" base.format(\"von CallinSub.Role4\");\n" +
" super.format(s);\n" +
" }\n" +
" //format <- replace print;\n" +
" }*/\n" +
"}\n" +
" \n",
"test1/SubSubTeam.java",
"\n" +
"package test1;\n" +
"public team class SubSubTeam extends CallinSub {\n" +
" @Override\n" +
" public class Role3 {\n" +
" @Override @SuppressWarnings(\"basecall\")\n" + // two basecalls (one is indirect)
" callin void format(String s) {\n" +
" System.out.println(\"SubSubTeam.Role3.format: \" + s);\n" +
" base.format(\"von SubSubTeam.Role3\");\n" +
" tsuper.format(s);\n" +
" }\n" +
" void format(String s) <- replace void print(String s);\n" +
" }\n" +
" public class RoleX extends Role3 {\n" +
" @Override\n" +
" callin void format(String s) {\n" +
" System.out.println(\"SubSubTeam.RoleX.format: \" + super.insertChars(\"X\", s));\n" +
" base.format(\"von SubSubTeam.RoleX\");\n" +
" super.format(s);\n" +
" }\n" +
" //format <- replace print;\n" +
" }\n" +
" public class RoleNOP extends Role2 {\n" +
" callin void nop() {\n" +
" System.out.println(\"SubSubTeam.RoleNOP.nop() called!\");\n" +
" base.nop();\n" +
" }\n" +
" //nop <- after nop; // okay\n" +
" //hook <- nop //-> compiler error!\n" +
" //void hook() <- void nop(); //-> compiler error!\n" +
"/*\n" +
" callin void hook () {\n" +
" System.out.println(\"SubSubTeam.RoleNOP.hook\");\n" +
" base.hook();\n" +
" //tsuper.hook(); // compiler: cannot resolve symbol <- okay\n" +
" super.hook();\n" +
" }\n" +
"*/\n" +
" void hook() <- replace void nop();\n" +
" //void hook() <- replace void nop(int i) with {}\n" +
" void nop() <- replace void nop(int i); \n" +
" }\n" +
" @Override\n" +
" public class Role2 {\n" +
" @Override\n" +
" callin void hook () {\n" +
" System.out.println(\"SubSub.Role2.hook()\");\n" +
" base.hook();\n" +
" //tsuper.hook();\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"SubSub.Role2.hook()\n" +
"B1.getInt() called!\n" +
"3\n" +
"CallinSub.Role2.check(1)\n" +
"B1.setInt(1) called!\n" +
"CallinSuper.Role.check(1)\n" +
"B1.setInt(1) called!\n" +
"--------------------------------------\n" +
"SubSub.Role2.hook()\n" +
"B1.nop() called!\n" +
"--------------------------------------\n" +
"SubSubTeam.RoleNOP.nop() called!\n" +
"B1.nop(int) called!\n" +
"--------------------------------------\n" +
"SubSubTeam.RoleX.format: GXeXsXcXhXeXnXkX\n" +
"B2.print: von SubSubTeam.RoleX\n" +
"SubSubTeam.Role3.format: Geschenk\n" +
"B2.print: von SubSubTeam.Role3\n" +
"CallinSub.Role3.format: G e s c h e n k \n" +
"B2.print: von CallinSub.Role3\n" +
"CallinSuper.Role3.format: GESCHENK\n" +
"B2.print: von CallinSuper.Role3\n" +
"-------------------- Test for Base-Subclassing ---------------\n" +
"Person.goToWork()\n" +
"---- just one sub base (Man) is effected by a callin ------\n" +
"---- defined in a sub role (BWLStudent):-----------------------\n" +
"She (Yukiko) gose to work.\n" +
"Stundent.enterClassroom()\n" +
"He (Tanaka) gose to work.\n" +
"----- callins are effective even for inherited base methods in sub bases: ------\n" +
"Person.haveFun()\n" +
"Stundent.enterClassroom()\n" +
"Person.haveFun()\n" +
"----- callins are inherited to neither redefinded nor rebound base methods: --\n" +
"Stundent.doHomework()\n" +
"Person.performWorkstep()\n" +
"Stundent.doHomework()\n" +
"Person.performWorkstep()");
}
// inherit a role method binding declared in the the super-super role of the super-super team
// X.1.1-otjld-binding-inheritance-2
public void testX11_bindingInheritance2() {
runConformTest(
new String[] {
"test1/MainX112.java",
"\n" +
"package test1;\n" +
"public class MainX112 {\n" +
" public static void main (String[] args) {\n" +
" MyBaseX112 b = new MyBaseX112();\n" +
" MySubTeamX112 mst = new MySubTeamX112();\n" +
" mst.activate();\n" +
" b.bm1();\n" +
" b.bm2();\n" +
" }\n" +
"}\n" +
" \n",
"test1/MyBaseX112.java",
"\n" +
"package test1;\n" +
"public class MyBaseX112 {\n" +
" public void bm1() {\n" +
" System.out.println(\"MyBase.bm1()\");\n" +
" }\n" +
" public void bm2() {\n" +
" System.out.println(\"MyBase.bm2()\");\n" +
" } \n" +
"}\n" +
" \n",
"test1/MySuperTeamX112.java",
"\n" +
"package test1;\n" +
"public team class MySuperTeamX112 {\n" +
" public class MyRole1X112 playedBy MyBaseX112 {\n" +
" callin void rm() {\n" +
" System.out.println(\"MySuperTeam.MyRole1.rm()\");\n" +
" base.rm();\n" +
" }\n" +
" rm <- replace bm1; \n" +
" } \n" +
"}\n" +
" \n",
"test1/MyTeamX112.java",
"\n" +
"package test1;\n" +
"public team class MyTeamX112 extends MySuperTeamX112 {\n" +
"}\n" +
" \n",
"test1/MySubTeamX112.java",
"\n" +
"package test1;\n" +
"public team class MySubTeamX112 extends MyTeamX112 {\n" +
" public class MyRole2X112 extends MyRole1X112 {\n" +
" }\n" +
" \n" +
" public class MyRole3X112 extends MyRole2X112 {\n" +
" rm <- replace bm2;\n" +
" }\n" +
"}\n" +
" \n"
},
"MySuperTeam.MyRole1.rm()\n" +
"MyBase.bm1()\n" +
"MySuperTeam.MyRole1.rm()\n" +
"MyBase.bm2()");
}
// redefine a role method in a sub role in a sub team
// X.1.1-otjld-binding-inheritance-3
public void testX11_bindingInheritance3() {
runConformTest(
new String[] {
"test1/MainX113.java",
"\n" +
"package test1;\n" +
"public class MainX113 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX113 b = new MyBaseX113();\n" +
" MySubTeamX113 st = new MySubTeamX113();\n" +
" st.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"} \n",
"test1/MyBaseX113.java",
"\n" +
"package test1;\n" +
"public class MyBaseX113 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"test1/MyTeamX113.java",
"\n" +
"package test1;\n" +
"public team class MyTeamX113 {\n" +
" public class MyRoleX113 playedBy MyBaseX113 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test1/MySubTeamX113.java",
"\n" +
"package test1;\n" +
"public team class MySubTeamX113 extends MyTeamX113 {\n" +
" //public class MyRoleX113 {}\n" +
" public class MySubRoleX113 extends MyRoleX113 {\n" +
" public void rm() {\n" +
" System.out.println(\"MySubTeam.MySubRole.rm()\");\n" +
" }\n" +
" }\n" +
"\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MySubTeam.MySubRole.rm()");
}
// redefine a role method in a sub role in a sub team (start compile at Main)
// X.1.1-otjld-binding-inheritance-3a
public void testX11_bindingInheritance3a() {
runConformTest(
new String[] {
"test1/MainX113a.java",
"\n" +
"package test1;\n" +
"public class MainX113a {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX113a b = new MyBaseX113a();\n" +
" MySubTeamX113a st = new MySubTeamX113a();\n" +
" st.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"} \n",
"test1/MySubTeamX113a.java",
"\n" +
"package test1;\n" +
"public team class MySubTeamX113a extends MyTeamX113a {\n" +
" //public class MyRoleX113a {}\n" +
" public class MySubRoleX113a extends MyRoleX113a {\n" +
" public void rm() {\n" +
" System.out.println(\"MySubTeam.MySubRole.rm()\");\n" +
" }\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test1/MyTeamX113a.java",
"\n" +
"package test1;\n" +
"public team class MyTeamX113a {\n" +
" public class MyRoleX113a playedBy MyBaseX113a {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test1/MyBaseX113a.java",
"\n" +
"package test1;\n" +
"public class MyBaseX113a {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MySubTeam.MySubRole.rm()");
}
// redefine a role method in a sub role in a sub team (default package)
// X.1.1-otjld-binding-inheritance-3b
public void testX11_bindingInheritance3b() {
runConformTest(
new String[] {
"MainX113b.java",
"\n" +
"public class MainX113b {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX113b b = new MyBaseX113b();\n" +
" MySubTeamX113b st = new MySubTeamX113b();\n" +
" st.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"} \n",
"MyBaseX113b.java",
"\n" +
"public class MyBaseX113b {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX113b.java",
"\n" +
"public team class MyTeamX113b {\n" +
" public class MyRoleX113b playedBy MyBaseX113b {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"MySubTeamX113b.java",
"\n" +
"public team class MySubTeamX113b extends MyTeamX113b {\n" +
" //public class MyRoleX113b {}\n" +
" public class MySubRoleX113b extends MyRoleX113b {\n" +
" public void rm() {\n" +
" System.out.println(\"MySubTeam.MySubRole.rm()\");\n" +
" }\n" +
" }\n" +
"\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MySubTeam.MySubRole.rm()");
}
// super call in base method - super-super method is adapted too
// X.1.1-otjld-binding-inheritance-4
public void testX11_bindingInheritance4() {
runConformTest(
new String[] {
"MainX114.java",
"\n" +
"public class MainX114 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX114 b = new MyBaseX114();\n" +
" MyTeamX114 t = new MyTeamX114();\n" +
" t.activate();\n" +
" b.bm();\n" +
" System.out.println(\"----------------\");\n" +
" MySubSubBaseX114 ssb = new MySubSubBaseX114();\n" +
" ssb.bm();\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX114.java",
"\n" +
"public class MyBaseX114 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MySubBaseX114.java",
"\n" +
"public class MySubBaseX114 extends MyBaseX114 {}\n" +
" \n",
"MySubSubBaseX114.java",
"\n" +
"public class MySubSubBaseX114 extends MySubBaseX114 {\n" +
" public void bm() {\n" +
" super.bm();\n" +
" System.out.println(\"MySubSubBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX114.java",
"\n" +
"public team class MyTeamX114 {\n" +
" public class MyRoleX114 playedBy MyBaseX114 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"\n" +
" public class MySubRoleX114 extends MyRoleX114 playedBy MySubSubBaseX114 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MySubRole.rm()\");\n" +
" }\n" +
" }\n" +
"}\n"
},
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()\n" +
"----------------\n" +
"MyBase.bm()\n" +
"MySubSubBase.bm()\n" +
"MyTeam.MySubRole.rm()");
}
// super call in base method - only super-super method is adapted
// X.1.1-otjld-binding-inheritance-4a
public void testX11_bindingInheritance4a() {
runConformTest(
new String[] {
"MainX114a.java",
"\n" +
"public class MainX114a {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX114a b = new MyBaseX114a();\n" +
" MyTeamX114a t = new MyTeamX114a();\n" +
" t.activate();\n" +
" b.bm();\n" +
" System.out.println(\"----------------\");\n" +
" MySubSubBaseX114a ssb = new MySubSubBaseX114a();\n" +
" ssb.bm();\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX114a.java",
"\n" +
"public class MyBaseX114a {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MySubBaseX114a.java",
"\n" +
"public class MySubBaseX114a extends MyBaseX114a {}\n" +
" \n",
"MySubSubBaseX114a.java",
"\n" +
"public class MySubSubBaseX114a extends MySubBaseX114a {\n" +
" public void bm() {\n" +
" super.bm();\n" +
" System.out.println(\"MySubSubBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX114a.java",
"\n" +
"public team class MyTeamX114a {\n" +
" public class MyRoleX114a playedBy MyBaseX114a {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()\n" +
"----------------\n" +
"MyBase.bm()\n" +
"MySubSubBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// super call in base method - only super-super method is adapted, complete explicit super-chain , replace binding
// X.1.1-otjld-binding-inheritance-4b
public void testX11_bindingInheritance4b() {
runConformTest(
new String[] {
"MainX114b.java",
"\n" +
"public class MainX114b {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX114b b = new MyBaseX114b();\n" +
" MyTeamX114b t = new MyTeamX114b();\n" +
" t.activate();\n" +
" b.bm();\n" +
" System.out.println(\"----------------\");\n" +
" MySubSubBaseX114b ssb = new MySubSubBaseX114b();\n" +
" ssb.bm();\n" +
" }\n" +
"}\n" +
" \n",
"MyBaseX114b.java",
"\n" +
"public class MyBaseX114b {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MySubBaseX114b.java",
"\n" +
"public class MySubBaseX114b extends MyBaseX114b {\n" +
" public void bm() {\n" +
" super.bm();\n" +
" System.out.println(\"MySubBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MySubSubBaseX114b.java",
"\n" +
"public class MySubSubBaseX114b extends MySubBaseX114b {\n" +
" public void bm() {\n" +
" super.bm();\n" +
" System.out.println(\"MySubSubBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX114b.java",
"\n" +
"public team class MyTeamX114b {\n" +
" public class MyRoleX114b playedBy MyBaseX114b {\n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()\n" +
"----------------\n" +
"MyBase.bm()\n" +
"MySubBase.bm()\n" +
"MySubSubBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// wicked super call interferes with callin binding
// X.1.1-otjld-binding-inheritance-4c
public void testX11_bindingInheritance4c() {
runConformTest(
new String[] {
"TeamX114c.java",
"\n" +
"public team class TeamX114c {\n" +
" protected class R playedBy MyBaseX114c {\n" +
" callin void rm() { base.rm(); }\n" +
" rm <- replace bm;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" // not even instantiating the team!\n" +
" new MySubBaseX114c().bm();\n" +
" }\n" +
"}\n" +
" \n",
"MyBaseX114c.java",
"\n" +
"public class MyBaseX114c {\n" +
" void bm() { System.out.print(\"MyBase.bm\"); }\n" +
"}\n" +
" \n",
"MySubBaseX114c.java",
"\n" +
"public class MySubBaseX114c extends MyBaseX114c {\n" +
" void bm2() {\n" +
" super.bm();\n" +
" }\n" +
" void bm() {\n" +
" System.out.println(\"MySubBase.bm\");\n" +
" bm2();\n" +
" }\n" +
"}\n" +
" \n"
},
"MySubBase.bm\n" +
"MyBase.bm");
}
// super call in base method - like 4a but with relevant signature
public void testX11_bindingInheritance4d() {
runConformTest(
new String[] {
"MainX114d.java",
"\n" +
"public class MainX114d {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX114d b = new MyBaseX114d();\n" +
" MyTeamX114d t = new MyTeamX114d();\n" +
" t.activate();\n" +
" System.out.println(b.bm(\"OK\"));\n" +
" System.out.println(\"----------------\");\n" +
" MySubSubBaseX114d ssb = new MySubSubBaseX114d();\n" +
" System.out.println(ssb.bm(\"Hoki\"));\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX114d.java",
"\n" +
"public class MyBaseX114d {\n" +
" public String bm(String in) {\n" +
" System.out.println(\"MyBase.bm(\"+in+\")\");\n" +
" return \"retBase\";\n" +
" }\n" +
"}\n" +
" \n",
"MySubBaseX114d.java",
"\n" +
"public class MySubBaseX114d extends MyBaseX114d {}\n" +
" \n",
"MySubSubBaseX114d.java",
"\n" +
"public class MySubSubBaseX114d extends MySubBaseX114d {\n" +
" public String bm(String in) {\n" +
" String res = super.bm(in);\n" +
" System.out.println(\"MySubSubBase.bm(\"+in+\")\");\n" +
" return res;\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX114d.java",
"\n" +
"public team class MyTeamX114d {\n" +
" public class MyRoleX114d playedBy MyBaseX114d {\n" +
" public void rm(String in) {\n" +
" System.out.println(\"MyTeam.MyRole.rm(\"+in+\")\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.bm(OK)\n" +
"MyTeam.MyRole.rm(OK)\n" +
"retBase\n" +
"----------------\n" +
"MyBase.bm(Hoki)\n" +
"MySubSubBase.bm(Hoki)\n" +
"MyTeam.MyRole.rm(Hoki)\n" +
"retBase");
}
// wicked super call interferes with callin binding
// Bug 468712: [otdre] stack overflow at callin-bound base method involving wicked super call
public void testX11_bindingInheritance4e() {
runConformTest(
new String[] {
"TeamX114e.java",
"\n" +
"public team class TeamX114e {\n" +
" protected class R playedBy MyBaseX114e {\n" +
" callin int rm() {\n" +
" System.out.println(\"> R.rm\");\n" +
" int res = base.rm();\n" +
" System.out.println(\"< R.rm\");\n" +
" return res+1;\n" +
" }\n" +
" rm <- replace bmA, bmB;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new TeamX114e().activate();\n" +
" MySub2BaseX114e b = new MySub2BaseX114e();\n" +
" int res = b.bmA();\n" +
" res = b.bmB(res);\n" +
" System.out.println(res);\n" +
" }\n" +
"}\n" +
" \n",
"MyBaseX114e.java",
"\n" +
"public class MyBaseX114e {\n" +
" protected int bmA() { System.out.println(\"MyBase.bmA\"); return 1; }\n" +
" protected int bmB(int in) { System.out.println(\"MyBase.bmB\"); return in+2; }\n" + // 2 methods to challenge reuse of existing ReplaceWickedSuperCallsAdapter (OTDRE)
"}\n" +
" \n",
"MySubBaseX114e.java",
"\n" +
"public class MySubBaseX114e extends MyBaseX114e {\n" +
" protected int bmA2() {\n" +
" System.out.println(\"MySubBase.bmA2\");\n" +
" return super.bmA() + 4;\n" +
" }\n" +
" protected int bmA() {\n" +
" System.out.println(\"MySubBase.bmA\");\n" +
" return bmA2() + 8;\n" +
" }\n" +
" protected int bmB2(int in) {\n" +
" System.out.println(\"MySubBase.bmB2\");\n" +
" return super.bmB(in+16);\n" + // invoke is last before return
" }\n" +
" protected int bmB(int in) {\n" +
" System.out.println(\"MySubBase.bmB\");\n" +
" return bmB2(in+32) + 64;\n" +
" }\n" +
"}\n" +
" \n",
"MySub2BaseX114e.java",
"\n" +
"public class MySub2BaseX114e extends MySubBaseX114e {\n" +
" protected int bmA() {\n" +
" System.out.println(\"MySub2Base.bmA\");\n" +
" return super.bmA() + 128;\n" +
" }\n" +
" protected int bmB(int in) {\n" +
" System.out.println(\"MySub2Base.bmB\");\n" +
" return super.bmB(in+256) + 512;\n" +
" }\n" +
"}\n" +
" \n"
},
"> R.rm\n" +
"MySub2Base.bmA\n" +
"MySubBase.bmA\n" +
"MySubBase.bmA2\n" +
"MyBase.bmA\n" +
"< R.rm\n" +
"> R.rm\n" +
"MySub2Base.bmB\n" +
"MySubBase.bmB\n" +
"MySubBase.bmB2\n" +
"MyBase.bmB\n" +
"< R.rm\n" +
"1025");
}
// after callin inherited from super role, before callin to the same base method added
// X.1.1-otjld-binding-inheritance-5
public void testX11_bindingInheritance5() {
runConformTest(
new String[] {
"MainX115.java",
"\n" +
"public class MainX115 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX115 b = new MyBaseX115();\n" +
" MySubTeamX115 t = new MySubTeamX115();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX115.java",
"\n" +
"public class MyBaseX115 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX115.java",
"\n" +
"public team class MyTeamX115 {\n" +
" public class MyRoleX115 playedBy MyBaseX115 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"MySubTeamX115.java",
"\n" +
"public team class MySubTeamX115 extends MyTeamX115 {\n" +
" public class MyRoleX115 {\n" +
" rm <- before bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// after callin inherited from super base, before callin added to the same (inherited) base method in sub base
// X.1.1-otjld-binding-inheritance-6
public void testX11_bindingInheritance6() {
runConformTest(
new String[] {
"MainX116.java",
"\n" +
"public class MainX116 {\n" +
" public static void main(String[] args) {\n" +
" MySubBaseX116 sb = new MySubBaseX116();\n" +
" MyTeamX116 t = new MyTeamX116();\n" +
" t.activate();\n" +
" sb.bm();\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX116.java",
"\n" +
"public class MyBaseX116 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"MySubBaseX116.java",
"\n" +
"public class MySubBaseX116 extends MyBaseX116 {}\n" +
" \n",
"MyTeamX116.java",
"\n" +
"public team class MyTeamX116 {\n" +
" public class MyRoleX116 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" }\n" +
" public class MyRoleAX116 extends MyRoleX116 playedBy MyBaseX116 {\n" +
" rm <- after bm;\n" +
" }\n" +
" public class MyRoleBX116 extends MyRoleX116 playedBy MySubBaseX116 {\n" +
" rm <- before bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// callin inherited from a super base, another callin to a different team is added to the same base method in the sub base
// X.1.1-otjld-binding-inheritance-7
public void testX11_bindingInheritance7() {
runConformTest(
new String[] {
"MainX117.java",
"\n" +
"public class MainX117 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamXX117 tX = new MyTeamXX117();\n" +
" tX.activate();\n" +
" MyTeamYX117 tY = new MyTeamYX117();\n" +
" tY.activate();\n" +
" MyBaseAX117 myClassA = new MyBaseAX117();\n" +
" myClassA.method1();\n" +
" MyBaseBX117 myClassB = new MyBaseBX117();\n" +
" myClassB.method1();\n" +
"\n" +
" MyBaseAX117 myClassC = new MyBaseCX117();\n" +
" myClassC.method1(); \n" +
"\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseAX117.java",
"\n" +
"public class MyBaseAX117 {\n" +
" public void method1()\n" +
" {\n" +
" System.out.println(\"MyBaseA.method1()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyBaseBX117.java",
"\n" +
"public class MyBaseBX117 extends MyBaseAX117 {\n" +
" public void method1()\n" +
" {\n" +
" System.out.println(\"MyBaseB.method1()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyBaseCX117.java",
"\n" +
"public class MyBaseCX117 extends MyBaseBX117 {\n" +
" public void method1()\n" +
" {\n" +
" System.out.println(\"MyBaseC.method1()\");\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamXX117.java",
"\n" +
"public team class MyTeamXX117 {\n" +
" public class MyRole playedBy MyBaseAX117 \n" +
" {\n" +
" public void m1()\n" +
" {\n" +
" System.out.println(\"MyTeamX.MyRole.m1()\");\n" +
" }\n" +
"\n" +
" m1 <- after method1;\n" +
" } \n" +
"}\n" +
" \n",
"MyTeamYX117.java",
"\n" +
"public team class MyTeamYX117 {\n" +
" public class MyRole playedBy MyBaseBX117 \n" +
" {\n" +
" public void m1()\n" +
" {\n" +
" System.out.println(\"MyTeamY.MyRole.m1()\");\n" +
" }\n" +
"\n" +
" m1 <- after method1;\n" +
" } \n" +
"}\n" +
" \n"
},
"MyBaseA.method1()\n" +
"MyTeamX.MyRole.m1()\n" +
"MyBaseB.method1()\n" +
"MyTeamX.MyRole.m1()\n" +
"MyTeamY.MyRole.m1()\n" +
"MyBaseC.method1()\n" +
"MyTeamX.MyRole.m1()\n" +
"MyTeamY.MyRole.m1()");
}
// overridden callin method with non-void return type calls 'tsuper'
// X.1.1-otjld-binding-inheritance-8
public void testX11_bindingInheritance8() {
runConformTest(
new String[] {
"MainX118.java",
"\n" +
"public class MainX118 {\n" +
" public static void main(String[] args) {\n" +
" MySubTeamX118 t = new MySubTeamX118();\n" +
" t.activate();\n" +
" MyBaseX118 b = new MyBaseX118();\n" +
" System.out.print(b.bm());\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX118.java",
"\n" +
"public class MyBaseX118 {\n" +
" public String bm()\n" +
" {\n" +
" return \"K\";\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX118.java",
"\n" +
"public team class MyTeamX118 {\n" +
" public class MyRole playedBy MyBaseX118 \n" +
" {\n" +
" callin String rm()\n" +
" {\n" +
" return base.rm();\n" +
" }\n" +
"\n" +
" rm <- replace bm;\n" +
" } \n" +
"}\n" +
" \n",
"MySubTeamX118.java",
"\n" +
"public team class MySubTeamX118 extends MyTeamX118 {\n" +
" public class MyRole \n" +
" {\n" +
" callin String rm()\n" +
" {\n" +
" return \"O\" + tsuper.rm();\n" +
" }\n" +
" } \n" +
"}\n" +
" \n"
},
"OK");
}
// overridden callin method with non-void basic return type calls 'tsuper'
// X.1.1-otjld-binding-inheritance-8a
public void testX11_bindingInheritance8a() {
runConformTest(
new String[] {
"MainX118a.java",
"\n" +
"public class MainX118a {\n" +
" public static void main(String[] args) {\n" +
" MySubTeamX118a t = new MySubTeamX118a();\n" +
" t.activate();\n" +
" MyBaseX118a b = new MyBaseX118a();\n" +
" System.out.print(b.bm());\n" +
" }\n" +
"} \n" +
" \n",
"MyBaseX118a.java",
"\n" +
"public class MyBaseX118a {\n" +
" public int bm()\n" +
" {\n" +
" return 2;\n" +
" }\n" +
"}\n" +
" \n",
"MyTeamX118a.java",
"\n" +
"public team class MyTeamX118a {\n" +
" public class MyRole playedBy MyBaseX118a \n" +
" {\n" +
" callin int rm()\n" +
" {\n" +
" return base.rm();\n" +
" }\n" +
"\n" +
" rm <- replace bm;\n" +
" } \n" +
"}\n" +
" \n",
"MySubTeamX118a.java",
"\n" +
"public team class MySubTeamX118a extends MyTeamX118a {\n" +
" public class MyRole \n" +
" {\n" +
" callin int rm()\n" +
" {\n" +
" return 40 + tsuper.rm();\n" +
" }\n" +
" } \n" +
"}\n" +
" \n"
},
"42");
}
// a base class which is a role at the same time inherits a binding form its implicit super (role) class
// X.1.1-otjld-binding-inheritance-9
public void testX11_bindingInheritance9() {
runConformTest(
new String[] {
"TX11bi9Main.java",
"\n" +
" public class TX11bi9Main {\n" +
" public static void main(String[] args) {\n" +
" TX11bi9 b= new TX11bi9();\n" +
" TeamX11bi9 pt = new TeamX11bi9();\n" +
" TeamX11bi9_3 ot = new TeamX11bi9_3(pt);\n" +
" pt.activate();\n" +
" ot.activate();\n" +
" b.foo();\n" +
" \n" +
" //cleaning up a little.\n" +
" pt.deactivate();\n" +
" ot.deactivate();\n" +
" \n" +
" //Now the same thing again - with a Subteam.\n" +
" TX11bi9 b2= new TX11bi9();\n" +
" TeamX11bi9_2 pt2 = new TeamX11bi9_2(); //TeamX11bi9_2 \"is a\" TeamX11bi9\n" +
" TeamX11bi9_3 ot2 = new TeamX11bi9_3(pt2);\n" +
" pt2.activate();\n" +
" ot2.activate();\n" +
" b2.foo();\n" +
" }\n" +
" }\n" +
" \n",
"TX11bi9.java",
"\n" +
" public class TX11bi9 {\n" +
" public void foo(){\n" +
" System.out.println(\"bar\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX11bi9.java",
"\n" +
" public team class TeamX11bi9 { \n" +
" public class RX11bi9 playedBy TX11bi9 { \n" +
" public void bar(){\n" +
" System.out.println(\"Aspect woven\");\n" +
" //nothing here, except a JoinPoint\n" +
" } \n" +
" \n" +
" bar <- before foo;\n" +
" } \n" +
" }\n" +
" \n",
"TeamX11bi9_2.java",
"\n" +
" public team class TeamX11bi9_2 extends TeamX11bi9 { \n" +
" public class RX11bi9_2 extends RX11bi9 { \n" +
" } \n" +
" }\n" +
" \n",
"TeamX11bi9_3.java",
"\n" +
" public team class TeamX11bi9_3 { \n" +
" final TeamX11bi9 otherTeam;\n" +
" \n" +
" public TeamX11bi9_3(TeamX11bi9 other){\n" +
" otherTeam = other;\n" +
" }\n" +
"\n" +
" protected class RX11bi9_3 playedBy RX11bi9<@otherTeam> {\n" +
" public void foobar() {\n" +
" System.out.println(\"Aspect on Aspect woven\");\n" +
" }\n" +
" foobar <- before bar;\n" +
" } \n" +
" }\n" +
" \n"
},
"Aspect on Aspect woven\n" +
"Aspect woven\n" +
"bar\n" +
"Aspect on Aspect woven\n" +
"Aspect woven\n" +
"bar");
}
// a base class which is a role at the same time inherits a binding form its implicit super-super (role) class
// X.1.1-otjld-binding-inheritance-10
public void testX11_bindingInheritance10() {
runConformTest(
new String[] {
"TX11bi10Main.java",
"\n" +
" public class TX11bi10Main {\n" +
" public static void main(String[] args) {\n" +
" TX11bi10 b= new TX11bi10();\n" +
" TeamX11bi10 pt = new TeamX11bi10();\n" +
" TeamX11bi10_3 ot = new TeamX11bi10_3(pt);\n" +
" pt.activate();\n" +
" ot.activate();\n" +
" b.foo();\n" +
" \n" +
" //cleaning up a little.\n" +
" pt.deactivate();\n" +
" ot.deactivate();\n" +
" \n" +
" //Now the same thing again - with a Subteam.\n" +
" TX11bi10 b2= new TX11bi10();\n" +
" TeamX11bi10_2 pt2 = new TeamX11bi10_2(); //TeamX11bi10_2 \"is a\" TeamX11bi10\n" +
" TeamX11bi10_3 ot2 = new TeamX11bi10_3(pt2);\n" +
" pt2.activate();\n" +
" ot2.activate();\n" +
" b2.foo();\n" +
" }\n" +
" }\n" +
" \n",
"TX11bi10.java",
"\n" +
" public class TX11bi10 {\n" +
" public void foo(){\n" +
" System.out.println(\"bar\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX11bi10.java",
"\n" +
" public team class TeamX11bi10 { \n" +
" public class RX11bi10 playedBy TX11bi10 { \n" +
" public void bar(){\n" +
" System.out.println(\"Aspect woven\");\n" +
" //nothing here, except a JoinPoint\n" +
" } \n" +
" \n" +
" bar <- before foo;\n" +
" } \n" +
" }\n" +
" \n",
"TeamX11bi10_1.java",
"\n" +
" public team class TeamX11bi10_1 extends TeamX11bi10 { \n" +
" }\n" +
" \n",
"TeamX11bi10_2.java",
"\n" +
" public team class TeamX11bi10_2 extends TeamX11bi10_1 { \n" +
" public class RX11bi10_2 extends RX11bi10 { \n" +
" } \n" +
" }\n" +
" \n",
"TeamX11bi10_3.java",
"\n" +
" public team class TeamX11bi10_3 { \n" +
" final TeamX11bi10 otherTeam;\n" +
" \n" +
" public TeamX11bi10_3(TeamX11bi10 other){\n" +
" otherTeam = other;\n" +
" }\n" +
"\n" +
" protected class RX11bi10_3 playedBy RX11bi10<@otherTeam> {\n" +
" public void foobar() {\n" +
" System.out.println(\"Aspect on Aspect woven\");\n" +
" }\n" +
" foobar <- before bar;\n" +
" } \n" +
" }\n" +
" \n"
},
"Aspect on Aspect woven\n" +
"Aspect woven\n" +
"bar\n" +
"Aspect on Aspect woven\n" +
"Aspect woven\n" +
"bar");
}
// A role inherits a replace binding, sub-base is bound to an unrelated role (reported by Marco Mosconi)
// X.1.1-otjld-binding-inheritance-11
public void testX11_bindingInheritance11() {
runConformTest(
new String[] {
"TeamX11bi11.java",
"\n" +
"public team class TeamX11bi11 {\n" +
" protected class R1 playedBy TX11bi11_1 {\n" +
" callin void rm() {\n" +
" System.out.print(\"R1<-\");\n" +
" base.rm();\n" +
" }\n" +
" rm <- replace test;\n" +
" }\n" +
" protected class R2 extends R1 playedBy TX11bi11_2 {\n" +
" callin void rm() {\n" +
" System.out.print(\"R2<-\");\n" +
" base.rm();\n" +
" }\n" +
" }\n" +
" protected class R3 /*no extends*/ playedBy TX11bi11_3 {}\n" +
" public static void main(String[] args) {\n" +
" new TeamX11bi11().activate();\n" +
" new TX11bi11_1().test();\n" +
" new TX11bi11_2().test();\n" +
" new TX11bi11_3().test();\n" +
" }\n" +
"}\n" +
" \n",
"TX11bi11_1.java",
"\n" +
"public class TX11bi11_1 {\n" +
" void test() { \n" +
" System.out.print(\"B1.\");\n" +
" } \n" +
"}\n" +
" \n",
"TX11bi11_2.java",
"\n" +
"public class TX11bi11_2 extends TX11bi11_1 {\n" +
" void test() { \n" +
" System.out.print(\"B2.\");\n" +
" } \n" +
"}\n" +
" \n",
"TX11bi11_3.java",
"\n" +
"public class TX11bi11_3 extends TX11bi11_2 {\n" +
" void test() { \n" +
" System.out.print(\"B3.\");\n" +
" } \n" +
"}\n" +
" \n"
},
"R1<-B1.R2<-B2.R2<-B3.");
}
// a super-call bypasses a callin binding
// X.1.1-otjld-binding-inheritance-12
public void testX11_bindingInheritance12() {
runConformTest(
new String[] {
"TeamX11bi12.java",
"\n" +
"public team class TeamX11bi12 {\n" +
" protected class R playedBy TX11bi12_2 {\n" +
" void rm() {\n" +
" System.out.print(\"WRONG\");\n" +
" }\n" +
" rm <- after m;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new TeamX11bi12().activate();\n" +
" new TX11bi12_2().m2();\n" +
" }\n" +
"}\n" +
" \n",
"TX11bi12_1.java",
"\n" +
"public class TX11bi12_1 {\n" +
" public void m() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
"}\n" +
" \n",
"TX11bi12_2.java",
"\n" +
"public class TX11bi12_2 extends TX11bi12_1 {\n" +
" public void m2() {\n" +
" System.out.print(\"O\");\n" +
" super.m();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a super-call bypasses a callin binding - other team binds super version
// X.1.1-otjld-binding-inheritance-13
public void testX11_bindingInheritance13() {
runConformTest(
new String[] {
"TeamX11bi13_2.java",
"\n" +
"public team class TeamX11bi13_2 {\n" +
" protected class R playedBy TX11bi13_2 {\n" +
" void rm() {\n" +
" System.out.print(\"WRONG\");\n" +
" }\n" +
" rm <- after m;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" Class<?> tc = TeamX11bi13_1.class;\n" +
" new TeamX11bi13_2().activate();\n" +
" new TX11bi13_2().m2();\n" +
" }\n" +
"}\n" +
" \n",
"TX11bi13_1.java",
"\n" +
"public class TX11bi13_1 {\n" +
" public void m() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
"}\n" +
" \n",
"TX11bi13_2.java",
"\n" +
"public class TX11bi13_2 extends TX11bi13_1 {\n" +
" public void m2() {\n" +
" System.out.print(\"O\");\n" +
" super.m();\n" +
" }\n" +
"}\n" +
" \n",
"TeamX11bi13_1.java",
"\n" +
"public team class TeamX11bi13_1 {\n" +
" protected class R1 playedBy TX11bi13_1 {\n" +
" void snafu() {}\n" +
" snafu <- after m;\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// a callin to a private base method does not affect the unrelated version in a sub-base (reported by Oliver Frank)
// X.1.1-otjld-binding-inheritance-14
public void testX11_bindingInheritance14() {
runConformTest(
new String[] {
"TeamX11bi14.java",
"\n" +
"public team class TeamX11bi14 {\n" +
" protected class R playedBy X11bi14_1 {\n" +
" void no() { System.out.print(\"NO\"); }\n" +
" no <- before test;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new TeamX11bi14().activate();\n" +
" new X11bi14_2().callTest();\n" +
" }\n" +
"}\n" +
" \n",
"X11bi14_1.java",
"\n" +
"public class X11bi14_1 {\n" +
" @SuppressWarnings(\"unused\")\n" +
" private void test() {}\n" +
"}\n" +
" \n",
"X11bi14_2.java",
"\n" +
"public class X11bi14_2 extends X11bi14_1 {\n" +
" private void test() { System.out.print(\"OK\"); }\n" +
" public void callTest() {\n" +
" test();\n" +
" }\n" +
"}\n" +
" \n"
},
"OK");
}
// modeled after a situation in PullUpAdaptor, that could cause StackOverflowError
// (bug not reproduced, though, due to different loading sequence).
public void testX11_bindingInheritance15() {
runConformTest(
new String[] {
"TeamX11bi15.java",
"import base b.X11bi15_1;\n" +
"import base b.X11bi15_2;\n" +
"public team class TeamX11bi15 {\n" +
" protected class R1 playedBy X11bi15_1 {\n" +
" void no() { System.out.print(\"NO\"); }\n" +
" no <- before test;\n" +
" }\n" +
" protected class R2 playedBy X11bi15_2 {\n" +
" callin void ask() {\n" +
" System.out.print(\"?\");\n" +
" base.ask();\n" +
" }\n" +
" ask <- replace callTest;\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new TeamX11bi15().activate();\n" +
" new b.X11bi15_2().callTest();\n" +
" }\n" +
"}\n" +
" \n",
"b/X11bi15_1.java",
"package b;\n" +
"public class X11bi15_1 {\n" +
" void test() { System.out.print('!'); }\n" +
"}\n" +
" \n",
"b/X11bi15_2.java",
"package b;\n" +
"public class X11bi15_2 extends X11bi15_1 {\n" +
" public void callTest() {\n" +
" test();\n" +
" }\n" +
"}\n" +
" \n"
},
"?NO!");
}
public void testBug480257() {
runConformTest(
new String[] {
"MT.java",
"public team class MT {\n" +
" public class R playedBy C1A {\n" +
" void bm() <- replace void bm();\n" +
" callin void bm() {\n" +
" System.out.print(\"R\");\n" +
" base.bm();\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" new MT().activate();\n" +
" new C1B().bm();\n" +
" }\n" +
"}\n",
"C0.java",
"public class C0 {\n" +
" public void bm() {\n" +
" System.out.print(\"C0\");\n" +
" }\n" +
"}\n",
"C1A.java",
"public class C1A extends C0 {\n" +
"}\n",
"C1B.java",
"public class C1B extends C0 {\n" +
" @Override\n" +
" public void bm() {\n" +
" System.out.print(\"C1B-\");\n" +
" super.bm();\n" + // this super call was confused by the (unrelated) callin binding
" System.out.print('!');\n" +
" }\n" +
"}\n"
},
"C1B-C0!");
}
// base call requires a result lifting
// X.1.2-otjld-result-lifting-1
public void testX12_resultLifting1() {
runConformTest(
new String[] {
"test2/X12rl1Main.java",
"\n" +
"package test2;\n" +
"public class X12rl1Main {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX121 b = new MyBaseX121();\n" +
" MyTeamX121 t = new MyTeamX121();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
"\n" +
" \n",
"test2/MyBaseX121.java",
"\n" +
"package test2;\n" +
"public class MyBaseX121 {\n" +
" public MyBaseX121 bm() {\n" +
" System.out.println(\"MyBaseX121.bm()\");\n" +
" return this;\n" +
" }\n" +
"}\n" +
"\n" +
" \n",
"test2/MyTeamX121.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX121 {\n" +
" public class MyRoleX121 playedBy MyBaseX121 {\n" +
" callin MyRoleX121 rm() {\n" +
" System.out.println(\"MyTeamX121.MyRoleX121.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamX121.MyRoleX121.rm()\n" +
"MyBaseX121.bm()");
}
// base call requires a result lifting - 'replace' modifier missing
// X.1.2-otjld-result-lifting-1a
public void testX12_resultLifting1a() {
runNegativeTest(
new String[] {
"test2/MyTeamX121a.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX121a {\n" +
" public class MyRoleX121a playedBy MyBaseX121a {\n" +
" callin MyRoleX121a rm() {\n" +
" System.out.println(\"MyTeamX121a.MyRoleX121a.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" rm <- bm;\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX121a.java",
"\n" +
"package test2;\n" +
"public class MyBaseX121a {\n" +
" public MyBaseX121a bm() {\n" +
" System.out.println(\"MyBaseX121a.bm()\");\n" +
" return this;\n" +
" }\n" +
"}\n" +
"\n" +
" \n"
},
"----------\n" +
"1. ERROR in test2\\MyTeamX121a.java (at line 9)\n" +
" rm <- bm;\n" +
" ^^\n" +
"Callin modifier (before, after or replace) missing for callin-binding rm (OTJLD A.3.3).\n" +
"----------\n");
}
// base call requires a result lifting - 'replace' modifier missing (different compiler invocation)
// X.1.2-otjld-result-lifting-1b
public void testX12_resultLifting1b() {
runNegativeTest(
new String[] {
"test2/X12rl1bMain.java",
"\n" +
"package test2;\n" +
"public class X12rl1bMain {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX121b b = new MyBaseX121b();\n" +
" MyTeamX121b t = new MyTeamX121b();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
"\n" +
" \n",
"test2/MyTeamX121b.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX121b {\n" +
" public class MyRoleX121b playedBy MyBaseX121b {\n" +
" callin MyRoleX121b rm() {\n" +
" System.out.println(\"MyTeamX121b.MyRoleX121b.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" rm <- bm;\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX121b.java",
"\n" +
"package test2;\n" +
"public class MyBaseX121b {\n" +
" public MyBaseX121b bm() {\n" +
" System.out.println(\"MyBaseX121b.bm()\");\n" +
" return this;\n" +
" }\n" +
"}\n" +
"\n" +
" \n"
},
"----------\n" +
"1. ERROR in test2\\MyTeamX121b.java (at line 9)\n" +
" rm <- bm;\n" +
" ^^\n" +
"Callin modifier (before, after or replace) missing for callin-binding rm (OTJLD A.3.3).\n" +
"----------\n");
}
// base call requires a result lifting
// X.1.2-otjld-result-lifting-1c
public void testX12_resultLifting1c() {
runConformTest(
new String[] {
"test2/X12rl1cMain.java",
"\n" +
"package test2;\n" +
"public class X12rl1cMain {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX121 b = new MyBaseX121();\n" +
" MyTeamX121 t = new MyTeamX121();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
"\n" +
" \n",
"test2/MyBaseX121.java",
"\n" +
"package test2;\n" +
"public class MyBaseX121 {\n" +
" public MyBaseX121 bm() {\n" +
" System.out.println(\"MyBaseX121.bm()\");\n" +
" return this;\n" +
" }\n" +
"}\n" +
"\n" +
" \n",
"test2/MyTeamX121.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX121 {\n" +
" public class MyRoleX121 playedBy MyBaseX121 {\n" +
" callin MyRoleX121 rm() {\n" +
" System.out.println(\"MyTeamX121.MyRoleX121.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamX121.MyRoleX121.rm()\n" +
"MyBaseX121.bm()");
}
// base call requires a result lifting - team hierarchy -- wrong base call
// X.1.2-otjld-result-lifting-2a
public void testX12_resultLifting2a() {
runNegativeTest(
new String[] {
"test2/MySuperTeamX122a.java",
"\n" +
"package test2;\n" +
"public team class MySuperTeamX122a {\n" +
" public class MyRole1X122a /*playedBy MyBase1X122a*/ {\n" +
" callin MyRole2X122a rm() {\n" +
" System.out.println(\"MySuperTeamX122a.MyRole1X122a.rm()\");\n" +
" return base.m1();\n" +
" }\n" +
" }\n" +
" public class MyRole2X122a {}\n" +
"}\n" +
" \n",
"test2/MyBase2X122a.java",
"\n" +
"package test2;\n" +
"public class MyBase2X122a {\n" +
"}\n" +
" \n",
"test2/MyBase1X122a.java",
"\n" +
"package test2;\n" +
"public class MyBase1X122a {\n" +
" public MyBase2X122a bm() {\n" +
" System.out.println(\"MyBase1X122a.bm()\");\n" +
" return new MyBase2X122a();\n" +
" }\n" +
"}\n" +
" \n"
},
"----------\n" +
"1. ERROR in test2\\MySuperTeamX122a.java (at line 7)\n" +
" return base.m1();\n" +
" ^^^^^^^^^\n" +
"Illegal method in base call, can only call base version of the enclosing method rm() (OTJLD 4.3(a)).\n" +
"----------\n");
}
// base call requires a result lifting - team hierarchy
// X.1.2-otjld-result-lifting-2
public void testX12_resultLifting2() {
runConformTest(
new String[] {
"test2/MainX122.java",
"\n" +
"package test2;\n" +
"public class MainX122 {\n" +
" public static void main(String[] args) {\n" +
" MyBase1X122 b = new MyBase1X122();\n" +
" MyTeamX122 t = new MyTeamX122();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
"\n" +
" \n",
"test2/MyBase2X122.java",
"\n" +
"package test2;\n" +
"public class MyBase2X122 {\n" +
"}\n" +
" \n",
"test2/MyBase1X122.java",
"\n" +
"package test2;\n" +
"public class MyBase1X122 {\n" +
" public MyBase2X122 bm() {\n" +
" System.out.println(\"MyBase1X122.bm()\");\n" +
" return new MyBase2X122();\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySuperTeamX122.java",
"\n" +
"package test2;\n" +
"public team class MySuperTeamX122 {\n" +
" public class MyRole1X122 /*playedBy MyBase1X122*/ {\n" +
" callin MyRole2X122 rm() {\n" +
" System.out.println(\"MySuperTeamX122.MyRole1X122.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" }\n" +
" public class MyRole2X122 {}\n" +
"}\n" +
" \n",
"test2/MyTeamX122.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX122 extends MySuperTeamX122 {\n" +
" @Override\n" +
" public class MyRole1X122 playedBy MyBase1X122 {\n" +
" rm <- replace bm;\n" +
" }\n" +
" @Override\n" +
" public class MyRole2X122 playedBy MyBase2X122 {}\n" +
"}\n" +
" \n"
},
"MySuperTeamX122.MyRole1X122.rm()\n" +
"MyBase1X122.bm()");
}
// team hierarchy - creating empty subsub team with empty superteam
// X.1.2-otjld-result-lifting-3
public void testX12_resultLifting3() {
runConformTest(
new String[] {
"test2/MainX123.java",
"\n" +
"package test2;\n" +
"public class MainX123 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX123 b = new MyBaseX123();\n" +
" MySubTeamX123 t = new MySubTeamX123();\n" +
" t.go(b);\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX123.java",
"\n" +
"package test2;\n" +
"public class MyBaseX123 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBaseX123.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySuperTeamX123.java",
"\n" +
"package test2;\n" +
"public team class MySuperTeamX123 {}\n" +
" \n",
"test2/MyTeamX123.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX123 extends MySuperTeamX123 {\n" +
" @org.objectteams.ImplicitTeamActivation\n" +
" public void go(MyBaseX123 b) {\n" +
" b.bm();\n" +
" }\n" +
"\n" +
" public class MyRoleX123 playedBy MyBaseX123 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeamX123.MyRoleX123.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySubTeamX123.java",
"\n" +
"package test2;\n" +
"public team class MySubTeamX123 extends MyTeamX123 {}\n" +
" \n"
},
"MyBaseX123.bm()\n" +
"MyTeamX123.MyRoleX123.rm()");
}
// team hierarchy - creating empty subsub team with empty superteam (different compiler invocation)
// X.1.2-otjld-result-lifting-3a
public void testX12_resultLifting3a() {
runConformTest(
new String[] {
"test2/MainX123a.java",
"\n" +
"package test2;\n" +
"public class MainX123a {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX123a b = new MyBaseX123a();\n" +
" MySubTeamX123a t = new MySubTeamX123a();\n" +
" t.go(b);\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySuperTeamX123a.java",
"\n" +
"package test2;\n" +
"public team class MySuperTeamX123a {}\n" +
" \n",
"test2/MyTeamX123a.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX123a extends MySuperTeamX123a {\n" +
" @org.objectteams.ImplicitTeamActivation\n" +
" public void go(MyBaseX123a b) {\n" +
" b.bm();\n" +
" }\n" +
"\n" +
" public class MyRoleX123a playedBy MyBaseX123a {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeamX123a.MyRoleX123a.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX123a.java",
"\n" +
"package test2;\n" +
"public class MyBaseX123a {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBaseX123a.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySubTeamX123a.java",
"\n" +
"package test2;\n" +
"public team class MySubTeamX123a extends MyTeamX123a {}\n" +
" \n"
},
"MyBaseX123a.bm()\n" +
"MyTeamX123a.MyRoleX123a.rm()");
}
// desc???
// X.1.2-otjld-result-lifting-4
public void testX12_resultLifting4() {
runConformTest(
new String[] {
"test2/Main4.java",
"\n" +
"package test2;\n" +
"public class Main4 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX124 b = new MyBaseX124();\n" +
" //MyTeamX124 t = new MyTeamX124();\n" +
" MySubTeamX124 t = new MySubTeamX124();\n" +
"\n" +
" t.go(b);\n" +
"\n" +
" //System.out.println(\"---- Team is NOT active ---------\");\n" +
" //b.bm();\n" +
" //t.activate();\n" +
" //b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test2/MySuperTeamX124.java",
"\n" +
"package test2;\n" +
"public team class MySuperTeamX124 {\n" +
" /*\n" +
" public void go(MyBaseX124 b) {\n" +
" b.bm();\n" +
" }*/\n" +
"}\n" +
" \n",
"test2/MyTeamX124.java",
"\n" +
"package test2;\n" +
"public team class MyTeamX124 extends MySuperTeamX124 {\n" +
" @org.objectteams.ImplicitTeamActivation\n" +
" public void go(MyBaseX124 b) {\n" +
"/*\n" +
" if (b.equals(\"test\")) {\n" +
" return;\n" +
" }\n" +
" \n" +
" if (b==null) {\n" +
" System.out.println(\"b was null\");\n" +
" b.bm();\n" +
" return;\n" +
" }\n" +
" b.bm();\n" +
" return;\n" +
"*/\n" +
" b.bm();\n" +
" }\n" +
"\n" +
" public class MyRoleX124 playedBy MyBaseX124 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeamX124.MyRoleX124.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX124.java",
"\n" +
"package test2;\n" +
"public class MyBaseX124 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBaseX124.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"test2/MySubTeamX124.java",
"\n" +
"package test2;\n" +
"public team class MySubTeamX124 extends MyTeamX124 {}\n" +
" \n"
},
"MyBaseX124.bm()\n" +
"MyTeamX124.MyRoleX124.rm()");
}
// base call result lifting for role in nested team
// X.1.2-otjld-result-lifting-5
public void testX12_resultLifting5() {
runConformTest(
new String[] {
"test2/MainX125.java",
"\n" +
"package test2;\n" +
"public class MainX125 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX125 b = new MyBaseX125();\n" +
" MyOuterTeamX125 t = new MyOuterTeamX125();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyBaseX125.java",
"\n" +
"package test2;\n" +
"public class MyBaseX125 {\n" +
" public MyBaseX125 bm() {\n" +
" return this;\n" +
" }\n" +
" @Override public String toString() {\n" +
" return\"NOTOK!\";\n" +
" }\n" +
"}\n" +
" \n",
"test2/MyOuterTeamX125.java",
"\n" +
"package test2;\n" +
"public team class MyOuterTeamX125 {\n" +
" MyOuterTeamX125() {\n" +
" activate();\n" +
" new MyInnerTeamX125();\n" +
" }\n" +
" \n" +
" public team class MyInnerTeamX125 {\n" +
" public MyInnerTeamX125() {\n" +
" activate();\n" +
" }\n" +
" public class MyRoleX125 playedBy MyBaseX125 {\n" +
" @Override public String toString() {\n" +
" return \"OK!\";\n" +
" }\n" +
" @SuppressWarnings(\"ambiguouslowering\") callin MyRoleX125 rm() {\n" +
" MyRoleX125 r = base.rm();\n" +
" System.out.print(r);\n" +
" return r;\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK!");
}
// callin to callin to callin to base method with base calls
// X.1.3-otjld-callin-to-callin-1
public void testX13_callinToCallin1() {
runConformTest(
new String[] {
"test3/MainX131.java",
"\n" +
"package test3;\n" +
"public class MainX131 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamCX131 mtc = new MyTeamCX131();\n" +
" mtc.activate();\n" +
" MyBaseX131 mb = new MyBaseX131();\n" +
" mb.doBase(\"test\");\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyBaseX131.java",
"\n" +
"package test3;\n" +
"\n" +
"public class MyBaseX131 {\n" +
" public void doBase(String s) {\n" +
" System.out.println(\"MyBase.doBase(s)\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test3/MyTeamAX131.java",
"\n" +
"package test3;\n" +
"public team class MyTeamAX131 {\n" +
" public class LowerRoleX131 playedBy MyBaseX131 {\n" +
" callin void doA(String s) {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA(s)\");\n" +
" base.doA(s);\n" +
" }\n" +
" doA <- replace doBase;\n" +
"\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamBX131.java",
"\n" +
"package test3;\n" +
"public team class MyTeamBX131 {\n" +
"\n" +
" final MyTeamAX131 thatTeam = new MyTeamAX131();\n" +
" public MyTeamBX131() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call to doA\n" +
" public class MyStackedRoleX131 playedBy LowerRoleX131<@thatTeam> {\n" +
" callin void doB() {\n" +
" base.doB();\n" +
" System.out.println(\"MyTeamB.MyStackedRole.doB()\");\n" +
" }\n" +
" doB <- replace doA;\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamCX131.java",
"\n" +
"package test3;\n" +
"public team class MyTeamCX131 {\n" +
"\n" +
" final MyTeamBX131 thatTeam = new MyTeamBX131();\n" +
" public MyTeamCX131() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call to doB\n" +
" protected class MyStackedRoleX131 playedBy MyStackedRoleX131<@thatTeam> {\n" +
" callin void doC() {\n" +
" base.doC();\n" +
" System.out.println(\"MyTeamC.MyStackedRole.doC()\");\n" +
" }\n" +
" doC <- replace doB;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamA.LowerRole.doA(s)\n" +
"MyBase.doBase(s)\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()");
}
// one callin to a callin method and to a non-callin method
// X.1.3-otjld-callin-to-callin-2
public void testX13_callinToCallin2() {
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"test3/MainX132.java",
"\n" +
"package test3;\n" +
"public class MainX132 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamCX132 mtc = new MyTeamCX132();\n" +
" mtc.activate();\n" +
" MyBaseX132 mb = new MyBaseX132();\n" +
" mb.doBase(\"test\");\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamCX132.java",
"\n" +
"package test3;\n" +
"public team class MyTeamCX132 {\n" +
"\n" +
" final MyTeamBX132 thatTeam = new MyTeamBX132();\n" +
" public MyTeamCX132() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" \n" +
" protected class MyStackedRoleX132 playedBy MyStackedRoleX132<@thatTeam> {\n" +
" callin void doC() {\n" +
" base.doC();\n" +
" System.out.println(\"MyTeamC.MyStackedRole.doC()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" doC <- replace doB;\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyBaseX132.java",
"\n" +
"package test3;\n" +
"\n" +
"public class MyBaseX132 {\n" +
" public void doBase(String s) {\n" +
" System.out.println(\"MyBase.doBase(s)\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test3/MyTeamAX132.java",
"\n" +
"package test3;\n" +
"public team class MyTeamAX132 {\n" +
" public class LowerRoleX132 playedBy MyBaseX132 {\n" +
" void doA1() {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA1()\");\n" +
" }\n" +
" void doA1() <- before void doBase(String s);\n" +
" \n" +
" callin void doA(String s) {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA(s)\");\n" +
" base.doA(s);\n" +
" }\n" +
" void doA(String sa) <- replace void doBase(String sb);\n" +
"\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamBX132.java",
"\n" +
"package test3;\n" +
"public team class MyTeamBX132 {\n" +
"\n" +
" final MyTeamAX132 thatTeam = new MyTeamAX132();\n" +
" public MyTeamBX132() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" public class MyStackedRoleX132 playedBy LowerRoleX132<@thatTeam> {\n" +
" callin void doB() {\n" +
" base.doB();\n" +
" System.out.println(\"MyTeamB.MyStackedRole.doB()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" void doB() <- replace void doA(String s);\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" void doB() <- replace void doA1();\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamA.LowerRole.doA1()\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()\n" +
"MyTeamA.LowerRole.doA(s)\n" +
"MyBase.doBase(s)\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
null/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// one callin to a callin method and to a non-callin method - compress to one binding
// X.1.3-otjld-callin-to-callin-2a
public void testX13_callinToCallin2a() {
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"test3/MainX132a.java",
"\n" +
"package test3;\n" +
"public class MainX132a {\n" +
" public static void main(String[] args) {\n" +
" MyTeamCX132a mtc = new MyTeamCX132a();\n" +
" mtc.activate();\n" +
" MyBaseX132a mb = new MyBaseX132a();\n" +
" mb.doBase(\"test\");\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamBX132a.java",
"\n" +
"package test3;\n" +
"public team class MyTeamBX132a {\n" +
"\n" +
" final MyTeamAX132a thatTeam = new MyTeamAX132a();\n" +
" public MyTeamBX132a() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" public class MyStackedRoleX132a playedBy LowerRoleX132a<@thatTeam> {\n" +
" callin void doB() {\n" +
" base.doB();\n" +
" System.out.println(\"MyTeamB.MyStackedRole.doB()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" void doB() <- replace void doA(String s);\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" void doB() <- replace void doA1();\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamCX132a.java",
"\n" +
"package test3;\n" +
"public team class MyTeamCX132a {\n" +
"\n" +
" final MyTeamBX132a thatTeam = new MyTeamBX132a();\n" +
" public MyTeamCX132a() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" \n" +
" protected class MyStackedRoleX132a playedBy MyStackedRoleX132a<@thatTeam> {\n" +
" callin void doC() {\n" +
" base.doC();\n" +
" System.out.println(\"MyTeamC.MyStackedRole.doC()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" doC <- replace doB;\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyBaseX132a.java",
"\n" +
"package test3;\n" +
"\n" +
"public class MyBaseX132a {\n" +
" public void doBase(String s) {\n" +
" System.out.println(\"MyBase.doBase(s)\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test3/MyTeamAX132a.java",
"\n" +
"package test3;\n" +
"public team class MyTeamAX132a {\n" +
" public class LowerRoleX132a playedBy MyBaseX132a {\n" +
" void doA1() {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA1()\");\n" +
" }\n" +
" void doA1() <- before void doBase(String s);\n" +
" \n" +
" callin void doA(String s) {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA(s)\");\n" +
" base.doA(s);\n" +
" }\n" +
" void doA(String sa) <- replace void doBase(String sb);\n" +
"\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamA.LowerRole.doA1()\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()\n" +
"MyTeamA.LowerRole.doA(s)\n" +
"MyBase.doBase(s)\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
null/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// callin from a nested team to a callin method
// X.1.3-otjld-callin-to-callin-3
public void testX13_callinToCallin3() {
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"test3/MainX133.java",
"\n" +
"package test3;\n" +
"public class MainX133 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamBX133 mtb = new MyTeamBX133();\n" +
" mtb.activate();\n" +
" MyBaseX133 mb = new MyBaseX133();\n" +
" mb.doBase();\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamBX133.java",
"\n" +
"package test3;\n" +
"public team class MyTeamBX133 {\n" +
" public MyTeamBX133() {\n" +
" new MyInnerTeamX133(new MyTeamAX133());\n" +
" }\n" +
"\n" +
" protected team class MyInnerTeamX133 playedBy MyTeamAX133 {\n" +
"\n" +
" public final MyTeamAX133 base_ref;\n" +
"\n" +
" public MyInnerTeamX133(final MyTeamAX133 br) {\n" +
" base_ref = br;\n" +
" activate();\n" +
" }\n" +
"\n" +
" protected class MyStackedRoleX133 playedBy LowerRoleX133<@base_ref> {\n" +
" void printMessage() {\n" +
" System.out.println(\"MyTeamB.MyInnerTeam.MyStackedRole.printMessage()\");\n" +
" }\n" +
" printMessage <- after doA;\n" +
" }\n" +
"\n" +
"\n" +
"\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyBaseX133.java",
"\n" +
"package test3;\n" +
"\n" +
"public class MyBaseX133 {\n" +
" public void doBase() {\n" +
" System.out.println(\"MyBase.doBase()\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test3/MyTeamAX133.java",
"\n" +
"package test3;\n" +
"public team class MyTeamAX133 {\n" +
" public class LowerRoleX133 playedBy MyBaseX133 {\n" +
" callin void doA() {\n" +
" base.doA();\n" +
" System.out.println(\"MyTeamA.LowerRole.doA()\");\n" +
" }\n" +
" void doA() <- replace void doBase();\n" +
" }\n" +
" MyTeamAX133 () {\n" +
" activate();\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.doBase()\n" +
"MyTeamA.LowerRole.doA()\n" +
"MyTeamB.MyInnerTeam.MyStackedRole.printMessage()",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
null/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// static callin to callin to callin to base method with base calls
// X.1.3-otjld-static-callin-to-callin-1
public void testX13_staticCallinToCallin1() {
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"test3/MainX13sctc1.java",
"\n" +
"package test3;\n" +
"public class MainX13sctc1 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamCX13sctc1 mtc = new MyTeamCX13sctc1();\n" +
" mtc.activate();\n" +
" MyBaseX13sctc1.doBase(\"test\");\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamCX13sctc1.java",
"\n" +
"package test3;\n" +
"public team class MyTeamCX13sctc1 {\n" +
"\n" +
" final MyTeamBX13sctc1 thatTeam = new MyTeamBX13sctc1();\n" +
" public MyTeamCX13sctc1() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" \n" +
" protected class MyStackedRoleX13sctc1 playedBy MyStackedRoleX13sctc1<@thatTeam> {\n" +
" static callin void doC() {\n" +
" base.doC();\n" +
" System.out.println(\"MyTeamC.MyStackedRole.doC()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" doC <- replace doB;\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyBaseX13sctc1.java",
"\n" +
"package test3;\n" +
"\n" +
"public class MyBaseX13sctc1 {\n" +
" public static void doBase(String s) {\n" +
" System.out.println(\"MyBase.doBase(s)\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test3/MyTeamAX13sctc1.java",
"\n" +
"package test3;\n" +
"public team class MyTeamAX13sctc1 {\n" +
" public class LowerRoleX13sctc1 playedBy MyBaseX13sctc1 {\n" +
" static callin void doA(String s) {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA(s)\");\n" +
" base.doA(s);\n" +
" }\n" +
" doA <- replace doBase;\n" +
"\n" +
" }\n" +
"}\n" +
" \n",
"test3/MyTeamBX13sctc1.java",
"\n" +
"package test3;\n" +
"public team class MyTeamBX13sctc1 {\n" +
"\n" +
" final MyTeamAX13sctc1 thatTeam = new MyTeamAX13sctc1();\n" +
" public MyTeamBX13sctc1() {\n" +
" thatTeam.activate();\n" +
" }\n" +
" public class MyStackedRoleX13sctc1 playedBy LowerRoleX13sctc1<@thatTeam> {\n" +
" static callin void doB() {\n" +
" base.doB();\n" +
" System.out.println(\"MyTeamB.MyStackedRole.doB()\");\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // wrt base call\n" +
" doB <- replace doA;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamA.LowerRole.doA(s)\n" +
"MyBase.doBase(s)\n" +
"MyTeamB.MyStackedRole.doB()\n" +
"MyTeamC.MyStackedRole.doC()",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
null/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// (replace) callin from one role method to two base methods with the same name but different signatures
// X.1.4-otjld-multiple-signatures-1
public void testX14_multipleSignatures1() {
runConformTest(
new String[] {
"test4/MainX141.java",
"\n" +
"package test4;\n" +
"public class MainX141 {\n" +
" public static void main(String[] args) {\n" +
" MyTeamAX141 mta = new MyTeamAX141();\n" +
" mta.activate();\n" +
" MyBaseX141 mb = new MyBaseX141();\n" +
" mb.doBase(\"test\");\n" +
" mb.doBase();\n" +
" }\n" +
"}\n" +
" \n",
"test4/MyBaseX141.java",
"\n" +
"package test4;\n" +
"\n" +
"public class MyBaseX141 {\n" +
" public void doBase() {\n" +
" System.out.println(\"MyBase.doBase()\");\n" +
" }\n" +
" \n" +
" public void doBase(String s) {\n" +
" System.out.println(\"MyBase.doBase(s)\");\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test4/MyTeamAX141.java",
"\n" +
"package test4;\n" +
"public team class MyTeamAX141 {\n" +
" public class LowerRoleX141 playedBy MyBaseX141 {\n" +
" callin void doA() {\n" +
" System.out.println(\"MyTeamA.LowerRole.doA()\");\n" +
" base.doA();\n" +
" }\n" +
" void doA() <- replace void doBase(String sb);\n" +
" void doA() <- replace void doBase();\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeamA.LowerRole.doA()\n" +
"MyBase.doBase(s)\n" +
"MyTeamA.LowerRole.doA()\n" +
"MyBase.doBase()");
}
// after and before callin to a static role method
// X.1.5-otjld-callin-to-static-role-method-1
public void testX15_callinToStaticRoleMethod1() {
runConformTest(
new String[] {
"test5/MainX151.java",
"\n" +
"package test5;\n" +
"public class MainX151 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX151 b = new MyBaseX151();\n" +
" MyTeamX151 t = new MyTeamX151();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test5/MyTeamX151.java",
"\n" +
"package test5;\n" +
"public team class MyTeamX151 {\n" +
" public class MyRoleX151 playedBy MyBaseX151 {\n" +
" public static void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" rm <- before bm;\n" +
" }\n" +
"}\n" +
" \n",
"test5/MyBaseX151.java",
"\n" +
"package test5;\n" +
"\n" +
"public class MyBaseX151 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// after and before callin to the same role method
// X.1.5-otjld-after-and-before-callin-1a
public void testX15_afterAndBeforeCallin1a() {
runConformTest(
new String[] {
"test5/MainX151a.java",
"\n" +
"package test5;\n" +
"public class MainX151a {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX151a b = new MyBaseX151a();\n" +
" MyTeamX151a t = new MyTeamX151a();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test5/MyTeamX151a.java",
"\n" +
"package test5;\n" +
"public team class MyTeamX151a {\n" +
" public class MyRoleX151a playedBy MyBaseX151a {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" rm <- before bm;\n" +
" }\n" +
"}\n" +
" \n",
"test5/MyBaseX151a.java",
"\n" +
"package test5;\n" +
"\n" +
"public class MyBaseX151a {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// replace callin to a static (callin) role method
// X.1.5-otjld-callin-to-static-role-method-2
public void testX15_callinToStaticRoleMethod2() {
runNegativeTestMatching(
new String[] {
"test5/MyTeamX152.java",
"\n" +
"package test5;\n" +
"public team class MyTeamX152 {\n" +
" public class MyRoleX152 playedBy MyBaseX152 {\n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
"}\n" +
" \n",
"test5/MyBaseX152.java",
"\n" +
"package test5;\n" +
"\n" +
"public class MyBaseX152 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
"4.7(d)");
}
// after callin to a static role method
// X.1.5-otjld-callin-to-static-role-method-3
public void testX15_callinToStaticRoleMethod3() {
runConformTest(
new String[] {
"test5/MainX153.java",
"\n" +
"package test5;\n" +
"public class MainX153 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX153 b = new MyBaseX153();\n" +
" MyTeamX153 t = new MyTeamX153();\n" +
" t.activate();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"test5/MyTeamX153.java",
"\n" +
"package test5;\n" +
"public team class MyTeamX153 {\n" +
" public class MyRoleX153 playedBy MyBaseX153 {\n" +
" public static void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test5/MyBaseX153.java",
"\n" +
"package test5;\n" +
"\n" +
"public class MyBaseX153 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()");
}
// after callin from a static base method to a non-static role method
// X.1.5-otjld-callin-from-static-base-method-4
public void testX15_callinFromStaticBaseMethod4() {
runNegativeTest(
new String[] {
"test5/TeamX15cfsbm4.java",
"\n" +
"package test5;\n" +
"public team class TeamX15cfsbm4 {\n" +
" public class MyRole playedBy TX15cfsbm4 {\n" +
" public void rm() { }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"test5/TX15cfsbm4.java",
"\n" +
"package test5;\n" +
"\n" +
"public class TX15cfsbm4 {\n" +
" public static void bm() { }\n" +
"}\n" +
" \n",
"test5/TX15cfsbm4Main.java",
"\n" +
"package test5;\n" +
"public class TX15cfsbm4Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm4 t = new TeamX15cfsbm4();\n" +
" t.activate();\n" +
" TX15cfsbm4.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n"
},
null);
}
// a replace-callin binds a static base method to a static role method without arguments
// X.1.5-otjld-callin-from-static-base-method-5
public void testX15_callinFromStaticBaseMethod5() {
runConformTest(
new String[] {
"TX15cfsbm5Main.java",
"\n" +
" public class TX15cfsbm5Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm5 t = new TeamX15cfsbm5();\n" +
" t.activate();\n" +
" TX15cfsbm5.sm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm5.java",
"\n" +
" public class TX15cfsbm5 {\n" +
" public static void sm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm5.java",
"\n" +
" public team class TeamX15cfsbm5 {\n" +
" public class RX15cfsbm5 playedBy TX15cfsbm5{\n" +
" static callin void srm(){\n" +
" base.srm();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" srm <- replace sm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a replace-callin binds a static base method with a declared result to a static role method that does not declare a result
// X.1.5-otjld-callin-from-static-base-method-6
public void testX15_callinFromStaticBaseMethod6() {
runConformTest(
new String[] {
"TX15cfsbm6Main.java",
"\n" +
" public class TX15cfsbm6Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm6 t = new TeamX15cfsbm6();\n" +
" t.activate();\n" +
" System.out.print(TX15cfsbm6.bm());\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm6.java",
"\n" +
" public class TX15cfsbm6 {\n" +
" public static int bm(){\n" +
" return 7;\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm6.java",
"\n" +
" public team class TeamX15cfsbm6 {\n" +
" public class RX15cfsbm6 playedBy TX15cfsbm6{\n" +
" static callin void srm(){\n" +
" base.srm();\n" +
" }\n" +
" void srm() <- replace int bm() with { \n" +
" 3 -> result\n" +
" }\n" +
" }\n" +
" }\n" +
" \n"
},
"3");
}
// replace-callin binding to a static role method with argument mapping
// X.1.5-otjld-callin-from-static-base-method-7
public void testX15_callinFromStaticBaseMethod7() {
runConformTest(
new String[] {
"TX15cfsbm7Main.java",
"\n" +
" public class TX15cfsbm7Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm7 t = new TeamX15cfsbm7();\n" +
" t.activate();\n" +
" TX15cfsbm7.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm7.java",
"\n" +
" public class TX15cfsbm7 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm7.java",
"\n" +
" public team class TeamX15cfsbm7 {\n" +
" public class RX15cfsbm7 playedBy TX15cfsbm7{\n" +
" static callin void srm(String arg){\n" +
" base.srm(arg);\n" +
" System.out.print(arg);\n" +
" }\n" +
" void srm(String arg) <- replace void bm() with { \n" +
" arg <- \"OK\"\n" +
" }\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a replace-callin binding cannot bind a non-static base method to a static role method
// X.1.5-otjld-callin-from-static-base-method-8
public void testX15_callinFromStaticBaseMethod8() {
runNegativeTestMatching(
new String[] {
"TeamX15cfsbm8.java",
"\n" +
" public team class TeamX15cfsbm8 {\n" +
" public class RX15cfsbm8 playedBy TX15cfsbm8{\n" +
" static callin void srm(){\n" +
" base.srm();\n" +
" }\n" +
" srm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm8.java",
"\n" +
" public class TX15cfsbm8 {\n" +
" public void bm(){}\n" +
" }\n" +
" \n"
},
"4.7(d)");
}
// a replace-callin binding of a static base method to a non-static role method is illegal
// X.1.5-otjld-callin-from-static-base-method-9
public void testX15_callinFromStaticBaseMethod9() {
runNegativeTestMatching(
new String[] {
"TeamX15cfsbm9.java",
"\n" +
" public team class TeamX15cfsbm9 {\n" +
" public class RX15cfsbm9 playedBy TX15cfsbm9{\n" +
" callin void srm(){\n" +
" base.srm();\n" +
" }\n" +
" srm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm9.java",
"\n" +
" public class TX15cfsbm9 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n"
},
"4.7(b)");
}
// a before-callin binding of a static base method to a non-static role method is illegal
// X.1.5-otjld-callin-from-static-base-method-10
public void testX15_callinFromStaticBaseMethod10() {
runNegativeTestMatching(
new String[] {
"TeamX15cfsbm10.java",
"\n" +
" public team class TeamX15cfsbm10 {\n" +
" public class RX15cfsbm10 playedBy TX15cfsbm10{\n" +
" public void srm(){}\n" +
" srm <- before bm;\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm10.java",
"\n" +
" public class TX15cfsbm10 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n"
},
"4.7(b)");
}
// an after-callin binding of a static base method to a non-static role method is illegal
// X.1.5-otjld-callin-from-static-base-method-11
public void testX15_callinFromStaticBaseMethod11() {
runNegativeTestMatching(
new String[] {
"TeamX15cfsbm11.java",
"\n" +
" public team class TeamX15cfsbm11 {\n" +
" public class RX15cfsbm11 playedBy TX15cfsbm11{\n" +
" public void srm(){}\n" +
" srm <- after bm;\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm11.java",
"\n" +
" public class TX15cfsbm11 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n"
},
"4.7(b)");
}
// a replace-callin binds an inherited static role method to a static base method
// X.1.5-otjld-callin-from-static-base-method-12
public void testX15_callinFromStaticBaseMethod12() {
runConformTest(
new String[] {
"TX15cfsbm12Main.java",
"\n" +
" public class TX15cfsbm12Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm12_2 t = new TeamX15cfsbm12_2();\n" +
" t.activate();\n" +
" TX15cfsbm12.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm12.java",
"\n" +
" public class TX15cfsbm12 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12_1.java",
"\n" +
" public team class TeamX15cfsbm12_1 {\n" +
" public class RX15cfsbm12_1 {\n" +
" static callin void srm() {\n" +
" base.srm();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm12_2.java",
"\n" +
" public team class TeamX15cfsbm12_2 extends TeamX15cfsbm12_1{\n" +
" public class RX15cfsbm12_2 extends RX15cfsbm12_1 playedBy TX15cfsbm12{\n" +
" srm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a replace-callin binds an inherited static role method to a static base method - same team
// X.1.5-otjld-callin-from-static-base-method-12a
public void testX15_callinFromStaticBaseMethod12a() {
runConformTest(
new String[] {
"TX15cfsbm12aMain.java",
"\n" +
" public class TX15cfsbm12aMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm12a_1 t = new TeamX15cfsbm12a_1();\n" +
" t.activate();\n" +
" TX15cfsbm12a.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm12a.java",
"\n" +
" public class TX15cfsbm12a {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12a_1.java",
"\n" +
" public team class TeamX15cfsbm12a_1 {\n" +
" public class RX15cfsbm12a_1 {\n" +
" static callin void srm() {\n" +
" base.srm();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" public class RX15cfsbm12a_2 extends RX15cfsbm12a_1 playedBy TX15cfsbm12a {\n" +
" srm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a replace-callin binds an inherited static role method to a static base method - method has a role type parameter
// X.1.5-otjld-callin-from-static-base-method-12b
public void testX15_callinFromStaticBaseMethod12b() {
runConformTest(
new String[] {
"TX15cfsbm12bMain.java",
"\n" +
" public class TX15cfsbm12bMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm12b_2 t = new TeamX15cfsbm12b_2();\n" +
" t.activate();\n" +
" TX15cfsbm12b.bm(new TX15cfsbm12b(\"!\"));\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm12b.java",
"\n" +
" public class TX15cfsbm12b {\n" +
" String v;\n" +
" public void k() { \n" +
" System.out.print(v);\n" +
" }\n" +
" public TX15cfsbm12b(String v) { this.v = v; }\n" +
" public static void bm(TX15cfsbm12b b){ System.out.print(\"O\");}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12b_1.java",
"\n" +
" public abstract team class TeamX15cfsbm12b_1 {\n" +
" public abstract class RX15cfsbm12b_1 {\n" +
" static callin void srm(RX15cfsbm12b_2 r) {\n" +
" base.srm(r);\n" +
" System.out.print(\"K\");\n" +
" r.co();\n" +
" }\n" +
" abstract void co();\n" +
" }\n" +
" public abstract class RX15cfsbm12b_2 extends RX15cfsbm12b_1 playedBy TX15cfsbm12b {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12b_2.java",
"\n" +
" public team class TeamX15cfsbm12b_2 extends TeamX15cfsbm12b_1{\n" +
" public class RX15cfsbm12b_2 {\n" +
" void srm(RX15cfsbm12b_2 r) <- replace void bm(TX15cfsbm12b b);\n" +
" co -> k;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK!");
}
// a replace-callin binds an inherited static role method to a static base method - method has a role type parameter -- double compile
// X.1.5-otjld-callin-from-static-base-method-12c
public void testX15_callinFromStaticBaseMethod12c() {
runConformTest(
new String[] {
"TX15cfsbm12cMain.java",
"\n" +
" public class TX15cfsbm12cMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm12c_2 t = new TeamX15cfsbm12c_2();\n" +
" t.activate();\n" +
" TX15cfsbm12c.bm(new TX15cfsbm12c(\"!\"));\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm12c.java",
"\n" +
" public class TX15cfsbm12c {\n" +
" String v;\n" +
" public void k() {\n" +
" System.out.print(v);\n" +
" }\n" +
" public TX15cfsbm12c(String v) { this.v = v; }\n" +
" public static void bm(TX15cfsbm12c b){ System.out.print(\"O\");}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12c_1.java",
"\n" +
" public abstract team class TeamX15cfsbm12c_1 {\n" +
" public abstract class RX15cfsbm12c_1 {\n" +
" static callin void srm(RX15cfsbm12c_2 r) {\n" +
" base.srm(r);\n" +
" System.out.print(\"K\");\n" +
" r.co();\n" +
" }\n" +
" abstract void co();\n" +
" }\n" +
" public abstract class RX15cfsbm12c_2 extends RX15cfsbm12c_1 playedBy TX15cfsbm12c {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm12c_2.java",
"\n" +
" public team class TeamX15cfsbm12c_2 extends TeamX15cfsbm12c_1{\n" +
" public class RX15cfsbm12c_2 {\n" +
" void srm(RX15cfsbm12c_2 r) <- replace void bm(TX15cfsbm12c b);\n" +
" co -> k;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK!");
}
// an after-callin binds an inherited static role method to a static base method
// X.1.5-otjld-callin-from-static-base-method-13
public void testX15_callinFromStaticBaseMethod13() {
runConformTest(
new String[] {
"TX15cfsbm13Main.java",
"\n" +
" public class TX15cfsbm13Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm13_2 t = new TeamX15cfsbm13_2();\n" +
" t.activate();\n" +
" TX15cfsbm13.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm13.java",
"\n" +
" public class TX15cfsbm13 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm13_1.java",
"\n" +
" public team class TeamX15cfsbm13_1 {\n" +
" public class RX15cfsbm13_1{\n" +
" public static void srm() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm13_2.java",
"\n" +
" public team class TeamX15cfsbm13_2 extends TeamX15cfsbm13_1{\n" +
" public class RX15cfsbm13_2 extends RX15cfsbm13_1 playedBy TX15cfsbm13{\n" +
" srm <- after bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a before-callin binds an inherited static role method to a static base method
// X.1.5-otjld-callin-from-static-base-method-14
public void testX15_callinFromStaticBaseMethod14() {
runConformTest(
new String[] {
"TX15cfsbm14Main.java",
"\n" +
" public class TX15cfsbm14Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm14_2 t = new TeamX15cfsbm14_2();\n" +
" t.activate();\n" +
" TX15cfsbm14.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm14.java",
"\n" +
" public class TX15cfsbm14 {\n" +
" public static void bm(){}\n" +
" }\n" +
" \n",
"TeamX15cfsbm14_1.java",
"\n" +
" public team class TeamX15cfsbm14_1 {\n" +
" public class RX15cfsbm14_1{\n" +
" public static void srm() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm14_2.java",
"\n" +
" public team class TeamX15cfsbm14_2 extends TeamX15cfsbm14_1{\n" +
" public class RX15cfsbm14_2 extends RX15cfsbm14_1 playedBy TX15cfsbm14{\n" +
" srm <- after bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a replace-callin binds an inherited method (implemented within the super-super team) to a static base method
// X.1.5-otjld-callin-from-static-base-method-15
public void testX15_callinFromStaticBaseMethod15() {
runConformTest(
new String[] {
"TX15cfsbm15Main.java",
"\n" +
" public class TX15cfsbm15Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm15_3 t = new TeamX15cfsbm15_3();\n" +
" t.activate();\n" +
" TX15cfsbm15_2.bm2(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm15_1.java",
"\n" +
" public class TX15cfsbm15_1 {\n" +
" public static void bm1() {}\n" +
" }\n" +
" \n",
"TX15cfsbm15_2.java",
"\n" +
" public class TX15cfsbm15_2 {\n" +
" public static void bm2() {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm15_1.java",
"\n" +
" public team class TeamX15cfsbm15_1 {\n" +
" public class RX15cfsbm15_1 {\n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" } \n" +
" }\n" +
" \n",
"TeamX15cfsbm15_2.java",
"\n" +
" public team class TeamX15cfsbm15_2 extends TeamX15cfsbm15_1{\n" +
" public class RX15cfsbm15_2_1 extends RX15cfsbm15_1 playedBy TX15cfsbm15_1{\n" +
" rm <- replace bm1;\n" +
" }\n" +
" \n" +
" public class RX15cfsbm15_2_2 extends RX15cfsbm15_1 playedBy TX15cfsbm15_2{\n" +
" rm <- replace bm2;\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm15_3.java",
"\n" +
" public team class TeamX15cfsbm15_3 extends TeamX15cfsbm15_2{\n" +
" public class RX15cfsbm15_3 extends RX15cfsbm15_1 playedBy TX15cfsbm15_2{\n" +
" rm <- replace bm2;\n" +
" }\n" +
" precedence RX15cfsbm15_2_2, RX15cfsbm15_3;\n" +
" }\n" +
" \n"
},
"OKOK");
}
// static base call requires a result lifting
// X.1.5-otjld-callin-from-static-base-method-16
public void testX15_callinFromStaticBaseMethod16() {
runConformTest(
new String[] {
"TX15cfsbm16Main.java",
"\n" +
" public class TX15cfsbm16Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm16 t = new TeamX15cfsbm16();\n" +
" t.activate();\n" +
" TX15cfsbm16.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm16.java",
"\n" +
" public class TX15cfsbm16 { \n" +
" public static TX15cfsbm16 bm() {\n" +
" System.out.println(\"TX15cfsbm16.bm()\");\n" +
" return new TX15cfsbm16(); \n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm16.java",
"\n" +
" public team class TeamX15cfsbm16 {\n" +
" public class RX15cfsbm16 playedBy TX15cfsbm16 {\n" +
" static callin RX15cfsbm16 rm() {\n" +
" System.out.println(\"TeamX15cfsbm16.RX15cfsbm16.rm()\");\n" +
" return base.rm();\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"TeamX15cfsbm16.RX15cfsbm16.rm()\n" +
"TX15cfsbm16.bm()");
}
// static base call requires a result lifting; parameter involved
// X.1.5-otjld-callin-from-static-base-method-16a
public void testX15_callinFromStaticBaseMethod16a() {
runConformTest(
new String[] {
"TX15cfsbm16aMain.java",
"\n" +
" public class TX15cfsbm16aMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm16a t = new TeamX15cfsbm16a();\n" +
" t.activate();\n" +
" TX15cfsbm16a.bm(\"\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm16a.java",
"\n" +
" public class TX15cfsbm16a { \n" +
" public static TX15cfsbm16a bm(String s) {\n" +
" System.out.println(\"TX15cfsbm16a.bm()\");\n" +
" return new TX15cfsbm16a(); \n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm16a.java",
"\n" +
" public team class TeamX15cfsbm16a {\n" +
" public class RX15cfsbm16a playedBy TX15cfsbm16a {\n" +
" static callin RX15cfsbm16a rm(String s) {\n" +
" System.out.println(\"TeamX15cfsbm16a.RX15cfsbm16a.rm()\");\n" +
" return base.rm(s);\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"TeamX15cfsbm16a.RX15cfsbm16a.rm()\n" +
"TX15cfsbm16a.bm()");
}
// replace-callin-binding with parameter mapping (constant value)
// X.1.5-otjld-callin-from-static-base-method-17
public void testX15_callinFromStaticBaseMethod17() {
runConformTest(
new String[] {
"TX15cfsbm17Main.java",
"\n" +
" public class TX15cfsbm17Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm17 t = new TeamX15cfsbm17();\n" +
" t.activate();\n" +
" TX15cfsbm17.bm(42);\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm17.java",
"\n" +
" public class TX15cfsbm17 {\n" +
" static void bm(int a) {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm17.java",
"\n" +
" public team class TeamX15cfsbm17 {\n" +
" public class RX15cfsbm17 playedBy TX15cfsbm17{\n" +
" static callin void rm(int b) {\n" +
" base.rm(b);\n" +
" System.out.print(b);\n" +
" }\n" +
" \n" +
" void rm(int b) <- replace void bm(int a) with {\n" +
" b <- 7\n" +
" }\n" +
" }\n" +
" }\n" +
" \n"
},
"7");
}
// an inherited static role method is bound in different roles to different static base methods
// X.1.5-otjld-callin-from-static-base-method-18
public void testX15_callinFromStaticBaseMethod18() {
runConformTest(
new String[] {
"TX15cfsbm18Main.java",
"\n" +
" public class TX15cfsbm18Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm18_2 t = new TeamX15cfsbm18_2();\n" +
" t.activate();\n" +
" TX15cfsbm18_1.bm();\n" +
" TX15cfsbm18_2.bm();\n" +
" \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm18_1.java",
"\n" +
" public class TX15cfsbm18_1 {\n" +
" public static void bm() {\n" +
" System.out.println(\"OK1\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm18_2.java",
"\n" +
" public class TX15cfsbm18_2 {\n" +
" public static void bm() {\n" +
" System.out.println(\"OK2\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm18_1.java",
"\n" +
" public team class TeamX15cfsbm18_1 {\n" +
" public class RX15cfsbm18_1 {\n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" }\n" +
" } \n" +
" }\n" +
" \n",
"TeamX15cfsbm18_2.java",
"\n" +
" public team class TeamX15cfsbm18_2 extends TeamX15cfsbm18_1{\n" +
" public class RX15cfsbm18_2_1 extends RX15cfsbm18_1 playedBy TX15cfsbm18_1{\n" +
" rm <- replace bm;\n" +
" }\n" +
" \n" +
" public class RX15cfsbm18_2_2 extends RX15cfsbm18_1 playedBy TX15cfsbm18_2{\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK1\n" +
"OK2");
}
// static role methods are bound to same base method
// X.1.5-otjld-callin-from-static-base-method-19
public void testX15_callinFromStaticBaseMethod19() {
runConformTest(
new String[] {
"TX15cfsbm19Main.java",
"\n" +
" public class TX15cfsbm19Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm19 t = new TeamX15cfsbm19();\n" +
" t.activate();\n" +
" TX15cfsbm19.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm19.java",
"\n" +
" public class TX15cfsbm19 {\n" +
" public static void bm() {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm19.java",
"\n" +
" public team class TeamX15cfsbm19 { \n" +
" public class RX15cfsbm19 playedBy TX15cfsbm19 { \n" +
" static callin void rm1() {\n" +
" System.out.println(\"rm1()\");\n" +
" base.rm1();\n" +
" }\n" +
" \n" +
" static callin void rm2() {\n" +
" System.out.println(\"rm2()\");\n" +
" base.rm2();\n" +
" }\n" +
" \n" +
" c1: rm1 <- replace bm;\n" +
" c2: rm2 <- replace bm;\n" +
" precedence c1,c2;\n" +
" } \n" +
" }\n" +
" \n"
},
"rm1()\n" +
"rm2()");
}
// static role methods of different roles are bound to same base method - no precedence needed due to different static base classes
// X.1.5-otjld-callin-from-static-base-method-19r
public void testX15_callinFromStaticBaseMethod19r() {
runConformTest(
new String[] {
"TX15cfsbm19rMain.java",
"\n" +
" public class TX15cfsbm19rMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm19r t = new TeamX15cfsbm19r();\n" +
" t.activate();\n" +
" TX15cfsbm19r_2.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm19r_1.java",
"\n" +
" public class TX15cfsbm19r_1 {\n" +
" public static void bm() {}\n" +
" }\n" +
" \n",
"TX15cfsbm19r_2.java",
"\n" +
" public class TX15cfsbm19r_2 extends TX15cfsbm19r_1 {}\n" +
" \n",
"TeamX15cfsbm19r.java",
"\n" +
" public team class TeamX15cfsbm19r {\n" +
" public class RX15cfsbm19r1 playedBy TX15cfsbm19r_1 {\n" +
" static callin void rm1() {\n" +
" System.out.println(\"rm1()\");\n" +
" base.rm1();\n" +
" }\n" +
" c1: rm1 <- replace bm;\n" +
" }\n" +
" public class RX15cfsbm19r2 playedBy TX15cfsbm19r_2 {\n" +
" static callin void rm2() {\n" +
" System.out.println(\"rm2()\");\n" +
" base.rm2();\n" +
" }\n" +
" c2: rm2 <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"rm2()\n" +
"rm1()");
}
// static replace binding to a base method, base- and team classes are placed in a package
// X.1.5-otjld-callin-from-static-base-method-20
public void testX15_callinFromStaticBaseMethod20() {
runConformTest(
new String[] {
"cfsbm20/TX15cfsbm20Main.java",
"\n" +
" package cfsbm20;\n" +
" public class TX15cfsbm20Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm20 t = new TeamX15cfsbm20();\n" +
" t.activate();\n" +
" TX15cfsbm20.bm();\n" +
" }\n" +
" }\n" +
" \n",
"cfsbm20/TX15cfsbm20.java",
"\n" +
" package cfsbm20;\n" +
" public class TX15cfsbm20 {\n" +
" public static void bm() {\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" \n",
"cfsbm20/TeamX15cfsbm20.java",
"\n" +
" package cfsbm20;\n" +
" public team class TeamX15cfsbm20 { \n" +
" public class RX15cfsbm20 playedBy TX15cfsbm20 { \n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" } \n" +
" rm <- replace bm;\n" +
" } \n" +
" }\n" +
" \n"
},
"OK");
}
// a static and a non-static role methods are bound to same base method
// X.1.5-otjld-callin-from-static-base-method-21
public void testX15_callinFromStaticBaseMethod21() {
runConformTest(
new String[] {
"TX15cfsbm21Main.java",
"\n" +
" public class TX15cfsbm21Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm21 t = new TeamX15cfsbm21();\n" +
" t.activate();\n" +
" TX15cfsbm21 b = new TX15cfsbm21();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm21.java",
"\n" +
" public class TX15cfsbm21 {\n" +
" public void bm() {}\n" +
" }\n" +
" \n",
"TeamX15cfsbm21.java",
"\n" +
" public team class TeamX15cfsbm21 { \n" +
" public class RX15cfsbm21 playedBy TX15cfsbm21 { \n" +
" static void rm1() {\n" +
" System.out.println(\"OK1\"); \n" +
" }\n" +
" void rm2() {\n" +
" System.out.println(\"OK2\"); \n" +
" }\n" +
" c1: rm1 <- after bm;\n" +
" c2: rm2 <- after bm;\n" +
" precedence after c2, c1;\n" +
" } \n" +
" }\n" +
" \n"
},
"OK1\n" +
"OK2");
}
// an overridden static base method is bound to methods of different role classes
// X.1.5-otjld-callin-from-static-base-method-22
public void testX15_callinFromStaticBaseMethod22() {
runConformTest(
new String[] {
"TX15cfsbm22Main.java",
"\n" +
" public class TX15cfsbm22Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm22 t = new TeamX15cfsbm22();\n" +
" t.activate();\n" +
" TX15cfsbm22_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm22_1.java",
"\n" +
" public class TX15cfsbm22_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm22_2.java",
"\n" +
" public class TX15cfsbm22_2 extends TX15cfsbm22_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" } \n" +
" }\n" +
" \n",
"TeamX15cfsbm22.java",
"\n" +
" public team class TeamX15cfsbm22 {\n" +
" public class RX15cfsbm22_1 playedBy TX15cfsbm22_1 {\n" +
" static callin void rm(){\n" +
" base.rm();\n" +
" System.out.print(\"X\");\n" +
" } \n" +
" c1: rm <- replace bm;\n" +
" }\n" +
" \n" +
" public class RX15cfsbm22_2 playedBy TX15cfsbm22_2 {\n" +
" static callin void rm(){\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" c2: rm <- replace bm;\n" +
" } \n" +
" precedence RX15cfsbm22_2.c2, RX15cfsbm22_1.c1;\n" +
" }\n" +
" \n"
},
"OK");
}
// an inherited static base method is bound (after) in a sub base class
// X.1.5-otjld-callin-from-static-base-method-23
public void testX15_callinFromStaticBaseMethod23() {
runConformTest(
new String[] {
"TX15cfsbm23Main.java",
"\n" +
" public class TX15cfsbm23Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm23 t = new TeamX15cfsbm23();\n" +
" t.activate();\n" +
" TX15cfsbm23_1.bm();\n" +
" TX15cfsbm23_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm23_1.java",
"\n" +
" public class TX15cfsbm23_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm23_2.java",
"\n" +
" public class TX15cfsbm23_2 extends TX15cfsbm23_1 { \n" +
" }\n" +
" \n",
"TeamX15cfsbm23.java",
"\n" +
" public team class TeamX15cfsbm23 {\n" +
" public class RX15cfsbm23_1 playedBy TX15cfsbm23_2 {\n" +
" static void rm(){\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" rm <- after bm;\n" +
" }\n" +
" }\n" +
" \n"
},
(this.weavingScheme == WeavingScheme.OTRE
? "OOK"
: "KK")); // see restriction https://bugs.eclipse.org/435136#c1
}
// an inherited static base method is bound (replace) in a sub base class
// X.1.5-otjld-callin-from-static-base-method-23a
public void testX15_callinFromStaticBaseMethod23a() {
runConformTest(
new String[] {
"TX15cfsbm23aMain.java",
"\n" +
" public class TX15cfsbm23aMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm23a t = new TeamX15cfsbm23a();\n" +
" t.activate();\n" +
" TX15cfsbm23a_1.bm();\n" +
" TX15cfsbm23a_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm23a_1.java",
"\n" +
" public class TX15cfsbm23a_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm23a_2.java",
"\n" +
" public class TX15cfsbm23a_2 extends TX15cfsbm23a_1 { \n" +
" }\n" +
" \n",
"TeamX15cfsbm23a.java",
"\n" +
" public team class TeamX15cfsbm23a {\n" +
" public class RX15cfsbm23a_1 playedBy TX15cfsbm23a_2 {\n" +
" static callin void rm(){\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
(this.weavingScheme == WeavingScheme.OTRE
? "OOK"
: "KK")); // see restriction https://bugs.eclipse.org/435136#c1
}
// a static base method is redefined and rebound (after) to a static (also redefined) role method
// X.1.5-otjld-callin-from-static-base-method-24
public void testX15_callinFromStaticBaseMethod24() {
runConformTest(
new String[] {
"TX15cfsbm24Main.java",
"\n" +
" public class TX15cfsbm24Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm24 t = new TeamX15cfsbm24();\n" +
" t.activate();\n" +
" TX15cfsbm24_1.bm();\n" +
" System.out.print(\"|\");\n" +
" TX15cfsbm24_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm24_1.java",
"\n" +
" public class TX15cfsbm24_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm24_2.java",
"\n" +
" public class TX15cfsbm24_2 extends TX15cfsbm24_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm24.java",
"\n" +
" public team class TeamX15cfsbm24 {\n" +
" public class RX15cfsbm24_1 playedBy TX15cfsbm24_1 {\n" +
" static void rm(){\n" +
" System.out.print(\"X\");\n" +
" } \n" +
" rm <- after bm;\n" +
" }\n" +
"\n" +
" public class RX15cfsbm24_2 extends RX15cfsbm24_1 playedBy TX15cfsbm24_2 {\n" +
" static void rm(){\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" rm <- after bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"NOTOX|OK");
}
// a static base method is redefined and rebound (replace) to a static (also redefined) role method
// X.1.5-otjld-callin-from-static-base-method-24a
public void testX15_callinFromStaticBaseMethod24a() {
runConformTest(
new String[] {
"TX15cfsbm24aMain.java",
"\n" +
" public class TX15cfsbm24aMain {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm24a t = new TeamX15cfsbm24a();\n" +
" t.activate();\n" +
" TX15cfsbm24a_1.bm();\n" +
" System.out.print(\"|\");\n" +
" TX15cfsbm24a_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm24a_1.java",
"\n" +
" public class TX15cfsbm24a_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm24a_2.java",
"\n" +
" public class TX15cfsbm24a_2 extends TX15cfsbm24a_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm24a.java",
"\n" +
" public team class TeamX15cfsbm24a {\n" +
" public class RX15cfsbm24a_1 playedBy TX15cfsbm24a_1 {\n" +
" static callin void rm(){\n" +
" base.rm();\n" +
" System.out.print(\"X\");\n" +
" } \n" +
" rm <- replace bm;\n" +
" }\n" +
"\n" +
" public class RX15cfsbm24a_2 extends RX15cfsbm24a_1 playedBy TX15cfsbm24a_2 {\n" +
" static callin void rm(){\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"NOTOX|OK");
}
// if a static base method is bound in a super base class, a call to this (not redefined!) method at the subclass 'inherits' the callin
// X.1.5-otjld-callin-from-static-base-method-25
public void testX15_callinFromStaticBaseMethod25() {
runConformTest(
new String[] {
"TX15cfsbm25Main.java",
"\n" +
" public class TX15cfsbm25Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm25 t = new TeamX15cfsbm25();\n" +
" t.activate();\n" +
" TX15cfsbm25_1.bm();\n" +
" TX15cfsbm25_2.bm(); \n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm25_1.java",
"\n" +
" public class TX15cfsbm25_1 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm25_2.java",
"\n" +
" public class TX15cfsbm25_2 extends TX15cfsbm25_1 { \n" +
" }\n" +
" \n",
"TeamX15cfsbm25.java",
"\n" +
" public team class TeamX15cfsbm25 {\n" +
" public class RX15cfsbm25_1 playedBy TX15cfsbm25_1 {\n" +
" static void rm(){\n" +
" System.out.print(\"K\");\n" +
" } \n" +
" rm <- after bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OKOK");
}
// replace binding of static methods - additional binding to the same role method in a sub role
// X.1.5-otjld-callin-from-static-base-method-26
public void testX15_callinFromStaticBaseMethod26() {
runConformTest(
new String[] {
"TX15cfsbm26Main.java",
"\n" +
" public class TX15cfsbm26Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm26_1 t = new TeamX15cfsbm26_1();\n" +
" t.activate();\n" +
" TX15cfsbm26.bm1();\n" +
" System.out.print(\"|\");\n" +
" TX15cfsbm26.bm2();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm26.java",
"\n" +
" public class TX15cfsbm26 {\n" +
" public static void bm1(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" \n" +
" public static void bm2() {\n" +
" System.out.print(\"OKA\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm26_1.java",
"\n" +
" public team class TeamX15cfsbm26_1 {\n" +
" public class RX15cfsbm26_1 playedBy TX15cfsbm26 {\n" +
" static callin void srm() {\n" +
" base.srm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" srm <- replace bm1;\n" +
" }\n" +
" public class RX15cfsbm26_2 extends RX15cfsbm26_1 {\n" +
" srm <- replace bm2;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK|OKAK");
}
// replace binding of static methods - additional binding to the same base method in a sub role
// X.1.5-otjld-callin-from-static-base-method-27
public void testX15_callinFromStaticBaseMethod27() {
runConformTest(
new String[] {
"TX15cfsbm27Main.java",
"\n" +
" public class TX15cfsbm27Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm27_1 t = new TeamX15cfsbm27_1();\n" +
" t.activate();\n" +
" TX15cfsbm27.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm27.java",
"\n" +
" public class TX15cfsbm27 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm27_1.java",
"\n" +
" public team class TeamX15cfsbm27_1 {\n" +
" precedence RX15cfsbm27_1.b1, RX15cfsbm27_2.b2;\n" +
" public class RX15cfsbm27_1 playedBy TX15cfsbm27 {\n" +
" static callin void srm1() {\n" +
" base.srm1();\n" +
" System.out.print(\"Y\");\n" +
" }\n" +
" b1: srm1 <- replace bm;\n" +
"\n" +
" static callin void srm2() {\n" +
" base.srm2();\n" +
" System.out.print(\"KA\");\n" +
" }\n" +
" }\n" +
" public class RX15cfsbm27_2 extends RX15cfsbm27_1 {\n" +
" b2: srm2 <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OKAY");
}
// replace binding of static methods - redefined role method in a sub role
// X.1.5-otjld-callin-from-static-base-method-28
public void testX15_callinFromStaticBaseMethod28() {
runConformTest(
new String[] {
"TX15cfsbm28Main.java",
"\n" +
" public class TX15cfsbm28Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm28_1 t = new TeamX15cfsbm28_1();\n" +
" t.activate();\n" +
" TX15cfsbm28.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm28.java",
"\n" +
" public class TX15cfsbm28 {\n" +
" public static void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm28_1.java",
"\n" +
" public team class TeamX15cfsbm28_1 {\n" +
" public class RX15cfsbm28_1 playedBy TX15cfsbm28 {\n" +
" static callin void srm() {\n" +
" base.srm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" srm <- replace bm;\n" +
" }\n" +
" public class RX15cfsbm28_2 extends RX15cfsbm28_1 {\n" +
" static callin void srm() {\n" +
" base.srm();\n" +
" System.out.print(\"X\");\n" +
" }\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a redefined static base method does not inherit a callin binding from its version of the super class
// X.1.5-otjld-callin-from-static-base-method-29
public void testX15_callinFromStaticBaseMethod29() {
runConformTest(
new String[] {
"TX15cfsbm29Main.java",
"\n" +
" public class TX15cfsbm29Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX15cfsbm29_1 t = new TeamX15cfsbm29_1();\n" +
" t.activate();\n" +
" TX15cfsbm29_2.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm29.java",
"\n" +
" public class TX15cfsbm29 {\n" +
" public static void bm(){\n" +
" System.out.print(\"X\");\n" +
" }\n" +
" }\n" +
" \n",
"TX15cfsbm29_2.java",
"\n" +
" public class TX15cfsbm29_2 extends TX15cfsbm29 {\n" +
" public static void bm(){\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX15cfsbm29_1.java",
"\n" +
" public team class TeamX15cfsbm29_1 {\n" +
" public class RX15cfsbm29_1 playedBy TX15cfsbm29 {\n" +
" static callin void srm() {\n" +
" System.out.print(\"NOT\");\n" +
" base.srm(); \n" +
" }\n" +
" srm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// we had a problem with signature weakening in team methods across several levels of inheritance, resulting in an "abstract method" error at run-time
// X.1.6-otjld-abstract-team-method-1
public void testX16_abstractTeamMethod1() {
runConformTest(
new String[] {
"X16atmMain1.java",
"\n" +
"import p16.*;\n" +
"public class X16atmMain1 {\n" +
" public static void main(String[] args) {\n" +
" X16atm1 b = new X16atm1();\n" +
" TeamX16atm1_2 t = new TeamX16atm1_3();\n" +
" t.activate();\n" +
" b.bm();\n" +
" t.doIt();\n" +
" }\n" +
"}\n" +
" \n",
"p16/X16atm1.java",
"\n" +
"package p16; \n" +
"public class X16atm1 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
"}\n" +
" \n",
"p16/TeamX16atm1_1.java",
"\n" +
"package p16;\n" +
"public abstract team class TeamX16atm1_1 {\n" +
" abstract MyRole getRole();\n" +
" abstract protected class MyRole {}\n" +
" public void doIt() {\n" +
" MyRole mr = getRole();\n" +
" }\n" +
"}\n" +
" \n",
"p16/TeamX16atm1_2.java",
"\n" +
"package p16;\n" +
"public abstract team class TeamX16atm1_2 extends TeamX16atm1_1 {\n" +
" @Override\n" +
" public void doIt() {\n" +
" MyRole mr = getRole();\n" +
" }\n" +
" @Override\n" +
" public class MyRole playedBy X16atm1 {\n" +
" public void rm() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n",
"p16/TeamX16atm1_3.java",
" \n" +
"package p16;\n" +
"public team class TeamX16atm1_3 extends TeamX16atm1_2 {\n" +
" @Override\n" +
" public MyRole getRole() {\n" +
" return null;\n" +
" }\n" +
"} \n" +
" \n"
},
"OK");
}
// if a team is referenced only indirect it has to be loaded before its bases too
// X.1.7-otjld-referenced-teams-1
public void testX17_referencedTeams1() {
runConformTest(
new String[] {
"X17rtMain1.java",
"\n" +
"import p17.*;\n" +
"public class X17rtMain1 {\n" +
" public static void main(String[] args) {\n" +
" TeamReferencerX17rt1 tr = null;\n" +
" MyBaseX17rt1 b = new MyBaseX17rt1();\n" +
" tr = new TeamReferencerX17rt1();\n" +
" tr.doIt();\n" +
" b.bm();\n" +
" }\n" +
"\n" +
"}\n" +
" \n",
"p17/MyBaseX17rt1.java",
"\n" +
"package p17;\n" +
"public class MyBaseX17rt1 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
"}\n" +
" \n",
"p17/TeamReferencerX17rt1.java",
"\n" +
"package p17;\n" +
"public class TeamReferencerX17rt1 {\n" +
" public void doIt() {\n" +
" TeamX17rt1 mt = new TeamX17rt1();\n" +
" try {\n" +
" mt.activate();\n" +
" } catch (org.objectteams.UnsupportedFeatureException ufe) {\n" +
" System.out.print(\"N\");\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"p17/TeamX17rt1.java",
"\n" +
"package p17; \n" +
"public team class TeamX17rt1 {\n" +
" public class MyRole playedBy MyBaseX17rt1 {\n" +
" public void rm() {\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
(this.weavingScheme == WeavingScheme.OTDRE ? "OK" : "NO"));
}
// an after callin passes the base result to the team
// X.1.8-otjld-after-result-passing-1
public void testX18_afterResultPassing1() {
runConformTest(
new String[] {
"X18arpMain1.java",
"\n" +
"import p18.*;\n" +
"public class X18arpMain1 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX18arp1 b = new MyBaseX18arp1();\n" +
" TeamX18arp1 t = new TeamX18arp1();\n" +
" t.activate();\n" +
" b.bm(\"seven\", \"unused\");\n" +
" }\n" +
"}\n" +
" \n",
"p18/MyBaseX18arp1.java",
"\n" +
"package p18;\n" +
"public class MyBaseX18arp1 {\n" +
" public int bm(String arg, String arg2) {\n" +
" System.out.println(\"MyBase.bm(\"+arg+\")\");\n" +
" return 77;\n" +
" }\n" +
"}\n" +
" \n",
"p18/TeamX18arp1.java",
"\n" +
"package p18; \n" +
"public team class TeamX18arp1 {\n" +
" public class MyRole playedBy MyBaseX18arp1 {\n" +
" public void rm(int i) {\n" +
" System.out.println(\"MyTeam.MyRole.rm(\"+i+\")\");\n" +
" }\n" +
"\n" +
" void rm(int i) <- after int bm(String s, String s2) with {\n" +
" i <- result\n" +
" }\n" +
"\n" +
" void rm(int i) <- before int bm(String s, String s2) with {\n" +
" i <- s.length()\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm(5)\n" +
"MyBase.bm(seven)\n" +
"MyTeam.MyRole.rm(77)");
}
// a team is instantiated and activated via a teamconfig file
// X.1.9-otjld-teamconfig-file-1
public void testX19_teamconfigFile1() {
myWriteFiles(
new String[] {
"p19/config1.txt",
"\n" +
"p19.TeamX19tcf1\n"});
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"X19tcfMain1.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain1 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf1 b = new MyBaseX19tcf1();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf1.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf1 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf1.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf1 {\n" +
" public class MyRole playedBy MyBaseX19tcf1 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()",
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config1.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// a team is instantiated and activated via a teamconfig file - the main method contains an exception handler
// X.1.9-otjld-teamconfig-file-2
public void testX19_teamconfigFile2() {
myWriteFiles(
new String[] {
"p19/config2.txt",
"\n" +
"p19.TeamX19tcf2\n" +
"\n"
});
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"X19tcfMain2.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain2 {\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf2 b = new MyBaseX19tcf2();\n" +
" b.bm(true);\n" +
" try {\n" +
" b.bm(false);\n" +
" } catch (NullPointerException npe) {\n" +
" System.out.println(\"NullPointerException caught!\");\n" +
" }\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf2.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf2 {\n" +
" public void bm(boolean ok) {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" if (!ok)\n" +
" throw new NullPointerException();\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf2.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf2 {\n" +
" public class MyRole playedBy MyBaseX19tcf2 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()\n" +
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"NullPointerException caught!",
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config2.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// a team is instantiated and activated via a teamconfig file, bindings are in the super team
// X.1.9-otjld-teamconfig-file-3
public void testX19_teamconfigFile3() {
myWriteFiles(new String[] {
"configX19tcf3.txt",
"\n" +
"TeamX19tcf3_2 \n" +
" \n"});
Map customOptions = getCompilerOptions();
runConformTest(
new String[] {
"TX19tcf3Main.java",
"\n" +
"public class TX19tcf3Main {\n" +
" static TX19tcf3 b;\n" +
" public static void main(String[] args) {\n" +
" b = new TX19tcf3();\n" +
" b.nop();\n" +
" }\n" +
"} \n" +
" \n",
"TX19tcf3.java",
"\n" +
"public team class TX19tcf3 {\n" +
" void nop() {}\n" +
"} \n" +
" \n",
"TeamX19tcf3_1.java",
"\n" +
"public team class TeamX19tcf3_1 {\n" +
" protected class RX19tcf3_1 {\n" +
" void out() {}\n" +
" }\n" +
" protected class RX19tcf3_2 extends RX19tcf3_1 playedBy TX19tcf3 {\n" +
" out <- after nop;\n" +
" }\n" +
"} \n" +
" \n",
"TeamX19tcf3_2.java",
"\n" +
"public team class TeamX19tcf3_2 extends TeamX19tcf3_1 {\n" +
" protected class RX19tcf3_1 {\n" +
" void out() { System.out.print(\"OK\"); }\n" +
" } \n" +
"} \n" +
" \n"
},
"OK",
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("configX19tcf3.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// trying to instantiate and activate a team without a default constructor via a teamconfig file
// X.1.9-otjld-teamconfig-file-4
public void testX19_teamconfigFile4() {
Map customOptions = getCompilerOptions();
myWriteFiles(new String[] {
"p19/config4.txt",
"\n" +
"p19.TeamX19tcf4\n" +
"\n"
});
runTest(
new String[] {
"X19tcfMain4.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain4 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf4 b = new MyBaseX19tcf4();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf4.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf4 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf4.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf4 {\n" +
" public TeamX19tcf4(String anArg) {\n" +
" }\n" +
"\n" +
" public class MyRole playedBy MyBaseX19tcf4 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
false/*expectingCompileErrors*/,
null/*expectedCompilerLog*/,
"MyBase.bm()"/*expectedOutputString*/,
"Activation failed: Team class 'p19.TeamX19tcf4' has no default constuctor!",
false/*forceExecution*/,
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config4.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/,
true/*skipJavac*/);
}
// trying to add a nonexisting team via a teamconfig file
// X.1.9-otjld-teamconfig-file-5
public void testX19_teamconfigFile5() {
Map customOptions = getCompilerOptions();
myWriteFiles(new String[] {
"p19/config5.txt",
"\n" +
"p19.TeamX19tcf5NOTEXISTING\n" +
"\n"});
runTest(
new String[] {
"X19tcfMain5.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain5 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf5 b = new MyBaseX19tcf5();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf5.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf5 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf5.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf5 {\n" +
" public class MyRole playedBy MyBaseX19tcf5 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
false/*expectingCompileErrors*/,
null/*expectedCompilerLog*/,
"MyBase.bm()"/*expectedOutputString*/,
"Config error: Team class \'p19.TeamX19tcf5NOTEXISTING\' in config file \'"+OUTPUT_DIR+"/p19/config5.txt\' can not be found!" /*exepectedErrorString*/,
false/*forceExecution*/,
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config5.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/,
true/*skipJavac*/);
}
// trying to add a nonexisting team via a teamconfig file, also adding an existing team
// X.1.9-otjld-teamconfig-file-5a
public void testX19_teamconfigFile5a() {
Map customOptions = getCompilerOptions();
myWriteFiles(new String[] {
"p19/config5a.txt",
"\n" +
"p19.TeamX19tcf5aNOTEXISTING\n" +
"p19.TeamX19tcf5a\n" +
"\n"});
runTest(
new String[] {
"X19tcfMain5a.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain5a {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf5a b = new MyBaseX19tcf5a();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf5a.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf5a {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf5a.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf5a {\n" +
" public class MyRole playedBy MyBaseX19tcf5a {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
false/*expectingCompileErrors*/,
null/*expectedCompilerLog*/,
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()"/*expectedOutputString*/,
"Config error: Team class 'p19.TeamX19tcf5aNOTEXISTING' in config file '"+OUTPUT_DIR+"/p19/config5a.txt' can not be found!",
false/*forceExecution*/,
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config5a.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/,
true/*skipJavac*/);
}
// trying to use a nonexisting teamconfig file
// X.1.9-otjld-teamconfig-file-6
public void testX19_teamconfigFile6() {
Map customOptions = getCompilerOptions();
runTest(
new String[] {
"X19tcfMain6.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain6 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf6 b = new MyBaseX19tcf6();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf6.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf6 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n"
},
false/*expectingCompileErrors*/,
null/*expectedCompilerLog*/,
"MyBase.bm()"/*expectedOutputString*/,
"File input error: config file '"+OUTPUT_DIR+"/p19/config6.txt' can not be found!"/*expectedErrorString*/,
false/*forceExecution*/,
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config6.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/,
true/*skipJavac*/);
}
// using comments in a teamconfig file
// X.1.9-otjld-teamconfig-file-7
public void testX19_teamconfigFile7() {
Map customOptions = getCompilerOptions();
myWriteFiles(new String[] {
"p19/config7.txt",
"\n" +
"# this is a comment \n" +
"p19.TeamX19tcf7\n" +
"# here is another comment\n" +
"\n"});
runConformTest(
new String[] {
"X19tcfMain7.java",
"\n" +
"import p19.*;\n" +
"public class X19tcfMain7 {\n" +
"\n" +
" public static void main(String[] args) {\n" +
" MyBaseX19tcf7 b = new MyBaseX19tcf7();\n" +
" b.bm();\n" +
" }\n" +
"}\n" +
" \n",
"p19/MyBaseX19tcf7.java",
"\n" +
"package p19;\n" +
"public class MyBaseX19tcf7 {\n" +
" public void bm() {\n" +
" System.out.println(\"MyBase.bm()\");\n" +
" }\n" +
"}\n" +
" \n",
"p19/TeamX19tcf7.java",
"\n" +
"package p19; \n" +
"public team class TeamX19tcf7 {\n" +
" public class MyRole playedBy MyBaseX19tcf7 {\n" +
" public void rm() {\n" +
" System.out.println(\"MyTeam.MyRole.rm()\");\n" +
" }\n" +
" rm <- before bm;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n" +
" \n"
},
"MyTeam.MyRole.rm()\n" +
"MyBase.bm()\n" +
"MyTeam.MyRole.rm()",
null/*classLibraries*/,
false/*shouldFlushOutputDirectory*/,
getTeamActivationVMArgs("p19/config7.txt")/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
// a sub base is bound to another team
// X.2.1-otjld-callin-with-base-inheritance-1
public void testX21_callinWithBaseInheritance1() {
runConformTest(
new String[] {
"TX21cwbi1Main.java",
"\n" +
" public class TX21cwbi1Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX21cwbi1_1 t1 = new TeamX21cwbi1_1();\n" +
" TeamX21cwbi1_2 t2 = new TeamX21cwbi1_2();\n" +
" t1.activate();\n" +
" t2.activate();\n" +
" TX21cwbi1_2 b = new TX21cwbi1_2();\n" +
" b.bm2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi1.java",
"\n" +
" public class TX21cwbi1 {\n" +
" public void bm(){}\n" +
" }\n" +
" \n",
"TX21cwbi1_2.java",
"\n" +
" public class TX21cwbi1_2 extends TX21cwbi1 {\n" +
" public void bm2(){}\n" +
" }\n" +
" \n",
"TeamX21cwbi1_1.java",
"\n" +
" public team class TeamX21cwbi1_1 {\n" +
" public class RX21cwbi1_1 playedBy TX21cwbi1 {\n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n",
"TeamX21cwbi1_2.java",
"\n" +
" public team class TeamX21cwbi1_2 {\n" +
" public class RX21cwbi1_2 playedBy TX21cwbi1_2 {\n" +
" public void rm() {\n" +
" System.out.print(\"O\");\n" +
" } \n" +
" rm <- before bm2;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// a sub base is bound to another role, the super base should not be affected
// X.2.1-otjld-callin-with-base-inheritance-2
public void testX21_callinWithBaseInheritance2() {
runConformTest(
new String[] {
"TX21cwbi2Main.java",
"\n" +
" public class TX21cwbi2Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX21cwbi2_2 t2 = new TeamX21cwbi2_2();\n" +
" t2.activate();\n" +
" TX21cwbi2 b = new TX21cwbi2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi2.java",
"\n" +
" public class TX21cwbi2 {\n" +
" public void bm(){\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi2_2.java",
"\n" +
" public class TX21cwbi2_2 extends TX21cwbi2 {}\n" +
" \n",
"TeamX21cwbi2_1.java",
"\n" +
" public team class TeamX21cwbi2_1 {\n" +
" public class RX21cwbi2_1 playedBy TX21cwbi2 {\n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n",
"TeamX21cwbi2_2.java",
"\n" +
" public team class TeamX21cwbi2_2 extends TeamX21cwbi2_1 {\n" +
" public class RX21cwbi2_2 extends RX21cwbi2_1 playedBy TX21cwbi2_2 {}\n" +
" }\n" +
" \n"
},
"OK");
}
// object creation (invokespecial != super) in overridden callin bound base method
// X.2.1-otjld-callin-with-base-inheritance-3
public void testX21_callinWithBaseInheritance3() {
runConformTest(
new String[] {
"TX21cwbi3Main.java",
"\n" +
" public class TX21cwbi3Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX21cwbi3_1 t = new TeamX21cwbi3_1();\n" +
" t.activate();\n" +
" TX21cwbi3_2 b = new TX21cwbi3_2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi3.java",
"\n" +
" public class TX21cwbi3 {\n" +
" public void bm(){\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi3_2.java",
"\n" +
" public class TX21cwbi3_2 extends TX21cwbi3 {\n" +
" public void bm() {\n" +
" String s = new String(\"O\");\n" +
" System.out.print(s);\n" +
" }\n" +
" }\n" +
" \n",
"TeamX21cwbi3_1.java",
"\n" +
" public team class TeamX21cwbi3_1 {\n" +
" public class RX21cwbi3_1 playedBy TX21cwbi3 {\n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// overridden callin bound base method with arguments
// X.2.1-otjld-callin-with-base-inheritance-4
public void testX21_callinWithBaseInheritance4() {
runConformTest(
new String[] {
"TX21cwbi4Main.java",
"\n" +
" public class TX21cwbi4Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX21cwbi4_1 t = new TeamX21cwbi4_1();\n" +
" t.activate();\n" +
" TX21cwbi4_2 b = new TX21cwbi4_2();\n" +
" b.bm(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi4.java",
"\n" +
" public class TX21cwbi4 {\n" +
" public void bm(String s){\n" +
" System.out.print(s);\n" +
" }\n" +
" }\n" +
" \n",
"TX21cwbi4_2.java",
"\n" +
" public class TX21cwbi4_2 extends TX21cwbi4 {\n" +
" public void bm(String s) {\n" +
" if (s.startsWith(\"NOT\")) {\n" +
" s = s.substring(3, s.length());\n" +
" }\n" +
" super.bm(s);\n" +
" }\n" +
" }\n" +
" \n",
"TeamX21cwbi4_1.java",
"\n" +
" public team class TeamX21cwbi4_1 {\n" +
" public class RX21cwbi4_1 playedBy TX21cwbi4 {\n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\");\n" +
" }\n" +
" rm <- replace bm;\n" +
" }\n" +
" }\n" +
" \n"
},
"OK");
}
// static replace binding with refinement of 'playedBy' in the same team + base method redefinition
// X.2.2-otjld-played-by-refinement-1
public void testX22_playedByRefinement1() {
runConformTest(
new String[] {
"TX22pbr1Main.java",
"\n" +
" public class TX22pbr1Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX22pbr1 t = new TeamX22pbr1();\n" +
" t.activate();\n" +
" TX22pbr1.bm();\n" +
" TX22pbr1_2.bm();\n" +
" \n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr1.java",
"\n" +
" public class TX22pbr1 {\n" +
" public static void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr1_2.java",
"\n" +
" public class TX22pbr1_2 extends TX22pbr1 {\n" +
" public static void bm() {\n" +
" System.out.print(\"AY\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX22pbr1.java",
"\n" +
" public team class TeamX22pbr1 { \n" +
" public class RX22pbr1 playedBy TX22pbr1 { \n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" public class RX122br1_2 extends RX22pbr1 playedBy TX22pbr1_2 { \n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"NOT\"); \n" +
" }\n" +
" } \n" +
" }\n" +
" \n"
},
"OKAY");
}
// static replace binding with refinement of 'playedBy' in a subteam + base method redefinition
// X.2.2-otjld-played-by-refinement-2
public void testX22_playedByRefinement2() {
runConformTest(
new String[] {
"TX22pbr2Main.java",
"\n" +
" public class TX22pbr2Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX22pbr2_2 t = new TeamX22pbr2_2();\n" +
" t.activate();\n" +
" TX22pbr2.bm();\n" +
" TX22pbr2_2.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr2.java",
"\n" +
" public class TX22pbr2 {\n" +
" public static void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr2_2.java",
"\n" +
" public class TX22pbr2_2 extends TX22pbr2 {\n" +
" public static void bm() {\n" +
" System.out.print(\"AY\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX22pbr2.java",
"\n" +
" public team class TeamX22pbr2 { \n" +
" public class RX22pbr2 playedBy TX22pbr2 { \n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" }\n" +
" \n",
"TeamX22pbr2_2.java",
"\n" +
" public team class TeamX22pbr2_2 extends TeamX22pbr2 { \n" +
" public class RX22pbr2_2 extends RX22pbr2 playedBy TX22pbr2_2 { \n" +
" static callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"NOT\"); \n" +
" }\n" +
" } \n" +
" }\n" +
" \n"
},
"OKAY");
}
// replace binding with refinement of 'playedBy' in the same team + base method redefinition
// X.2.2-otjld-played-by-refinement-3
public void testX22_playedByRefinement3() {
runConformTest(
new String[] {
"TX22pbr3Main.java",
"\n" +
" public class TX22pbr3Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX22pbr3 t = new TeamX22pbr3();\n" +
" t.activate();\n" +
" TX22pbr3_2 b = new TX22pbr3_2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr3.java",
"\n" +
" public class TX22pbr3 {\n" +
" public void bm() {\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr3_2.java",
"\n" +
" public class TX22pbr3_2 extends TX22pbr3 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX22pbr3.java",
"\n" +
" public team class TeamX22pbr3 { \n" +
" public class RX22pbr3 playedBy TX22pbr3 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"X\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" public class RX22pbr3_2 extends RX22pbr3 playedBy TX22pbr3_2 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" } \n" +
" }\n" +
" \n"
},
"OK");
}
// replace binding with refinement of 'playedBy' in a subteam + base method redefinition
// X.2.2-otjld-played-by-refinement-4
public void testX22_playedByRefinement4() {
runConformTest(
new String[] {
"TX22pbr4Main.java",
"\n" +
" public class TX22pbr4Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX22pbr4_2 t = new TeamX22pbr4_2();\n" +
" t.activate();\n" +
" TX22pbr4_2 b = new TX22pbr4_2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr4.java",
"\n" +
" public class TX22pbr4 {\n" +
" public void bm() {\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr4_2.java",
"\n" +
" public class TX22pbr4_2 extends TX22pbr4 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX22pbr4.java",
"\n" +
" public team class TeamX22pbr4 { \n" +
" public class RX22pbr4 playedBy TX22pbr4 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"X\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" }\n" +
" \n",
"TeamX22pbr4_2.java",
"\n" +
" public team class TeamX22pbr4_2 extends TeamX22pbr4 { \n" +
" public class RX22pbr4_2 extends RX22pbr4 playedBy TX22pbr4_2 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" } \n" +
" }\n" +
" \n"
},
"OK");
}
// replace binding with refinement of 'playedBy' in a subteam, in an implicit subrole + base method redefinition
// X.2.2-otjld-played-by-refinement-5
public void testX22_playedByRefinement5() {
runConformTest(
new String[] {
"TX22pbr5Main.java",
"\n" +
" public class TX22pbr5Main {\n" +
" public static void main(String[] args) {\n" +
" TeamX22pbr5_2 t = new TeamX22pbr5_2();\n" +
" t.activate();\n" +
" TX22pbr5_2 b = new TX22pbr5_2();\n" +
" b.bm();\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr5.java",
"\n" +
" public class TX22pbr5 {\n" +
" public void bm() {\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX22pbr5_2.java",
"\n" +
" public class TX22pbr5_2 extends TX22pbr5 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n",
"TeamX22pbr5.java",
"\n" +
" public team class TeamX22pbr5 { \n" +
" public class RX22pbr5 playedBy TX22pbr5 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"X\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" }\n" +
" \n",
"TeamX22pbr5_2.java",
"\n" +
" public team class TeamX22pbr5_2 extends TeamX22pbr5 { \n" +
" public class RX22pbr5 { \n" +
" callin void rm() {\n" +
" tsuper.rm();\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" } \n" +
" }\n" +
" \n"
},
"OXOK");
}
// mulitple replace bindings from different roles in the same team to one base method -> compiler should enforce precedence declaration
// X.2.3-otjld-multiple-bindings-1
public void testX23_multipleBindings1() {
runNegativeTestMatching(
new String[] {
"TeamX23mb1.java",
"\n" +
" public team class TeamX23mb1 { \n" +
" public class RX23mb1 playedBy TX23mb1 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"X\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" public class RX23mb1_2 playedBy TX23mb1_2 { \n" +
" callin void rm() {\n" +
" base.rm();\n" +
" System.out.print(\"K\"); \n" +
" }\n" +
" rm <- replace bm;\n" +
" } \n" +
" }\n" +
" \n",
"TX23mb1.java",
"\n" +
" public class TX23mb1 {\n" +
" public void bm() {\n" +
" System.out.print(\"NOTO\");\n" +
" }\n" +
" }\n" +
" \n",
"TX23mb1_2.java",
"\n" +
" public class TX23mb1_2 extends TX23mb1 {\n" +
" public void bm() {\n" +
" System.out.print(\"O\");\n" +
" }\n" +
" }\n" +
" \n"
},
"4.8");
}
String[] getBookingClassLibraries() {
if (this.verifier != null)
this.verifier.shutDown();
this.verifier = getTestVerifier(false);
this.createdVerifier = true;
String jarFilename = "booking.jar";
String destPath = this.outputRootDirectoryPath+"/regression";
createOutputTestDirectory("/regression");
// upload the jar:
Util.copy(getTestResourcePath(jarFilename), destPath);
// setup classpath:
String[] classPaths = getDefaultClassPaths();
int l = classPaths.length;
System.arraycopy(classPaths, 0, classPaths=new String[l+1], 0, l);
classPaths[l] = this.outputRootDirectoryPath+"/regression/"+jarFilename;
return classPaths;
}
// the flightbonus sample as shipped with the OTDT, compilation only (interactive GUI application!)
// X.3.1-otjld-flightbonus-sample
public void testX31_flightbonusSample() {
runConformTest(
new String[] {
"fbapplication/DummyMain.java",
"package fbapplication;\n" +
"public class DummyMain {\n" +
" public static void main(String... args) {\n" +
" new GUIConnector().activate();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
"}\n",
"fbapplication/FlightBonus.java",
"\n" +
"package fbapplication;\n" +
"import bonussystem.Bonus;\n" +
"@SuppressWarnings(\"bindingconventions\")\n" +
"public team class FlightBonus extends Bonus {\n" +
" public FlightBonus(flightbooking.model.Passenger as Subscriber s) {\n" +
" activate();\n" +
" }\n" +
" @Override\n" +
" public class Subscriber playedBy flightbooking.model.Passenger \n" +
" base when (FlightBonus.this.hasRole(base)) \n" +
" {\n" +
" buy <- replace book;\n" +
" String getName() -> String getName();\n" +
" };\n" +
" @Override\n" +
" public class Item playedBy flightbooking.model.Segment {\n" +
" @Override\n" +
" public int calculateCredit () {\n" +
" int miles = getDistance();\n" +
" int credit = (((miles+999)/1000)) * 1000;\n" +
" return credit;\n" +
" };\n" +
" earnCredit <- after book;\n" +
" String getDestination() -> String getDestination();\n" +
" int getDistance() -> int getDistance();\n" +
" String getStart() -> String getStart();\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication/BonusGUI.java",
"\n" +
"package fbapplication;\n" +
"import java.awt.Component;\n" +
"import javax.swing.JOptionPane;\n" +
"import flightbooking.model.Passenger;\n" +
"public team class BonusGUI {\n" +
" View view = null;\n" +
" abstract protected class View {\n" +
" void registerView() {\n" +
" BonusGUI.this.view = this;\n" +
" }\n" +
" protected boolean queryRegisterDialog() {\n" +
" int choice = JOptionPane.showConfirmDialog(\n" +
" getComponent(), \n" +
" \"Register for Flight Bonus?\", \n" +
" \"OT Bonus System\", \n" +
" JOptionPane.YES_NO_OPTION);\n" +
" return choice == JOptionPane.YES_OPTION;\n" +
" }\n" +
" protected abstract Component getComponent();\n" +
" }\n" +
" protected class Controller \n" +
" when (BonusGUI.this.view != null) \n" +
" {\n" +
" void queryRegisterForBonus (Passenger p) {\n" +
" if (BonusGUI.this.view.queryRegisterDialog()) \n" +
" new FlightBonusDialog(new FlightBonus(p));\n" +
" };\n" +
" }\n" +
"}\n" +
" \n",
"bonussystem/Bonus.java",
"\n" +
"package bonussystem;\n" +
"public abstract team class Bonus {\n" +
" protected Subscriber subscriber = null;\n" +
" public abstract class Subscriber {\n" +
" private int collectedCredits = 0;\n" +
" protected int getCollectedCredits() {\n" +
" return collectedCredits;\n" +
" }\n" +
" protected void collectCredit (int credit) {\n" +
" collectedCredits += credit;\n" +
" }\n" +
" callin void buy ()\n" +
" {\n" +
" Bonus.this.subscriber = this;\n" +
" base.buy();\n" +
" Bonus.this.subscriber = null;\n" +
"\n" +
" log(\"Sub. has collected \"+getCollectedCredits()+\" credit points.\");\n" +
" }\n" +
" }\n" +
" public abstract class Item {\n" +
" protected abstract int calculateCredit ();\n" +
" protected void earnCredit () {\n" +
" @SuppressWarnings(\"hiding\")\n" +
" Subscriber subscriber = Bonus.this.subscriber;\n" +
" if (subscriber == null)\n" +
" return;\n" +
"\n" +
" int tmpCredits = calculateCredit();\n" +
" log(\"buying an item that yields \"+tmpCredits+\" credit points.\");\n" +
" subscriber.collectCredit(tmpCredits);\n" +
" }\n" +
" }\n" +
" protected void log (String msg) {\n" +
" System.out.println(\">>Bonus>> \"+msg);\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication/GUIConnector.java",
"\n" +
"package fbapplication;\n" +
"import java.awt.Component;\n" +
"@SuppressWarnings(\"bindingconventions\")\n" +
"public team class GUIConnector extends BonusGUI {\n" +
" @Override\n" +
" protected class View playedBy flightbooking.gui.FlightBookingGUI {\n" +
" @Override\n" +
" protected Component getComponent () {\n" +
" return this;\n" +
" }\n" +
" registerView <- after initComponents;\n" +
" }\n" +
" @Override\n" +
" protected class Controller playedBy flightbooking.model.PassengerDB {\n" +
" queryRegisterForBonus <- after add;\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication/GUIConnector/FlightBonusDialog.java",
"\n" +
"team package fbapplication.GUIConnector;\n" +
"@SuppressWarnings(\"roletypesyntax\")\n" +
"protected team class FlightBonusDialog playedBy FlightBonus {\n" +
" protected class Collector playedBy base.Item {\n" +
" recordCredits <- replace calculateCredit;\n" +
" getDestination -> getDestination;\n" +
" getStart -> getStart;\n" +
" }\n" +
" @SuppressWarnings(\"decapsulation\") // getCollectedCredits\n" +
" protected class Message playedBy base.Subscriber {\n" +
" getTotalCollectedCredits -> getCollectedCredits;\n" +
" getName -> getName;\n" +
" showBonusDialog <- after buy;\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication/BonusGUI/FlightBonusDialog.java",
"\n" +
"team package fbapplication.BonusGUI;\n" +
"protected team class FlightBonusDialog playedBy FlightBonus {\n" +
" String message; \n" +
" public FlightBonusDialog(FlightBonus fb) {\n" +
" this.initializeMessage(0);\n" +
" this.activate();\n" +
" System.out.println(\"FBDialog \");\n" +
" }\n" +
" void initializeMessage(int credits) {\n" +
" this.message = new String(\"Collected credits in the past: \"+credits+\"\\n\");\n" +
" }\n" +
" protected abstract class Collector {\n" +
" public abstract String getStart();\n" +
" public abstract String getDestination();\n" +
" callin int recordCredits() {\n" +
" int credits = base.recordCredits();\n" +
" FlightBonusDialog.this.message += \"FlightSegment: \\n\";\n" +
" FlightBonusDialog.this.message += \" \"+this.getStart()+\"-->\"+this.getDestination()+\"\\n\";\n" +
" FlightBonusDialog.this.message += \" earning credit: \"+credits+\"\\n\";\n" +
" return credits;\n" +
" }\n" +
" }\n" +
" protected abstract class Message {\n" +
" abstract int getTotalCollectedCredits();\n" +
" abstract String getName();\n" +
" public void showBonusDialog() {\n" +
" int currentCredits = this.getTotalCollectedCredits();\n" +
" String title = \"Bonus message for Passenger \"+this.getName(); \n" +
" FlightBonusDialog.this.message += new String (\"Collected credits now: \"+currentCredits);\n" +
" JOptionPane.showMessageDialog(\n" +
" BonusGUI.this.view.getComponent(), \n" +
" FlightBonusDialog.this.message, \n" +
" title, \n" +
" JOptionPane.INFORMATION_MESSAGE);\n" +
" FlightBonusDialog.this.initializeMessage(currentCredits);\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK",
getBookingClassLibraries(),
false/*shouldFlushOutputDirectory*/,
null/*vmArguments*/);
}
// the flightbonus sample as shipped with the OTDT, compilation only (interactive GUI application!) - parameterized type syntax
// X.3.1-otjld-flightbonus-sample-2
public void testX31_flightbonusSample2() {
runConformTest(
new String[] {
"fbapplication2/DummyMain.java",
"package fbapplication2;\n" +
"public class DummyMain {\n" +
" public static void main(String... args) {\n" +
" new GUIConnector().activate();\n" +
" System.out.print(\"OK\");\n" +
" }\n" +
"}\n",
"fbapplication2/FlightBonus.java",
"\n" +
"package fbapplication2;\n" +
"import bonussystem2.Bonus;\n" +
"import base flightbooking.model.Passenger;\n" +
"import base flightbooking.model.Segment;\n" +
"public team class FlightBonus extends Bonus {\n" +
" public FlightBonus(Passenger as Subscriber s) {\n" +
" activate();\n" +
" }\n" +
" @Override\n" +
" public class Subscriber playedBy Passenger \n" +
" base when (FlightBonus.this.hasRole(base)) \n" +
" {\n" +
" buy <- replace book;\n" +
" String getName() -> String getName();\n" +
" };\n" +
" @Override\n" +
" public class Item playedBy Segment {\n" +
" @Override\n" +
" int calculateCredit () {\n" +
" int miles = getDistance();\n" +
" int credit = (((miles+999)/1000)) * 1000;\n" +
" return credit;\n" +
" };\n" +
" earnCredit <- after book;\n" +
" String getDestination() -> String getDestination();\n" +
" int getDistance() -> int getDistance();\n" +
" String getStart() -> String getStart();\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication2/BonusGUI.java",
"\n" +
"package fbapplication2;\n" +
"import java.awt.Component;\n" +
"import javax.swing.JOptionPane;\n" +
"import flightbooking.model.Passenger;\n" +
"public team class BonusGUI {\n" +
" View view = null;\n" +
" abstract protected class View {\n" +
" void registerView() {\n" +
" BonusGUI.this.view = this;\n" +
" }\n" +
" protected boolean queryRegisterDialog() {\n" +
" int choice = JOptionPane.showConfirmDialog(\n" +
" getComponent(), \n" +
" \"Register for Flight Bonus?\", \n" +
" \"OT Bonus System\", \n" +
" JOptionPane.YES_NO_OPTION);\n" +
" return choice == JOptionPane.YES_OPTION;\n" +
" }\n" +
" protected abstract Component getComponent();\n" +
" }\n" +
" protected class Controller \n" +
" when (BonusGUI.this.view != null) \n" +
" {\n" +
" void queryRegisterForBonus (Passenger p) {\n" +
" if (BonusGUI.this.view.queryRegisterDialog()) \n" +
" new FlightBonusDialog(new FlightBonus(p));\n" +
" };\n" +
" }\n" +
"}\n" +
" \n",
"bonussystem2/Bonus.java",
"\n" +
"package bonussystem2;\n" +
"public abstract team class Bonus {\n" +
" protected Subscriber subscriber = null;\n" +
" public abstract class Subscriber {\n" +
" private int collectedCredits = 0;\n" +
" protected int getCollectedCredits() {\n" +
" return collectedCredits;\n" +
" }\n" +
" protected void collectCredit (int credit) {\n" +
" collectedCredits += credit;\n" +
" }\n" +
" callin void buy ()\n" +
" {\n" +
" Bonus.this.subscriber = this;\n" +
" base.buy();\n" +
" Bonus.this.subscriber = null;\n" +
"\n" +
" log(\"Sub. has collected \"+getCollectedCredits()+\" credit points.\");\n" +
" }\n" +
" }\n" +
" public abstract class Item {\n" +
" abstract int calculateCredit ();\n" +
" protected void earnCredit () {\n" +
" Subscriber subscriber = Bonus.this.subscriber;\n" +
" if (subscriber == null)\n" +
" return;\n" +
"\n" +
" int tmpCredits = calculateCredit();\n" +
" log(\"buying an item that yields \"+tmpCredits+\" credit points.\");\n" +
" subscriber.collectCredit(tmpCredits);\n" +
" }\n" +
" }\n" +
" protected void log (String msg) {\n" +
" System.out.println(\">>Bonus>> \"+msg);\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication2/GUIConnector.java",
"\n" +
"package fbapplication2;\n" +
"import java.awt.Component;\n" +
"import base flightbooking.gui.FlightBookingGUI;\n" +
"import base flightbooking.model.PassengerDB;\n" +
"public team class GUIConnector extends BonusGUI {\n" +
" @Override\n" +
" protected class View playedBy FlightBookingGUI {\n" +
" protected Component getComponent () {\n" +
" return this;\n" +
" }\n" +
" registerView <- after initComponents;\n" +
" }\n" +
" @Override\n" +
" protected class Controller playedBy PassengerDB {\n" +
" queryRegisterForBonus <- after add;\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication2/GUIConnector/FlightBonusDialog.java",
"\n" +
"team package fbapplication2.GUIConnector;\n" +
"@Override\n" +
"protected team class FlightBonusDialog playedBy FlightBonus {\n" +
" @Override @SuppressWarnings(\"decapsulation\") // base calls to callin\n" +
" protected class Collector playedBy Item<@FlightBonusDialog.base> {\n" +
" recordCredits <- replace calculateCredit;\n" +
" getDestination -> getDestination;\n" +
" getStart -> getStart;\n" +
" }\n" +
" @Override @SuppressWarnings(\"decapsulation\") // getCollectedCredits\n" +
" protected class Message playedBy Subscriber<@FlightBonusDialog.base> {\n" +
" getTotalCollectedCredits -> getCollectedCredits;\n" +
" getName -> getName;\n" +
" showBonusDialog <- after buy;\n" +
" }\n" +
"}\n" +
" \n",
"fbapplication2/BonusGUI/FlightBonusDialog.java",
"\n" +
"team package fbapplication2.BonusGUI;\n" +
"protected team class FlightBonusDialog playedBy FlightBonus {\n" +
" String message; \n" +
" public FlightBonusDialog(FlightBonus fb) {\n" +
" this.initializeMessage(0);\n" +
" this.activate();\n" +
" System.out.println(\"FBDialog \");\n" +
" }\n" +
" void initializeMessage(int credits) {\n" +
" this.message = new String(\"Collected credits in the past: \"+credits+\"\\n\");\n" +
" }\n" +
" protected abstract class Collector {\n" +
" public abstract String getStart();\n" +
" public abstract String getDestination();\n" +
" callin int recordCredits() {\n" +
" int credits = base.recordCredits();\n" +
" FlightBonusDialog.this.message += \"FlightSegment: \\n\";\n" +
" FlightBonusDialog.this.message += \" \"+this.getStart()+\"-->\"+this.getDestination()+\"\\n\";\n" +
" FlightBonusDialog.this.message += \" earning credit: \"+credits+\"\\n\";\n" +
" return credits;\n" +
" }\n" +
" }\n" +
" protected abstract class Message {\n" +
" abstract int getTotalCollectedCredits();\n" +
" abstract String getName();\n" +
" public void showBonusDialog() {\n" +
" int currentCredits = this.getTotalCollectedCredits();\n" +
" String title = \"Bonus message for Passenger \"+this.getName(); \n" +
" FlightBonusDialog.this.message += new String (\"Collected credits now: \"+currentCredits);\n" +
" JOptionPane.showMessageDialog(\n" +
" BonusGUI.this.view.getComponent(), \n" +
" FlightBonusDialog.this.message, \n" +
" title, \n" +
" JOptionPane.INFORMATION_MESSAGE);\n" +
" FlightBonusDialog.this.initializeMessage(currentCredits);\n" +
" }\n" +
" }\n" +
"}\n" +
" \n"
},
"OK",
getBookingClassLibraries(),
false/*shouldFlushOutputDirectory*/,
null/*vmArguments*/);
}
// a team extends a non-team class - note: "-g" caused an overflow of non-wide constants
// X.4.1-otjld-team-extends-regular-1
public void testX41_teamExtendsRegular1() {
Map customOptions = getCompilerOptions();
customOptions.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE);
customOptions.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE);
customOptions.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE);
runConformTest(
new String[] {
"TeamX41ter1.java",
"\n" +
"public team class TeamX41ter1 extends TX41ter1 {\n" +
" public static void main(String[] args) {\n" +
" org.objectteams.ITeam t = new TeamX41ter1();\n" +
" t.activate(org.objectteams.Team.ALL_THREADS);\n" +
" if (t.isActive());\n" +
" System.out.print(t);\n" +
" t.deactivate();\n" +
" System.out.print(t.isActive());\n" +
" }\n" +
"}\n" +
" \n",
"TX41ter1.java",
"\n" +
"public class TX41ter1 {\n" +
" public String toString() {\n" +
" return \"OK\";\n" +
" }\n" +
"}\n" +
" \n"
},
"OKfalse",
null/*classLibraries*/,
true/*shouldFlushOutputDirectory*/,
null/*vmArguments*/,
customOptions,
null/*no custom requestor*/);
}
public void testBug487037() {
runConformTest(
new String[] {
"Main.java",
"public class Main {\n" +
" public static void main(String... args) {\n" +
" new TeamFoo().activate();\n" +
" new b.B1().test();\n" +
" new b.B1b();\n" +
" new b.B2().test();\n" +
" }\n" +
"}\n",
"b/B1.java",
"package b;\n" +
"public class B1 {\n" +
" void bm1() {}\n" +
" void bm2() {}\n" +
" void bm3() {}\n" +
" void bm4() {}\n" +
" void bm5() {}\n" +
" void bm6() {}\n" +
" void bm7() {}\n" +
" void bm8() {}\n" +
" void bm9() {}\n" +
" void bmA() {}\n" +
" private void bm() {\n" +
" System.out.print(\"bm\");\n" +
" }\n" +
" public void test() { bm(); }\n" +
"}\n",
"b/B1b.java",
"package b;\n" +
"public class B1b extends B1 {}\n", // stuffing to test transfer of binding tasks accross multiple anonymous sub classes
"b/B2.java",
"package b;\n" +
"public class B2 extends B1 {\n" +
" public void test() { super.test(); }\n" +
"}\n",
"TeamFoo.java",
"import base b.B1;\n" +
"public team class TeamFoo {\n" +
" protected class R playedBy B1 {\n" +
" void rm() { System.out.print(\"rm\"); }\n" +
" rm <- after bm1;\n" + // stuffing to create more interesting method & joinpoint ids
" rm <- after bm2;\n" +
" rm <- after bm3;\n" +
" rm <- after bm4;\n" +
" rm <- after bm5;\n" +
" rm <- after bm6;\n" +
" rm <- after bm7;\n" +
" rm <- after bm8;\n" +
" rm <- after bm;\n" +
" }\n" +
"}\n"
},
"bmrmbmrm");
}
}