test: check code after reload

jadx-core/src/test/java/jadx/tests/api/IntegrationTest.java

@@ -21,6 +21,7 @@ import java.util.concurrent.TimeoutException;
 import java.util.jar.JarOutputStream;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 
@@ -157,17 +158,23 @@ public abstract class IntegrationTest extends TestUtils {
 		assertThat("Class not found: " + clsName, cls, notNullValue());
 		assertThat(clsName, is(cls.getClassInfo().getFullName()));
 
-		decompileAndCheck(jadxDecompiler, Collections.singletonList(cls));
+		decompileAndCheck(cls);
 		return cls;
 	}
 
-	public ClassNode searchCls(List<ClassNode> list, String fullClsName) {
+	@Nullable
+	public ClassNode searchCls(List<ClassNode> list, String clsName) {
 		for (ClassNode cls : list) {
-			if (cls.getClassInfo().getFullName().equals(fullClsName)) {
+			if (cls.getClassInfo().getFullName().equals(clsName)) {
 				return cls;
 			}
 		}
-		fail("Class not found by name " + fullClsName + " in list: " + list);
+		for (ClassNode cls : list) {
+			if (cls.getClassInfo().getShortName().equals(clsName)) {
+				return cls;
+			}
+		}
+		fail("Class not found by name " + clsName + " in list: " + list);
 		return null;
 	}
 
@@ -187,7 +194,11 @@ public abstract class IntegrationTest extends TestUtils {
 		return d;
 	}
 
-	protected void decompileAndCheck(JadxDecompiler d, List<ClassNode> clsList) {
+	protected void decompileAndCheck(ClassNode cls) {
+		decompileAndCheck(Collections.singletonList(cls));
+	}
+
+	protected void decompileAndCheck(List<ClassNode> clsList) {
 		if (!unloadCls) {
 			clsList.forEach(cls -> cls.add(AFlag.DONT_UNLOAD_CLASS));
 		}
@@ -207,6 +218,14 @@ public abstract class IntegrationTest extends TestUtils {
 			clsList.forEach(this::printSmali);
 		}
 
+		runChecks(clsList);
+	}
+
+	public void runChecks(ClassNode cls) {
+		runChecks(Collections.singletonList(cls));
+	}
+
+	protected void runChecks(List<ClassNode> clsList) {
 		clsList.forEach(this::checkCode);
 		compile(clsList);
 		clsList.forEach(this::runAutoCheck);

jadx-core/src/test/java/jadx/tests/api/SmaliTest.java

@@ -57,7 +57,7 @@ public abstract class SmaliTest extends IntegrationTest {
 		jadxDecompiler = loadFiles(collectSmaliFiles(getTestPkg(), getTestName()));
 		RootNode root = JadxInternalAccess.getRoot(jadxDecompiler);
 		List<ClassNode> classes = root.getClasses(false);
-		decompileAndCheck(jadxDecompiler, classes);
+		decompileAndCheck(classes);
 		return classes;
 	}
 

jadx-core/src/test/java/jadx/tests/api/utils/assertj/JadxClassNodeAssertions.java

 package jadx.tests.api.utils.assertj;
 
-import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.AbstractObjectAssert;
 
 import jadx.api.ICodeInfo;
 import jadx.core.dex.nodes.ClassNode;
+import jadx.tests.api.IntegrationTest;
 
 import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
 
-public class JadxClassNodeAssertions extends AbstractAssert<JadxClassNodeAssertions, ClassNode> {
+public class JadxClassNodeAssertions extends AbstractObjectAssert<JadxClassNodeAssertions, ClassNode> {
 	public JadxClassNodeAssertions(ClassNode cls) {
 		super(cls, JadxClassNodeAssertions.class);
 	}
@@ -20,4 +21,17 @@ public class JadxClassNodeAssertions extends AbstractAssert<JadxClassNodeAsserti
 		assertThat(codeStr).isNotBlank();
 		return new JadxCodeAssertions(codeStr);
 	}
+
+	public JadxCodeAssertions reloadCode(IntegrationTest testInstance) {
+		isNotNull();
+		ICodeInfo code = actual.reloadCode();
+		assertThat(code).isNotNull();
+		String codeStr = code.getCodeStr();
+		assertThat(codeStr).isNotBlank();
+
+		JadxCodeAssertions codeAssertions = new JadxCodeAssertions(codeStr);
+		codeAssertions.print();
+		testInstance.runChecks(actual);
+		return codeAssertions;
+	}
 }

jadx-core/src/test/java/jadx/tests/integration/rename/TestAnonymousInline.java

@@ -23,12 +23,11 @@ public class TestAnonymousInline extends IntegrationTest {
 	@Test
 	public void test() {
 		ClassNode cls = getClassNode(TestCls.class);
-		assertThat(cls.getCode())
+		assertThat(cls).code()
 				.containsOnlyOnce("return new Runnable() {");
 
-		assertThat(cls.reloadCode())
+		assertThat(cls).reloadCode(this)
 				.removeBlockComments() // remove comment about inlined class
-				.print()
 				.containsOnlyOnce("return new Runnable() {")
 				.doesNotContain("AnonymousClass1");
 	}

jadx-core/src/test/java/jadx/tests/integration/rename/TestConstReplace.java

@@ -20,11 +20,10 @@ public class TestConstReplace extends IntegrationTest {
 	@Test
 	public void test() {
 		ClassNode cls = getClassNode(TestCls.class);
-		assertThat(cls.getCode())
+		assertThat(cls).code()
 				.containsOnlyOnce("return CONST;");
 
-		assertThat(cls.reloadCode())
-				.print()
+		assertThat(cls).reloadCode(this)
 				.containsOnlyOnce("return CONST;");
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/rename/TestFieldWithGenericRename.java

@@ -18,10 +18,12 @@ public class TestFieldWithGenericRename extends IntegrationTest {
 	@Test
 	public void test() {
 		ClassNode cls = getClassNode(TestCls.class);
-		assertThat(cls.getCode()).containsOnlyOnce("List<String> list;");
+		assertThat(cls).code()
+				.containsOnlyOnce("List<String> list;");
 
 		cls.searchFieldByName("list").getFieldInfo().setAlias("listFieldRenamed");
 
-		assertThat(cls.reloadCode()).print().containsOnlyOnce("List<String> listFieldRenamed;");
+		assertThat(cls).reloadCode(this)
+				.containsOnlyOnce("List<String> listFieldRenamed;");
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/rename/TestRenameEnum.java

@@ -30,14 +30,13 @@ public class TestRenameEnum extends IntegrationTest {
 	@Test
 	public void test() {
 		ClassNode cls = getClassNode(TestCls.class);
-		assertThat(cls.getCode())
+		assertThat(cls).code()
 				.containsOnlyOnce("public enum A ")
 				.containsOnlyOnce("ONE {");
 
 		cls.getInnerClasses().get(0).getClassInfo().changeShortName("ARenamed");
 
-		assertThat(cls.reloadCode())
-				.print()
+		assertThat(cls).reloadCode(this)
 				.containsOnlyOnce("public enum ARenamed ")
 				.containsOnlyOnce("ONE {");
 	}