// For now, we'll keep the standard ones and allow modules to add more
  androidSignature(library("signature-android-apilevel21")) { artifact { type = "signature" } }
  jvmSignature(library("codehaus-signature-java18")) { artifact { type = "signature" } }

  "lintChecks"(library("androidx-lint-gradle"))
}

configure<com.android.build.api.dsl.Lint> {
  xmlReport = true
  checkDependencies = true
}

package org.codelibs.fess.suggest.index.operations;

/**
 * Encapsulates the context parameters commonly passed to content indexing operations.
 * Groups together index name, field configuration, and bad words to simplify method signatures.
 */
public class ContentIndexingContext {

    private final String index;
    private final String[] supportedFields;
    private final String[] tagFieldNames;
    private final String roleFieldName;

     *
     * @return whether signatures are supported but not required
     * @throws SmbException if an error occurs checking signing status
     */
    boolean isSigningOptional() throws SmbException;

    /**
     * Checks if message signing is mandatory for this connection.
     *
     * @return whether signatures are enforced from either side

import okio.BufferedSource

/**
 * Returns true if the body in question probably contains human-readable text. Uses a small
 * sample of code points to detect Unicode control characters commonly used in binary file
 * signatures.
 *
 * @param codePointLimit the number of code points to read in order to make a decision.
 */
internal fun BufferedSource.isProbablyUtf8(codePointLimit: Long = Long.MAX_VALUE): Boolean {
  try {
    val peek = peek()

class AddressTest extends BaseTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Address mockAddress;

    @Test
    @DisplayName("Address interface should define correct method signatures")
    void testInterfaceContract() {
        // Given
        Address address = mockAddress;

        // When & Then - verify interface methods exist and can be called
        assertDoesNotThrow(() -> {

        }
        final byte[] signature = digest();
        for (int i = 0; i < 8; i++) {
            if (signature[i] != data[offset + SmbConstants.SIGNATURE_OFFSET + i]) {
                if (log.isDebugEnabled()) {
                    log.debug("signature verification failure"); //$NON-NLS-1$
                    log.debug("Expect: " + Hexdump.toHexString(signature, 0, 8));

  testImplementation(libs.assertk)
  testImplementation(kotlin("test"))
}

val jvmSignature = configurations.getByName("jvmSignature")
configure<AnimalSnifferExtension> {
  // Only check JVM
  signatures = jvmSignature
}

configure<ApiValidationExtension> {
  validationDisabled = true
}

tasks.jar {
  manifest {
    attributes("Main-Class" to "okhttp3.curl.MainCommandLineKt")
  }
}

    - name: Cache Gradle Modules
      uses: actions/cache@v5
      with:
        path: |
          ~/.gradle/caches/modules-2/
          ~/.gradle/caches/build-cache-1/
          ~/.gradle/caches/signatures/
          ~/.gradle/caches/keyrings/
        key: ${{ runner.os }}-gradle-cache-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
        if: ${{ matrix.language == 'java' }}

 * versions of the {@link FluentFuture#catching(Class, com.google.common.base.Function)
 * FluentFuture.catching} family of methods. Those versions have slightly different signatures.
 */
abstract class GwtFluentFutureCatchingSpecialization<V extends @Nullable Object>
    extends AbstractFuture<V> {
  /*
   * In the GWT versions of the methods (below), every exceptionType parameter is required to be

    SmbResourceLocator other;

    @Mock
    DfsReferralData referral;

    // Reflection-based API checks ensure the interface contract is as expected
    @Test
    @DisplayName("Type hierarchy and method signatures are correct")
    void typeAndSignatures() throws Exception {
        Class<?> clazz = SmbResourceLocatorInternal.class;

        // Assert it's an interface and extends the right superinterface