instant.resultAvailable < instant.resultReceived
    }

    def "run() blocks until result is available"() {
        given:
        asyncConnection.run(!null, !null) >> { def consumerAction, ResultHandlerVersion1 adaptedHandler ->
            start {
                thread.block()
                instant.resultAvailable
                adaptedHandler.onComplete(null)
            }
        }

	if len(pemData) == 0 {
		return nil
	}

	blocks := 0
	for {
		block, remainingData := pem.Decode(pemData)
		if block == nil {
			break
		}

		if block.Type != utilcert.CertificateBlockType {
			return fmt.Errorf("only CERTIFICATE PEM blocks are allowed, found %q", block.Type)
		}
		if len(block.Headers) != 0 {
			return fmt.Errorf("no PEM block headers are permitted")
		}
		blocks++

#define SEED(off, reg, XR) \
	MOVL (4*off)(AX), reg; \
	REPLREG(reg, XR) \

// block runs 4 ChaCha8 block transformations in the four stripes of the X registers.

// func block(seed *[8]uint32, blocks *[16][4]uint32, counter uint32)
TEXT ·block<ABIInternal>(SB), NOSPLIT, $16
	// seed in AX
	// blocks in BX
	// counter in CX

	// Load initial constants into top row.
	REPL(0x61707865, X0)

    }

    def 'supports correct order of blocks in setttings file if there is #order'() {
        given:
        file("settings.gradle.dcl") << content

        expect:
        succeeds(":projects")
        outputContains("Root project 'test-project'")

        where:
        order                                     | content

    def userInputReader = new DefaultUserInputReader()

    def "blocks until user response received"() {
        expect:
        async {
            start {
                def result = userInputReader.readInput()
                instant.read
                assert result == response
            }
            thread.block()
            instant.put
            userInputReader.putInput(response)
        }

    // We recur into these nested blocks to raise those as well. We don't raise
    // "CPU" ops who are themselves nested within a "CPU" op, so set
    // `skip_cpu` to true.
    if (device_is(device, kCpuDeviceName)) {
      for (auto& block : ops_added.func_op->getRegion(0).getBlocks())
        for (auto& op : block) {
          auto op_device = GetInferenceDeviceTypeForOp(&op);

        file.text =="""plugins {
            |    id("com.gradle.develocity") version("${VERSION}")
            |}
            |
            |includeBuild '../lib'""".stripMargin()
    }

    def "plugin management block blocks"() {
        given:
        File file = File.createTempFile("test_script", ".tmp")
        file.write("""pluginManagement {
            |    repositories {
            |        gradlePluginPortal()
            |    }

	//
	// In this case we can also replace x with a copy of c.
	//
	// The optimization idea:
	// 1. block b has a phi value x, x = OpPhi (ConstBool [true]) (ConstBool [false]),
	//    and len(b.Preds) is equal to 2.
	// 2. find the common dominator(b0) of the predecessors(pb0, pb1) of block b, and the
	//    dominator(b0) is a If block.
	//    Special case: one of the predecessors(pb0 or pb1) is the dominator(b0).

  // The data must consist only of PEM certificate blocks that parse as valid
  // X.509 certificates.  Each certificate must include a basic constraints
  // extension with the CA bit set.  The API server will reject objects that
  // contain duplicate certificates, or that use PEM block headers.
  //
  // Users of ClusterTrustBundles, including Kubelet, are free to reorder and
  // deduplicate certificate blocks in this file according to their own logic,

		block = append(block, "//go:build "...)
		block = append(block, x.String()...)
		block = append(block, tabwriter.Escape, '\n')
		if len(p.plusBuild) > 0 {
			lines, err := constraint.PlusBuildLines(x)
			if err != nil {
				lines = []string{"// +build error: " + err.Error()}
			}
			for _, line := range lines {
				block = append(block, tabwriter.Escape)
				block = append(block, line...)