}
        }

        gradlePluginPortal()
    }
}

plugins {
    id("com.gradle.develocity").version("4.3") // Run `java build-logic-settings/UpdateDevelocityPluginVersion.java <new-version>` to update
    id("io.github.gradle.develocity-conventions-plugin").version("0.12.1")
    id("org.gradle.toolchains.foojay-resolver-convention").version("1.0.0")
}

include("build-environment")

/**
 * Source of {@link LongAddable} objects that deals with GWT and all that.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class LongAddables {
  public static LongAddable create() {
    return new JavaUtilConcurrentLongAdder();
  }

  private static final class JavaUtilConcurrentLongAdder extends LongAdder implements LongAddable {}

  private LongAddables() {}

    testEncodesWithOffset(base64(), "foobar", 4, 0, "");
  }

  public void testBase64Url() {
    testDecodesByBytes(base64Url(), "_zzz", new byte[] {-1, 60, -13});
    testDecodesByBytes(base64Url(), "-zzz", new byte[] {-5, 60, -13});
  }

  public void testBase64UrlInvalidDecodings() {
    assertFailsToDecode(base64Url(), "+zzz", "Unrecognized character: +");

        final ClassificationMeta onMainSchema = findOnMainSchema(classificationName);
        if (onMainSchema == null) {
            final String msg = "Not found the classification: " + classificationName;
            throw new ProvidedClassificationNotFoundException(msg);
        }
        return onMainSchema;
    }

    protected ClassificationMeta findOnMainSchema(final String classificationName) throws ProvidedClassificationNotFoundException {

 *
 * This is a generic response message for SMB commands that don't
 * return specific data in their response.
 */
public class SmbComBlankResponse extends ServerMessageBlock {

    /**
     * Creates a new blank SMB1 response.
     *
     * @param config the CIFS configuration
     */
    public SmbComBlankResponse(final Configuration config) {
        super(config);
    }

    @Override

    private static final long serialVersionUID = 1L;

    /** The action class that requires specific user roles */
    private final Class<? extends RootAction> actionClass;

    /**
     * Constructs a new UserRoleLoginException with the specified action class.
     *
     * @param actionClass the action class that requires specific user roles
     */
    public UserRoleLoginException(final Class<? extends RootAction> actionClass) {

 * a handle to a specific domain in the Security Account Manager.
 */
public class MsrpcSamrOpenDomain extends samr.SamrOpenDomain {

    /**
     * Creates a new request to open a domain handle.
     *
     * @param handle the SAM policy handle
     * @param access the desired access rights
     * @param sid the security identifier of the domain

                logger.debug("BoostQuery: query={}, boost={}", query, boost);
            }
            return getQueryProcessor().execute(context, boostQuery.getQuery(), boostQuery.getBoost());
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    VERSION_1(0x00010001),

    /**
     * Witness Protocol Version 2 - Windows Server 2012 R2 and later
     */
    VERSION_2(0x00020000);

    private final int version;

    /**
     * Creates a new WitnessVersion with the specified version value.
     *
     * @param version the numeric version value
     */
    WitnessVersion(int version) {
        this.version = version;
    }

    /**

 */
@GwtIncompatible(value = "untested")
@NullUnmarked
public class MultimapsFilterEntriesAsMapTest extends AbstractMultimapAsMapImplementsMapTest {
  private static final Predicate<Entry<String, Integer>> PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !Objects.equals(entry.getKey(), "badkey") && entry.getValue() != 55556;
        }
      };