}

    @Override
    public boolean isDisconnected() {
        return delegate.isDisconnected();
    }

    @Override
    public boolean disconnect(boolean hard, boolean inuse) throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null) {
                try {
                    rdmaConnection.close();

   * gigantic heap, in which case we scale by heap size.
   */
  private static long timeoutSeconds() {
    // This class can make no hard guarantees.  The methods in this class are inherently flaky, but
    // we try hard to make them robust in practice.  We could additionally try to add in a system
    // load timeout multiplier.  Or we could try to use a CPU time bound instead of wall clock time

   * gigantic heap, in which case we scale by heap size.
   */
  private static long timeoutSeconds() {
    // This class can make no hard guarantees.  The methods in this class are inherently flaky, but
    // we try hard to make them robust in practice.  We could additionally try to add in a system
    // load timeout multiplier.  Or we could try to use a CPU time bound instead of wall clock time

 * {@code SmbTransport} collaborator and is used only for
 * demonstration – the real class behaviour is not required for
 * validating constants.
 */
public class SmbConstantsTest {

    /**
     * Verify that the hard‑coded default values are present.
     */
    @Test
    @DisplayName("Default constant values match expectations")
    void defaultValues() {
        assertEquals(445, SmbConstants.DEFAULT_PORT);

   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we
   * would declare a return type of `@Nullable T[]`. However, we've decided not to think too hard
   * about arrays for now, as they're a mess. (We previously discussed this in the review of
   * ObjectArrays, which is the main caller of this method.)
   */

   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we
   * would declare a return type of `@Nullable T[]`. However, we've decided not to think too hard
   * about arrays for now, as they're a mess. (We previously discussed this in the review of
   * ObjectArrays, which is the main caller of this method.)
   */

    avatarUrl: https://avatars.githubusercontent.com/u/9536869?u=652dd0d49717803c0cbcbf44f7740e53cf2d4892&v=4
    url: https://github.com/DMantis
  - login: hard-coders
    avatarUrl: https://avatars.githubusercontent.com/u/9651103?u=95db33927bbff1ed1c07efddeb97ac2ff33068ed&v=4
    url: https://github.com/hard-coders
  - login: supdann
    avatarUrl: https://avatars.githubusercontent.com/u/9986994?u=9671810f4ae9504c063227fee34fd47567ff6954&v=4

* full-stack: full-stack (do not translate to "de pila completa")
* stack: stack (do not translate to "pila")
* loop (as in async loop): loop (do not translate to "bucle" or "ciclo")
* hard dependencies: dependencias obligatorias (do not translate to "dependencias duras")
* locking: locking (do not translate to "bloqueo")
* testing (as in software testing): escribir pruebas (do not translate to "probar")

		}
	}
	return nil
}

// bitrotSelfTest performs a self-test to ensure that bitrot
// algorithms compute correct checksums. If any algorithm
// produces an incorrect checksum it fails with a hard error.
//
// bitrotSelfTest tries to catch any issue in the bitrot implementation
// early instead of silently corrupting data.
func bitrotSelfTest() {
	checksums := map[BitrotAlgorithm]string{

    val server = serverListener.assertOpen()

    // Initiate a close on the client, which will schedule a hard cancel in 500 ms.
    val closeAtNanos = System.nanoTime()
    webSocket.close(1000, "goodbye", 500L)
    serverListener.assertClosing(1000, "goodbye")

    // Confirm that the hard cancel occurred after 500 ms.
    clientListener.assertFailure()
    val elapsedUntilFailure = System.nanoTime() - closeAtNanos