private ExceptionWithSomePrivateConstructors(String a) {}

    private ExceptionWithSomePrivateConstructors(String a, String b) {}

    public ExceptionWithSomePrivateConstructors(String a, String b, String c) {}

    private ExceptionWithSomePrivateConstructors(String a, String b, String c, String d) {}

    private ExceptionWithSomePrivateConstructors(

 */
@Deprecated(since = "4.0.0")
class DefaultModelProblemCollector implements ModelProblemCollectorExt {

    private final ModelBuildingResult result;

    private List<ModelProblem> problems;

    private String source;

    private Model sourceModel;

    private Model rootModel;

    private Set<ModelProblem.Severity> severities = EnumSet.noneOf(ModelProblem.Severity.class);

        }
        return difference(multiset1, multiset2);
      }
    };
  }

  private static final ImmutableMultiset<String> ELEMENTS_TO_FILTER_OUT =
      ImmutableMultiset.of("foobar", "bazfoo", "foobar", "foobar");

  private static final Predicate<String> PREDICATE = not(Predicates.in(ELEMENTS_TO_FILTER_OUT));

  private static TestStringMultisetGenerator filteredGenerator() {
    return new TestStringMultisetGenerator() {

   */
  private static class ListenableFutureAdapter<V extends @Nullable Object>
      extends ForwardingFuture<V> implements ListenableFuture<V> {

    private static final ThreadFactory threadFactory =
        new ThreadFactoryBuilder()
            .setDaemon(true)
            .setNameFormat("ListenableFutureAdapter-thread-%d")
            .build();
    private static final Executor defaultAdapterExecutor =

    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);

import jcifs.CIFSContext;
import jcifs.smb.SmbFileInputStream;


/**
 * 
 *
 */
public class Lmhosts {

    private static final Logger log = LoggerFactory.getLogger(Lmhosts.class);

    private final Map<Name, NbtAddress> table = new HashMap<>();
    private long lastModified = 1L;
    private int alt;


    /**
     * This is really just for {@link jcifs.netbios.UniAddress}. It does

			portRange = tokens[1]
		case "tls-private-key":
			tlsPrivateKey = tokens[1]
		case "tls-public-cert":
			tlsPublicCert = tokens[1]
		}
	}

	// Verify if only partial inputs are given for FTP(secure)
	{
		if tlsPrivateKey == "" && tlsPublicCert != "" {
			logger.Fatal(fmt.Errorf("invalid TLS arguments provided missing private key --ftp=\"tls-private-key=path/to/private.key\""), "unable to start FTP server")
		}

    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);

    public class DocMeta implements Serializable {

        private static final long serialVersionUID = 1L;

        protected String id;

        protected Long version;

        protected Long seqNo;

        protected Long primaryTerm;

        private transient RequestOptionCall<IndexRequestBuilder> indexOption;

        private transient RequestOptionCall<DeleteRequestBuilder> deleteOption;

   * much faster to initialize than [BasicTrustRootIndex] because it doesn't need to load and
   * index trusted CA certificates.
   */
  internal data class CustomTrustRootIndex(
    private val trustManager: X509TrustManager,
    private val findByIssuerAndSignatureMethod: Method,
  ) : TrustRootIndex {
    override fun findByIssuerAndSignature(cert: X509Certificate): X509Certificate? {
      return try {
        val trustAnchor =