}
	absPath := filePath
	// os.(*File).Chdir is emulated by setting the working directory to the
	// absolute path that this file was opened at, which is why we have to
	// resolve and capture it here.
	if filePath[0] != '/' {
		wd, err := syscall.Getwd()
		if err != nil {
			return -1, poll.SysFile{}, err
		}
		absPath = joinPath(wd, filePath)
	}
	fd, err := syscall.Open(absPath, flag, perm)

/**
 * Returns every property backing field for which a corresponding convention mapping flag field also exists.
 *
 * The convention mapping flag field is a Boolean field injected by [AsmBackedClassGenerator] in order to capture
 * whether a convention mapped property has been explicitly set or not.
 */
private
fun conventionAwareFieldsOf(beanType: Class<*>): Sequence<Pair<Field, Field>> =
    ClassInspector.inspect(beanType).let { details ->

	OutboundPorts             = "istio-outbound-ports"
	LocalOutboundPortsExclude = "istio-local-outbound-ports-exclude"
	EnvoyPort                 = "envoy-port"
	InboundCapturePort        = "inbound-capture-port"
	InboundTunnelPort         = "inbound-tunnel-port"
	ProxyUID                  = "proxy-uid"
	ProxyGID                  = "proxy-gid"
	KubeVirtInterfaces        = "kube-virt-interfaces"

limitations under the License.
*/

package types

// UID is a type that holds unique ID values, including UUIDs.  Because we
// don't ONLY use UUIDs, this is an alias to string.  Being a type captures
// intent and helps make sure that UIDs and names do not get conflated.

type Event int

const (
	// EventAdd is sent when an object is added
	EventAdd Event = iota

	// EventUpdate is sent when an object is modified
	// Captures the modified object
	EventUpdate

	// EventDelete is sent when an object is deleted
	// Captures the object at the last known state
	EventDelete
)

func (event Event) String() string {
	out := "unknown"
	switch event {
	case EventAdd:

                reports.junitXml.outputPerTestCase = true
                onOutput { test, event -> print "\$test -> \$event.message" }
            }
        """
    }

    @Issue("GRADLE-2841")
    def "captures output from logging frameworks"() {
        buildFile << """
            dependencies { implementation "org.slf4j:slf4j-simple:1.7.10", "org.slf4j:slf4j-api:1.7.10" }
"""
        file("src/test/java/FooTest.java") << """

import org.gradle.internal.fingerprint.FileCollectionFingerprint;
import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

/**
 * Captures the state of the inputs of a {@link org.gradle.internal.execution.UnitOfWork}.
 */
public interface ExecutionInputState {
    /**
     * The main implementation snapshots.
     */

                }
            }
        """

        file('build.gradle') << """
            apply plugin: MultipleUserInputPlugin

            task $DUMMY_TASK_NAME
        """
    }

    def "can capture multiple user input if standard input was provided"() {
        when:
        withConnection { ProjectConnection connection ->
            runBuildWithStandardInput(connection, 'something one', 'something two')
        }

	dataUsageInfo, err := c.dataUsageInfo.Get()
	if err != nil {
		metricsLogIf(ctx, err)
		return nil
	}

	// data usage has not captured any data yet.
	if dataUsageInfo.LastUpdate.IsZero() {
		return nil
	}

	var (
		clusterSize               uint64
		clusterBuckets            uint64
		clusterObjectsCount       uint64

        when:
        featureCheck.verify()

        then:
        Throwable t = thrown(UnsupportedFeatureException)
        t.message == "The version of Gradle you are using ($UNSUPPORTED_GRADLE_VERSION.version) does not capture build output in debug mode with the GradleRunner. Support for this is available in Gradle $TestKitFeature.CAPTURE_BUILD_RESULT_OUTPUT_IN_DEBUG.since.version and all later versions."
    }