recommend using the "official" serialization stack in `k8s.io/apimachinery`.
Directly serializing these types to proto will not result in data that matches
the wire format or is compatible with other kubernetes ecosystem tools. The
reason is that the wire format includes a magic prefix and an envelope proto.
Please see:
https://kubernetes.io/docs/reference/using-api/api-concepts/#protobuf-encoding

import okhttp3.internal.http2.Header
import okio.ByteString

/**
 * Representation of an individual case (set of headers and wire format). There are many cases for a
 * single story.  This class is used reflectively with Moshi to parse stories.
 */
data class Case(
  val seqno: Int = 0,
  val wire: ByteString? = null,
  val headers: List<Map<String, String>>,
) : Cloneable {
  val headersList: List<Header>
    get() {

	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)

	return &chunkedWriter{w}
}

// Writing to chunkedWriter translates to writing in HTTP chunked Transfer
// Encoding wire format to the underlying Wire chunkedWriter.
type chunkedWriter struct {
	Wire io.Writer
}

// Write the contents of data as one chunk to Wire.
// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
// a bug since it does not check for success of [io.WriteString]

import org.gradle.api.Project;

/**
 * Adds an "example" extension to project and wires dependencies from the extension to a Configuration.
 */
public class ExamplePlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        ExampleExtension example = project.getExtensions().create("example", ExampleExtension.class);
// tag::wire-dependencies[]

// license that can be found in the LICENSE file.

package raw

import (
	"encoding/binary"
	"fmt"
	"io"

	"internal/trace/event"
	"internal/trace/version"
)

// Writer emits the wire format of a trace.
//
// It may not produce a byte-for-byte compatible trace from what is
// produced by the runtime, because it may be missing extra padding
// in the LEB128 encoding that the runtime adds but isn't necessary

    failureCount = CU_get_number_of_failures();

    // Write test failures to the console
    if (failureCount > 0) {
        printf("\nThere were test failures:");
        CU_basic_show_failures(CU_get_failure_list());
        printf("\n\n");
    }

    CU_cleanup_registry();

    // TODO Wire a test listener and use it to generate a test event stream and binary results (don't use Automated)

    return failureCount == 0 ? 0 : -1;

 * [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