sb.append(":");
            if (version != null) {
                sb.append(version);
            }
            return sb.toString();
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (null == obj || !getClass().equals(obj.getClass())) {
                return false;
            }

     * @param active Should the profile be activated?
     * @param optional Can the build continue if the profile does not exist?
     */
    public void addProfileActivation(String id, boolean active, boolean optional) {
        final ActivationSettings settings = ActivationSettings.of(active, optional);
        this.activations.put(id, settings);
    }

import org.opensearch.index.query.QueryBuilders;

public class WildcardQueryCommand extends QueryCommand {
    private static final Logger logger = LogManager.getLogger(WildcardQueryCommand.class);

    protected boolean lowercaseWildcard = true;

    @Override
    protected String getQueryClassName() {
        return WildcardQuery.class.getSimpleName();
    }

    @Override

      .addHeader("content-length", s.length / 2)
      .build()
  }

  private fun buildLocalhost(
    bootstrapClient: OkHttpClient,
    includeIPv6: Boolean,
    post: Boolean = false,
  ): DnsOverHttps {
    val url = server.url("/lookup?ct")
    return DnsOverHttps.Builder().client(bootstrapClient)
      .includeIPv6(includeIPv6)
      .resolvePrivateAddresses(true)

    //                                                                         ===========
    @Override
    public boolean hasPrimaryKey() {
        return false;
    }

    @Override
    public boolean hasCompoundPrimaryKey() {
        return false;
    }

    @Override
    protected UniqueInfo cpui() {
        return null;
    }

 *   }
 * });
 * }</pre>
 *
 * @author Ben Yu
 * @since 14.0
 */
@GwtIncompatible
@J2ktIncompatible
@ElementTypesAreNonnullByDefault
public final class ForwardingWrapperTester {

  private boolean testsEquals = false;

  /**
   * Asks for {@link Object#equals} and {@link Object#hashCode} to be tested. That is, forwarding
   * wrappers of equal instances should be equal.
   */
  @CanIgnoreReturnValue

    private final DefaultTransformerContext context;

    private final Map<String, Set<FileModelSource>> mappedSources = new ConcurrentHashMap<>(64);

    private volatile boolean fullReactorLoaded;

    DefaultTransformerContextBuilder(DefaultModelBuilder defaultModelBuilder) {
        this.defaultModelBuilder = defaultModelBuilder;

    replaceWith = ReplaceWith(expression = "certificatePinner"),
    level = DeprecationLevel.ERROR,
  )
  fun certificatePinner(): CertificatePinner? = certificatePinner

  override fun equals(other: Any?): Boolean {
    return other is Address &&
      url == other.url &&
      equalsNonHost(other)
  }

  override fun hashCode(): Int {
    var result = 17
    result = 31 * result + url.hashCode()

        is JApiField -> this.getjApiClass()
        is JApiBehavior -> this.getjApiClass()
        else -> error("Unsupported japicmp member type '${this::class}'")
    }


internal
val JApiClass.isKotlin: Boolean
    get() = newClass.orNull()?.isKotlin ?: false


internal
val JApiClass.simpleName: String
    get() = fullyQualifiedName.substringAfterLast(".")


internal
val JApiClass.packagePath: String

import org.opensearch.index.IndexSettings;
import org.opensearch.index.analysis.AbstractTokenFilterFactory;

public class KuromojiReadingFormFilterFactory extends AbstractTokenFilterFactory {

    private final boolean useRomaji;

    public KuromojiReadingFormFilterFactory(IndexSettings indexSettings, Environment environment, String name, Settings settings) {
        super(indexSettings, name, settings);