errors.invalid_query_unknown = A consulta especificada tem condições desconhecidas.
errors.invalid_query_parse_error = A consulta fornecida é inválida.
errors.invalid_query_sort_value = A ordenação especificada {0} é inválida.
errors.invalid_query_unsupported_sort_field = O campo de ordenação especificado {0} não é suportado.

        when(handle.isValid()).thenReturn(true);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        sut.close();

        verify(handle, times(1)).close(0L);
    }

    // close() should do nothing when handle is invalid
    @Test
    @DisplayName("close() does nothing when handle invalid")
    void close_invalidHandle_doesNothing() throws Exception {

O `RequestValidationError` contém o `body` que ele recebeu de dados inválidos.

Você pode utilizá-lo enquanto desenvolve seu app para conectar o *body* e debugá-lo, e assim retorná-lo ao usuário, etc.

Tente enviar um item inválido como este:

```JSON
{
  "title": "towel",
  "size": "XL"
}
```

Você receberá uma *response* informando-o de que a data é inválida, e contendo o *body* recebido:

```JSON hl_lines="12-15"

    }

    /**
     * Test isValid() when the handle is valid.
     */
    @Test
    void testIsValid_whenValid() {
        when(smbFileHandle.isValid()).thenReturn(true);
        assertTrue(smbFileHandle.isValid(), "isValid should return true when the handle is valid.");
        verify(smbFileHandle, times(1)).isValid();
    }

    /**
     * Test isValid() when the handle is invalid.
     */
    @Test

            fail("Expected CIFSException");
        } catch (CIFSException e) {
            // Expected
        }

        assertFalse(context.isValid());

        // Further operations on invalid context should fail
        assertThrows(CIFSException.class, () -> {
            preauthService.updatePreauthHash(sessionId, "test".getBytes());
        });
    }

    @Test

func (s *peerRESTServer) HealthHandler(w http.ResponseWriter, r *http.Request) {
	s.IsValid(w, r)
}

// VerifyBinary - verifies the downloaded binary is in-tact
func (s *peerRESTServer) VerifyBinaryHandler(w http.ResponseWriter, r *http.Request) {
	if !s.IsValid(w, r) {
		s.writeErrorResponse(w, errors.New("Invalid request"))
		return
	}

	if r.ContentLength < 0 {

      ParseException parseException = new ParseException("Invalid host specifier: " + specifier, 0);
      parseException.initCause(e);
      throw parseException;
    }
  }

  /**
   * Determines whether {@code specifier} represents a valid {@link HostSpecifier} as described in
   * the documentation for {@link #fromValid(String)}.
   */
  public static boolean isValid(String specifier) {
    try {

        // Re-prepare state for second branch: not open but handle set
        when(fileHandle.isValid()).thenReturn(false);
        // Need to reopen logic to set handle again
        // Reset open flag by reconstructing target
        target = new SmbPipeHandleImpl(pipe);

        target.ensureOpen(); // handle present but invalid per isValid=false
        target.close();
        verify(fileHandle, atLeastOnce()).release();
    }

        }

        @Test
        @DisplayName("Should detect invalid signature")
        void testVerifyInvalidSignature() {
            // Set signed flag
            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, data, 16);

            // Place invalid signature
            byte[] invalidSignature = new byte[SIGNATURE_LENGTH];

  override fun getCreationTime(): Long = delegate!!.creationTime

  override fun getLastAccessedTime(): Long = delegate!!.lastAccessedTime

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean = delegate!!.isValid

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }