*/
class BridgeForBytecodeUpgradeAdapterClassFilter implements ClassFilter {

    private static final BRIDGE_CLASS_PREFIX = "\$\$BridgeFor\$\$"

    @Override
    boolean matches(CtClass ctClass) {
        return ctClass.name.contains(BRIDGE_CLASS_PREFIX) && ctClass.hasAnnotation(Generated.class)
    }

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

import org.apache.maven.artifact.Artifact;

/**
 */
public interface ArtifactFilter {
    boolean include(Artifact artifact);

            System.err.println("Unable determine version from JAR file: " + e.getMessage());
        }

        return properties;
    }

    public static void showError(Logger logger, String message, Throwable e, boolean showStackTrace) {
        if (logger == null) {
            System.err.println(message);
            if (showStackTrace && e != null) {
                e.printStackTrace(System.err);
            }

            }

            @Override
            public String getCoordinatesString() {
                return coordinatesString;
            }

            @Override
            public boolean equals(Object o) {
                return o instanceof DefaultArtifactFactoryRequestArtifact that
                        && Objects.equals(groupId, that.groupId)

        public void onEndJavadocTag(String name) {
            onInlineContent();
            visitor.onEndJavadocTag(name);
        }

        @Override
        public void onText(String text) {
            boolean ws = text.matches("\\s*");
            if (!ws) {
                onInlineContent();
                visitor.onText(text);
            } else if (!elementStack.isEmpty() && !blockContent.contains(elementStack.getFirst())) {

            String key = ArtifactUtils.key(project.getGroupId(), project.getArtifactId(), project.getVersion());
            projectKeys.add(key);
        }
        return projectKeys;
    }

    public boolean isEmpty() {
        return items.isEmpty();
    }

    /**
     * @return a set of all the projects managed by the build
     */
    public Set<MavenProject> getProjects() {

        "Check_GradleceptionWithGroovy4",
        "CompileAllBuild_BuildCacheNG",
        "CompileAllBuild_NGRemote"
    ) || isBuildCommitDistribution

val Project.isBuildCommitDistribution: Boolean
    get() = providers.gradleProperty("buildCommitDistribution").map { it.toBoolean() }.orElse(false).get()

        void shouldDetermineApplicabilityBasedOnOptions(
                Boolean all, String model, boolean expectedApplicable, String description) {
            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptions(all, null, null, null, model));

            boolean isApplicable = strategy.isApplicable(context);

            assertEquals(expectedApplicable, isApplicable, description);

        } finally {
            Thread.currentThread().setContextClassLoader(originalClassLoader);
        }
    }

    private void persistResumptionData(MavenExecutionResult result, MavenSession session) {
        boolean hasLifecycleExecutionExceptions =
                result.getExceptions().stream().anyMatch(LifecycleExecutionException.class::isInstance);

        if (hasLifecycleExecutionExceptions) {

        is JApiField -> this.getjApiClass()
        is JApiBehavior -> this.getjApiClass()
        else -> error("Unsupported japicmp member type '${this::class}'")
    }


internal
val JApiClass.isKotlin: Boolean
    get() = newClass.orElse(null)?.isKotlin ?: false


internal
val JApiClass.simpleName: String
    get() = fullyQualifiedName.substringAfterLast(".")


internal
val JApiClass.packagePath: String