.setResolveTransitively(true);

        try {
            result = repositorySystem.resolve(request);
            resolutionErrorHandler.throwErrors(request, result);
        } catch (Exception e) {
            assertTrue(result.hasMissingArtifacts());
        }
    }

    @Test
    void testLocalRepositoryBasedir() throws Exception {

        assertTrue(content.contains("テスト"));
    }

    public void test_getText_null() {
        try {
            jodExtractor.getText(null, null);
            fail();
        } catch (CrawlerSystemException e) {
            // NOP
        }
    }

      Assert.fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      hashFunction.hashBytes(new byte[128], 64, 256 /* too long len */);
      Assert.fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      hashFunction.hashBytes(new byte[64], 0, -1);
      Assert.fail();
    } catch (IndexOutOfBoundsException expected) {
    }
  }

     */
    @Override
    public ActionResponse godHandPrologue(final ActionRuntime runtime) {
        try {
            return super.godHandPrologue(runtime);
        } catch (final UserRoleLoginException e) {
            return redirect(e.getActionClass());
        }
    }

    /**
     * Hook method called before action execution.
     * <p>

                                writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });

    Class<? extends Exception> exceptionType = this.exceptionType.exceptionType;
    for (int i = 0; i < reps; ++i) {
      try {
        tmp += getChecked(validator, future, exceptionType).hashCode();
      } catch (Exception e) {
        tmp += e.hashCode();
      }
    }
    return tmp;
  }

  private static GetCheckedTypeValidator nonCachingWithoutConstructorCheckValidator() {

  public void testAddAllAtIndex_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(n, nothing) should return false or throw",
          getList().addAll(0, emptyCollection()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_withDuplicates() {

    doParallelCacheOp(
        count,
        n -> {
          try {
            String unused = cache.get(key, () -> key);
            cache.asMap().compute(key, (k, v) -> null);
          } catch (ExecutionException e) {
            throw new UncheckedExecutionException(e);
          }
        });

    CacheTesting.checkEmpty(cache);
    for (RemovalNotification<String, String> entry : notifications) {

                            isBeingDeleted, isInConflict, isActive, isPermanent, macAddress);
                }
            }
        } catch (final UnsupportedEncodingException uee) {}
        return srcIndex - start;
    }

    @Override
    public String toString() {
        return ("NodeStatusResponse[" + super.toString() + "]");
    }

        configuration.setResolveDependencies(true);
        initRepoSession(configuration);

        try {
            return projectBuilder.build(pom, configuration).getProject();
        } catch (Exception e) {
            Throwable cause = e.getCause();
            if (cause instanceof ModelBuildingException modelBuildingException) {
                StringBuilder message = new StringBuilder("In: " + pom + "\n\n");