// +optional
  // +listType=atomic
  repeated ContainerImage images = 8;

  // List of attachable volumes in use (mounted) by the node.
  // +optional
  // +listType=atomic
  repeated string volumesInUse = 9;

  // List of volumes that are attached to the node.
  // +optional
  // +listType=atomic
  repeated AttachedVolume volumesAttached = 10;

}


fun prettyPrintLanguageResult(languageResult: LanguageResult<*>, startDepth: Int = 0): String {
    fun StringBuilder.recurse(current: LanguageResult<*>, depth: Int) {
        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)
        fun appendIndented(value: Any) {
            append(indent())
            append(value)
        }
        fun appendNextIndented(value: Any) {
            append(nextIndent())

    public DependencyReportContainer reports(Closure closure) {
        return reports(new ClosureBackedAction<>(closure));
    }

    @Override
    public DependencyReportContainer reports(Action<? super DependencyReportContainer> configureAction) {
        configureAction.execute(reports);
        return reports;
    }

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();

    ): String = buildString {
        fun visitValue(valueNode: ValueNode, indent: Int) {
            append(" ".repeat(indent * 4))
            append(valueFormatter(valueNode))
        }

        fun visitDocumentNode(documentNode: DocumentNode, indent: Int) {
            append(" ".repeat(indent * 4))
            append(nodeFormatter(documentNode))
            when (documentNode) {

// with the following instructions:
//
//	00000000: stop
//	0nnnnnnn: emit n bits copied from the next (n+7)/8 bytes
//	10000000 n c: repeat the previous n bits c times; n, c are varints
//	1nnnnnnn c: repeat the previous n bits c times; c is a varint

// runGCProg returns the number of 1-bit entries written to memory.
func runGCProg(prog, dst *byte) uintptr {
	dstStart := dst

        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating
configurations.compileOnly { extendsFrom(flamegraph) }

repositories {
    googleApisJs()
}

dependencies {
    reports("jquery:jquery.min:3.5.1@js")
    reports("flot:flot:0.8.1:min@js")

    api(project(":base-services"))
    api(project(":core"))

}

// HeaderValuesContainsToken reports whether any string in values
// contains the provided token, ASCII case-insensitively.
func HeaderValuesContainsToken(values []string, token string) bool {
	for _, v := range values {
		if headerValueContainsToken(v, token) {
			return true
		}
	}
	return false
}

// isOWS reports whether b is an optional whitespace byte, as defined

    def events = ProgressEvents.create()

    def "reports no execution reasons for skipped tasks"() {
        given:
        buildFile << """
            task disabledTask {
                enabled = false
            }
        """

        when:
        runBuild('disabledTask')

        then:
        taskSkippedResult(':disabledTask')
    }

}

// IsInterface reports whether t is an interface type.
func IsInterface(t Type) bool {
	_, ok := under(t).(*Interface)
	return ok
}

// isNonTypeParamInterface reports whether t is an interface type but not a type parameter.
func isNonTypeParamInterface(t Type) bool {
	return !isTypeParam(t) && IsInterface(t)
}

// isTypeParam reports whether t is a type parameter.

import org.gradle.util.GradleVersion

@TargetGradleVersion('>=5.1')
class TaskOriginCrossVersionSpec extends ToolingApiSpecification {

    def events = ProgressEvents.create()

    def "reports task origin for script plugins"() {
        given:
        file("script.gradle") << """
            task b { dependsOn('a') }
        """
        buildFile << """
            apply from: 'script.gradle'