* @param predicateType The first parameter to the method (boolean or Object)
   */
  private static ImmutableList<ImmutableList<Class<?>>> allSignatures(Class<?> predicateType) {
    ImmutableSet.Builder<ImmutableList<Class<?>>> allOverloads = ImmutableSet.builder();
    // The first two are for the overloads that don't take formatting args, e.g.
    // checkArgument(boolean) and checkArgument(boolean, Object)

   * @param predicateType The first parameter to the method (boolean or Object)
   */
  private static ImmutableList<ImmutableList<Class<?>>> allSignatures(Class<?> predicateType) {
    ImmutableSet.Builder<ImmutableList<Class<?>>> allOverloads = ImmutableSet.builder();
    // The first two are for the overloads that don't take formatting args, e.g.
    // checkArgument(boolean) and checkArgument(boolean, Object)

    private long fp;
    private int readSize, readSizeFile, openFlags, access, sharing;
    private byte[] tmp = new byte[1];

    SmbFile file;

    private boolean largeReadX;

    private final boolean unsharedFile;

    private boolean smb2;

    /**
     * Creates an input stream for reading from the specified SMB URL
     *
     * @param url the SMB URL to read from
     * @param tc

     */
    @Deprecated
    Model interpolate(Model project, Map<String, ?> context) throws ModelInterpolationException;

    /**
     * @deprecated Use {@link ModelInterpolator#interpolate(Model, File, ProjectBuilderConfiguration, boolean)} instead.
     */
    @Deprecated
    Model interpolate(Model model, Map<String, ?> context, boolean strict) throws ModelInterpolationException;

            boolean done = false;
            for (int i = 0; i < 60; i++) {
                final List<Map<String, Object>> installed =
                        checkGetMethod(Collections.emptyMap(), getInstalledEndpointSuffix() + "/").body()
                                .jsonPath()
                                .get("response.plugins");
                boolean exists = installed.stream()

}

data class GradleSubproject(
    val name: String,
    val path: String,
    val unitTests: Boolean = true,
    val functionalTests: Boolean = true,
    val crossVersionTests: Boolean = false,
) {
    fun hasTestsOf(testType: TestType) =
        (unitTests && testType.unitTests) ||
            (functionalTests && testType.functionalTests) ||

    }
  }

  private abstract static class MapTests extends MapInterfaceTest<String, Integer> {

    MapTests(
        boolean allowsNullValues,
        boolean supportsPut,
        boolean supportsRemove,
        boolean supportsClear,
        boolean supportsIteratorRemove) {
      super(
          false,
          allowsNullValues,
          supportsPut,
          supportsRemove,

    public int security;
    /**
     * Whether the server requires encrypted passwords.
     */
    public boolean encryptedPasswords;
    /**
     * Whether message signing is enabled.
     */
    public boolean signaturesEnabled;
    /**
     * Whether message signing is required.
     */
    public boolean signaturesRequired;
    /**
     * Maximum number of virtual circuits.
     */
    public int maxNumberVcs;

    public boolean equals(@Nullable Object obj) {
      if (obj instanceof SameCharacterInstance) {
        SameCharacterInstance that = (SameCharacterInstance) obj;
        return i == that.i;
      }
      return false;
    }
  }

  static class SameBooleanInstance {
    private final Boolean i;

    public SameBooleanInstance(Boolean i) {
      this.i = checkNotNull(i);
    }

    implements Multimap<K, V> {
  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    for (Collection<V> collection : asMap().values()) {
      if (collection.contains(value)) {
        return true;
      }
    }

    return false;
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {