<2> Use Maven Central for resolving dependencies.
<3> Use JUnit Jupiter for testing (using the version catalog).
<4> This dependency is used by the application (referred using the version catalog).
<5> Define the toolchain version.
<6> Define the main class for the application.
<7> Use JUnit Platform for unit tests.
=====
[.multi-language-sample]
=====
[source, groovy]
----
plugins {

package org.gradle.kotlin.dsl.fixtures

import org.gradle.test.fixtures.file.CleanupTestDirectory
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

import org.junit.Rule

import java.io.File


@CleanupTestDirectory(fieldName = "tempFolder")
abstract class FolderBasedTest {

    @JvmField
    @Rule
    val tempFolder = TestNameTestDirectoryProvider(javaClass)

    val root: File

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import junit.framework.TestCase;

/**
 * Unit tests for {@link Runnables}.
 *
 * @author Olivier Pernet
 */
@GwtCompatible
public class RunnablesTest extends TestCase {
  public void testDoNothingRunnableIsSingleton() {

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import junit.framework.TestCase;

/**
 * Unit tests for {@link Runnables}.
 *
 * @author Olivier Pernet
 */
@GwtCompatible
public class RunnablesTest extends TestCase {
  public void testDoNothingRunnableIsSingleton() {

import org.gradle.kotlin.dsl.support.compileToDirectory
import org.gradle.kotlin.dsl.support.loggerFor
import org.gradle.kotlin.dsl.support.uppercaseFirstChar
import org.gradle.nativeplatform.BuildType
import org.junit.Assert.assertEquals
import org.junit.Test
import org.mockito.ArgumentMatchers.anyMap
import java.io.File
import java.lang.reflect.Method
import java.lang.reflect.Modifier.PUBLIC
import java.lang.reflect.Modifier.STATIC

    fun `can parse many symbols`() {
        val parser = zeroOrMore(combinator.symbol("foo"))
        assertSuccess(
            parser("foo"),
            listOf(Unit)
        )
        assertSuccess(
            parser("foo foo"),
            listOf(Unit, Unit)
        )
    }

    @Test
    fun `can parse many symbols before another symbol`() {

    override fun apply(target: Gradle) = Unit
}


private
class SettingsPlugin : Plugin<Settings> {
    override fun apply(target: Settings) = Unit
}


private
class ProjectPlugin : Plugin<Project> {
    override fun apply(target: Project) = Unit
}


private
class AnyPlugin : Plugin<Any> {
    override fun apply(target: Any) = Unit

== Implementing automated tests

This section discusses representative implementation examples for unit, integration, and functional tests.
All test classes are based on the use of Spock, though it should be relatively easy to adapt the code to a different test framework.

[[unit-tests]]
=== Implementing unit tests

The URL verifier plugin emits HTTP GET calls to check if a URL can be resolved successfully.

import org.gradle.internal.metaobject.DynamicObject
import org.junit.Test


class TrackingDynamicLookupRoutineTest {
    @Test
    fun `tracks context in all implementations`() {
        val receiver = mock<DynamicObject> {
            on { tryGetProperty(any()) }.thenReturn(DynamicInvokeResult.found())
        }

        fun shouldTrackContext(action: DynamicLookupRoutine.() -> Unit) {
            val tracker = mock<DynamicCallContextTracker>()

import org.gradle.api.Action

import org.gradle.api.artifacts.dsl.RepositoryHandler
import org.gradle.api.artifacts.repositories.IvyArtifactRepository
import org.gradle.api.artifacts.repositories.MavenArtifactRepository

import org.junit.Test
import org.mockito.invocation.InvocationOnMock


class RepositoryHandlerExtensionsTest {

    @Test
    fun `#maven(String)`() {

        val repository = mock<MavenArtifactRepository>()