switch ut.externalEnc {
		case xGob:
			info.wire.GobEncoderT = gt
		case xBinary:
			info.wire.BinaryMarshalerT = gt
		case xText:
			info.wire.TextMarshalerT = gt
		}
		rt = ut.user
	} else {
		t := info.id.gobType()
		switch typ := rt; typ.Kind() {
		case reflect.Array:
			info.wire.ArrayT = t.(*arrayType)
		case reflect.Map:
			info.wire.MapT = t.(*mapType)
		case reflect.Slice:

 * [Stetho](https://github.com/facebook/stetho): Stetho is a debug bridge for Android applications.
 * [Thrifty](https://github.com/Microsoft/thrifty): An implementation of Apache Thrift for Android.

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.

org.slf4j.simpleLogger.log.Sisu=info
org.slf4j.simpleLogger.warnLevelString=WARNING

# MNG-6181: mvn -X also prints all debug logging from HttpClient
org.slf4j.simpleLogger.log.org.apache.http=off

[short] skip

# Hard-wire new coverage for this test.
env GOEXPERIMENT=coverageredesign

# Baseline run.
go test -cover example/foo
stdout 'coverage: 50.0% of statements$'

# Coverage percentage output should mention -coverpkg selection.
go test -coverpkg=example/foo example/foo
stdout 'coverage: 50.0% of statements in example/foo'

# Try to ask for coverage of a package that doesn't exist.
go test -coverpkg nonexistent example/bar

                    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());

	if id < firstUserId || dec.wireType[id] != nil {
		dec.err = errors.New("gob: duplicate type received")
		return
	}

	// Type:
	wire := new(wireType)
	dec.decodeValue(tWireType, reflect.ValueOf(wire))
	if dec.err != nil {
		return
	}
	// Remember we've seen this type.
	dec.wireType[id] = wire
}

var errBadCount = errors.New("invalid message length")

// TODO: define a proto matching Config - to avoid useless superficial conversions.
func PilotConfigToResource(c *Config) (*mcp.Resource, error) {
	r := &mcp.Resource{}

	// MCP, K8S and Istio configs use gogo configs
	// On the wire it's the same as golang proto.
	a, err := ToProto(c.Spec)
	if err != nil {
		return nil, err
	}
	r.Body = a
	r.Metadata = &mcp.Metadata{
		Name:        c.Namespace + "/" + c.Name,

	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