*             if there is an error resolving the name
     */
    NetbiosAddress getNbtByName ( String host, int type, String scope, InetAddress svr ) throws UnknownHostException;


    /**
     * Determines the address of a host given it's host name. NetBIOS
     * names also have a <code>type</code>. Types(aka Hex Codes)
     * are used to distinguish the various services on a host. <a

				for _, cond = range gwc.Status.Conditions {
					if cond.Type == string(gateway.GatewayConditionProgrammed) && string(cond.Status) == "True" {
						programmed = true
						break
					}
				}
			}
			if ctx.Namespace() == "" {
				fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n", gwc.Namespace, gwc.Name, cond.Status, cond.Type, cond.Reason, cond.Message)
			} else {

        @SuppressWarnings("rawtypes") // using raw types to avoid a bug in our nullness checker :(
        InternalEntry entry = map.getEntry(sample);
        if (entry != null) {
          Object canonical = entry.getKey();
          if (canonical != null) { // only matters if weak/soft keys are used
            // The compiler would know this is safe if not for our use of raw types (see above).
            @SuppressWarnings("unchecked")

 *     ExecutionException}, {@code UncheckedExecutionException}, and {@code ExecutionError}. Any
 *     code that is still catching {@code ComputationException} may need to be updated to catch some
 *     of those types instead. (Note that this type, though deprecated, is not planned to be removed
 *     from Guava.)
 */
@Deprecated
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class ComputationException extends RuntimeException {

 * the License.
 */

/**
 * Utility methods and classes for I/O; for example input streams, output streams, readers, writers,
 * and files.
 *
 * <p>At the core of this package are the Source/Sink types: {@link ByteSource ByteSource}, {@link
 * CharSource CharSource}, {@link ByteSink ByteSink} and {@link CharSink CharSink}. They are
 * factories for I/O streams that provide many convenience methods that handle both opening and

}

tasks.withType<Test>().configureEach {
    val testVersionProvider = javaLauncher.map { it.metadata.languageVersion }
    jvmArgumentProviders.add(CommandLineArgumentProvider {
        //allow ProjectBuilder to inject legacy types into the system classloader
        if (testVersionProvider.get().canCompileOrRun(9)) {
            listOf("--add-opens", "java.base/java.lang=ALL-UNNAMED")
        } else {
            emptyList()
        }
    })

  //   the IngressClass. Implementations can treat this as a separate PathType
  //   or treat it identically to Prefix or Exact path types.
  // Implementations are required to support all path types.
  // Defaults to ImplementationSpecific.
  optional string pathType = 3;

  // Backend defines the referenced service endpoint to which the traffic
  // will be forwarded to.

		},
		Data: map[string][]byte{},
		Type: v1.SecretTypeServiceAccountToken,
	}
	if len(caData) > 0 {
		out.Data[v1.ServiceAccountRootCAKey] = []byte(caData)
	}
	if len(token) > 0 {
		out.Data[v1.ServiceAccountTokenKey] = []byte(token)
	}
	return out
}

type fakeOutputWriter struct {
	b           bytes.Buffer
	injectError error
	failAfter   int
}

 *
 * <h3>String utilities</h3>
 *
 * <ul>
 *   <li>{@link Ascii}
 *   <li>{@link CaseFormat}
 *   <li>{@link CharMatcher}
 *   <li>{@link Splitter}
 *   <li>{@link Strings}
 * </ul>
 *
 * <h3>Function types</h3>
 *
 * <ul>
 *   <li>{@link Converter}
 *   <li>{@link Equivalence}
 * </ul>
 *
 * <h3>Other</h3>
 *
 * <ul>
 *   <li>{@link Enums}
 *   <li>{@link MoreObjects}
 *   <li>{@link Preconditions}

import java.util.Comparator;
import java.util.SortedSet;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Utilities for dealing with sorted collections of all types.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class SortedIterables {
  private SortedIterables() {}

  /**