project cleanup

- test classes (src/test/*) moved to separate root
- stray .class files dropped
- binary files (bin/, dist/full/, dist/obfuscated/) excluded from the repo
- .classpath and .gitignore updated accordingly
- invalid import statements removed

test/test/BradTest.java

@@ -0,0 +1,57 @@
+package test;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class BradTest {
+
+	public void testForLoop() {
+
+		for(int i = 0; i < 5; i++) {
+			System.out.println(i);
+		}
+
+		int[] testArray = new int[] {};
+
+		for(int i : testArray) {
+			System.out.println(i);
+		}
+
+		int k = 0;
+		int j = 0;
+
+		while(j < 5) {
+
+			System.out.println("Test while.");
+
+			j++;
+
+			if(j < 3) {
+				continue;
+			}
+
+			k++;
+
+		}
+
+		List keys = new java.util.ArrayList();
+
+		for(Object test : keys) {
+
+			System.out.println(test);
+
+			System.out.println(test);
+
+			System.out.println(test);
+
+		}
+
+		List<BradTest> objects = new LinkedList<BradTest>();
+
+		for(BradTest test : objects) {
+			System.out.println(test);
+
+		}
+	}
+
+}

test/test/TestAnnotationsEclipse.java

@@ -0,0 +1,42 @@
+package test;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+public class TestAnnotationsEclipse {
+
+	public String a;
+
+	@Retention(RetentionPolicy.CLASS)
+	@interface MyAnnotation {}
+
+	public static void main(String[] args) {
+	
+		TestInner a = new TestAnnotationsEclipse().new TestInner();
+		
+		for(Constructor mt : a.getClass().getConstructors()) {
+
+			Annotation[][] ann = mt.getParameterAnnotations();
+		
+			System.out.println(ann.length);
+		}		
+	}
+	
+	protected class TestInner {
+
+		public TestInner() {}
+		
+		public TestInner(String param1, Object param2, @MyAnnotation boolean param3) {
+			System.out.println(param1);
+			System.out.println(param2);
+			System.out.println(param3);
+		}
+
+		public void accessField() {
+			System.out.println(TestAnnotationsEclipse.this.a);
+		}
+	}
+}

test/test/input/TestEclipse7.java

@@ -0,0 +1,59 @@
+package test.input;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+public class TestEclipse7 {
+
+	
+//	public void testTryResources() throws IOException {
+//		
+//		try (FileReader reader = new FileReader("file"); FileReader reader1 = new FileReader("file")) {
+//			System.out.println();
+//		}
+//		
+//	}
+//
+//	public void testTryResources1() throws IOException {
+//		
+//		try (FileReader reader = new FileReader("file")) {
+//			System.out.println("block");
+//		} catch(RuntimeException ex) {
+//			System.out.println(ex.toString());
+//		} finally {
+//			System.out.println("finally");
+//		}
+//		
+//	}
+	
+	public void testMultiCatch() {
+
+		try {
+			Method method = getClass().getDeclaredMethod("foo");
+		} catch (NoSuchMethodException | SecurityException e) {
+			e.printStackTrace();
+		}
+	}
+	
+
+//	public void testSwitchString() {
+//
+//		String s = "";
+//		switch(s) {
+//		case "Aa": // "xyz":
+//			System.out.println("!");
+//			break;
+//		case "BB": // "abc":
+//			System.out.println("?");
+//			break;
+//		case "__":
+//			System.out.println("_");
+//			break;
+//		default:
+//			System.out.println("#");
+//		}
+//		
+//	}
+	
+}

test/test/input/TestJavac7.java

@@ -0,0 +1,59 @@
+package test.input;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+public class TestJavac7 {
+
+	
+	public void testTryResources() throws IOException {
+		
+		try (FileReader reader = new FileReader("file"); FileReader reader1 = new FileReader("file")) {
+			System.out.println();
+		}
+		
+	}
+
+	public void testTryResources1() throws IOException {
+		
+		try (FileReader reader = new FileReader("file")) {
+			System.out.println("block");
+		} catch(RuntimeException ex) {
+			System.out.println(ex.toString());
+		} finally {
+			System.out.println("finally");
+		}
+		
+	}
+	
+	public void testMultiCatch() {
+
+		try {
+			Method method = getClass().getDeclaredMethod("foo");
+		} catch (NoSuchMethodException | SecurityException e) {
+			e.printStackTrace();
+		}
+	}
+	
+
+	public void testSwitchString() {
+
+		String s = "";
+		switch(s) {
+		case "Aa": // "xyz":
+			System.out.println("!");
+			break;
+		case "BB": // "abc":
+			System.out.println("?");
+			break;
+		case "__":
+			System.out.println("_");
+			break;
+		default:
+			System.out.println("#");
+		}
+		
+	}
+
+}

test/test/input/TestJavac8.java

@@ -0,0 +1,58 @@
+package test.input;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+public class TestJavac8 {
+
+//	public static void main(String args[]) {
+//		new TestJavac8().testLambda();
+//	}
+//	
+//	public void testTryResources() throws IOException {
+//		
+//		try (FileReader reader = new FileReader("file"); FileReader reader1 = new FileReader("file")) {
+//			System.out.println();
+//		}
+//		
+//	}
+//
+//	public void testMultiCatch() {
+//
+//		try {
+//			Method method = getClass().getDeclaredMethod("foo");
+//		} catch (NoSuchMethodException | SecurityException e) {
+//			e.printStackTrace();
+//		}
+//	}
+//	
+//
+//	private void testSwitchString() {
+//
+//		String s = "";
+//		switch(s) {
+//		case "Aa": // "xyz":
+//			System.out.println("!");
+//			break;
+//		case "BB": // "abc":
+//			System.out.println("?");
+//			break;
+//		case "__":
+//			System.out.println("_");
+//			break;
+//		default:
+//			System.out.println("#");
+//		}
+//		
+//	}
+
+	public void testLambda() {
+		
+		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+		list.forEach(n -> {int a = 2 * n; System.out.println(a);});	
+	}
+	
+}

test/test/input/TestLoop.java

@@ -0,0 +1,20 @@
+package test.input;
+
+public class TestLoop {
+
+	public static void main(String[] args) {
+
+		boolean a = true;
+		while(true) {
+			try {
+				if(!a) {
+					return; 
+				}
+			} finally {
+				System.out.println("1");
+			}
+		}
+	
+	}
+	
+}

test/test/misc/ExtTest.java

@@ -0,0 +1,81 @@
+package test.misc;
+
+import java.io.IOException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+public class ExtTest<E> extends ArrayList<E> {
+
+	public static void main(String[] args) {
+		
+		Date d = new Date(); Timestamp t = new Timestamp(d.getTime());
+		System.out.println(d.after(t)); 
+
+		System.out.println((int)-1);
+		System.out.println((int)1);
+		System.out.println((Integer)1);
+		System.out.println((Integer)1);
+		
+		Class c = String.class;
+		
+		Integer Integer = 0;
+		Integer = (Integer)-1;
+		
+		int z = 0;
+		z = z+++(++z);
+		
+		Entry ent = (Entry)new HashMap().entrySet().iterator().next();
+		
+		label1: {
+		System.out.println("1");
+		if(Math.random() > 4) {
+			break label1;
+		}
+		System.out.println("2");
+		}
+		System.out.println("3");
+	}
+
+	public <T extends E> void test(T o) {
+		
+	}
+	
+	public void testException() throws IOException {
+//		if(true) {
+//			throw new RuntimeException();
+//		} else {
+//			throw new IOException();
+//		}
+//		throw true?new IOException():new IOException();
+//		throw true?new ClassCastException():new IOException();
+	}
+	
+	public static int ttt() {
+		
+		Object obj = new Integer(5);
+		synchronized (new Integer(3)) {
+			System.out.println(obj);
+			obj = null;
+		}
+		
+		
+		System.out.println("1");
+		if(Math.random() > 1) {
+			System.out.println("2");
+		} else {
+			System.out.println("3");
+		}
+		System.out.println("4");
+		
+		int a = 0;
+		try {
+			a = 2;
+			return a;
+		} finally {
+			a = 4;
+		}
+	}
+}

test/test/misc/GenericTest.java

@@ -0,0 +1,65 @@
+package test.misc;
+
+import java.io.Serializable;
+import java.util.AbstractCollection;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+public class GenericTest<T extends Object & Serializable> {
+
+	@test.misc.ann.RequestForEnhancement(
+			id       = 2868724,
+		    synopsis = "Enable time-travel",
+		    engineer = "Mr. Peabody",
+		    date     = "4/1/3007",
+		    arr      = {"1","2","3"},
+		    cl       = Void.class
+	)
+	@Deprecated
+	public boolean test(@Deprecated Collection c) {
+		return true;
+	}
+	
+	public int testparam(boolean t, @Deprecated List lst, double d) {
+		return 0;
+	}
+
+}
+
+class GenericTestChild<E extends Collection> extends GenericTest<GenericTestChild<AbstractCollection>> implements Serializable {
+
+//	public <T> void test(Collection<T> c) {
+//		T var1 = c.iterator().next();
+//		c.add(var1);
+//	}	
+	
+	public List<String>[][] field;
+	
+	public <T extends Date & List> void test(List<? super ArrayList> list1, List<?> list) {
+		
+//	l2: {
+//		l1: {
+//			if(Math.random() > 2){
+//				break l1;
+//			}
+//	
+//			System.out.println("1");
+//			break l2;
+//		}
+//	
+//		System.out.println("2");
+//	}
+	
+	if(Math.random() > 2){
+		System.out.println("2");
+	} else {
+		System.out.println("1");
+	}
+
+	
+	}
+	
+}
+

test/test/misc/ITest.java

@@ -0,0 +1,9 @@
+package test.misc;
+
+import java.io.Serializable;
+
+public interface ITest extends Serializable, Comparable<Long> {
+
+	public void test();
+	
+}

test/test/misc/MainClass.java

@@ -0,0 +1,115 @@
+package test.misc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainClass {
+
+	private int intfield;
+	
+	private static int stfield;
+	
+	private static void statmeth(int t) {
+		System.out.println(t);
+	}
+	
+	private String maintest(int v) {
+		System.out.println(v+"test!");
+		return "";
+	}
+	
+	public MainClass() {
+		super();
+	}
+	
+	public void mainclosure() {
+		
+		final int local1 = (int)Math.random();
+		
+		List l = new ArrayList(new ArrayList()) {
+			
+			{
+				System.out.println(intfield);
+			}
+			
+			public void anontest() {
+				System.out.println(local1);
+			}
+		};
+		
+		class LocalClass {
+			
+			public LocalClass(String s) {
+				System.out.println(s);
+				statmeth(4);
+			}
+			
+			public void localtest() {
+				int i = intfield;
+				intfield = 4;
+				maintest(i);
+
+				System.out.println(local1);
+				
+				System.out.println(stfield);
+				stfield = 3;
+			}
+			
+			class LocalMemberClass {
+				
+			}
+			
+		}
+		
+		boolean t = false;
+		if(t) {
+			LocalClass lc = new LocalClass("1");
+			LocalClass.LocalMemberClass rt = lc.new LocalMemberClass();;
+		} else {
+			if(Math.random() > 1) {
+				LocalClass lc1 = new LocalClass("1");
+			}
+			System.out.println();
+		}
+		
+	}
+	
+	
+	public class MemberClass {
+		
+		public MemberClass(String z) {
+			System.out.println(z);
+		}
+		
+		public void membertest() {
+			int i = intfield;
+			maintest(i);
+			stfield = 5;
+			
+			Member2Class.Member3Class t = (new Member2Class()).new Member3Class();
+		}
+
+		public class Member2Class1 {
+
+			public class Member3Class1 {
+				
+			}
+		}
+		
+		class Member2Class {
+			
+			public void member2test() {
+				int i = intfield;
+				maintest(i);
+				Member2Class1.Member3Class1 t;
+			}
+			
+			public class Member3Class {
+				
+			}
+			
+		}
+		
+	}
+	
+}

test/test/misc/MiscTest.java

@@ -0,0 +1,83 @@
+package test.misc;
+
+public class MiscTest {
+	
+	public static double test = 1 / 0; 
+	
+	
+	public static void main(String[] args) {
+		
+		System.out.println(test);
+		
+		String s = "a  b";
+		s = s.replaceAll("  ", " &nbsp");
+		System.out.println(s);
+		
+		try {
+			throw null;
+		} catch(RuntimeException ex) {
+			System.out.println(ex);
+		}
+		
+		
+		int a = 3;
+		
+		if(a == 1) {
+			System.out.println("1");
+		} else if(a == 2) {
+			System.out.println("2");
+		} else if(a == 3) {
+			System.out.println("3");
+		} else if(a == 4) {
+			System.out.println("4");
+		} else if(a == 5) {
+			System.out.println("5");
+		} else if(a == 6) {
+			System.out.println("6");
+		} else if(a == 7) {
+			System.out.println("7");
+		}
+		
+		if(a == 0) {
+			return;
+		} else {
+			System.out.println("0");
+		}
+		
+		if(a==4) {
+			System.out.println("assert");
+			assert a==4 && a==5;
+		} else {
+			assert false;
+		}
+		
+		assert a==5: Math.random();
+		
+		assert false: Math.random();
+		
+		assert true;
+		
+		assert true: Math.random();
+		
+		/*
+		label: {
+		if(a == 0) {
+			System.out.println("0");
+		} else if(a == 1) {
+			System.out.println("01");
+		} else {
+			if(a == -1) {
+				System.out.println("-1");
+			} else {
+				System.out.println("-2");
+			}
+			break label;
+		}
+		
+		System.out.println("end");
+		}
+		System.out.println("end1");
+		*/
+	}
+
+}

test/test/misc/MultipleClassTest.java

@@ -0,0 +1,33 @@
+package test.misc;
+
+public class MultipleClassTest {
+
+	public int field = this.hashCode();
+	
+	public void test() {
+		
+		class Test1 {
+			public int t1() {
+//				System.out.println("1");
+				
+				try {
+					return 2;
+				} finally {
+					System.out.println("1");
+					return 3;
+				}
+				
+			}
+		}
+		
+		class Test2 {
+			public void t2() {
+				System.out.println("2");
+				//new Test1().t1();
+			}
+		}
+
+//		new Test1().t1();
+	}
+	
+}

test/test/misc/ParentFieldTest.java

@@ -0,0 +1,19 @@
+package test.misc;
+
+public class ParentFieldTest {
+
+	public int test = 0;
+	
+	private class Parent extends ParentFieldTest {
+
+		private class Child {
+			
+			public void test() {
+				System.out.println(ParentFieldTest.this.test);
+			}
+			
+		}
+		
+	}
+	
+}

test/test/misc/SuperTest.java

@@ -0,0 +1,27 @@
+package test.misc;
+
+import java.util.ArrayList;
+
+public class SuperTest extends ArrayList {
+
+	public SuperTest() {
+		super(3);
+		super.modCount = 2;
+		SuperTest.super.size();
+	}
+	
+	public int size() {
+		System.out.println("1");
+		return 0;
+	}
+	
+	class SuperTest1 {
+		
+		public void test() {
+			SuperTest.super.size();
+			SuperTest.super.modCount = 2;
+		}
+		
+	}
+	
+}

