super.prepareOptions(options);
            options.addOption(Option.builder(MODEL_VERSION)
                    .longOpt("model-version")
                    .hasArg()
                    .argName("version")
                    .desc("Target POM model version (4.0.0 or 4.1.0)")
                    .get());
            options.addOption(Option.builder(DIRECTORY)
                    .longOpt("directory")
                    .hasArg()

      if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket("my-bucketname").build())) {
        minioClient.makeBucket(MakeBucketArgs.builder().bucket("my-bucketname").build());
        System.out.println("my-bucketname is created successfully");
      }

      boolean isVersioningEnabled =
          minioClient.isVersioningEnabled(
              IsVersioningEnabledArgs.builder().bucket("my-bucketname").build());

  private final OkHttpClient client = new OkHttpClient.Builder()
      .certificatePinner(
          new CertificatePinner.Builder()
              .add("publicobject.com", "sha256/Vjs8r4z+80wjNcr1YKepWQboSIRi63WsWXhIMN+eWys=")
              .build())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/robots.txt")
        .build();

    ImmutableMap.Builder<R, ImmutableMap<C, V>> rowBuilder =
        new ImmutableMap.Builder<>(rows.size());
    for (Entry<R, Map<C, V>> row : rows.entrySet()) {
      rowBuilder.put(row.getKey(), ImmutableMap.copyOf(row.getValue()));
    }
    this.rowMap = rowBuilder.buildOrThrow();

    ImmutableMap.Builder<C, ImmutableMap<R, V>> columnBuilder =
        new ImmutableMap.Builder<>(columns.size());

            date += diff;
        }
        Rounding.Builder roundingBuilder;
        if (interval.startsWith("calendar ")) {
            roundingBuilder = Rounding.builder(
                DateHistogramAggregationBuilder.DATE_FIELD_UNITS.get(interval.substring("calendar ".length()))
            );
        } else {
            roundingBuilder = Rounding.builder(TimeValue.parseTimeValue(interval, "interval"));
        }

testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:5.3.0")
```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()

                return null;
            }
        };

        final Normalizer normalizer = (text, field, lang) -> null;

        final Suggester suggester = Suggester.builder()
                .settings(SuggestSettings.builder().setSettingsIndexName(settingsIndexName))
                .readingConverter(converter)
                .normalizer(normalizer)
                .build(runner.client(), id);

        assertTrue("Index creation should be acknowledged", response.isAcknowledged());

        final Suggester suggester = Suggester.builder().build(client, "test");

        // Use reflection to access private method
        final Method method = Suggester.class.getDeclaredMethod("getIndicesForAlias", String.class);
        method.setAccessible(true);

    }
  }

  private static final class MockEquivalence extends Equivalence<Object> {
    final ImmutableTable.Builder<Object, Object, Boolean> equivalentExpectationsBuilder =
        ImmutableTable.builder();
    final ImmutableMap.Builder<Object, Integer> hashExpectationsBuilder = ImmutableMap.builder();
    ImmutableTable<Object, Object, Boolean> equivalentExpectations;
    ImmutableMap<Object, Integer> hashExpectations;

    }
  }

  private static final class MockEquivalence extends Equivalence<Object> {
    final ImmutableTable.Builder<Object, Object, Boolean> equivalentExpectationsBuilder =
        ImmutableTable.builder();
    final ImmutableMap.Builder<Object, Integer> hashExpectationsBuilder = ImmutableMap.builder();
    ImmutableTable<Object, Object, Boolean> equivalentExpectations;
    ImmutableMap<Object, Integer> hashExpectations;