Predicates.<Entry<K, V>>and(
            multimap.entryPredicate(), Maps.<V>valuePredicateOnEntries(Predicates.in(c))));
  }

  @Override
  public boolean retainAll(Collection<?> c) {
    return Iterables.removeIf(
        multimap.unfiltered().entries(),
        // explicit <Entry<K, V>> is required to build with JDK6
        Predicates.<Entry<K, V>>and(
            multimap.entryPredicate(),

    def "creates snapshot for string"() {
        expect:
        def snapshot = snapshotter.snapshot("abc")
        snapshot instanceof StringValueSnapshot
        snapshot == snapshotter.snapshot("abc")
        snapshot != snapshotter.snapshot("other")
    }

    def "creates snapshot for isolated string"() {
        expect:

     * Creates a dependency scope configuration which can change roles.
     */
    Configuration dependencyScopeUnlocked(String name);

    /**
     * Creates a dependency scope configuration which can change role and executes the provided
     * {@code action} against the configuration.
     */
    Configuration dependencyScopeUnlocked(String name, Action<? super Configuration> action);

    /**

     * the results of the task will not be cached.</p>
     *
     * <p>You may add multiple such predicates. The results of the task are not cached if any of the predicates return {@code false},
     * or if any of the predicates passed to {@link #doNotCacheIf(String, Spec)} returns {@code true}. If {@code cacheIf()} is not specified,

    /**
     * Creates an empty {@link ConfigurableFileCollection} instance.
     */
    ConfigurableFileCollection configurableFiles(String displayName);

    /**
     * Creates an empty {@link ConfigurableFileCollection} instance.
     */
    ConfigurableFileCollection configurableFiles();

    /**
     * Creates a {@link ConfigurableFileTree} instance with no base dir specified.

	}
	for i := 0; i < len(creates) || i < len(expectedCreates); i++ {
		var expected, actual runtime.Object
		if i < len(creates) {
			actual = creates[i].GetObject()
		}
		if i < len(expectedCreates) {
			expected = expectedCreates[i]
		}
		if !apiequality.Semantic.DeepEqual(expected, actual) {

nullValue() - Static method in class org.hamcrest.core.IsNull Creates a matcher that matches if examined object is null. nullValue(Class<T>) - Static method in class org.hamcrest.core.IsNull Creates a matcher that matches if examined object is null. nullValue() - Static method in class org.hamcrest.CoreMatchers Creates a matcher that matches if examined object is null. nullValue(Class<T>) - Static method in class org.hamcrest.CoreMatchers Creates a matcher that matches if examined object is null. O or(Matcher<?...

    public static ArchCondition<JavaClass> callMethodWithName(String ownerName, String methodName) {
        return callMethodWhere(JavaCall.Predicates.target(HasOwner.Predicates.With.<JavaClass>owner(name(ownerName)))
            .and(JavaCall.Predicates.target(name(methodName))))
            .as("call method %s.%s", ensureSimpleName(ownerName), methodName);
    }

    def snapshotter = new DefaultValueSnapshotter([], classLoaderHasher)
    def isolatableFactory = new DefaultIsolatableFactory(classLoaderHasher, managedFactoryRegistry)

    def "creates isolated string"() {
        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof StringValueSnapshot
        isolated.isolate().is(original)
    }

// Creates a ReadVariableOp on a local variable.
Value ReadLocalVariable(Value local_var, OpBuilder builder, Location loc);

// Creates an AssignVariableOp on a local variable.
TF::AssignVariableOp WriteLocalVariable(Value local_var, Value value,
                                        OpBuilder builder, Location loc);

// Adds two values, or creates a logical-or if they are boolean type.