"k8s.io/client-go/kubernetes/fake"
	utiltesting "k8s.io/client-go/util/testing"
	"k8s.io/kubernetes/pkg/volume"
	volumetest "k8s.io/kubernetes/pkg/volume/testing"
)

const (
	testHostName      = "test-hostname"
	socketPath        = "/var/run/kmsplugin"
	migratedVolume    = "migrated-volume-name"
	nonMigratedVolume = "non-migrated-volume-name"
	testNodeName      = "test-node-name"
)

var (

        }
    }

    static final class NotEC2Agent implements TestPrecondition {
        @Override
        boolean isSatisfied() throws UnknownHostException {
            return !InetAddress.getLocalHost().getHostName().startsWith("ip-")
        }
    }

    static final class StableGroovy implements TestPrecondition {
        @Override
        boolean isSatisfied() {
            !GroovySystem.version.endsWith("-SNAPSHOT")

            args: args.collect { it.toString() },
            gradleOpts: resolveGradleOpts(),
            daemon: useDaemon,
            jvm: Jvm.current().toString(),
            host: InetAddress.getLocalHost().getHostName(),
            operatingSystem: OperatingSystem.current().toString(),
            versionUnderTest: GradleVersion.current().getVersion(),
            vcsBranch: Git.current().branchName,

				}
			} else {
				if tcpProxy.TunnelingConfig.GetHostname() != tt.expectedTunnelingConfig.hostname {
					t.Fatalf("Expected to get tunneling_config.hostname: %s, but got: %s",
						tt.expectedTunnelingConfig.hostname, tcpProxy.TunnelingConfig.GetHostname())
				}
				if tcpProxy.TunnelingConfig.GetUsePost() != tt.expectedTunnelingConfig.usePost {

				"object.spec.string.findAll('[0-9]+').size() > 0",           // kubernetes string lib
				"object.spec.list.isSorted()",                               // kubernetes list lib
				"url(object.spec.endpoint).getHostname() in ['ok1', 'ok2']", // kubernetes url lib
			},
		},
		{
			name: "valid request",
			expressions: []string{
				"request.kind.group == 'example.com' && request.kind.version == 'v1' && request.kind.kind == 'Fake'",

	}

	return plugin.NewUnmounter(spec.Name(), podUID)
}

func (kvh *kubeletVolumeHost) GetMounter(pluginName string) mount.Interface {
	return kvh.kubelet.mounter
}

func (kvh *kubeletVolumeHost) GetHostName() string {
	return kvh.kubelet.hostname
}

func (kvh *kubeletVolumeHost) GetHostIP() (net.IP, error) {
	hostIPs, err := kvh.kubelet.GetHostIPs()
	if err != nil {
		return nil, err
	}

    protected String getHostInfo() {
        final StringBuilder buf = new StringBuilder();
        try {
            final InetAddress ia = InetAddress.getLocalHost();
            final String hostname = ia.getHostName();
            if (StringUtil.isNotBlank(hostname)) {
                buf.append(hostname);
            }
            final String ip = ia.getHostAddress();
            if (StringUtil.isNotBlank(ip)) {

            } catch (IOException ex) { }
        }
        int domainLength = domain.length;
        byte[] server = new byte[0];
        try {
            String host = NbtAddress.getLocalHost().getHostName();
            if (host != null) {
                try {
                    server = host.getBytes(UNI_ENCODING);
                } catch (IOException ex) { }
            }
        } catch (UnknownHostException ex) { }

	public final fun getBodyLimit ()J
	public final fun getDelegate ()Lmockwebserver3/MockWebServer;
	public final fun getDispatcher ()Lokhttp3/mockwebserver/Dispatcher;
	public final fun getHostName ()Ljava/lang/String;
	public final fun getPort ()I
	public final fun getProtocolNegotiationEnabled ()Z
	public final fun getRequestCount ()I
	public final fun getServerSocketFactory ()Ljavax/net/ServerSocketFactory;

        return ssn;
    }
    boolean matches( UniAddress address, int port, InetAddress localAddr, int localPort, String hostName ) {
        if (hostName == null)
            hostName = address.getHostName();
        return (this.tconHostName == null || hostName.equalsIgnoreCase(this.tconHostName)) &&
                    address.equals( this.address ) &&
                    (port == 0 || port == this.port ||