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++) {

 * limitations under the License.
 */
package gradlebuild.docs

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

class DomBuilder extends BuilderSupport {
    Document document
    Node parent
    List elements = []

    def DomBuilder(Document document) {
        this.document = document
        this.parent = document

            .map(Version::fromString)
            .collect(Collectors.toList());

        BwcVersions vc = new BwcVersions(
            listOfVersions.stream().map(this::formatVersionToLine).collect(Collectors.toList()),
            Version.fromString("8.0.0")
        );
        vc.compareToAuthoritative(authoritativeReleasedVersions);
    }

 */

package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.dsl.docbook.model.ClassDoc;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class ClassDescriptionRenderer {
    private final ElementWarningsRenderer warningsRenderer = new ElementWarningsRenderer();

    public void renderTo(ClassDoc classDoc, Element parent) {

    when {
      PlatformVersion.majorVersion > 11 -> {
        assertThat(s.enabledProtocols.toList()).containsExactly(
          "TLSv1.3",
          "TLSv1.2",
        )
      }

      // Not much we can guarantee on JDK 11.
      PlatformVersion.majorVersion == 11 -> {
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      }

            getUnreleased().stream().filter(version -> version.equals(currentVersion) == false).collect(Collectors.toList())
        ).stream()
            .map(version -> new UnreleasedVersionInfo(version, getBranchFor(version), getGradleProjectPathFor(version)))
            .collect(Collectors.toList());

        collect.forEach(consumer::accept);
    }

    private String getGradleProjectPathFor(Version version) {

            return br.lines()
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
        }
    }

    private static void checkCommit(String commit) throws IOException, InterruptedException, ExecutionException {
        List<String> parentCommits = parentCommitsOf(commit);

        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))
                .collect(Collectors.toList()));
    }

    @Override
    protected void mergeDependency_Exclusions(
            Dependency.Builder builder,
            Dependency target,
            Dependency source,

    }

    /**
     * Appends the string representation of a {@link NodeList}.
     *
     * @param children
     *            The child nodes. Must not be {@literal null}.
     * @param buf
     *            The string buffer. Must not be {@literal null}.
     */
    public static void appendChildren(final NodeList children, final StringBuilder buf) {
        assertArgumentNotNull("children", children);

                .toList();
    }

    @Override
    @Nonnull
    public List<Profile> getDeclaredActiveProfiles() {
        return project.getActiveProfiles().stream()
                .map(org.apache.maven.model.Profile::getDelegate)
                .toList();
    }

    @Override
    @Nonnull