for (int i = 0; i < 8; i++) {
            if (signature[i] != data[offset + SmbConstants.SIGNATURE_OFFSET + i]) {
                if (log.isDebugEnabled()) {
                    log.debug("signature verification failure"); //$NON-NLS-1$
                    log.debug("Expect: " + Hexdump.toHexString(signature, 0, 8));
                    log.debug("Have: " + Hexdump.toHexString(data, offset + SmbConstants.SIGNATURE_OFFSET, 8));
                }

                    }
                }
                masterKey = null;

                log.debug("SecureCredentialStorage destroyed");

                // If we had a non-critical destroy failure, throw it now
                if (failedToDestroy && destroyException != null) {
                    throw new DestroyFailedException("Partial destroy: " + destroyException.getMessage());
                }

        // In a real scenario, the connection would reconnect and send Type1/Type3 messages
        // This simplified test just verifies the initial handshake detection
    }

    /**
     * Test handshake failure when the server does not return an NTLM challenge.
     * @throws IOException
     */
    @Test
    void testHandshakeFails_NoNtlmChallenge() throws IOException {
        // Arrange

        File artifactFile = new File(repository.getBasedir(), path);

        if (artifactFile.exists()) {
            if (!artifactFile.delete()) {
                throw new IOException("Failure while attempting to delete artifact " + artifactFile);
            }
        }
    }

    protected DefaultRepositorySystemSession initRepoSession() throws Exception {

# Application Exception
# ---------------------
# /- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# five framework-embedded messages (don't change key names)
# - - - - - - - - - -/
errors.login.failure = Anmeldung fehlgeschlagen.
errors.app.illegal.transition = Ungültiger Übergang. Bitte versuchen Sie es erneut.

 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *

 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such
 * cases the consuming thread must call [close] when it has finished reading the response

 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *

    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);
      }
      return;
    }
    fail("expected failure not reported");
  }

  private class ForwardingRunnable implements Runnable {

    private final Runnable runnable;

    ForwardingRunnable(Runnable runnable) {
      this.runnable = runnable;
    }

## Version 4.12.0

_2023-10-16_

 *  Fix: Don't hang taking headers for HTTP 103 responses.

 *  Fix: Recover gracefully when a cache entry's certificate is corrupted.

 *  Fix: Fail permanently when there's a failure loading the bundled public suffix database.
    This is the dataset that powers `HttpUrl.topPrivateDomain()`.

 *  Fix: Immediately update the connection's flow control window instead of waiting for the