azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert CodegenTestsOnAndroidRunner to Kotlin

Browse Source
This commit is contained in:
Mikhael Bogdanov
2017-10-23 11:48:07 +02:00
parent 37300f7486
commit dd24ba6978
1 changed files with 106 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/android-tests/src/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidRunner.kt
+106 -121
View File
@@ -14,172 +14,157 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.android.tests; package org.jetbrains.kotlin.android.tests
import com.intellij.util.PlatformUtils; import com.intellij.util.PlatformUtils
import junit.framework.TestCase; import junit.framework.TestCase
import junit.framework.TestSuite; import junit.framework.TestSuite
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.android.tests.download.SDKDownloader
import org.jetbrains.kotlin.android.tests.download.SDKDownloader; import org.jetbrains.kotlin.android.tests.emulator.Emulator
import org.jetbrains.kotlin.android.tests.emulator.Emulator; import org.jetbrains.kotlin.android.tests.gradle.GradleRunner
import org.jetbrains.kotlin.android.tests.gradle.GradleRunner; import org.jetbrains.kotlin.android.tests.run.PermissionManager
import org.jetbrains.kotlin.android.tests.run.PermissionManager; import org.junit.Assert
import org.junit.Assert; import org.w3c.dom.Element
import org.w3c.dom.Document; import org.xml.sax.SAXException
import org.w3c.dom.Element; import java.io.File
import org.w3c.dom.NodeList; import java.io.IOException
import org.xml.sax.SAXException; import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.parsers.ParserConfigurationException
import javax.xml.parsers.DocumentBuilder; class CodegenTestsOnAndroidRunner private constructor(private val pathManager: PathManager) {
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class CodegenTestsOnAndroidRunner { private fun generateTestSuite(): TestSuite {
val rootSuite = TestSuite("Root")
private final PathManager pathManager; downloadDependencies()
val emulator = Emulator(pathManager, Emulator.ARM)
emulator.createEmulator()
public static TestSuite getTestSuite(PathManager pathManager) { val gradleRunner = GradleRunner(pathManager)
return new CodegenTestsOnAndroidRunner(pathManager).generateTestSuite();
}
private CodegenTestsOnAndroidRunner(PathManager pathManager) {
this.pathManager = pathManager;
}
private TestSuite generateTestSuite() {
TestSuite rootSuite = new TestSuite("Root");
downloadDependencies();
Emulator emulator = new Emulator(pathManager, Emulator.ARM);
emulator.createEmulator();
GradleRunner gradleRunner = new GradleRunner(pathManager);
//old dex //old dex
cleanAndBuildProject(gradleRunner); cleanAndBuildProject(gradleRunner)
try { try {
emulator.startEmulator(); emulator.startEmulator()
try { try {
emulator.waitEmulatorStart(); emulator.waitEmulatorStart()
runTestsOnEmulator(gradleRunner, TestSuite("Dex")).apply {
rootSuite.addTest(this)
}
TestSuite dex = runTestsOnEmulator(gradleRunner, new TestSuite("Dex"));
rootSuite.addTest(dex);
} }
catch (RuntimeException e) { catch (e: RuntimeException) {
e.printStackTrace(); e.printStackTrace()
throw e; throw e
} }
finally { finally {
emulator.stopEmulator(); emulator.stopEmulator()
} }
} }
catch (RuntimeException e) { catch (e: RuntimeException) {
e.printStackTrace(); e.printStackTrace()
throw e; throw e
} }
finally { finally {
emulator.finishEmulatorProcesses(); emulator.finishEmulatorProcesses()
} }
return rootSuite; return rootSuite
} }
private void processReport(TestSuite suite, String resultOutput) { private fun processReport(suite: TestSuite, resultOutput: String) {
String reportFolder = pathManager.getTmpFolder() + "/build/outputs/androidTest-results/connected"; val reportFolder = pathManager.tmpFolder + "/build/outputs/androidTest-results/connected"
try { try {
List<TestCase> testCases = parseSingleReportInFolder(reportFolder); val testCases = parseSingleReportInFolder(reportFolder)
for (TestCase aCase : testCases) { testCases.forEach { aCase -> suite.addTest(aCase) }
suite.addTest(aCase); Assert.assertNotEquals("There is no test results in report", 0, testCases.size.toLong())
}
Assert.assertNotEquals("There is no test results in report", 0, testCases.size());
} }
catch (Exception e) { catch (e: Exception) {
throw new RuntimeException("Can't parse test results in " + reportFolder +"\n" + resultOutput); throw RuntimeException("Can't parse test results in " + reportFolder + "\n" + resultOutput)
} }
} }
@Nullable private fun runTestsOnEmulator(gradleRunner: GradleRunner, suite: TestSuite): TestSuite? {
private TestSuite runTestsOnEmulator(GradleRunner gradleRunner, TestSuite suite) { val platformPrefixProperty = System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, "Idea")
String platformPrefixProperty = System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, "Idea");
try { try {
String resultOutput = gradleRunner.connectedDebugAndroidTest(); val resultOutput = gradleRunner.connectedDebugAndroidTest()
processReport(suite, resultOutput); processReport(suite, resultOutput)
return suite; return suite
} }
finally { finally {
if (platformPrefixProperty != null) { if (platformPrefixProperty != null) {
System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, platformPrefixProperty); System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, platformPrefixProperty)
} }
else { else {
System.clearProperty(PlatformUtils.PLATFORM_PREFIX_KEY); System.clearProperty(PlatformUtils.PLATFORM_PREFIX_KEY)
} }
} }
} }
private static void cleanAndBuildProject(GradleRunner gradleRunner) { private fun downloadDependencies() {
gradleRunner.clean(); val rootForAndroidDependencies = File(pathManager.dependenciesRoot)
gradleRunner.build();
}
private void downloadDependencies() {
File rootForAndroidDependencies = new File(pathManager.getDependenciesRoot());
if (!rootForAndroidDependencies.exists()) { if (!rootForAndroidDependencies.exists()) {
rootForAndroidDependencies.mkdirs(); rootForAndroidDependencies.mkdirs()
} }
SDKDownloader downloader = new SDKDownloader(pathManager); val downloader = SDKDownloader(pathManager)
downloader.downloadAll(); downloader.downloadAll()
downloader.unzipAll(); downloader.unzipAll()
PermissionManager.setPermissions(pathManager); PermissionManager.setPermissions(pathManager)
} }
private static List<TestCase> parseSingleReportInFolder(String reportFolder) throws companion object {
IOException,
SAXException,
ParserConfigurationException {
File folder = new File(reportFolder);
File[] files = folder.listFiles();
assert files != null;
assert files.length == 1;
File reportFile = files[0];
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); @JvmStatic
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); fun getTestSuite(pathManager: PathManager): TestSuite {
Document doc = dBuilder.parse(reportFile); return CodegenTestsOnAndroidRunner(pathManager).generateTestSuite()
Element root = doc.getDocumentElement();
NodeList testCases = root.getElementsByTagName("testcase");
List<TestCase> result = new ArrayList(testCases.getLength());
for (int i = 0; i < testCases.getLength(); i++) {
Element item = (Element) testCases.item(i);
NodeList failure = item.getElementsByTagName("failure");
String name = item.getAttribute("name");
String clazz = item.getAttribute("classname");
if (failure.getLength() == 0) {
result.add(new TestCase(name) {
@Override
protected void runTest() throws Throwable {
}
});
}
else {
result.add(new TestCase(name) {
@Override
protected void runTest() throws Throwable {
Assert.fail(failure.item(0).getTextContent());
}
});
}
} }
return result; private fun cleanAndBuildProject(gradleRunner: GradleRunner) {
gradleRunner.clean()
gradleRunner.build()
}
@Throws(IOException::class, SAXException::class, ParserConfigurationException::class)
private fun parseSingleReportInFolder(reportFolder: String): List<TestCase> {
val folder = File(reportFolder)
val files = folder.listFiles()!!
assert(files.size == 1)
val reportFile = files[0]
val dbFactory = DocumentBuilderFactory.newInstance()
val dBuilder = dbFactory.newDocumentBuilder()
val doc = dBuilder.parse(reportFile)
val root = doc.documentElement
val testCases = root.getElementsByTagName("testcase")
return (0 until testCases.length).map { i ->
val item = testCases.item(i) as Element
val failure = item.getElementsByTagName("failure")
val name = item.getAttribute("name")
val clazz = item.getAttribute("classname")
if (failure.length == 0) {
object : TestCase(name) {
@Throws(Throwable::class)
override fun runTest() {
}
}
}
else {
object : TestCase(name) {
@Throws(Throwable::class)
override fun runTest() {
Assert.fail(failure.item(0).textContent)
}
}
}
}
}
} }
} }