Then you can use the new `settings` object in your application:

{* ../../docs_src/settings/tutorial001_py310.py hl[18:20] *}

### Run the server { #run-the-server }

Next, you would run the server passing the configurations as environment variables, for example you could set an `ADMIN_EMAIL` and `APP_NAME` with:

<div class="termy">

```console
$ ADMIN_EMAIL="******@****.***" APP_NAME="ChimichangApp" fastapi run main.py

                /*
                 * The SMB_COM_NT_CREATE_ANDX response wordCount is wrong. There's an
                 * extra 16 bytes for some "Offline Files (CSC or Client Side Caching)"
                 * junk. We need to bump up the wordCount here so that this method returns
                 * the correct number of bytes for signing purposes. Otherwise we get a
                 * signing verification failure.

   * Number value = first.or(0.5); // error
   * }
   *
   * <p>As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
   * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
   * Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
   *
   * {@snippet :

controlled by the [`x509sha1` setting](/pkg/crypto/x509#InsecureAlgorithmError).
This setting was removed in Go 1.24.

### Go 1.10

Go 1.10 changed how build caching worked and added test caching, along
with the [`gocacheverify`, `gocachehash`, and `gocachetest` settings](/cmd/go/#hdr-Build_and_test_caching).
There is no plan to remove these settings.

### Go 1.6

    response1.close()

    // Force a fresh connection for the next request.
    client.connectionPool.evictAll()

    // Confirm that a second request also succeeds. This should detect caching problems.
    server.enqueue(
      MockResponse
        .Builder()
        .body("def")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val call2 =
      client.newCall(

   * Number value = first.or(0.5); // error
   * }
   *
   * <p>As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
   * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
   * Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
   *
   * {@snippet :

 * reasonable and it will be fine.
 *
 * <ul>
 *   <li>If checking whether the <i>caller</i> has violated your method or constructor's contract
 *       (such as by passing an invalid argument), use the utilities of the {@link Preconditions}
 *       class instead.
 *   <li>If checking an <i>impossible</i> condition (which <i>cannot</i> happen unless your own

        }
      }

      static class Gist {
        Map<String, GistFile> files;
      }

      static class GistFile {
        String content;
      }
    ```

### Response Caching ([.kt][CacheResponseKotlin], [.java][CacheResponseJava])

  TFE_DeleteOp(op);

  // The device of var_handle1 is remote device, which was replaced during
  // cluster update. Removing resource with invalid device should fail
  // gracefully (i.e., with error status) instead of crashing with segfaults.
  op = TFE_NewOp(ctx, "DestroyResourceOp", status);
  ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_OpAddInput(op, var_handle1, status);
  TFE_OpSetDevice(op, dev1_name, status);

            assertTrue(exception.getCause() instanceof UnsupportedEncodingException, "Cause should be UnsupportedEncodingException");
        }
    }

    @Nested
    @DisplayName("Secret Masking Tests")
    class SecretMaskingTests {

        @ParameterizedTest
        @DisplayName("maskSecretValue should mask SMB URLs containing credentials")