$greetTask

                val greetingProp = providers.systemProperty("greeting")
                if (greetingProp.get() == "hello") {
                    tasks.register<Greet>("greet") {
                        greeting.set("hello, hello")
                    }
                } else {
                    tasks.register<Greet>("greet") {
                        greeting.set(greetingProp)

        buildFile("""
            tasks.register("sneakyTask", SneakyTask) {}
        """)

        when:
        configurationCacheFails(":sneakyTask")

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {
            withProblem("$location: external process started")
        }

        where:
        snippetsFactory                      | location

	// local to remote
	remoteConn := local.Connection(remoteHost)
	remoteConn.WaitForConnect(context.Background())
	defer testlogger.T.SetErrorTB(t)()

	t.Run("localToRemote", func(t *testing.T) {
		const testPayload = "Hello Grid World!"

		start := time.Now()
		resp, err := remoteConn.Request(context.Background(), handlerTest, []byte(testPayload))
		errFatal(err)
		if string(resp) != testPayload {

 */
class ExternalProcessFixture {
    private final TestFile testDirectory
    private final ShellScript testExecutable = ShellScript.builder()
        .printText("Hello from script")
        .writeTo(testDirectory, "test")

    ExternalProcessFixture(TestFile testDirectory) {
        this.testDirectory = testDirectory
    }

    private String getCommandLineAsVarargLiterals() {

        when:
        configurationCacheRun "greet"

        then:
        configurationCache.assertStateStored()
        output.contains("Hello!")

        when:
        configurationCacheRun "greet"

        then:
        configurationCache.assertStateLoaded()
        output.contains("Hello!")
    }

    def "#usage property from properties file used as build logic input"() {
        given:

                // remaining parts.
                // E.g., coreR.string.hello
                //   -> string.hello (drop the first segment)
                //   test.pkg.R.string.hello
                //   -> string.hello (take last two segments, where the size is determined by the size of qualified access minus 1)

	addTestClientEndpoints(s.MemRegistry)
	s.MemRegistry.AddHTTPService(edsIncSvc, edsIncVip, 8080)
	s.MemRegistry.SetEndpoints(edsIncSvc, "",
		newEndpointWithAccount("127.0.0.1", "hello-sa", "v1"))
	// Wait until the above debounce, to ensure we can precisely check XDS responses without spurious pushes
	s.EnsureSynced(t)

        // Unnecessary cast will trigger a warning
        String s = (String)"Hello World";
    }
"""
        }

        void addError() {
            errorIndex += 1
            sourceFile << """\
public void error${errorIndex}() {
    // Missing semicolon will trigger an error
    String s = "Hello, World!"
}
"""
        }

        TestFile save() throws Exception {

)

// Model specify the model you would like to run db operations
//
//	// update all users's name to `hello`
//	db.Model(&User{}).Update("name", "hello")
//	// if user's primary key is non-blank, will use it as condition, then will only update that user's name to `hello`
//	db.Model(&user).Update("name", "hello")
func (db *DB) Model(value interface{}) (tx *DB) {
	tx = db.getInstance()
	tx.Statement.Model = value
	return
}

     * <pre>
     * /.../src/main/java/Foo.java:10: error: ';' expected
     *                     String s = "Hello, World!"
     *                                               ^
     * /.../Bar.java:10: warning: [cast] redundant cast to String
     *                     String s = (String)"Hello World";
     *                                ^
     * 1 error
     * 1 warning
     * </pre>
     *