import okio.DeflaterSink

private val EMPTY_DEFLATE_BLOCK = "000000ffff".decodeHex()
private const val LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION = 4

class MessageDeflater(
  private val noContextTakeover: Boolean,
) : Closeable {
  private val deflatedBytes = Buffer()

  private val deflater =
    Deflater(
      Deflater.DEFAULT_COMPRESSION,
      // nowrap (omits zlib header):
      true,
    )

     */
    public static boolean isAbstract(final Method method) {
        return Modifier.isAbstract(method.getModifiers());
    }

    /**
     * <code>public</code>かどうかを返します。
     *
     * @param method
     *            メソッド。{@literal null}であってはいけません
     * @return <code>public</code>なら{@literal true}
     */
    public static boolean isPublic(final Method method) {

  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V replace(K key, V value) {
    return delegate().replace(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean replace(K key, V oldValue, V newValue) {

    // We're relying on callers to call this method only with an edge that's in the graph.
    return requireNonNull(incidentEdgeMap.get(edge));
  }

  @Override
  @CheckForNull
  public N removeInEdge(E edge, boolean isSelfLoop) {
    if (!isSelfLoop) {
      return removeOutEdge(edge);
    }
    return null;
  }

  @Override
  public N removeOutEdge(E edge) {
    N previousNode = incidentEdgeMap.remove(edge);

/**
 * @deprecated use {@link org.apache.maven.api.services.model.RootLocator} instead
 */
@Named
@Deprecated(since = "4.0.0")
public class DefaultRootLocator implements RootLocator {

    public boolean isRootDirectory(Path dir) {
        if (Files.isDirectory(dir.resolve(".mvn"))) {
            return true;
        }
        // we're too early to use the modelProcessor ...
        Path pom = dir.resolve("pom.xml");

     * @throws CIFSException
     */
    public static List<AvPair> decode ( byte[] data ) throws CIFSException {
        List<AvPair> pairs = new LinkedList<>();
        int pos = 0;
        boolean foundEnd = false;
        while ( pos + 4 <= data.length ) {
            int avId = SMBUtil.readInt2(data, pos);
            int avLen = SMBUtil.readInt2(data, pos + 2);
            pos += 4;

   *       predicate.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.

    val isTeamCity = "TEAMCITY_VERSION" in System.getenv()
    val isTeamCityParallelTestsEnabled
        get() = "TEAMCITY_PARALLEL_TESTS_ENABLED" in System.getenv()
    val isCodeQl: Boolean by lazy {
        // This logic is kept here instead of `codeql-analysis.init.gradle` because that file will hopefully be removed in the future.

        _ * classMetaData.imports >> ['java.util.*']
    }

    def resolvesPrimitiveType() {
        when:
        def name = typeNameResolver.resolve('boolean', classMetaData)

        then:
        name == 'boolean'
    }

    def resolvesParameterisedTypes() {
        def typeMetaData = type('SomeClass')
        typeMetaData.addTypeArg(type('String'))

        when:

    protected boolean useRobotsTxtDisallows = true;

    protected boolean useRobotsTxtAllows = true;

    protected CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

    protected AuthCache authCache = new BasicAuthCache();

    protected HttpRoutePlanner routePlanner;

    protected boolean redirectsEnabled = false;