test/test/misc/ann/RequestForEnhancement.java

@@ -0,0 +1,22 @@
+package test.misc.ann;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Describes the Request-For-Enhancement(RFE) that led
+ * to the presence of the annotated API element.
+ */
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface RequestForEnhancement {
+	int    id();
+	String synopsis();
+	String engineer() default "[unassigned]"; 
+	String date()    default "[unimplemented]"; 
+	String[] arr();
+	Class cl();
+}

test/test/misc/en/AutocastTest.java

@@ -0,0 +1,17 @@
+package test.misc.en;
+
+import java.util.HashMap;
+
+public class AutocastTest {
+
+	public static void main(String[] args) {
+		
+		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+		
+		Integer key = new Integer(1);
+		Integer value = map.containsKey(key)?0:map.get(key);
+		
+		System.out.println(value == null);
+	}
+	
+}

test/test/misc/en/FastSetTest.java

@@ -0,0 +1,60 @@
+package test.misc.en;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import de.fernflower.util.FastSetFactory;
+import de.fernflower.util.FastSetFactory.FastSet;
+
+public class FastSetTest {
+
+	public static void main(String[] args) {
+
+		SortedSet<Integer> set = new TreeSet<Integer>();   
+		
+		for(int i=0;i<3;i++) {
+			set.add(i);
+		}
+		
+//		for(Integer s : set) {
+//			System.out.println(s);
+//		}
+		
+		 FastSetFactory<Integer> factory = new FastSetFactory<Integer>(set);
+		
+//		 factory.print();
+	
+//		 int index = 1;
+//		 for(int i=0;i<100;i++) {
+//			 if(i % 32 == 0) {
+//				 index = 1;
+//			 }
+//
+//			 System.out.println(index);
+//			 index<<=1;
+//			 
+//		 }
+		 
+		 
+
+		 FastSet<Integer> set1 = factory.spawnEmptySet();
+		 set1.addAll(new HashSet<Integer>(Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})));
+		 
+		 FastSet<Integer> set2 = set1.getCopy();
+		 set2.remove(4);
+		 set2.remove(5);
+		 set2.add(10);
+		 
+		 set1.symdiff(set2);
+		 Set<Integer> set3 = new TreeSet<Integer>(set1.toPlainSet());
+
+		 for(Integer s : set3) {
+			 System.out.println(s);
+		 }
+	}
+	
+
+}

