def "is deprecated when @Deprecated annotation is attached to class"() {
        def notDeprecated = new ClassMetaData("SomeClass")
        def deprecated = new ClassMetaData("SomeClass")
        deprecated.addAnnotationTypeName(Deprecated.class.name)

        expect:
        !notDeprecated.deprecated
        deprecated.deprecated
    }

    def "is incubating when @Incubating annotation is attached to class"() {

package main

func main() {
L:
	for i := 0; i < 1; i++ {
	L1:
		for {
			break L
		}
		panic("BUG: not reached - break")
		if false {
			goto L1
		}
	}

L2:
	for i := 0; i < 1; i++ {
	L3:
		for {
			continue L2
		}
		panic("BUG: not reached - continue")
		if false {
			goto L3
		}
	}

import org.gradle.api.Action;
import org.gradle.api.Incubating;

/**
 * Marker interface for additional data that can be attached to a {@link Problem}.
 * <p>
 * This is effectively a sealed interface that is used to restrict the types of additional data that can be attached to a problem.
 * The list interfaces supported by the problems API are:
 * <ul>
 *     <li>{@link GeneralData}</li>

  // source represents the volume that should be attached.
  optional VolumeAttachmentSource source = 2;

  // nodeName represents the node that the volume should be attached to.
  optional string nodeName = 3;
}

// VolumeAttachmentStatus is the status of a VolumeAttachment request.
message VolumeAttachmentStatus {
  // attached indicates the volume is successfully attached.

	// a parent is a console process without console is not clearly documented
	// but empirically we observed the new console is created and attached to the
	// subprocess in the default setup.
	//
	// Ensure no new console is attached to the subprocess by setting CREATE_NO_WINDOW.
	//   https://learn.microsoft.com/en-us/windows/console/creation-of-a-console

        // Use Jansi's detection mechanism
        try {
            new WindowsAnsiPrintStream(new PrintStream(new ByteArrayOutputStream()));
            return FallbackConsoleMetaData.ATTACHED;
        } catch (IOException ignore) {
            // Not attached to a console
            return null;
        }
    }

    @Override
    public boolean isConsoleInput() {
        return System.console() != null;
    }

        if (!sources.isEmpty()) {
            assert lib.sourcePath != null: "no sources attached"
            assert lib.sourcePath.endsWith("/${sources.get(0)}")
        }
        if (!javadoc.isEmpty()) {
            assert lib.javadocLocation != null: "no javadoc attached"
            assert lib.javadocLocation.endsWith("/${javadoc.get(0)}!/")
        }
    }

    @Override

    Optional<Path> getPath(Project project);

    /**
     * Returns an immutable collection of attached artifacts for given project.
     */
    @Nonnull
    Collection<Artifact> getAttachedArtifacts(Project project);

    /**
     * Returns project's all artifacts as immutable collection. The list contains all artifacts, even the attached ones,

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * This annotation is attached to an exception class to indicate that it provides contextual information about the
 * exception which might help the user determine what the failed operation was, or where it took place. Generally, this
 * annotation is only attached to exceptions which chain lower-level exceptions.
 */
@Retention(RetentionPolicy.RUNTIME)

package org.gradle.internal.nativeintegration.console;

public interface ConsoleMetaData {
    /**
     * Returns true if the current process' stdout is attached to the console.
     */
    boolean isStdOut();

    /**
     * Returns true if the current process' stderr is attached to the console.
     */
    boolean isStdErr();

    /**
     * <p>Returns the number of columns available in the console.</p>
     *