colons := strings.Count(host, ":")
	if colons == 0 {
		return false
	}
	if colons == 1 {
		return true
	}
	return host[0] == '[' && strings.Contains(host, "]:")
}

// jarKey returns the key to use for a jar.
func jarKey(host string, psl PublicSuffixList) string {
	if isIP(host) {
		return host
	}

	var i int
	if psl == nil {
		i = strings.LastIndex(host, ".")
		if i <= 0 {
			return host

	".net":          ".net",
	"a.":            "a.",
	"b.a.":          "a.",
	"weird.stuff..": ".",
}

func TestJarKey(t *testing.T) {
	for host, want := range jarKeyTests {
		if got := jarKey(host, testPSL{}); got != want {
			t.Errorf("%q: got %q, want %q", host, got, want)
		}
	}
}

var jarKeyNilPSLTests = map[string]string{
	"foo.www.example.com": "example.com",

typedef jobject jclass;
typedef jobject jthrowable;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
typedef jarray jcharArray;
typedef jarray jshortArray;
typedef jarray jintArray;
typedef jarray jlongArray;
typedef jarray jfloatArray;
typedef jarray jdoubleArray;
typedef jarray jobjectArray;

typedef jobject jweak;

        when:
        project.container {
            Fred
            Barney {}
        }

        then:
        container.size() == 2
        container.findByName("Fred") == realFred
        container.findByName("Barney") == realBarney
        container.asDynamicObject.getProperty("Fred") == realFred
        container.asDynamicObject.getProperty("Barney") == realBarney
    }

    def "create elements with specified type"() {

        container.findByName("fred") == fred
        container.findByName("barney") == barney
        container.elementsAsDynamicObject.getProperty("fred") == fred
        container.elementsAsDynamicObject.getProperty("barney") == barney
        container.createableTypes == Collections.singleton(Person)
    }

    def "maybe create elements without specifying type"() {

        new DefaultTestExecutionResult(testDirectory).assertTestClassesExecuted('com.example.SomeTest')

        when:
        createNewJarWithoutPackageEntries(jar, jarNew)
        String entry = "org/gradle/BasePlatformTestCase.class"
        assertJarContainsOnlyOneEntry(jarNew, entry)
        testDirectory.file("build.gradle").replace(jarName, jarNameNew)
        succeeds("test", "--tests", "SomeTest")
        then:

	var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
	_ = x1
	var x2 C.jclass = 0
	_ = x2
	var x3 C.jthrowable = 0
	_ = x3
	var x4 C.jstring = 0
	_ = x4
	var x5 C.jarray = 0
	_ = x5
	var x6 C.jbooleanArray = 0
	_ = x6
	var x7 C.jbyteArray = 0
	_ = x7
	var x8 C.jcharArray = 0
	_ = x8
	var x9 C.jshortArray = 0
	_ = x9
	var x10 C.jintArray = 0
	_ = x10

","guam","guatemala","guernsey","guinea","guinea-bissau","guyana","haiti","heard island and mcdonald islands","honduras","hong kong","hungary","iceland","india","indonesia","iran","iraq","ireland","isle of man","israel","italy","jamaica","japan","jersey","jordan","kazakhstan","kenya","kiribati","north korea","south korea","kuwait","kyrgyzstan","laos","latvia","lebanon","lesotho","liberia","libya","liechtenstein","lithuania","luxembourg","macao","macedonia","madagascar","malawi","malaysia","maldi...

                "opentest4j-${OPENTEST4J_VERSION}.jar",
                "apiguardian-api-${API_GUARDIAN_VERSION}.jar"
            ));
            assertTrue(jars.containsAll(jarSet));
            jars.removeAll(jarSet);

            // The distribtuion-loaded jars can vary in version, since the GE test acceleration
            // plugins inject their own versions of these libraries during integration tests.

	return typefix(f, func(s string) bool {
		switch s {
		case "C.jobject":
			return true
		case "C.jclass":
			return true
		case "C.jthrowable":
			return true
		case "C.jstring":
			return true
		case "C.jarray":
			return true
		case "C.jbooleanArray":
			return true
		case "C.jbyteArray":
			return true
		case "C.jcharArray":
			return true
		case "C.jshortArray":
			return true
		case "C.jintArray":