def "configures checkstyle extension to read config from root project in a single project build"() {
        given:
        buildFile << javaProjectUsingCheckstyle()
        file('src/main/java/Dummy.java') << javaClassWithNewLineAtEnd()
        file('config/checkstyle/checkstyle.xml') << simpleCheckStyleConfig()

        expect:
        succeeds('checkstyleMain')
        checkStyleReportFile(testDirectory).assertExists()

hg update -r 4

hg branch v3
unquote ''
cp stdout dummy
hg add dummy
hg commit --user 'Russ Cox <******@****.***>' --date '2018-06-27T12:15:45-04:00' -m 'dummy'

hg update v2.3.4
hg branch v2.3.4
unquote ''
cp stdout dummy
hg add dummy
hg commit --user 'Russ Cox <******@****.***>' --date '2018-06-27T12:16:10-04:00' -m 'dummy'

    Object dummy =
        Proxy.newProxyInstance(
            interfaceClasses.iterator().next().getClassLoader(),
            interfaceClasses.toArray(new Class<?>[interfaceClasses.size()]),
            new DummyHandler(interfaceType));
    @SuppressWarnings("unchecked") // interfaceType is T
    T result = (T) dummy;
    return result;
  }

  /** Returns the dummy return value for {@code returnType}. */

	fs := flag.NewFlagSet("ExampleBoolFunc", flag.ContinueOnError)
	fs.SetOutput(os.Stdout)

	fs.BoolFunc("log", "logs a dummy message", func(s string) error {
		fmt.Println("dummy message:", s)
		return nil
	})
	fs.Parse([]string{"-log"})
	fs.Parse([]string{"-log=0"})

	// Output:
	// dummy message: true
	// dummy message: 0

    HMODULE dummyDll = LoadLibrary("dummy.dll");
    if (!dummyDll) {
        fprintf(stderr, "ERROR: Could not load dummy.dll\n");
        return 1;
    }

    // Call the Dummy function so that Go initialization completes, since
    // all cgo entry points call out to _cgo_wait_runtime_init_done.
    if (((int(*)(void))GetProcAddress(dummyDll, "Dummy"))() != 42) {

    #set ( $dummy = $imports.add( "java.io.Serializable" ) )
    #set ( $dummy = $imports.add( "java.util.Collections" ) )
    #set ( $dummy = $imports.add( "java.util.HashMap" ) )
    #set ( $dummy = $imports.add( "java.util.Map" ) )
    #set ( $dummy = $imports.add( "org.apache.maven.api.annotations.Experimental" ) )
    #set ( $dummy = $imports.add( "org.apache.maven.api.annotations.Generated" ) )

    }

    interface Dummy {
        void accept(MyEnum value)
    }

    static class MyEnumBuildOption extends EnumBuildOption<MyEnum, Dummy> {

        MyEnumBuildOption() {
            super("my option", MyEnum, MyEnum.values(), "test")
        }

        @Override
        void applyTo(MyEnum value, Dummy settings, Origin origin) {
            settings.accept(value)
        }

            }
        """

        file('src/dummy-input.txt') << "dummy text"

        buildFile << """
            task cacheableTask {
                def inputFile = file("src/dummy-input.txt")
                def outputDir = file(layout.buildDirectory.dir("dummy-output"))
                def outputFile = file(layout.buildDirectory.file("dummy-output/result.txt"))

                outputs.cacheIf { true }

stderr preferlinkext
env CGO_CFLAGS=-fplugin
go build -x -n -o dummy.exe ./usesInternalCgo
stderr preferlinkext
env CGO_CFLAGS=-fprofile-instr-generate
go build -x -n -o dummy.exe ./usesInternalCgo
stderr preferlinkext

# The -fdebug-prefix-map=path is permitted for internal linking.
env CGO_CFLAGS=-fdebug-prefix-map=/some/sandbox/execroot/workspace=/tmp/new
go build -x -n -o dummy.exe ./usesInternalCgo

    auto enter =
        ops::internal::Enter(scope.WithOpName("while/Enter"), x, "aloop");
    auto dummy = ops::Placeholder(scope.WithOpName("dummy"), DT_RESOURCE);
    auto merge = ops::Merge(scope.WithOpName("while/Merge"),
                            std::initializer_list<Input>{enter, dummy});
    auto false_value = ops::Const<bool>(scope.WithOpName("false"), false);
    auto loop_cond =