println new Foo0()
                }
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {
            buildFile.text = buildFile.text.replace("Foo$i", "Foo${i + 1}")
            executer.withBuildJvmOpts("-Xmx256m", "-XX:+HeapDumpOnOutOfMemoryError")
            assert succeeds("myTask")
        }
    }

 */

@groovy.transform.CompileStatic
void createTasks(Project p, int iterations) {
    for (int i=0; i<iterations; i++) {
        p.task("foo\$i", type: Copy)
    }
}

if (tasks.metaClass.respondsTo(tasks, "register")) {
    for (int i=0; i<$taskCount; i++) {
       project.tasks.register("foo\$i", Copy)
    }
} else {
    createTasks(project, $taskCount)

	{"-march=@dawn"},
	{"-march=-dawn"},
	{"-mcmodel=@model"},
	{"-mlarge-data-threshold=@12"},
	{"-std=@c99"},
	{"-std=-c99"},
	{"-x@c"},
	{"-x-c"},
	{"-D", "@foo"},
	{"-D", "-foo"},
	{"-I", "@foo"},
	{"-I", "-foo"},
	{"-I", "=@obj"},
	{"-include", "@foo"},
	{"-framework", "-Caffeine"},
	{"-framework", "@Home"},
	{"-x", "--c"},
	{"-x", "@obj"},
}

func TestCheckCompilerFlags(t *testing.T) {

        def emitter = new AggregatingProblemConsumer(eventConsumer, { new OperationIdentifier(1) })


        when:
        for (int i = 0; i < 3; i++) {
            emitter.emit(createMockProblem("foo$i"))
        }

        then:
        3 * eventConsumer.progress(_)
    }

    def "emit summary if there are deduplicate events"() {
        given:
        def eventConsumer = Mock(ProgressEventConsumer)

    fun someClassesInDefaultPackage(): Sequence<Path> {
        val directory = projectDir.resolve("classes-default")

        DEFAULT_EXCLUDES_FOR_TEST.forEachIndexed { i, pkg ->
            touchFile(directory.resolve("$pkg/Foo$i.class"))
        }

        return sequenceOf(directory)
    }

    private
    fun aJar(sourceFiles: Sequence<Path>): Sequence<Path> {
        val outputPath = projectDir.resolve("mylib.jar")

   * ...
   * synchronized (queue) {  // Must synchronize on queue!
   *   Iterator<E> i = queue.iterator(); // Must be in synchronized block
   *   while (i.hasNext()) {
   *     foo(i.next());
   *   }
   * }
   * }</pre>
   *
   * <p>Failure to follow this advice may result in non-deterministic behavior.
   *

// tokens, regular expression literal tokens, or division operators.
//
// This fails on some valid but nonsensical JavaScript programs like
// "x = ++/foo/i" which is quite different than "x++/foo/i", but is not known to
// fail on any known useful programs. It is based on the draft
// JavaScript 2.0 lexical grammar and requires one token of lookbehind:

                // Class<T> + Groovy named arguments to KClass<T> + vararg of Pair
                filter(ReplaceTokens::class, "foo" to "bar")
            }
            """
        )

        build("foo", "-I", "init.gradle.kts")
    }

    @Test
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `can use Gradle API generated extensions in buildSrc`() {

        withKotlinBuildSrc()

   * ...
   * synchronized (queue) {  // Must synchronize on queue!
   *   Iterator<E> i = queue.iterator(); // Must be in synchronized block
   *   while (i.hasNext()) {
   *     foo(i.next());
   *   }
   * }
   * }</pre>
   *
   * <p>Failure to follow this advice may result in non-deterministic behavior.
   *

            'if (true) { add $("foo") }',
            'if (false) {} else if (true) { add $("foo") }',
            'if (false) {} else { add $("foo") }',
            'def i = true; while(i) { add $("foo"); i = false }',
            '[1].each { add $("foo") }',
            'add "${$("foo")}"',
            'def v = $("foo"); add(v)',
            'add($("foo"))',
            'add($("foo").toString())',
            '''