Na sobrescrita da dependência definimos um novo valor para `admin_email` ao criar o novo objeto `Settings`, e então retornamos esse novo objeto.

Depois podemos testar que ele é usado.

## Lendo um arquivo `.env` { #reading-a-env-file }

Se você tiver muitas configurações que possivelmente mudam bastante, talvez em diferentes ambientes, pode ser útil colocá-las em um arquivo e então lê-las como se fossem variáveis de ambiente.

    editor.commit()
  }

  @Test
  fun `Windows cannot write while reading`() {
    Assumptions.assumeTrue(windows)

    set("k1", "a", "a")
    val snapshot = cache["k1"]!!
    assertThat(cache.edit("k1")).isNull()
    snapshot.close()
  }

  @Test
  fun `can read while reading`() {
    set("k1", "a", "a")
    cache["k1"]!!.use { snapshot1 ->

		if s3Error != testCase.s3Error {
			if _, err := io.ReadAll(testCase.req.Body); toAPIErrorCode(ctx, err) != testCase.s3Error {
				t.Fatalf("Test %d: Unexpected S3 error: want %d - got %d (got after reading request %s)", i, testCase.s3Error, s3Error, toAPIError(ctx, err).Code)
			}
		}
	}
}

func TestCheckAdminRequestAuthType(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

		ContentType: mime.TypeByExtension(filepath.Ext(object)),
	}

	var rc io.ReadCloser

	if file.UncompressedSize64 > 0 {
		// There may be number of header bytes before the content.
		// Reading 64K extra. This should more than cover name and any "extra" details.
		end := min(file.Offset+int64(file.CompressedSize64)+64<<10, zipObjInfo.Size)
		rs := &HTTPRangeSpec{Start: file.Offset, End: end}

   */
  open fun responseBodyStart(call: Call) {
  }

  /**
   * Invoked immediately after receiving a response body and completing reading it.
   *
   * Will only be invoked for requests having a response body e.g. won't be invoked for a web socket
   * upgrade.
   *
   * If the response body is closed before the response body is exhausted, this is invoked at the

    assertThat(cookie.matches("http://www.example.com".toHttpUrl())).isFalse()
    assertThat(cookie.matches("http://square.com".toHttpUrl())).isFalse()
  }

  /** Ignore an optional leading `.` in the domain.  */
  @Test fun domainMatchesIgnoresLeadingDot() {
    val cookie = parse(url, "a=b; domain=.example.com")
    assertThat(cookie!!.matches("http://example.com".toHttpUrl())).isTrue()

But that means that if you just convert it to a string and return that information directly, you could be leaking a bit of information about your system, that's why here the code extracts and shows each error independently.

///

### Use the `RequestValidationError` body { #use-the-requestvalidationerror-body }

        try {
            context.extensions = readCoreExtensionsDescriptor(context);
        } catch (Exception e) {
            context.parsingFailed = true;
            parserRequest.logger().error("Error reading core extensions descriptor", e);
        }

        // CI detection
        context.ciInfo = detectCI(context);

        // only if not failed so far; otherwise we may have no options to validate

	if err != nil {
		return "", fmt.Errorf("request err: %v", err)
	}
	// {
	// 	bodyBuf, err := io.ReadAll(resp.Body)
	// 	if err != nil {
	// 		return "", fmt.Errorf("Error reading body: %v", err)
	// 	}
	// 	fmt.Printf("bodyBuf (for LDAP login page): %s\n", string(bodyBuf))
	// }

	// Fill the login form with our test creds:
	// fmt.Printf("login form url: %s\n", lastReq.URL.String())

import okio.Buffer

/**
 * A connection to a remote web server capable of carrying 1 or more concurrent streams.
 *
 * Connections are shared in a connection pool. Accesses to the connection's state must be guarded
 * by holding a lock on the connection.
 */
class RealConnection internal constructor(
  val taskRunner: TaskRunner,
  val connectionPool: RealConnectionPool,
  override val route: Route,
  /** The low-level TCP socket. */