test/test/misc/en/FinallyTest.java

@@ -0,0 +1,22 @@
+package test.misc.en;
+
+public class FinallyTest {
+
+	public FinallyTest() {
+		
+		int i;
+		try {
+			try {
+				i = 0;
+			} finally {
+				i = 1; 
+			}
+			i = 2;
+		} finally {
+			i = 3; 
+		}
+		
+		System.out.println(i);
+	}
+
+}

test/test/misc/en/Foo.java

@@ -0,0 +1,52 @@
+package test.misc.en;
+
+class Foo {
+
+	public Foo() {}
+		
+	public Foo(String test) {}
+	
+	private void foo() {
+		System.out.println("qwe");
+	}
+
+	static class Bar extends Foo {
+		void bar() {
+			System.out.println("1");
+			//((Foo)this).foo();
+		}
+	}
+
+	static class Bar1 extends Bar {
+		void bar() {
+			super.bar();
+			//System.out.println("2");
+			//((Foo)this).foo();
+		}
+	}
+
+	static class Bar2 extends Bar1 {
+		void bar1() {
+			super.bar();
+		}
+	}
+	
+	public static void main(String[] args) {
+		new Bar2().bar();
+	}
+	
+	public int testfin() {
+		
+		int i;
+		
+		try {
+			System.out.println();
+			i = 0;
+		} finally {
+			System.out.println();
+		}
+		
+		
+		return i;
+	}
+}

test/test/misc/en/InnerTest$1.java

@@ -0,0 +1,22 @@
+package test.misc.en;
+
+
+class InnerTest$1 extends Foo implements Runnable {
+
+   // $FF: synthetic field
+   final String val$test;
+   // $FF: synthetic field
+   final int val$test1;
+
+
+   InnerTest$1(String var1, int var2) {
+      super();
+      this.val$test = var1;
+      this.val$test1 = var2;
+   }
+
+   public void run() {
+      System.out.println(this.val$test);
+      System.out.println(this.val$test1);
+   }
+}

