gui: add internal tests

build.gradle

@@ -25,6 +25,7 @@ subprojects {
     dependencies {
         compile 'org.slf4j:slf4j-api:1.7.5'
         testCompile 'junit:junit:4.11'
+        testCompile "org.mockito:mockito-core:1.9.5"
     }
 
     repositories {

jadx-core/src/main/java/jadx/api/Decompiler.java

@@ -101,6 +101,10 @@ public final class Decompiler {
 		return Collections.unmodifiableList(packages);
 	}
 
+	public int getErrorsCount() {
+		return errorsCount;
+	}
+
 	public ThreadPoolExecutor saveAll(File dir) {
 		int threadsCount = args.getThreadsCount();
 		LOG.debug("processing threads count: {}", threadsCount);
@@ -157,8 +161,4 @@ public final class Decompiler {
 			LOG.error("Process class error", e);
 		}
 	}
-
-	public int getErrorsCount() {
-		return errorsCount;
-	}
 }

jadx-core/src/main/java/jadx/api/JavaField.java

@@ -4,7 +4,7 @@ import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
 
-public class JavaField {
+public final class JavaField {
 
 	private final FieldNode field;
 

jadx-core/src/main/java/jadx/api/JavaMethod.java

@@ -7,7 +7,7 @@ import jadx.core.dex.nodes.MethodNode;
 
 import java.util.List;
 
-public class JavaMethod {
+public final class JavaMethod {
 	private final MethodNode mth;
 
 	public JavaMethod(MethodNode m) {

jadx-gui/src/main/java/jadx/gui/treemodel/JRoot.java

@@ -39,11 +39,23 @@ public class JRoot extends DefaultMutableTreeNode implements JNode {
 			}
 		} else {
 			// build packages hierarchy
-			Map<String, JPackage> pkgMap = new HashMap<String, JPackage>();
-			for (JavaPackage pkg : wrapper.getPackages()) {
-				addPackage(pkgMap, new JPackage(pkg));
+			List<JPackage> rootPkgs = getHierarchyPackages(wrapper.getPackages());
+			for (JPackage jPackage : rootPkgs) {
+				jPackage.updateChilds();
+				add(jPackage);
 			}
-			// merge packages without classes
+		}
+	}
+
+	List<JPackage> getHierarchyPackages(List<JavaPackage> packages) {
+		Map<String, JPackage> pkgMap = new HashMap<String, JPackage>();
+		for (JavaPackage pkg : packages) {
+			addPackage(pkgMap, new JPackage(pkg));
+		}
+		// merge packages without classes
+		boolean repeat;
+		do {
+			repeat = false;
 			for (JPackage pkg : pkgMap.values()) {
 				if (pkg.getInnerPackages().size() == 1 && pkg.getClasses().isEmpty()) {
 					JPackage innerPkg = pkg.getInnerPackages().get(0);
@@ -53,32 +65,34 @@ public class JRoot extends DefaultMutableTreeNode implements JNode {
 					pkg.setName(pkg.getName() + "." + innerPkg.getName());
 					innerPkg.getInnerPackages().clear();
 					innerPkg.getClasses().clear();
+
+					repeat = true;
+					pkgMap.remove(innerPkg.getName());
+					break;
 				}
 			}
-			// remove empty packages
-			for (Iterator<Map.Entry<String, JPackage>> it = pkgMap.entrySet().iterator(); it.hasNext(); ) {
-				JPackage pkg = it.next().getValue();
-				if (pkg.getInnerPackages().isEmpty() && pkg.getClasses().isEmpty()) {
-					it.remove();
-				}
-			}
-			// find root packages
-			Set<JPackage> inners = new HashSet<JPackage>();
-			for (JPackage pkg : pkgMap.values()) {
-				inners.addAll(pkg.getInnerPackages());
-			}
-			List<JPackage> rootPkgs = new ArrayList<JPackage>();
-			for (JPackage pkg : pkgMap.values()) {
-				if (!inners.contains(pkg)) {
-					rootPkgs.add(pkg);
-				}
+		} while (repeat);
+
+		// remove empty packages
+		for (Iterator<Map.Entry<String, JPackage>> it = pkgMap.entrySet().iterator(); it.hasNext(); ) {
+			JPackage pkg = it.next().getValue();
+			if (pkg.getInnerPackages().isEmpty() && pkg.getClasses().isEmpty()) {
+				it.remove();
 			}
-			Collections.sort(rootPkgs);
-			for (JPackage jPackage : rootPkgs) {
-				jPackage.updateChilds();
-				add(jPackage);
+		}
+		// find root packages
+		Set<JPackage> inners = new HashSet<JPackage>();
+		for (JPackage pkg : pkgMap.values()) {
+			inners.addAll(pkg.getInnerPackages());
+		}
+		List<JPackage> rootPkgs = new ArrayList<JPackage>();
+		for (JPackage pkg : pkgMap.values()) {
+			if (!inners.contains(pkg)) {
+				rootPkgs.add(pkg);
 			}
 		}
+		Collections.sort(rootPkgs);
+		return rootPkgs;
 	}
 
 	private void addPackage(Map<String, JPackage> pkgs, JPackage pkg) {

jadx-gui/src/test/java/jadx/api/Factory.java

+package jadx.api;
+
+import jadx.core.dex.nodes.ClassNode;
+
+import java.util.List;
+
+public class Factory {
+
+	public static JavaPackage newPackage(String name, List<JavaClass> classes) {
+		return new JavaPackage(name, classes);
+	}
+
+	public static JavaClass newClass(Decompiler decompiler, ClassNode classNode) {
+		return new JavaClass(decompiler, classNode);
+	}
+}

jadx-gui/src/test/java/jadx/gui/treemodel/JRootTest.java

+package jadx.gui.treemodel;
+
+import jadx.api.Decompiler;
+import jadx.api.Factory;
+import jadx.api.IJadxArgs;
+import jadx.api.JavaClass;
+import jadx.api.JavaPackage;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.gui.JadxWrapper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+public class JRootTest {
+
+	@Test
+	public void testHierarchyPackages() {
+		String pkgName = "a.b.c.d.e";
+
+		JadxWrapper wrapper = mock(JadxWrapper.class);
+		JRoot root = new JRoot(wrapper);
+
+		JavaClass cls = Factory.newClass(new Decompiler(mock(IJadxArgs.class)), mock(ClassNode.class));
+		JavaPackage pkg = Factory.newPackage(pkgName, Arrays.asList(cls));
+
+		List<JavaPackage> packages = new ArrayList<JavaPackage>();
+		packages.add(pkg);
+
+		List<JPackage> out = root.getHierarchyPackages(packages);
+
+		assertEquals(out.size(), 1);
+		JPackage jpkg = out.get(0);
+		assertEquals(jpkg.getName(), pkgName);
+		assertEquals(jpkg.getClasses().size(), 1);
+	}
+
+}