val requestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          throw IOException("boom") // Despite this exception, 'sink' is healthy.
        }
      }

    val callA =
      client.newCall(
        Request(
          url = server.url("/"),
          body = requestBody,
        ),

                  if (state() != State.STARTING) {
                    inGetNextSchedule.await();
                    Thread.yield();
                    throw new RuntimeException("boom");
                  }
                  return new Schedule(0, NANOSECONDS);
                }
              };
            }
          };
      service.startAsync().awaitRunning();

                  if (state() != State.STARTING) {
                    inGetNextSchedule.await();
                    Thread.yield();
                    throw new RuntimeException("boom");
                  }
                  return new Schedule(0, NANOSECONDS);
                }
              };
            }
          };
      service.startAsync().awaitRunning();

  }

  @Test
  fun clientReadsHeadersDataTrailersHttp2() {
    platform.assumeHttp2Support()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .body("HelloBonjour")
        .trailers(headersOf("trailers", "boom"))
        .build(),
    )

                // to
                // ensure that the thread running the failure callbacks is not the main thread.
                Uninterruptibles.awaitUninterruptibly(afterStarted);
                notifyFailed(new Exception("boom"));
              }
            }.start();
          }

          @Override
          protected void doStop() {
            notifyStopped();
          }
        };

                // to
                // ensure that the thread running the failure callbacks is not the main thread.
                Uninterruptibles.awaitUninterruptibly(afterStarted);
                notifyFailed(new Exception("boom"));
              }
            }.start();
          }

          @Override
          protected void doStop() {
            notifyStopped();
          }
        };

        Dispatcher::class.java to Dispatcher(),
        Handshake::class.java to handshake,
        HttpUrl::class.java to url,
        IOException::class.java to IOException("boom"),
        InetSocketAddress::class.java to InetSocketAddress.createUnresolved("localhost", 80),
        List::class.java to listOf<Any?>(),
        Long::class.java to 123L,

    client =
      client
        .newBuilder()
        .dns { hostname: String? -> throw RuntimeException("boom!") }
        .build()
    server.enqueue(MockResponse())
    assertFailsWith<RuntimeException> {
      getResponse(newRequest("/"))
    }.also { expected ->
      assertThat(expected.message).isEqualTo("boom!")
    }
  }

  @Test
  fun streamedBodyIsRetriedOnHttp2Shutdown() {

import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
	"time"
)

// hasNUL reports whether the NUL character exists within s.
func hasNUL(s string) bool {
	return strings.Contains(s, "\x00")
}

// isASCII reports whether the input is an ASCII C-style string.
func isASCII(s string) bool {
	for _, c := range s {
		if c >= 0x80 || c == 0x00 {
			return false
		}
	}
	return true
}

		Name   string `gorm:"primarykey"`
		Value  string
	}

	type Book struct {
		ID     int
		Name   string
		Labels []Label
	}

	DB.Migrator().DropTable(&Label{}, &Book{})
	if err := DB.AutoMigrate(&Label{}, &Book{}); err != nil {
		t.Fatalf("failed to migrate, got %v", err)
	}

	book := Book{
		Name: "my book",
		Labels: []Label{
			{Name: "region", Value: "emea"},
		},
	}