resetMap(createArrayWithNullValue());
  }

  /**
   * Equivalent to {@link #expectMissingKeys(Object[]) expectMissingKeys} {@code (null)} except that
   * the call to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {

        }

        final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        if (systemClassLoader != null) {
            return systemClassLoader;
        }

        throw new ClIllegalStateException(MessageFormatter.getMessage("ECL0001", "ClassLoader"));
    }

    /**
     * Returns <code>true</code> if the class loader <code>other</code> is an ancestor of the class loader <code>cl</code>.

        if (StringUtil.isBlank(url)) {
            throw new PluginException("url is blank: " + artifact.getName());
        }
        if (url.startsWith("http:") || url.startsWith("https:")) {
            try (final CurlResponse response = createCurlRequest(url).execute()) {
                if (response.getHttpStatusCode() != 200) {

        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }
        final String content = params.getOrDefault(ExtractData.RESOURCE_NAME_KEY, StringUtil.EMPTY);
        try {
            return new ExtractData(content);
        } catch (final Exception e) {
            throw new ExtractException(e);
        }
    }

        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }
        try {
            @SuppressWarnings("resource")
            final VisioTextExtractor visioTextExtractor = new VisioTextExtractor(in);
            return new ExtractData(visioTextExtractor.getText());
        } catch (final IOException e) {
            throw new ExtractException(e);
        }
    }

            final long now = SystemUtil.currentTimeMillis();
            if (now - previousTime < interval) {
                throw new IllegalStateException();
            }
            previousTime = now;

            count++;
            if (count <= exceptionCount) {
                throw new CrawlerSystemException("exception " + count);
            }

            final ResponseData responseData = new ResponseData();

        SocketInputStream sis = new SocketInputStream(in);

        // Try to skip more than available
        // Skip uses read internally, which may throw IOException when it tries to read the next header
        try {
            long skipped = sis.skip(10);
            // If it doesn't throw, it should only skip what's available
            assertEquals(3, skipped);
        } catch (IOException e) {

    return certificates.single() as X509Certificate
  } catch (nsee: NoSuchElementException) {
    throw IllegalArgumentException("failed to decode certificate", nsee)
  } catch (iae: IllegalArgumentException) {
    throw IllegalArgumentException("failed to decode certificate", iae)
  } catch (e: GeneralSecurityException) {
    throw IllegalArgumentException("failed to decode certificate", e)
  }
}

/**

    for (String propertyName : new String[] {"value", "absent"}) {
      Method method = null;
      try {
        method = annotationClass.getMethod(propertyName);
      } catch (NoSuchMethodException e) {
        throw new AssertionError("Annotation is missing required method", e);
      }
      Class<?> returnType = method.getReturnType();
      assertTrue(

    this.iterator = iterator;
  }

  @Override
  public Iterator<E> iterator() {
    if (iterator == null) {
      // TODO: throw something else? Do we worry that people's code and tests
      // might be relying on this particular type of exception?
      throw new IllegalStateException();
    }
    try {
      return iterator;
    } finally {
      iterator = null;
    }
  }