assertTrue(content.contains("コメント"));
    }

    public void test_getXml_null() {
        try {
            xmlExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }
    }

      val handshake = response.handshake
      println(
        "${handshake!!.tlsVersion} ${handshake.cipherSuite} ${response.protocol} " +
          "${response.code} ${response.body.bytes().size}b",
      )
    }
  } catch (ioe: IOException) {
    println(ioe)
  }
}

fun main(vararg args: String) {
  // System.setProperty("javax.net.debug", "ssl:handshake:verbose");

        try {
            final DuplicateHostService duplicateHostService = ComponentUtil.getComponent(DuplicateHostService.class);
            duplicateHostList.addAll(duplicateHostService.getDuplicateHostList());
        } catch (final AutoBindingFailureException e) {
            logger.warn("DuplicateHostService is not found.", e);
        }
    }

    /**
     * Sets the list of duplicate host rules.
     *

                  actualIsOccupiedByCurrentThread.set(monitor.isOccupiedByCurrentThread());
                  actualOccupiedDepth.set(monitor.getOccupiedDepth());
                } catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertNull(thrown.get());
    assertEquals(expectedIsOccupied, actualIsOccupied.get());

          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)

                  actualIsOccupiedByCurrentThread.set(monitor.isOccupiedByCurrentThread());
                  actualOccupiedDepth.set(monitor.getOccupiedDepth());
                } catch (Throwable t) {
                  thrown.set(t);
                }
              }
            }));
    assertNull(thrown.get());
    assertEquals(expectedIsOccupied, actualIsOccupied.get());

                    logger.debug("Updating job schedule:{}", scheduledJob.getName());
                }
                try {
                    jobHelper.register(scheduledJob);
                } catch (final Exception e) {
                    logger.warn("Failed to update schdule {}", scheduledJob, e);
                }
            });
            schedulerTime = now;

    AtomicInteger runCalled = new AtomicInteger();
    list.add(
        new Runnable() {
          @Override
          public void run() {
            try {
              okayToRun.await();
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
              throw new RuntimeException(e);
            }
            runCalled.getAndIncrement();
          }
        },

 * </p>
 *
 * <p>
 * Example usage:
 * </p>
 *
 * <pre>
 * try {
 *     // Attempt to access a resource
 * } catch (CrawlingAccessException e) {
 *     if (e.isErrorEnabled()) {
 *         // Log the error
 *     }
 * }
 * </pre>
 */
public class CrawlingAccessException extends CrawlerSystemException {

        try {
            userService.changePassword(username, form.newPassword);
            saveInfo(messages -> messages.addSuccessChangedPassword(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to change password for {}", username, e);
            throwValidationError(messages -> messages.addErrorsFailedToChangePassword(GLOBAL), toIndexPage);
        }