{name: "malformed timestamp", in: []byte("\x45hello"), out: MicroTime{}, errMessage: `parsing time "hello" as "2006-01-02T15:04:05.000000Z07:00": cannot parse "hello" as "2006"`}, // 'hello'
	} {
		t.Run(tc.name, func(t *testing.T) {
			var got MicroTime
			err := got.UnmarshalCBOR(tc.in)
			if err != nil {
				if tc.errMessage == "" {

)

// 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
}

        // 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 {

    assertThat(headersToList(response)).containsExactly("Cookie: a=android")
  }

  @Test
  fun regularResponse() {
    server.enqueue(MockResponse().setBody("hello world"))
    val url = server.url("/").toUrl()
    val connection = url.openConnection() as HttpURLConnection
    connection.setRequestProperty("Accept-Language", "en-US")
    val inputStream = connection.inputStream

    assertThat(headersToList(builder)).containsExactly("Cookie: a=android")
  }

  @Test
  fun regularResponse() {
    server.enqueue(MockResponse.Builder().body("hello world").build())
    val url = server.url("/").toUrl()
    val connection = url.openConnection() as HttpURLConnection
    connection.setRequestProperty("Accept-Language", "en-US")

        .retryOnConnectionFailure(false)
        .build()
    url = server.url("/")
  }

  @Test
  fun get() {
    assumeNotWindows()
    server.enqueue(
      MockResponse.Builder()
        .body("Hello!")
        .setHeader("Content-Type", PLAIN)
        .build(),
    )
    val response = client.newCall(request().build()).execute()
    assertThat(response.body).isNotNull()
    response.body.bytes()
    logRecorder

}

func TestServerRunWithSNI(t *testing.T) {
	tests := map[string]struct {
		Cert              TestCertSpec
		SNICerts          []NamedTestCertSpec
		ExpectedCertIndex int

		// passed in the client hello info, "localhost" if unset
		ServerName string

		// optional ip or hostname to pass to NewLoopbackClientConfig
		LoopbackClientBindAddressOverride string
	}{
		"only one cert": {
			Cert: TestCertSpec{

	err := enc.Encode(GobTest4{17, ValueGobber("hello"), BinaryValueGobber("Καλημέρα"), TextValueGobber("こんにちは")})
	if err != nil {
		t.Fatal("encode error:", err)
	}
	dec := NewDecoder(b)
	x := new(GobTest5)
	err = dec.Decode(x)
	if err != nil {
		t.Fatal("decode error:", err)
	}
	if *x.V != "hello" || *x.BV != "Καλημέρα" || *x.TV != "こんにちは" {
		t.Errorf("expected `hello` got %s", *x.V)
	}
}

            }
        """
        settingsFile << "rootProject.name = 'client-runner'"

        file("test-project/build.gradle") << "println 'Hello from ' + gradle.gradleVersion"
        file("test-project/settings.gradle") << "rootProject.name = 'target-project'"
        file("src/main/java/ToolingApiCompatibilityClient.java").java("""

        lockfileFixture.verifyBuildscriptLockfile('classpath', ['org.foo:foo-plugin:1.1'])
    }

    def "can use plugins block with plugin management block"() {
        given:
        def message = "hello from settings plugin"
        pluginBuilder.addSettingsPlugin("println '$message'")
        pluginBuilder.publishAs("org", "settings-plugin", "1.0", pluginRepo, createExecuter()).allowAll()

        and: