google.golang.org/protobuf v1.26.0-rc.1: proto.MarshalOptions

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1
Demonstrate these symbols/APIs:
  - google.golang.org/protobuf/proto.MarshalOptions

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:85a0a96d907f9a31e12a11e5f047c6dbd5489efad7640f8bbca3ffd2eda09288","contract":["proto.MarshalOptions with Deterministic produces identical byte sequences across repeated marshaling of map fields","proto.MarshalOptions.MarshalAppend appends wire-format message data to an existing buffer without modifying prefix","proto.MarshalOptions.Size returns the wire-format byte count matching Marshal output length","proto.MarshalOptions with AllowPartial serializes messages without returning required field errors","proto.MarshalOptions with UseCachedSize serializes messages with valid cached size","proto.MarshalOptions correctly serializes well-known types including Timestamp and Duration"],"goal":"verify pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1","kind":"HOW","packages":["pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1"],"schemaVersion":1,"symbols":["google.golang.org/protobuf/proto.MarshalOptions"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1"],"schemaVersion":1,"subject":"pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1","symbols":["google.golang.org/protobuf/proto.MarshalOptions"],"verifierAdapter":"golang@1"}

module sample

go 1.23

require google.golang.org/protobuf v1.26.0-rc.1

github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v1.26.0-rc.1 h1:7QnIQpGRHE5RnLKnESfDoxm2dTapTZua5a0kS0A+VXQ=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=

package main

import (
	"fmt"

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/structpb"
	"google.golang.org/protobuf/types/known/timestamppb"
)

// SerializeDeterministic marshals a protobuf message using deterministic serialization.
func SerializeDeterministic(m proto.Message) ([]byte, error) {
	opts := proto.MarshalOptions{
		Deterministic: true,
	}
	return opts.Marshal(m)
}

// AppendSerialized appends the wire-format encoding of m to the provided buffer.
func AppendSerialized(buf []byte, m proto.Message) ([]byte, error) {
	opts := proto.MarshalOptions{}
	return opts.MarshalAppend(buf, m)
}

