def "detects that the build scan plugin has been [applied=#applied]"() {
        given:
        if (applied) {
            applyPlugin()
        }

        settingsFile << """
            println "present: " + services.get($GradleEnterprisePluginManager.name).present
        """

        when:
        succeeds "t"

        then:
        output.contains("present: ${applied}")

        where:

        agentStatusWas(true)
    }

    private void agentWasNotApplied() {
        agentStatusWas(false)
    }

    private void agentStatusWas(boolean applied) {
        assert buildOutput.contains("agent applied = $applied")
    }

    private void withAgentEnabledInProperties() {
        withAgentStatusInProperties(true)
    }

    private void withAgentDisabledInProperties() {

        then:
        plugin.assertAutoApplied(output, true)
        outputContains("${plugin.id} is already applied")
    }

    @ToBeImplemented("https://github.com/gradle/gradle/issues/24884")
    def "is not auto-applied when --scan is used and applied via init script in beforeSettings"() {
        given:
        def pluginArtifactId = "com.gradle:develocity-gradle-plugin:${plugin.runtimeVersion}"

        then:
        agentWasApplied()
    }

    def "agent is not applied if disabled in the command-line"() {
        given:
        withoutAgent()
        withDumpAgentStatusTask()

        when:
        succeeds()

        then:
        agentWasNotApplied()
    }

    def "agent is applied to the daemon process running the build"() {
        given:
        withAgent()

}

/**
 * A list of annotations applied with specified [classId].
 *
 * @see [KaAnnotationList.classIds]
 */
@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("annotations[classId]"))
public fun KaAnnotated.annotationsByClassId(classId: ClassId): List<KaAnnotation> {
    return annotations[classId]
}

/**
 * A list of annotations applied.
 *
 * @see [KaAnnotationList.classIds]
 */

    }

    def "does not render hint for successful build without applied plugin"() {
        given:
        buildFile << """
            task $DUMMY_TASK_NAME
        """

        when:
        succeeds(DUMMY_TASK_NAME)

        then:
        result.assertNotOutput(SCAN)
    }

    def "renders hint for failing build without applied plugin and #description"() {
        given:

        mavenRepo.module("org", "foo", '1.1').publish()
        mavenRepo.module("org", "bar", '1.0').dependsOn(foo11).publish()
    }

    void "force resolution strategy is applied to dependency constraints"() {
        given:
        buildFile << """
            dependencies {
                conf 'org:bar:1.0'
                constraints {
                    conf 'org:foo:1.1'

        BaseBuildScanPluginCheckInFixture getTransitivePluginFixture() {
            // Develocity plugin is auto-applied but the Gradle Enterprise plugin is a transitive dependency
            gradleEnterpriseFixture
        }

        @Override
        void assertNotAutoApplied(String output) {
            // Develocity plugin is applied neither as a transitive dependency, nor via auto-application mechanism as Gradle Enterprise plugin is present

                case ScriptDiscovery.DEFAULT:
                    return new ScriptChangeFixture(rootProjectDir, defaultScriptFile, buildArguments)
                case ScriptDiscovery.APPLIED:
                    String appliedScriptName = "applied${scriptFileExtension}"
                    TestFile appliedScriptFile = new TestFile(defaultScriptFile.parentFile, appliedScriptName)

 * 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.instrumentation.api.types;

public enum BytecodeInterceptorType {

    /**
     * An interceptor that is applied to the bytecode always.
     */
    INSTRUMENTATION(