.importPackagesOf(
                org.gradle.kotlin.dsl.execution.Interpreter::class.java,
                org.gradle.kotlin.dsl.provider.KotlinScriptClassPathProvider::class.java,
                org.gradle.kotlin.dsl.support.EmbeddedKotlinProvider::class.java,
                org.gradle.kotlin.dsl.accessors.ProjectSchema::class.java
            )

            on { maybeCreate("alice", DomainObjectBase.Foo::class.java) } doReturn alice
            on { create(eq("bob"), eq(DomainObjectBase.Bar::class.java), any<Action<DomainObjectBase.Bar>>()) } doReturn bob
            on { create("john") } doReturn default
            on { create("john", DomainObjectBase.Default::class.java) } doReturn default
            onNamedWithAction("marty", DomainObjectBase.Foo::class, martyProvider)

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentCaptor
import org.mockito.ArgumentMatchers.any
import java.util.UUID


class ConfigurationCacheBuildOperationsTest {
    @JvmField
    @Rule
    val testDirectoryProvider = TestNameTestDirectoryProvider(javaClass)

    @Test

import org.gradle.internal.serialize.graph.writeNextProperty
import java.lang.reflect.Field
import java.lang.reflect.Modifier.isStatic


object JavaRecordCodec : EncodingProducer, Decoding {

    override fun encodingForType(type: Class<*>): Encoding? =
        // need to check by name because it's only present in Java 14+
        JavaRecordEncoding.takeIf { type.superclass?.canonicalName == "java.lang.Record" }

    private
    val problemsService = services.get(Problems::class.java)

    private
    val inspection by lazy {
        inspectionSchemeFactory.inspectionScheme(
            listOf(
                Input::class.java,
                ServiceReference::class.java,
            ),
            listOf(
                org.gradle.api.tasks.Optional::class.java
            ),
            instantiatorFactory.decorateScheme()

        }
        componentMetadataHandler.all<SomeRule>()
        inOrder(componentMetadataHandler) {
            verify(componentMetadataHandler).all(SomeRule::class.java)
            verifyNoMoreInteractions()
        }
    }

    @Test
    fun allWithParams() {
        val configAction = Config()
        val componentMetadataHandler = mock<ComponentMetadataHandler> {

 */

package gradlebuild.kotlindsl.generator.codegen

import org.gradle.api.internal.file.pattern.PatternMatcher
import org.gradle.api.internal.file.pattern.PatternMatcherFactory
import java.io.File
import java.util.Properties
import java.util.jar.JarFile


internal
data class GradleApiMetadata(
    val includes: List<String>,
    val excludes: List<String>,
    val parameterNamesSupplier: (String) -> List<String>?
) {

# These files are text and should be normalized (Convert crlf => lf)
*.bash          text eol=lf
*.css           text diff=css
*.htm           text diff=html
*.html          text diff=html
*.java          text diff=java
*.sh            text eol=lf


# These files are binary and should be left untouched
# (binary is a macro for -text -diff)
*.a             binary
*.lib           binary
*.icns          binary

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("java-library")
}
description = "Provides a custom CodeNarc rule used by the Gradle build"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }
}

group = "gradlebuild"

dependencies {

 * @see [ServiceRegistration.add]
 */
inline fun <reified ServiceType, reified ImplementationType : ServiceType> ServiceRegistration.add() {
    add(ServiceType::class.java, ImplementationType::class.java)