func main() {
	st, err := structpb.NewStruct(map[string]interface{}{
		"keyA": "valueA",
		"keyB": "valueB",
		"keyC": 123.45,
	})
	if err != nil {
		panic(err)
	}

	deterministicBytes, err := SerializeDeterministic(st)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Deterministic wire size: %d bytes\n", len(deterministicBytes))

	prefix := []byte("HEADER:")
	ts := timestamppb.Now()
	buffered, err := AppendSerialized(prefix, ts)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Appended buffer total length: %d bytes\n", len(buffered))
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/google.golang.org/protobuf@v1.26.0-rc.1"
  ],
  "symbols": [
    "google.golang.org/protobuf/proto.MarshalOptions"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"os"

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/durationpb"
	"google.golang.org/protobuf/types/known/structpb"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func main() {
	// Assertion 1: proto.MarshalOptions with Deterministic produces identical byte sequences across repeated marshaling of map fields
	{
		st, err := structpb.NewStruct(map[string]interface{}{
			"alpha":   "first",
			"bravo":   "second",
			"charlie": float64(100),
			"delta":   true,
			"echo":    "fifth",
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: structpb.NewStruct error: %v\n", err)
			os.Exit(1)
		}

		opts := proto.MarshalOptions{Deterministic: true}
		var reference []byte
		for i := 0; i < 20; i++ {
			out, err := opts.Marshal(st)
			if err != nil {
				fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal error on iteration %d: %v\n", i, err)
				os.Exit(1)
			}
			if reference == nil {
				reference = out
			} else if !bytes.Equal(reference, out) {
				fmt.Fprintf(os.Stderr, "FAIL: deterministic marshal produced inconsistent bytes at iteration %d\n", i)
				os.Exit(1)
			}
		}
		if len(reference) == 0 {
			fmt.Fprintf(os.Stderr, "FAIL: deterministic marshal produced empty output\n")
			os.Exit(1)
		}
	}

	// Assertion 2: proto.MarshalOptions.MarshalAppend appends wire-format message data to an existing buffer without modifying prefix
	{
		ts := &timestamppb.Timestamp{
			Seconds: 1700000000,
			Nanos:   543210,
		}
		opts := proto.MarshalOptions{}
		prefix := []byte("PACKET_HEADER_DATA_")
		origPrefixLen := len(prefix)

		combined, err := opts.MarshalAppend(prefix, ts)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: MarshalAppend error: %v\n", err)
			os.Exit(1)
		}
		if !bytes.HasPrefix(combined, prefix[:origPrefixLen]) {
			fmt.Fprintf(os.Stderr, "FAIL: MarshalAppend corrupted prefix\n")
			os.Exit(1)
		}

		directWire, err := opts.Marshal(ts)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal error: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(combined[origPrefixLen:], directWire) {
			fmt.Fprintf(os.Stderr, "FAIL: appended bytes do not match direct wire bytes\n")
			os.Exit(1)
		}
	}

	// Assertion 3: proto.MarshalOptions.Size returns the wire-format byte count matching Marshal output length
	{
		dur := &durationpb.Duration{
			Seconds: 7200,
			Nanos:   999000,
		}
		opts := proto.MarshalOptions{}
		data, err := opts.Marshal(dur)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal error: %v\n", err)
			os.Exit(1)
		}

		calculatedSize := opts.Size(dur)
		if calculatedSize != len(data) {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Size mismatch: got %d, want %d\n", calculatedSize, len(data))
			os.Exit(1)
		}

		var nilMsg proto.Message
		if nilSize := opts.Size(nilMsg); nilSize != 0 {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Size(nil) expected 0, got %d\n", nilSize)
			os.Exit(1)
		}
	}

	// Assertion 4: proto.MarshalOptions with AllowPartial serializes messages without returning required field errors
	{
		ts := &timestamppb.Timestamp{
			Seconds: 1600000000,
		}
		opts := proto.MarshalOptions{AllowPartial: true}
		data, err := opts.Marshal(ts)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal with AllowPartial error: %v\n", err)
			os.Exit(1)
		}
		if len(data) == 0 {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal with AllowPartial returned empty byte slice\n")
			os.Exit(1)
		}
	}

	// Assertion 5: proto.MarshalOptions with UseCachedSize serializes messages with valid cached size
	{
		ts := &timestamppb.Timestamp{
			Seconds: 1750000000,
			Nanos:   123456,
		}
		// First compute size to populate cached size
		_ = proto.Size(ts)

		opts := proto.MarshalOptions{UseCachedSize: true}
		data, err := opts.Marshal(ts)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal with UseCachedSize failed: %v\n", err)
			os.Exit(1)
		}

		var decoded timestamppb.Timestamp
		if err := proto.Unmarshal(data, &decoded); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Unmarshal failed on cached-size serialized data: %v\n", err)
			os.Exit(1)
		}
		if !proto.Equal(ts, &decoded) {
			fmt.Fprintf(os.Stderr, "FAIL: unmarshaled message from cached-size data does not match original\n")
			os.Exit(1)
		}
	}

	// Assertion 6: proto.MarshalOptions correctly serializes well-known types including Timestamp and Duration
	{
		dur := &durationpb.Duration{
			Seconds: 300,
			Nanos:   500000,
		}
		opts := proto.MarshalOptions{}
		wireBytes, err := opts.Marshal(dur)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: opts.Marshal duration failed: %v\n", err)
			os.Exit(1)
		}

		var decoded durationpb.Duration
		if err := proto.Unmarshal(wireBytes, &decoded); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Unmarshal duration failed: %v\n", err)
			os.Exit(1)
		}
		if !proto.Equal(dur, &decoded) {
			fmt.Fprintf(os.Stderr, "FAIL: decoded duration does not match original\n")
			os.Exit(1)
		}
	}

	fmt.Println("CONTRACT_PASS")
}