diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/internal/MinimizeSpecsTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/internal/MinimizeSpecsTest.kt index afd087e31..8aef617e7 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/internal/MinimizeSpecsTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/internal/MinimizeSpecsTest.kt @@ -16,65 +16,59 @@ class MinimizeSpecsTest { private val project = ProjectBuilder.builder().build() @Test - fun defaultMinimizeSpecUsesDependencyAnalyzer() { - val spec = project.objects.newInstance(DefaultMinimizeSpec::class.java, project) - - assertThat(spec.tool.get()).isEqualTo(MinimizeTool.DEPENDENCY_ANALYZER) - assertThat(spec.r8SpecForInputs).isNull() - } + fun defaultMinimizeSpecUsesDependencyAnalyzer() = + with(project.objects.newInstance(DefaultMinimizeSpec::class.java, project)) { + assertThat(tool.get()).isEqualTo(MinimizeTool.DEPENDENCY_ANALYZER) + assertThat(r8SpecForInputs).isNull() + } @Test - fun r8ConfiguresToolAndExposesSameSpecAsInput() { - val spec = project.objects.newInstance(DefaultMinimizeSpec::class.java, project) - lateinit var configured: Any - - spec.r8 { configured = it } + fun r8ConfiguresToolAndExposesSameSpecAsInput() = + with(project.objects.newInstance(DefaultMinimizeSpec::class.java, project)) { + lateinit var configured: Any + r8 { configured = it } - assertThat(spec.tool.get()).isEqualTo(MinimizeTool.R8) - assertThat(spec.r8SpecForInputs).isSameInstanceAs(configured) - assertThat(spec.r8Spec).isSameInstanceAs(configured) - } + assertThat(tool.get()).isEqualTo(MinimizeTool.R8) + assertThat(r8SpecForInputs).isSameInstanceAs(configured) + assertThat(r8Spec).isSameInstanceAs(configured) + } @Test - fun defaultR8SpecIsShrinkOnly() { - val spec = project.objects.newInstance(DefaultR8Spec::class.java) - - assertThat(spec.args.get()).containsExactly(DefaultR8Spec.NO_MINIFICATION_ARG) - assertThat(spec.obfuscationEnabled.get()).isFalse() - assertThat(spec.optimizationEnabled.get()).isFalse() - assertThat(spec.keepRules.get()).isEmpty() - assertThat(spec.keepRuleFiles.files).isEmpty() - } + fun defaultR8SpecIsShrinkOnly() = + with(project.objects.newInstance(DefaultR8Spec::class.java)) { + assertThat(args.get()).containsExactly(DefaultR8Spec.NO_MINIFICATION_ARG) + assertThat(obfuscationEnabled.get()).isFalse() + assertThat(optimizationEnabled.get()).isFalse() + assertThat(keepRules.get()).isEmpty() + assertThat(keepRuleFiles.files).isEmpty() + } @Test - fun enablingObfuscationRemovesDefaultArgument() { - val spec = project.objects.newInstance(DefaultR8Spec::class.java) + fun enablingObfuscationRemovesDefaultArgument() = + with(project.objects.newInstance(DefaultR8Spec::class.java)) { + enableObfuscation() - spec.enableObfuscation() - - assertThat(spec.args.get()).isEmpty() - assertThat(spec.obfuscationEnabled.get()).isTrue() - assertThat(spec.optimizationEnabled.get()).isFalse() - } + assertThat(args.get()).isEmpty() + assertThat(obfuscationEnabled.get()).isTrue() + assertThat(optimizationEnabled.get()).isFalse() + } @Test - fun enablingOptimizationOnlyChangesOptimizationFlag() { - val spec = project.objects.newInstance(DefaultR8Spec::class.java) - - spec.enableOptimization() + fun enablingOptimizationOnlyChangesOptimizationFlag() = + with(project.objects.newInstance(DefaultR8Spec::class.java)) { + enableOptimization() - assertThat(spec.args.get()).containsExactly(DefaultR8Spec.NO_MINIFICATION_ARG) - assertThat(spec.obfuscationEnabled.get()).isFalse() - assertThat(spec.optimizationEnabled.get()).isTrue() - } + assertThat(args.get()).containsExactly(DefaultR8Spec.NO_MINIFICATION_ARG) + assertThat(obfuscationEnabled.get()).isFalse() + assertThat(optimizationEnabled.get()).isTrue() + } @Test - fun explicitArgumentsTakePrecedenceOverChangedDefaults() { - val spec = project.objects.newInstance(DefaultR8Spec::class.java) - spec.args.set(listOf("--debug")) - - spec.enableObfuscation() + fun explicitArgumentsTakePrecedenceOverChangedDefaults() = + with(project.objects.newInstance(DefaultR8Spec::class.java)) { + args.set(listOf("--debug")) + enableObfuscation() - assertThat(spec.args.get()).containsExactly("--debug") - } + assertThat(args.get()).containsExactly("--debug") + } } diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheLicenseResourceTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheLicenseResourceTransformerTest.kt index 887c479df..f48c65a8a 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheLicenseResourceTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheLicenseResourceTransformerTest.kt @@ -17,20 +17,22 @@ class ApacheLicenseResourceTransformerTest : } @Test - fun canTransformResource() { - assertThat(transformer.canTransformResource("META-INF/LICENSE")).isTrue() - assertThat(transformer.canTransformResource("META-INF/LICENSE.TXT")).isTrue() - assertThat(transformer.canTransformResource("META-INF/License.txt")).isTrue() - assertThat(transformer.canTransformResource("META-INF/LICENSE.md")).isTrue() - assertThat(transformer.canTransformResource("META-INF/License.md")).isTrue() - assertThat(transformer.canTransformResource("META-INF/MANIFEST.MF")).isFalse() - } + fun canTransformResource() = + with(transformer) { + assertThat(canTransformResource("META-INF/LICENSE")).isTrue() + assertThat(canTransformResource("META-INF/LICENSE.TXT")).isTrue() + assertThat(canTransformResource("META-INF/License.txt")).isTrue() + assertThat(canTransformResource("META-INF/LICENSE.md")).isTrue() + assertThat(canTransformResource("META-INF/License.md")).isTrue() + assertThat(canTransformResource("META-INF/MANIFEST.MF")).isFalse() + } @Test - fun canTransformByPattern() { - transformer.exclude("META-INF/LICENSE.txt") - transformer.include("META-INF/LICENSE.*") - assertThat(transformer.canTransformResource("META-INF/LICENSE.txt")).isFalse() - assertThat(transformer.canTransformResource("META-INF/LICENSE.log")).isTrue() - } + fun canTransformByPattern() = + with(transformer) { + exclude("META-INF/LICENSE.txt") + include("META-INF/LICENSE.*") + assertThat(canTransformResource("META-INF/LICENSE.txt")).isFalse() + assertThat(canTransformResource("META-INF/LICENSE.log")).isTrue() + } } diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheNoticeResourceTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheNoticeResourceTransformerTest.kt index f525b6f34..2439d45a3 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheNoticeResourceTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheNoticeResourceTransformerTest.kt @@ -21,39 +21,42 @@ class ApacheNoticeResourceTransformerTest : BaseTransformerTest() { } @Test - fun canTransformResource() { - transformer.resource.set("abcdefghijklmnopqrstuvwxyz") + fun canTransformResource() = + with(transformer) { + resource.set("abcdefghijklmnopqrstuvwxyz") - assertThat(transformer.canTransformResource("abcdefghijklmnopqrstuvwxyz")).isTrue() - assertThat(transformer.canTransformResource("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).isTrue() - assertThat(transformer.canTransformResource("META-INF/MANIFEST.MF")).isFalse() - } + assertThat(canTransformResource("abcdefghijklmnopqrstuvwxyz")).isTrue() + assertThat(canTransformResource("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).isTrue() + assertThat(canTransformResource("META-INF/MANIFEST.MF")).isFalse() + } } diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ComponentsXmlResourceTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ComponentsXmlResourceTransformerTest.kt index 838cf710c..ee999d03b 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ComponentsXmlResourceTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ComponentsXmlResourceTransformerTest.kt @@ -14,16 +14,17 @@ import org.junit.jupiter.api.Test class ComponentsXmlResourceTransformerTest : BaseTransformerTest() { @Test - fun configurationMerging() { - XMLUnit.setNormalizeWhitespace(true) - transformer.transform(resourceContext("components-1.xml")) - transformer.transform(resourceContext("components-2.xml")) + fun configurationMerging() = + with(transformer) { + XMLUnit.setNormalizeWhitespace(true) + transform(resourceContext("components-1.xml")) + transform(resourceContext("components-2.xml")) - val diff = - XMLUnit.compareXML( - requireResourceAsPath("components-expected.xml").readText(), - transformer.transformedResource.decodeToString(), - ) - assertThat(diff.identical()).isTrue() - } + val diff = + XMLUnit.compareXML( + requireResourceAsPath("components-expected.xml").readText(), + transformedResource.decodeToString(), + ) + assertThat(diff.identical()).isTrue() + } } diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/Log4j2PluginsCacheFileTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/Log4j2PluginsCacheFileTransformerTest.kt index a6fecafd2..ff3992c28 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/Log4j2PluginsCacheFileTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/Log4j2PluginsCacheFileTransformerTest.kt @@ -34,77 +34,81 @@ import org.junit.jupiter.params.provider.MethodSource class Log4j2PluginsCacheFileTransformerTest : BaseTransformerTest() { @Test - fun canTransformResource() { - assertThat(transformer.canTransformResource("")).isFalse() - assertThat(transformer.canTransformResource(".")).isFalse() - assertThat(transformer.canTransformResource("tmp.dat")).isFalse() - assertThat(transformer.canTransformResource("$PLUGIN_CACHE_FILE.tmp")).isFalse() - assertThat(transformer.canTransformResource("tmp/$PLUGIN_CACHE_FILE")).isFalse() - assertThat(transformer.canTransformResource(PLUGIN_CACHE_FILE)).isTrue() - } + fun canTransformResource() = + with(transformer) { + assertThat(canTransformResource("")).isFalse() + assertThat(canTransformResource(".")).isFalse() + assertThat(canTransformResource("tmp.dat")).isFalse() + assertThat(canTransformResource("$PLUGIN_CACHE_FILE.tmp")).isFalse() + assertThat(canTransformResource("tmp/$PLUGIN_CACHE_FILE")).isFalse() + assertThat(canTransformResource(PLUGIN_CACHE_FILE)).isTrue() + } @Test - fun relocateClassesInsideDatFile() { - val relocator = SimpleRelocator("org.apache.logging", "new.location.org.apache.logging") - transformer.transform(context(relocator)) - assertThat(transformer.hasTransformedResource()).isTrue() + fun relocateClassesInsideDatFile() = + with(transformer) { + val relocator = SimpleRelocator("org.apache.logging", "new.location.org.apache.logging") + transform(context(relocator)) + assertThat(hasTransformedResource()).isTrue() - val tempJar = createTempFile("testable-zip-file-", ".jar") - tempJar.outputStream().zipOutputStream().use { zos -> - transformer.modifyOutputStream(zos, true) - } + val tempJar = createTempFile("testable-zip-file-", ".jar") + tempJar.outputStream().zipOutputStream().use { zos -> + modifyOutputStream(zos, true) + } - // Pull the data back out and make sure it was transformed - val cache = PluginCache() - val url = URI("jar:" + tempJar.toUri().toURL() + "!/" + PLUGIN_CACHE_FILE).toURL() - cache.loadCacheFiles(Collections.enumeration(listOf(url))) + // Pull the data back out and make sure it was transformed + val cache = PluginCache() + val url = URI("jar:" + tempJar.toUri().toURL() + "!/" + PLUGIN_CACHE_FILE).toURL() + cache.loadCacheFiles(Collections.enumeration(listOf(url))) - assertThat(cache.getCategory("lookup")["date"]?.className) - .isEqualTo("new.location.org.apache.logging.log4j.core.lookup.DateLookup") - } + assertThat(cache.getCategory("lookup")["date"]?.className) + .isEqualTo("new.location.org.apache.logging.log4j.core.lookup.DateLookup") + } @Test - fun transformAndModifyOutputStream() { - assertThat(transformer.hasTransformedResource()).isFalse() + fun transformAndModifyOutputStream() = + with(transformer) { + assertThat(hasTransformedResource()).isFalse() - transformer.transform(context()) - assertThat(transformer.hasTransformedResource()).isTrue() - transformer.transform(context()) - assertThat(transformer.hasTransformedResource()).isTrue() + transform(context()) + assertThat(hasTransformedResource()).isTrue() + transform(context()) + assertThat(hasTransformedResource()).isTrue() - val jarBuff = ByteArrayOutputStream() - ZipOutputStream(jarBuff).use { transformer.modifyOutputStream(it, false) } - JarInputStream(jarBuff.toByteArray().inputStream()).use { inputStream -> - while (true) { - val jarEntry = inputStream.nextJarEntry - if (jarEntry == null) { - fail("No expected resource in the output jar.") - } else if (jarEntry.name == PLUGIN_CACHE_FILE) { - assertThat(inputStream.readAllBytes().contentHashCode()).all { - // Hash of the original plugin cache file. - isNotEqualTo(-2114104185) - isEqualTo(1911442937) + val jarBuff = ByteArrayOutputStream() + ZipOutputStream(jarBuff).use { modifyOutputStream(it, false) } + JarInputStream(jarBuff.toByteArray().inputStream()).use { inputStream -> + while (true) { + val jarEntry = inputStream.nextJarEntry + if (jarEntry == null) { + fail("No expected resource in the output jar.") + } else if (jarEntry.name == PLUGIN_CACHE_FILE) { + assertThat(inputStream.readAllBytes().contentHashCode()).all { + // Hash of the original plugin cache file. + isNotEqualTo(-2114104185) + isEqualTo(1911442937) + } + break } - break } } } - } @ParameterizedTest @MethodSource("relocationProvider") - fun relocations(pattern: String, shadedPattern: String, expected: String) { - val aggregator = - PluginCache().apply { loadCacheFiles(Collections.enumeration(listOf(pluginCacheUrl))) } - transformer.transform(context(SimpleRelocator(pattern, shadedPattern))) - transformer.relocatePlugins(aggregator) + fun relocations(pattern: String, shadedPattern: String, expected: String) = + with(transformer) { + val aggregator = + PluginCache().apply { loadCacheFiles(Collections.enumeration(listOf(pluginCacheUrl))) } + transform(context(SimpleRelocator(pattern, shadedPattern))) + relocatePlugins(aggregator) - for (pluginEntryMap in aggregator.allCategories.values) { - for (entry in pluginEntryMap.values) { - assertThat(entry.className).startsWith(expected) + for (pluginEntryMap in aggregator.allCategories.values) { + for (entry in pluginEntryMap.values) { + assertThat(entry.className).startsWith(expected) + } } } - } private companion object { val pluginCacheUrl: URL = requireResourceAsPath(PLUGIN_CACHE_FILE).toUri().toURL() diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ManifestAppenderTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ManifestAppenderTransformerTest.kt index bf34d2f68..9e2549e9d 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ManifestAppenderTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ManifestAppenderTransformerTest.kt @@ -23,11 +23,12 @@ class ManifestAppenderTransformerTest : BaseTransformerTest() { @Test - fun hasTransformedResource() { - transformer.transform(manifestTransformerContext) + fun hasTransformedResource() = + with(transformer) { + transform(manifestTransformerContext) - assertThat(transformer.hasTransformedResource()).isTrue() - } + assertThat(hasTransformedResource()).isTrue() + } @Test fun hasNotTransformedResource() { @@ -31,27 +32,27 @@ class PropertiesFileTransformerTest : BaseTransformerTest, expectedOutput: Map, expectedConflicts: Map>, - ) { - transformer.mergeStrategy.set(MergeStrategy.from(mergeStrategy)) - transformer.mergeSeparator.set(mergeSeparator) - - if (transformer.canTransformResource(path)) { - transformer.transform(context(path, input1)) - transformer.transform(context(path, input2)) + ) = + with(transformer) { + this.mergeStrategy.set(MergeStrategy.from(mergeStrategy)) + this.mergeSeparator.set(mergeSeparator) + + if (canTransformResource(path)) { + transform(context(path, input1)) + transform(context(path, input2)) + } + + assertThat(propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) + assertThat(conflicts).isEqualTo(expectedConflicts) } - assertThat(transformer.propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) - assertThat(transformer.conflicts).isEqualTo(expectedConflicts) - } - @ParameterizedTest @MethodSource("transformConfigWithPathsProvider") fun exerciseAllTransformConfigurationsWithPaths( @@ -90,17 +92,18 @@ class PropertiesFileTransformerTest : BaseTransformerTest, input2: Map, expectedOutput: Map, - ) { - transformer.paths.set(paths) - transformer.mergeStrategy.set(MergeStrategy.First) + ) = + with(transformer) { + this.paths.set(paths) + mergeStrategy.set(MergeStrategy.First) - if (transformer.canTransformResource(path)) { - transformer.transform(context(path, input1)) - transformer.transform(context(path, input2)) - } + if (canTransformResource(path)) { + transform(context(path, input1)) + transform(context(path, input2)) + } - assertThat(transformer.propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) - } + assertThat(propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) + } @ParameterizedTest @MethodSource("transformConfigWithMappingsProvider") @@ -110,17 +113,18 @@ class PropertiesFileTransformerTest : BaseTransformerTest, input2: Map, expectedOutput: Map, - ) { - transformer.mappings.set(mappings) - transformer.mergeStrategy.set(MergeStrategy.Latest) + ) = + with(transformer) { + this.mappings.set(mappings) + mergeStrategy.set(MergeStrategy.Latest) - if (transformer.canTransformResource(path)) { - transformer.transform(context(path, input1)) - transformer.transform(context(path, input2)) - } + if (canTransformResource(path)) { + transform(context(path, input1)) + transform(context(path, input2)) + } - assertThat(transformer.propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) - } + assertThat(propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) + } @ParameterizedTest @MethodSource("keyTransformerProvider") @@ -130,17 +134,18 @@ class PropertiesFileTransformerTest : BaseTransformerTest, input2: Map, expectedOutput: Map, - ) { - transformer.mergeStrategy.set(MergeStrategy.Append) - transformer.keyTransformer = keyTransformer + ) = + with(transformer) { + mergeStrategy.set(MergeStrategy.Append) + this.keyTransformer = keyTransformer - if (transformer.canTransformResource(path)) { - transformer.transform(context(path, input1)) - transformer.transform(context(path, input2)) - } + if (canTransformResource(path)) { + transform(context(path, input1)) + transform(context(path, input2)) + } - assertThat(transformer.propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) - } + assertThat(propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) + } @ParameterizedTest @MethodSource("charsetProvider") @@ -149,15 +154,16 @@ class PropertiesFileTransformerTest : BaseTransformerTest, expectedOutput: Map, - ) { - transformer.charsetName.set(charset) + ) = + with(transformer) { + charsetName.set(charset) - if (transformer.canTransformResource(path)) { - transformer.transform(context(path, input, Charset.forName(charset))) - } + if (canTransformResource(path)) { + transform(context(path, input, Charset.forName(charset))) + } - assertThat(transformer.propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) - } + assertThat(propertiesEntries[path].orEmpty()).isEqualTo(expectedOutput) + } private companion object { fun context( diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ServiceFileTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ServiceFileTransformerTest.kt index f41f3fa4c..a98551043 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ServiceFileTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ServiceFileTransformerTest.kt @@ -39,26 +39,28 @@ class ServiceFileTransformerTest : BaseTransformerTest() @ParameterizedTest @MethodSource("resourceProvider") - fun canTransformResource(path: String, exclude: Boolean, expected: Boolean) { - if (exclude) { - transformer.exclude(path) + fun canTransformResource(path: String, exclude: Boolean, expected: Boolean) = + with(transformer) { + if (exclude) { + exclude(path) + } + assertThat(canTransformResource(path)).isEqualTo(expected) } - assertThat(transformer.canTransformResource(path)).isEqualTo(expected) - } @ParameterizedTest @MethodSource("serviceFileProvider") - fun transformServiceFile(path: String, input1: String, input2: String, output: String) { - if (transformer.canTransformResource(path)) { - transformer.transform(textContext(path, input1)) - transformer.transform(textContext(path, input2)) + fun transformServiceFile(path: String, input1: String, input2: String, output: String) = + with(transformer) { + if (canTransformResource(path)) { + transform(textContext(path, input1)) + transform(textContext(path, input2)) + } + + assertThat(hasTransformedResource()).isTrue() + val entry = serviceEntries.getValue(path).joinToString("\n") + assertThat(entry).isEqualTo(output) } - assertThat(transformer.hasTransformedResource()).isTrue() - val entry = transformer.serviceEntries.getValue(path).joinToString("\n") - assertThat(entry).isEqualTo(output) - } - @Test fun excludesGroovyExtensionModuleDescriptorFilesByDefault() { val element = "META-INF/services/org.codehaus.groovy.runtime.ExtensionModule" @@ -66,88 +68,88 @@ class ServiceFileTransformerTest : BaseTransformerTest() } @Test - fun canTransformAlternateResource() { - transformer.path = "foo/bar" - assertThat(transformer.canTransformResource("foo/bar/moo/goo/Zoo")).isTrue() - assertThat(transformer.canTransformResource("META-INF/services/Zoo")).isFalse() - } + fun canTransformAlternateResource() = + with(transformer) { + path = "foo/bar" + assertThat(canTransformResource("foo/bar/moo/goo/Zoo")).isTrue() + assertThat(canTransformResource("META-INF/services/Zoo")).isFalse() + } @Test - fun relocatedClasses() { - val relocator = SimpleRelocator("org.foo", "borg.foo", excludes = listOf("org.foo.exclude.*")) - val content = "org.foo.Service\norg.foo.exclude.OtherService\n" - val contentResource = "META-INF/services/org.foo.something.another" - val contentResourceShaded = "META-INF/services/borg.foo.something.another" + fun relocatedClasses() = + with(ServiceFileTransformer()) { + val relocator = SimpleRelocator("org.foo", "borg.foo", excludes = listOf("org.foo.exclude.*")) + val content = "org.foo.Service\norg.foo.exclude.OtherService\n" + val contentResource = "META-INF/services/org.foo.something.another" + val contentResourceShaded = "META-INF/services/borg.foo.something.another" - val transformer = ServiceFileTransformer() - transformer.transform(textContext(contentResource, content, relocator)) + transform(textContext(contentResource, content, relocator)) - tempJar.outputStream().zipOutputStream().use { zos -> - transformer.modifyOutputStream(zos, false) - } + tempJar.outputStream().zipOutputStream().use { zos -> + modifyOutputStream(zos, false) + } - val transformedContent = JarPath(tempJar).use { it.getContent(contentResourceShaded) } - assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.foo.exclude.OtherService") - } + val transformedContent = JarPath(tempJar).use { it.getContent(contentResourceShaded) } + assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.foo.exclude.OtherService") + } @Test - fun mergeRelocatedFiles() { - val relocator = SimpleRelocator("org.foo", "borg.foo", excludes = listOf("org.foo.exclude.*")) - val content = "org.foo.Service\norg.foo.exclude.OtherService\n" - val contentResource = "META-INF/services/org.foo.something.another" - val contentResourceShaded = "META-INF/services/borg.foo.something.another" - - val transformer = ServiceFileTransformer() - transformer.transform(textContext(contentResource, content, relocator)) - transformer.transform(textContext(contentResourceShaded, content, relocator)) - - tempJar.outputStream().zipOutputStream().use { zos -> - transformer.modifyOutputStream(zos, false) + fun mergeRelocatedFiles() = + with(ServiceFileTransformer()) { + val relocator = SimpleRelocator("org.foo", "borg.foo", excludes = listOf("org.foo.exclude.*")) + val content = "org.foo.Service\norg.foo.exclude.OtherService\n" + val contentResource = "META-INF/services/org.foo.something.another" + val contentResourceShaded = "META-INF/services/borg.foo.something.another" + + transform(textContext(contentResource, content, relocator)) + transform(textContext(contentResourceShaded, content, relocator)) + + tempJar.outputStream().zipOutputStream().use { zos -> + modifyOutputStream(zos, false) + } + + val transformedContent = JarPath(tempJar).use { it.getContent(contentResourceShaded) } + assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.foo.exclude.OtherService") } - val transformedContent = JarPath(tempJar).use { it.getContent(contentResourceShaded) } - assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.foo.exclude.OtherService") - } - @Test - fun concatenationAppliedMultipleTimes() { - val relocator = SimpleRelocator("org.eclipse", "org.eclipse1234") - val content = "org.eclipse.osgi.launch.EquinoxFactory\n" - val contentResource = "META-INF/services/org.osgi.framework.launch.FrameworkFactory" + fun concatenationAppliedMultipleTimes() = + with(ServiceFileTransformer()) { + val relocator = SimpleRelocator("org.eclipse", "org.eclipse1234") + val content = "org.eclipse.osgi.launch.EquinoxFactory\n" + val contentResource = "META-INF/services/org.osgi.framework.launch.FrameworkFactory" - val transformer = ServiceFileTransformer() - transformer.transform(textContext(contentResource, content, relocator)) + transform(textContext(contentResource, content, relocator)) - tempJar.outputStream().zipOutputStream().use { zos -> - transformer.modifyOutputStream(zos, false) - } + tempJar.outputStream().zipOutputStream().use { zos -> + modifyOutputStream(zos, false) + } - val transformedContent = JarPath(tempJar).use { it.getContent(contentResource) } - assertThat(transformedContent).isEqualTo("org.eclipse1234.osgi.launch.EquinoxFactory") - } + val transformedContent = JarPath(tempJar).use { it.getContent(contentResource) } + assertThat(transformedContent).isEqualTo("org.eclipse1234.osgi.launch.EquinoxFactory") + } @Test - fun concatenation() { - val relocator = SimpleRelocator("org.foo", "borg.foo") - var content = "org.foo.Service\n" - var contentResource = "META-INF/services/org.something.another" + fun concatenation() = + with(ServiceFileTransformer()) { + val relocator = SimpleRelocator("org.foo", "borg.foo") + var content = "org.foo.Service\n" + var contentResource = "META-INF/services/org.something.another" + transform(textContext(contentResource, content, relocator)) - val transformer = ServiceFileTransformer() - transformer.transform(textContext(contentResource, content, relocator)) + content = "org.blah.Service\n" + contentResource = "META-INF/services/org.something.another" - content = "org.blah.Service\n" - contentResource = "META-INF/services/org.something.another" + transform(textContext(contentResource, content, relocator)) - transformer.transform(textContext(contentResource, content, relocator)) + tempJar.outputStream().zipOutputStream().use { zos -> + modifyOutputStream(zos, false) + } - tempJar.outputStream().zipOutputStream().use { zos -> - transformer.modifyOutputStream(zos, false) + val transformedContent = JarPath(tempJar).use { it.getContent(contentResource) } + assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.blah.Service") } - val transformedContent = JarPath(tempJar).use { it.getContent(contentResource) } - assertThat(transformedContent).isEqualTo("borg.foo.Service\norg.blah.Service") - } - private companion object { @JvmStatic fun resourceProvider() = diff --git a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/XmlAppendingTransformerTest.kt b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/XmlAppendingTransformerTest.kt index 3fc6ddb39..09a09d233 100644 --- a/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/XmlAppendingTransformerTest.kt +++ b/src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/XmlAppendingTransformerTest.kt @@ -12,11 +12,12 @@ class XmlAppendingTransformerTest : BaseTransformerTest } @Test - fun canTransformResource() { - transformer.resource.set("abcdefghijklmnopqrstuvwxyz") + fun canTransformResource() = + with(transformer) { + resource.set("abcdefghijklmnopqrstuvwxyz") - assertThat(transformer.canTransformResource("abcdefghijklmnopqrstuvwxyz")).isTrue() - assertThat(transformer.canTransformResource("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).isTrue() - assertThat(transformer.canTransformResource("META-INF/MANIFEST.MF")).isFalse() - } + assertThat(canTransformResource("abcdefghijklmnopqrstuvwxyz")).isTrue() + assertThat(canTransformResource("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).isTrue() + assertThat(canTransformResource("META-INF/MANIFEST.MF")).isFalse() + } }