System.exit(1);
        }
    }

    private static void downloadFileFromURL(String urlString, File destination) throws Exception {
        if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
            String username = System.getenv("MVNW_USERNAME");
            char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
            Authenticator.setDefault(new Authenticator() {

        while (!queue.isEmpty()) {
            ClassMetaData cl = queue.removeFirst();
            if (cl == null) {
                continue;
            }
            MethodMetaData overriddenMethod = cl.findDeclaredMethod(overrideSignature);
            if (overriddenMethod != null) {
                return overriddenMethod;
            }
            queue.add(cl.getSuperClass());

    @Override
    public List<String> convert(final String text, final String field, final String... langs) throws IOException {
        final ReadingConverter converter;
        if (langs == null || langs.length == 0) {
            converter = new LangAnayzerConverter(null);
        } else {
            final ReadingConverterChain chain = new ReadingConverterChain();
            for (final String lang : langs) {

    Iterable<@Nullable String> set = newHashSet("a", null, "b");
    assertTrue(Iterables.contains(set, null));
  }

  public void test_contains_null_set_no() {
    Iterable<String> set = newHashSet("a", "b");
    assertFalse(Iterables.contains(set, null));
  }

  public void test_contains_null_iterable_yes() {
    Iterable<@Nullable String> set = iterable("a", null, "b");
    assertTrue(Iterables.contains(set, null));

    /*
     * Even though it's weird to pass a defaultValue that is null, some callers do so. Those who
     * pass a literal "null" should probably just use `get`, but I would expect other callers to
     * pass an expression that *might* be null. This could happen with:
     *
     * - a `getFooOrDefault(@CheckForNull Foo defaultValue)` method that returns

      } // else no check necessary, all index values are valid
      ArrayReference<? extends L> existingRef = locks.get(index);
      L existing = existingRef == null ? null : existingRef.get();
      if (existing != null) {
        return existing;
      }
      L created = supplier.get();
      ArrayReference<L> newRef = new ArrayReference<>(created, index, queue);

public class ScheduledJobBhv extends BsScheduledJobBhv {

    private static final Logger logger = LogManager.getLogger(ScheduledJobBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {
            final String name = ComponentUtil.getFessConfig().getIndexConfigIndex();
            indexName = super.asEsIndex().replaceFirst(Pattern.quote("fess_config"), name);

            String artifactId,
            String version,
            String type,
            String classifier,
            Throwable t) {
        super(message, groupId, artifactId, version, type, classifier, null, null, t);
    }

    public ArtifactResolutionException(String message, Artifact artifact) {
        super(message, artifact);
    }

    public PersistedToolchains build(File userToolchainsFile) throws MisconfiguredToolchainException {
        PersistedToolchains toolchains = null;

        if (userToolchainsFile != null && userToolchainsFile.isFile()) {
            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path) {
        return fromPath(path, null);
    }

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path, @Nullable String location) {
        return new PathSource(nonNull(path, "path cannot be null"), location);
    }