setup:
        multiProjectBuildInRootFolder("root", ["child1", "child2"]) {
            buildFile << """
            subprojects {
                apply plugin: 'java-library'
            }
            project(":child2") {
                apply plugin: 'eclipse'
                configurations {
                    toRemove
                }
                eclipse {
                    classpath {

                id("org.jetbrains.kotlin.jvm") version kotlinVersion
                id("org.jetbrains.kotlin.kapt") version kotlinVersion apply false
                id("java") apply false

                val app = id("application")
                app.apply(false)
            }""".trimIndent()
        val result = schema.reflect(code)

        printReflection(result)

            }
            val additions = buildList {
                softwareType.conventions.filterIsInstance<AdditionRecordConvention>().forEach { it.apply(::add) }
            }
            val nestedObjectAccess = buildList {
                softwareType.conventions.filterIsInstance<NestedObjectAccessConvention>().forEach { it.apply(::add) }
            }

        buildFile << """
            apply plugin: 'idea'

            idea {
                project {
                    languageLevel = 1.7
                }
            }

            project(':child1') {
            }

            project(':child2') {
                apply plugin: 'java'
                ${javaSourceCompatibility(targetVersion, JavaVersion.VERSION_1_2)}

        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: CustomPlugin
                apply plugin: 'java'
            }
        """

        expect:
        def models = withConnection {
            def action = action(new ActionRunsMultipleLevelsOfNestedActions())

        sourceDirectory.accessRules.isEmpty()
    }

    def "Has some access rules defined"() {
        buildFile <<
        """import org.gradle.plugins.ide.eclipse.model.AccessRule
           apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->

        group = "org.jetbrains.trove4j"
      ) // Might not be available on Maven Central and not needed for this test
    }
  }
}

subprojects {
  if (name.endsWith("Java")) {
    apply(plugin = "java-library")
  } else {
    apply(plugin = "com.android.application")
    the<com.android.build.gradle.AppExtension>().compileSdkVersion(30)
  }

  var expectedClasspath =
    if (runningGradle5) {

    override fun apply(receiver: AssignmentRecordConventionReceiver) {
        receiver.receive(assignmentRecord)
    }
}


/**
 * A convention that applies a data addition operation (e.g. addFoo("bar")).
 */
class AdditionRecordConvention(private val dataAdditionRecord: DataAdditionRecord) :
    Convention<AdditionRecordConventionReceiver> {
    override fun apply(receiver: AdditionRecordConventionReceiver) {

    }

    def "Source directory has custom output"() {
        setup:
        settingsFile << 'rootProject.name = "root"'
        buildFile << """
            apply plugin: 'java'
            apply plugin: 'eclipse'

            eclipse.classpath.file.whenMerged {
                entries.find { entry -> entry.path == 'src/test/java' }.output = null

			[]byte(createDockerCredential(registryUser, registryPasswd, registry.Address()))),
	}
	if err := ctx.ConfigIstio().EvalFile(apps.Namespace.Name(), args, "testdata/registry-secret.yaml").
		Apply(apply.CleanupConditionally); err != nil {
		return err
	}
	return nil
}

func createDockerCredential(user, passwd, registry string) string {
	credentials := `{
	"auths":{
		"%v":{
			"username": "%v",