Otherwise they're just normal programs.

## Trace debug commands

The `cmd` directory contains helpful tools for debugging traces.

* `gotraceraw` parses traces without validation.
  It can produce a text version of the trace wire format, or convert
  the text format back into bytes.
* `gotracevalidate` parses traces and validates them.
  It performs more rigorous checks than the parser does on its own,
  which helps for debugging the parser as well.

                    DependencyScopeConfiguration implementation = project.getConfigurations().dependencyScope("implementation").get();

                    // create and wire the custom dependencies extension's dependencies to these global configurations
                    api.fromDependencyCollector(getRestricted().getDependencies().getApi());

	sectionHeader:      "header",
	sectionQuestions:   "Question",
	sectionAnswers:     "Answer",
	sectionAuthorities: "Authority",
	sectionAdditionals: "Additional",
}

// header is the wire format for a DNS message header.
type header struct {
	id          uint16
	bits        uint16
	questions   uint16
	answers     uint16
	authorities uint16
	additionals uint16
}

import org.apache.maven.api.annotations.Consumer;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle;

/**
 * Interface that can be provided by the plugin to wire in custom lifecycles
 * leveraged using the {@link org.apache.maven.api.plugin.annotations.Execute}
 * annotation.  If a {@code META-INF/maven/lifecycle.xml} file is packaged

import javax.inject.Inject

class ConfigurationCacheWorkerApiIntegrationTest extends AbstractConfigurationCacheIntegrationTest implements TasksWithInputsAndOutputs {
    def "task can wire input #type with fixed value to worker action parameter property"() {
        buildFile << """
            import ${Inject.name}

            abstract class UsesWorker extends DefaultTask {
                @Input

        try {
            return delegate.execute(action, actionParameters, requestContext);
        } catch (Throwable e) {
            // TODO - wire this stuff in properly

            // Sanitise the exception and report it

// into an event stream.
type Reader struct {
	r     *bufio.Reader
	v     version.Version
	specs []event.Spec
}

// NewReader creates a new reader for the trace wire format.
func NewReader(r io.Reader) (*Reader, error) {
	br := bufio.NewReader(r)
	v, err := version.ReadHeader(br)
	if err != nil {
		return nil, err
	}
	return &Reader{r: br, v: v, specs: v.Specs()}, nil
}

            .displayName("cross session services")
            .parent(parent)
            .provider(new Services(startParameter))
            .build();
        // Trigger listener to wire itself in
        services.get(BuildOperationTrace.class);
    }

    public ServiceRegistry getServices() {
        return services;
    }

    @Override
    public void close() {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package raw provides an interface to interpret and emit Go execution traces.
It can interpret and emit execution traces in its wire format as well as a
bespoke but simple text format.

The readers and writers in this package perform no validation on or ordering of
the input, and so are generally unsuitable for analysis. However, they're very

        daemonRegistry = repoRoot().dir("build/daemon")
        gradleSnippetsDir = repoRoot().dir("platforms/documentation/docs/src/snippets") // TODO use dependency management
    }

    // Wire the different inputs for local distributions and repos that are declared by dependencies in the build scripts
    normalizedDistributionZip.distributionZip = configurations["${prefix}TestNormalizedDistributionPath"]