file('module-a').mkdir()
        file('module-b').mkdir()
        file('module-c').mkdir()
        file('module-a/settings.gradle') << """
            includeBuild('../module-b')
        """
        file('module-b/settings.gradle') << """
            includeBuild('../module-c')
        """
        file('module-c/settings.gradle') << """
            includeBuild('../module-a')
        """
    }

    }

    // BuildListener
    @Override
    public void beforeSettings(Settings settings) {
        long now = clock.getCurrentTime();
        buildProfile.setBuildStarted(now);
        buildProfile.setProfilingStarted(buildStartedTime.getStartTime());
    }

    @Override
    public void settingsEvaluated(Settings settings) {
        buildProfile.setSettingsEvaluated(clock.getCurrentTime());
    }

    @Override

import com.google.common.collect.ImmutableSet;
import com.google.common.reflect.TypeToken;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.initialization.Settings;
import org.gradle.api.internal.tasks.properties.InspectionScheme;
import org.gradle.api.internal.plugins.software.SoftwareType;
import org.gradle.internal.Cast;

            ClosureReference.Project -> BrokenScript(Project::class.java)
            ClosureReference.Settings -> BrokenScript(Settings::class.java)
            ClosureReference.Init -> BrokenScript(Gradle::class.java)
            ClosureReference.NotScript -> BrokenObject
        }

    private
    enum class ClosureReference {
        Project, Settings, Init, NotScript
    }

    private
    object BrokenObject : GroovyObjectSupport()

            import org.gradle.api.initialization.Settings;

            class MyPlugin implements Plugin<Settings> {
                @Override
                public void apply(Settings settings) {
                    settings.getPluginManager().apply("${transitivePluginFixture.id}");
                }
            }
        """

        file("build-src/settings.gradle") << """
            rootProject.name = 'build-src'

            import ${Plugin.name};
            import ${Settings.name};
            ${snippets.imports}

            public abstract class SneakyPlugin implements Plugin<Settings> {
                @Inject
                protected abstract ExecOperations getExecOperations();

                @Override
                public void apply(Settings project) {
                    ${snippets.body}
                }

            includeBuild "i2"
        """

        file("buildSrc/settings.gradle") << buildSrcCache.localCacheConfiguration() << enablingCode
        file("i1/settings.gradle") << i1Cache.localCacheConfiguration() << enablingCode
        file("i1/buildSrc/settings.gradle") << i1BuildSrcCache.localCacheConfiguration() << enablingCode
        file("i2/settings.gradle") << i2Cache.localCacheConfiguration() << enablingCode

            }
        '''
        createDir('lib') {
            file('settings.gradle') << 'rootProject.name = "lib"'
            file('build.gradle') << '''
                plugins { id 'java-library' }
                group = 'com.example'
                version = '1.0'
            '''
        }
        createDir('util') {
            file('settings.gradle') << 'rootProject.name = "util"'
            file('build.gradle') << '''

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

package org.gradle.internal.declarativedsl.settings

import org.gradle.api.initialization.Settings
import org.gradle.declarative.dsl.evaluation.InterpretationStepFeature
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument

     *
     * @param activeExternalProfiles the active profiles coming from external sources (settings.xml), must not be {@code null}
     * @param model The model to validate, must not be {@code null}.
     * @param request The model building request that holds further settings, must not be {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.