private void wrapContentInContainer(Document document) {
        // Wrap the page in a text container to get the margins
        Elements bodyContent = document.body().children().remove();
        document.body().prepend("<div class='container'/>");
        document.body().children().get(0).html(bodyContent.outerHtml());
    }

    private void addTOC(Document document) {

                props.put(propertyDoc.getName(), propertyDoc.forClass(classDoc, additionalValues.values()));
            }
        }

        for (Element row : children(classDoc.getPropertiesTable(), "tr")) {
            List<Element> cells = children(row, "td");
            if (cells.size() != header.size()) {
                throw new RuntimeException(String.format("Expected %s <td> elements in <tr>, found: %s", header.size(), tr));

            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()
            val children = readList().uncheckedCast<List<CopySpecInternal>>()
            val copySpec = DefaultCopySpec(fileCollectionFactory, objectFactory, instantiator, patternSetFactory, destPath, sourceFiles, patterns, actions, children)
            copySpec.duplicatesStrategy = duplicatesStrategy
            copySpec.includeEmptyDirs = includeEmptyDirs

    private final String description;
    private final Action<? super ModelSchema<T>> validator;
    private ModelSchema<T> result;
    private final List<DefaultModelSchemaExtractionContext<?>> children = new ArrayList<>();
    private final FormattingValidationProblemCollector problems;

        then:
        fixture.assertNoConfigurationCache()

        with(expectedProjectModel) {
            it.name == "root"
            it.tasks.size() > 0
            it.children.size() == 1
            it.children[0].children.size() == 1
        }

        when: "fetching with Isolated Projects"
        executer.withArguments(ENABLE_CLI)
        def projectModel = fetchModel(GradleProject)

        then:

        given:
        def parents = []
        def children = []

        when:
        container.add new TypeOf<List<Parent>>() {}, "parents", parents
        container.add new TypeOf<List<Child>>() {}, "children", children

        then:
        container.getByType(new TypeOf<List<Parent>>() {}) is parents
        container.getByType(new TypeOf<List<Child>>() {}) is children
    }

    def "can get extensions schema"() {

        } else if (segment.contains("*") || segment.contains("?")) {
            PatternStep step = PatternStepFactory.getStep(segment, false);
            File[] children = file.listFiles();
            if (children == null) {
                if (!file.canRead()) {
                    throw new GradleException(String.format("Could not list contents of directory '%s' as it is not readable.", file));
                }

        set.containsAll(set as List)
        set.containsAll(set.findAll { it.name == '1' })
        !set.containsAll(["green"])
        !set.containsAll([{} as NamedThing])
    }

    def "can configure children"() {
        when:
        mutate {
            afterEach {
                value += " after"
            }
            create { name = '1' }
            beforeEach {
                value = "before"

    for (kid in kidsArray) {
        if (kid == null) break
        kid.print(indent)
        print(kid, "\t$indent")
    }
}


internal
fun FlyweightCapableTreeStructure<LighterASTNode>.children(
    node: LighterASTNode
): List<LighterASTNode> {
    val ref = Ref<Array<LighterASTNode?>>()
    getChildren(node, ref)
    return ref.get()
        .filterNotNull()
        .filter { it.isUseful }

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.util.ArrayList;
import java.util.List;

public class ModelBuilderSupport {
    protected List<Element> children(Element element, String childName) {
        List<Element> matches = new ArrayList<Element>();
        NodeList childNodes = element.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {