}
    }

    /**
     * Validates a port number
     *
     * @param port the port number to validate
     * @throws IllegalArgumentException if port is invalid
     */
    public static void validatePort(int port) {
        if (port < 1 || port > 65535) {
            throw new IllegalArgumentException("Invalid port number: " + port);
        }
    }

    /**

 * version.
 * <p>
 * Each branch has a current version, and expected compatible versions are parsed from the server code's Version` class.
 * We can reliably figure out which the unreleased versions are due to the convention of always adding the next unreleased
 * version number to server in all branches when a version is released.

   * be logged if the test fails.
   *
   * This client is also configured to be slightly more deterministic, returning a single IP
   * address for all hosts, regardless of the actual number of IP addresses reported by DNS.
   */
  fun newClient(): OkHttpClient {
    var client = testClient
    if (client == null) {
      client =
        initialClientBuilder()

        /** The low field of the timestamp */
        public int time_low;
        /** The middle field of the timestamp */
        public short time_mid;
        /** The high field of the timestamp multiplexed with the version number */
        public short time_hi_and_version;
        /** The high field of the clock sequence multiplexed with the variant */
        public byte clock_seq_hi_and_reserved;
        /** The low field of the clock sequence */

     */
    @Nonnull
    Optional<Boolean> alsoMakeDependents();

    /**
     * Returns the number of threads used for parallel builds.
     *
     * @return an {@link Optional} containing the number of threads (or "1C" for one thread per CPU core), or empty if not specified
     */
    @Nonnull
    Optional<String> threads();

    /**

		t.Fatalf("Failed to migrate, got error: %v", err)
	}

	member := &Member{
		Profiles: []Profile{{
			Number: "1",
		}, {
			Number: "2",
		}},
	}

	if err := DB.Create(&member).Error; err != nil {
		t.Fatalf("Failed to create test data, got error: %v", err)
	}

	if err := DB.Model(member).Association("Profiles").Clear(); err == nil {
		t.Fatalf("No error occurred during clearind not null association")
	}

const (
	defaultTTL            = 30
	defaultContextTimeout = 5 * time.Minute
)

// SrvRecord - represents a DNS service record
type SrvRecord struct {
	Host     string      `json:"host,omitempty"`
	Port     json.Number `json:"port,omitempty"`
	Priority int         `json:"priority,omitempty"`
	Weight   int         `json:"weight,omitempty"`
	Text     string      `json:"text,omitempty"`

    @CanIgnoreReturnValue
    @Override
    public boolean set(T t) {
      return super.set(t);
    }

    @CanIgnoreReturnValue
    @Override
    public boolean setException(Throwable t) {
      return super.setException(t);
    }
  }

  private static class OldAbstractFutureFacade<T> extends OldAbstractFuture<T>
      implements Facade<T> {

  private final transient long[] cumulativeCounts;
  private final transient int offset;
  private final transient int length;

  RegularImmutableSortedMultiset(Comparator<? super E> comparator) {
    this.elementSet = ImmutableSortedSet.emptySet(comparator);
    this.cumulativeCounts = zeroCumulativeCounts;
    this.offset = 0;
    this.length = 0;
  }

  RegularImmutableSortedMultiset(

        // Enable ALPN.
        val names = alpnProtocolNames(protocols)
        sslParameters.applicationProtocols = names.toTypedArray()

        sslSocket.sslParameters = sslParameters
      }
    } else {
      super.configureTlsExtensions(sslSocket, hostname, protocols)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (sslSocket is org.openjsse.javax.net.ssl.SSLSocket) {