/**
 * This interface supplies the API for providing feedback to the user from the {@code Mojo},
 * using standard Maven channels.
 * There should be no big surprises here, although you may notice that the methods accept
 * <code>java.lang.CharSequence</code> rather than <code>java.lang.String</code>. This is provided mainly as a
 * convenience, to enable developers to pass things like <code>java.lang.StringBuffer</code> directly into the logger,

            BufferCache.releaseBuffer(nullBuffer); // Should ignore null
            BufferCache.releaseBuffer(wrongSizeBuffer); // Should ignore wrong size
            BufferCache.releaseBuffer(correctBuffer); // Should accept correct size
        });
    }

    /**
     * Test concurrent buffer allocation and release for thread safety.
     */
    @Test
    public void testConcurrentBufferOperations() throws Exception {

	return h.reqPool.Get()
}

// PutRequest will accept a request for reuse.
// These should be returned by the handler.
func (h *StreamTypeHandler[Payload, Req, Resp]) PutRequest(r Req) {
	if r != h.nilReq {
		//nolint:staticcheck // SA6002 IT IS A GENERIC VALUE! (and always a pointer)
		h.reqPool.Put(r)
	}
}

// PutResponse will accept a response for reuse.
// These should be returned by the caller.

Por ejemplo, supongamos que quieres tener una *path operation* que permita actualizar elementos, y devuelva códigos de estado HTTP de 200 "OK" cuando sea exitoso.

Pero también quieres que acepte nuevos elementos. Y cuando los elementos no existían antes, los crea y devuelve un código de estado HTTP de 201 "Created".

  }

  private fun doServerHandshake(server: HandshakeCertificates): Future<Handshake> {
    return executorService.submit<Handshake> {
      serverSocket!!.accept().use { rawSocket ->
        val sslSocket =
          server.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,

   * an exception if parsing fails. Additionally, this method only accepts ASCII digits, and returns
   * {@code null} if non-ASCII digits are present in the string.
   *
   * <p>Note that strings prefixed with ASCII {@code '+'} are rejected, even though {@link
   * Integer#parseInt(String)} accepts them.
   *
   * @param string the string representation of a long value

/// tip

Here we are using `Query()` because this is a **query parameter**. Later we will see others like `Path()`, `Body()`, `Header()`, and `Cookie()`, that also accept the same arguments as `Query()`.

///

FastAPI will now:

* **Validate** the data making sure that the max length is 50 characters
* Show a **clear error** for the client when the data is not valid

		r.readCloser.Close()
	}
	if r.exitReader != nil {
		close(r.exitReader)
		r.readerWg.Wait()
		r.exitReader = nil
		r.input = nil
	}
	return nil
}

// startReader will start a reader that accepts input from r.input.
// Input should be root -> object input. Each root indicates a record.
// If r.input is closed, it is assumed that no more input will come.

            assertNotNull(writeRequest);
        }

        @Test
        @DisplayName("Should accept null file ID in constructor")
        void testConstructorWithNullFileId() {
            assertDoesNotThrow(() -> new Smb2WriteRequest(mockConfig, null));
        }

        @Test
        @DisplayName("Should accept empty file ID in constructor")
        void testConstructorWithEmptyFileId() {

		return
	}

	m.wg.Add(1)
	defer m.wg.Done()

	if atomic.LoadInt32(&m.closing) == 1 {
		return
	}

	select {
	case m.opCh <- op:
	default:
	}
}

// Do not accept new MRF operations anymore and start to save
// the current heal status in one available disk
func (m *mrfState) shutdown() {
	atomic.StoreInt32(&m.closing, 1)
	m.wg.Wait()
	close(m.opCh)