}

    /**
     * Set the domain pattern for this cookie. The cookie will match [domain] and all of its
     * subdomains.
     */
    fun domain(domain: String): Builder = domain(domain, false)

    /**
     * Set the host-only domain for this cookie. The cookie will match [domain] but none of
     * its subdomains.
     */
    fun hostOnlyDomain(domain: String): Builder = domain(domain, true)

    final Range<C> range;
    final DiscreteDomain<C> domain;

    private SerializedForm(Range<C> range, DiscreteDomain<C> domain) {
      this.range = range;
      this.domain = domain;
    }

    private Object readResolve() {
      return new RegularContiguousSet<>(range, domain);
    }
  }

  @GwtIncompatible
  @J2ktIncompatible
    @Override

  private static final class SerializedForm<C extends Comparable> implements Serializable {
    private final DiscreteDomain<C> domain;

    private SerializedForm(DiscreteDomain<C> domain) {
      this.domain = domain;
    }

    private Object readResolve() {
      return new EmptyContiguousSet<>(domain);
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

        }
    }

    /**
     * Validates domain name
     *
     * @param domain the domain to validate
     * @throws IllegalArgumentException if domain is invalid
     */
    public static void validateDomain(String domain) {
        if (domain == null) {
            return; // Null domain allowed
        }
        if (domain.length() > MAX_DOMAIN_LENGTH) {

    @Test
    public void testEqualsWithPassword() {
        NtlmPasswordAuthenticator auth1 = new NtlmPasswordAuthenticator("DOMAIN", "user", "pass123");
        NtlmPasswordAuthenticator auth2 = new NtlmPasswordAuthenticator("DOMAIN", "user", "pass123");
        NtlmPasswordAuthenticator auth3 = new NtlmPasswordAuthenticator("DOMAIN", "user", "differentPass");

        assertEquals(auth1, auth2, "Authenticators with same credentials should be equal");

        assertEquals(1, parameterMap.size());
        assertEquals("D", parameterMap.get("domain"));

        parameters = "domain=DOMAIN";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());
        assertEquals("DOMAIN", parameterMap.get("domain"));

        parameters = "\n";
        parameterMap = ParameterUtil.parse(parameters);

    /**
     * Create username/password credentials with specified domain
     *
     * @param domain the authentication domain
     * @param username the username
     * @param passwordHash
     *            NT password hash
     */
    public NtlmNtHashAuthenticator(final String domain, final String username, final byte[] passwordHash) {
        super(domain, username, (String) null, AuthenticationType.USER);

            // System properties should take precedence (if implemented)
            String domain = testConfig.getDefaultDomain();
            assertTrue(domain.equals("systemdomain") || domain.equals("propsdomain"));

        } finally {
            // Cleanup
            if (originalValue != null) {
                System.setProperty("jcifs.smb.client.domain", originalValue);
            } else {

     * @param serviceName
     *            JAAS configuration name
     * @param domain the domain for authentication
     * @param username the username for authentication
     * @param password the password for authentication
     */
    public JAASAuthenticator(String serviceName, String domain, String username, String password) {
        super(null, domain, username, password);
        this.serviceName = serviceName;
    }

    /**

            this.authType = authType;
            this.timestamp = System.currentTimeMillis();
            this.clientAddress = clientAddress;
            this.serverAddress = serverAddress;
        }

        public String getUsername() {
            return username;
        }

        public String getDomain() {
            return domain;
        }