val subprojectRoots = File("../platforms").listFiles(File::isDirectory).plus(File("../subprojects"))
        val subProjectFolders = subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten().filter { dir ->
            // filter out the directories that have only a `build` subdirectory - this usually happens after branch switching
            dir.listFiles { _: File, name: String -> name != "build" }!!.isNotEmpty()
        }

 * under the License.
 */
package org.apache.maven.artifact.resolver.filter;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * Filter to only retain objects in the given scope or better. This implementation allows the accumulation of multiple
 * scopes and their associated implied scopes, so that the user can filter apply a series of implication rules in a

	fieldSelectors := []string{}
	if cfg.FieldSelectors != "" {
		fieldSelectors = append(fieldSelectors, cfg.FieldSelectors)
	}
	// filter out pod events from different nodes
	fieldSelectors = append(fieldSelectors, fmt.Sprintf("spec.nodeName=%v", cfg.NodeName))
	c.pods = kclient.NewFiltered[*corev1.Pod](client, kclient.Filter{
		LabelSelector: cfg.LabelSelectors,
		FieldSelector: strings.Join(fieldSelectors, ","),
	})

                unfiltered.add("zzz");
                unfiltered.add("abc");
                return Collections2.filter(Collections2.filter(unfiltered, LENGTH_1), NOT_YYY_ZZZ);
              }
            })
        .named("Collections2.filter, filtered input")
        .withFeatures(
            CollectionFeature.SUPPORTS_ADD,
            CollectionFeature.SUPPORTS_REMOVE,

	defer ps.RUnlock()
	for _, sub := range ps.subs {
		if sub.types.Contains(Mask(item.Mask())) && (sub.filter == nil || sub.filter(item)) {
			select {
			case sub.ch <- item:
			default:
			}
		}
	}
}

// Subscribe - Adds a subscriber to pubsub system
func (ps *PubSub[T, M]) Subscribe(mask M, subCh chan T, doneCh <-chan struct{}, filter func(entry T) bool) error {
	totalSubs := atomic.AddInt32(&ps.numSubscribers, 1)

                Map.of("_default", List.of("QUERY1")),...

            ArtifactFilter filter)
            throws ArtifactResolutionException, ArtifactNotFoundException {
        return resolveTransitively(
                artifacts,
                originatingArtifact,
                Collections.emptyMap(),
                localRepository,
                remoteRepositories,
                source,
                filter);
    }

 * limitations under the License.
 */

package gradlebuild.binarycompatibility.filters

import gradlebuild.binarycompatibility.metadata.KotlinMetadataQueries
import japicmp.filter.BehaviorFilter
import japicmp.filter.ClassFilter
import japicmp.filter.FieldFilter
import javassist.CtBehavior
import javassist.CtClass
import javassist.CtField

/**
 * Matches Kotlin <code>internal</code> members.
 */

   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is
   * reached, the proxy will attempt to abort the call to the target, and will throw an {@link
   * UncheckedTimeoutException} to the caller.
   *
   * <p>It is important to note that the primary purpose of the proxy object is to return control to

    <modelVersion>4.0.0</modelVersion>

    <groupId>test</groupId>
    <artifactId>test</artifactId>
    <version>0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <my.filter.value>hello</my.filter.value>
    </properties>

    <profiles>
        <profile>
            <id>two-conditions</id>
            <activation>
                <file>
                    <exists>simple.xml</exists>