}

  interface X {}

  interface Y {}

  static class A implements X, Y {}

  static class B implements X, Y {}

  /**
   * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles.
   * That statement compiles only if {@link FluentIterable#concat concat(aIterable, bIterable)}
   * returns a {@link FluentIterable} of elements of an anonymous type whose supertypes are the <a

        } else if (input instanceof List) {
            values = ((List<?>) input).stream().filter(Objects::nonNull).map(Object::toString).toArray(n -> new String[n]);
        } else if (input instanceof String) {
            return input.toString();
        }
        if (values != null) {
            return stream(values).get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining(" ")));
        }

                .filter(StringUtil::isNotBlank)
                .distinct()
                .collect(Collectors.joining("\n")));
        body.virtualHosts = stream(entity.getVirtualHosts())
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).collect(Collectors.joining("\n")));
        return body;
    }

    /**
     * Escapes special characters in a value for use in LDAP search filters.
     * This method escapes characters that have special meaning in LDAP filter expressions
     * to prevent LDAP injection attacks.
     *
     * @param value the value to escape (null is treated as empty string)
     * @return the escaped value safe for use in LDAP search filters

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.resolver.filter;

import java.util.Objects;

/**
 * Filter to only retain objects in the given artifactScope or better.
 *
 */
public class ScopeArtifactFilter extends AbstractScopeArtifactFilter {

    private final String scope;

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

/**
 * Filter based on a resource name
 *
 * @author mbechler
 *
 */
public interface ResourceNameFilter {

    /**
     * Tests whether the specified resource name should be included.
     *

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.smb1;

/**
 * Filter interface for SMB file listings
 */
public interface SmbFileFilter {
    /**
     * Tests whether the specified SMB file should be included in a file list.
     *
     * @param file the SMB file to test for inclusion

)

// Association represents an association operation
type Association struct {
	Association string            // Association name
	Type        AssociationOpType // Operation type
	Conditions  []Expression      // Filter conditions
	Set         []Assignment      // Assignment operations (for Update and Create)
	Values      []interface{}     // Values for Create operation
}

  }

  public void testAccept() {
    File dir = new File("foo");
    FilenameFilter filter = new PatternFilenameFilter("a+");
    assertTrue(filter.accept(dir, "a"));
    assertTrue(filter.accept(dir, "aaaa"));
    assertFalse(filter.accept(dir, "b"));

    // Show that dir is ignored
    assertTrue(filter.accept(null, "a"));
  }

  public void testNulls() throws Exception {

        this.objectFactory = objectFactory;
    }

    @InputFiles
    public FileCollection getResolvedArtifacts() {
        return objectFactory.fileCollection()
            .from(configs.stream().filter(ResolveAllDependencies::canBeResolved).collect(Collectors.toList()));
    }

    @TaskAction
    void resolveAll() {
        // do nothing, dependencies are resolved when snapshotting task inputs
    }