PropertyTrace.BuildLogic(location.sourceShortDisplayName, location.lineNumber)
        } else {
            locationForCaller(consumer, diagnostics.source)
        }
    }

    private
    fun locationForCaller(consumer: String?, source: UserCodeSource?): PropertyTrace {
        return if (source != null) {
            PropertyTrace.BuildLogic(source.displayName, null)

            // So, disable or fail or whatever based on which execution modes are enabled
            whenThirdPartyAgentPresent()
        } else {
            CachedClasspathTransformer.StandardTransform.BuildLogic
        }
    }

    abstract fun whenThirdPartyAgentPresent(): CachedClasspathTransformer.StandardTransform

            fragments.addAll(message.fragments)
        }
    }
}


sealed class PropertyTrace {

    object Unknown : PropertyTrace()

    object Gradle : PropertyTrace()

    class BuildLogic(
        val source: DisplayName,
        val lineNumber: Int? = null
    ) : PropertyTrace()

    class BuildLogicClass(
        val name: String
    ) : PropertyTrace()

    class Task(

                documentationSection = DocumentationSection.NotYetImplementedTestKitJavaAgent
            )
        )
        return CachedClasspathTransformer.StandardTransform.BuildLogic
    }

                property("kind", "Project")
                comma()
                property("path", trace.path)
            }

            is PropertyTrace.BuildLogic -> {
                property("kind", "BuildLogic")
                comma()
                property("location", trace.source.displayName)
            }

            is PropertyTrace.BuildLogicClass -> {

 */
@ServiceScope(Scope.UserHome.class)
public interface CachedClasspathTransformer {
    enum StandardTransform {
        BuildLogic, None
    }

    /**
     * Transforms a classpath to a classpath with the given transformations applied.
     */
    ClassPath transform(ClassPath classPath, StandardTransform transform);

    /**

            summary.problemCount,
            equalTo(3)
        )
    }

    private
    fun buildLogicProblem(location: String, message: String) = PropertyProblem(
        PropertyTrace.BuildLogic(Describables.of(location), 1),
        StructuredMessage.build { text(message) }
    )

        } finally {
            lock.unlock();
        }
    }

    private FileLock lockBuildLogicQueueFile() {
        return fileLockManager.lock(
            new File(projectCacheDir.getDir(), "noVersion/buildLogic"),
            mode(FileLockManager.LockMode.Exclusive),
            "build logic queue"
        );
    }

        then:
        subprojectDir.file("build.gradle.kts").assertExists()

        and:
        targetDir.file("/buildSrc/src/main/kotlin/buildlogic.kotlin-common-conventions.gradle.kts").assertContents(containsString("junit.jupiter"))

        when:
        run("build")

        then:

        switch (transform) {
            case None:
                return Lazy.locking().of(this::createUninstrumentedPluginRegistry);
            case BuildLogic:
                return Lazy.locking().of(() -> createInstrumentedPluginRegistry(dependencyResolutionServicesFactory));
            default: