A couple of unit tests

test/unit/TestSingleClasses.java

@@ -0,0 +1,89 @@
+package unit;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Date;
+import java.util.HashMap;
+
+import org.junit.Test;
+
+import de.fernflower.main.decompiler.ConsoleDecompiler;
+import de.fernflower.main.extern.IFernflowerPreferences;
+
+public class TestSingleClasses {
+
+	@Test
+	public void test() throws IOException {
+
+		Date start = new Date();
+		
+		String current_path = new File(".").getCanonicalPath().toString();
+
+		iterateDirectory(new File(current_path + "/bin/unit/classes/"));
+		
+		System.out.println("\n\nTime elapsed " + (new Date().getTime() - start.getTime())/1000);
+	}
+	
+	private void iterateDirectory(File dir) throws IOException {
+		
+    	for (File file : dir.listFiles()) {
+    		if (file.isDirectory()) {
+    			iterateDirectory(file);
+    		} else if(file.getName().endsWith(".class")) {
+    			decompileAndCheckFile(file);
+    		}
+    	}
+	}
+	
+	private void decompileAndCheckFile(File file) throws IOException {
+
+		try {
+    		
+    		ConsoleDecompiler decompiler = new ConsoleDecompiler(new HashMap<String, Object>(){{
+    			put("log", "warn");
+    			put("ren", "1");
+    	        put(IFernflowerPreferences.HIDE_DEFAULT_CONSTRUCTOR, "1");
+    	        put(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES, "0");
+    	        put(IFernflowerPreferences.IDEA_NOT_NULL_ANNOTATION, "1");
+    	        put(IFernflowerPreferences.LAMBDA_TO_ANONYMOUS_CLASS, "0");
+    	        put(IFernflowerPreferences.USE_DEBUG_VARNAMES, "0");
+    	        put(IFernflowerPreferences.NEW_LINE_SEPARATOR, "0");
+    	     }});
+    		
+    		decompiler.addSpace(file, true);
+
+    		// files 
+    		String current_path = new File(".").getCanonicalPath().toString();
+    		
+    		String file_class_name = file.getName();
+    		String file_name = file_class_name.substring(0, file_class_name.lastIndexOf(".class")); 
+    		String file_java_name = file_name+".java"; 
+
+    		File reference_file = new File(current_path + "/test/unit/results/" + file_name + ".dec");  
+    		File temp_dir = new File(Files.createTempDirectory("tempdec_"+file_name).toString());
+    	 	
+    		// decompile it
+    		decompiler.decompileContext(temp_dir);
+    		
+    		// get both the decompiled file content and the reference
+    		// NOTE: reference files are saved with Windows-style line endings. Convert them if you are decompiling to Unix. 
+    		String decompiled_content = new String(Files.readAllBytes(new File(temp_dir, file_java_name).toPath()), "UTF-8");
+    		String reference_content = new String(Files.readAllBytes(reference_file.toPath()), "UTF-8");
+    		
+    		// clean up
+    		//temp_dir.delete();
+
+    		// compare file content with the reference
+    		assertEquals(decompiled_content, reference_content);
+    		
+		} catch(Exception ex) {
+			System.out.println("ERROR: testing file " + file.getCanonicalPath());
+			ex.printStackTrace();
+		}
+		
+	}
+
+}

test/unit/classes/TestClassLambda.java

@@ -0,0 +1,67 @@
+package unit.classes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.function.IntBinaryOperator;
+import java.util.function.Supplier;
+
+public class TestClassLambda {
+
+	public int field = 0;
+	
+	public void testLambda() {
+		
+		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+		int b = (int)Math.random();
+		
+		list.forEach(n -> {int a = 2 * n; System.out.println(a + b + field);});	
+	}
+
+	public void testLambda1() {
+		
+		int a = (int)Math.random();
+		
+		Runnable r = () -> { System.out.println("hello" + a); };
+
+		Runnable r1 = () -> { System.out.println("hello1" + a); };
+	}
+
+	public void testLambda2() { 
+		reduce((left, right) -> Math.max(left, right));
+	}
+
+	public void testLambda3() { // IDEA-127301
+		reduce(Math::max);
+	}
+
+	public void testLambda4() { 
+		reduce(TestClassLambda::localMax);
+	}
+	
+	public void testLambda5() { 
+		String x = "abcd";
+		function(x::toString);
+	}
+	
+	public void testLambda6() {
+        List<String> list = new ArrayList<String>();
+        int bottom = list.size() * 2; 
+        int top = list.size() * 5;
+        list.removeIf( s -> (bottom >= s.length() && s.length() <= top) );
+    }
+	
+	public static OptionalInt reduce(IntBinaryOperator op) {
+	    return null;
+	}
+	
+	public static String function(Supplier<String> supplier) {
+	    return supplier.get();
+	}
+
+	public static int localMax(int first, int second) {
+	    return 0;
+	}
+
+}

