return false
        }
    }

    public companion object {
        public operator fun invoke(predicate: KaSession.(type: KaType, symbol: KaClassOrObjectSymbol) -> Boolean): KaSuperTypesFilter {
            return KaSuperTypesFilter { analysisSession, superType, symbol -> predicate(analysisSession, superType, symbol) }
        }
    }
}

 * limitations under the License.
 */

package org.gradle.cache.internal


import java.util.concurrent.ConcurrentHashMap
import java.util.function.Function
import java.util.function.Predicate

class TestCrossBuildInMemoryCacheFactory implements CrossBuildInMemoryCacheFactory {
    private final static CrossBuildInMemoryCacheFactory INSTANCE = new TestCrossBuildInMemoryCacheFactory()

import org.gradle.api.specs.Spec;
import org.gradle.internal.Cast;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A {@link org.gradle.api.internal.tasks.TaskExecuter} which skips tasks whose onlyIf predicate evaluates to false
 */
public class SkipOnlyIfTaskExecuter implements TaskExecuter {
    private static final Logger LOGGER = LoggerFactory.getLogger(SkipOnlyIfTaskExecuter.class);
    private final TaskExecuter executer;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLParameters;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Arrays;
import java.util.function.Predicate;

/**
 * An HTTPS server fixture for tests.
 *
 * Unless you really need HTTPS, you should use a plain {@link BlockingHttpServer}.
 */
public class BlockingHttpsServer extends BlockingHttpServer {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.file;

import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Lists;
import groovy.lang.Closure;
import org.gradle.api.file.DirectoryTree;
import org.gradle.api.tasks.AntBuilderAware;

                    projectsInRequestScope.add(requestPomProject);

                    Predicate<ProjectBuildingResult> projectsOutsideOfRequestScope =
                            pr -> !projectsInRequestScope.contains(pr.getProject());

                    Predicate<Exception> pluginArtifactNotFoundException = exc -> exc instanceof PluginManagerException

        public operator fun invoke(
            predicate: KaSession.(modifier: KtKeywordToken, annotated: KaAnnotated) -> Boolean
        ): KaRendererKeywordFilter =
            object : KaRendererKeywordFilter {
                override fun filter(analysisSession: KaSession, modifier: KtKeywordToken, annotated: KaAnnotated): Boolean {
                    return predicate(analysisSession, modifier, annotated)
                }

    throw new UnsupportedOperationException();
  }

  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  public final boolean removeIf(Predicate<? super E> predicate) {
    throw new UnsupportedOperationException();
  }

  public final boolean retainAll(Collection<?> elementsToKeep) {
    throw new UnsupportedOperationException();
  }

  public final void clear() {

    public companion object {
        public operator fun invoke(
            predicate: KaSession.(annotation: KaAnnotation, owner: KaAnnotated) -> Boolean
        ): KaRendererAnnotationsFilter = object : KaRendererAnnotationsFilter {
            override fun filter(analysisSession: KaSession, annotation: KaAnnotation, owner: KaAnnotated): Boolean {
                return predicate(analysisSession, annotation, owner)
            }
        }
    }
}

import me.lucko.jarrelocator.JarRelocator
import me.lucko.jarrelocator.Relocation
import java.util.function.Predicate
import java.util.jar.JarFile
import java.util.stream.Collectors

import org.gradle.api.artifacts.transform.TransformParameters

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath("me.lucko:jar-relocator:1.3")
    }
}

// tag::artifact-transform-relocate[]