// select.
	"hchan": true,
	// Multiple hchanLeafs are acquired in hchan.sortkey() order in
	// syncadjustsudogs().
	"hchanLeaf": true,
	// The point of the deadlock lock is to deadlock.
	"deadlock": true,
}

func main() {
	flagO := flag.String("o", "", "write to `file` instead of stdout")
	flagDot := flag.Bool("dot", false, "emit graphviz output instead of Go")
	flag.Parse()

            Future<?> ignored = deadlockPreventer.submit(new Runnable() {
                @Override
                public void run() {
                    // do not do this directly or a deadlock happens
                    // to prevent that deadlock, execute it separately in another thread
                    LOGGER.warn("More progress was logged than there should be ({} > {})", current, total);
                }
            });
        }

        then:
        1 * listenerManager.removeListener(daemonExpirationListener)
    }

    def "should not deadlock with daemon scan info"() {
        def manager = new DefaultListenerManager(Scope.Global)
        def daemonScanInfo = new DefaultDaemonScanInfo(new DaemonRunningStats(), 1000, false, Mock(DaemonRegistry), manager)

// arguments to a function to be invoked by Do:
//
//	config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
func (o *Once) Do(f func()) {
	// Note: Here is an incorrect implementation of Do:
	//

setupGlobalState()

tasks.registerDistributionsPromotionTasks()

tasks.registerEarlyFeedbackRootLifecycleTasks()

/**
 * Print all stacktraces of running JVMs on the machine upon timeout. Helps us diagnose deadlock issues.
 */
fun setupTimeoutMonitorOnCI() {
    if (BuildEnvironment.isCiServer && project.name != "gradle-kotlin-dsl-accessors") {

 * {@link org.gradle.integtests.fixtures.AbstractIntegrationSpec}. Upon timeout,
 * all threads' stack traces of current JVM (embedded executer) or forked JVM (forking executer)
 * are printed to help us debug deadlock issues.
 */

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@ExtensionAnnotation(IntegrationTestTimeoutExtension.class)
public @interface IntegrationTestTimeout {

		ff := func(o []Event[T], initialSync bool) {
			f(slices.Map(o, castEvent[T, any]), initialSync)
		}
		// Skip calling all the existing state for secondary dependencies, otherwise we end up with a deadlock due to
		// rerunning the same collection's recomputation at the same time (once for the initial event, then for the initial registration).
		c.RegisterBatch(ff, false)
	})

	// Now we can do the real fetching

func time_now() (sec int64, nsec int32, mono int64) {
	return faketime / 1e9, int32(faketime % 1e9), faketime
}

// write is like the Unix write system call.
// We have to avoid write barriers to avoid potential deadlock
// on write calls.
//
//go:nowritebarrierrec
func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
	if !(fd == 1 || fd == 2) {
		// Do an ordinary write.
		return write1(fd, p, n)
	}

        // This is not thread-safe because of lock juggling that happens for project state. When calculating the dependencies for an IDEA model, we can easily
        // deadlock when there are multiple projects that need to be locked at the same time.
        ResolvableArtifact resolvableArtifact = allResolvedArtifacts.get(artifact.getId());
        if (resolvableArtifact == null) {

func _[T interface{ ~*int }](p T) int {
	return *p
}

// Channel send and receive on a generic type which has a channel as core type.
func _[T interface{ ~chan int }](ch T) int {
	// This would deadlock if executed (but ok for a compile test)
	ch <- 0
	return <-ch
}

// Calling of a generic type which has a function as core type.
func _[T interface{ ~func() }](f T) {
	f()
	go f()
}