"java home disagrees with executable" | null    | "other"   | "current"  | "executable"
        "tool disagrees with executable"      | "other" | null      | "current"  | "executable"
        "tool disagrees with java home"       | "other" | "current" | null       | "javaHome"
        "tool disagrees with "                | "other" | "current" | "current"  | "javaHome"
    }

		case current.version.Major == target.version.Major && current.version.Minor < target.version.Minor:
			stepVersion := m.cfg.supportedVersions.NextVersionPair(current)
			klog.Infof("upgrading etcd from %s to %s", current, stepVersion)
			current, err = m.minorVersionUpgrade(current, stepVersion)
		case current.version.Major == 3 && target.version.Major == 3 && current.version.Minor > target.version.Minor:

                }
            }
        }

        void added() {
            DefaultFileChange added = DefaultFileChange.added(current.getKey(), propertyTitle, current.getValue().getType(), current.getValue().getNormalizedPath());
            changeConsumer.visitChange(added);
            current = nextEntry(currentEntries);
        }

        void removed() {

}

func NewHintMerger(numaInfo *NUMAInfo, hints [][]TopologyHint, policyName string, opts PolicyOptions) HintMerger {
	compareNumaAffinityMasks := func(current, candidate *TopologyHint) *TopologyHint {
		// If current and candidate bitmasks are the same, prefer current hint.
		if candidate.NUMANodeAffinity.IsEqual(current.NUMANodeAffinity) {
			return current

        lock.lock();
        try {
            if (current != null) {
                ResponseProducer producer = current.selectResponseProducer(id, exchange);
                if (producer != null) {
                    return producer;
                }
                current = null;
            }
            for (TrackingHttpHandler handler : available) {

        if (current.state == State.CollectValue) {
            current.state = State.Done;
            current = current.parent;
        }
        if (current.state != State.TraverseChildren) {
            throw new IllegalStateException("Cannot end children.");
        }
        if (current.isTopLevelNode()) {
            writeNode(current);
        }
        current.state = State.Done;
        current = current.parent;

        and:
        result.current << operation(totalTime: 110)
        result.current << operation(totalTime: 110)
        result.current << operation(totalTime: 111)
        result.current << operation(totalTime: 111)
        result.current << operation(totalTime: 111)
        result.current << operation(totalTime: 110)
        result.current << operation(totalTime: 110)
        result.current << operation(totalTime: 111)

        def currentDir = new File(new File(stopAt, "intermediate"), 'current')
        currentDir.mkdirs()

        expect:
        def layout = locator.getLayoutFor(currentDir, true)
        layout.rootDirectory == currentDir
        layout.settingsDir == currentDir
        layout.settingsFile == new File(currentDir, "settings.gradle") // this is the current behaviour
        layout.buildDefinitionMissing

        baseline.significantlyFasterByMedianThan(current.results, 0.14)
        current.significantlySlowerThan(baseline.results, minConfidence)
    }

    def "does not consider changes with less then 10 milliseconds as significant"() {
        baseline.results.addAll([millis(100)] * 10)
        current.results.addAll([millis(105)] * 10)
        def confidence = calculateConfidence(baseline, current)

	groupFile = "/etc/group"
)

var colon = []byte{':'}

// Current returns the current user.
//
// The first call will cache the current user information.
// Subsequent calls will return the cached value and will not reflect
// changes to the current user.
func Current() (*User, error) {
	cache.Do(func() { cache.u, cache.err = current() })
	if cache.err != nil {
		return nil, cache.err
	}
	u := *cache.u // copy