test/unit/classes/TestClassVar.java

@@ -0,0 +1,44 @@
+package unit.classes;
+
+
+public class TestClassVar {
+
+    private boolean field_boolean = (Math.random() > 0);
+	public int field_int = 0;
+
+	public void testFieldSSAU() {
+
+        for(int i = 0; i < 10; i++) {
+        	
+        	try {
+        		System.out.println();
+        	} finally {
+        		if (field_boolean) {
+        			System.out.println();
+        		}
+        	}
+        	
+        }
+	}
+	
+	public Long testFieldSSAU1() { // IDEA-127466
+		return new Long(field_int++);
+	}
+	
+	public void testComplexPropagation() {
+		
+		int a = 0;
+
+		while (a < 10) {
+			
+			int b = a;
+
+			for(; a < 10 && a == 0; a++) {}
+			
+			if (b != a) {
+				System.out.println();
+			}
+		}
+	}
+	
+}

test/unit/results/TestClassLambda.dec

@@ -0,0 +1,75 @@
+package unit.classes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.function.Consumer;
+import java.util.function.IntBinaryOperator;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class TestClassLambda {
+
+   public int field = 0;
+
+
+   public void testLambda() {
+      List var1 = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4), Integer.valueOf(5), Integer.valueOf(6), Integer.valueOf(7)});
+      int var2 = (int)Math.random();
+      var1.forEach((var2x) -> {
+         int var3 = 2 * var2x.intValue();
+         System.out.println(var3 + var2 + this.field);
+      });
+   }
+
+   public void testLambda1() {
+      int var1 = (int)Math.random();
+      Runnable var2 = () -> {
+         System.out.println("hello" + var1);
+      };
+      Runnable var3 = () -> {
+         System.out.println("hello1" + var1);
+      };
+   }
+
+   public void testLambda2() {
+      reduce((var0, var1) -> {
+         return Math.max(var0, var1);
+      });
+   }
+
+   public void testLambda3() {
+      reduce(Math::max);
+   }
+
+   public void testLambda4() {
+      reduce(TestClassLambda::localMax);
+   }
+
+   public void testLambda5() {
+      String var1 = "abcd";
+      function(var1::toString);
+   }
+
+   public void testLambda6() {
+      ArrayList var1 = new ArrayList();
+      int var2 = var1.size() * 2;
+      int var3 = var1.size() * 5;
+      var1.removeIf((var2x) -> {
+         return var2 >= var2x.length() && var2x.length() <= var3;
+      });
+   }
+
+   public static OptionalInt reduce(IntBinaryOperator var0) {
+      return null;
+   }
+
+   public static String function(Supplier var0) {
+      return (String)var0.get();
+   }
+
+   public static int localMax(int var0, int var1) {
+      return 0;
+   }
+}

test/unit/results/TestClassLoop.dec

@@ -0,0 +1,39 @@
+package unit.classes;
+
+
+public class TestClassLoop {
+
+   public static void testFinally() {
+      boolean var0 = Math.random() > 0.0D;
+
+      while(true) {
+         try {
+            if(!var0) {
+               return;
+            }
+         } finally {
+            System.out.println("1");
+         }
+      }
+   }
+
+   public static void testFinallyContinue() {
+      boolean var0 = Math.random() > 0.0D;
+
+      while(true) {
+         while(true) {
+            try {
+               System.out.println("1");
+               break;
+            } finally {
+               if(var0) {
+                  System.out.println("3");
+                  continue;
+               }
+            }
+         }
+
+         System.out.println("4");
+      }
+   }
+}

test/unit/results/TestClassVar.dec

@@ -0,0 +1,43 @@
+package unit.classes;
+
+
+public class TestClassVar {
+
+   private boolean field_boolean = Math.random() > 0.0D;
+   public int field_int = 0;
+
+
+   public void testFieldSSAU() {
+      for(int var1 = 0; var1 < 10; ++var1) {
+         try {
+            System.out.println();
+         } finally {
+            if(this.field_boolean) {
+               System.out.println();
+            }
+
+         }
+      }
+
+   }
+
+   public Long testFieldSSAU1() {
+      return new Long((long)(this.field_int++));
+   }
+
+   public void testComplexPropagation() {
+      int var1 = 0;
+
+      while(var1 < 10) {
+         int var2;
+         for(var2 = var1; var1 < 10 && var1 == 0; ++var1) {
+            ;
+         }
+
+         if(var2 != var1) {
+            System.out.println();
+         }
+      }
+
+   }
+}