request.setPath(dunc);
                }

                if (!t.getShare().equals(dr.getShare())) {
                    // this should only happen for standalone roots or if the DC/domain root lookup failed
                    IOException last;
                    final DfsReferralData start = dr;
                    do {
                        if (log.isDebugEnabled()) {

        SmbResourceLocatorImpl bad = locator("smb://badhost/");
        CIFSException ex = assertThrows(CIFSException.class, bad::getAddress);
        assertTrue(ex.getMessage().contains("Failed to lookup address"));
    }

    @Test
    @DisplayName("hashCode/equals based on address or server fallback")
    void testEqualsAndHashCode() throws Exception {
        UniAddress a = mock(UniAddress.class);

    //    second thread can then dispatch to the subscriber it took before the first thread does.
    //
    // All this makes me really wonder if there's any value in queueing here at all. A dispatcher
    // that simply loops through the subscribers and dispatches the event to each would actually
    // probably provide a stronger order guarantee, though that order would obviously be different
    // in some cases.

    /** Global event queue. */

        assertThat(UnsignedInts.parseUnsignedInt(Long.toString(a, radix), radix))
            .isEqualTo((int) a);
      }
    }
  }

  public void testParseIntWithRadixLimits() {
    // loops through all legal radix values.
    for (int r = Character.MIN_RADIX; r <= Character.MAX_RADIX; r++) {
      int radix = r;
      // tests can successfully parse a number string with this radix.

      processCalled--; // don't count the tail invocation (makes tests a bit more understandable)
    }

    // ensures that the number of invocations looks sane
    void assertInvariants(int expectedBytes) {
      // we should have seen as many bytes as the next multiple of chunk after expectedBytes - 1

    assertTrue(map.isEmpty());
  }

  // ----------------------------------------------------------------
  // Test that interrupts result in RuntimeException, not InterruptedException.
  // Trickier than it looks, because runFinalization swallows interrupts.
  // ----------------------------------------------------------------

  class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

     * This method handles the resolution of SPNEGO credentials by checking
     * if the user is an admin user or needs to be authenticated through LDAP.
     *
     * @param resolver The credential resolver to use for user lookup
     */
    @Override
    public void resolveCredential(final LoginCredentialResolver resolver) {
        resolver.resolve(SpnegoCredential.class, credential -> {

    `Response.networkResponse`, and `Response.priorResponse`. In such cases the body is now
    non-null, but attempts to read its content will fail.
 *  New: Kotlin-specific APIs for request tags. Kotlin language users can lookup tags with a type
    parameter only, like `request.tag<MyTagClass>()`.
 *  New: MockWebServer has improved support for HTTP/1xx responses. Once you've migrated to the new

     *
     * ```
     * http://google.com/foo
     * GET
     * 2
     * Accept-Language: fr-CA
     * Accept-Charset: UTF-8
     * HTTP/1.1 200 OK
     * 3
     * Content-Type: image/png
     * Content-Length: 100
     * Cache-Control: max-age=600
     * ```
     *
     * A typical HTTPS file looks like this:
     *
     * ```

     */
    @Override
    public boolean verifySignature(final byte[] buffer, final int i, final int size) {
        // observed too that signatures on error responses are sometimes wrong??
        // Looks like the failure case also is just reflecting back the signature we sent

        // with SMB3's negotiation validation it's no longer possible to ignore this (on the validation response)