failure.assertThatCause(containsString("only buildscript {}, pluginManagement {} and other plugins {} script blocks are allowed before plugins {} blocks, no other statements are allowed"))
        includesLinkToUserguide()
    }

    def "settings scripts can have plugin blocks"() {
        when:
        settingsFile.text = """
          plugins {
            id "noop" version "1.0"
          }

//
// The entry point is Blocks[0]; there may be multiple return blocks.
type CFG struct {
	fset   *token.FileSet
	Blocks []*Block // block[0] is entry; order otherwise undefined
}

// A Block represents a basic block: a list of statements and
// expressions that are always evaluated sequentially.
//
// A block may have 0-2 successors: zero for a return block or a block

Both are based on Groovy language features and we explain them in the following sections.

=== Block method signatures

You can easily identify a method as the implementation behind a block by its signature, or more specifically, its argument types. If a method corresponds to a block:

 * It must have at least one argument.

					bb := s.Block()
					if ln.b2l[b.ID] == nil && ln.b2l[bb.ID] != nil && bb != ln.b2l[bb.ID].header {
						f.Fatalf("block %s not in loop branches to non-header block %s in loop", b.String(), bb.String())
					}
					if ln.b2l[b.ID] != nil && ln.b2l[bb.ID] != nil && bb != ln.b2l[bb.ID].header && !ln.b2l[b.ID].isWithinOrEq(ln.b2l[bb.ID]) {
						f.Fatalf("block %s in loop branches to non-header block %s in non-containing loop", b.String(), bb.String())

	item   *itemBuilder
	todo   func() line
}

func (b *listBuilder) build(p buildState) Block {
	blocks := p.blocks()
	pos := p.pos()

	// list can have wrong pos b/c extend dance.
	pos.EndLine = blocks[len(blocks)-1].Pos().EndLine
Loose:
	for i, c := range blocks {
		c := c.(*Item)
		if i+1 < len(blocks) {
			if blocks[i+1].Pos().StartLine-c.EndLine > 1 {
				b.loose = true
				break Loose
			}
		}

	"strings"
)

/*

list block itself does not appear on stack?
item does
end of item returns block,
new item continues previous block if possible?

if close leaves lines or blocks behind, panic

close(b a list item, parent)
	if b's parent's last block is list && item can be added to it, do so
	else return new list

or maybe not parent but just current list of blocks

preserve LinkRefDefs?

*/

import (
	"bytes"
)

type Quote struct {
	Position
	Blocks []Block
}

func (b *Quote) PrintHTML(buf *bytes.Buffer) {
	buf.WriteString("<blockquote>\n")
	for _, c := range b.Blocks {
		c.PrintHTML(buf)
	}
	buf.WriteString("</blockquote>\n")
}

func (b *Quote) printMarkdown(buf *bytes.Buffer, s mdState) {
	s.prefix += "> "
	printMarkdownBlocks(b.Blocks, buf, s)
}

func trimQuote(s line) (line, bool) {

        )
    }

    @Test
    fun `Settings target - top-level - pluginManagement block - empty body`() {

        val fragment = fragment("pluginManagement", "...")
        val program = Program.PluginManagement(fragment)

        assertThat(
            "reduces to static program that evaluates pluginManagement block then applies default plugin requests",
            partialEvaluationOf(
                program,

	blocks := make(map[string]*Block)
	values := make(map[string]*Value)
	// Create all the blocks and values.
	for _, bloc := range blocs {
		b := f.NewBlock(bloc.control.kind)
		blocks[bloc.name] = b
		for _, valu := range bloc.valus {
			// args are filled in the second pass.

    /**
     * Blocks until the build is complete and assert that the build completed successfully.
     */
    ExecutionResult waitForFinish();

    /**
     * Blocks until the build is complete and assert that the build completed with a failure.
     */
    ExecutionFailure waitForFailure();

    /**
     * Blocks until the build is complete and exits, disregarding the result.
     */