test/test/misc/en/InnerTest.java

@@ -0,0 +1,13 @@
+package test.misc.en;
+
+import test.misc.en.InnerTest$1;
+
+public class InnerTest {
+
+   public static void main(String[] args) throws Throwable {
+      String test = args[0];
+      int test1 = Integer.parseInt(args[1]);
+      new InnerTest$1(test, test1);
+      System.out.println("готово");
+   }
+}

test/test/misc/en/InnerTestOld.java

@@ -0,0 +1,20 @@
+package test.misc.en;
+
+public class InnerTestOld {
+
+	public static void main(String[] args) {
+
+		final String test = args[0];
+		final int test1 = Integer.parseInt(args[1]);
+		
+		Runnable r = new Runnable() {
+			public void run() {
+				System.out.println(test);
+				System.out.println(test1);
+			}
+		};
+		
+		System.out.println("done");
+	}
+
+}

test/test/misc/en/ListInsertTest.java

@@ -0,0 +1,34 @@
+package test.misc.en;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+
+public class ListInsertTest {
+
+	public static void main(String[] args) {
+		
+		List<Integer> lst1 = new ArrayList<Integer>(Arrays.asList(new Integer[]{1, 2, 3}));
+		List<Integer> lst2 = new LinkedList<Integer>(Arrays.asList(new Integer[]{1, 2, 3}));
+
+		Date d = new Date();
+		
+		for(int i=0;i<300000;i++) {
+			lst1.add(1, i);
+		}
+		
+		System.out.println(new Date().getTime() - d.getTime());
+
+		d = new Date();
+		
+		for(int i=0;i<300000;i++) {
+			lst2.add(1, i);
+		}
+		
+		System.out.println(new Date().getTime() - d.getTime());
+		
+	}
+
+}

test/test/misc/en/Operation.java

@@ -0,0 +1,51 @@
+package test.misc.en;
+
+public enum Operation {
+	
+    PLUS(2) {
+        double eval(double x, double y) { return x + y; }
+    },
+    MINUS(7) {
+        double eval(double x, double y) { return x - y; }
+    },
+    TIMES(8) {
+        double eval(double x, double y) { return x * y; }
+    },
+    DIVIDED_BY(0) {
+        double eval(double x, double y) { return x / y; }
+    };
+    
+
+    // Perform the arithmetic operation represented by this constant
+    
+    abstract double eval(double x, double y);
+    
+    Operation(int t) {
+    	
+//    	class LocalClass {
+//    		
+//    	}
+//    	
+//    	LocalClass e = null;
+    	
+    	System.out.println();
+    }
+    
+
+    public static void main(String args[]) {
+        double x = Double.parseDouble(args[0]);
+        double y = Double.parseDouble(args[1]);
+
+        Operation opp = Operation.DIVIDED_BY;
+        
+        switch(opp) {
+        	case MINUS:
+        		System.out.println();
+        	case PLUS:
+        }
+
+        for (Operation op : Operation.values()) {
+            System.out.println(x + " " + op + " " + y + " = " + op.eval(x, y));
+        }
+    }
+}

test/test/misc/en/SwitchInTest.java

@@ -0,0 +1,19 @@
+package test.misc.en;
+
+public class SwitchInTest {
+
+	public static void main(String[] args) {
+
+		short t = 2;
+		switch(t) {
+		case -56:
+		case 0:
+		case 3:
+		case 129:
+			System.out.println();
+		default:
+		}
+		
+	}
+
+}

test/test/misc/en/TestOperation.java

@@ -0,0 +1,31 @@
+package test.misc.en;
+
+public class TestOperation {
+
+	public void test() {
+		
+        double x = 2;
+        double y = 3;
+
+        Operation opp = Operation.DIVIDED_BY;
+        
+        switch(opp) {
+        	case MINUS:
+        		System.out.println();
+        	case PLUS:
+        }
+        
+        switch(Operation.MINUS) {
+    	case DIVIDED_BY:
+    		System.out.println();
+    	case PLUS:
+    	case TIMES:
+        }
+        
+        for (Operation op : Operation.values()) {
+            System.out.println(x + " " + op + " " + y + " = " + op.eval(x, y));
+        }
+		
+	}
+	
+}

test/test/output/TestEclipse7.java

@@ -0,0 +1,15 @@
+package test.output;
+
+import java.lang.reflect.Method;
+
+public class TestEclipse7 {
+
+   public void testMultiCatch() {
+      try {
+         Method e = this.getClass().getDeclaredMethod("foo", new Class[0]);
+      } catch (SecurityException | NoSuchMethodException var2) {
+         var2.printStackTrace();
+      }
+
+   }
+}

test/test/output/TestJavac7.java

