buildFile << """
            @Managed interface CustomManagedLSS extends LanguageSourceSet {}
            @Managed interface CustomManagedLSSInternal extends CustomManagedLSS {
                String getInternal()
                void setInternal(String internal)
            }
            class CustomManagedLSSPlugin extends RuleSource {
                @ComponentType

		if v.Disabled {
			continue
		}
		allKeys.Insert(k)
	}
	for k := range tmm {
		allKeys.Insert(k)
	}

	rotationInterval := getInterval(features.MetricRotationInterval, defaultMetricRotationInterval)
	gracefulDeletionInterval := getInterval(features.MetricGracefulDeletionInterval, defaultMetricGracefulDeletionInterval)

	m := make([]telemetryFilterConfig, 0, allKeys.Len())

    @get:Classpath
    val runtimeClassPathFiles: FileCollection
        get() = runtimeClassPathArtifactCollection.get().artifactFiles

    /**
     * Tracked via [runtimeClassPathFiles].
     */
    @get:Internal
    internal
    abstract val runtimeClassPathArtifactCollection: Property<ArtifactCollection>

    @get:OutputDirectory
    abstract val metadataOutputDir: DirectoryProperty

    @get:InputDirectory

            }

            class MyObject(val value: String) {
                override fun toString(): String = value
            }

            abstract class MyTask: DefaultTask() {
                @get:Internal
                $inputDeclaration

                @TaskAction
                fun run() {
                    when (val anyInput = input as Any?) {

        withBuildScript(
            """
            import org.gradle.api.*
            import org.gradle.api.tasks.*

            abstract class PrintInputToFile : DefaultTask() {
                @get:Internal
                abstract val inputSource: Property<String>
                @get:Input
                val input = { inputSource.get() }
                @get:OutputFile

			input:      1 * time.Second,
			defaultVal: 0,
			expected:   durationpb.New(1 * time.Second),
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			actual := getInterval(tc.input, tc.defaultVal)
			assert.Equal(t, tc.expected, actual)
		})
	}
}

func Test_appendApplicableTelemetries(t *testing.T) {
	namespacedName := types.NamespacedName{