Call with in more tests

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")
+    }
 }

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()
+    }
 }

src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/ApacheNoticeResourceTransformerTest.kt

@@ -21,39 +21,42 @@ class ApacheNoticeResourceTransformerTest : BaseTransformerTest<ApacheNoticeReso
   }
 
   @Test
-  fun canTransformResource() {
-    assertThat(transformer.canTransformResource("META-INF/NOTICE")).isTrue()
-    assertThat(transformer.canTransformResource("META-INF/NOTICE.TXT")).isTrue()
-    assertThat(transformer.canTransformResource("META-INF/Notice.txt")).isTrue()
-    assertThat(transformer.canTransformResource("META-INF/NOTICE.md")).isTrue()
-    assertThat(transformer.canTransformResource("META-INF/Notice.md")).isTrue()
-    assertThat(transformer.canTransformResource("META-INF/MANIFEST.MF")).isFalse()
-  }
+  fun canTransformResource() =
+    with(transformer) {
+      assertThat(canTransformResource("META-INF/NOTICE")).isTrue()
+      assertThat(canTransformResource("META-INF/NOTICE.TXT")).isTrue()
+      assertThat(canTransformResource("META-INF/Notice.txt")).isTrue()
+      assertThat(canTransformResource("META-INF/NOTICE.md")).isTrue()
+      assertThat(canTransformResource("META-INF/Notice.md")).isTrue()
+      assertThat(canTransformResource("META-INF/MANIFEST.MF")).isFalse()
+    }
 
   @Test
-  fun canTransformByPattern() {
-    transformer.exclude("META-INF/NOTICE.txt")
-    transformer.include("META-INF/NOTICE.*")
-    assertThat(transformer.canTransformResource("META-INF/NOTICE.txt")).isFalse()
-    assertThat(transformer.canTransformResource("META-INF/NOTICE.log")).isTrue()
-  }
+  fun canTransformByPattern() =
+    with(transformer) {
+      exclude("META-INF/NOTICE.txt")
+      include("META-INF/NOTICE.*")
+      assertThat(canTransformResource("META-INF/NOTICE.txt")).isFalse()
+      assertThat(canTransformResource("META-INF/NOTICE.log")).isTrue()
+    }
 
   @Test
-  fun preamble1ShouldHaveATrailingSpace() {
-    val baos = ByteArrayOutputStream()
-    val zos = ZipOutputStream(baos)
+  fun preamble1ShouldHaveATrailingSpace() =
+    with(transformer) {
+      val baos = ByteArrayOutputStream()
+      val zos = ZipOutputStream(baos)
 
-    transformer.projectName.set("test-project")
-    transformer.transform(textContext(NOTICE_RESOURCE))
-    transformer.modifyOutputStream(zos, false)
-    zos.close()
+      projectName.set("test-project")
+      transform(textContext(NOTICE_RESOURCE))
+      modifyOutputStream(zos, false)
+      zos.close()
 
-    val zis = ZipInputStream(baos.toByteArray().inputStream())
-    zis.nextEntry
-    val output = zis.readAllBytes().toString(Charset.forName(transformer.charsetName.get()))
+      val zis = ZipInputStream(baos.toByteArray().inputStream())
+      zis.nextEntry
+      val output = zis.readAllBytes().toString(Charset.forName(charsetName.get()))
 
-    assertThat(output).contains("in this case for test-project")
-  }
+      assertThat(output).contains("in this case for test-project")
+    }
 
   private companion object {
     const val NOTICE_RESOURCE = "META-INF/NOTICE"

src/test/kotlin/com/github/jengelman/gradle/plugins/shadow/transformers/AppendingTransformerTest.kt

@@ -16,11 +16,12 @@ class AppendingTransformerTest : BaseTransformerTest<AppendingTransformer>() {
   }
 
   @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()
+    }
 }

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<ComponentsXmlResourceTransformer>() {
   @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()
+    }
 }

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<Log4j2PluginsCacheFileTransformer>() {
   @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()