@@ -0,0 +1,129 @@
+package test.output;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+public class TestJavac7 {
+
+   public void testTryResources() throws IOException {
+      FileReader var1 = new FileReader("file");
+      Throwable var2 = null;
+
+      try {
+         FileReader var3 = new FileReader("file");
+         Throwable var4 = null;
+
+         try {
+            System.out.println();
+         } catch (Throwable var27) {
+            var4 = var27;
+            throw var27;
+         } finally {
+            if(var3 != null) {
+               if(var4 != null) {
+                  try {
+                     var3.close();
+                  } catch (Throwable var26) {
+                     var4.addSuppressed(var26);
+                  }
+               } else {
+                  var3.close();
+               }
+            }
+
+         }
+      } catch (Throwable var29) {
+         var2 = var29;
+         throw var29;
+      } finally {
+         if(var1 != null) {
+            if(var2 != null) {
+               try {
+                  var1.close();
+               } catch (Throwable var25) {
+                  var2.addSuppressed(var25);
+               }
+            } else {
+               var1.close();
+            }
+         }
+
+      }
+
+   }
+
+   public void testTryResources1() throws IOException {
+      try {
+         FileReader var1 = new FileReader("file");
+         Throwable var2 = null;
+
+         try {
+            System.out.println("block");
+         } catch (Throwable var20) {
+            var2 = var20;
+            throw var20;
+         } finally {
+            if(var1 != null) {
+               if(var2 != null) {
+                  try {
+                     var1.close();
+                  } catch (Throwable var19) {
+                     var2.addSuppressed(var19);
+                  }
+               } else {
+                  var1.close();
+               }
+            }
+
+         }
+      } catch (RuntimeException var22) {
+         System.out.println(var22.toString());
+      } finally {
+         System.out.println("finally");
+      }
+
+   }
+
+   public void testMultiCatch() {
+      try {
+         Method var1 = this.getClass().getDeclaredMethod("foo", new Class[0]);
+      } catch (SecurityException var2) {
+         var2.printStackTrace();
+      }
+
+   }
+
+   public void testSwitchString() {
+      String var1 = "";
+      byte var3 = -1;
+      switch(var1.hashCode()) {
+      case 2112:
+         if(var1.equals("BB")) {
+            var3 = 1;
+         } else if(var1.equals("Aa")) {
+            var3 = 0;
+         }
+         break;
+      case 3040:
+         if(var1.equals("__")) {
+            var3 = 2;
+         }
+      }
+
+      switch(var3) {
+      case 0:
+         System.out.println("!");
+         break;
+      case 1:
+         System.out.println("?");
+         break;
+      case 2:
+         System.out.println("_");
+         break;
+      default:
+         System.out.println("#");
+      }
+
+   }
+}

test/test/output/TestJavac8.java

@@ -0,0 +1,104 @@
+package test.output;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+public class TestJavac8 {
+
+   public static void main(String[] var0) {
+      (new TestJavac8()).testLambda();
+   }
+
+   public void testTryResources() throws IOException {
+      FileReader var1 = new FileReader("file");
+      Throwable var2 = null;
+
+      try {
+         FileReader var3 = new FileReader("file");
+         Throwable var4 = null;
+
+         try {
+            System.out.println();
+         } catch (Throwable var27) {
+            var4 = var27;
+            throw var27;
+         } finally {
+            if(var3 != null) {
+               if(var4 != null) {
+                  try {
+                     var3.close();
+                  } catch (Throwable var26) {
+                     var4.addSuppressed(var26);
+                  }
+               } else {
+                  var3.close();
+               }
+            }
+
+         }
+      } catch (Throwable var29) {
+         var2 = var29;
+         throw var29;
+      } finally {
+         if(var1 != null) {
+            if(var2 != null) {
+               try {
+                  var1.close();
+               } catch (Throwable var25) {
+                  var2.addSuppressed(var25);
+               }
+            } else {
+               var1.close();
+            }
+         }
+
+      }
+
+   }
+
+   public void testMultiCatch() {
+      try {
+         Method var1 = this.getClass().getDeclaredMethod("foo", new Class[0]);
+      } catch (SecurityException var2) {
+         var2.printStackTrace();
+      }
+
+   }
+
+   private void testSwitchString() {
+      String var1 = "";
+      byte var3 = -1;
+      switch(var1.hashCode()) {
+      case 2112:
+         if(var1.equals("BB")) {
+            var3 = 1;
+         } else if(var1.equals("Aa")) {
+            var3 = 0;
+         }
+         break;
+      case 3040:
+         if(var1.equals("__")) {
+            var3 = 2;
+         }
+      }
+
+      switch(var3) {
+      case 0:
+         System.out.println("!");
+         break;
+      case 1:
+         System.out.println("?");
+         break;
+      case 2:
+         System.out.println("_");
+         break;
+      default:
+         System.out.println("#");
+      }
+
+   }
+
+   public void testLambda() {
+   }
+}

test/test/util/DotExporter.java

@@ -0,0 +1,183 @@
+package test.util;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+
+import de.fernflower.code.cfg.BasicBlock;
+import de.fernflower.code.cfg.ControlFlowGraph;
+import de.fernflower.modules.decompiler.StatEdge;
+import de.fernflower.modules.decompiler.sforms.DirectGraph;
+import de.fernflower.modules.decompiler.sforms.DirectNode;
+import de.fernflower.modules.decompiler.stats.Statement;
+import de.fernflower.modules.decompiler.vars.VarVersionEdge;
+import de.fernflower.modules.decompiler.vars.VarVersionNode;
+import de.fernflower.modules.decompiler.vars.VarVersionsGraph;
+
+public class DotExporter {
+
+	
+	public static String toDotFormat(Statement stat) {
+		
+		StringBuffer buffer = new StringBuffer();
+		
+		buffer.append("digraph G {\r\n");
+		
+		for(Statement st : stat.getStats()) {
+			
+			String sourceid = st.id + (st.getSuccessorEdges(StatEdge.TYPE_EXCEPTION).isEmpty()?"":"000000");
+			
+			buffer.append(sourceid+" [shape=box,label=\""+sourceid+"\"];\r\n");
+			
+			for(StatEdge edge : st.getSuccessorEdges(Statement.STATEDGE_DIRECT_ALL)) {
+				String destid = edge.getDestination().id + (edge.getDestination().getSuccessorEdges(StatEdge.TYPE_EXCEPTION).isEmpty()?"":"000000");
+
+				buffer.append(sourceid+"->"+destid+";\r\n");
+				
+				if(!stat.getStats().contains(edge.getDestination())) {
+					buffer.append(destid+" [label=\""+destid+"\"];\r\n");
+				}
+			}
+
+			for(StatEdge edge : st.getSuccessorEdges(StatEdge.TYPE_EXCEPTION)) {
+				String destid = edge.getDestination().id + (edge.getDestination().getSuccessorEdges(StatEdge.TYPE_EXCEPTION).isEmpty()?"":"000000");
+
+				buffer.append(sourceid+" -> "+destid+" [style=dotted];\r\n");
+
+				if(!stat.getStats().contains(edge.getDestination())) {
+					buffer.append(destid+" [label=\""+destid+"\"];\r\n");
+				}
+			}
+		}
+		
+		buffer.append("}");
+		
+		return buffer.toString(); 
+	}
+	
+	
+	public static String toDotFormat(ControlFlowGraph graph, boolean showMultipleEdges) {
+		
+		StringBuffer buffer = new StringBuffer();
+		
+		buffer.append("digraph G {\r\n");
+		
+		List<BasicBlock> blocks = graph.getBlocks(); 
+		for(int i=0;i<blocks.size();i++) {
+			BasicBlock block = (BasicBlock)blocks.get(i);
+			
+			buffer.append(block.id+" [shape=box,label=\""+block.id+"\"];\r\n");
+			
+			
+			List<BasicBlock> suc = block.getSuccs();
+			if(!showMultipleEdges) {
+				HashSet<BasicBlock> set = new HashSet<BasicBlock>();
+				set.addAll(suc);
+				suc = Collections.list(Collections.enumeration(set));
+			}
+			for(int j=0;j<suc.size();j++) {
+				buffer.append(block.id+"->"+((BasicBlock)suc.get(j)).id+";\r\n");
+			}
+
+			
+			suc = block.getSuccExceptions();
+			if(!showMultipleEdges) {
+				HashSet<BasicBlock> set = new HashSet<BasicBlock>();
+				set.addAll(suc);
+				suc = Collections.list(Collections.enumeration(set));
+			}
+			for(int j=0;j<suc.size();j++) {
+				buffer.append(block.id+" -> "+((BasicBlock)suc.get(j)).id+" [style=dotted];\r\n");
+			}
+		}
+		
+		buffer.append("}");
+		
+		return buffer.toString(); 
+	}
+
+	public static String toDotFormat(VarVersionsGraph graph) {
+		
+		StringBuffer buffer = new StringBuffer();
+		
+		buffer.append("digraph G {\r\n");
+		
+		List<VarVersionNode> blocks = graph.nodes; 
+		for(int i=0;i<blocks.size();i++) {
+			VarVersionNode block = blocks.get(i);
+			
+			buffer.append((block.var*1000+block.version)+" [shape=box,label=\""+block.var+"_"+block.version+"\"];\r\n");
+			
+			for(VarVersionEdge edge: block.succs) {
+				VarVersionNode dest = edge.dest;
+				buffer.append((block.var*1000+block.version)+"->"+(dest.var*1000+dest.version)+(edge.type==VarVersionEdge.EDGE_PHANTOM?" [style=dotted]":"")+";\r\n");
+			}
+		}
+		
+		buffer.append("}");
+		
+		return buffer.toString(); 
+	}
+
+	public static String toDotFormat(DirectGraph graph) {
+		
+		StringBuffer buffer = new StringBuffer();
+		
+		buffer.append("digraph G {\r\n");
+		
+		List<DirectNode> blocks = graph.nodes; 
+		for(int i=0;i<blocks.size();i++) {
+			DirectNode block = blocks.get(i);
+			
+			buffer.append(directBlockIdToDot(block.id)+" [shape=box,label=\""+directBlockIdToDot(block.id)+"\"];\r\n");
+			
+			for(DirectNode dest: block.succs) {
+				buffer.append(directBlockIdToDot(block.id)+"->"+directBlockIdToDot(dest.id)+";\r\n");
+			}
+		}
+		
+		buffer.append("}");
+		
+		return buffer.toString(); 
+	}
+	
+	private static String directBlockIdToDot(String id) {
+		id = id.replaceAll("_try", "999");
+		id = id.replaceAll("_tail", "888");
+		return id;
+	}
+
+	public static void toDotFile(ControlFlowGraph graph, File file, boolean showMultipleEdges) throws FileNotFoundException, IOException {
+		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 
+		out.write(toDotFormat(graph, showMultipleEdges).getBytes());
+		out.close(); 
+	}
+
+	public static void toDotFile(VarVersionsGraph graph, File file) throws FileNotFoundException, IOException {
+		
+		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 
+		out.write(toDotFormat(graph).getBytes());
+		out.close(); 
+	}
+
+	public static void toDotFile(DirectGraph graph, File file) throws FileNotFoundException, IOException {
+		
+		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 
+		out.write(toDotFormat(graph).getBytes());
+		out.close(); 
+	}
+
+	public static void toDotFile(Statement stat, File file) throws FileNotFoundException, IOException {
+		
+		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 
+		out.write(toDotFormat(stat).getBytes());
+		out.close(); 
+	}
+	
+}

