*
     * @param model The model whose reporting section should be converted, must not be <code>null</code>.
     * @param request The model building request that holds further settings, must not be {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.
     */
    void convertReporting(Model model, ModelBuildingRequest request, ModelProblemCollector problems);

     * the method returns.
     *
     * @param output The writer to serialize the toolchains to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param toolchains The toolchains to serialize, must not be {@code null}.
     * @throws IOException If the toolchains could not be serialized.
     */

import model.Stage

open class BaseGradleBuildType(
    open val stage: Stage? = null,
    open val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {}
) : BuildType() {
    init {
        this.init()
    }
}

open class OsAwareBaseGradleBuildType(
    val os: Os,
    override val stage: Stage? = null,
    override val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {}

  public void testAddAllAtIndex_nullSupported() {
    List<E> containsNull = singletonList(null);
    assertTrue("addAll(n, containsNull) should return true", getList().addAll(0, containsNull));
    /*
     * We need (E) to force interpretation of null as the single element of a
     * varargs array, not the array itself
     */
    expectAdded(0, (E) null);
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)

                    break;
                }
            }
            if ( this.authMethod == null )
                return null;
            NtlmMessage message = ( authorization != null ) ? new Type2Message(Base64.decode(authorization)) : null;
            reconnect();
            if ( message == null ) {
                message = new Type1Message(this.transportContext);

        if (formatType != null) {
            return formatType;
        }

        formatType = detectFormatType(request);
        request.setAttribute(API_FORMAT_TYPE, formatType);
        return formatType;
    }

    protected FormatType detectFormatType(final HttpServletRequest request) {
        String value = request.getParameter("type");
        if (value == null) {

  /**
   * Determines whether two possibly-null objects are equal. Returns:
   *
   * <ul>
   *   <li>{@code true} if {@code a} and {@code b} are both null.
   *   <li>{@code true} if {@code a} and {@code b} are both non-null and they are equal according to
   *       {@link Object#equals(Object)}.
   *   <li>{@code false} in all other situations.
   * </ul>
   *

            @Nonnull Session session, @Nonnull Collection<? extends ArtifactCoordinates> coordinates) {
        return builder()
                .session(nonNull(session, "session cannot be null"))
                .coordinates(nonNull(coordinates, "coordinates cannot be null"))
                .build();
    }

    @Nonnull
    static ArtifactResolverRequest build(
            @Nonnull Session session,

   */
  public void add(Runnable runnable, Executor executor) {
    // Fail fast on a null. We throw NPE here because the contract of Executor states that it throws
    // NPE on null listener, so we propagate that contract up into the add method as well.
    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that

    in 191..242 -> "8.1.13.v20181017"
    else -> null
  }
}

/**
 * Returns the alpn-boot version specific to this OpenJDK 8 JVM, or null if this is not a Java 8 VM.
 * https://github.com/xjdr/xio/blob/master/alpn-boot.gradle
 */
fun alpnBootVersion(): String? {
  val version = System.getProperty("alpn.boot.version")

  if (version != null) {
    return version
  }