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

# Verification of google.golang.org/protobuf v1.26.0-rc.1

This clean-room sample verifies core APIs of `google.golang.org/protobuf@v1.26.0-rc.1`:
- `proto.Marshal` and `proto.Unmarshal` message round-tripping
- `proto.Equal` and `proto.Clone` deep equality and isolation
- `proto.Merge` field merging semantics
- `proto.Size` wire-format byte size parity with `proto.Marshal`
- `protojson.Marshal` and `protojson.Unmarshal` JSON serialization
- `anypb.New` and `anypb.UnmarshalTo` dynamic typing with `anypb.Any`
- `structpb.NewStruct` and `structpb.AsMap` dynamic JSON-like struct conversion

All tests execute offline without network dependencies.

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

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:2da1a02306bc3213dc0152a47ae21af80ca1e339c63cf131095bbb43305ac626","contract":["proto.Marshal and proto.Unmarshal correctly round-trip protobuf messages","proto.Equal and proto.Clone maintain message equality and deep-copy semantics","proto.Merge merges populated fields from source message into destination","proto.Size returns exact wire-format byte size matching proto.Marshal length","protojson.Marshal and protojson.Unmarshal convert messages to and from valid JSON","anypb.New and UnmarshalTo pack and unpack arbitrary protobuf messages","structpb.NewStruct and AsMap convert between Go map structures and dynamic protobuf structs"],"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},"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","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"
	"time"

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

// TelemetryEvent represents a sample telemetry record with standard protobuf types.
type TelemetryEvent struct {
	Timestamp *timestamppb.Timestamp
	Duration  *durationpb.Duration
	Payload   *structpb.Struct
	Detail    *anypb.Any
}

// NewTelemetryEvent creates a new TelemetryEvent instance.
func NewTelemetryEvent(t time.Time, d time.Duration, meta map[string]interface{}, detail proto.Message) (*TelemetryEvent, error) {
	st, err := structpb.NewStruct(meta)
	if err != nil {
		return nil, fmt.Errorf("structpb creation failed: %w", err)
	}

	var anyDetail *anypb.Any
	if detail != nil {
		anyDetail, err = anypb.New(detail)
		if err != nil {
			return nil, fmt.Errorf("anypb creation failed: %w", err)
		}
	}

	return &TelemetryEvent{
		Timestamp: timestamppb.New(t),
		Duration:  durationpb.New(d),
		Payload:   st,
		Detail:    anyDetail,
	}, nil
}

