}

    @Override
    public boolean removeAll(Collection<?> collection) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeAll(collection);
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.isEmpty();
    }

    @Override
    public boolean contains(Object object) {

    private Map managedVersionMap;

    /** result type - flat list; the default */
    private boolean asList = true;

    /** result type - dirty tree */
    private boolean asDirtyTree = false;

    /** result type - resolved tree */
    private boolean asResolvedTree = false;

    /** result type - graph */
    private boolean asGraph = false;

    public MetadataResolutionRequest() {}

    /**  By default, the Mojo is inherited */
    private boolean inheritedByDefault = true;

    /**  By default, the Mojo cannot be invoked directly */
    private boolean directInvocationOnly = false;

    /**  By default, the Mojo don't need reports to run */
    private boolean requiresReports = false;

    /**
     * By default, mojos are not threadsafe
     * @since 3.0-beta-2

    underlying.put("b", "");

    Map<String, Boolean> map =
        transformValues(
            underlying,
            new Function<@Nullable String, Boolean>() {
              @Override
              public Boolean apply(@Nullable String from) {
                return from == null;
              }
            });
    Map<String, Boolean> expected = ImmutableMap.of("a", true, "b", false);

public static SelectorUtils getInstance(); public static boolean matchPatternStart(String, String); public static boolean matchPatternStart(String, String, boolean); public static boolean matchPath(String, String); public static boolean matchPath(String, String, boolean); public static boolean match(String, String); public static boolean match(String, String, boolean); public static java.util.Vector tokenizePath(String); public static boolean isOutOfDate(java.io.File, java.io.File, int); public static...

   * address.
   */
  private fun routeMatchesAny(candidates: List<Route>): Boolean =
    candidates.any {
      it.proxy.type() == Proxy.Type.DIRECT &&
        route.proxy.type() == Proxy.Type.DIRECT &&
        route.socketAddress == it.socketAddress
    }

  private fun supportsUrl(url: HttpUrl): Boolean {
    assertLockHeld()

    val routeUrl = route.address.url

    underlying.put("b", "");

    Map<@Nullable String, Boolean> map =
        transformValues(
            underlying,
            new Function<@Nullable String, Boolean>() {
              @Override
              public Boolean apply(@Nullable String from) {
                return from == null;
              }
            });
    Map<String, Boolean> expected = ImmutableMap.of("a", true, "b", false);

        hasAttribute(ctMethod, AttributePredicate.functionAttribute(KmFunction::isInfix))

    private
    fun hasAttribute(ctClass: CtClass, predicate: AttributePredicate): Boolean =
        queryKotlinMetadata(ctClass) { metadata ->
            metadata.hasAttribute(MemberType.TYPE, ctClass.name, predicate)
        }

    private
    fun hasAttribute(ctMember: CtMember, predicate: AttributePredicate): Boolean =

        this.nodeType = nodeType;
    }

    NbtAddress(final Name hostName, final int address, final boolean groupName, final int nodeType, final boolean isBeingDeleted,
            final boolean isInConflict, final boolean isActive, final boolean isPermanent, final byte[] macAddress) {

        /* The NodeStatusResponse.readNodeNameArray method may also set this

    /**
     * Checks if the given URL uses a valid web protocol.
     *
     * @param url the URL to validate
     * @return true if the URL starts with a supported web protocol, false otherwise
     */
    public boolean isValidWebProtocol(final String url) {
        return stream(webProtocols).get(stream -> stream.anyMatch(s -> url.startsWith(s)));
    }

    /**
     * Checks if the given URL uses a valid file protocol.
     *