continue
		}
		portnet := f[1] // "80/tcp"
		port, j, ok := dtoi(portnet)
		if !ok || port <= 0 || j >= len(portnet) || portnet[j] != '/' {
			continue
		}
		netw := portnet[j+1:] // "tcp"
		m, ok1 := services[netw]
		if !ok1 {
			m = make(map[string]int)
			services[netw] = m
		}
		for i := 0; i < len(f); i++ {
			if i != 1 { // f[1] was port/net
				m[f[i]] = port
			}
		}
	}
}

        return !(version in ['4.10', '4.11', '4.12'])
    }

    def 'reports unloadable #type'() {
        given:
        testSources.with {
            testClass('SomeTestClass').with {
                testMethod('ok1')
                testMethod('ok2')
            }
        }
        testSourceGenerator.writeAllSources(testSources)
        buildFile << """
            apply plugin: "java"

            ${mavenCentralRepository()}

		sort.Slice(oldKeys, func(i, j int) bool {
			key1, ok1 := oldKeys[i].(map[string]any)
			key2, ok2 := oldKeys[j].(map[string]any)
			if ok1 && ok2 {
				key1Id, kid1Exists := key1["kid"]
				key2Id, kid2Exists := key2["kid"]
				if kid1Exists && kid2Exists {
					key1IdStr, ok1 := key1Id.(string)
					key2IdStr, ok2 := key2Id.(string)
					if ok1 && ok2 {
						return key1IdStr < key2IdStr
					}
				}

        result.assertTestClassesExecuted('SomeLocaleTests')
        result.testClass("SomeLocaleTests").assertTestCount(3, 0, 0)
        result.testClass("SomeLocaleTests").assertTestsExecuted('ok1 [de]', 'ok1 [en]', 'ok1 [fr]')
    }

    def "can run parameterized tests with categories"() {
        given:
        testSources.with {
            testCategory('SomeCategory')

        result.testClass("SomeLocaleTests").assertTestCount(3, 0, 0)
        result.testClass("SomeLocaleTests").assertTestsExecuted(
            result.testCase('ok1(Locale)[1]', 'French'),
            result.testCase('ok1(Locale)[2]', 'German'),
            result.testCase('ok1(Locale)[3]', 'English')
        )
    }

    def "can run parameterized tests with tags"() {
        given:
        testSources.with {

// the decision may be based on the path names.
// SameFile only applies to results returned by this package's [Stat].
// It returns false in other cases.
func SameFile(fi1, fi2 FileInfo) bool {
	fs1, ok1 := fi1.(*fileStat)
	fs2, ok2 := fi2.(*fileStat)
	if !ok1 || !ok2 {
		return false
	}
	return sameFile(fs1, fs2)

        return Description.createSuiteDescription(type)
    }

    void run(RunNotifier notifier) {
        notifier.fireTestStarted(Description.createTestDescription(type, "ok1"))
        notifier.fireTestFinished(Description.createTestDescription(type, "ok1"))
        notifier.fireTestStarted(Description.createTestDescription(type, "broken"))
        throw failure.rawFailure
    }
}

public class ATestClassWhichCannotBeLoaded {

			}
			done = true // Invalidate iterator
			race.Release(unsafe.Pointer(&racer))
		}()
		seq(yield)
		var v0 V
		v, ok = v0, false
		seqDone = true
	})
	next = func() (v1 V, ok1 bool) {
		race.Write(unsafe.Pointer(&racer)) // detect races

		if done {
			return
		}
		if yieldNext {
			panic("iter.Pull: next called again before yield")
		}
		yieldNext = true

public class SomeTestClass {
    @Test
    public void ok1() {
    }

    @Test
    public void ok2() {
    }
}
        """
        file("src/integTest/java/org/example/SomeIntegTestClass.java") << """
package org.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Tag;

@Tag("fast")
public class SomeIntegTestClass {
    @Test
    public void ok1() {
    }

    @Test

// An invalid semantic version string is considered less than a valid one.
// All invalid semantic version strings compare equal to each other.
func Compare(v, w string) int {
	pv, ok1 := parse(v)
	pw, ok2 := parse(w)
	if !ok1 && !ok2 {
		return 0
	}
	if !ok1 {
		return -1
	}
	if !ok2 {
		return +1
	}
	if c := compareInt(pv.major, pw.major); c != 0 {
		return c
	}