}

    @Override
    public void ignoreNullOrEmptyQuery() {
    }

    @Override
    public void checkNullOrEmptyQuery() {
    }

    @Override
    public void enableEmptyStringQuery(ModeQuery noArgInLambda) {
        // do nothing
    }

    @Override
    public void disableEmptyStringQuery() {
    }

    @Override
    public void enableOverridingQuery(ModeQuery noArgInLambda) {

    @Test
    public void testInfo() throws Exception {
        logger.info("info");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testWarn() throws Exception {
        logger.warn("warn");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testError() throws Exception {
        logger.error("error");
    }

    /**
     * @throws Exception

    public void setFrom(String from, String personal) {
        doSetFrom(from, personal);
    }

    public void addTo(String to) {
        doAddTo(to);
    }

    public void addTo(String to, String personal) {
        doAddTo(to, personal);
    }

    public void addCc(String cc) {
        doAddCc(cc);
    }

    public void addCc(String cc, String personal) {

</div>

## Proibindo Cabeçalhos adicionais { #forbid-extra-headers }

Em alguns casos de uso especiais (provavelmente não muito comuns), você pode querer **restringir** os cabeçalhos que você quer receber.

Você pode usar a configuração dos modelos do Pydantic para proibir (`forbid`) quaisquer campos `extra`:

{* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *}

        public void columnId() {
            doColumn("_id");
        }

        public void columnConfigId() {
            doColumn("configId");
        }

        public void columnErrorCount() {
            doColumn("errorCount");
        }

        public void columnErrorLog() {
            doColumn("errorLog");
        }

        public void columnErrorName() {
            doColumn("errorName");

      this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
      countDownLatch.countDown();
    }
  }

  public void testExceptionsCaught() {
    list.add(THROWING_RUNNABLE, directExecutor());
    list.execute();
    list.add(THROWING_RUNNABLE, directExecutor());
  }

  public void testNulls() {
    new NullPointerTester().testAllPublicInstanceMethods(new ExecutionList());

    }
  }

  public void testByteArrayHashtable() {
    hashtableTestHelper(ImmutableList.of(2, 89));
  }

  public void testShortArrayHashtable() {
    hashtableTestHelper(ImmutableList.of(90, 22937));
  }

  public void testIntArrayHashtable() {
    hashtableTestHelper(ImmutableList.of(22938));
  }

  // Non-creation tests

  public void testNullGet() {

   * stream may perform better.
   *
   * @see Stream#concat(Stream, Stream)
   */
  @SuppressWarnings("unchecked") // could probably be avoided with a forwarding Spliterator
  @SafeVarargs
  public static <T extends @Nullable Object> Stream<T> concat(Stream<? extends T>... streams) {
    // TODO(lowasser): consider an implementation that can support SUBSIZED

        ctx = new Kerb5Context("host.example", "cifs", null, 0, 0, null);
    }

    @AfterEach
    void tearDown() {
        if (mockedStatic != null) {
            mockedStatic.close();
        }
    }

    private static void setPrivateField(Object target, String name, Object value) throws Exception {
        Field f = target.getClass().getDeclaredField(name);

    private byte[] testKey;

    @BeforeEach
    public void setUp() {
        keyManager = new SecureKeyManager();
        testKey = new byte[16];
        new SecureRandom().nextBytes(testKey);
    }

    @AfterEach
    public void tearDown() {
        if (keyManager != null) {
            keyManager.close();
        }
    }

    @Test
    public void testStoreAndRetrieveKey() {