forked from JavaTX/JavaCompilerCore
Overloading an neue Assumptions angepasst
This commit is contained in:
JanUlrich
parent
c242061541
commit
d397002960
@ -1,12 +0,0 @@
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class TestAssignmentTwoGenericTypesNegative {
|
||||
|
||||
public void m() {
|
||||
|
||||
ArrayList<String> ls;
|
||||
ls = new ArrayList<String>();
|
||||
ArrayList<Object> lo;
|
||||
lo = ls; /*<-- compile error*/
|
||||
}
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
interface I1 {}
|
||||
|
||||
interface I2 {}
|
||||
|
||||
class Implementation implements I1 {}
|
||||
|
||||
class Implementation2 implements I2 {}
|
||||
|
||||
class A<T extends I1> {}
|
||||
|
||||
class B<T extends I1 & I2>{}
|
||||
|
||||
class C<T extends I1 & Implementation>{}
|
||||
|
||||
class D<T extends I2 & Implementation>{}
|
||||
|
||||
class E<T extends Implementation & Implementation2>{}
|
||||
@ -1,21 +0,0 @@
|
||||
interface I1 {
|
||||
public m1();
|
||||
}
|
||||
|
||||
class Implementation implements I1 {
|
||||
public m1() {
|
||||
}
|
||||
}
|
||||
|
||||
class TestClassesWithBoundedGenericsUsedInMethods<T extends I1> {
|
||||
|
||||
/*since S is at least of Type I1, call m1() should work*/
|
||||
public <S extends I1> void m3 (S x) {
|
||||
x.m1();
|
||||
}
|
||||
|
||||
/*T is bounded by class generics, thus always at least of type I1*/
|
||||
public m2(T x) {
|
||||
x.m1();
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
interface I1 {
|
||||
public m1();
|
||||
}
|
||||
|
||||
interface I2 {
|
||||
public m2();
|
||||
}
|
||||
|
||||
class Implementation implements I1, I2 {
|
||||
public m1() {}
|
||||
|
||||
public m2() {}
|
||||
}
|
||||
|
||||
class Tester<T extends I1 & I2> {
|
||||
|
||||
public m3(T x) {
|
||||
x.m1();
|
||||
x.m2();
|
||||
}
|
||||
}
|
||||
|
||||
public class TestExtendedClassesWithBoundedGenerics {
|
||||
|
||||
public m() {
|
||||
x;
|
||||
/*can only be of Type Implementation*/
|
||||
x= new Implementation();
|
||||
y;
|
||||
/*could be of Type: Tester<Implementation>, Tester<? super Implementation>*/
|
||||
y= new Tester<Implementation>();
|
||||
y.m3(x);
|
||||
}
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
class A<T>{
|
||||
|
||||
}
|
||||
|
||||
public class TestNestedGenerics{
|
||||
<T extends A<C>,C> void foo(T a,C b){}
|
||||
|
||||
void m(){
|
||||
TestNestedGenerics t = new TestNestedGenerics();
|
||||
String str = new String();
|
||||
A<String> a = new A<String>();
|
||||
t.foo(a,str);
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
|
||||
public class TestNestedGenerics{
|
||||
|
||||
<T extends A<C>,C> void foo(T a,C b){}
|
||||
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
import java.util.Vector;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class TestSimpleClassesWithBoundedGenerics<T extends java.lang.Number> {
|
||||
|
||||
public ma(T x) {
|
||||
return x;
|
||||
}
|
||||
}
|
||||
|
||||
class A {
|
||||
|
||||
public m1() {
|
||||
x;
|
||||
x= new TestSimpleClassesWithBoundedGenerics<Integer>();
|
||||
return x.ma(3);
|
||||
}
|
||||
|
||||
public m2() {
|
||||
x;
|
||||
x = new TestSimpleClassesWithBoundedGenerics<Double>();
|
||||
}
|
||||
/*
|
||||
public m2() {
|
||||
x;
|
||||
x= new TestSimpleClassesWithBoundedGenerics<Double>();
|
||||
return x.m(new Double(3.));
|
||||
}
|
||||
*/
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
|
||||
public class TestSimpleClassesWithBoundedGenericsNegative<T extends java.lang.Number> {
|
||||
|
||||
public m(T x) {
|
||||
return x;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class A {
|
||||
public m1() {
|
||||
x;
|
||||
x = new TestSimpleClassesWithBoundedGenericsNegative<String>();
|
||||
return x.m("abc");
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
public class TestSimpleClassesWithGenerics<T> {
|
||||
|
||||
public m(T x) {
|
||||
return x;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class A {
|
||||
|
||||
public method() {
|
||||
x;
|
||||
x= new TestSimpleClassesWithGenerics<Integer>();
|
||||
return x.m(3);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
public class TestSimpleClassesWithGenericsNegative<T> {
|
||||
|
||||
public m(T x) {
|
||||
return x;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class A {
|
||||
|
||||
public method() {
|
||||
x;
|
||||
x= new TestSimpleClassesWithGenerics<Integer>();
|
||||
return x.m("abc");
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
public class TestInferenceOwnTypeByMember {
|
||||
|
||||
Float a;
|
||||
|
||||
public void m1(b) {
|
||||
a += b;
|
||||
}
|
||||
|
||||
public void m2(a) {
|
||||
this.a=a;
|
||||
}
|
||||
|
||||
public m3() {
|
||||
return a;
|
||||
}
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
class A {
|
||||
|
||||
public Character c;
|
||||
|
||||
}
|
||||
|
||||
public class TestInferenceOwnTypeByMemberAcrossClasses {
|
||||
|
||||
public m1(a) {
|
||||
x;
|
||||
x = new A();
|
||||
a=x.c;
|
||||
}
|
||||
}
|
||||
@ -1,32 +0,0 @@
|
||||
public class TestInferenceOwnTypeByMethodCall{
|
||||
|
||||
public m1(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
public Integer m2(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
public m3(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public void m01(d) {
|
||||
e;
|
||||
e=m1(d);
|
||||
}
|
||||
|
||||
public void m02(d) {
|
||||
e;
|
||||
e=m2(d);
|
||||
}
|
||||
|
||||
public void m03(c,Character d) {
|
||||
e;
|
||||
e=c.m3(d);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
class A{
|
||||
public mA(x){
|
||||
return(x);
|
||||
}
|
||||
}
|
||||
|
||||
class TestInferenceOwnTypeByMethodCallAcrossClasses{
|
||||
|
||||
public m(Integer a, String b){
|
||||
x;
|
||||
x=new A();
|
||||
c;
|
||||
c=x.mA(a);
|
||||
d;
|
||||
d=x.mA(b);
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
class A {
|
||||
static void m() {}
|
||||
}
|
||||
|
||||
public class TestInferenceOwnTypeByMethodParameter {
|
||||
|
||||
m1(a,b) {
|
||||
return a+b;
|
||||
}
|
||||
|
||||
m2(java.lang.String a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
m3(a) {
|
||||
return a.m();
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
class A1{
|
||||
void foo(java.lang.String x){}
|
||||
}
|
||||
class A2{
|
||||
void foo(java.lang.Integer y){}
|
||||
}
|
||||
class B1{
|
||||
java.lang.String bar(){return("");}
|
||||
}
|
||||
class B2{
|
||||
java.lang.Integer bar(){return(1);}
|
||||
}
|
||||
public class TestInferenceOwnTypeByMethodReturnTypeMixed1{
|
||||
method1(a,b){
|
||||
a.foo(b.bar());
|
||||
}
|
||||
method2(a,B2 b) {
|
||||
a.foo(b.bar());
|
||||
}
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
public class TestInferenceOwnTypeByReturnType {
|
||||
|
||||
public java.lang.Integer m1(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
public String m2() {
|
||||
return "abc";
|
||||
}
|
||||
|
||||
public void m3(a) {
|
||||
a=m2();
|
||||
}
|
||||
|
||||
public java.lang.Integer m4(a,b) {
|
||||
return a+b;
|
||||
}
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
class A{
|
||||
public String m() {
|
||||
return "abc";
|
||||
}
|
||||
}
|
||||
|
||||
class B{
|
||||
public Integer m() {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestInferenceOwnTypeByReturnTypeAcrossClasses {
|
||||
|
||||
public main1(java.lang.Integer i, x){
|
||||
i=x.m();
|
||||
}
|
||||
|
||||
public main2(i,x) {
|
||||
i=x.m();
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,9 +0,0 @@
|
||||
import java.lang.System;
|
||||
|
||||
public class TestInferenceStdTypeByMember {
|
||||
|
||||
public m1(a) {
|
||||
a=System.out;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
import java.util.HashMap;
|
||||
import java.lang.Object;
|
||||
|
||||
public class TestInferenceStdTypeByOperation {
|
||||
|
||||
public m1(a) {
|
||||
a.put("1","1");
|
||||
}
|
||||
|
||||
public m2(b) {
|
||||
b.toString();
|
||||
}
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
import java.util.Vector;
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class TestInferenceStdTypeByReturnType {
|
||||
|
||||
public void m1(a) {
|
||||
b;
|
||||
b= new Vector<String>();
|
||||
a = b.size();
|
||||
}
|
||||
|
||||
public void m2(a) {
|
||||
b;
|
||||
b= new ArrayList<String>();
|
||||
a = b.get(0);
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,56 +0,0 @@
|
||||
/*
|
||||
A
|
||||
B C
|
||||
D E
|
||||
|
||||
*/
|
||||
|
||||
class A {
|
||||
fooA() {}
|
||||
}
|
||||
|
||||
class B extends A {
|
||||
fooB() {}
|
||||
}
|
||||
|
||||
class C extends A {
|
||||
fooC(){}
|
||||
}
|
||||
|
||||
class D extends B {
|
||||
fooD() {}
|
||||
}
|
||||
|
||||
class E extends B {
|
||||
fooE() {}
|
||||
}
|
||||
|
||||
|
||||
|
||||
public class TestInheritanceAcrossLevel {
|
||||
|
||||
public m1(x) {
|
||||
x.fooA();
|
||||
return x;
|
||||
}
|
||||
|
||||
public m2(x) {
|
||||
x.fooB();
|
||||
/*return x;*/
|
||||
}
|
||||
|
||||
public m3(x) {
|
||||
x.fooC();
|
||||
/*return x;*/
|
||||
}
|
||||
|
||||
public m4(x) {
|
||||
x.fooD();
|
||||
/*return x;*/
|
||||
}
|
||||
|
||||
public m5(B x) {
|
||||
x.fooA();
|
||||
return x;
|
||||
}
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
/*
|
||||
|
||||
<i>A
|
||||
<i>B <i>C
|
||||
D
|
||||
*/
|
||||
|
||||
interface A{
|
||||
fooA();
|
||||
}
|
||||
|
||||
interface B extends A{
|
||||
fooB();
|
||||
}
|
||||
|
||||
interface C extends A{}
|
||||
|
||||
class D implements B,C {
|
||||
fooA() {
|
||||
}
|
||||
fooB() {
|
||||
}
|
||||
}
|
||||
|
||||
public class TestInheritanceCircle{
|
||||
|
||||
public m1(x) {
|
||||
x.fooA();
|
||||
/*return x;*/
|
||||
}
|
||||
|
||||
public m2(x) {
|
||||
x.fooB();
|
||||
/*return x;*/
|
||||
}
|
||||
public m3(D x) {
|
||||
x.fooA();
|
||||
return x;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
class A {
|
||||
public Integer memberInteger;
|
||||
|
||||
public A(i) {
|
||||
member=i;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class B extends A {
|
||||
public String memberString;
|
||||
public B(i,s) {
|
||||
super(i);
|
||||
memberString=s;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestInheritanceConstructor {
|
||||
|
||||
public static main() {
|
||||
x;
|
||||
x=new B(3,"abc");
|
||||
y;
|
||||
y=x.memberInteger;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
interface A{
|
||||
}
|
||||
interface B{}
|
||||
|
||||
class Tester implements A,B{
|
||||
m(){
|
||||
}
|
||||
}
|
||||
|
||||
public class TestInheritanceMultiple{
|
||||
|
||||
/*should return either of Type Intf1, Intf2, or Tester*/
|
||||
public m1(x){
|
||||
x.m();
|
||||
return(x);
|
||||
}
|
||||
|
||||
public m2(Tester x){
|
||||
x.m();
|
||||
return x;
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
|
||||
class A {}
|
||||
|
||||
class B {}
|
||||
|
||||
public class TestInheritanceMultipleClasses extends A, B {
|
||||
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
class A{
|
||||
public m() {
|
||||
return new A();
|
||||
}
|
||||
}
|
||||
|
||||
class B extends A{
|
||||
|
||||
public m() {
|
||||
return new B();
|
||||
}
|
||||
public m(java.lang.Integer a) {
|
||||
return a;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestInheritanceOverriding {
|
||||
|
||||
public main1(x,A y) {
|
||||
y = new B();
|
||||
x = y.m();
|
||||
}
|
||||
/*public main2(x) {
|
||||
y;
|
||||
y=x.m(2);
|
||||
}*/
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
|
||||
/*
|
||||
|
||||
A <i>I
|
||||
B C D
|
||||
E F
|
||||
|
||||
*/
|
||||
interface I{
|
||||
void fooA();
|
||||
}
|
||||
class A{
|
||||
void fooA() {}
|
||||
}
|
||||
class B extends A{}
|
||||
|
||||
class C extends A implements I{}
|
||||
|
||||
class D implements I{
|
||||
fooD() {}
|
||||
}
|
||||
class E extends B {}
|
||||
|
||||
class F extends C{}
|
||||
|
||||
public class TestInheritanceTwoHierarchies {
|
||||
|
||||
public m1(x) {
|
||||
x.fooA();
|
||||
return x;
|
||||
}
|
||||
|
||||
public m2(x) {
|
||||
x.fooD();
|
||||
return x;
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
|
||||
class A {
|
||||
|
||||
public m1() {
|
||||
}
|
||||
}
|
||||
|
||||
public class TestSimpleInheritance extends A {
|
||||
|
||||
public m(x) {
|
||||
x.m1();
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
class OverloadingDifferentNumberOfParameters{
|
||||
void foo(){}
|
||||
void foo(Integer a){}
|
||||
void foo(Integer a, Double b){}
|
||||
void foo(Integer a, Double b, Long c){}
|
||||
}
|
||||
@ -1,9 +0,0 @@
|
||||
class OverloadingDifferentNumberOfParametersAndDifferentTypes{
|
||||
void foo(){}
|
||||
void foo(Integer a){}
|
||||
void foo(Integer a, Double b){}
|
||||
void foo(Integer a, Double b, Long c){}
|
||||
void foo(String a){}
|
||||
void foo(String a, Integer b){}
|
||||
void foo(String a, Integer b, Long c){}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaed eine Methoden bei total Typverschiedenen generischen parametern (nicht gleiche Vererbungshierarchie
|
||||
*/
|
||||
class OverloadingGenericNotSameHierarchy{
|
||||
|
||||
void foo(){}
|
||||
<T extends Number> void foo(T n){}
|
||||
<T extends java.util.Vector> void foo(T v){}
|
||||
|
||||
/*
|
||||
<T extends Vector> void foo(T n){}
|
||||
*/
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaedt eine Methoden bei verschiedenen generischen Typen von Parametern welche in der gleichen Vererbungshierarchie liegen*/
|
||||
|
||||
class OverloadingGenericSameHierarchy {
|
||||
<T extends Object> void foo(T o){}
|
||||
<T extends Number> void foo(T n){}
|
||||
<T extends Integer> void foo(T i){}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaedt eine Methode durch Typinferenz erkannte generische typverschiedenen Tarametern (nicht gleiche Vererbungshierarchie)
|
||||
*/
|
||||
|
||||
import java.util.Vector;
|
||||
|
||||
class A<T> {
|
||||
|
||||
}
|
||||
|
||||
class OverloadingGenericTypeInferenceNotSameHierarchy<T>{
|
||||
foo(){}
|
||||
foo(i){
|
||||
i = new A<Double>();
|
||||
}
|
||||
foo(s){
|
||||
s = new Vector<Integer>();
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaedt eine Methoden durch typeinferenz erkannte generische Typverschiedenen parametern welche in der selben Typhierarchie sind*/
|
||||
class B<T>{
|
||||
}
|
||||
class C<T> extends B<T>{
|
||||
}
|
||||
class D<T> extends C<T>{
|
||||
}
|
||||
class OverloadingGenericTypeInferenceSameHierarchy{
|
||||
foo(i){
|
||||
i = new B<Integer>();
|
||||
}
|
||||
foo(n){
|
||||
n = new C<Integer>();
|
||||
}
|
||||
|
||||
foo(o){
|
||||
o = new D<Integer>();
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaed eine Methoden bei total Typverschiedenen parametern (nicht gleiche Vererbungshierarchie
|
||||
*/
|
||||
class OverloadingNotSameHierarchy{
|
||||
void foo(){}
|
||||
void foo(String s){}
|
||||
void foo(Integer i){}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaedt eine Methoden bei verschiedenen Typen von Parametern welche in der gleichen Vererbungshierarchie liegen*/
|
||||
class OverloadingSameHierarchy{
|
||||
void foo(java.lang.Number n){}
|
||||
void foo(java.lang.Integer i){}
|
||||
void foo(java.lang.Object o){}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
class OverloadingSameSignature{
|
||||
void foo(){
|
||||
}
|
||||
void foo(){
|
||||
}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class OverloadingSameSignatureDifferentReturnTypes{
|
||||
void foo(){
|
||||
}
|
||||
String foo(){
|
||||
return "abcd";
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
class OverloadingSameSignatureGenerics{
|
||||
<T> T foo(T a){
|
||||
return a;
|
||||
}
|
||||
<T> void foo(T a){
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaed eine Methoden durch typeinferenz erkannte Typverschiedenen parametern (nicht gleiche Vererbungshierarchie
|
||||
*/
|
||||
class OverloadingTypeInferenceNotSameHierarchy{
|
||||
foo(){}
|
||||
foo(i){
|
||||
i = new java.lang.Integer();
|
||||
}
|
||||
foo(s){
|
||||
s = "String";
|
||||
}
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
/*
|
||||
Diese Klasse ueberlaed eine Methoden durch typeinferenz erkannte Typverschiedenen parametern welche in der selben Typhierarchie sind*/
|
||||
class OverloadingTypeInferenceSameHierarchy{
|
||||
/*i = Integer*/
|
||||
foo(i){
|
||||
i = new java.lang.Integer();
|
||||
}
|
||||
/*n = Number*/
|
||||
foo(n){
|
||||
n = new java.lang.Number();
|
||||
}
|
||||
/*o = Object*/
|
||||
foo(o){
|
||||
o = new java.lang.Object();
|
||||
}
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
public class Access{
|
||||
|
||||
public String nonStaticMember="abc";
|
||||
|
||||
public nonStaticMethod() {
|
||||
return "def";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class TestNonStaticAccess {
|
||||
|
||||
public method1(a,b) {
|
||||
x;
|
||||
x = new Access();
|
||||
a=x.nonStaticMember;
|
||||
b=x.nonStaticMethod();
|
||||
}
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
public class Access{
|
||||
|
||||
public static String staticMember="def";
|
||||
|
||||
public static staticMethod() {
|
||||
return "abc";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class TestStaticAccess {
|
||||
|
||||
public method1(a,b) {
|
||||
x;
|
||||
a=x.staticMember;
|
||||
b=x.staticMethod();
|
||||
}
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
public class Access{
|
||||
public String nonStaticMember="abc";
|
||||
|
||||
public nonStaticMethod() {
|
||||
return "def";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class TestStaticAccessError {
|
||||
|
||||
public methodError1(a,b) {
|
||||
x;
|
||||
a=x.nonStaticMember;
|
||||
b=x.nonStaticMethod();
|
||||
}
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
class BasicAssumptionsTest{
|
||||
|
||||
varString;
|
||||
var = 2;
|
||||
|
||||
void methode(){
|
||||
var = 1;
|
||||
varString = varString.toString();
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
class ConstructorTest1{
|
||||
|
||||
ConstructorTest1(){
|
||||
var;
|
||||
var = 1;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class ConstructorTest2{
|
||||
var;
|
||||
void method(){
|
||||
var = new ConstructorTest1();
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class GenericVarTest{
|
||||
Vector<? extends Object> test;
|
||||
method(){
|
||||
test = test;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class GenericVarTest{
|
||||
test;
|
||||
method(){
|
||||
test = test;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class LambdaTest1{
|
||||
var = "test";
|
||||
|
||||
method(String toAppend){
|
||||
return (String text) -> { return toAppend;};
|
||||
}
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
class OverloadingTest{
|
||||
|
||||
var;
|
||||
|
||||
public Object clone(){
|
||||
return this;
|
||||
}
|
||||
|
||||
public testMethode(){
|
||||
return var.clone();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class OverloadingTest2{
|
||||
|
||||
public Object clone(){
|
||||
return this;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
class Assign{
|
||||
stringVar = "String";
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
class Matrix extends Vector<Vector<Integer>> {
|
||||
op = (m) -> (f) -> f.apply(this, m); }
|
||||
@ -1,13 +0,0 @@
|
||||
class TestIfStmt {
|
||||
|
||||
methode(){
|
||||
var;
|
||||
if(true){
|
||||
var=this;
|
||||
}else{
|
||||
var=this;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
class TestLambda{
|
||||
op = (test) -> test = "string";
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
class TestMethodCall {
|
||||
|
||||
var;
|
||||
|
||||
getSomething(){
|
||||
return this;
|
||||
}
|
||||
|
||||
getSomethingMore(){
|
||||
return getSomething();
|
||||
}
|
||||
|
||||
void setVar(){
|
||||
var = getSomethingMore();
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
class WhileTest{
|
||||
|
||||
public method(){
|
||||
var;
|
||||
while(true){
|
||||
var = "String";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class ThisTest{
|
||||
|
||||
thisVar = this;
|
||||
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
class Klasse2 {
|
||||
|
||||
var1;
|
||||
|
||||
testMethode(){
|
||||
var1 = new Klasse1();
|
||||
return var1.getVar1();
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
class Klasse1 {
|
||||
var1;
|
||||
|
||||
int getVar1(){
|
||||
return var1;
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
|
||||
class TestAbstractInferenceTest<A> {
|
||||
|
||||
public foo(a, b) {
|
||||
c;
|
||||
d;
|
||||
d = a+ b;
|
||||
{
|
||||
i;
|
||||
i=5;
|
||||
}
|
||||
{
|
||||
i;
|
||||
i="abc";
|
||||
}
|
||||
c = new TestAbstractInferenceTest<String>();
|
||||
return a+b;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
|
||||
public class TestAbstractInferenceTest2 {
|
||||
|
||||
method(Integer a, String s) {
|
||||
}
|
||||
}
|
||||
|
||||
class TestAbstractInferenceTest3 extends TestAbstractInferenceTest2 {
|
||||
/*
|
||||
method(Integer a) {
|
||||
c;
|
||||
}*/
|
||||
method2(String s) {
|
||||
c;
|
||||
c = new TestAbstractInferenceTest2();
|
||||
c.method(2,"abc");
|
||||
method(3,"abc");
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
|
||||
public class TestClassMemberWithoutType {
|
||||
|
||||
member;
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
public class TestConstantsWithoutType {
|
||||
public final static B = true;
|
||||
public final static I = 1;
|
||||
public final static C = 'A';
|
||||
public final static S = "Hello World!";
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
|
||||
|
||||
public class TestGenerics {
|
||||
|
||||
<T extends Vector<Integer>> void foo(T n) {}
|
||||
<T extends Number> void foo(T i) {}
|
||||
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
interface A{
|
||||
public m();
|
||||
}
|
||||
class TestInheritanceCheckValidImplementationFromInterface implements A{
|
||||
|
||||
public void m(){}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
interface A{
|
||||
public m();
|
||||
}
|
||||
class TestInheritanceCheckValidImplementationFromInterfaceNegative implements A{
|
||||
|
||||
public void m1(){}
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
interface TestInheritanceCheckValidImplementationFromInterfaceNegative2{
|
||||
public m();
|
||||
}
|
||||
class A implements TestInheritanceCheckValidImplementationFromInterfaceNegative2{
|
||||
|
||||
public void m(){}
|
||||
}
|
||||
|
||||
class B implements TestInheritanceCheckValidImplementationFromInterfaceNegative2 {
|
||||
|
||||
public m() {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
|
||||
public class TestMethodReturnType {
|
||||
|
||||
/* methodReturnType1(a) {
|
||||
return a;
|
||||
}
|
||||
*/
|
||||
methodReturnType2(a,b) {
|
||||
return a+b;
|
||||
}
|
||||
|
||||
methodReturnType3(String a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
Integer methodReturnType4(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
|
||||
public class TestMethodReturnTypeGeneric<A> {
|
||||
|
||||
testMethodReturnTypeGeneric() {
|
||||
return new TestMethodReturnTypeGeneric<Double>();
|
||||
}
|
||||
|
||||
testMethodReturnTypeGeneric2(T<?extends Number> a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
|
||||
public class TestMethodReturnTypeNegative {
|
||||
|
||||
/*returned String, but must be Integer*/
|
||||
Integer m1(String a) {
|
||||
return a;
|
||||
}
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
|
||||
public class TestMethodReturnTypeNegative2 {
|
||||
|
||||
/*not always boolean returned*/
|
||||
public m1() {
|
||||
a;
|
||||
if (a) {
|
||||
return a;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
public class TestOperatorArithmetic {
|
||||
|
||||
public m1(i,j) {
|
||||
return i+j;
|
||||
}
|
||||
|
||||
public m2(i,java.lang.Double j) {
|
||||
return i-j;
|
||||
}
|
||||
|
||||
public m3(java.lang.Integer i,j) {
|
||||
return i*j;
|
||||
}
|
||||
|
||||
public java.lang.Double m4(i,j) {
|
||||
return i/j;
|
||||
}
|
||||
|
||||
public m5(i,j) {
|
||||
return i%j;
|
||||
}
|
||||
|
||||
public m6(i) {
|
||||
return -i;
|
||||
}
|
||||
|
||||
public m7 (i,j) {
|
||||
i+=j;
|
||||
return i;
|
||||
}
|
||||
|
||||
public m8(i, java.lang.Float j) {
|
||||
return i/j;
|
||||
}
|
||||
|
||||
/*public java.lang.Long m9(i, j) {
|
||||
return i+j;
|
||||
}*/
|
||||
|
||||
}
|
||||
@ -1,45 +0,0 @@
|
||||
public class TestOperatorBitwise {
|
||||
|
||||
public m1(a,b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
public m2(a,b) {
|
||||
return a ^ b;
|
||||
}
|
||||
|
||||
public m3(a,b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
public m4(Integer a, b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
public m5(a, Long b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
public Integer m6(a,b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
/* bit-shift not accepted by parser
|
||||
|
||||
public m7(a,b) {
|
||||
return x << y;
|
||||
}
|
||||
|
||||
public m8(a,b) {
|
||||
return x >> y;
|
||||
}
|
||||
|
||||
public m9(a,b) {
|
||||
return x >>> y;
|
||||
}
|
||||
|
||||
public m10(a) {
|
||||
return ~a;
|
||||
}
|
||||
*/
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
public class TestOperatorBool {
|
||||
|
||||
public m1(a,b) {
|
||||
return a && b;
|
||||
}
|
||||
|
||||
public m2(a,b) {
|
||||
return a || b;
|
||||
}
|
||||
|
||||
public m3(a) {
|
||||
return !a;
|
||||
}
|
||||
|
||||
public m4( a, b) {
|
||||
return a==b;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
public class TestOperatorComparison {
|
||||
|
||||
/* public m1(a,b) {
|
||||
return a < b;
|
||||
}
|
||||
|
||||
public m2(a, b) {
|
||||
return a >= b;
|
||||
}
|
||||
*/
|
||||
public m3(a, b) {
|
||||
return a==b;
|
||||
}
|
||||
|
||||
public java.lang.Boolean m4(a,b) {
|
||||
return a!=b;
|
||||
}
|
||||
|
||||
public m5(Integer a, b) {
|
||||
return a<b;
|
||||
}
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
|
||||
public class TestOperatorIncrement {
|
||||
|
||||
public void m(i,j,k,l) {
|
||||
i++;
|
||||
j--;
|
||||
++k;
|
||||
--l;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
class A {
|
||||
|
||||
public java.lang.Integer m(a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class TestOperatorObjects {
|
||||
|
||||
public static void main() {
|
||||
b;
|
||||
b=new A();
|
||||
c;
|
||||
c=b.m(3);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
public class TestOperatorString {
|
||||
|
||||
public m() {
|
||||
a;
|
||||
b;
|
||||
a="abc";
|
||||
b="def";
|
||||
return a+b;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class BooleanTest{
|
||||
void booleanTest(b){
|
||||
b = true;
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
class ByteTest{
|
||||
void byteTest(b){
|
||||
byte myByte = -1;
|
||||
b = myByte;
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class CharTest{
|
||||
void character(c){
|
||||
c = 'c';
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class DoubleTest{
|
||||
void doublePrecision(d){
|
||||
d = 1.0;
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class FloatTest {
|
||||
void floatingPoint(f) {
|
||||
f = 5f;
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class IntegerTest{
|
||||
void integer(i){
|
||||
i = 1; /* koennte vielleicht auch short/byte/char sein .. */
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class LongTest{
|
||||
void longTest(l){
|
||||
l = 4L;
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
class StringTest{
|
||||
void string(s){
|
||||
s = "String";
|
||||
}
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
|
||||
class TestSimpleTypes{
|
||||
|
||||
public m1(int a) {
|
||||
}
|
||||
|
||||
public int m2(int a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
public m3(char a) {}
|
||||
|
||||
/* not implemented?
|
||||
public m4(float a) {}
|
||||
public m5(double a) {}*/
|
||||
|
||||
/* cast from Integer to int does not work
|
||||
public int m6() {
|
||||
return 3;
|
||||
}*/
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
|
||||
public class TestClassEmpty {
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
public class TestClassEmptyGenerics<E,F> {
|
||||
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
import java.util.Vector;
|
||||
public class TestClassMember {
|
||||
|
||||
Integer member;
|
||||
Vector<String> member2;
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
|
||||
public class TestClassMemberAssignment {
|
||||
|
||||
Integer member;
|
||||
|
||||
public m1() {
|
||||
member=1;
|
||||
}
|
||||
|
||||
public m2() {
|
||||
this.member=2;
|
||||
}
|
||||
|
||||
public m3(a) {
|
||||
member=a;
|
||||
}
|
||||
|
||||
public void m(a) {
|
||||
this.a=a;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
public class TestConstants {
|
||||
public final static Boolean B = true;
|
||||
public final static Integer I = 1;
|
||||
public final static Character C = 'A';
|
||||
public final static String S = "Hello World!";
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
import java.util.Stack;
|
||||
|
||||
public class TestConstructor {
|
||||
Integer i;
|
||||
Stack s;
|
||||
|
||||
public TestConstructor() {
|
||||
i=3;
|
||||
s=new Stack();
|
||||
}
|
||||
|
||||
public TestConstructor(a) {
|
||||
a=4;
|
||||
}
|
||||
|
||||
public TestConstructor(java.lang.Integer a, Stack b) {
|
||||
i=a;
|
||||
s=b;
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
|
||||
public class TestConstructorNegative {
|
||||
|
||||
/*should throw error*/
|
||||
public TestConstructorNegative(java.lang.Integer a, String b) {
|
||||
return a;
|
||||
}
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
interface TestInterfaceEmpty {
|
||||
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
interface TestInterfaceMember {
|
||||
|
||||
Integer member=3;
|
||||
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
interface TestInterfaceMethod {
|
||||
|
||||
empty1();
|
||||
|
||||
void empty2();
|
||||
|
||||
empty3(Integer a);
|
||||
|
||||
empty4(String a, Integer b);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user