}

                    @Override
                    public HostKey[] getHostKey() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public HostKey[] getHostKey(String host, String type) {
                        return new HostKey[0];
                    }
                });
            }

	PermitAddressSharing bool
}

type CertKey struct {
	// CertFile is a file containing a PEM-encoded certificate, and possibly the complete certificate chain
	CertFile string
	// KeyFile is a file containing a PEM-encoded private key for the certificate specified by CertFile
	KeyFile string
}

type GeneratableKeyCert struct {
	// CertKey allows setting an explicit cert/key file to use.
	CertKey CertKey

	testFe = make([]float32, 256)

	q := ve / math.Exp(-de)
	testKe[0] = uint32((de / q) * m2)
	testKe[1] = 0
	testWe[0] = float32(q / m2)
	testWe[255] = float32(de / m2)
	testFe[0] = 1.0
	testFe[255] = float32(math.Exp(-de))
	for i := 254; i >= 1; i-- {
		de = -math.Log(ve/de + math.Exp(-de))
		testKe[i+1] = uint32((de / te) * m2)
		te = de
		testFe[i] = float32(math.Exp(-de))
		testWe[i] = float32(de / m2)
	}

        Preconditions.checkArgument(!versions.isEmpty(), "versions must not be empty");
        this.versions = new TreeMap<>(versions);
    }

    public CacheVersion getLatestVersion() {
        return versions.get(versions.lastKey());
    }

    public Optional<CacheVersion> getVersionUsedBy(GradleVersion gradleVersion) {
        GradleVersion versionToFind = gradleVersion.isSnapshot() ? gradleVersion.getBaseVersion() : gradleVersion;

	for i, t := range tolerations {
		// listKey includes the toleration fields identified as listKeys in the API.
		listKey := core.Toleration{
			Key:      t.Key,
			Operator: t.Operator,
			Value:    t.Value,
			Effect:   t.Effect,
		}
		if tolerationSet[listKey] {
			allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), t))
		} else {
			tolerationSet[listKey] = true
		}
	}
	return allErrs

package main

import (
	"./a"
	"fmt"
	"math"
	"sort"
)

var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16}
var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"}

func TestKeys() {
	want := []int{1, 2, 4, 8}

	got1 := a.Keys(m1)
	sort.Ints(got1)
	if !a.SliceEqual(got1, want) {
		panic(fmt.Sprintf("a.Keys(%v) = %v, want %v", m1, got1, want))
	}

	got2 := a.Keys(m2)

    }

    private static String findFreeAlias(Set<String> reservedKeys, String key) {
        String nextKey = key;
        int collisionCount = 0;
        while (reservedKeys.contains(nextKey)) {
            collisionCount += 1;
            nextKey = key + "-x" + collisionCount;
        }
        return nextKey;
    }

    @NonNullApi
    public static class VersionEntry {
        String alias;

            if (!normalized(left.keySet()).contains(normalized(rightKey))) {
                return false;
            } else {
                for (String leftKey : left.keySet()) {
                    if (normalized(leftKey).equals(normalized(rightKey)) && !left.get(leftKey).equals(right.get(rightKey))) {
                        return false;
                    }
                }
            }
        }
        return true;

  public void testFirst() {
    assertEquals(a.getKey(), navigableMap.firstKey());
  }

  @CollectionSize.Require(SEVERAL)
  public void testLast() {
    assertEquals(c.getKey(), navigableMap.lastKey());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)

	if err := pkiutil.WriteCertAndKey(
		dirPKI,
		caName,
		testCACert,
		testCAKey); err != nil {
		t.Fatalf("couldn't write out certificate %s to %s", caName, dirPKI)
	}

	// creates a certificate and then embeds it into a kubeconfig file
	cert := writeTestKubeconfig(t, dirKubernetes, "test", testCACert, testCAKey, time.Time{}, time.Time{})

	// Creates a KubeconfigReadWriter