*/
    public void addMaxLength(final String mimeType, final long maxLength) {
        if (StringUtil.isBlank(mimeType)) {
            throw new CrawlerSystemException("MIME type is a blank.");
        }
        if (maxLength < 0) {
            throw new CrawlerSystemException("The value of maxLength is invalid.");
        }
        maxLengthMap.put(mimeType, maxLength);
    }

    /**

        } catch (SAXNotRecognizedException | SAXNotSupportedException e) {
            throw new SAXRuntimeException(e);
        } catch (final ParserConfigurationException e) {
            throw new ParserConfigurationRuntimeException(e);
        }
        return factory;
    }

    /**

    public T next() {
      try {
        return iterator.next();
      } catch (NoSuchElementException e) {
        nextThrewException = true;
        throw e;
      }
    }

    @Override
    public void remove() {
      if (nextThrewException) {
        throw new IllegalStateException();
      }
      iterator.remove();
    }
  }

  public void testCanCatchJdkBug6529795InTargetIterator() {

        return
      }
    }
    throw AssertionError("No such job: $url")
  }

  override fun shutdown() {
    shutdown = true
  }

  override fun shutdownNow(): List<Runnable> = throw UnsupportedOperationException()

  override fun isShutdown(): Boolean = shutdown

  override fun isTerminated(): Boolean = throw UnsupportedOperationException()

  override fun awaitTermination(

    TestCloseable c2 = closer.register(TestCloseable.normal());

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());

        if (sessionId == null || sessionId.isEmpty()) {
            throw new CIFSException("Session ID cannot be null or empty");
        }
        if (salt == null || salt.length < 16) {
            throw new CIFSException("Invalid preauth salt: minimum 16 bytes required");
        }
        if (!isHashAlgorithmSupported(hashAlgorithm)) {
            throw new CIFSException("Unsupported hash algorithm: " + hashAlgorithm);
        }

                    state = 0;
                    thread = null;
                    throw new TransportException("Connection timeout");
                case 2:
                    if (te != null) { /* doConnect throw Exception */
                        state = 4; /* error */
                        thread = null;
                        throw te;
                    }
                    state = 3; /* Success! */
                }

        searchEngineClient = new SearchEngineClient() {
            @Override
            public long deleteByQuery(String index, QueryBuilder query) {
                throw new RuntimeException("Delete operation failed");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job

                return acl;
              }
            };
        return () -> attribute;
      } catch (IOException e) {
        // We throw a new exception each time so that the stack trace is right.
        return () -> {
          throw new IOException("Could not find user", e);
        };
      }
    }

    private static String getUsername() {
      /*

            }
            // gz
            bis.reset();
            return parse(new GZIPInputStream(bis), false);
        } catch (final CrawlingAccessException e) {
            throw e;
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not parse Sitemaps: " + preloadDate, e);
        }
    }

    /**
     * Parses a text-based sitemap from the given input stream.