mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-06 00:55:51 +00:00
a3456c946b
The dynamicpb package permits creating Message values from a MessageDescriptor. Change-Id: Ice429ae45a0835dffb5a7ec8c0bd2c1df7aac8a2 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174960 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
625 lines
18 KiB
Go
625 lines
18 KiB
Go
// Copyright 2019 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package prototest exercises protobuf reflection.
|
|
package prototest
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math"
|
|
"sort"
|
|
"testing"
|
|
|
|
"google.golang.org/protobuf/encoding/prototext"
|
|
"google.golang.org/protobuf/internal/encoding/wire"
|
|
"google.golang.org/protobuf/proto"
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
preg "google.golang.org/protobuf/reflect/protoregistry"
|
|
)
|
|
|
|
// TODO: Test read-only properties of unpopulated composite values.
|
|
// TODO: Test invalid field descriptors or oneof descriptors.
|
|
// TODO: This should test the functionality that can be provided by fast-paths.
|
|
|
|
// MessageOptions configure message tests.
|
|
type MessageOptions struct {
|
|
// ExtensionTypes is a list of types to test with.
|
|
//
|
|
// If nil, TestMessage will look for extension types in the global registry.
|
|
ExtensionTypes []pref.ExtensionType
|
|
}
|
|
|
|
// TestMessage runs the provided m through a series of tests
|
|
// exercising the protobuf reflection API.
|
|
func TestMessage(t testing.TB, m proto.Message, opts MessageOptions) {
|
|
md := m.ProtoReflect().Descriptor()
|
|
m1 := m.ProtoReflect().New()
|
|
for i := 0; i < md.Fields().Len(); i++ {
|
|
fd := md.Fields().Get(i)
|
|
testField(t, m1, fd)
|
|
}
|
|
if opts.ExtensionTypes == nil {
|
|
preg.GlobalTypes.RangeExtensionsByMessage(md.FullName(), func(e pref.ExtensionType) bool {
|
|
opts.ExtensionTypes = append(opts.ExtensionTypes, e)
|
|
return true
|
|
})
|
|
}
|
|
for _, xt := range opts.ExtensionTypes {
|
|
testField(t, m1, xt)
|
|
}
|
|
for i := 0; i < md.Oneofs().Len(); i++ {
|
|
testOneof(t, m1, md.Oneofs().Get(i))
|
|
}
|
|
testUnknown(t, m1)
|
|
|
|
// Test round-trip marshal/unmarshal.
|
|
m2 := m.ProtoReflect().New().Interface()
|
|
populateMessage(m2.ProtoReflect(), 1, nil)
|
|
b, err := proto.Marshal(m2)
|
|
if err != nil {
|
|
t.Errorf("Marshal() = %v, want nil\n%v", err, marshalText(m2))
|
|
}
|
|
m3 := m.ProtoReflect().New().Interface()
|
|
if err := proto.Unmarshal(b, m3); err != nil {
|
|
t.Errorf("Unmarshal() = %v, want nil\n%v", err, marshalText(m2))
|
|
}
|
|
if !proto.Equal(m2, m3) {
|
|
t.Errorf("round-trip marshal/unmarshal did not preserve message\nOriginal:\n%v\nNew:\n%v", marshalText(m2), marshalText(m3))
|
|
}
|
|
}
|
|
|
|
func marshalText(m proto.Message) string {
|
|
b, _ := prototext.MarshalOptions{Indent: " "}.Marshal(m)
|
|
return string(b)
|
|
}
|
|
|
|
// testField exercises set/get/has/clear of a field.
|
|
func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
|
|
name := fd.FullName()
|
|
num := fd.Number()
|
|
|
|
switch {
|
|
case fd.IsList():
|
|
testFieldList(t, m, fd)
|
|
case fd.IsMap():
|
|
testFieldMap(t, m, fd)
|
|
case fd.Kind() == pref.FloatKind || fd.Kind() == pref.DoubleKind:
|
|
testFieldFloat(t, m, fd)
|
|
}
|
|
|
|
// Set to a non-zero value, the zero value, different non-zero values.
|
|
for _, n := range []seed{1, 0, minVal, maxVal} {
|
|
v := newValue(m, fd, n, nil)
|
|
m.Set(fd, v)
|
|
wantHas := true
|
|
if n == 0 {
|
|
if fd.Syntax() == pref.Proto3 && fd.Message() == nil {
|
|
wantHas = false
|
|
}
|
|
if fd.Cardinality() == pref.Repeated {
|
|
wantHas = false
|
|
}
|
|
if fd.IsExtension() {
|
|
wantHas = true
|
|
}
|
|
if fd.ContainingOneof() != nil {
|
|
wantHas = true
|
|
}
|
|
}
|
|
if got, want := m.Has(fd), wantHas; got != want {
|
|
t.Errorf("after setting %q to %v:\nMessage.Has(%v) = %v, want %v", name, formatValue(v), num, got, want)
|
|
}
|
|
if got, want := m.Get(fd), v; !valueEqual(got, want) {
|
|
t.Errorf("after setting %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
|
|
}
|
|
found := false
|
|
m.Range(func(d pref.FieldDescriptor, got pref.Value) bool {
|
|
if fd != d {
|
|
return true
|
|
}
|
|
found = true
|
|
if want := v; !valueEqual(got, want) {
|
|
t.Errorf("after setting %q:\nMessage.Range got value %v, want %v", name, formatValue(got), formatValue(want))
|
|
}
|
|
return true
|
|
})
|
|
if got, want := wantHas, found; got != want {
|
|
t.Errorf("after setting %q:\nMessageRange saw field: %v, want %v", name, got, want)
|
|
}
|
|
}
|
|
|
|
m.Clear(fd)
|
|
if got, want := m.Has(fd), false; got != want {
|
|
t.Errorf("after clearing %q:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
|
|
}
|
|
switch {
|
|
case fd.IsList():
|
|
if got := m.Get(fd); got.List().Len() != 0 {
|
|
t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want empty list", name, num, formatValue(got))
|
|
}
|
|
case fd.IsMap():
|
|
if got := m.Get(fd); got.Map().Len() != 0 {
|
|
t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want empty list", name, num, formatValue(got))
|
|
}
|
|
case fd.Message() == nil:
|
|
if got, want := m.Get(fd), fd.Default(); !valueEqual(got, want) {
|
|
t.Errorf("after clearing %q:\nMessage.Get(%v) = %v, want default %v", name, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
|
|
// Set to the wrong type.
|
|
v := pref.ValueOf("")
|
|
if fd.Kind() == pref.StringKind {
|
|
v = pref.ValueOf(int32(0))
|
|
}
|
|
if !panics(func() {
|
|
m.Set(fd, v)
|
|
}) {
|
|
t.Errorf("setting %v to %T succeeds, want panic", name, v.Interface())
|
|
}
|
|
}
|
|
|
|
// testFieldMap tests set/get/has/clear of entries in a map field.
|
|
func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
|
|
name := fd.FullName()
|
|
num := fd.Number()
|
|
|
|
m.Clear(fd) // start with an empty map
|
|
mapv := m.Mutable(fd).Map()
|
|
|
|
// Add values.
|
|
want := make(testMap)
|
|
for i, n := range []seed{1, 0, minVal, maxVal} {
|
|
if got, want := m.Has(fd), i > 0; got != want {
|
|
t.Errorf("after inserting %d elements to %q:\nMessage.Has(%v) = %v, want %v", i, name, num, got, want)
|
|
}
|
|
|
|
k := newMapKey(fd, n)
|
|
v := newMapValue(fd, mapv, n, nil)
|
|
mapv.Set(k, v)
|
|
want.Set(k, v)
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after inserting %d elements to %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
|
|
// Set values.
|
|
want.Range(func(k pref.MapKey, v pref.Value) bool {
|
|
nv := newMapValue(fd, mapv, 10, nil)
|
|
mapv.Set(k, nv)
|
|
want.Set(k, nv)
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after setting element %v of %q:\nMessage.Get(%v) = %v, want %v", formatValue(k.Value()), name, num, formatValue(got), formatValue(want))
|
|
}
|
|
return true
|
|
})
|
|
|
|
// Clear values.
|
|
want.Range(func(k pref.MapKey, v pref.Value) bool {
|
|
mapv.Clear(k)
|
|
want.Clear(k)
|
|
if got, want := m.Has(fd), want.Len() > 0; got != want {
|
|
t.Errorf("after clearing elements of %q:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
|
|
}
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after clearing elements of %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
|
|
}
|
|
return true
|
|
})
|
|
|
|
// Non-existent map keys.
|
|
missingKey := newMapKey(fd, 1)
|
|
if got, want := mapv.Has(missingKey), false; got != want {
|
|
t.Errorf("non-existent map key in %q: Map.Has(%v) = %v, want %v", name, formatValue(missingKey.Value()), got, want)
|
|
}
|
|
if got, want := mapv.Get(missingKey).IsValid(), false; got != want {
|
|
t.Errorf("non-existent map key in %q: Map.Get(%v).IsValid() = %v, want %v", name, formatValue(missingKey.Value()), got, want)
|
|
}
|
|
mapv.Clear(missingKey) // noop
|
|
}
|
|
|
|
type testMap map[interface{}]pref.Value
|
|
|
|
func (m testMap) Get(k pref.MapKey) pref.Value { return m[k.Interface()] }
|
|
func (m testMap) Set(k pref.MapKey, v pref.Value) { m[k.Interface()] = v }
|
|
func (m testMap) Has(k pref.MapKey) bool { return m.Get(k).IsValid() }
|
|
func (m testMap) Clear(k pref.MapKey) { delete(m, k.Interface()) }
|
|
func (m testMap) Len() int { return len(m) }
|
|
func (m testMap) NewMessage() pref.Message { panic("unimplemented") }
|
|
func (m testMap) Range(f func(pref.MapKey, pref.Value) bool) {
|
|
for k, v := range m {
|
|
if !f(pref.ValueOf(k).MapKey(), v) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// testFieldList exercises set/get/append/truncate of values in a list.
|
|
func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
|
|
name := fd.FullName()
|
|
num := fd.Number()
|
|
|
|
m.Clear(fd) // start with an empty list
|
|
list := m.Mutable(fd).List()
|
|
|
|
// Append values.
|
|
var want pref.List = &testList{}
|
|
for i, n := range []seed{1, 0, minVal, maxVal} {
|
|
if got, want := m.Has(fd), i > 0 || fd.IsExtension(); got != want {
|
|
t.Errorf("after appending %d elements to %q:\nMessage.Has(%v) = %v, want %v", i, name, num, got, want)
|
|
}
|
|
v := newListElement(fd, list, n, nil)
|
|
want.Append(v)
|
|
list.Append(v)
|
|
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after appending %d elements to %q:\nMessage.Get(%v) = %v, want %v", i+1, name, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
|
|
// Set values.
|
|
for i := 0; i < want.Len(); i++ {
|
|
v := newListElement(fd, list, seed(i+10), nil)
|
|
want.Set(i, v)
|
|
list.Set(i, v)
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after setting element %d of %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
|
|
// Truncate.
|
|
for want.Len() > 0 {
|
|
n := want.Len() - 1
|
|
want.Truncate(n)
|
|
list.Truncate(n)
|
|
if got, want := m.Has(fd), want.Len() > 0 || fd.IsExtension(); got != want {
|
|
t.Errorf("after truncating %q to %d:\nMessage.Has(%v) = %v, want %v", name, n, num, got, want)
|
|
}
|
|
if got, want := m.Get(fd), pref.ValueOf(want); !valueEqual(got, want) {
|
|
t.Errorf("after truncating %q to %d:\nMessage.Get(%v) = %v, want %v", name, n, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
}
|
|
|
|
type testList struct {
|
|
a []pref.Value
|
|
}
|
|
|
|
func (l *testList) Append(v pref.Value) { l.a = append(l.a, v) }
|
|
func (l *testList) Get(n int) pref.Value { return l.a[n] }
|
|
func (l *testList) Len() int { return len(l.a) }
|
|
func (l *testList) Set(n int, v pref.Value) { l.a[n] = v }
|
|
func (l *testList) Truncate(n int) { l.a = l.a[:n] }
|
|
func (l *testList) NewMessage() pref.Message { panic("unimplemented") }
|
|
|
|
// testFieldFloat exercises some interesting floating-point scalar field values.
|
|
func testFieldFloat(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
|
|
name := fd.FullName()
|
|
num := fd.Number()
|
|
|
|
for _, v := range []float64{math.Inf(-1), math.Inf(1), math.NaN(), math.Copysign(0, -1)} {
|
|
var val pref.Value
|
|
if fd.Kind() == pref.FloatKind {
|
|
val = pref.ValueOf(float32(v))
|
|
} else {
|
|
val = pref.ValueOf(v)
|
|
}
|
|
m.Set(fd, val)
|
|
// Note that Has is true for -0.
|
|
if got, want := m.Has(fd), true; got != want {
|
|
t.Errorf("after setting %v to %v: Message.Has(%v) = %v, want %v", name, v, num, got, want)
|
|
}
|
|
if got, want := m.Get(fd), val; !valueEqual(got, want) {
|
|
t.Errorf("after setting %v: Message.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
|
|
}
|
|
}
|
|
}
|
|
|
|
// testOneof tests the behavior of fields in a oneof.
|
|
func testOneof(t testing.TB, m pref.Message, od pref.OneofDescriptor) {
|
|
for _, mutable := range []bool{false, true} {
|
|
for i := 0; i < od.Fields().Len(); i++ {
|
|
fda := od.Fields().Get(i)
|
|
if mutable {
|
|
// Set fields by requesting a mutable reference.
|
|
if !fda.IsMap() && !fda.IsList() && fda.Message() == nil {
|
|
continue
|
|
}
|
|
_ = m.Mutable(fda)
|
|
} else {
|
|
// Set fields explicitly.
|
|
m.Set(fda, newValue(m, fda, 1, nil))
|
|
}
|
|
if got, want := m.WhichOneof(od), fda; got != want {
|
|
t.Errorf("after setting oneof field %q:\nWhichOneof(%q) = %v, want %v", fda.FullName(), fda.Name(), got, want)
|
|
}
|
|
for j := 0; j < od.Fields().Len(); j++ {
|
|
fdb := od.Fields().Get(j)
|
|
if got, want := m.Has(fdb), i == j; got != want {
|
|
t.Errorf("after setting oneof field %q:\nGet(%q) = %v, want %v", fda.FullName(), fdb.FullName(), got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// testUnknown tests the behavior of unknown fields.
|
|
func testUnknown(t testing.TB, m pref.Message) {
|
|
var b []byte
|
|
b = wire.AppendTag(b, 1000, wire.VarintType)
|
|
b = wire.AppendVarint(b, 1001)
|
|
m.SetUnknown(pref.RawFields(b))
|
|
if got, want := []byte(m.GetUnknown()), b; !bytes.Equal(got, want) {
|
|
t.Errorf("after setting unknown fields:\nGetUnknown() = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func formatValue(v pref.Value) string {
|
|
switch v := v.Interface().(type) {
|
|
case pref.List:
|
|
var buf bytes.Buffer
|
|
buf.WriteString("list[")
|
|
for i := 0; i < v.Len(); i++ {
|
|
if i > 0 {
|
|
buf.WriteString(" ")
|
|
}
|
|
buf.WriteString(formatValue(v.Get(i)))
|
|
}
|
|
buf.WriteString("]")
|
|
return buf.String()
|
|
case pref.Map:
|
|
var buf bytes.Buffer
|
|
buf.WriteString("map[")
|
|
var keys []pref.MapKey
|
|
v.Range(func(k pref.MapKey, v pref.Value) bool {
|
|
keys = append(keys, k)
|
|
return true
|
|
})
|
|
sort.Slice(keys, func(i, j int) bool {
|
|
return keys[i].String() < keys[j].String()
|
|
})
|
|
for i, k := range keys {
|
|
if i > 0 {
|
|
buf.WriteString(" ")
|
|
}
|
|
buf.WriteString(formatValue(k.Value()))
|
|
buf.WriteString(":")
|
|
buf.WriteString(formatValue(v.Get(k)))
|
|
}
|
|
buf.WriteString("]")
|
|
return buf.String()
|
|
case pref.Message:
|
|
b, err := prototext.Marshal(v.Interface())
|
|
if err != nil {
|
|
return fmt.Sprintf("<%v>", err)
|
|
}
|
|
return fmt.Sprintf("%v{%v}", v.Descriptor().FullName(), string(b))
|
|
case string:
|
|
return fmt.Sprintf("%q", v)
|
|
default:
|
|
return fmt.Sprint(v)
|
|
}
|
|
}
|
|
|
|
func valueEqual(a, b pref.Value) bool {
|
|
ai, bi := a.Interface(), b.Interface()
|
|
switch ai.(type) {
|
|
case pref.Message:
|
|
return proto.Equal(
|
|
a.Message().Interface(),
|
|
b.Message().Interface(),
|
|
)
|
|
case pref.List:
|
|
lista, listb := a.List(), b.List()
|
|
if lista.Len() != listb.Len() {
|
|
return false
|
|
}
|
|
for i := 0; i < lista.Len(); i++ {
|
|
if !valueEqual(lista.Get(i), listb.Get(i)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
case pref.Map:
|
|
mapa, mapb := a.Map(), b.Map()
|
|
if mapa.Len() != mapb.Len() {
|
|
return false
|
|
}
|
|
equal := true
|
|
mapa.Range(func(k pref.MapKey, v pref.Value) bool {
|
|
if !valueEqual(v, mapb.Get(k)) {
|
|
equal = false
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
return equal
|
|
case []byte:
|
|
return bytes.Equal(a.Bytes(), b.Bytes())
|
|
case float32:
|
|
// NaNs are equal, but must be the same NaN.
|
|
return math.Float32bits(ai.(float32)) == math.Float32bits(bi.(float32))
|
|
case float64:
|
|
// NaNs are equal, but must be the same NaN.
|
|
return math.Float64bits(ai.(float64)) == math.Float64bits(bi.(float64))
|
|
default:
|
|
return ai == bi
|
|
}
|
|
}
|
|
|
|
// A seed is used to vary the content of a value.
|
|
//
|
|
// A seed of 0 is the zero value. Messages do not have a zero-value; a 0-seeded messages
|
|
// is unpopulated.
|
|
//
|
|
// A seed of minVal or maxVal is the least or greatest value of the value type.
|
|
type seed int
|
|
|
|
const (
|
|
minVal seed = -1
|
|
maxVal seed = -2
|
|
)
|
|
|
|
// newValue returns a new value assignable to a field.
|
|
//
|
|
// The stack parameter is used to avoid infinite recursion when populating circular
|
|
// data structures.
|
|
func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.MessageDescriptor) pref.Value {
|
|
switch {
|
|
case fd.IsList():
|
|
list := m.New().Mutable(fd).List()
|
|
if n == 0 {
|
|
return pref.ValueOf(list)
|
|
}
|
|
list.Append(newListElement(fd, list, 0, stack))
|
|
list.Append(newListElement(fd, list, minVal, stack))
|
|
list.Append(newListElement(fd, list, maxVal, stack))
|
|
list.Append(newListElement(fd, list, n, stack))
|
|
return pref.ValueOf(list)
|
|
case fd.IsMap():
|
|
mapv := m.New().Mutable(fd).Map()
|
|
if n == 0 {
|
|
return pref.ValueOf(mapv)
|
|
}
|
|
mapv.Set(newMapKey(fd, 0), newMapValue(fd, mapv, 0, stack))
|
|
mapv.Set(newMapKey(fd, minVal), newMapValue(fd, mapv, minVal, stack))
|
|
mapv.Set(newMapKey(fd, maxVal), newMapValue(fd, mapv, maxVal, stack))
|
|
mapv.Set(newMapKey(fd, n), newMapValue(fd, mapv, 10*n, stack))
|
|
return pref.ValueOf(mapv)
|
|
case fd.Message() != nil:
|
|
return populateMessage(m.Mutable(fd).Message(), n, stack)
|
|
default:
|
|
return newScalarValue(fd, n)
|
|
}
|
|
}
|
|
|
|
func newListElement(fd pref.FieldDescriptor, list pref.List, n seed, stack []pref.MessageDescriptor) pref.Value {
|
|
if fd.Message() == nil {
|
|
return newScalarValue(fd, n)
|
|
}
|
|
return populateMessage(list.NewMessage(), n, stack)
|
|
}
|
|
|
|
func newMapKey(fd pref.FieldDescriptor, n seed) pref.MapKey {
|
|
kd := fd.MapKey()
|
|
return newScalarValue(kd, n).MapKey()
|
|
}
|
|
|
|
func newMapValue(fd pref.FieldDescriptor, mapv pref.Map, n seed, stack []pref.MessageDescriptor) pref.Value {
|
|
vd := fd.MapValue()
|
|
if vd.Message() == nil {
|
|
return newScalarValue(vd, n)
|
|
}
|
|
return populateMessage(mapv.NewMessage(), n, stack)
|
|
}
|
|
|
|
func newScalarValue(fd pref.FieldDescriptor, n seed) pref.Value {
|
|
switch fd.Kind() {
|
|
case pref.BoolKind:
|
|
return pref.ValueOf(n != 0)
|
|
case pref.EnumKind:
|
|
// TODO: use actual value
|
|
return pref.ValueOf(pref.EnumNumber(n))
|
|
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
|
|
switch n {
|
|
case minVal:
|
|
return pref.ValueOf(int32(math.MinInt32))
|
|
case maxVal:
|
|
return pref.ValueOf(int32(math.MaxInt32))
|
|
default:
|
|
return pref.ValueOf(int32(n))
|
|
}
|
|
case pref.Uint32Kind, pref.Fixed32Kind:
|
|
switch n {
|
|
case minVal:
|
|
// Only use 0 for the zero value.
|
|
return pref.ValueOf(uint32(1))
|
|
case maxVal:
|
|
return pref.ValueOf(uint32(math.MaxInt32))
|
|
default:
|
|
return pref.ValueOf(uint32(n))
|
|
}
|
|
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
|
|
switch n {
|
|
case minVal:
|
|
return pref.ValueOf(int64(math.MinInt64))
|
|
case maxVal:
|
|
return pref.ValueOf(int64(math.MaxInt64))
|
|
default:
|
|
return pref.ValueOf(int64(n))
|
|
}
|
|
case pref.Uint64Kind, pref.Fixed64Kind:
|
|
switch n {
|
|
case minVal:
|
|
// Only use 0 for the zero value.
|
|
return pref.ValueOf(uint64(1))
|
|
case maxVal:
|
|
return pref.ValueOf(uint64(math.MaxInt64))
|
|
default:
|
|
return pref.ValueOf(uint64(n))
|
|
}
|
|
case pref.FloatKind:
|
|
switch n {
|
|
case minVal:
|
|
return pref.ValueOf(float32(math.SmallestNonzeroFloat32))
|
|
case maxVal:
|
|
return pref.ValueOf(float32(math.MaxFloat32))
|
|
default:
|
|
return pref.ValueOf(1.5 * float32(n))
|
|
}
|
|
case pref.DoubleKind:
|
|
switch n {
|
|
case minVal:
|
|
return pref.ValueOf(float64(math.SmallestNonzeroFloat64))
|
|
case maxVal:
|
|
return pref.ValueOf(float64(math.MaxFloat64))
|
|
default:
|
|
return pref.ValueOf(1.5 * float64(n))
|
|
}
|
|
case pref.StringKind:
|
|
if n == 0 {
|
|
return pref.ValueOf("")
|
|
}
|
|
return pref.ValueOf(fmt.Sprintf("%d", n))
|
|
case pref.BytesKind:
|
|
if n == 0 {
|
|
return pref.ValueOf([]byte(nil))
|
|
}
|
|
return pref.ValueOf([]byte{byte(n >> 24), byte(n >> 16), byte(n >> 8), byte(n)})
|
|
}
|
|
panic("unhandled kind")
|
|
}
|
|
|
|
func populateMessage(m pref.Message, n seed, stack []pref.MessageDescriptor) pref.Value {
|
|
if n == 0 {
|
|
return pref.ValueOf(m)
|
|
}
|
|
md := m.Descriptor()
|
|
for _, x := range stack {
|
|
if md == x {
|
|
return pref.ValueOf(m)
|
|
}
|
|
}
|
|
stack = append(stack, md)
|
|
for i := 0; i < md.Fields().Len(); i++ {
|
|
fd := md.Fields().Get(i)
|
|
if fd.IsWeak() {
|
|
continue
|
|
}
|
|
m.Set(fd, newValue(m, fd, 10*n+seed(i), stack))
|
|
}
|
|
return pref.ValueOf(m)
|
|
}
|
|
|
|
func panics(f func()) (didPanic bool) {
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
didPanic = true
|
|
}
|
|
}()
|
|
f()
|
|
return false
|
|
}
|