t := 0
	for i := 0; i < n; i++ {
		for j := 0; j < i; j++ {
			t += i ^ j
		}
	}
	return t
}

// Tests runtime/coverage.snapshot() directly. Note that if
// coverage is not enabled, the hook is designed to just return
// zero.
func TestCoverageSnapshot(t *testing.T) {
	C1 := Snapshot()
	thisFunctionOnlyCalledFromSnapshotTest(15)
	C2 := Snapshot()
	cond := "C1 > C2"
	val := C1 > C2

If you want to look at the measurement for the Gradle build itself you can have a look at the blog post https://blog.gradle.org/introducing-gradle-build-cache["Introducing the build cache"].

== Measuring developer builds

		return err
	}
	s.postStartHooks[name] = postStartHookEntry{hook: hook, originatingStack: string(debug.Stack()), done: done}

	return nil
}

// AddPostStartHookOrDie allows you to add a PostStartHook, but dies on failure
func (s *GenericAPIServer) AddPostStartHookOrDie(name string, hook PostStartHookFunc) {
	if err := s.AddPostStartHook(name, hook); err != nil {
		klog.Fatalf("Error registering PostStartHook %q: %v", name, err)

	f3 := func() { println("blek") }
	f4 := func() { println("blub") }
	f5 := func() { println("blat") }
	exithook.Add(exithook.Hook{F: f1})
	exithook.Add(exithook.Hook{F: f2, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f3})
	exithook.Add(exithook.Hook{F: f4, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f5})
	os.Exit(1)
}

func testPanics() {
	f1 := func() { println("ok") }
	f2 := func() { panic("BADBADBAD") }

		t.Fatalf("wrong source file descriptor: got %d, want %d", hook.srcfd, src.Fd())
	}
	sc, ok := dst.(syscall.Conn)
	if !ok {
		t.Fatalf("destination is not a syscall.Conn")
	}
	rc, err := sc.SyscallConn()
	if err != nil {
		t.Fatalf("destination SyscallConn error: %v", err)
	}
	if err = rc.Control(func(fd uintptr) {
		if hook.called && hook.dstfd != int(fd) {

    json = JSON.parse(response.body)
    book = json['items'][0]['volumeInfo']

    language = book['language'] === 'en'? 'English' : 'unknown'
    type = book['printType'] === 'BOOK'? 'paperback' : 'unknown'
    isbn10 = get_isbn(book, 'ISBN_10')
    isbn13 = get_isbn(book, 'ISBN_13')

    return {
        'id' => id,
        'author': book['authors'][0],
        'year': book['publishedDate'],
        'type' => type,

			{
				mode:     "badexit",
				expected: "blub blix",
			},
			{
				mode: "panics",
				musthave: []string{
					"fatal error: exit hook invoked panic",
					"main.testPanics",
				},
			},
			{
				mode: "callsexit",
				musthave: []string{
					"fatal error: exit hook invoked exit",
				},
			},
			{
				mode:     "exit2",
				expected: "",
			},
		}

	runGoid atomic.Uint64
	hooks   []Hook
	running bool

	// runtime sets these for us
	Gosched func()
	Goid    func() uint64
	Throw   func(string)
)

// Add adds a new exit hook.
func Add(h Hook) {
	for !locked.CompareAndSwap(0, 1) {
		Gosched()
	}
	hooks = append(hooks, h)
	locked.Store(0)
}

// Run runs the exit hooks.
//
// If an exit hook panics, Run will throw with the panic on the stack.

// terminates.
func InitHook(istest bool) {
	// Note: hooks are run in reverse registration order, so
	// register the counter data hook before the meta-data hook
	// (in the case where two hooks are needed).
	exithook.Add(exithook.Hook{F: emitCounterData, RunOnFailure: true})
	if istest {
		exithook.Add(exithook.Hook{F: emitMetaData, RunOnFailure: true})
	} else {
		emitMetaData()
	}

    }

    def "fails if two subprojects have the same java name"() {
        given:
        createDirs("super-cool", "super--cool")
        settingsFile << """
            include 'super-cool'
            include 'super--cool'
        """

        buildFile << """
            tasks.register("noExtension") {
                doLast {