From 70bf7f3f6993c6ea23dd568e39257b9c0dd6c8c7 Mon Sep 17 00:00:00 2001 From: Stiver Date: Sat, 9 Aug 2014 17:34:24 +0200 Subject: [PATCH] A couple of unit tests --- test/unit/TestSingleClasses.java | 89 +++++++++++++++++++ test/unit/classes/TestClassLambda.java | 67 ++++++++++++++ .../classes/TestClassLoop.java} | 0 test/unit/classes/TestClassVar.java | 44 +++++++++ test/unit/results/TestClassLambda.dec | 75 ++++++++++++++++ test/unit/results/TestClassLoop.dec | 39 ++++++++ test/unit/results/TestClassVar.dec | 43 +++++++++ 7 files changed, 357 insertions(+) create mode 100644 test/unit/TestSingleClasses.java create mode 100644 test/unit/classes/TestClassLambda.java rename test/{test/input/TestLoop.java => unit/classes/TestClassLoop.java} (100%) create mode 100644 test/unit/classes/TestClassVar.java create mode 100644 test/unit/results/TestClassLambda.dec create mode 100644 test/unit/results/TestClassLoop.dec create mode 100644 test/unit/results/TestClassVar.dec diff --git a/test/unit/TestSingleClasses.java b/test/unit/TestSingleClasses.java new file mode 100644 index 0000000..2758316 --- /dev/null +++ b/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(){{ + 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(); + } + + } + +} diff --git a/test/unit/classes/TestClassLambda.java b/test/unit/classes/TestClassLambda.java new file mode 100644 index 0000000..a2b9d9a --- /dev/null +++ b/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 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 list = new ArrayList(); + 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 supplier) { + return supplier.get(); + } + + public static int localMax(int first, int second) { + return 0; + } + +} diff --git a/test/test/input/TestLoop.java b/test/unit/classes/TestClassLoop.java similarity index 100% rename from test/test/input/TestLoop.java rename to test/unit/classes/TestClassLoop.java diff --git a/test/unit/classes/TestClassVar.java b/test/unit/classes/TestClassVar.java new file mode 100644 index 0000000..fdba5c6 --- /dev/null +++ b/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(); + } + } + } + +} diff --git a/test/unit/results/TestClassLambda.dec b/test/unit/results/TestClassLambda.dec new file mode 100644 index 0000000..6ff82d8 --- /dev/null +++ b/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; + } +} diff --git a/test/unit/results/TestClassLoop.dec b/test/unit/results/TestClassLoop.dec new file mode 100644 index 0000000..3870f83 --- /dev/null +++ b/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"); + } + } +} diff --git a/test/unit/results/TestClassVar.dec b/test/unit/results/TestClassVar.dec new file mode 100644 index 0000000..cca4d7a --- /dev/null +++ b/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(); + } + } + + } +}