.forEach(m -> pluginValidationManager.reportPluginMojoValidationIssue(
                        PluginValidationManager.IssueLocality.EXTERNAL, mavenSession, mojoDescriptor, mojoClass, m));
    }

    private boolean isDeprecated(Parameter parameter) {
        return Objects.equals(
                        org.apache.maven.artifact.repository.ArtifactRepository.class.getName(), parameter.getType())

    val isTeamCity = "TEAMCITY_VERSION" in System.getenv()
    val isTeamCityParallelTestsEnabled
        get() = "TEAMCITY_PARALLEL_TESTS_ENABLED" in System.getenv()
    val isCodeQl: Boolean by lazy {
        // This logic is kept here instead of `codeql-analysis.init.gradle` because that file will hopefully be removed in the future.

        _ * classMetaData.imports >> ['java.util.*']
    }

    def resolvesPrimitiveType() {
        when:
        def name = typeNameResolver.resolve('boolean', classMetaData)

        then:
        name == 'boolean'
    }

    def resolvesParameterisedTypes() {
        def typeMetaData = type('SomeClass')
        typeMetaData.addTypeArg(type('String'))

        when:

            Collections.synchronizedMap(new LinkedHashMap<TransferResourceIdentifier, TransferResourceAndSize>());

    private final boolean printResourceNames;
    private int lastLength;

    public ConsoleMavenTransferListener(PrintStream out, boolean printResourceNames) {
        super(out);
        this.printResourceNames = printResourceNames;
    }

    @Override

                        .build());

                StringBuilder message = new StringBuilder("Messages [");
                boolean test = true;
                for (int i = 0; i < 999; i++) {
                    boolean ok = output.containsKey("Progress (1): test-resource (" + i + "/999 B)");
                    if (!ok) {
                        System.out.println("false : " + i);

        return model;
    }

    public final void addProvideToken(String type, RequirementMatcher matcher) {
        provides.put(type, matcher);
    }

    @Override
    public boolean matchesRequirements(Map<String, String> requirements) {
        for (Map.Entry<String, String> requirement : requirements.entrySet()) {
            String key = requirement.getKey();

        return createArtifact(id, version, scope, null, false);
    }

    protected Artifact createArtifact(String id, String version, String scope, String inheritedScope, boolean optional)
            throws InvalidVersionSpecificationException {
        VersionRange versionRange = VersionRange.createFromVersionSpec(version);

        return artifactFactory.createDependencyArtifact(

            @Nullable
            @Override
            public List<RemoteRepository> getRepositories() {
                return repositories;
            }

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

    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val mainSources: ConfigurableFileCollection

    @get:Input
    abstract val generateAutoTestedSamplesTest: Property<Boolean>

    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    init {
        outputDir.convention(project.layout.buildDirectory.dir("generated/sources/autoTested/groovy"))
    }

    @Test
    void testDeployBuildPomWithBooleanValue() {
        // Test that build POM deployment works with Boolean values (not just strings)
        ConsumerPomArtifactTransformer transformer = new ConsumerPomArtifactTransformer((s, p, f) -> null);

        Map<String, Object> configProps = Map.of(Constants.MAVEN_DEPLOY_BUILD_POM, Boolean.FALSE);
        RepositorySystemSession session = createMockSession(configProps);