/**
 * A {@link TaskExecutionListener} adapter class for receiving task execution events.
 *
 * The methods in this class are empty. This class exists as convenience for creating listener objects.
 */
@SuppressWarnings("deprecation")
public class TaskExecutionAdapter implements TaskExecutionListener {

    @Override
    public void beforeExecute(Task task) {}

    @Override
    public void afterExecute(Task task, TaskState state) {}

    }

    def "emits deprecation warning when convention mapping is used with Provider"() {
        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Inject abstract ProviderFactory getProviderFactory()

                problems.forNamespace("org.example.plugin").reporting {
                    it.${targetVersion < GradleVersion.version("8.8") ? 'label("The \'standard-plugin\' is deprecated").category("deprecation", "plugin")' : 'id("adhoc-deprecation", "The \'standard-plugin\' is deprecated")' }
                        .severity(Severity.WARNING)
                        .solution("Please use 'standard-plugin-2' instead of this plugin")

        then:
        thrown(BuildException)
        listener.problems.size() == 0
    }

    def "Problems expose summary Tooling API events"() {
        given:
        withMultipleProblems("id(\"deprecation\", \"The 'standard-plugin' is deprecated\")")

        when:
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')

import org.gradle.api.tasks.testing.Test;
import org.gradle.internal.Cast;
import org.gradle.internal.artifacts.configurations.AbstractRoleBasedConfigurationCreationRequest;
import org.gradle.internal.deprecation.DeprecatableConfiguration;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.internal.jvm.JavaModuleDetector;
import org.gradle.jvm.tasks.Jar;
import org.gradle.jvm.toolchain.JavaToolchainService;

        return UsageDescriber.describeRole(this);
    }

    /**
     * Checks that the current allowed usage of a configuration is the same as that specified by this role.
     *
     * Does not check deprecation status.
     *
     * @param configuration the configuration to check
     * @return {@code true} if so; {@code false} otherwise
     */
    default boolean isUsageConsistentWithRole(Configuration configuration) {

import java.io.File;
import java.util.Set;

/**
 * A {@code FileCollectionDependency} is a {@link Dependency} on a collection of local files which are not stored in a
 * repository.
 */
@SuppressWarnings("deprecation") // Because of SelfResolvingDependency
public interface FileCollectionDependency extends SelfResolvingDependency {
    /**
     * Returns the files attached to this dependency.
     *
     * @since 3.3
     */

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.deprecation;

import org.gradle.api.problems.internal.DocLink;

import javax.annotation.Nullable;

class DeprecationMessage {

    private final String summary;
    private final String removalDetails;

// CheckDeprecation returns "", nil if there is no deprecation message.
func CheckDeprecation(ctx context.Context, m module.Version) (deprecation string, err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("loading deprecation for %s: %w", m.Path, err)
		}
	}()

	if m.Version == "" {
		// Main module, standard library, or file replacement module.
		// Don't look up deprecation.
		return "", nil
	}

 *
 * Note: Temporarily non-{@code final}, so long as {@link org.gradle.internal.component.AmbiguousVariantSelectionException} is not yet removed.
 */
@SuppressWarnings("deprecation")
public class ArtifactVariantSelectionException extends AbstractResolutionFailureException {
    public ArtifactVariantSelectionException(String message, ResolutionFailure failure, List<String> resolutions) {