func resolverForTest(t test.Failer, xdsPort int, ns string) resolver.Builder {
	xdsresolver, err := xdsgrpc.NewXDSResolverWithConfigForTesting(
		GRPCBootstrap("foo", ns, "10.0.0.1", xdsPort))
	if err != nil {
		t.Fatal(err)
	}
	return xdsresolver
}

func init() {
	// Setup gRPC logging. Do it once in init to avoid races
	o := log.DefaultOptions()

package forwarder

import (
	"context"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/credentials/xds"
	xdsresolver "google.golang.org/grpc/xds"

	"istio.io/istio/pkg/test/echo/common"
	"istio.io/istio/pkg/test/echo/proto"
)

var _ protocol = &grpcProtocol{}

type xdsProtocol struct {
	e *executor
}

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.vcs.VersionControlSpec;

import javax.annotation.Nullable;

@ServiceScope(Scope.BuildTree.class)
public interface VcsResolver {
    /**
     * Returns the VCS to use to search for matches to the given selector, or null if no such VCS.
     */
    @Nullable
    VersionControlSpec locateVcsFor(ModuleComponentSelector selector);

    /**

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;


/**
 * This is an internal API.
 * 
 * @author mbechler
 * @internal
 */
public interface DfsResolver {

    /**
     * @param domain
     * @param tf
     * @return whether the given domain is trusted
     * @throws CIFSException
     * @throws jcifs.smb.SmbAuthException
     */

import org.gradle.vcs.VersionControlSpec;

import javax.annotation.Nullable;

@ServiceScope(Scope.BuildTree.class)
public interface VcsMappingsStore {
    VcsResolver asResolver();

    void addRule(Action<? super VcsMapping> rule, Gradle gradle);

    VcsResolver NO_OP = new VcsResolver() {
        @Nullable
        @Override
        public VersionControlSpec locateVcsFor(ModuleComponentSelector selector) {
            return null;

        @Inject
        public VcsResolverFactory(
            VcsResolver vcsResolver,
            BuildStateRegistry buildRegistry,
            PublicBuildPath publicBuildPath,
            VersionControlRepositoryConnectionFactory versionControlSystemFactory,
            VcsVersionWorkingDirResolver workingDirResolver
        ) {
            this.vcsResolver = vcsResolver;
            this.buildRegistry = buildRegistry;

    public DefaultVcsMappingsStore(VcsMappingFactory vcsMappingFactory) {
        this.vcsMappingFactory = vcsMappingFactory;
    }

    @Override
    public VcsResolver asResolver() {
        return this;
    }

    @Nullable
    @Override
    public VersionControlSpec locateVcsFor(ModuleComponentSelector selector) {
        if (!hasRules()) {
            return null;
        }

 */

package okhttp3.android

import android.net.DnsResolver
import android.net.Network
import android.os.Build
import androidx.annotation.RequiresApi
import java.net.InetAddress
import java.net.UnknownHostException
import java.util.concurrent.Executors
import okhttp3.AsyncDns
import okhttp3.ExperimentalOkHttpApi

/**
 * DNS implementation based on android.net.DnsResolver, which submits a request for

    private final DependencySubstitutionRules globalDependencySubstitutionRules;
    private final ImmutableModuleIdentifierFactory moduleIdentifierFactory;
    private final VcsResolver vcsResolver;
    private final ComponentSelectorConverter componentSelectorConverter;
    private final DependencyLockingProvider dependencyLockingProvider;
    private final CapabilitiesResolutionInternal capabilitiesResolution;

 */
package okhttp3.android

import android.net.DnsResolver
import android.net.Network
import android.os.CancellationSignal
import java.net.InetAddress
import java.util.concurrent.Executor
import org.robolectric.annotation.Implementation
import org.robolectric.annotation.Implements
import org.robolectric.shadow.api.Shadow

@Implements(DnsResolver::class)
class ShadowDnsResolver {
  var responder: (Request) -> Unit = {