}

    def "can write and then read a block multiple times"() {
        expect:
        def block = write("test")
        read(block) == "test"
        read(block) == "test"
        read(block) == "test"
    }

    def "can write multiple blocks and read in any order"() {
        expect:
        def block1 = write("test 1")
        def block2 = write("test 2")
        def block3 = write("test 3")

        def block1 = server.expectAndBlock("block1")
        def block2 = server.expectAndBlock("block2")

        when:
        // Block until first build has produced red things
        def build1 = executer.withTasks("redThings", "block1", "blueThings").start()
        block1.waitForAllPendingCalls()

        // Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()

    dependsOn a
    inputFile = a.outputFile
    outputFile = file('out.b.txt')
}
task block1 {
    doLast {
        ${server.callFromBuild("block1")}
    }
}
block1.mustRunAfter a
b.mustRunAfter block1

task block2 {
    doLast {
        ${server.callFromBuild("block2")}
    }
}
block2.mustRunAfter b
"""
        TestFile inputAFile = file('src.a.txt')

type transformerFunc func(t testing.TB, block cipher.Block, key []byte) value.Transformer

func newGCMTransformer(t testing.TB, block cipher.Block, _ []byte) value.Transformer {
	t.Helper()

	transformer, err := NewGCMTransformer(block)
	if err != nil {
		t.Fatal(err)
	}

	return transformer
}

func newGCMTransformerWithUniqueKeyUnsafeTest(t testing.TB, block cipher.Block, _ []byte) value.Transformer {
	t.Helper()

task b {
    def files = configurations.b
    doLast {
        files.files
    }
}
task block1 {
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}
block1.mustRunAfter a
b.mustRunAfter block1

task block2 {
    doLast {
        ${blockingServer.callFromBuild("block2")}
    }
}
block2.mustRunAfter b
"""
        // Ensure scripts are compiled
        run("help")

        expect:

    }
}

task block1 {
    dependsOn tasks.a
    onlyIf { project.hasProperty("enable-block1") }
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}

task b {
    dependsOn tasks.block1
    doLast {
        configurations.b.files
    }
}

task block2 {
    dependsOn tasks.b
    onlyIf { project.hasProperty("enable-block2") }
    doLast {

        ''')
        ClassDoc classDoc = classDoc('Class', content: content)
        BlockDoc block1 = blockDoc('block1', id: 'block1', description: 'block1 description', comment: 'block1 comment', type: 'org.gradle.Type')
        BlockDoc block2 = blockDoc('block2', id: 'block2', description: 'block2 description', comment: 'block2 comment', type: 'org.gradle.Type', multivalued: true)
        _ * classDoc.classProperties >> []

cathedral(thing(a: 12, 123, false))
""")
    }

    def "can add code blocks"() {
        given:
        def block1 = builder.block("Add some thing", "foo.bar")
        block1.propertyAssignment(null, "foo.bar", "bazar", true)
        def block2 = builder.block("Do it again", "foo.bar")
        block2.propertyAssignment(null, "foo.bar", "bazar", true)
        builder.block(null, "other")

        when:

""")
    }

    def "can add code blocks"() {
        given:
        def block1 = builder.block("Add some thing", "foo.bar")
        block1.propertyAssignment(null, "foo.bar", "bazar", true)
        def block2 = builder.block("Do it again", "foo.bar")
        block2.propertyAssignment(null, "foo.bar", "bazar", true)
        builder.block(null, "other")

        when:

		return
	}
	// Self-check: Verify that the instrumented basic blocks are disjoint.
	t := make([]block1, len(f.blocks))
	for i := range f.blocks {
		t[i].Block = f.blocks[i]
		t[i].index = i
	}
	sort.Sort(blockSlice(t))
	for i := 1; i < len(t); i++ {
		if t[i-1].endByte > t[i].startByte {
			fmt.Fprintf(os.Stderr, "cover: internal error: block %d overlaps block %d\n", t[i-1].index, t[i].index)