// ToJSON converts the payload to JSON format using protojson.
func (e *TelemetryEvent) ToJSON() (string, error) {
	if e.Payload == nil {
		return "{}", nil
	}
	data, err := protojson.Marshal(e.Payload)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

// CloneTimestamp creates a deep copy of the Timestamp message.
func (e *TelemetryEvent) CloneTimestamp() *timestamppb.Timestamp {
	if e.Timestamp == nil {
		return nil
	}
	cloned := proto.Clone(e.Timestamp)
	return cloned.(*timestamppb.Timestamp)
}

func main() {
	now := time.Now()
	event, err := NewTelemetryEvent(
		now,
		1500*time.Millisecond,
		map[string]interface{}{"source": "sensor-1", "active": true, "reading": 42.5},
		durationpb.New(2*time.Second),
	)
	if err != nil {
		panic(err)
	}

	jsonStr, err := event.ToJSON()
	if err != nil {
		panic(err)
	}
	fmt.Printf("Telemetry JSON: %s\n", jsonStr)

	wireData, err := proto.Marshal(event.Duration)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Duration wire bytes: %d, size: %d\n", len(wireData), proto.Size(event.Duration))
}

{
  "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"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"os"
	"reflect"
	"time"

	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/anypb"
	"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.Marshal and proto.Unmarshal correctly round-trip protobuf messages
	{
		orig := timestamppb.New(time.Date(2026, 9, 4, 12, 0, 0, 0, time.UTC))
		data, err := proto.Marshal(orig)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Marshal error: %v\n", err)
			os.Exit(1)
		}
		if len(data) == 0 {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Marshal produced empty byte slice\n")
			os.Exit(1)
		}

		var decoded timestamppb.Timestamp
		if err := proto.Unmarshal(data, &decoded); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Unmarshal error: %v\n", err)
			os.Exit(1)
		}
		if !proto.Equal(orig, &decoded) {
			fmt.Fprintf(os.Stderr, "FAIL: unmarshaled message does not equal original\n")
			os.Exit(1)
		}
		if !decoded.AsTime().Equal(orig.AsTime()) {
			fmt.Fprintf(os.Stderr, "FAIL: decoded time %v does not match original %v\n", decoded.AsTime(), orig.AsTime())
			os.Exit(1)
		}
	}

	// Assertion 2: proto.Equal and proto.Clone maintain message equality and deep-copy semantics
	{
		orig := &durationpb.Duration{
			Seconds: 3600,
			Nanos:   500000,
		}
		cloned := proto.Clone(orig).(*durationpb.Duration)
		if !proto.Equal(orig, cloned) {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Clone result is not equal to original\n")
			os.Exit(1)
		}

		// Mutating clone must not affect original
		cloned.Seconds = 7200
		if proto.Equal(orig, cloned) {
			fmt.Fprintf(os.Stderr, "FAIL: mutated clone should not be equal to original\n")
			os.Exit(1)
		}
		if orig.Seconds != 3600 {
			fmt.Fprintf(os.Stderr, "FAIL: modifying clone altered original message\n")
			os.Exit(1)
		}
	}

	// Assertion 3: proto.Merge merges populated fields from source message into destination
	{
		dst := &durationpb.Duration{
			Seconds: 100,
			Nanos:   0,
		}
		src := &durationpb.Duration{
			Seconds: 0,
			Nanos:   500,
		}
		proto.Merge(dst, src)
		if dst.Nanos != 500 {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Merge did not update destination field\n")
			os.Exit(1)
		}
	}

	// Assertion 4: proto.Size returns exact wire-format byte size matching proto.Marshal length
	{
		dur := &durationpb.Duration{
			Seconds: 3600,
			Nanos:   123456,
		}
		data, err := proto.Marshal(dur)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Marshal failed: %v\n", err)
			os.Exit(1)
		}
		if sz := proto.Size(dur); sz != len(data) {
			fmt.Fprintf(os.Stderr, "FAIL: proto.Size mismatch: got %d, want %d\n", sz, len(data))
			os.Exit(1)
		}

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

	// Assertion 5: protojson.Marshal and protojson.Unmarshal convert messages to and from valid JSON
	{
		orig := timestamppb.New(time.Date(2026, 1, 15, 8, 0, 0, 0, time.UTC))
		jsonBytes, err := protojson.Marshal(orig)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: protojson.Marshal error: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Contains(jsonBytes, []byte("2026-01-15T08:00:00Z")) {
			fmt.Fprintf(os.Stderr, "FAIL: JSON output %s does not contain expected RFC3339 timestamp\n", string(jsonBytes))
			os.Exit(1)
		}

		var decoded timestamppb.Timestamp
		if err := protojson.Unmarshal(jsonBytes, &decoded); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: protojson.Unmarshal error: %v\n", err)
			os.Exit(1)
		}
		if !proto.Equal(orig, &decoded) {
			fmt.Fprintf(os.Stderr, "FAIL: unmarshaled JSON message does not equal original\n")
			os.Exit(1)
		}
	}

	// Assertion 6: anypb.New and UnmarshalTo pack and unpack arbitrary protobuf messages
	{
		inner := &durationpb.Duration{
			Seconds: 120,
			Nanos:   0,
		}
		anyMsg, err := anypb.New(inner)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: anypb.New error: %v\n", err)
			os.Exit(1)
		}
		if !anyMsg.MessageIs(&durationpb.Duration{}) {
			fmt.Fprintf(os.Stderr, "FAIL: anyMsg.MessageIs returned false for Duration\n")
			os.Exit(1)
		}

		var unpacked durationpb.Duration
		if err := anyMsg.UnmarshalTo(&unpacked); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: anyMsg.UnmarshalTo error: %v\n", err)
			os.Exit(1)
		}
		if !proto.Equal(inner, &unpacked) {
			fmt.Fprintf(os.Stderr, "FAIL: unpacked any message does not match original\n")
			os.Exit(1)
		}
	}

	// Assertion 7: structpb.NewStruct and AsMap convert between Go map structures and dynamic protobuf structs
	{
		inputMap := map[string]interface{}{
			"string_key": "sample_value",
			"number_key": float64(42),
			"bool_key":   true,
		}
		st, err := structpb.NewStruct(inputMap)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: structpb.NewStruct error: %v\n", err)
			os.Exit(1)
		}
		outMap := st.AsMap()
		if !reflect.DeepEqual(inputMap, outMap) {
			fmt.Fprintf(os.Stderr, "FAIL: AsMap result %v does not match input %v\n", outMap, inputMap)
			os.Exit(1)
		}
	}

	fmt.Println("CONTRACT_PASS")
}