*/

package org.gradle.internal.featurelifecycle;

/**
 * An immutable description of the usage of a deprecated feature.
 */
public abstract class FeatureUsage {
    private final String summary;
    private final Class<?> calledFrom;

    protected FeatureUsage(String summary, Class<?> calledFrom) {
        this.summary = summary;
        this.calledFrom = calledFrom;
    }

    /**

    public final DeprecatedFeatureUsage featureUsage;
    private final ProblemDiagnostics diagnostics;

    public DefaultDeprecatedUsageProgressDetails(DeprecatedFeatureUsage featureUsage, ProblemDiagnostics diagnostics) {
        this.featureUsage = featureUsage;
        this.diagnostics = diagnostics;
    }

    @Override
    public String getSummary() {
        return featureUsage.getSummary();
    }

    @Override

    def "formats messages"() {
        given:
        def featureUsage = new DeprecatedFeatureUsage(summary, removalDetails, advice, contextualAdvice, documentationReference, DeprecatedFeatureUsage.Type.USER_CODE_DIRECT, "id display name", "id", getClass())

        expect:
        featureUsage.formattedMessage() == expected

        where:

 */
class SimulatedGroovyCallLocation {
    static FeatureUsage create() {
        return SimulatedSingleMessageLogger.nagUserWith(SimulatedSingleMessageLogger.DIRECT_CALL)
    }

    static FeatureUsage indirectly() {
        return SimulatedSingleMessageLogger.indirectly(SimulatedSingleMessageLogger.INDIRECT_CALL)
    }

    static FeatureUsage indirectly2() {

                                type = in.nextString();
                                break;
                            }
                            case "featureUsage": {
                                featureUsage = in.nextString();
                                break;
                            }
                            case "pluginId": {
                                pluginId = in.nextString();

            DeprecatedFeatureUsage featureUsage = deprecationMessage.toDeprecatedFeatureUsage(calledFrom);
            nagUserWith(featureUsage);

            if (!featureUsage.formattedMessage().contains("deprecated")) {
                throw new RuntimeException("Deprecation message does not contain the word 'deprecated'. Message: \n" + featureUsage.formattedMessage());
            }
        }
    }

 */

package org.gradle.internal.featurelifecycle;

/**
 * Notified when a deprecated feature is used.
 *
 * <p>Implementations need not be thread-safe.
 */
public interface FeatureHandler<T extends FeatureUsage> {
    void featureUsed(T usage);

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

package org.gradle.internal.featurelifecycle;

public class IncubatingFeatureUsage extends FeatureUsage {
    public IncubatingFeatureUsage(String summary, Class<?> calledFrom) {
        super(summary, calledFrom);
    }

    }

    public static TestFeatureUsage nagUserWith(String message) {
        return new TestFeatureUsage(message, SimulatedSingleMessageLogger.class);
    }

    static class TestFeatureUsage extends FeatureUsage {
        public final Exception exception = new Exception();

        public TestFeatureUsage(String summary, Class<?> calledFrom) {
            super(summary, calledFrom);
        }
    }

import org.gradle.api.problems.internal.DeprecationData;
import org.gradle.api.problems.internal.DocLink;
import org.gradle.internal.featurelifecycle.FeatureUsage;

import javax.annotation.Nullable;

import static org.apache.commons.lang.StringUtils.isNotEmpty;

public class DeprecatedFeatureUsage extends FeatureUsage {

    private final String removalDetails;
    private final String advice;
    private final String contextualAdvice;