test/test/util/MemoryMonitor.java

@@ -0,0 +1,25 @@
+package test.util;
+
+public class MemoryMonitor implements Runnable {
+
+	public static boolean run = false;
+	
+	
+	public void run() {
+		
+		while(run) {
+			try {
+				Thread.sleep(500);
+			} catch(InterruptedException ex) {
+				ex.printStackTrace();
+			}
+			
+			//Runtime.getRuntime().gc();
+			System.err.println((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory())/(1024*1024));
+			
+		}
+		
+	}
+
+	
+}

test/test/util/Timer.java

@@ -0,0 +1,31 @@
+package test.util;
+
+import java.util.HashMap;
+
+public class Timer {
+
+	private static HashMap<String, Double> mapValue = new HashMap<String, Double>(); 
+	
+	public static void addTime(int index, long value) {
+		addTime(String.valueOf(index), value);
+	}
+
+	public static double getTime(int index) {
+		return mapValue.get(String.valueOf(index));
+	}
+
+	public static void addTime(String index, double value) {
+		Double val = mapValue.get(index);
+		if(val != null) {
+			value+=val.doubleValue();
+		}  
+		mapValue.put(index, value);
+	}
+
+	public static double getTime(String index) {
+		Double value = mapValue.get(index);
+		return value==null?0:value.doubleValue();
+	}
+	
+}
+

test/test/util/ZipStripper.java

@@ -0,0 +1,71 @@
+package test.util;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+public class ZipStripper {
+
+	public static void main(String[] args) {
+
+		try {
+			String sourceFileName = args[0];
+			File sourceFile = new File(sourceFileName);
+			
+			File tempFile = new File(sourceFile.getParentFile(), "tmp31415926535.zip");
+			tempFile.createNewFile();
+			
+			ZipOutputStream outTemp = new ZipOutputStream(new FileOutputStream(tempFile));
+			
+			ZipFile archive = new ZipFile(sourceFile);
+			
+			Enumeration<? extends ZipEntry> en = archive.entries();
+			while(en.hasMoreElements()) {
+				ZipEntry entr = en.nextElement();
+			
+				outTemp.putNextEntry(new ZipEntry(entr.getName()));
+				
+				if(!entr.isDirectory()) {
+					InputStream in = archive.getInputStream(entr);
+					
+					copyInputStream(in, outTemp);
+					in.close();
+				}
+			}
+			
+			outTemp.flush();
+			outTemp.close();
+			
+			archive.close();
+			
+			String destFileName = args[1];
+
+			if(sourceFileName.equals(destFileName)) {
+				sourceFile.delete();
+			}
+			
+			tempFile.renameTo(new File(destFileName));
+			
+		} catch(Exception ex) {
+			ex.printStackTrace();
+		}
+		
+	}
+
+	public static void copyInputStream(InputStream in, OutputStream out)throws IOException {
+		
+		byte[] buffer = new byte[1024];
+		int len;
+		
+		while((len = in.read(buffer)) >= 0) {
+			out.write(buffer, 0, len);
+		}
+	}
+	
+}