expect:
        DaemonStopEvents.uniqueRecentDaemonStopEvents([immediateStop1, immediateStop1]) == [immediateStop1]
    }

    def "uniqueRecentDaemonStopEvents() returns most severe event given same PIDs"() {
        expect:
        DaemonStopEvents.uniqueRecentDaemonStopEvents([gracefulStop1, immediateStop1]) == [immediateStop1]
    }

    def "uniqueRecentDaemonStopEvents() omits stop events older than 1 hour"() {

import gradlebuild.basics.isBundleGroovy4
import gradlebuild.basics.tasks.PackageListGenerator

plugins {
    id("gradlebuild.distribution.implementation-java")
}

description = "A library that aids in testing Gradle plugins and build logic in general"

errorprone {
    disabledChecks.addAll(
        "CatchAndPrintStackTrace", // 1 occurrences
        "ImmutableEnumChecker", // 1 occurrences
    )
}

dependencies {

	def invoke(self, arg, _from_tty):
		goid_str, cmd = arg.split(None, 1)
		goids = []

		if goid_str == 'all':
			for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")):
				goids.append(int(ptr['goid']))
		else:
			goids = [int(gdb.parse_and_eval(goid_str))]

		for goid in goids:
			self.invoke_per_goid(goid, cmd)

	def invoke_per_goid(self, goid, cmd):

            } else {
                final List<PDNameTreeNode<PDComplexFileSpecification>> kids = efTree.getKids();
                if (kids == null) {
                    return;
                }
                for (final PDNameTreeNode<PDComplexFileSpecification> node : kids) {
                    processEmbeddedDocNames(node.getNames(), writer);
                }
            }

            Long pid = event.getPid();
            if (event.occurredInLastHours(RECENTLY) && !uniqueStoppedPids.contains(pid)) {
                // We can only determine if two DaemonStopEvent point at the same daemon if we know the PIDs
                if (pid != null) {
                    uniqueStoppedPids.add(pid);
                }
                recentStopEvents.add(event);
            }
        }
        return recentStopEvents;
    }

[!net:github.com] skip
[!git] skip
env GOPROXY=direct
env GOSUMDB=off

# We can resolve the @master branch without unshallowing the local repository
# (even with older gits), so try that before we do anything else.
# (This replicates https://golang.org/issue/26713 with git 2.7.4.)
go get github.com/rsc/legacytest@master
go list -m all

					if len(l.lockUID) == locks*readers {
						t.Fatalf("objects uids all remain, unlikely")
					}
					if len(l.lockMap) == 0 {
						t.Fatalf("objects all deleted, 0 remains")
					}
					if len(l.lockUID) == 0 {
						t.Fatalf("objects uids all deleted, 0 remains")
					}

					start = time.Now()
					l.expireOldLocks(-time.Minute)

//
// 2) Mid:
//    MidLetter, MidNumLet, Single_Quote.
//    (Cf. case-ignorable: MidLetter, MidNumLet, Single_Quote or cat is Mn,
//    Me, Cf, Lm or Sk).
//    Rule: Don't break between Letter and Mid, but break between two Mids.
//
// 3) Break:
//    Any other category: NewLine, MidNum, CR, LF, Double_Quote, Katakana, and
//    Other.
//    These categories should always result in a break between two cased letters.
//    Rule: Always break.

	rs := newReplicaSet(d, fmt.Sprintf("foo-%s", uid), 0)
	rs.UID = types.UID(uid)
	return rs
}

func podMapWithUIDs(uids []string) map[types.UID][]*v1.Pod {
	podMap := make(map[types.UID][]*v1.Pod)
	for _, uid := range uids {
		podMap[types.UID(uid)] = []*v1.Pod{
			{ /* supposedly a pod */ },
			{ /* supposedly another pod pod */ },
		}
	}
	return podMap

	return errNotSupported
}

func (m *unsupportedCgroupManager) MemoryUsage(_ CgroupName) (int64, error) {
	return -1, errNotSupported
}

func (m *unsupportedCgroupManager) Pids(_ CgroupName) []int {
	return nil
}

func (m *unsupportedCgroupManager) CgroupName(name string) CgroupName {
	return CgroupName([]string{})
}