/** Returns true if the [String] is ASCII encoded (0-127). */
  private fun String.isAscii() = length == utf8Size().toInt()

  /**
   * Returns true if [hostname] matches the domain name [pattern].
   *
   * @param hostname lower-case host name.
   * @param pattern domain name pattern from certificate. May be a wildcard pattern such as
   *     `*.android.com`.
   */
  private fun verifyHostname(
    hostname: String?,

        }

        @Test
        @DisplayName("Should fixup domain")
        void testFixupDomain() {
            String domain = "example.com";

            // Test with mock
            doNothing().when(mockReferralData).fixupDomain(domain);
            mockReferralData.fixupDomain(domain);
            verify(mockReferralData, times(1)).fixupDomain(domain);

     * domain, username, and password. Parameters that are {@code null}
     * will be substituted with {@code jcifs.smb.client.domain},
     * {@code jcifs.smb.client.username}, {@code jcifs.smb.client.password}
     * property values.
     *
     * @param tc
     *            context to use
     * @param domain the authentication domain
     * @param username the username to authenticate with

     * Generates the NTOWFv2 hash for the given domain, username, and password.
     *
     * @param domain the authentication domain
     * @param username the username
     * @param password the password
     *
     * @return the calculated mac
     */
    public static byte[] nTOWFv2(final String domain, final String username, final String password) {
        return nTOWFv2(domain, username, getNTHash(password));
    }

    }

    // It is not any kind of IP address; must be a domain name or invalid.

    // TODO(user): different versions of this for different factories?
    InternetDomainName domain = InternetDomainName.from(host);

    if (domain.hasPublicSuffix()) {
      return new HostSpecifier(domain.toString());
    }

    throw new IllegalArgumentException(
        "Domain name does not have a recognized public suffix: " + host);
  }

        NtlmPasswordAuthenticator startAuth = new NtlmPasswordAuthenticator("domain", "user", new String(diffAtStart));
        NtlmPasswordAuthenticator middleAuth = new NtlmPasswordAuthenticator("domain", "user", new String(diffAtMiddle));
        NtlmPasswordAuthenticator endAuth = new NtlmPasswordAuthenticator("domain", "user", new String(diffAtEnd));

        try {

      assertFalse(name, domain.isPublicSuffix());
      assertFalse(name, domain.hasPublicSuffix());
      assertFalse(name, domain.isUnderPublicSuffix());
      assertFalse(name, domain.isTopPrivateDomain());
      assertNull(domain.publicSuffix());
    }

    for (String name : NON_PS) {
      InternetDomainName domain = InternetDomainName.from(name);

    void testNTOWFv2_overloadsAndDomainSensitivity() {
        // Arrange
        String domain = "Domain";
        String user = "User";
        String password = "password";

        // Act
        byte[] viaHash = NtlmUtil.nTOWFv2(domain, user, NtlmUtil.getNTHash(password));
        byte[] viaPassword = NtlmUtil.nTOWFv2(domain, user, password);

   * assertNull(getEffectiveTldPlusOne("mymacbook"));
   * ```
   *
   * @param domain A canonicalized domain. An International Domain Name (IDN) should be punycode
   *     encoded.
   */
  fun getEffectiveTldPlusOne(domain: String): String? {
    // We use UTF-8 in the list so we need to convert to Unicode.
    val unicodeDomain = IDN.toUnicode(domain)
    val domainLabels = splitDomain(unicodeDomain)

    }

    /**
     * Test domain constructor with char array
     */
    @Test
    public void testDomainCharArrayConstructor() {
        char[] testPassword = "DomainPass321!".toCharArray();
        NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("DOMAIN", "testuser", testPassword);

        assertEquals("DOMAIN", auth.getUserDomain());