if (!mechs.contains(NtlmContext.NTLMSSP_OID)) {
                        throw new SmbUnsupportedOperationException("Server does not support NTLM authentication");
                    }
                }
            }
        } catch (SmbException e) {
            throw e;
        } catch (IOException e1) {
            log.debug("Ignoring invalid initial token", e1);
        }

    resetMap(createArrayWithNullValue());
  }

  /**
   * Equivalent to {@link #expectMissingKeys(Object[]) expectMissingKeys} {@code (null)} except that
   * the call to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {

        }

        final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        if (systemClassLoader != null) {
            return systemClassLoader;
        }

        throw new ClIllegalStateException(MessageFormatter.getMessage("ECL0001", "ClassLoader"));
    }

    /**
     * Returns <code>true</code> if the class loader <code>other</code> is an ancestor of the class loader <code>cl</code>.

                statusField.setAccessible(true);
                statusField.set(this, status);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public void setFlagsForTest(int flags) {
            // Workaround: Use reflection to set private flags field
            try {

        if (password == null) {
            throw new RuntimeException("Password parameter is required");
        }
        try {
            final MD4 md4 = new MD4();
            md4.update(password.getBytes(SmbConstants.UNI_ENCODING));
            return md4.digest();
        } catch (final UnsupportedEncodingException uee) {
            throw new RuntimeException(uee.getMessage());
        }
    }

            try {
                final boolean isTimeout = !latch.await(time, unit);
                if (isTimeout) {
                    throw new SuggesterException("Request timeout. time:" + time + " unit:" + unit.name());
                }
                if (error != null) {
                    throw new SuggesterException("An error occurred during the deferred computation.", error);
                }
                return response;

                throw new SsoLoginException("could not validate nonce");
            }

            final String nonce = (String) claimsSet.getClaim("nonce");
            if (logger.isDebugEnabled()) {
                logger.debug("nonce={}", nonce);
            }
            if (StringUtils.isEmpty(nonce) || !nonce.equals(stateData.getNonce())) {
                throw new SsoLoginException("could not validate nonce");

            case HALF_UP:
              return (x >= 0) ? roundCeilingAsDouble : roundFloorAsDouble;
            default:
              throw new AssertionError("impossible");
          }
        }
    }
    throw new AssertionError("impossible");
  }

  /**
   * Returns the closest representable {@code long} to the absolute value of {@code x}.
   *

        pkcs8Base64Text.decodeBase64()
          ?: throw IllegalArgumentException("failed to decode private key")

      // The private key doesn't tell us its type but it's okay because the certificate knows!
      val keyType =
        when (certificate.publicKey) {
          is ECPublicKey -> "EC"
          is RSAPublicKey -> "RSA"
          else -> throw IllegalArgumentException("unexpected key type: ${certificate.publicKey}")

        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;
        case TIMED_WAITING:
          return;
        case TERMINATED:
          throw new AssertionError();
      }
    }
  }

  public void testDirectExecutorService_shutdownNow() {
    ExecutorService executor = newDirectExecutorService();