i++;
                }
            }
        }

        return false;
    }

    static boolean isAllDigits(final String hostname) {
        for (int i = 0; i < hostname.length(); i++) {
            if (!Character.isDigit(hostname.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**

                        "parameters": [
                            {
                                "name": "q",
                                "in": "query",
                                "required": False,
                                "schema": {
                                    "anyOf": [
                                        {"type": "string", "pattern": "^fixedquery$"},

        requiresOs(Os.LINUX)
    }

    params {
        text(
            "wrapperVersion",
            "should-be-overridden",
            display = ParameterDisplay.PROMPT,
            allowEmpty = false,
            description =
                "The version of Gradle to update to. " +
                    "Can be a specific version or one of 'latest', 'release-candidate', 'release-milestone'",
        )

    @Inject
    public Check(StrategyOrchestrator orchestrator) {
        super(orchestrator);
    }

    @Override
    protected boolean shouldSaveModifications() {
        return false;
    }

    @Override
    public int execute(UpgradeContext context) throws Exception {
        context.info("Maven Upgrade Tool - Check");
        context.println();

        return super.execute(context);

    assertTrue(message, collection.retainAll(target.toRetain));
  }

  private void expectReturnsFalse(Target target) {
    String message = Platform.format("retainAll(%s) should return false", target);
    assertFalse(message, collection.retainAll(target.toRetain));
  }

  private void expectThrows(Target target) {
    try {
      collection.retainAll(target.toRetain);

              () -> {
                try {
                  return method.invoke(target, args);
                } catch (InvocationTargetException e) {
                  throw throwCause(e, /* combineStackTraces= */ false);
                }
              };
          return callWithTimeout(
              callable, timeoutDuration, timeoutUnit, interruptibleMethods.contains(method));
        };
    return newProxy(interfaceType, handler);

   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code flush}
   *     method
   * @throws IOException if {@code swallowIOException} is false and {@link Flushable#flush} throws
   *     an {@code IOException}.
   * @see Closeables#close
   */
  @SuppressWarnings("IdentifierName") // See Closeables.close

      Entry<K, V> entry = unfilteredItr.next();
      if (entryPredicate.apply(entry) && Objects.equals(entry.getValue(), o)) {
        unfilteredItr.remove();
        return true;
      }
    }
    return false;
  }

  @Override
  public boolean removeAll(Collection<?> c) {
    return Iterables.removeIf(
        multimap.unfiltered().entries(),
        and(multimap.entryPredicate(), valuePredicateOnEntries(in(c))));
  }

  public final boolean equals(@Nullable Object o) {
    if (o instanceof TypeParameter) {
      TypeParameter<?> that = (TypeParameter<?>) o;
      return typeVariable.equals(that.typeVariable);
    }
    return false;
  }

  @Override
  public String toString() {
    return typeVariable.toString();
  }

        while (tg.getParent() == null) {
            tg = tg.getParent();
        }

        ThreadGroup[] tgList = new ThreadGroup[tg.activeGroupCount()];
        tg.enumerate(tgList);

        boolean seen = false;

        for (ThreadGroup aTgList : tgList) {
            if (!aTgList.getName().equals(DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME)) {
                continue;
            }