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

Implement base zip cache with tests...

Browse Source 
plus some relevant fixes and refactorings
This commit is contained in:
Ilya Chernikov
2019-07-24 18:47:55 +02:00
parent c7eb9e9520
commit 42dde50b6b
6 changed files with 164 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/scripting/jvm-host-test/test/kotlin/script/experimental/jvmhost/test/CachingTest.kt
+77 -12
View File
@@ -16,11 +16,14 @@ import java.nio.file.Files
import java.security.MessageDigest
import kotlin.script.experimental.api.*
import kotlin.script.experimental.host.toScriptSource
import kotlin.script.experimental.jvm.BasicJvmScriptEvaluator
import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
import kotlin.script.experimental.host.with
import kotlin.script.experimental.jvm.*
import kotlin.script.experimental.jvm.impl.KJvmCompiledScript
import kotlin.script.experimental.jvmhost.*
import kotlin.script.templates.standard.SimpleScriptTemplate
import kotlin.script.experimental.jvm.util.KotlinJars
import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
import kotlin.script.experimental.jvmhost.CompiledJvmScriptsCache
import kotlin.script.experimental.jvmhost.CompiledScriptJarsCache
import kotlin.script.experimental.jvmhost.JvmScriptCompiler
class CachingTest : TestCase() {
@@ -63,16 +66,53 @@ class CachingTest : TestCase() {
}
}
@Test
fun testJarCache() {
withTempDir("scriptingTestJarCache") { cacheDir ->
val cache = TestCompiledScriptJarsCache(cacheDir)
Assert.assertTrue(cache.baseDir.listFiles()!!.isEmpty())
checkWithCache(cache, simpleScript, simpleScriptExpectedOutput)
val scriptOut = runScriptFromJar(cache.baseDir.listFiles()!!.first { it.extension == "jar" })
Assert.assertEquals(simpleScriptExpectedOutput, scriptOut)
}
}
@Test
fun testSimpleImportWithJarCache() {
withTempDir("scriptingTestJarCache") { cacheDir ->
val cache = TestCompiledScriptJarsCache(cacheDir)
Assert.assertTrue(cache.baseDir.listFiles()!!.isEmpty())
checkWithCache(cache, scriptWithImport, scriptWithImportExpectedOutput) { makeSimpleConfigurationWithTestImport() }
// cannot make it work in this form - it requires a dependency on the current test classes, but classes directory seems
// not work when specified in the manifest
// TODO: find a way to make it work
// val scriptOut = runScriptFromJar(cache.baseDir.listFiles()!!.first { it.extension == "jar" })
//
// Assert.assertEquals(scriptWithImportExpectedOutput, scriptOut)
}
}
private fun checkWithCache(
cache: ScriptingCacheWithCounters, script: String, expectedOutput: List<String>,
configurationBuilder: ScriptCompilationConfiguration.Builder.() -> Unit = {}
) {
val compiler = JvmScriptCompiler(defaultJvmScriptingHostConfiguration, cache = cache)
val hostConfiguration = defaultJvmScriptingHostConfiguration.with {
jvm {
baseClassLoader.replaceOnlyDefault(null)
}
}
val compiler = JvmScriptCompiler(hostConfiguration, cache = cache)
val evaluator = BasicJvmScriptEvaluator()
val host = BasicJvmScriptingHost(compiler = compiler, evaluator = evaluator)
val scriptCompilationConfiguration =
createJvmCompilationConfigurationFromTemplate<SimpleScriptTemplate>(body = configurationBuilder)
val scriptCompilationConfiguration = ScriptCompilationConfiguration(body = configurationBuilder).with {
updateClasspath(KotlinJars.kotlinScriptStandardJarsWithReflect)
}
Assert.assertEquals(0, cache.storedScripts)
var compiledScript: CompiledScript<*>? = null
@@ -95,11 +135,11 @@ class CachingTest : TestCase() {
val compiledScriptClassRes = runBlocking { compiledScript!!.getClass(null) }
val cachedScriptClassRes = runBlocking { cachedScript!!.getClass(null) }
val compiledScriptClass = compiledScriptClassRes.valueOrNull()
val cachedScriptClass = cachedScriptClassRes.valueOrNull()
val compiledScriptClass = compiledScriptClassRes.valueOrThrow()
val cachedScriptClass = cachedScriptClassRes.valueOrThrow()
Assert.assertEquals(compiledScriptClass!!.qualifiedName, cachedScriptClass!!.qualifiedName)
Assert.assertEquals(compiledScriptClass!!.supertypes, cachedScriptClass!!.supertypes)
Assert.assertEquals(compiledScriptClass.qualifiedName, cachedScriptClass.qualifiedName)
Assert.assertEquals(compiledScriptClass.supertypes, cachedScriptClass.supertypes)
val output2 = captureOut {
runBlocking {
@@ -108,7 +148,9 @@ class CachingTest : TestCase() {
}.lines()
Assert.assertEquals(output, output2)
val output3 = captureOut { evalScriptWithConfiguration(script, host, configurationBuilder).throwOnFailure() }.lines()
val output3 = captureOut {
host.eval(script.toScriptSource(), scriptCompilationConfiguration, null).throwOnFailure()
}.lines()
Assert.assertEquals(2, cache.retrievedScripts)
Assert.assertEquals(output, output3)
}
@@ -174,6 +216,29 @@ private class FileBasedScriptCache(val baseDir: File) : ScriptingCacheWithCounte
private set
}
class TestCompiledScriptJarsCache(val baseDir: File) : CompiledScriptJarsCache(
{ script, scriptCompilationConfiguration ->
File(baseDir, uniqueScriptHash(script, scriptCompilationConfiguration) + ".jar")
}), ScriptingCacheWithCounters
{
override fun get(script: SourceCode, scriptCompilationConfiguration: ScriptCompilationConfiguration): CompiledScript<*>? =
super.get(script, scriptCompilationConfiguration)?.also { retrievedScripts++ }
override fun store(
compiledScript: CompiledScript<*>,
script: SourceCode,
scriptCompilationConfiguration: ScriptCompilationConfiguration
) {
super.store(compiledScript, script, scriptCompilationConfiguration).also { storedScripts++ }
}
override var storedScripts: Int = 0
private set
override var retrievedScripts: Int = 0
private set
}
internal fun uniqueScriptHash(script: SourceCode, scriptCompilationConfiguration: ScriptCompilationConfiguration): String {
val digestWrapper = MessageDigest.getInstance("MD5")
digestWrapper.update(script.text.toByteArray())
libraries/scripting/jvm-host-test/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt
+8 -5
View File
@@ -14,8 +14,9 @@ import org.jetbrains.org.objectweb.asm.ClassVisitor
import org.jetbrains.org.objectweb.asm.Opcodes
import org.junit.Assert
import org.junit.Test
import java.io.*
import java.lang.RuntimeException
import java.io.ByteArrayOutputStream
import java.io.File
import java.io.PrintStream
import java.net.URLClassLoader
import java.nio.file.Files
import java.util.concurrent.TimeUnit
@@ -161,7 +162,7 @@ class ScriptingHostTest : TestCase() {
checkInvokeMain(Thread.currentThread().contextClassLoader)
val outputFromProcess = runScriptFromJar(outJar)
Assert.assertEquals(greeting, outputFromProcess)
Assert.assertEquals(listOf(greeting), outputFromProcess)
}
@Test
@@ -373,12 +374,12 @@ class ScriptingHostTest : TestCase() {
}
}
internal fun runScriptFromJar(jar: File): String {
internal fun runScriptFromJar(jar: File): List<String> {
val javaExecutable = File(File(System.getProperty("java.home"), "bin"), "java")
val args = listOf(javaExecutable.absolutePath, "-jar", jar.path)
val processBuilder = ProcessBuilder(args)
processBuilder.redirectErrorStream(true)
return run {
val r = run {
val process = processBuilder.start()
process.waitFor(10, TimeUnit.SECONDS)
val out = process.inputStream.reader().readText()
@@ -389,6 +390,7 @@ internal fun runScriptFromJar(jar: File): String {
out
}
}.trim()
return r.lineSequence().map { it.trim() }.toList()
}
fun <T> ResultWithDiagnostics<T>.throwOnFailure(): ResultWithDiagnostics<T> = apply {
@@ -421,6 +423,7 @@ internal fun evalScriptWithConfiguration(
}
internal fun ScriptCompilationConfiguration.Builder.makeSimpleConfigurationWithTestImport() {
updateClasspath(classpathFromClass<ScriptingHostTest>()) // the lambda below should be in the classpath
refineConfiguration {
beforeCompiling { ctx ->
val importedScript = File(ScriptingHostTest.TEST_DATA_DIR, "importTest/helloWithVal.kts")