when(mockInetAddress.getHostName()).thenReturn("inet-host");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("inet-host", uniAddress.getHostName());
        }

        @Test
        void shouldReturnNbtAddressHostnameWhenWrappedIsNbtAddress() {
            when(mockNbtAddress.getHostName()).thenReturn("nbt-host");
            UniAddress uniAddress = new UniAddress(mockNbtAddress);

     *
     * @param parser
     *            The {@link SAXParser} to use. Must not be {@literal null}.
     * @param inputSource
     *            The {@link InputSource} containing the content to be parsed. Must not be {@literal null}.
     * @param handler
     *            The SAX {@link DefaultHandler} to use. Must not be {@literal null}.
     */

    checkNotNull(funnel);
    checkArgument(
        expectedInsertions >= 0, "Expected insertions (%s) must be >= 0", expectedInsertions);
    checkArgument(fpp > 0.0, "False positive probability (%s) must be > 0.0", fpp);
    checkArgument(fpp < 1.0, "False positive probability (%s) must be < 1.0", fpp);
    return Collector.of(
        () -> BloomFilter.create(funnel, expectedInsertions, fpp),
        BloomFilter::put,

    protected SerializeUtil() {
    }

    private static final int BYTE_ARRAY_SIZE = 8 * 1024;

    /**
     * Tests if the object can be serialized.
     *
     * @param obj the object to be serialized (must not be {@literal null})
     * @return the deserialized object
     */
    public static Object serialize(final Object obj) {
        assertArgumentNotNull("obj", obj);

    protected ZipInputStreamUtil() {
    }

    /**
     * A method that wraps the exception handling of {@link ZipInputStream#getNextEntry()}.
     *
     * @param zis
     *            {@link ZipInputStream}. Must not be {@literal null}.
     * @return {@link ZipEntry}
     * @see ZipInputStream#getNextEntry()
     */
    public static ZipEntry getNextEntry(final ZipInputStream zis) {
        assertArgumentNotNull("zis", zis);

    /**
     * Returns an {@link Iterable} that wraps the array for use in a for-each statement.
     *
     * @param <T> the type of elements
     * @param items the array of elements to iterate (must not be {@literal null})
     * @return an {@link Iterable} wrapping the array
     */
    public static <T> Iterable<T> iterable(final T... items) {
        assertArgumentNotNull("items", items);

 * @since 20.0
 */
@Beta
public interface MutableGraph<N> extends Graph<N> {

  /**
   * Adds {@code node} if it is not already present.
   *
   * <p><b>Nodes must be unique</b>, just as {@code Map} keys must be. They must also be non-null.
   *
   * @return {@code true} if the graph was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean addNode(N node);

  /**

    /**
     * Do not instantiate.
     */
    protected PreparedStatementUtil() {
    }

    /**
     * Executes the query.
     *
     * @param ps
     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @return {@link ResultSet}
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */

      return routes[nextRouteIndex++]
    }
  }

  companion object {
    /** Obtain a host string containing either an actual host name or a numeric IP address. */
    val InetSocketAddress.socketHost: String get() {
      // The InetSocketAddress was specified with a string (either a numeric IP or a host name). If
      // it is a name, all IPs for that name should be tried. If it is an IP address, only that IP

func getObjectLocation(r *http.Request, domains []string, bucket, object string) string {
	// unit tests do not have host set.
	if r.Host == "" {
		return path.Clean(r.URL.Path)
	}
	proto := handlers.GetSourceScheme(r)
	if proto == "" {
		proto = getURLScheme(globalIsTLS)
	}
	u := &url.URL{
		Host:   r.Host,
		Path:   path.Join(SlashSeparator, bucket, object),
		Scheme: proto,
	}