assert !thisBuild.mustCheck
        assert thisBuild.keepFor == Duration.ofMillis(FOREVER)

        def expiry1 = cachePolicy.moduleExpiry(id, module, Duration.ofMillis(2 * DAY))
        assert !expiry1.mustCheck
        assert expiry1.keepFor == Duration.ofMillis(FOREVER)

        def expiry2 = cachePolicy.moduleExpiry(id, module, Duration.ofMillis(FOREVER))
        assert !expiry2.mustCheck

)

// For any test of the style:
//
//	...
//	<- time.After(timeout):
//	   t.Errorf("Timed out")
//
// The value for timeout should effectively be "forever." Obviously we don't want our tests to truly lock up forever, but 30s
// is long enough that it is effectively forever for the things that can slow down a run on a heavily contended machine

# mod_import_cycle covers this error in module mode.
env GO111MODULE=off

! go build selfimport
stderr -count=1 'import cycle not allowed'

go list -e -f '{{.Error}}' selfimport # Don't hang forever
stdout -count=1 'import cycle not allowed'

-- selfimport/selfimport.go --
package selfimport

// compile

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 8076. nilwalkfwd walked forward forever
// on the instruction loop following the dereference.

package main

func main() {
	_ = *(*int)(nil)
L:
	_ = 0
	goto L

env GO111MODULE=off

! go build selfimport
stderr -count=1 'import cycle not allowed'

# 'go list' shouldn't hang forever.
go list -e -json selfimport

-- $GOPATH/src/selfimport/selfimport.go --
package selfimport

// license that can be found in the LICENSE file.

package main

import "C"

import (
	"os"
	"runtime"
	"sync/atomic"
)

var started int32

// Start a goroutine that loops forever.
func init() {
	runtime.GOMAXPROCS(1)
	go func() {
		for {
			atomic.StoreInt32(&started, 1)
		}
	}()
}

//export GoFunction8
func GoFunction8() {
	for atomic.LoadInt32(&started) == 0 {

			return
		}
		if eb, ok := req.Form["exact-body"]; ok {
			io.WriteString(rw, eb[0])
			return
		}
		if req.FormValue("write-forever") == "1" {
			io.Copy(rw, neverEnding('a'))
			for {
				time.Sleep(5 * time.Second) // hang forever, until killed
			}
		}
		fmt.Fprintf(rw, "test=Hello CGI-in-CGI\n")
		for k, vv := range req.Form {
			for _, v := range vv {

 * limitations under the License.
 */

package org.gradle.api.internal;

/**
 * Demarcates objects that expose a convention.
 *
 * Convention objects aren't going to be around forever, so this is a temporary interface.
 *
 * @deprecated Use extensions instead. This interface is scheduled for removal in Gradle 9.
 * @see org.gradle.api.plugins.ExtensionAware
 */
@Deprecated

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test basic concurrency: the classic prime sieve.
// Do not run - loops forever.

package main

// Send the sequence 2, 3, 4, ... to channel 'ch'.
func Generate(ch chan<- int) {
	for i := 2; ; i++ {
		ch <- i // Send 'i' to channel 'ch'.
	}
}

              @Override
              public Integer call() throws Exception {
                enterLatch.countDown();
                try {
                  new CountDownLatch(1).await(); // wait forever
                  throw new AssertionError();
                } catch (InterruptedException e) {
                  interruptedExceptionThrown.set(true);
                  throw e;
                } finally {