<la:option value="OFF">OFF</la:option>
                                            <la:option value="FATAL">FATAL</la:option>
                                            <la:option value="ERROR">ERROR</la:option>
                                            <la:option value="WARN">WARN</la:option>

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		w.Write(c)
	})

	address := fmt.Sprintf(":%v", port)
	log.Printf("listening on http://%s/", address)
	log.Fatal(http.ListenAndServe(address, nil))

func TestQueryScanToArray(t *testing.T) {
	err := DB.Create(&User{Name: "testname1", Age: 10}).Error
	if err != nil {
		t.Fatal(err)
	}

	users := [2]*User{{Name: "1"}, {Name: "2"}}
	err = DB.Model(&User{}).Where("name = ?", "testname1").Find(&users).Error
	if err != nil {
		t.Fatal(err)
	}
	if users[0] == nil || users[0].Name != "testname1" {
		t.Error("users[0] not covered")
	}
	if users[1] != nil {

	if err := DB.Joins("NamedPet", onQuery4).Where("users.name = ?", user.Name).First(&user4).Error; err != nil {
		t.Fatalf("Failed to load with joins on, got error: %v", err)
	}
	if user4.NamedPet.ID == 0 {
		t.Fatal("Pet ID can not be empty")
	}
	AssertEqual(t, user4.NamedPet.Name, "")
}

func TestNestedJoins(t *testing.T) {
	users := []User{
		{
			Name: "nested-joins-1",
			Manager: &User{

// Tests for issue reproduced when getting the right encrypted
// offset of the object.
func TestGetDecryptedRange_Issue50(t *testing.T) {
	rs, err := parseRequestRangeSpec("bytes=594870256-594870263")
	if err != nil {
		t.Fatal(err)
	}

	objInfo := ObjectInfo{
		Bucket: "bucket",
		Name:   "object",
		Size:   595160760,
		UserDefined: map[string]string{
			crypto.MetaMultipart:                   "",

	}

	for _, testCase := range testCases {
		u, err := url.Parse(testCase.releaseChecksumURL)
		if err != nil {
			t.Fatal(err)
		}

		result, err := downloadReleaseURL(u, 1*time.Second, "")
		switch {
		case testCase.expectedErr == nil:
			if err != nil {
				t.Fatalf("error: expected: %v, got: %v", testCase.expectedErr, err)

3. Instale o Poetry nesse estágio do Docker.

4. Copie os arquivos `pyproject.toml` e `poetry.lock` para o diretório `/tmp`.

    Porque está usando `./poetry.lock*` (terminando com um `*`), não irá falhar se esse arquivo ainda não estiver disponível.

5. Gere o arquivo `requirements.txt`.

6. Este é o estágio final, tudo aqui será preservado na imagem final do contêiner.

          true
        } catch (cnfe: ClassNotFoundException) {
          false
        }

      val isCorrettoSupported: Boolean =
        try {
          // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
          Class.forName("com.amazon.corretto.crypto.provider.AmazonCorrettoCryptoProvider")

          AmazonCorrettoCryptoProvider.INSTANCE.loadingError == null &&

	localIP6 = mustGetLocalIP6()

	// List of all local loopback addresses.
	localLoopbacks = mustGetLocalLoopbacks()
)

// mustSplitHostPort is a wrapper to net.SplitHostPort() where error is assumed to be a fatal.
func mustSplitHostPort(hostPort string) (host, port string) {
	xh, err := xnet.ParseHost(hostPort)
	if err != nil {
		logger.FatalIf(err, "Unable to split host port %s", hostPort)
	}
	return xh.Name, xh.Port.String()

    if (!client.retryOnConnectionFailure) return false

    // We can't send the request body again.
    if (requestSendStarted && requestIsOneShot(e, userRequest)) return false

    // This exception is fatal.
    if (!isRecoverable(e, requestSendStarted)) return false

    // No more routes to attempt.
    if (!call.retryAfterFailure()) return false