From 52be0a1af39d99c5635ac83215c334ff404c0447 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrico=20Schr=C3=B6dter?= Date: Fri, 23 Oct 2015 19:04:13 +0200 Subject: [PATCH 1/6] =?UTF-8?q?Overloading=20Test=20=C3=BCberarbeitet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/bytecode/types/OverloadingTest.java | 33 +++++++++++++++++------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/test/bytecode/types/OverloadingTest.java b/test/bytecode/types/OverloadingTest.java index 9e6b3a22..514264a3 100644 --- a/test/bytecode/types/OverloadingTest.java +++ b/test/bytecode/types/OverloadingTest.java @@ -2,7 +2,10 @@ package bytecode.types; import static org.junit.Assert.*; +import java.io.File; import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; import java.util.Vector; import org.junit.Test; @@ -24,17 +27,22 @@ public class OverloadingTest extends BytecodeTest{ Class cls = getClassToTest(); Object obj = cls.newInstance(); - Vector stringVector = new Vector(); + File file = new File(rootDirectory); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%String%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = stringVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); + method.invoke(obj, stringVector.newInstance()); assertTrue(true); }catch(Exception e){ - e.printStackTrace(); - fail(); + throw new RuntimeException(e); } } @@ -44,17 +52,22 @@ public class OverloadingTest extends BytecodeTest{ Class cls = getClassToTest(); Object obj = cls.newInstance(); - Vector stringVector = new Vector(); + File file = new File(rootDirectory); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class integerVector = classLoader.loadClass("java%util%Vector%%java%lang%Integer%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = integerVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); + method.invoke(obj, integerVector.newInstance()); assertTrue(true); }catch(Exception e){ - e.printStackTrace(); - fail(); + throw new RuntimeException(e); } } From 12093f2fc7b4f27236c728e2fadb5afc30bda407 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrico=20Schr=C3=B6dter?= Date: Tue, 27 Oct 2015 13:27:00 +0100 Subject: [PATCH 2/6] Signatur ist das gleiche wie Description --- .../dhbwstuttgart/syntaxtree/FormalParameter.java | 2 +- .../syntaxtree/factory/ASTFactory.java | 14 +++++++++++--- src/de/dhbwstuttgart/syntaxtree/type/RefType.java | 4 ++-- test/bytecode/types/Test.java | 12 ------------ 4 files changed, 14 insertions(+), 18 deletions(-) delete mode 100644 test/bytecode/types/Test.java diff --git a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java index e410bd57..ddb325d7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java +++ b/src/de/dhbwstuttgart/syntaxtree/FormalParameter.java @@ -236,7 +236,7 @@ public class FormalParameter extends SyntaxTreeNode implements Typeable, TypeIns public String getDescription() { String ret = ""; if(this.getType() != null && !(this.getType() instanceof TypePlaceholder)){ - ret += this.getType().getName() + " "; + ret += this.getType().getBytecodeSignature(null); } return ret+this.getIdentifier(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index 060ea12c..db782e91 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -4,7 +4,9 @@ import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.misc.DeclId; +import de.dhbwstuttgart.syntaxtree.misc.UsedId; import de.dhbwstuttgart.syntaxtree.statement.Block; import de.dhbwstuttgart.syntaxtree.statement.SuperCall; import de.dhbwstuttgart.typeinference.Menge; @@ -45,11 +47,17 @@ public class ASTFactory { return new Constructor(method, superClass); } - public static Class createClass(String className, Class superClass) { + public static Class createClass(String className, String superClass, Class parent) { // TODO bytecode createClass Class generatedClass = new Class(className, 0); - generatedClass.addField(ASTFactory.createEmptyConstructor(superClass)); - generatedClass.parserPostProcessing(superClass); + generatedClass.addField(ASTFactory.createEmptyConstructor(parent)); + + if(superClass != null){ + generatedClass.superclassid = UsedId.createFromQualifiedName(superClass, 0); + } + + //TODO bytecode parserPostProcressing ist die SuperKlasse oder eine Sourcefile? + generatedClass.parserPostProcessing(parent); return generatedClass; } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index 3fe126b4..117c5b9e 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -852,8 +852,8 @@ public class RefType extends ObjectType implements IMatchable String combinedType = getCombinedType(cg); if(!combinedType.equals(getName().toString())){ // TODO bytecode statt getParentClass die eigene Class?!?! - Class classObject = ASTFactory.createClass(getName().toString(), ASTFactory.createObjectClass()); - Class generatedClass = ASTFactory.createClass(getCombinedType(cg), classObject); + Class classObject = ASTFactory.createClass(getName().toString(), null, ASTFactory.createObjectClass()); + Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getName().toString(), classObject); cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResultSet(generatedClass, new Menge<>(), new ResultSet())).getByteCode()); } diff --git a/test/bytecode/types/Test.java b/test/bytecode/types/Test.java deleted file mode 100644 index 78235be2..00000000 --- a/test/bytecode/types/Test.java +++ /dev/null @@ -1,12 +0,0 @@ -import java.util.Vector; - -public class Test { - - public static void main(String[] args) { - Overloading o = new Overloading(); - Vector stringVector = new Vector(); - - o.method(stringVector); - } - -} From ce52fd8904f4532081406274d957f9011f0607e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrico=20Schr=C3=B6dter?= Date: Tue, 27 Oct 2015 15:14:52 +0100 Subject: [PATCH 3/6] ConsoleInterface an neue CompilerApi angepasst RefType getBytecodeSignature unterscheidet zwischen RefType und TypePlacholder Abstrakte ByteCodeTest Klasse um getClassLoader erweitert Alle BytecodeTypeTests angepasst --- .../dhbwstuttgart/core/ConsoleInterface.java | 5 +- .../syntaxtree/type/RefType.java | 9 +- test/bytecode/BytecodeTest.java | 14 +- test/bytecode/types/ExtendsObjectTest.java | 6 +- .../types/ExtendsVectorStringTest.java | 6 +- test/bytecode/types/ExtendsVectorTest.java | 6 +- test/bytecode/types/OverloadingTest.java | 18 ++- test/bytecode/types/ReflectionTest.java | 120 ++++++++++++++++++ test/bytecode/types/TypedVectorTest.java | 20 +-- test/bytecode/types/UntypedVector.jav | 7 + test/bytecode/types/UntypedVectorTest.java | 68 ++++++++++ 11 files changed, 250 insertions(+), 29 deletions(-) create mode 100644 test/bytecode/types/ReflectionTest.java create mode 100644 test/bytecode/types/UntypedVector.jav create mode 100644 test/bytecode/types/UntypedVectorTest.java diff --git a/src/de/dhbwstuttgart/core/ConsoleInterface.java b/src/de/dhbwstuttgart/core/ConsoleInterface.java index 1c99aa30..9c6735a6 100755 --- a/src/de/dhbwstuttgart/core/ConsoleInterface.java +++ b/src/de/dhbwstuttgart/core/ConsoleInterface.java @@ -7,6 +7,7 @@ import java.util.*; import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.LoggerConfiguration; +import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; @@ -34,13 +35,13 @@ public class ConsoleInterface { ///////////////////////// // Parsen: ///////////////////////// - compiler.parse(filenames); + Menge sourceFiles = compiler.parse(filenames); ///////////////////////// // Typrekonstruktion: ///////////////////////// try{ - resultSet = compiler.typeReconstruction(); + resultSet = compiler.typeReconstruction(sourceFiles); }catch(TypeinferenceException texc){ texc.printStackTrace(); fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage()); diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index 117c5b9e..62d67ebf 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -869,7 +869,14 @@ public class RefType extends ObjectType implements IMatchable sb.append(getName().toString().replace(".", "%")); sb.append("%%"); for(Type type: parameter){ - sb.append(((RefType) type).getCombinedType(cg).replace(".", "%")); + if(type instanceof RefType){ + sb.append(((RefType) type).getCombinedType(cg).replace(".", "%")); + }else if(type instanceof TypePlaceholder){ + sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%")); + }else{ + sb.append(((TypePlaceholder) type).getBytecodeType(cg).toString().replace(".", "%")); + } + sb.append("%"); } }else{ diff --git a/test/bytecode/BytecodeTest.java b/test/bytecode/BytecodeTest.java index 35b8dc33..92c38e19 100644 --- a/test/bytecode/BytecodeTest.java +++ b/test/bytecode/BytecodeTest.java @@ -39,11 +39,7 @@ public abstract class BytecodeTest extends TestCase{ protected Class getClassToTest(){ Class classToTest = null; try { - File file = new File(rootDirectory); - URL url = file.toURL(); - URL[] urls = new URL[]{url}; - - ClassLoader classLoader = new URLClassLoader(urls); + ClassLoader classLoader = getClassLoader(); classToTest = classLoader.loadClass(testName); @@ -54,4 +50,12 @@ public abstract class BytecodeTest extends TestCase{ return classToTest; } + + protected ClassLoader getClassLoader() throws Exception{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + return new URLClassLoader(urls); + } } diff --git a/test/bytecode/types/ExtendsObjectTest.java b/test/bytecode/types/ExtendsObjectTest.java index 43648fdf..964d52c9 100644 --- a/test/bytecode/types/ExtendsObjectTest.java +++ b/test/bytecode/types/ExtendsObjectTest.java @@ -34,7 +34,11 @@ public class ExtendsObjectTest extends BytecodeTest{ @Test public void testConstruct(){ try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/ExtendsVectorStringTest.java b/test/bytecode/types/ExtendsVectorStringTest.java index 8511499b..efcbc095 100644 --- a/test/bytecode/types/ExtendsVectorStringTest.java +++ b/test/bytecode/types/ExtendsVectorStringTest.java @@ -33,7 +33,11 @@ public class ExtendsVectorStringTest extends BytecodeTest{ @Test public void testConstruct() throws Exception{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/ExtendsVectorTest.java b/test/bytecode/types/ExtendsVectorTest.java index aefe5d4b..5253507e 100644 --- a/test/bytecode/types/ExtendsVectorTest.java +++ b/test/bytecode/types/ExtendsVectorTest.java @@ -34,7 +34,11 @@ public class ExtendsVectorTest extends BytecodeTest{ @Test public void testConstruct(){ try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Constructor method = cls.getConstructor(new Class[]{}); method.newInstance(); diff --git a/test/bytecode/types/OverloadingTest.java b/test/bytecode/types/OverloadingTest.java index 514264a3..15469089 100644 --- a/test/bytecode/types/OverloadingTest.java +++ b/test/bytecode/types/OverloadingTest.java @@ -24,15 +24,16 @@ public class OverloadingTest extends BytecodeTest{ @Test public void testString() { try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + Object obj = cls.newInstance(); File file = new File(rootDirectory); URL url = file.toURL(); URL[] urls = new URL[]{url}; - ClassLoader classLoader = new URLClassLoader(urls); - Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%String%"); Class[] params = new Class[1]; @@ -49,14 +50,11 @@ public class OverloadingTest extends BytecodeTest{ @Test public void testInteger() { try{ - Class cls = getClassToTest(); - Object obj = cls.newInstance(); - - File file = new File(rootDirectory); - URL url = file.toURL(); - URL[] urls = new URL[]{url}; + ClassLoader classLoader = getClassLoader(); - ClassLoader classLoader = new URLClassLoader(urls); + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); Class integerVector = classLoader.loadClass("java%util%Vector%%java%lang%Integer%"); diff --git a/test/bytecode/types/ReflectionTest.java b/test/bytecode/types/ReflectionTest.java new file mode 100644 index 00000000..db5a25e2 --- /dev/null +++ b/test/bytecode/types/ReflectionTest.java @@ -0,0 +1,120 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Stack; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; +import de.dhbwstuttgart.logger.Logger; +import de.dhbwstuttgart.logger.Section; + +public class ReflectionTest{ + @Test + public void testUntypedVectorDeclaredMethods() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + for(Method method: untypedVectorTest.getDeclaredMethods()){ + System.out.println(method.toGenericString()); + } + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testUntypedVectorDeclaredMethodsCallMethod() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + Object stringVectorObj = stringVector.newInstance(); + + for(Method method: untypedVectorTest.getDeclaredMethods()){ + method.invoke(untypedVectorTest.newInstance(), stringVectorObj); + } + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testUntypedVectorMethod() { + try{ + File file = new File(System.getProperty("user.dir")+"/test/bytecode/types/"); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + ClassLoader classLoader = new URLClassLoader(urls); + + Class untypedVectorTest = classLoader.loadClass("UntypedVector"); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + + Class[] params = new Class[1]; + params[0] = stringVector; + + Method method = untypedVectorTest.getDeclaredMethod("method", params); + method.invoke(untypedVectorTest.newInstance(), stringVector.newInstance()); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testStdVectorAdd() { + try{ + Vector vector = new Vector(); + + Class vectorClass = vector.getClass(); + + String helloWorld = new String("Hello World!"); + + Class[] params = new Class[1]; + params[0] = new Object().getClass(); + + Method method = vectorClass.getDeclaredMethod("add", params); + method.invoke(vector, helloWorld); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testStdVectorEnsureCapacity() { + try{ + Vector vector = new Vector(); + + Class vectorClass = vector.getClass(); + + Integer integer = new Integer(1); + + Class[] params = new Class[1]; + params[0] = int.class; + + Method method = vectorClass.getDeclaredMethod("ensureCapacity", params); + method.invoke(vector, integer); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} diff --git a/test/bytecode/types/TypedVectorTest.java b/test/bytecode/types/TypedVectorTest.java index ef32180b..6a5cb441 100644 --- a/test/bytecode/types/TypedVectorTest.java +++ b/test/bytecode/types/TypedVectorTest.java @@ -2,7 +2,10 @@ package bytecode.types; import static org.junit.Assert.*; +import java.io.File; import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; import java.util.Stack; import java.util.Vector; @@ -22,20 +25,21 @@ public class TypedVectorTest extends BytecodeTest{ @Test public void test() { try{ - Class cls = getClassToTest(); + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + Object obj = cls.newInstance(); - - Vector stringVector = new Vector(); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%String%"); Class[] params = new Class[1]; - params[0] = stringVector.getClass(); + params[0] = stringVector; Method method = cls.getDeclaredMethod("method", params); - method.invoke(obj, stringVector); - assertTrue(true); + method.invoke(obj, stringVector.newInstance()); }catch(Exception e){ - Logger.getLogger("SingleClassTester").error(e.toString(), Section.CODEGEN); - fail(); + throw new RuntimeException(e); } } } diff --git a/test/bytecode/types/UntypedVector.jav b/test/bytecode/types/UntypedVector.jav new file mode 100644 index 00000000..05835507 --- /dev/null +++ b/test/bytecode/types/UntypedVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class UntypedVector{ + public void method(Vector v) { + + } +} \ No newline at end of file diff --git a/test/bytecode/types/UntypedVectorTest.java b/test/bytecode/types/UntypedVectorTest.java new file mode 100644 index 00000000..a2277c0c --- /dev/null +++ b/test/bytecode/types/UntypedVectorTest.java @@ -0,0 +1,68 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Stack; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; +import de.dhbwstuttgart.logger.Logger; +import de.dhbwstuttgart.logger.Section; + +public class UntypedVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "UntypedVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + @Test + public void testObjectVector() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + File file = new File(rootDirectory); + URL url = file.toURL(); + URL[] urls = new URL[]{url}; + + Object object = new Object(); + + Class[] params = new Class[1]; + params[0] = object.getClass(); + + Method method = cls.getDeclaredMethod("method", params); + method.invoke(obj, object); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + + @Test + public void testGenericClass() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class untypedVectorTest = classLoader.loadClass(testName); + + Class stringVector = classLoader.loadClass("java%util%Vector%%java%lang%Object%"); + + Class[] params = new Class[1]; + params[0] = stringVector; + + Method method = untypedVectorTest.getDeclaredMethod("method", params); + method.invoke(untypedVectorTest.newInstance(), stringVector.newInstance()); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} From f077829d303bfb70928ed1076add9357201fde48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrico=20Schr=C3=B6dter?= Date: Wed, 28 Oct 2015 10:48:14 +0100 Subject: [PATCH 4/6] =?UTF-8?q?JUnit=20Test=20f=C3=BCr=20Lokale=20Variabel?= =?UTF-8?q?n=20erstellt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../types/LocalVariableStringVector.jav | 7 ++++ .../types/LocalVariableStringVectorTest.java | 39 +++++++++++++++++++ test/bytecode/types/LocalVariableVector.jav | 7 ++++ .../types/LocalVariableVectorTest.java | 38 ++++++++++++++++++ ...edVector.jav => MethodWithTypedVector.jav} | 2 +- ...st.java => MethodWithTypedVectorTest.java} | 4 +- ...Vector.jav => MethodWithUntypedVector.jav} | 2 +- ....java => MethodWithUntypedVectorTest.java} | 4 +- 8 files changed, 97 insertions(+), 6 deletions(-) create mode 100644 test/bytecode/types/LocalVariableStringVector.jav create mode 100644 test/bytecode/types/LocalVariableStringVectorTest.java create mode 100644 test/bytecode/types/LocalVariableVector.jav create mode 100644 test/bytecode/types/LocalVariableVectorTest.java rename test/bytecode/types/{TypedVector.jav => MethodWithTypedVector.jav} (70%) rename test/bytecode/types/{TypedVectorTest.java => MethodWithTypedVectorTest.java} (90%) rename test/bytecode/types/{UntypedVector.jav => MethodWithUntypedVector.jav} (65%) rename test/bytecode/types/{UntypedVectorTest.java => MethodWithUntypedVectorTest.java} (93%) diff --git a/test/bytecode/types/LocalVariableStringVector.jav b/test/bytecode/types/LocalVariableStringVector.jav new file mode 100644 index 00000000..887c82d6 --- /dev/null +++ b/test/bytecode/types/LocalVariableStringVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class LocalVariableStringVector{ + void method() { + Vector vector; + } +} \ No newline at end of file diff --git a/test/bytecode/types/LocalVariableStringVectorTest.java b/test/bytecode/types/LocalVariableStringVectorTest.java new file mode 100644 index 00000000..a3761210 --- /dev/null +++ b/test/bytecode/types/LocalVariableStringVectorTest.java @@ -0,0 +1,39 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; + +public class LocalVariableStringVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "LocalVariableStringVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + + + @Test + public void testCompiler() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + assertTrue(true); + }catch(Exception e){ + throw new RuntimeException(e); + } + } + +} diff --git a/test/bytecode/types/LocalVariableVector.jav b/test/bytecode/types/LocalVariableVector.jav new file mode 100644 index 00000000..13cd673c --- /dev/null +++ b/test/bytecode/types/LocalVariableVector.jav @@ -0,0 +1,7 @@ +import java.util.Vector; + +class LocalVariableVector{ + void method() { + Vector vector; + } +} \ No newline at end of file diff --git a/test/bytecode/types/LocalVariableVectorTest.java b/test/bytecode/types/LocalVariableVectorTest.java new file mode 100644 index 00000000..52869f43 --- /dev/null +++ b/test/bytecode/types/LocalVariableVectorTest.java @@ -0,0 +1,38 @@ +package bytecode.types; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Vector; + +import org.junit.Test; + +import bytecode.BytecodeTest; + +public class LocalVariableVectorTest extends BytecodeTest{ + @Override + protected void init() { + testName = "LocalVariableVector"; + rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; + } + + + + @Test + public void testCompiler() { + try{ + ClassLoader classLoader = getClassLoader(); + + Class cls = classLoader.loadClass(testName); + + Object obj = cls.newInstance(); + + assertTrue(true); + }catch(Exception e){ + throw new RuntimeException(e); + } + } +} diff --git a/test/bytecode/types/TypedVector.jav b/test/bytecode/types/MethodWithTypedVector.jav similarity index 70% rename from test/bytecode/types/TypedVector.jav rename to test/bytecode/types/MethodWithTypedVector.jav index d64e4f5f..a74062ee 100644 --- a/test/bytecode/types/TypedVector.jav +++ b/test/bytecode/types/MethodWithTypedVector.jav @@ -1,6 +1,6 @@ import java.util.Vector; -class TypedVector{ +class MethodWithTypedVector{ public void method(Vector v) { } diff --git a/test/bytecode/types/TypedVectorTest.java b/test/bytecode/types/MethodWithTypedVectorTest.java similarity index 90% rename from test/bytecode/types/TypedVectorTest.java rename to test/bytecode/types/MethodWithTypedVectorTest.java index 6a5cb441..6933c248 100644 --- a/test/bytecode/types/TypedVectorTest.java +++ b/test/bytecode/types/MethodWithTypedVectorTest.java @@ -15,10 +15,10 @@ import bytecode.BytecodeTest; import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Section; -public class TypedVectorTest extends BytecodeTest{ +public class MethodWithTypedVectorTest extends BytecodeTest{ @Override protected void init() { - testName = "TypedVector"; + testName = "MethodWithTypedVector"; rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; } diff --git a/test/bytecode/types/UntypedVector.jav b/test/bytecode/types/MethodWithUntypedVector.jav similarity index 65% rename from test/bytecode/types/UntypedVector.jav rename to test/bytecode/types/MethodWithUntypedVector.jav index 05835507..fead3981 100644 --- a/test/bytecode/types/UntypedVector.jav +++ b/test/bytecode/types/MethodWithUntypedVector.jav @@ -1,6 +1,6 @@ import java.util.Vector; -class UntypedVector{ +class MethodWithUntypedVector{ public void method(Vector v) { } diff --git a/test/bytecode/types/UntypedVectorTest.java b/test/bytecode/types/MethodWithUntypedVectorTest.java similarity index 93% rename from test/bytecode/types/UntypedVectorTest.java rename to test/bytecode/types/MethodWithUntypedVectorTest.java index a2277c0c..1be45ff0 100644 --- a/test/bytecode/types/UntypedVectorTest.java +++ b/test/bytecode/types/MethodWithUntypedVectorTest.java @@ -15,10 +15,10 @@ import bytecode.BytecodeTest; import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Section; -public class UntypedVectorTest extends BytecodeTest{ +public class MethodWithUntypedVectorTest extends BytecodeTest{ @Override protected void init() { - testName = "UntypedVector"; + testName = "MethodWithUntypedVector"; rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/"; } From 50916b5db23fa000db3e3692d03eef2b33f2887d Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 29 Oct 2015 17:00:39 +0100 Subject: [PATCH 5/6] =?UTF-8?q?SourceFile=20als=20Parent=20f=C3=BCr=20Clas?= =?UTF-8?q?s.parserPostProcessing?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index db782e91..f39e6968 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -4,6 +4,7 @@ import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.misc.DeclId; import de.dhbwstuttgart.syntaxtree.misc.UsedId; @@ -47,16 +48,15 @@ public class ASTFactory { return new Constructor(method, superClass); } - public static Class createClass(String className, String superClass, Class parent) { + public static Class createClass(String className, String superClass, SourceFile parent) { // TODO bytecode createClass Class generatedClass = new Class(className, 0); - generatedClass.addField(ASTFactory.createEmptyConstructor(parent)); + generatedClass.addField(ASTFactory.createEmptyConstructor(generatedClass)); if(superClass != null){ generatedClass.superclassid = UsedId.createFromQualifiedName(superClass, 0); } - //TODO bytecode parserPostProcressing ist die SuperKlasse oder eine Sourcefile? generatedClass.parserPostProcessing(parent); return generatedClass; From 64dce5d8149f389875cd8da77fade6b12dfce111 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrico=20Schr=C3=B6dter?= Date: Thu, 29 Oct 2015 17:18:15 +0100 Subject: [PATCH 6/6] Parent von Class ist Sourcefile --- src/de/dhbwstuttgart/syntaxtree/type/RefType.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index 62d67ebf..9f33148b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -16,6 +16,7 @@ import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.SourceFile; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; import de.dhbwstuttgart.syntaxtree.misc.UsedId; @@ -852,8 +853,7 @@ public class RefType extends ObjectType implements IMatchable String combinedType = getCombinedType(cg); if(!combinedType.equals(getName().toString())){ // TODO bytecode statt getParentClass die eigene Class?!?! - Class classObject = ASTFactory.createClass(getName().toString(), null, ASTFactory.createObjectClass()); - Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getName().toString(), classObject); + Class generatedClass = ASTFactory.createClass(getCombinedType(cg), getName().toString(), new SourceFile()); cg.addExtraClass(generatedClass.genByteCode(new TypeinferenceResultSet(generatedClass, new Menge<>(), new ResultSet())).getByteCode()); }