.entries
            .filter { "UNKNOWN" != it.key }
            .filter { model.subprojects.getSubprojectByName(it.key) != null }
            .map { SubprojectTestClassTime(model.subprojects.getSubprojectByName(it.key)!!, it.value.filter { it.testClassAndSourceSet.sourceSet != "test" }) }
            .sortedBy { -it.totalTime }
            .filter { onlyNativeSubprojectsForIntelMacs(testCoverage, it.subProject.name) }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.filter;

/**
 * UrlFilter checks if a given url is a target one.
 *
 * @author shinsuke
 *
 */
public interface UrlFilter {

    /**
     * Initialize a url filter by sessionId.
     *
     * @param sessionId Session ID
     */
    void init(String sessionId);

    /**

                .filter {
                    it.gradleVersion() > latestFinalRelease.gradleVersion()
                }.maxByOrNull { it.buildTimeStamp() }
                ?: latestFinalRelease
        val previousVersions = (listOf(latestRelease) + releasedVersions.finalReleases)
            .filter {
                it.gradleVersion() >= lowestInterestingVersion &&

import okhttp3.internal.connection.RealCall

/**
 * A concrete interceptor chain that carries the entire interceptor chain: all application
 * interceptors, the OkHttp core, all network interceptors, and finally the network caller.
 *
 * If the chain is for an application interceptor then [exchange] must be null. Otherwise it is for
 * a network interceptor and [exchange] must be non-null.
 */
class RealInterceptorChain(

                node.disable();
            }
        }
    }

    public boolean filterTrail(ArtifactFilter filter) throws OverConstrainedVersionException {
        boolean success = true;
        if (filter != null) {
            for (Artifact artifact : getTrail()) {
                if (!filter.include(artifact)) {
                    success = false;
                }
            }
        }

	hosts, local := eps.GridHosts()
	lookupHost := globalDNSCache.LookupHost
	g, err := grid.NewManager(ctx, grid.ManagerOptions{
		// Pass Dialer for websocket grid, make sure we do not
		// provide any DriveOPTimeout() function, as that is not
		// useful over persistent connections.
		Dialer: grid.ConnectWS(

            testTask.filter.isFailOnNoMatchingTests = false
            val classesForSourceSet = includeTestClasses[sourceSetName]
            if (classesForSourceSet == null) {
                // No classes included, disable
                testTask.enabled = false
            } else {
                testTask.filter.includePatterns.addAll(classesForSourceSet)
            }
        }

        if (crawlerContext.getMaxDepth() >= 0 && depth > crawlerContext.getMaxDepth()) {
            return;
        }

        // add url and filter
        final Set<String> urlSet = new HashSet<>();
        final List<UrlQueue<?>> childList = childUrlList.stream().filter(d -> StringUtil.isNotBlank(d.getUrl())
                && urlSet.add(d.getUrl() + "\n" + d.getMetaData()) && crawlerContext.urlFilter.match(d.getUrl())).map(d -> {

        assertEquals(BoolQueryBuilder.class, queryBuilder.getClass());

        called.set(false);
        final AtomicBoolean calledFirst = new AtomicBoolean(false);
        queryProcessor.addFilter(new QueryProcessor.Filter() {
            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost, FilterChain chain) {
                calledFirst.set(true);
                assertFalse(called.get());

// NewInternodeDialContext setups a custom dialer for internode communication
func NewInternodeDialContext(dialTimeout time.Duration, opts TCPOptions) DialContext {
	return func(ctx context.Context, network, addr string) (net.Conn, error) {
		dialer := &net.Dialer{
			Timeout: dialTimeout,
			Control: setTCPParametersFn(opts),
		}
		conn, err := dialer.DialContext(ctx, network, addr)
		if err != nil {