buffer.append("Could not find goal '").append(goal).append('\'');

        if (pluginDescriptor != null) {
            buffer.append(" in plugin ").append(pluginDescriptor.getId());

            buffer.append(" among available goals ");
            List<MojoDescriptor> mojos = pluginDescriptor.getMojos();
            if (mojos != null) {
                for (Iterator<MojoDescriptor> it = mojos.iterator(); it.hasNext(); ) {

              "options": {
                "match": "null",
                "result": {
                  "text": "N/A"
                }
              },
              "type": "special"
            }
          ],
          "thresholds": {
            "mode": "absolute",
            "steps": [
              {
                "color": "green",
                "value": null
              },
              {

      init {
        val trustManager = trustManagerForCertificates(trustedCertificatesInputStream())
        val sslContext = SSLContext.getInstance("TLS")
        sslContext.init(null, arrayOf<TrustManager>(trustManager), null)
        val sslSocketFactory = sslContext.socketFactory

        client = OkHttpClient.Builder()
            .sslSocketFactory(sslSocketFactory, trustManager)
            .build()
      }

    return (connectingEdge == null)
        ? ImmutableSet.<E>of().iterator()
        : Iterators.singletonIterator(connectingEdge);
  }

  @Override
  public int size() {
    return getConnectingEdge() == null ? 0 : 1;
  }

  @Override
  public boolean contains(@CheckForNull Object edge) {
    E connectingEdge = getConnectingEdge();
    return (connectingEdge != null && connectingEdge.equals(edge));
  }

     * .
     */
    @Test
    public void testCreateAndCopySrcNull() {
        exception.expect(NullArgumentException.class);
        exception.expectMessage(is("[ECL0008]argument[calendar] is null."));
        CalendarConversionUtil.localize(null);
    }

     * filter out incompatible values from its result.
     *
     * @param value The configuration value to preprocess, must not be {@code null}.
     * @param type The target type of the value, may be {@code null}.
     * @return The processed configuration value or {@code null} if none.
     * @throws BeanConfigurationException If an error occurred while preprocessing the value.
     */

            MASTER_BRANCH -> 0
            RELEASE_BRANCH -> 1
            else -> {
                val matchResult = OLD_RELEASE_PATTERN.find(branchName)
                if (matchResult == null) {
                    null
                } else {
                    (matchResult.groupValues[1].toInt() - 4).apply {
                        require(this in 2..23)
                    }
                }
            }

        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent;
    }

    public Object getDelegate() {

        .createTestSuite();
  }

  // TODO: consider being null-hostile in these tests

  private static Test testsForHashMapNullKeysForbidden() {
    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override
          Map<String, String> wrap(final HashMap<String, String> map) {
            if (map.containsKey(null)) {
              throw new NullPointerException();
            }

    return try {
      val response = call.execute()
      val bodyString = response.body.string()
      RecordedResponse(request, response, null, bodyString, null)
    } catch (e: IOException) {
      RecordedResponse(request, null, null, null, e)
    }
  }