▽

Source file src/github.com/gogo/protobuf/test/combos/marshaler/thetestpb_test.go

Documentation: github.com/gogo/protobuf/test/combos/marshaler

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: combos/marshaler/thetest.proto
     3  
     4  package test
     5  
     6  import (
     7  	fmt "fmt"
     8  	_ "github.com/gogo/protobuf/gogoproto"
     9  	github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb"
    10  	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
    11  	proto "github.com/gogo/protobuf/proto"
    12  	go_parser "go/parser"
    13  	math "math"
    14  	math_rand "math/rand"
    15  	testing "testing"
    16  	time "time"
    17  )
    18  
    19  // Reference imports to suppress errors if they are not otherwise used.
    20  var _ = proto.Marshal
    21  var _ = fmt.Errorf
    22  var _ = math.Inf
    23  
    24  func TestNidOptNativeProto(t *testing.T) {
    25  	seed := time.Now().UnixNano()
    26  	popr := math_rand.New(math_rand.NewSource(seed))
    27  	p := NewPopulatedNidOptNative(popr, false)
    28  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
    29  	if err != nil {
    30  		t.Fatalf("seed = %d, err = %v", seed, err)
    31  	}
    32  	msg := &NidOptNative{}
    33  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
    34  		t.Fatalf("seed = %d, err = %v", seed, err)
    35  	}
    36  	littlefuzz := make([]byte, len(dAtA))
    37  	copy(littlefuzz, dAtA)
    38  	for i := range dAtA {
    39  		dAtA[i] = byte(popr.Intn(256))
    40  	}
    41  	if err := p.VerboseEqual(msg); err != nil {
    42  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
    43  	}
    44  	if !p.Equal(msg) {
    45  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
    46  	}
    47  	if len(littlefuzz) > 0 {
    48  		fuzzamount := 100
    49  		for i := 0; i < fuzzamount; i++ {
    50  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
    51  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
    52  		}
    53  		// shouldn't panic
    54  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
    55  	}
    56  }
    57  
    58  func TestNidOptNativeMarshalTo(t *testing.T) {
    59  	seed := time.Now().UnixNano()
    60  	popr := math_rand.New(math_rand.NewSource(seed))
    61  	p := NewPopulatedNidOptNative(popr, false)
    62  	size := p.Size()
    63  	dAtA := make([]byte, size)
    64  	for i := range dAtA {
    65  		dAtA[i] = byte(popr.Intn(256))
    66  	}
    67  	_, err := p.MarshalTo(dAtA)
    68  	if err != nil {
    69  		t.Fatalf("seed = %d, err = %v", seed, err)
    70  	}
    71  	msg := &NidOptNative{}
    72  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
    73  		t.Fatalf("seed = %d, err = %v", seed, err)
    74  	}
    75  	for i := range dAtA {
    76  		dAtA[i] = byte(popr.Intn(256))
    77  	}
    78  	if err := p.VerboseEqual(msg); err != nil {
    79  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
    80  	}
    81  	if !p.Equal(msg) {
    82  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
    83  	}
    84  }
    85  
    86  func BenchmarkNidOptNativeProtoMarshal(b *testing.B) {
    87  	popr := math_rand.New(math_rand.NewSource(616))
    88  	total := 0
    89  	pops := make([]*NidOptNative, 10000)
    90  	for i := 0; i < 10000; i++ {
    91  		pops[i] = NewPopulatedNidOptNative(popr, false)
    92  	}
    93  	b.ResetTimer()
    94  	for i := 0; i < b.N; i++ {
    95  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
    96  		if err != nil {
    97  			panic(err)
    98  		}
    99  		total += len(dAtA)
   100  	}
   101  	b.SetBytes(int64(total / b.N))
   102  }
   103  
   104  func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) {
   105  	popr := math_rand.New(math_rand.NewSource(616))
   106  	total := 0
   107  	datas := make([][]byte, 10000)
   108  	for i := 0; i < 10000; i++ {
   109  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false))
   110  		if err != nil {
   111  			panic(err)
   112  		}
   113  		datas[i] = dAtA
   114  	}
   115  	msg := &NidOptNative{}
   116  	b.ResetTimer()
   117  	for i := 0; i < b.N; i++ {
   118  		total += len(datas[i%10000])
   119  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   120  			panic(err)
   121  		}
   122  	}
   123  	b.SetBytes(int64(total / b.N))
   124  }
   125  
   126  func TestNinOptNativeProto(t *testing.T) {
   127  	seed := time.Now().UnixNano()
   128  	popr := math_rand.New(math_rand.NewSource(seed))
   129  	p := NewPopulatedNinOptNative(popr, false)
   130  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   131  	if err != nil {
   132  		t.Fatalf("seed = %d, err = %v", seed, err)
   133  	}
   134  	msg := &NinOptNative{}
   135  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   136  		t.Fatalf("seed = %d, err = %v", seed, err)
   137  	}
   138  	littlefuzz := make([]byte, len(dAtA))
   139  	copy(littlefuzz, dAtA)
   140  	for i := range dAtA {
   141  		dAtA[i] = byte(popr.Intn(256))
   142  	}
   143  	if err := p.VerboseEqual(msg); err != nil {
   144  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   145  	}
   146  	if !p.Equal(msg) {
   147  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   148  	}
   149  	if len(littlefuzz) > 0 {
   150  		fuzzamount := 100
   151  		for i := 0; i < fuzzamount; i++ {
   152  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   153  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   154  		}
   155  		// shouldn't panic
   156  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   157  	}
   158  }
   159  
   160  func TestNinOptNativeMarshalTo(t *testing.T) {
   161  	seed := time.Now().UnixNano()
   162  	popr := math_rand.New(math_rand.NewSource(seed))
   163  	p := NewPopulatedNinOptNative(popr, false)
   164  	size := p.Size()
   165  	dAtA := make([]byte, size)
   166  	for i := range dAtA {
   167  		dAtA[i] = byte(popr.Intn(256))
   168  	}
   169  	_, err := p.MarshalTo(dAtA)
   170  	if err != nil {
   171  		t.Fatalf("seed = %d, err = %v", seed, err)
   172  	}
   173  	msg := &NinOptNative{}
   174  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   175  		t.Fatalf("seed = %d, err = %v", seed, err)
   176  	}
   177  	for i := range dAtA {
   178  		dAtA[i] = byte(popr.Intn(256))
   179  	}
   180  	if err := p.VerboseEqual(msg); err != nil {
   181  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   182  	}
   183  	if !p.Equal(msg) {
   184  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   185  	}
   186  }
   187  
   188  func BenchmarkNinOptNativeProtoMarshal(b *testing.B) {
   189  	popr := math_rand.New(math_rand.NewSource(616))
   190  	total := 0
   191  	pops := make([]*NinOptNative, 10000)
   192  	for i := 0; i < 10000; i++ {
   193  		pops[i] = NewPopulatedNinOptNative(popr, false)
   194  	}
   195  	b.ResetTimer()
   196  	for i := 0; i < b.N; i++ {
   197  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   198  		if err != nil {
   199  			panic(err)
   200  		}
   201  		total += len(dAtA)
   202  	}
   203  	b.SetBytes(int64(total / b.N))
   204  }
   205  
   206  func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) {
   207  	popr := math_rand.New(math_rand.NewSource(616))
   208  	total := 0
   209  	datas := make([][]byte, 10000)
   210  	for i := 0; i < 10000; i++ {
   211  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false))
   212  		if err != nil {
   213  			panic(err)
   214  		}
   215  		datas[i] = dAtA
   216  	}
   217  	msg := &NinOptNative{}
   218  	b.ResetTimer()
   219  	for i := 0; i < b.N; i++ {
   220  		total += len(datas[i%10000])
   221  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   222  			panic(err)
   223  		}
   224  	}
   225  	b.SetBytes(int64(total / b.N))
   226  }
   227  
   228  func TestNidRepNativeProto(t *testing.T) {
   229  	seed := time.Now().UnixNano()
   230  	popr := math_rand.New(math_rand.NewSource(seed))
   231  	p := NewPopulatedNidRepNative(popr, false)
   232  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   233  	if err != nil {
   234  		t.Fatalf("seed = %d, err = %v", seed, err)
   235  	}
   236  	msg := &NidRepNative{}
   237  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   238  		t.Fatalf("seed = %d, err = %v", seed, err)
   239  	}
   240  	littlefuzz := make([]byte, len(dAtA))
   241  	copy(littlefuzz, dAtA)
   242  	for i := range dAtA {
   243  		dAtA[i] = byte(popr.Intn(256))
   244  	}
   245  	if err := p.VerboseEqual(msg); err != nil {
   246  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   247  	}
   248  	if !p.Equal(msg) {
   249  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   250  	}
   251  	if len(littlefuzz) > 0 {
   252  		fuzzamount := 100
   253  		for i := 0; i < fuzzamount; i++ {
   254  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   255  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   256  		}
   257  		// shouldn't panic
   258  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   259  	}
   260  }
   261  
   262  func TestNidRepNativeMarshalTo(t *testing.T) {
   263  	seed := time.Now().UnixNano()
   264  	popr := math_rand.New(math_rand.NewSource(seed))
   265  	p := NewPopulatedNidRepNative(popr, false)
   266  	size := p.Size()
   267  	dAtA := make([]byte, size)
   268  	for i := range dAtA {
   269  		dAtA[i] = byte(popr.Intn(256))
   270  	}
   271  	_, err := p.MarshalTo(dAtA)
   272  	if err != nil {
   273  		t.Fatalf("seed = %d, err = %v", seed, err)
   274  	}
   275  	msg := &NidRepNative{}
   276  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   277  		t.Fatalf("seed = %d, err = %v", seed, err)
   278  	}
   279  	for i := range dAtA {
   280  		dAtA[i] = byte(popr.Intn(256))
   281  	}
   282  	if err := p.VerboseEqual(msg); err != nil {
   283  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   284  	}
   285  	if !p.Equal(msg) {
   286  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   287  	}
   288  }
   289  
   290  func BenchmarkNidRepNativeProtoMarshal(b *testing.B) {
   291  	popr := math_rand.New(math_rand.NewSource(616))
   292  	total := 0
   293  	pops := make([]*NidRepNative, 10000)
   294  	for i := 0; i < 10000; i++ {
   295  		pops[i] = NewPopulatedNidRepNative(popr, false)
   296  	}
   297  	b.ResetTimer()
   298  	for i := 0; i < b.N; i++ {
   299  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   300  		if err != nil {
   301  			panic(err)
   302  		}
   303  		total += len(dAtA)
   304  	}
   305  	b.SetBytes(int64(total / b.N))
   306  }
   307  
   308  func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) {
   309  	popr := math_rand.New(math_rand.NewSource(616))
   310  	total := 0
   311  	datas := make([][]byte, 10000)
   312  	for i := 0; i < 10000; i++ {
   313  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false))
   314  		if err != nil {
   315  			panic(err)
   316  		}
   317  		datas[i] = dAtA
   318  	}
   319  	msg := &NidRepNative{}
   320  	b.ResetTimer()
   321  	for i := 0; i < b.N; i++ {
   322  		total += len(datas[i%10000])
   323  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   324  			panic(err)
   325  		}
   326  	}
   327  	b.SetBytes(int64(total / b.N))
   328  }
   329  
   330  func TestNinRepNativeProto(t *testing.T) {
   331  	seed := time.Now().UnixNano()
   332  	popr := math_rand.New(math_rand.NewSource(seed))
   333  	p := NewPopulatedNinRepNative(popr, false)
   334  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   335  	if err != nil {
   336  		t.Fatalf("seed = %d, err = %v", seed, err)
   337  	}
   338  	msg := &NinRepNative{}
   339  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   340  		t.Fatalf("seed = %d, err = %v", seed, err)
   341  	}
   342  	littlefuzz := make([]byte, len(dAtA))
   343  	copy(littlefuzz, dAtA)
   344  	for i := range dAtA {
   345  		dAtA[i] = byte(popr.Intn(256))
   346  	}
   347  	if err := p.VerboseEqual(msg); err != nil {
   348  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   349  	}
   350  	if !p.Equal(msg) {
   351  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   352  	}
   353  	if len(littlefuzz) > 0 {
   354  		fuzzamount := 100
   355  		for i := 0; i < fuzzamount; i++ {
   356  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   357  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   358  		}
   359  		// shouldn't panic
   360  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   361  	}
   362  }
   363  
   364  func TestNinRepNativeMarshalTo(t *testing.T) {
   365  	seed := time.Now().UnixNano()
   366  	popr := math_rand.New(math_rand.NewSource(seed))
   367  	p := NewPopulatedNinRepNative(popr, false)
   368  	size := p.Size()
   369  	dAtA := make([]byte, size)
   370  	for i := range dAtA {
   371  		dAtA[i] = byte(popr.Intn(256))
   372  	}
   373  	_, err := p.MarshalTo(dAtA)
   374  	if err != nil {
   375  		t.Fatalf("seed = %d, err = %v", seed, err)
   376  	}
   377  	msg := &NinRepNative{}
   378  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   379  		t.Fatalf("seed = %d, err = %v", seed, err)
   380  	}
   381  	for i := range dAtA {
   382  		dAtA[i] = byte(popr.Intn(256))
   383  	}
   384  	if err := p.VerboseEqual(msg); err != nil {
   385  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   386  	}
   387  	if !p.Equal(msg) {
   388  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   389  	}
   390  }
   391  
   392  func BenchmarkNinRepNativeProtoMarshal(b *testing.B) {
   393  	popr := math_rand.New(math_rand.NewSource(616))
   394  	total := 0
   395  	pops := make([]*NinRepNative, 10000)
   396  	for i := 0; i < 10000; i++ {
   397  		pops[i] = NewPopulatedNinRepNative(popr, false)
   398  	}
   399  	b.ResetTimer()
   400  	for i := 0; i < b.N; i++ {
   401  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   402  		if err != nil {
   403  			panic(err)
   404  		}
   405  		total += len(dAtA)
   406  	}
   407  	b.SetBytes(int64(total / b.N))
   408  }
   409  
   410  func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) {
   411  	popr := math_rand.New(math_rand.NewSource(616))
   412  	total := 0
   413  	datas := make([][]byte, 10000)
   414  	for i := 0; i < 10000; i++ {
   415  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false))
   416  		if err != nil {
   417  			panic(err)
   418  		}
   419  		datas[i] = dAtA
   420  	}
   421  	msg := &NinRepNative{}
   422  	b.ResetTimer()
   423  	for i := 0; i < b.N; i++ {
   424  		total += len(datas[i%10000])
   425  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   426  			panic(err)
   427  		}
   428  	}
   429  	b.SetBytes(int64(total / b.N))
   430  }
   431  
   432  func TestNidRepPackedNativeProto(t *testing.T) {
   433  	seed := time.Now().UnixNano()
   434  	popr := math_rand.New(math_rand.NewSource(seed))
   435  	p := NewPopulatedNidRepPackedNative(popr, false)
   436  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   437  	if err != nil {
   438  		t.Fatalf("seed = %d, err = %v", seed, err)
   439  	}
   440  	msg := &NidRepPackedNative{}
   441  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   442  		t.Fatalf("seed = %d, err = %v", seed, err)
   443  	}
   444  	littlefuzz := make([]byte, len(dAtA))
   445  	copy(littlefuzz, dAtA)
   446  	for i := range dAtA {
   447  		dAtA[i] = byte(popr.Intn(256))
   448  	}
   449  	if err := p.VerboseEqual(msg); err != nil {
   450  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   451  	}
   452  	if !p.Equal(msg) {
   453  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   454  	}
   455  	if len(littlefuzz) > 0 {
   456  		fuzzamount := 100
   457  		for i := 0; i < fuzzamount; i++ {
   458  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   459  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   460  		}
   461  		// shouldn't panic
   462  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   463  	}
   464  }
   465  
   466  func TestNidRepPackedNativeMarshalTo(t *testing.T) {
   467  	seed := time.Now().UnixNano()
   468  	popr := math_rand.New(math_rand.NewSource(seed))
   469  	p := NewPopulatedNidRepPackedNative(popr, false)
   470  	size := p.Size()
   471  	dAtA := make([]byte, size)
   472  	for i := range dAtA {
   473  		dAtA[i] = byte(popr.Intn(256))
   474  	}
   475  	_, err := p.MarshalTo(dAtA)
   476  	if err != nil {
   477  		t.Fatalf("seed = %d, err = %v", seed, err)
   478  	}
   479  	msg := &NidRepPackedNative{}
   480  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   481  		t.Fatalf("seed = %d, err = %v", seed, err)
   482  	}
   483  	for i := range dAtA {
   484  		dAtA[i] = byte(popr.Intn(256))
   485  	}
   486  	if err := p.VerboseEqual(msg); err != nil {
   487  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   488  	}
   489  	if !p.Equal(msg) {
   490  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   491  	}
   492  }
   493  
   494  func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) {
   495  	popr := math_rand.New(math_rand.NewSource(616))
   496  	total := 0
   497  	pops := make([]*NidRepPackedNative, 10000)
   498  	for i := 0; i < 10000; i++ {
   499  		pops[i] = NewPopulatedNidRepPackedNative(popr, false)
   500  	}
   501  	b.ResetTimer()
   502  	for i := 0; i < b.N; i++ {
   503  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   504  		if err != nil {
   505  			panic(err)
   506  		}
   507  		total += len(dAtA)
   508  	}
   509  	b.SetBytes(int64(total / b.N))
   510  }
   511  
   512  func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) {
   513  	popr := math_rand.New(math_rand.NewSource(616))
   514  	total := 0
   515  	datas := make([][]byte, 10000)
   516  	for i := 0; i < 10000; i++ {
   517  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false))
   518  		if err != nil {
   519  			panic(err)
   520  		}
   521  		datas[i] = dAtA
   522  	}
   523  	msg := &NidRepPackedNative{}
   524  	b.ResetTimer()
   525  	for i := 0; i < b.N; i++ {
   526  		total += len(datas[i%10000])
   527  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   528  			panic(err)
   529  		}
   530  	}
   531  	b.SetBytes(int64(total / b.N))
   532  }
   533  
   534  func TestNinRepPackedNativeProto(t *testing.T) {
   535  	seed := time.Now().UnixNano()
   536  	popr := math_rand.New(math_rand.NewSource(seed))
   537  	p := NewPopulatedNinRepPackedNative(popr, false)
   538  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   539  	if err != nil {
   540  		t.Fatalf("seed = %d, err = %v", seed, err)
   541  	}
   542  	msg := &NinRepPackedNative{}
   543  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   544  		t.Fatalf("seed = %d, err = %v", seed, err)
   545  	}
   546  	littlefuzz := make([]byte, len(dAtA))
   547  	copy(littlefuzz, dAtA)
   548  	for i := range dAtA {
   549  		dAtA[i] = byte(popr.Intn(256))
   550  	}
   551  	if err := p.VerboseEqual(msg); err != nil {
   552  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   553  	}
   554  	if !p.Equal(msg) {
   555  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   556  	}
   557  	if len(littlefuzz) > 0 {
   558  		fuzzamount := 100
   559  		for i := 0; i < fuzzamount; i++ {
   560  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   561  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   562  		}
   563  		// shouldn't panic
   564  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   565  	}
   566  }
   567  
   568  func TestNinRepPackedNativeMarshalTo(t *testing.T) {
   569  	seed := time.Now().UnixNano()
   570  	popr := math_rand.New(math_rand.NewSource(seed))
   571  	p := NewPopulatedNinRepPackedNative(popr, false)
   572  	size := p.Size()
   573  	dAtA := make([]byte, size)
   574  	for i := range dAtA {
   575  		dAtA[i] = byte(popr.Intn(256))
   576  	}
   577  	_, err := p.MarshalTo(dAtA)
   578  	if err != nil {
   579  		t.Fatalf("seed = %d, err = %v", seed, err)
   580  	}
   581  	msg := &NinRepPackedNative{}
   582  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   583  		t.Fatalf("seed = %d, err = %v", seed, err)
   584  	}
   585  	for i := range dAtA {
   586  		dAtA[i] = byte(popr.Intn(256))
   587  	}
   588  	if err := p.VerboseEqual(msg); err != nil {
   589  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   590  	}
   591  	if !p.Equal(msg) {
   592  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   593  	}
   594  }
   595  
   596  func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) {
   597  	popr := math_rand.New(math_rand.NewSource(616))
   598  	total := 0
   599  	pops := make([]*NinRepPackedNative, 10000)
   600  	for i := 0; i < 10000; i++ {
   601  		pops[i] = NewPopulatedNinRepPackedNative(popr, false)
   602  	}
   603  	b.ResetTimer()
   604  	for i := 0; i < b.N; i++ {
   605  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   606  		if err != nil {
   607  			panic(err)
   608  		}
   609  		total += len(dAtA)
   610  	}
   611  	b.SetBytes(int64(total / b.N))
   612  }
   613  
   614  func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) {
   615  	popr := math_rand.New(math_rand.NewSource(616))
   616  	total := 0
   617  	datas := make([][]byte, 10000)
   618  	for i := 0; i < 10000; i++ {
   619  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false))
   620  		if err != nil {
   621  			panic(err)
   622  		}
   623  		datas[i] = dAtA
   624  	}
   625  	msg := &NinRepPackedNative{}
   626  	b.ResetTimer()
   627  	for i := 0; i < b.N; i++ {
   628  		total += len(datas[i%10000])
   629  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   630  			panic(err)
   631  		}
   632  	}
   633  	b.SetBytes(int64(total / b.N))
   634  }
   635  
   636  func TestNidOptStructProto(t *testing.T) {
   637  	seed := time.Now().UnixNano()
   638  	popr := math_rand.New(math_rand.NewSource(seed))
   639  	p := NewPopulatedNidOptStruct(popr, false)
   640  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   641  	if err != nil {
   642  		t.Fatalf("seed = %d, err = %v", seed, err)
   643  	}
   644  	msg := &NidOptStruct{}
   645  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   646  		t.Fatalf("seed = %d, err = %v", seed, err)
   647  	}
   648  	littlefuzz := make([]byte, len(dAtA))
   649  	copy(littlefuzz, dAtA)
   650  	for i := range dAtA {
   651  		dAtA[i] = byte(popr.Intn(256))
   652  	}
   653  	if err := p.VerboseEqual(msg); err != nil {
   654  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   655  	}
   656  	if !p.Equal(msg) {
   657  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   658  	}
   659  	if len(littlefuzz) > 0 {
   660  		fuzzamount := 100
   661  		for i := 0; i < fuzzamount; i++ {
   662  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   663  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   664  		}
   665  		// shouldn't panic
   666  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   667  	}
   668  }
   669  
   670  func TestNidOptStructMarshalTo(t *testing.T) {
   671  	seed := time.Now().UnixNano()
   672  	popr := math_rand.New(math_rand.NewSource(seed))
   673  	p := NewPopulatedNidOptStruct(popr, false)
   674  	size := p.Size()
   675  	dAtA := make([]byte, size)
   676  	for i := range dAtA {
   677  		dAtA[i] = byte(popr.Intn(256))
   678  	}
   679  	_, err := p.MarshalTo(dAtA)
   680  	if err != nil {
   681  		t.Fatalf("seed = %d, err = %v", seed, err)
   682  	}
   683  	msg := &NidOptStruct{}
   684  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   685  		t.Fatalf("seed = %d, err = %v", seed, err)
   686  	}
   687  	for i := range dAtA {
   688  		dAtA[i] = byte(popr.Intn(256))
   689  	}
   690  	if err := p.VerboseEqual(msg); err != nil {
   691  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   692  	}
   693  	if !p.Equal(msg) {
   694  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   695  	}
   696  }
   697  
   698  func BenchmarkNidOptStructProtoMarshal(b *testing.B) {
   699  	popr := math_rand.New(math_rand.NewSource(616))
   700  	total := 0
   701  	pops := make([]*NidOptStruct, 10000)
   702  	for i := 0; i < 10000; i++ {
   703  		pops[i] = NewPopulatedNidOptStruct(popr, false)
   704  	}
   705  	b.ResetTimer()
   706  	for i := 0; i < b.N; i++ {
   707  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   708  		if err != nil {
   709  			panic(err)
   710  		}
   711  		total += len(dAtA)
   712  	}
   713  	b.SetBytes(int64(total / b.N))
   714  }
   715  
   716  func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) {
   717  	popr := math_rand.New(math_rand.NewSource(616))
   718  	total := 0
   719  	datas := make([][]byte, 10000)
   720  	for i := 0; i < 10000; i++ {
   721  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false))
   722  		if err != nil {
   723  			panic(err)
   724  		}
   725  		datas[i] = dAtA
   726  	}
   727  	msg := &NidOptStruct{}
   728  	b.ResetTimer()
   729  	for i := 0; i < b.N; i++ {
   730  		total += len(datas[i%10000])
   731  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   732  			panic(err)
   733  		}
   734  	}
   735  	b.SetBytes(int64(total / b.N))
   736  }
   737  
   738  func TestNinOptStructProto(t *testing.T) {
   739  	seed := time.Now().UnixNano()
   740  	popr := math_rand.New(math_rand.NewSource(seed))
   741  	p := NewPopulatedNinOptStruct(popr, false)
   742  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   743  	if err != nil {
   744  		t.Fatalf("seed = %d, err = %v", seed, err)
   745  	}
   746  	msg := &NinOptStruct{}
   747  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   748  		t.Fatalf("seed = %d, err = %v", seed, err)
   749  	}
   750  	littlefuzz := make([]byte, len(dAtA))
   751  	copy(littlefuzz, dAtA)
   752  	for i := range dAtA {
   753  		dAtA[i] = byte(popr.Intn(256))
   754  	}
   755  	if err := p.VerboseEqual(msg); err != nil {
   756  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   757  	}
   758  	if !p.Equal(msg) {
   759  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   760  	}
   761  	if len(littlefuzz) > 0 {
   762  		fuzzamount := 100
   763  		for i := 0; i < fuzzamount; i++ {
   764  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   765  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   766  		}
   767  		// shouldn't panic
   768  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   769  	}
   770  }
   771  
   772  func TestNinOptStructMarshalTo(t *testing.T) {
   773  	seed := time.Now().UnixNano()
   774  	popr := math_rand.New(math_rand.NewSource(seed))
   775  	p := NewPopulatedNinOptStruct(popr, false)
   776  	size := p.Size()
   777  	dAtA := make([]byte, size)
   778  	for i := range dAtA {
   779  		dAtA[i] = byte(popr.Intn(256))
   780  	}
   781  	_, err := p.MarshalTo(dAtA)
   782  	if err != nil {
   783  		t.Fatalf("seed = %d, err = %v", seed, err)
   784  	}
   785  	msg := &NinOptStruct{}
   786  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   787  		t.Fatalf("seed = %d, err = %v", seed, err)
   788  	}
   789  	for i := range dAtA {
   790  		dAtA[i] = byte(popr.Intn(256))
   791  	}
   792  	if err := p.VerboseEqual(msg); err != nil {
   793  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   794  	}
   795  	if !p.Equal(msg) {
   796  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   797  	}
   798  }
   799  
   800  func BenchmarkNinOptStructProtoMarshal(b *testing.B) {
   801  	popr := math_rand.New(math_rand.NewSource(616))
   802  	total := 0
   803  	pops := make([]*NinOptStruct, 10000)
   804  	for i := 0; i < 10000; i++ {
   805  		pops[i] = NewPopulatedNinOptStruct(popr, false)
   806  	}
   807  	b.ResetTimer()
   808  	for i := 0; i < b.N; i++ {
   809  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   810  		if err != nil {
   811  			panic(err)
   812  		}
   813  		total += len(dAtA)
   814  	}
   815  	b.SetBytes(int64(total / b.N))
   816  }
   817  
   818  func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) {
   819  	popr := math_rand.New(math_rand.NewSource(616))
   820  	total := 0
   821  	datas := make([][]byte, 10000)
   822  	for i := 0; i < 10000; i++ {
   823  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false))
   824  		if err != nil {
   825  			panic(err)
   826  		}
   827  		datas[i] = dAtA
   828  	}
   829  	msg := &NinOptStruct{}
   830  	b.ResetTimer()
   831  	for i := 0; i < b.N; i++ {
   832  		total += len(datas[i%10000])
   833  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   834  			panic(err)
   835  		}
   836  	}
   837  	b.SetBytes(int64(total / b.N))
   838  }
   839  
   840  func TestNidRepStructProto(t *testing.T) {
   841  	seed := time.Now().UnixNano()
   842  	popr := math_rand.New(math_rand.NewSource(seed))
   843  	p := NewPopulatedNidRepStruct(popr, false)
   844  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   845  	if err != nil {
   846  		t.Fatalf("seed = %d, err = %v", seed, err)
   847  	}
   848  	msg := &NidRepStruct{}
   849  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   850  		t.Fatalf("seed = %d, err = %v", seed, err)
   851  	}
   852  	littlefuzz := make([]byte, len(dAtA))
   853  	copy(littlefuzz, dAtA)
   854  	for i := range dAtA {
   855  		dAtA[i] = byte(popr.Intn(256))
   856  	}
   857  	if err := p.VerboseEqual(msg); err != nil {
   858  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   859  	}
   860  	if !p.Equal(msg) {
   861  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   862  	}
   863  	if len(littlefuzz) > 0 {
   864  		fuzzamount := 100
   865  		for i := 0; i < fuzzamount; i++ {
   866  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   867  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   868  		}
   869  		// shouldn't panic
   870  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   871  	}
   872  }
   873  
   874  func TestNidRepStructMarshalTo(t *testing.T) {
   875  	seed := time.Now().UnixNano()
   876  	popr := math_rand.New(math_rand.NewSource(seed))
   877  	p := NewPopulatedNidRepStruct(popr, false)
   878  	size := p.Size()
   879  	dAtA := make([]byte, size)
   880  	for i := range dAtA {
   881  		dAtA[i] = byte(popr.Intn(256))
   882  	}
   883  	_, err := p.MarshalTo(dAtA)
   884  	if err != nil {
   885  		t.Fatalf("seed = %d, err = %v", seed, err)
   886  	}
   887  	msg := &NidRepStruct{}
   888  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   889  		t.Fatalf("seed = %d, err = %v", seed, err)
   890  	}
   891  	for i := range dAtA {
   892  		dAtA[i] = byte(popr.Intn(256))
   893  	}
   894  	if err := p.VerboseEqual(msg); err != nil {
   895  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   896  	}
   897  	if !p.Equal(msg) {
   898  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   899  	}
   900  }
   901  
   902  func BenchmarkNidRepStructProtoMarshal(b *testing.B) {
   903  	popr := math_rand.New(math_rand.NewSource(616))
   904  	total := 0
   905  	pops := make([]*NidRepStruct, 10000)
   906  	for i := 0; i < 10000; i++ {
   907  		pops[i] = NewPopulatedNidRepStruct(popr, false)
   908  	}
   909  	b.ResetTimer()
   910  	for i := 0; i < b.N; i++ {
   911  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   912  		if err != nil {
   913  			panic(err)
   914  		}
   915  		total += len(dAtA)
   916  	}
   917  	b.SetBytes(int64(total / b.N))
   918  }
   919  
   920  func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) {
   921  	popr := math_rand.New(math_rand.NewSource(616))
   922  	total := 0
   923  	datas := make([][]byte, 10000)
   924  	for i := 0; i < 10000; i++ {
   925  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false))
   926  		if err != nil {
   927  			panic(err)
   928  		}
   929  		datas[i] = dAtA
   930  	}
   931  	msg := &NidRepStruct{}
   932  	b.ResetTimer()
   933  	for i := 0; i < b.N; i++ {
   934  		total += len(datas[i%10000])
   935  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   936  			panic(err)
   937  		}
   938  	}
   939  	b.SetBytes(int64(total / b.N))
   940  }
   941  
   942  func TestNinRepStructProto(t *testing.T) {
   943  	seed := time.Now().UnixNano()
   944  	popr := math_rand.New(math_rand.NewSource(seed))
   945  	p := NewPopulatedNinRepStruct(popr, false)
   946  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   947  	if err != nil {
   948  		t.Fatalf("seed = %d, err = %v", seed, err)
   949  	}
   950  	msg := &NinRepStruct{}
   951  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   952  		t.Fatalf("seed = %d, err = %v", seed, err)
   953  	}
   954  	littlefuzz := make([]byte, len(dAtA))
   955  	copy(littlefuzz, dAtA)
   956  	for i := range dAtA {
   957  		dAtA[i] = byte(popr.Intn(256))
   958  	}
   959  	if err := p.VerboseEqual(msg); err != nil {
   960  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   961  	}
   962  	if !p.Equal(msg) {
   963  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   964  	}
   965  	if len(littlefuzz) > 0 {
   966  		fuzzamount := 100
   967  		for i := 0; i < fuzzamount; i++ {
   968  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   969  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   970  		}
   971  		// shouldn't panic
   972  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   973  	}
   974  }
   975  
   976  func TestNinRepStructMarshalTo(t *testing.T) {
   977  	seed := time.Now().UnixNano()
   978  	popr := math_rand.New(math_rand.NewSource(seed))
   979  	p := NewPopulatedNinRepStruct(popr, false)
   980  	size := p.Size()
   981  	dAtA := make([]byte, size)
   982  	for i := range dAtA {
   983  		dAtA[i] = byte(popr.Intn(256))
   984  	}
   985  	_, err := p.MarshalTo(dAtA)
   986  	if err != nil {
   987  		t.Fatalf("seed = %d, err = %v", seed, err)
   988  	}
   989  	msg := &NinRepStruct{}
   990  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   991  		t.Fatalf("seed = %d, err = %v", seed, err)
   992  	}
   993  	for i := range dAtA {
   994  		dAtA[i] = byte(popr.Intn(256))
   995  	}
   996  	if err := p.VerboseEqual(msg); err != nil {
   997  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   998  	}
   999  	if !p.Equal(msg) {
  1000  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1001  	}
  1002  }
  1003  
  1004  func BenchmarkNinRepStructProtoMarshal(b *testing.B) {
  1005  	popr := math_rand.New(math_rand.NewSource(616))
  1006  	total := 0
  1007  	pops := make([]*NinRepStruct, 10000)
  1008  	for i := 0; i < 10000; i++ {
  1009  		pops[i] = NewPopulatedNinRepStruct(popr, false)
  1010  	}
  1011  	b.ResetTimer()
  1012  	for i := 0; i < b.N; i++ {
  1013  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1014  		if err != nil {
  1015  			panic(err)
  1016  		}
  1017  		total += len(dAtA)
  1018  	}
  1019  	b.SetBytes(int64(total / b.N))
  1020  }
  1021  
  1022  func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) {
  1023  	popr := math_rand.New(math_rand.NewSource(616))
  1024  	total := 0
  1025  	datas := make([][]byte, 10000)
  1026  	for i := 0; i < 10000; i++ {
  1027  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false))
  1028  		if err != nil {
  1029  			panic(err)
  1030  		}
  1031  		datas[i] = dAtA
  1032  	}
  1033  	msg := &NinRepStruct{}
  1034  	b.ResetTimer()
  1035  	for i := 0; i < b.N; i++ {
  1036  		total += len(datas[i%10000])
  1037  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1038  			panic(err)
  1039  		}
  1040  	}
  1041  	b.SetBytes(int64(total / b.N))
  1042  }
  1043  
  1044  func TestNidEmbeddedStructProto(t *testing.T) {
  1045  	seed := time.Now().UnixNano()
  1046  	popr := math_rand.New(math_rand.NewSource(seed))
  1047  	p := NewPopulatedNidEmbeddedStruct(popr, false)
  1048  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1049  	if err != nil {
  1050  		t.Fatalf("seed = %d, err = %v", seed, err)
  1051  	}
  1052  	msg := &NidEmbeddedStruct{}
  1053  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1054  		t.Fatalf("seed = %d, err = %v", seed, err)
  1055  	}
  1056  	littlefuzz := make([]byte, len(dAtA))
  1057  	copy(littlefuzz, dAtA)
  1058  	for i := range dAtA {
  1059  		dAtA[i] = byte(popr.Intn(256))
  1060  	}
  1061  	if err := p.VerboseEqual(msg); err != nil {
  1062  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1063  	}
  1064  	if !p.Equal(msg) {
  1065  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1066  	}
  1067  	if len(littlefuzz) > 0 {
  1068  		fuzzamount := 100
  1069  		for i := 0; i < fuzzamount; i++ {
  1070  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1071  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1072  		}
  1073  		// shouldn't panic
  1074  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1075  	}
  1076  }
  1077  
  1078  func TestNidEmbeddedStructMarshalTo(t *testing.T) {
  1079  	seed := time.Now().UnixNano()
  1080  	popr := math_rand.New(math_rand.NewSource(seed))
  1081  	p := NewPopulatedNidEmbeddedStruct(popr, false)
  1082  	size := p.Size()
  1083  	dAtA := make([]byte, size)
  1084  	for i := range dAtA {
  1085  		dAtA[i] = byte(popr.Intn(256))
  1086  	}
  1087  	_, err := p.MarshalTo(dAtA)
  1088  	if err != nil {
  1089  		t.Fatalf("seed = %d, err = %v", seed, err)
  1090  	}
  1091  	msg := &NidEmbeddedStruct{}
  1092  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1093  		t.Fatalf("seed = %d, err = %v", seed, err)
  1094  	}
  1095  	for i := range dAtA {
  1096  		dAtA[i] = byte(popr.Intn(256))
  1097  	}
  1098  	if err := p.VerboseEqual(msg); err != nil {
  1099  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1100  	}
  1101  	if !p.Equal(msg) {
  1102  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1103  	}
  1104  }
  1105  
  1106  func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) {
  1107  	popr := math_rand.New(math_rand.NewSource(616))
  1108  	total := 0
  1109  	pops := make([]*NidEmbeddedStruct, 10000)
  1110  	for i := 0; i < 10000; i++ {
  1111  		pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
  1112  	}
  1113  	b.ResetTimer()
  1114  	for i := 0; i < b.N; i++ {
  1115  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1116  		if err != nil {
  1117  			panic(err)
  1118  		}
  1119  		total += len(dAtA)
  1120  	}
  1121  	b.SetBytes(int64(total / b.N))
  1122  }
  1123  
  1124  func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) {
  1125  	popr := math_rand.New(math_rand.NewSource(616))
  1126  	total := 0
  1127  	datas := make([][]byte, 10000)
  1128  	for i := 0; i < 10000; i++ {
  1129  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false))
  1130  		if err != nil {
  1131  			panic(err)
  1132  		}
  1133  		datas[i] = dAtA
  1134  	}
  1135  	msg := &NidEmbeddedStruct{}
  1136  	b.ResetTimer()
  1137  	for i := 0; i < b.N; i++ {
  1138  		total += len(datas[i%10000])
  1139  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1140  			panic(err)
  1141  		}
  1142  	}
  1143  	b.SetBytes(int64(total / b.N))
  1144  }
  1145  
  1146  func TestNinEmbeddedStructProto(t *testing.T) {
  1147  	seed := time.Now().UnixNano()
  1148  	popr := math_rand.New(math_rand.NewSource(seed))
  1149  	p := NewPopulatedNinEmbeddedStruct(popr, false)
  1150  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1151  	if err != nil {
  1152  		t.Fatalf("seed = %d, err = %v", seed, err)
  1153  	}
  1154  	msg := &NinEmbeddedStruct{}
  1155  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1156  		t.Fatalf("seed = %d, err = %v", seed, err)
  1157  	}
  1158  	littlefuzz := make([]byte, len(dAtA))
  1159  	copy(littlefuzz, dAtA)
  1160  	for i := range dAtA {
  1161  		dAtA[i] = byte(popr.Intn(256))
  1162  	}
  1163  	if err := p.VerboseEqual(msg); err != nil {
  1164  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1165  	}
  1166  	if !p.Equal(msg) {
  1167  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1168  	}
  1169  	if len(littlefuzz) > 0 {
  1170  		fuzzamount := 100
  1171  		for i := 0; i < fuzzamount; i++ {
  1172  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1173  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1174  		}
  1175  		// shouldn't panic
  1176  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1177  	}
  1178  }
  1179  
  1180  func TestNinEmbeddedStructMarshalTo(t *testing.T) {
  1181  	seed := time.Now().UnixNano()
  1182  	popr := math_rand.New(math_rand.NewSource(seed))
  1183  	p := NewPopulatedNinEmbeddedStruct(popr, false)
  1184  	size := p.Size()
  1185  	dAtA := make([]byte, size)
  1186  	for i := range dAtA {
  1187  		dAtA[i] = byte(popr.Intn(256))
  1188  	}
  1189  	_, err := p.MarshalTo(dAtA)
  1190  	if err != nil {
  1191  		t.Fatalf("seed = %d, err = %v", seed, err)
  1192  	}
  1193  	msg := &NinEmbeddedStruct{}
  1194  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1195  		t.Fatalf("seed = %d, err = %v", seed, err)
  1196  	}
  1197  	for i := range dAtA {
  1198  		dAtA[i] = byte(popr.Intn(256))
  1199  	}
  1200  	if err := p.VerboseEqual(msg); err != nil {
  1201  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1202  	}
  1203  	if !p.Equal(msg) {
  1204  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1205  	}
  1206  }
  1207  
  1208  func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) {
  1209  	popr := math_rand.New(math_rand.NewSource(616))
  1210  	total := 0
  1211  	pops := make([]*NinEmbeddedStruct, 10000)
  1212  	for i := 0; i < 10000; i++ {
  1213  		pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
  1214  	}
  1215  	b.ResetTimer()
  1216  	for i := 0; i < b.N; i++ {
  1217  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1218  		if err != nil {
  1219  			panic(err)
  1220  		}
  1221  		total += len(dAtA)
  1222  	}
  1223  	b.SetBytes(int64(total / b.N))
  1224  }
  1225  
  1226  func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) {
  1227  	popr := math_rand.New(math_rand.NewSource(616))
  1228  	total := 0
  1229  	datas := make([][]byte, 10000)
  1230  	for i := 0; i < 10000; i++ {
  1231  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false))
  1232  		if err != nil {
  1233  			panic(err)
  1234  		}
  1235  		datas[i] = dAtA
  1236  	}
  1237  	msg := &NinEmbeddedStruct{}
  1238  	b.ResetTimer()
  1239  	for i := 0; i < b.N; i++ {
  1240  		total += len(datas[i%10000])
  1241  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1242  			panic(err)
  1243  		}
  1244  	}
  1245  	b.SetBytes(int64(total / b.N))
  1246  }
  1247  
  1248  func TestNidNestedStructProto(t *testing.T) {
  1249  	seed := time.Now().UnixNano()
  1250  	popr := math_rand.New(math_rand.NewSource(seed))
  1251  	p := NewPopulatedNidNestedStruct(popr, false)
  1252  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1253  	if err != nil {
  1254  		t.Fatalf("seed = %d, err = %v", seed, err)
  1255  	}
  1256  	msg := &NidNestedStruct{}
  1257  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1258  		t.Fatalf("seed = %d, err = %v", seed, err)
  1259  	}
  1260  	littlefuzz := make([]byte, len(dAtA))
  1261  	copy(littlefuzz, dAtA)
  1262  	for i := range dAtA {
  1263  		dAtA[i] = byte(popr.Intn(256))
  1264  	}
  1265  	if err := p.VerboseEqual(msg); err != nil {
  1266  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1267  	}
  1268  	if !p.Equal(msg) {
  1269  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1270  	}
  1271  	if len(littlefuzz) > 0 {
  1272  		fuzzamount := 100
  1273  		for i := 0; i < fuzzamount; i++ {
  1274  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1275  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1276  		}
  1277  		// shouldn't panic
  1278  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1279  	}
  1280  }
  1281  
  1282  func TestNidNestedStructMarshalTo(t *testing.T) {
  1283  	seed := time.Now().UnixNano()
  1284  	popr := math_rand.New(math_rand.NewSource(seed))
  1285  	p := NewPopulatedNidNestedStruct(popr, false)
  1286  	size := p.Size()
  1287  	dAtA := make([]byte, size)
  1288  	for i := range dAtA {
  1289  		dAtA[i] = byte(popr.Intn(256))
  1290  	}
  1291  	_, err := p.MarshalTo(dAtA)
  1292  	if err != nil {
  1293  		t.Fatalf("seed = %d, err = %v", seed, err)
  1294  	}
  1295  	msg := &NidNestedStruct{}
  1296  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1297  		t.Fatalf("seed = %d, err = %v", seed, err)
  1298  	}
  1299  	for i := range dAtA {
  1300  		dAtA[i] = byte(popr.Intn(256))
  1301  	}
  1302  	if err := p.VerboseEqual(msg); err != nil {
  1303  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1304  	}
  1305  	if !p.Equal(msg) {
  1306  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1307  	}
  1308  }
  1309  
  1310  func BenchmarkNidNestedStructProtoMarshal(b *testing.B) {
  1311  	popr := math_rand.New(math_rand.NewSource(616))
  1312  	total := 0
  1313  	pops := make([]*NidNestedStruct, 10000)
  1314  	for i := 0; i < 10000; i++ {
  1315  		pops[i] = NewPopulatedNidNestedStruct(popr, false)
  1316  	}
  1317  	b.ResetTimer()
  1318  	for i := 0; i < b.N; i++ {
  1319  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1320  		if err != nil {
  1321  			panic(err)
  1322  		}
  1323  		total += len(dAtA)
  1324  	}
  1325  	b.SetBytes(int64(total / b.N))
  1326  }
  1327  
  1328  func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) {
  1329  	popr := math_rand.New(math_rand.NewSource(616))
  1330  	total := 0
  1331  	datas := make([][]byte, 10000)
  1332  	for i := 0; i < 10000; i++ {
  1333  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false))
  1334  		if err != nil {
  1335  			panic(err)
  1336  		}
  1337  		datas[i] = dAtA
  1338  	}
  1339  	msg := &NidNestedStruct{}
  1340  	b.ResetTimer()
  1341  	for i := 0; i < b.N; i++ {
  1342  		total += len(datas[i%10000])
  1343  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1344  			panic(err)
  1345  		}
  1346  	}
  1347  	b.SetBytes(int64(total / b.N))
  1348  }
  1349  
  1350  func TestNinNestedStructProto(t *testing.T) {
  1351  	seed := time.Now().UnixNano()
  1352  	popr := math_rand.New(math_rand.NewSource(seed))
  1353  	p := NewPopulatedNinNestedStruct(popr, false)
  1354  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1355  	if err != nil {
  1356  		t.Fatalf("seed = %d, err = %v", seed, err)
  1357  	}
  1358  	msg := &NinNestedStruct{}
  1359  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1360  		t.Fatalf("seed = %d, err = %v", seed, err)
  1361  	}
  1362  	littlefuzz := make([]byte, len(dAtA))
  1363  	copy(littlefuzz, dAtA)
  1364  	for i := range dAtA {
  1365  		dAtA[i] = byte(popr.Intn(256))
  1366  	}
  1367  	if err := p.VerboseEqual(msg); err != nil {
  1368  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1369  	}
  1370  	if !p.Equal(msg) {
  1371  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1372  	}
  1373  	if len(littlefuzz) > 0 {
  1374  		fuzzamount := 100
  1375  		for i := 0; i < fuzzamount; i++ {
  1376  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1377  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1378  		}
  1379  		// shouldn't panic
  1380  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1381  	}
  1382  }
  1383  
  1384  func TestNinNestedStructMarshalTo(t *testing.T) {
  1385  	seed := time.Now().UnixNano()
  1386  	popr := math_rand.New(math_rand.NewSource(seed))
  1387  	p := NewPopulatedNinNestedStruct(popr, false)
  1388  	size := p.Size()
  1389  	dAtA := make([]byte, size)
  1390  	for i := range dAtA {
  1391  		dAtA[i] = byte(popr.Intn(256))
  1392  	}
  1393  	_, err := p.MarshalTo(dAtA)
  1394  	if err != nil {
  1395  		t.Fatalf("seed = %d, err = %v", seed, err)
  1396  	}
  1397  	msg := &NinNestedStruct{}
  1398  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1399  		t.Fatalf("seed = %d, err = %v", seed, err)
  1400  	}
  1401  	for i := range dAtA {
  1402  		dAtA[i] = byte(popr.Intn(256))
  1403  	}
  1404  	if err := p.VerboseEqual(msg); err != nil {
  1405  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1406  	}
  1407  	if !p.Equal(msg) {
  1408  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1409  	}
  1410  }
  1411  
  1412  func BenchmarkNinNestedStructProtoMarshal(b *testing.B) {
  1413  	popr := math_rand.New(math_rand.NewSource(616))
  1414  	total := 0
  1415  	pops := make([]*NinNestedStruct, 10000)
  1416  	for i := 0; i < 10000; i++ {
  1417  		pops[i] = NewPopulatedNinNestedStruct(popr, false)
  1418  	}
  1419  	b.ResetTimer()
  1420  	for i := 0; i < b.N; i++ {
  1421  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1422  		if err != nil {
  1423  			panic(err)
  1424  		}
  1425  		total += len(dAtA)
  1426  	}
  1427  	b.SetBytes(int64(total / b.N))
  1428  }
  1429  
  1430  func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) {
  1431  	popr := math_rand.New(math_rand.NewSource(616))
  1432  	total := 0
  1433  	datas := make([][]byte, 10000)
  1434  	for i := 0; i < 10000; i++ {
  1435  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false))
  1436  		if err != nil {
  1437  			panic(err)
  1438  		}
  1439  		datas[i] = dAtA
  1440  	}
  1441  	msg := &NinNestedStruct{}
  1442  	b.ResetTimer()
  1443  	for i := 0; i < b.N; i++ {
  1444  		total += len(datas[i%10000])
  1445  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1446  			panic(err)
  1447  		}
  1448  	}
  1449  	b.SetBytes(int64(total / b.N))
  1450  }
  1451  
  1452  func TestNidOptCustomProto(t *testing.T) {
  1453  	seed := time.Now().UnixNano()
  1454  	popr := math_rand.New(math_rand.NewSource(seed))
  1455  	p := NewPopulatedNidOptCustom(popr, false)
  1456  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1457  	if err != nil {
  1458  		t.Fatalf("seed = %d, err = %v", seed, err)
  1459  	}
  1460  	msg := &NidOptCustom{}
  1461  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1462  		t.Fatalf("seed = %d, err = %v", seed, err)
  1463  	}
  1464  	littlefuzz := make([]byte, len(dAtA))
  1465  	copy(littlefuzz, dAtA)
  1466  	for i := range dAtA {
  1467  		dAtA[i] = byte(popr.Intn(256))
  1468  	}
  1469  	if err := p.VerboseEqual(msg); err != nil {
  1470  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1471  	}
  1472  	if !p.Equal(msg) {
  1473  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1474  	}
  1475  	if len(littlefuzz) > 0 {
  1476  		fuzzamount := 100
  1477  		for i := 0; i < fuzzamount; i++ {
  1478  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1479  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1480  		}
  1481  		// shouldn't panic
  1482  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1483  	}
  1484  }
  1485  
  1486  func TestNidOptCustomMarshalTo(t *testing.T) {
  1487  	seed := time.Now().UnixNano()
  1488  	popr := math_rand.New(math_rand.NewSource(seed))
  1489  	p := NewPopulatedNidOptCustom(popr, false)
  1490  	size := p.Size()
  1491  	dAtA := make([]byte, size)
  1492  	for i := range dAtA {
  1493  		dAtA[i] = byte(popr.Intn(256))
  1494  	}
  1495  	_, err := p.MarshalTo(dAtA)
  1496  	if err != nil {
  1497  		t.Fatalf("seed = %d, err = %v", seed, err)
  1498  	}
  1499  	msg := &NidOptCustom{}
  1500  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1501  		t.Fatalf("seed = %d, err = %v", seed, err)
  1502  	}
  1503  	for i := range dAtA {
  1504  		dAtA[i] = byte(popr.Intn(256))
  1505  	}
  1506  	if err := p.VerboseEqual(msg); err != nil {
  1507  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1508  	}
  1509  	if !p.Equal(msg) {
  1510  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1511  	}
  1512  }
  1513  
  1514  func BenchmarkNidOptCustomProtoMarshal(b *testing.B) {
  1515  	popr := math_rand.New(math_rand.NewSource(616))
  1516  	total := 0
  1517  	pops := make([]*NidOptCustom, 10000)
  1518  	for i := 0; i < 10000; i++ {
  1519  		pops[i] = NewPopulatedNidOptCustom(popr, false)
  1520  	}
  1521  	b.ResetTimer()
  1522  	for i := 0; i < b.N; i++ {
  1523  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1524  		if err != nil {
  1525  			panic(err)
  1526  		}
  1527  		total += len(dAtA)
  1528  	}
  1529  	b.SetBytes(int64(total / b.N))
  1530  }
  1531  
  1532  func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) {
  1533  	popr := math_rand.New(math_rand.NewSource(616))
  1534  	total := 0
  1535  	datas := make([][]byte, 10000)
  1536  	for i := 0; i < 10000; i++ {
  1537  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false))
  1538  		if err != nil {
  1539  			panic(err)
  1540  		}
  1541  		datas[i] = dAtA
  1542  	}
  1543  	msg := &NidOptCustom{}
  1544  	b.ResetTimer()
  1545  	for i := 0; i < b.N; i++ {
  1546  		total += len(datas[i%10000])
  1547  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1548  			panic(err)
  1549  		}
  1550  	}
  1551  	b.SetBytes(int64(total / b.N))
  1552  }
  1553  
  1554  func TestCustomDashProto(t *testing.T) {
  1555  	seed := time.Now().UnixNano()
  1556  	popr := math_rand.New(math_rand.NewSource(seed))
  1557  	p := NewPopulatedCustomDash(popr, false)
  1558  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1559  	if err != nil {
  1560  		t.Fatalf("seed = %d, err = %v", seed, err)
  1561  	}
  1562  	msg := &CustomDash{}
  1563  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1564  		t.Fatalf("seed = %d, err = %v", seed, err)
  1565  	}
  1566  	littlefuzz := make([]byte, len(dAtA))
  1567  	copy(littlefuzz, dAtA)
  1568  	for i := range dAtA {
  1569  		dAtA[i] = byte(popr.Intn(256))
  1570  	}
  1571  	if err := p.VerboseEqual(msg); err != nil {
  1572  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1573  	}
  1574  	if !p.Equal(msg) {
  1575  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1576  	}
  1577  	if len(littlefuzz) > 0 {
  1578  		fuzzamount := 100
  1579  		for i := 0; i < fuzzamount; i++ {
  1580  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1581  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1582  		}
  1583  		// shouldn't panic
  1584  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1585  	}
  1586  }
  1587  
  1588  func TestCustomDashMarshalTo(t *testing.T) {
  1589  	seed := time.Now().UnixNano()
  1590  	popr := math_rand.New(math_rand.NewSource(seed))
  1591  	p := NewPopulatedCustomDash(popr, false)
  1592  	size := p.Size()
  1593  	dAtA := make([]byte, size)
  1594  	for i := range dAtA {
  1595  		dAtA[i] = byte(popr.Intn(256))
  1596  	}
  1597  	_, err := p.MarshalTo(dAtA)
  1598  	if err != nil {
  1599  		t.Fatalf("seed = %d, err = %v", seed, err)
  1600  	}
  1601  	msg := &CustomDash{}
  1602  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1603  		t.Fatalf("seed = %d, err = %v", seed, err)
  1604  	}
  1605  	for i := range dAtA {
  1606  		dAtA[i] = byte(popr.Intn(256))
  1607  	}
  1608  	if err := p.VerboseEqual(msg); err != nil {
  1609  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1610  	}
  1611  	if !p.Equal(msg) {
  1612  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1613  	}
  1614  }
  1615  
  1616  func BenchmarkCustomDashProtoMarshal(b *testing.B) {
  1617  	popr := math_rand.New(math_rand.NewSource(616))
  1618  	total := 0
  1619  	pops := make([]*CustomDash, 10000)
  1620  	for i := 0; i < 10000; i++ {
  1621  		pops[i] = NewPopulatedCustomDash(popr, false)
  1622  	}
  1623  	b.ResetTimer()
  1624  	for i := 0; i < b.N; i++ {
  1625  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1626  		if err != nil {
  1627  			panic(err)
  1628  		}
  1629  		total += len(dAtA)
  1630  	}
  1631  	b.SetBytes(int64(total / b.N))
  1632  }
  1633  
  1634  func BenchmarkCustomDashProtoUnmarshal(b *testing.B) {
  1635  	popr := math_rand.New(math_rand.NewSource(616))
  1636  	total := 0
  1637  	datas := make([][]byte, 10000)
  1638  	for i := 0; i < 10000; i++ {
  1639  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false))
  1640  		if err != nil {
  1641  			panic(err)
  1642  		}
  1643  		datas[i] = dAtA
  1644  	}
  1645  	msg := &CustomDash{}
  1646  	b.ResetTimer()
  1647  	for i := 0; i < b.N; i++ {
  1648  		total += len(datas[i%10000])
  1649  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1650  			panic(err)
  1651  		}
  1652  	}
  1653  	b.SetBytes(int64(total / b.N))
  1654  }
  1655  
  1656  func TestNinOptCustomProto(t *testing.T) {
  1657  	seed := time.Now().UnixNano()
  1658  	popr := math_rand.New(math_rand.NewSource(seed))
  1659  	p := NewPopulatedNinOptCustom(popr, false)
  1660  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1661  	if err != nil {
  1662  		t.Fatalf("seed = %d, err = %v", seed, err)
  1663  	}
  1664  	msg := &NinOptCustom{}
  1665  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1666  		t.Fatalf("seed = %d, err = %v", seed, err)
  1667  	}
  1668  	littlefuzz := make([]byte, len(dAtA))
  1669  	copy(littlefuzz, dAtA)
  1670  	for i := range dAtA {
  1671  		dAtA[i] = byte(popr.Intn(256))
  1672  	}
  1673  	if err := p.VerboseEqual(msg); err != nil {
  1674  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1675  	}
  1676  	if !p.Equal(msg) {
  1677  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1678  	}
  1679  	if len(littlefuzz) > 0 {
  1680  		fuzzamount := 100
  1681  		for i := 0; i < fuzzamount; i++ {
  1682  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1683  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1684  		}
  1685  		// shouldn't panic
  1686  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1687  	}
  1688  }
  1689  
  1690  func TestNinOptCustomMarshalTo(t *testing.T) {
  1691  	seed := time.Now().UnixNano()
  1692  	popr := math_rand.New(math_rand.NewSource(seed))
  1693  	p := NewPopulatedNinOptCustom(popr, false)
  1694  	size := p.Size()
  1695  	dAtA := make([]byte, size)
  1696  	for i := range dAtA {
  1697  		dAtA[i] = byte(popr.Intn(256))
  1698  	}
  1699  	_, err := p.MarshalTo(dAtA)
  1700  	if err != nil {
  1701  		t.Fatalf("seed = %d, err = %v", seed, err)
  1702  	}
  1703  	msg := &NinOptCustom{}
  1704  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1705  		t.Fatalf("seed = %d, err = %v", seed, err)
  1706  	}
  1707  	for i := range dAtA {
  1708  		dAtA[i] = byte(popr.Intn(256))
  1709  	}
  1710  	if err := p.VerboseEqual(msg); err != nil {
  1711  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1712  	}
  1713  	if !p.Equal(msg) {
  1714  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1715  	}
  1716  }
  1717  
  1718  func BenchmarkNinOptCustomProtoMarshal(b *testing.B) {
  1719  	popr := math_rand.New(math_rand.NewSource(616))
  1720  	total := 0
  1721  	pops := make([]*NinOptCustom, 10000)
  1722  	for i := 0; i < 10000; i++ {
  1723  		pops[i] = NewPopulatedNinOptCustom(popr, false)
  1724  	}
  1725  	b.ResetTimer()
  1726  	for i := 0; i < b.N; i++ {
  1727  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1728  		if err != nil {
  1729  			panic(err)
  1730  		}
  1731  		total += len(dAtA)
  1732  	}
  1733  	b.SetBytes(int64(total / b.N))
  1734  }
  1735  
  1736  func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) {
  1737  	popr := math_rand.New(math_rand.NewSource(616))
  1738  	total := 0
  1739  	datas := make([][]byte, 10000)
  1740  	for i := 0; i < 10000; i++ {
  1741  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false))
  1742  		if err != nil {
  1743  			panic(err)
  1744  		}
  1745  		datas[i] = dAtA
  1746  	}
  1747  	msg := &NinOptCustom{}
  1748  	b.ResetTimer()
  1749  	for i := 0; i < b.N; i++ {
  1750  		total += len(datas[i%10000])
  1751  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1752  			panic(err)
  1753  		}
  1754  	}
  1755  	b.SetBytes(int64(total / b.N))
  1756  }
  1757  
  1758  func TestNidRepCustomProto(t *testing.T) {
  1759  	seed := time.Now().UnixNano()
  1760  	popr := math_rand.New(math_rand.NewSource(seed))
  1761  	p := NewPopulatedNidRepCustom(popr, false)
  1762  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1763  	if err != nil {
  1764  		t.Fatalf("seed = %d, err = %v", seed, err)
  1765  	}
  1766  	msg := &NidRepCustom{}
  1767  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1768  		t.Fatalf("seed = %d, err = %v", seed, err)
  1769  	}
  1770  	littlefuzz := make([]byte, len(dAtA))
  1771  	copy(littlefuzz, dAtA)
  1772  	for i := range dAtA {
  1773  		dAtA[i] = byte(popr.Intn(256))
  1774  	}
  1775  	if err := p.VerboseEqual(msg); err != nil {
  1776  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1777  	}
  1778  	if !p.Equal(msg) {
  1779  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1780  	}
  1781  	if len(littlefuzz) > 0 {
  1782  		fuzzamount := 100
  1783  		for i := 0; i < fuzzamount; i++ {
  1784  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1785  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1786  		}
  1787  		// shouldn't panic
  1788  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1789  	}
  1790  }
  1791  
  1792  func TestNidRepCustomMarshalTo(t *testing.T) {
  1793  	seed := time.Now().UnixNano()
  1794  	popr := math_rand.New(math_rand.NewSource(seed))
  1795  	p := NewPopulatedNidRepCustom(popr, false)
  1796  	size := p.Size()
  1797  	dAtA := make([]byte, size)
  1798  	for i := range dAtA {
  1799  		dAtA[i] = byte(popr.Intn(256))
  1800  	}
  1801  	_, err := p.MarshalTo(dAtA)
  1802  	if err != nil {
  1803  		t.Fatalf("seed = %d, err = %v", seed, err)
  1804  	}
  1805  	msg := &NidRepCustom{}
  1806  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1807  		t.Fatalf("seed = %d, err = %v", seed, err)
  1808  	}
  1809  	for i := range dAtA {
  1810  		dAtA[i] = byte(popr.Intn(256))
  1811  	}
  1812  	if err := p.VerboseEqual(msg); err != nil {
  1813  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1814  	}
  1815  	if !p.Equal(msg) {
  1816  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1817  	}
  1818  }
  1819  
  1820  func BenchmarkNidRepCustomProtoMarshal(b *testing.B) {
  1821  	popr := math_rand.New(math_rand.NewSource(616))
  1822  	total := 0
  1823  	pops := make([]*NidRepCustom, 10000)
  1824  	for i := 0; i < 10000; i++ {
  1825  		pops[i] = NewPopulatedNidRepCustom(popr, false)
  1826  	}
  1827  	b.ResetTimer()
  1828  	for i := 0; i < b.N; i++ {
  1829  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1830  		if err != nil {
  1831  			panic(err)
  1832  		}
  1833  		total += len(dAtA)
  1834  	}
  1835  	b.SetBytes(int64(total / b.N))
  1836  }
  1837  
  1838  func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) {
  1839  	popr := math_rand.New(math_rand.NewSource(616))
  1840  	total := 0
  1841  	datas := make([][]byte, 10000)
  1842  	for i := 0; i < 10000; i++ {
  1843  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false))
  1844  		if err != nil {
  1845  			panic(err)
  1846  		}
  1847  		datas[i] = dAtA
  1848  	}
  1849  	msg := &NidRepCustom{}
  1850  	b.ResetTimer()
  1851  	for i := 0; i < b.N; i++ {
  1852  		total += len(datas[i%10000])
  1853  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1854  			panic(err)
  1855  		}
  1856  	}
  1857  	b.SetBytes(int64(total / b.N))
  1858  }
  1859  
  1860  func TestNinRepCustomProto(t *testing.T) {
  1861  	seed := time.Now().UnixNano()
  1862  	popr := math_rand.New(math_rand.NewSource(seed))
  1863  	p := NewPopulatedNinRepCustom(popr, false)
  1864  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1865  	if err != nil {
  1866  		t.Fatalf("seed = %d, err = %v", seed, err)
  1867  	}
  1868  	msg := &NinRepCustom{}
  1869  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1870  		t.Fatalf("seed = %d, err = %v", seed, err)
  1871  	}
  1872  	littlefuzz := make([]byte, len(dAtA))
  1873  	copy(littlefuzz, dAtA)
  1874  	for i := range dAtA {
  1875  		dAtA[i] = byte(popr.Intn(256))
  1876  	}
  1877  	if err := p.VerboseEqual(msg); err != nil {
  1878  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1879  	}
  1880  	if !p.Equal(msg) {
  1881  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1882  	}
  1883  	if len(littlefuzz) > 0 {
  1884  		fuzzamount := 100
  1885  		for i := 0; i < fuzzamount; i++ {
  1886  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1887  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1888  		}
  1889  		// shouldn't panic
  1890  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1891  	}
  1892  }
  1893  
  1894  func TestNinRepCustomMarshalTo(t *testing.T) {
  1895  	seed := time.Now().UnixNano()
  1896  	popr := math_rand.New(math_rand.NewSource(seed))
  1897  	p := NewPopulatedNinRepCustom(popr, false)
  1898  	size := p.Size()
  1899  	dAtA := make([]byte, size)
  1900  	for i := range dAtA {
  1901  		dAtA[i] = byte(popr.Intn(256))
  1902  	}
  1903  	_, err := p.MarshalTo(dAtA)
  1904  	if err != nil {
  1905  		t.Fatalf("seed = %d, err = %v", seed, err)
  1906  	}
  1907  	msg := &NinRepCustom{}
  1908  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1909  		t.Fatalf("seed = %d, err = %v", seed, err)
  1910  	}
  1911  	for i := range dAtA {
  1912  		dAtA[i] = byte(popr.Intn(256))
  1913  	}
  1914  	if err := p.VerboseEqual(msg); err != nil {
  1915  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1916  	}
  1917  	if !p.Equal(msg) {
  1918  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1919  	}
  1920  }
  1921  
  1922  func BenchmarkNinRepCustomProtoMarshal(b *testing.B) {
  1923  	popr := math_rand.New(math_rand.NewSource(616))
  1924  	total := 0
  1925  	pops := make([]*NinRepCustom, 10000)
  1926  	for i := 0; i < 10000; i++ {
  1927  		pops[i] = NewPopulatedNinRepCustom(popr, false)
  1928  	}
  1929  	b.ResetTimer()
  1930  	for i := 0; i < b.N; i++ {
  1931  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1932  		if err != nil {
  1933  			panic(err)
  1934  		}
  1935  		total += len(dAtA)
  1936  	}
  1937  	b.SetBytes(int64(total / b.N))
  1938  }
  1939  
  1940  func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) {
  1941  	popr := math_rand.New(math_rand.NewSource(616))
  1942  	total := 0
  1943  	datas := make([][]byte, 10000)
  1944  	for i := 0; i < 10000; i++ {
  1945  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false))
  1946  		if err != nil {
  1947  			panic(err)
  1948  		}
  1949  		datas[i] = dAtA
  1950  	}
  1951  	msg := &NinRepCustom{}
  1952  	b.ResetTimer()
  1953  	for i := 0; i < b.N; i++ {
  1954  		total += len(datas[i%10000])
  1955  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1956  			panic(err)
  1957  		}
  1958  	}
  1959  	b.SetBytes(int64(total / b.N))
  1960  }
  1961  
  1962  func TestNinOptNativeUnionProto(t *testing.T) {
  1963  	seed := time.Now().UnixNano()
  1964  	popr := math_rand.New(math_rand.NewSource(seed))
  1965  	p := NewPopulatedNinOptNativeUnion(popr, false)
  1966  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1967  	if err != nil {
  1968  		t.Fatalf("seed = %d, err = %v", seed, err)
  1969  	}
  1970  	msg := &NinOptNativeUnion{}
  1971  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1972  		t.Fatalf("seed = %d, err = %v", seed, err)
  1973  	}
  1974  	littlefuzz := make([]byte, len(dAtA))
  1975  	copy(littlefuzz, dAtA)
  1976  	for i := range dAtA {
  1977  		dAtA[i] = byte(popr.Intn(256))
  1978  	}
  1979  	if err := p.VerboseEqual(msg); err != nil {
  1980  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1981  	}
  1982  	if !p.Equal(msg) {
  1983  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1984  	}
  1985  	if len(littlefuzz) > 0 {
  1986  		fuzzamount := 100
  1987  		for i := 0; i < fuzzamount; i++ {
  1988  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1989  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1990  		}
  1991  		// shouldn't panic
  1992  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1993  	}
  1994  }
  1995  
  1996  func TestNinOptNativeUnionMarshalTo(t *testing.T) {
  1997  	seed := time.Now().UnixNano()
  1998  	popr := math_rand.New(math_rand.NewSource(seed))
  1999  	p := NewPopulatedNinOptNativeUnion(popr, false)
  2000  	size := p.Size()
  2001  	dAtA := make([]byte, size)
  2002  	for i := range dAtA {
  2003  		dAtA[i] = byte(popr.Intn(256))
  2004  	}
  2005  	_, err := p.MarshalTo(dAtA)
  2006  	if err != nil {
  2007  		t.Fatalf("seed = %d, err = %v", seed, err)
  2008  	}
  2009  	msg := &NinOptNativeUnion{}
  2010  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2011  		t.Fatalf("seed = %d, err = %v", seed, err)
  2012  	}
  2013  	for i := range dAtA {
  2014  		dAtA[i] = byte(popr.Intn(256))
  2015  	}
  2016  	if err := p.VerboseEqual(msg); err != nil {
  2017  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2018  	}
  2019  	if !p.Equal(msg) {
  2020  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2021  	}
  2022  }
  2023  
  2024  func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) {
  2025  	popr := math_rand.New(math_rand.NewSource(616))
  2026  	total := 0
  2027  	pops := make([]*NinOptNativeUnion, 10000)
  2028  	for i := 0; i < 10000; i++ {
  2029  		pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
  2030  	}
  2031  	b.ResetTimer()
  2032  	for i := 0; i < b.N; i++ {
  2033  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2034  		if err != nil {
  2035  			panic(err)
  2036  		}
  2037  		total += len(dAtA)
  2038  	}
  2039  	b.SetBytes(int64(total / b.N))
  2040  }
  2041  
  2042  func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) {
  2043  	popr := math_rand.New(math_rand.NewSource(616))
  2044  	total := 0
  2045  	datas := make([][]byte, 10000)
  2046  	for i := 0; i < 10000; i++ {
  2047  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false))
  2048  		if err != nil {
  2049  			panic(err)
  2050  		}
  2051  		datas[i] = dAtA
  2052  	}
  2053  	msg := &NinOptNativeUnion{}
  2054  	b.ResetTimer()
  2055  	for i := 0; i < b.N; i++ {
  2056  		total += len(datas[i%10000])
  2057  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2058  			panic(err)
  2059  		}
  2060  	}
  2061  	b.SetBytes(int64(total / b.N))
  2062  }
  2063  
  2064  func TestNinOptStructUnionProto(t *testing.T) {
  2065  	seed := time.Now().UnixNano()
  2066  	popr := math_rand.New(math_rand.NewSource(seed))
  2067  	p := NewPopulatedNinOptStructUnion(popr, false)
  2068  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2069  	if err != nil {
  2070  		t.Fatalf("seed = %d, err = %v", seed, err)
  2071  	}
  2072  	msg := &NinOptStructUnion{}
  2073  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2074  		t.Fatalf("seed = %d, err = %v", seed, err)
  2075  	}
  2076  	littlefuzz := make([]byte, len(dAtA))
  2077  	copy(littlefuzz, dAtA)
  2078  	for i := range dAtA {
  2079  		dAtA[i] = byte(popr.Intn(256))
  2080  	}
  2081  	if err := p.VerboseEqual(msg); err != nil {
  2082  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2083  	}
  2084  	if !p.Equal(msg) {
  2085  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2086  	}
  2087  	if len(littlefuzz) > 0 {
  2088  		fuzzamount := 100
  2089  		for i := 0; i < fuzzamount; i++ {
  2090  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2091  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2092  		}
  2093  		// shouldn't panic
  2094  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2095  	}
  2096  }
  2097  
  2098  func TestNinOptStructUnionMarshalTo(t *testing.T) {
  2099  	seed := time.Now().UnixNano()
  2100  	popr := math_rand.New(math_rand.NewSource(seed))
  2101  	p := NewPopulatedNinOptStructUnion(popr, false)
  2102  	size := p.Size()
  2103  	dAtA := make([]byte, size)
  2104  	for i := range dAtA {
  2105  		dAtA[i] = byte(popr.Intn(256))
  2106  	}
  2107  	_, err := p.MarshalTo(dAtA)
  2108  	if err != nil {
  2109  		t.Fatalf("seed = %d, err = %v", seed, err)
  2110  	}
  2111  	msg := &NinOptStructUnion{}
  2112  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2113  		t.Fatalf("seed = %d, err = %v", seed, err)
  2114  	}
  2115  	for i := range dAtA {
  2116  		dAtA[i] = byte(popr.Intn(256))
  2117  	}
  2118  	if err := p.VerboseEqual(msg); err != nil {
  2119  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2120  	}
  2121  	if !p.Equal(msg) {
  2122  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2123  	}
  2124  }
  2125  
  2126  func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) {
  2127  	popr := math_rand.New(math_rand.NewSource(616))
  2128  	total := 0
  2129  	pops := make([]*NinOptStructUnion, 10000)
  2130  	for i := 0; i < 10000; i++ {
  2131  		pops[i] = NewPopulatedNinOptStructUnion(popr, false)
  2132  	}
  2133  	b.ResetTimer()
  2134  	for i := 0; i < b.N; i++ {
  2135  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2136  		if err != nil {
  2137  			panic(err)
  2138  		}
  2139  		total += len(dAtA)
  2140  	}
  2141  	b.SetBytes(int64(total / b.N))
  2142  }
  2143  
  2144  func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) {
  2145  	popr := math_rand.New(math_rand.NewSource(616))
  2146  	total := 0
  2147  	datas := make([][]byte, 10000)
  2148  	for i := 0; i < 10000; i++ {
  2149  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false))
  2150  		if err != nil {
  2151  			panic(err)
  2152  		}
  2153  		datas[i] = dAtA
  2154  	}
  2155  	msg := &NinOptStructUnion{}
  2156  	b.ResetTimer()
  2157  	for i := 0; i < b.N; i++ {
  2158  		total += len(datas[i%10000])
  2159  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2160  			panic(err)
  2161  		}
  2162  	}
  2163  	b.SetBytes(int64(total / b.N))
  2164  }
  2165  
  2166  func TestNinEmbeddedStructUnionProto(t *testing.T) {
  2167  	seed := time.Now().UnixNano()
  2168  	popr := math_rand.New(math_rand.NewSource(seed))
  2169  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
  2170  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2171  	if err != nil {
  2172  		t.Fatalf("seed = %d, err = %v", seed, err)
  2173  	}
  2174  	msg := &NinEmbeddedStructUnion{}
  2175  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2176  		t.Fatalf("seed = %d, err = %v", seed, err)
  2177  	}
  2178  	littlefuzz := make([]byte, len(dAtA))
  2179  	copy(littlefuzz, dAtA)
  2180  	for i := range dAtA {
  2181  		dAtA[i] = byte(popr.Intn(256))
  2182  	}
  2183  	if err := p.VerboseEqual(msg); err != nil {
  2184  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2185  	}
  2186  	if !p.Equal(msg) {
  2187  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2188  	}
  2189  	if len(littlefuzz) > 0 {
  2190  		fuzzamount := 100
  2191  		for i := 0; i < fuzzamount; i++ {
  2192  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2193  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2194  		}
  2195  		// shouldn't panic
  2196  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2197  	}
  2198  }
  2199  
  2200  func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) {
  2201  	seed := time.Now().UnixNano()
  2202  	popr := math_rand.New(math_rand.NewSource(seed))
  2203  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
  2204  	size := p.Size()
  2205  	dAtA := make([]byte, size)
  2206  	for i := range dAtA {
  2207  		dAtA[i] = byte(popr.Intn(256))
  2208  	}
  2209  	_, err := p.MarshalTo(dAtA)
  2210  	if err != nil {
  2211  		t.Fatalf("seed = %d, err = %v", seed, err)
  2212  	}
  2213  	msg := &NinEmbeddedStructUnion{}
  2214  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2215  		t.Fatalf("seed = %d, err = %v", seed, err)
  2216  	}
  2217  	for i := range dAtA {
  2218  		dAtA[i] = byte(popr.Intn(256))
  2219  	}
  2220  	if err := p.VerboseEqual(msg); err != nil {
  2221  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2222  	}
  2223  	if !p.Equal(msg) {
  2224  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2225  	}
  2226  }
  2227  
  2228  func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
  2229  	popr := math_rand.New(math_rand.NewSource(616))
  2230  	total := 0
  2231  	pops := make([]*NinEmbeddedStructUnion, 10000)
  2232  	for i := 0; i < 10000; i++ {
  2233  		pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
  2234  	}
  2235  	b.ResetTimer()
  2236  	for i := 0; i < b.N; i++ {
  2237  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2238  		if err != nil {
  2239  			panic(err)
  2240  		}
  2241  		total += len(dAtA)
  2242  	}
  2243  	b.SetBytes(int64(total / b.N))
  2244  }
  2245  
  2246  func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
  2247  	popr := math_rand.New(math_rand.NewSource(616))
  2248  	total := 0
  2249  	datas := make([][]byte, 10000)
  2250  	for i := 0; i < 10000; i++ {
  2251  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false))
  2252  		if err != nil {
  2253  			panic(err)
  2254  		}
  2255  		datas[i] = dAtA
  2256  	}
  2257  	msg := &NinEmbeddedStructUnion{}
  2258  	b.ResetTimer()
  2259  	for i := 0; i < b.N; i++ {
  2260  		total += len(datas[i%10000])
  2261  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2262  			panic(err)
  2263  		}
  2264  	}
  2265  	b.SetBytes(int64(total / b.N))
  2266  }
  2267  
  2268  func TestNinNestedStructUnionProto(t *testing.T) {
  2269  	seed := time.Now().UnixNano()
  2270  	popr := math_rand.New(math_rand.NewSource(seed))
  2271  	p := NewPopulatedNinNestedStructUnion(popr, false)
  2272  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2273  	if err != nil {
  2274  		t.Fatalf("seed = %d, err = %v", seed, err)
  2275  	}
  2276  	msg := &NinNestedStructUnion{}
  2277  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2278  		t.Fatalf("seed = %d, err = %v", seed, err)
  2279  	}
  2280  	littlefuzz := make([]byte, len(dAtA))
  2281  	copy(littlefuzz, dAtA)
  2282  	for i := range dAtA {
  2283  		dAtA[i] = byte(popr.Intn(256))
  2284  	}
  2285  	if err := p.VerboseEqual(msg); err != nil {
  2286  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2287  	}
  2288  	if !p.Equal(msg) {
  2289  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2290  	}
  2291  	if len(littlefuzz) > 0 {
  2292  		fuzzamount := 100
  2293  		for i := 0; i < fuzzamount; i++ {
  2294  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2295  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2296  		}
  2297  		// shouldn't panic
  2298  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2299  	}
  2300  }
  2301  
  2302  func TestNinNestedStructUnionMarshalTo(t *testing.T) {
  2303  	seed := time.Now().UnixNano()
  2304  	popr := math_rand.New(math_rand.NewSource(seed))
  2305  	p := NewPopulatedNinNestedStructUnion(popr, false)
  2306  	size := p.Size()
  2307  	dAtA := make([]byte, size)
  2308  	for i := range dAtA {
  2309  		dAtA[i] = byte(popr.Intn(256))
  2310  	}
  2311  	_, err := p.MarshalTo(dAtA)
  2312  	if err != nil {
  2313  		t.Fatalf("seed = %d, err = %v", seed, err)
  2314  	}
  2315  	msg := &NinNestedStructUnion{}
  2316  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2317  		t.Fatalf("seed = %d, err = %v", seed, err)
  2318  	}
  2319  	for i := range dAtA {
  2320  		dAtA[i] = byte(popr.Intn(256))
  2321  	}
  2322  	if err := p.VerboseEqual(msg); err != nil {
  2323  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2324  	}
  2325  	if !p.Equal(msg) {
  2326  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2327  	}
  2328  }
  2329  
  2330  func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) {
  2331  	popr := math_rand.New(math_rand.NewSource(616))
  2332  	total := 0
  2333  	pops := make([]*NinNestedStructUnion, 10000)
  2334  	for i := 0; i < 10000; i++ {
  2335  		pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
  2336  	}
  2337  	b.ResetTimer()
  2338  	for i := 0; i < b.N; i++ {
  2339  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2340  		if err != nil {
  2341  			panic(err)
  2342  		}
  2343  		total += len(dAtA)
  2344  	}
  2345  	b.SetBytes(int64(total / b.N))
  2346  }
  2347  
  2348  func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) {
  2349  	popr := math_rand.New(math_rand.NewSource(616))
  2350  	total := 0
  2351  	datas := make([][]byte, 10000)
  2352  	for i := 0; i < 10000; i++ {
  2353  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false))
  2354  		if err != nil {
  2355  			panic(err)
  2356  		}
  2357  		datas[i] = dAtA
  2358  	}
  2359  	msg := &NinNestedStructUnion{}
  2360  	b.ResetTimer()
  2361  	for i := 0; i < b.N; i++ {
  2362  		total += len(datas[i%10000])
  2363  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2364  			panic(err)
  2365  		}
  2366  	}
  2367  	b.SetBytes(int64(total / b.N))
  2368  }
  2369  
  2370  func TestTreeProto(t *testing.T) {
  2371  	seed := time.Now().UnixNano()
  2372  	popr := math_rand.New(math_rand.NewSource(seed))
  2373  	p := NewPopulatedTree(popr, false)
  2374  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2375  	if err != nil {
  2376  		t.Fatalf("seed = %d, err = %v", seed, err)
  2377  	}
  2378  	msg := &Tree{}
  2379  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2380  		t.Fatalf("seed = %d, err = %v", seed, err)
  2381  	}
  2382  	littlefuzz := make([]byte, len(dAtA))
  2383  	copy(littlefuzz, dAtA)
  2384  	for i := range dAtA {
  2385  		dAtA[i] = byte(popr.Intn(256))
  2386  	}
  2387  	if err := p.VerboseEqual(msg); err != nil {
  2388  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2389  	}
  2390  	if !p.Equal(msg) {
  2391  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2392  	}
  2393  	if len(littlefuzz) > 0 {
  2394  		fuzzamount := 100
  2395  		for i := 0; i < fuzzamount; i++ {
  2396  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2397  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2398  		}
  2399  		// shouldn't panic
  2400  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2401  	}
  2402  }
  2403  
  2404  func TestTreeMarshalTo(t *testing.T) {
  2405  	seed := time.Now().UnixNano()
  2406  	popr := math_rand.New(math_rand.NewSource(seed))
  2407  	p := NewPopulatedTree(popr, false)
  2408  	size := p.Size()
  2409  	dAtA := make([]byte, size)
  2410  	for i := range dAtA {
  2411  		dAtA[i] = byte(popr.Intn(256))
  2412  	}
  2413  	_, err := p.MarshalTo(dAtA)
  2414  	if err != nil {
  2415  		t.Fatalf("seed = %d, err = %v", seed, err)
  2416  	}
  2417  	msg := &Tree{}
  2418  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2419  		t.Fatalf("seed = %d, err = %v", seed, err)
  2420  	}
  2421  	for i := range dAtA {
  2422  		dAtA[i] = byte(popr.Intn(256))
  2423  	}
  2424  	if err := p.VerboseEqual(msg); err != nil {
  2425  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2426  	}
  2427  	if !p.Equal(msg) {
  2428  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2429  	}
  2430  }
  2431  
  2432  func BenchmarkTreeProtoMarshal(b *testing.B) {
  2433  	popr := math_rand.New(math_rand.NewSource(616))
  2434  	total := 0
  2435  	pops := make([]*Tree, 10000)
  2436  	for i := 0; i < 10000; i++ {
  2437  		pops[i] = NewPopulatedTree(popr, false)
  2438  	}
  2439  	b.ResetTimer()
  2440  	for i := 0; i < b.N; i++ {
  2441  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2442  		if err != nil {
  2443  			panic(err)
  2444  		}
  2445  		total += len(dAtA)
  2446  	}
  2447  	b.SetBytes(int64(total / b.N))
  2448  }
  2449  
  2450  func BenchmarkTreeProtoUnmarshal(b *testing.B) {
  2451  	popr := math_rand.New(math_rand.NewSource(616))
  2452  	total := 0
  2453  	datas := make([][]byte, 10000)
  2454  	for i := 0; i < 10000; i++ {
  2455  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false))
  2456  		if err != nil {
  2457  			panic(err)
  2458  		}
  2459  		datas[i] = dAtA
  2460  	}
  2461  	msg := &Tree{}
  2462  	b.ResetTimer()
  2463  	for i := 0; i < b.N; i++ {
  2464  		total += len(datas[i%10000])
  2465  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2466  			panic(err)
  2467  		}
  2468  	}
  2469  	b.SetBytes(int64(total / b.N))
  2470  }
  2471  
  2472  func TestOrBranchProto(t *testing.T) {
  2473  	seed := time.Now().UnixNano()
  2474  	popr := math_rand.New(math_rand.NewSource(seed))
  2475  	p := NewPopulatedOrBranch(popr, false)
  2476  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2477  	if err != nil {
  2478  		t.Fatalf("seed = %d, err = %v", seed, err)
  2479  	}
  2480  	msg := &OrBranch{}
  2481  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2482  		t.Fatalf("seed = %d, err = %v", seed, err)
  2483  	}
  2484  	littlefuzz := make([]byte, len(dAtA))
  2485  	copy(littlefuzz, dAtA)
  2486  	for i := range dAtA {
  2487  		dAtA[i] = byte(popr.Intn(256))
  2488  	}
  2489  	if err := p.VerboseEqual(msg); err != nil {
  2490  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2491  	}
  2492  	if !p.Equal(msg) {
  2493  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2494  	}
  2495  	if len(littlefuzz) > 0 {
  2496  		fuzzamount := 100
  2497  		for i := 0; i < fuzzamount; i++ {
  2498  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2499  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2500  		}
  2501  		// shouldn't panic
  2502  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2503  	}
  2504  }
  2505  
  2506  func TestOrBranchMarshalTo(t *testing.T) {
  2507  	seed := time.Now().UnixNano()
  2508  	popr := math_rand.New(math_rand.NewSource(seed))
  2509  	p := NewPopulatedOrBranch(popr, false)
  2510  	size := p.Size()
  2511  	dAtA := make([]byte, size)
  2512  	for i := range dAtA {
  2513  		dAtA[i] = byte(popr.Intn(256))
  2514  	}
  2515  	_, err := p.MarshalTo(dAtA)
  2516  	if err != nil {
  2517  		t.Fatalf("seed = %d, err = %v", seed, err)
  2518  	}
  2519  	msg := &OrBranch{}
  2520  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2521  		t.Fatalf("seed = %d, err = %v", seed, err)
  2522  	}
  2523  	for i := range dAtA {
  2524  		dAtA[i] = byte(popr.Intn(256))
  2525  	}
  2526  	if err := p.VerboseEqual(msg); err != nil {
  2527  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2528  	}
  2529  	if !p.Equal(msg) {
  2530  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2531  	}
  2532  }
  2533  
  2534  func BenchmarkOrBranchProtoMarshal(b *testing.B) {
  2535  	popr := math_rand.New(math_rand.NewSource(616))
  2536  	total := 0
  2537  	pops := make([]*OrBranch, 10000)
  2538  	for i := 0; i < 10000; i++ {
  2539  		pops[i] = NewPopulatedOrBranch(popr, false)
  2540  	}
  2541  	b.ResetTimer()
  2542  	for i := 0; i < b.N; i++ {
  2543  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2544  		if err != nil {
  2545  			panic(err)
  2546  		}
  2547  		total += len(dAtA)
  2548  	}
  2549  	b.SetBytes(int64(total / b.N))
  2550  }
  2551  
  2552  func BenchmarkOrBranchProtoUnmarshal(b *testing.B) {
  2553  	popr := math_rand.New(math_rand.NewSource(616))
  2554  	total := 0
  2555  	datas := make([][]byte, 10000)
  2556  	for i := 0; i < 10000; i++ {
  2557  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false))
  2558  		if err != nil {
  2559  			panic(err)
  2560  		}
  2561  		datas[i] = dAtA
  2562  	}
  2563  	msg := &OrBranch{}
  2564  	b.ResetTimer()
  2565  	for i := 0; i < b.N; i++ {
  2566  		total += len(datas[i%10000])
  2567  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2568  			panic(err)
  2569  		}
  2570  	}
  2571  	b.SetBytes(int64(total / b.N))
  2572  }
  2573  
  2574  func TestAndBranchProto(t *testing.T) {
  2575  	seed := time.Now().UnixNano()
  2576  	popr := math_rand.New(math_rand.NewSource(seed))
  2577  	p := NewPopulatedAndBranch(popr, false)
  2578  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2579  	if err != nil {
  2580  		t.Fatalf("seed = %d, err = %v", seed, err)
  2581  	}
  2582  	msg := &AndBranch{}
  2583  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2584  		t.Fatalf("seed = %d, err = %v", seed, err)
  2585  	}
  2586  	littlefuzz := make([]byte, len(dAtA))
  2587  	copy(littlefuzz, dAtA)
  2588  	for i := range dAtA {
  2589  		dAtA[i] = byte(popr.Intn(256))
  2590  	}
  2591  	if err := p.VerboseEqual(msg); err != nil {
  2592  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2593  	}
  2594  	if !p.Equal(msg) {
  2595  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2596  	}
  2597  	if len(littlefuzz) > 0 {
  2598  		fuzzamount := 100
  2599  		for i := 0; i < fuzzamount; i++ {
  2600  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2601  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2602  		}
  2603  		// shouldn't panic
  2604  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2605  	}
  2606  }
  2607  
  2608  func TestAndBranchMarshalTo(t *testing.T) {
  2609  	seed := time.Now().UnixNano()
  2610  	popr := math_rand.New(math_rand.NewSource(seed))
  2611  	p := NewPopulatedAndBranch(popr, false)
  2612  	size := p.Size()
  2613  	dAtA := make([]byte, size)
  2614  	for i := range dAtA {
  2615  		dAtA[i] = byte(popr.Intn(256))
  2616  	}
  2617  	_, err := p.MarshalTo(dAtA)
  2618  	if err != nil {
  2619  		t.Fatalf("seed = %d, err = %v", seed, err)
  2620  	}
  2621  	msg := &AndBranch{}
  2622  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2623  		t.Fatalf("seed = %d, err = %v", seed, err)
  2624  	}
  2625  	for i := range dAtA {
  2626  		dAtA[i] = byte(popr.Intn(256))
  2627  	}
  2628  	if err := p.VerboseEqual(msg); err != nil {
  2629  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2630  	}
  2631  	if !p.Equal(msg) {
  2632  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2633  	}
  2634  }
  2635  
  2636  func BenchmarkAndBranchProtoMarshal(b *testing.B) {
  2637  	popr := math_rand.New(math_rand.NewSource(616))
  2638  	total := 0
  2639  	pops := make([]*AndBranch, 10000)
  2640  	for i := 0; i < 10000; i++ {
  2641  		pops[i] = NewPopulatedAndBranch(popr, false)
  2642  	}
  2643  	b.ResetTimer()
  2644  	for i := 0; i < b.N; i++ {
  2645  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2646  		if err != nil {
  2647  			panic(err)
  2648  		}
  2649  		total += len(dAtA)
  2650  	}
  2651  	b.SetBytes(int64(total / b.N))
  2652  }
  2653  
  2654  func BenchmarkAndBranchProtoUnmarshal(b *testing.B) {
  2655  	popr := math_rand.New(math_rand.NewSource(616))
  2656  	total := 0
  2657  	datas := make([][]byte, 10000)
  2658  	for i := 0; i < 10000; i++ {
  2659  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false))
  2660  		if err != nil {
  2661  			panic(err)
  2662  		}
  2663  		datas[i] = dAtA
  2664  	}
  2665  	msg := &AndBranch{}
  2666  	b.ResetTimer()
  2667  	for i := 0; i < b.N; i++ {
  2668  		total += len(datas[i%10000])
  2669  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2670  			panic(err)
  2671  		}
  2672  	}
  2673  	b.SetBytes(int64(total / b.N))
  2674  }
  2675  
  2676  func TestLeafProto(t *testing.T) {
  2677  	seed := time.Now().UnixNano()
  2678  	popr := math_rand.New(math_rand.NewSource(seed))
  2679  	p := NewPopulatedLeaf(popr, false)
  2680  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2681  	if err != nil {
  2682  		t.Fatalf("seed = %d, err = %v", seed, err)
  2683  	}
  2684  	msg := &Leaf{}
  2685  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2686  		t.Fatalf("seed = %d, err = %v", seed, err)
  2687  	}
  2688  	littlefuzz := make([]byte, len(dAtA))
  2689  	copy(littlefuzz, dAtA)
  2690  	for i := range dAtA {
  2691  		dAtA[i] = byte(popr.Intn(256))
  2692  	}
  2693  	if err := p.VerboseEqual(msg); err != nil {
  2694  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2695  	}
  2696  	if !p.Equal(msg) {
  2697  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2698  	}
  2699  	if len(littlefuzz) > 0 {
  2700  		fuzzamount := 100
  2701  		for i := 0; i < fuzzamount; i++ {
  2702  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2703  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2704  		}
  2705  		// shouldn't panic
  2706  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2707  	}
  2708  }
  2709  
  2710  func TestLeafMarshalTo(t *testing.T) {
  2711  	seed := time.Now().UnixNano()
  2712  	popr := math_rand.New(math_rand.NewSource(seed))
  2713  	p := NewPopulatedLeaf(popr, false)
  2714  	size := p.Size()
  2715  	dAtA := make([]byte, size)
  2716  	for i := range dAtA {
  2717  		dAtA[i] = byte(popr.Intn(256))
  2718  	}
  2719  	_, err := p.MarshalTo(dAtA)
  2720  	if err != nil {
  2721  		t.Fatalf("seed = %d, err = %v", seed, err)
  2722  	}
  2723  	msg := &Leaf{}
  2724  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2725  		t.Fatalf("seed = %d, err = %v", seed, err)
  2726  	}
  2727  	for i := range dAtA {
  2728  		dAtA[i] = byte(popr.Intn(256))
  2729  	}
  2730  	if err := p.VerboseEqual(msg); err != nil {
  2731  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2732  	}
  2733  	if !p.Equal(msg) {
  2734  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2735  	}
  2736  }
  2737  
  2738  func BenchmarkLeafProtoMarshal(b *testing.B) {
  2739  	popr := math_rand.New(math_rand.NewSource(616))
  2740  	total := 0
  2741  	pops := make([]*Leaf, 10000)
  2742  	for i := 0; i < 10000; i++ {
  2743  		pops[i] = NewPopulatedLeaf(popr, false)
  2744  	}
  2745  	b.ResetTimer()
  2746  	for i := 0; i < b.N; i++ {
  2747  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2748  		if err != nil {
  2749  			panic(err)
  2750  		}
  2751  		total += len(dAtA)
  2752  	}
  2753  	b.SetBytes(int64(total / b.N))
  2754  }
  2755  
  2756  func BenchmarkLeafProtoUnmarshal(b *testing.B) {
  2757  	popr := math_rand.New(math_rand.NewSource(616))
  2758  	total := 0
  2759  	datas := make([][]byte, 10000)
  2760  	for i := 0; i < 10000; i++ {
  2761  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false))
  2762  		if err != nil {
  2763  			panic(err)
  2764  		}
  2765  		datas[i] = dAtA
  2766  	}
  2767  	msg := &Leaf{}
  2768  	b.ResetTimer()
  2769  	for i := 0; i < b.N; i++ {
  2770  		total += len(datas[i%10000])
  2771  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2772  			panic(err)
  2773  		}
  2774  	}
  2775  	b.SetBytes(int64(total / b.N))
  2776  }
  2777  
  2778  func TestDeepTreeProto(t *testing.T) {
  2779  	seed := time.Now().UnixNano()
  2780  	popr := math_rand.New(math_rand.NewSource(seed))
  2781  	p := NewPopulatedDeepTree(popr, false)
  2782  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2783  	if err != nil {
  2784  		t.Fatalf("seed = %d, err = %v", seed, err)
  2785  	}
  2786  	msg := &DeepTree{}
  2787  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2788  		t.Fatalf("seed = %d, err = %v", seed, err)
  2789  	}
  2790  	littlefuzz := make([]byte, len(dAtA))
  2791  	copy(littlefuzz, dAtA)
  2792  	for i := range dAtA {
  2793  		dAtA[i] = byte(popr.Intn(256))
  2794  	}
  2795  	if err := p.VerboseEqual(msg); err != nil {
  2796  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2797  	}
  2798  	if !p.Equal(msg) {
  2799  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2800  	}
  2801  	if len(littlefuzz) > 0 {
  2802  		fuzzamount := 100
  2803  		for i := 0; i < fuzzamount; i++ {
  2804  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2805  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2806  		}
  2807  		// shouldn't panic
  2808  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2809  	}
  2810  }
  2811  
  2812  func TestDeepTreeMarshalTo(t *testing.T) {
  2813  	seed := time.Now().UnixNano()
  2814  	popr := math_rand.New(math_rand.NewSource(seed))
  2815  	p := NewPopulatedDeepTree(popr, false)
  2816  	size := p.Size()
  2817  	dAtA := make([]byte, size)
  2818  	for i := range dAtA {
  2819  		dAtA[i] = byte(popr.Intn(256))
  2820  	}
  2821  	_, err := p.MarshalTo(dAtA)
  2822  	if err != nil {
  2823  		t.Fatalf("seed = %d, err = %v", seed, err)
  2824  	}
  2825  	msg := &DeepTree{}
  2826  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2827  		t.Fatalf("seed = %d, err = %v", seed, err)
  2828  	}
  2829  	for i := range dAtA {
  2830  		dAtA[i] = byte(popr.Intn(256))
  2831  	}
  2832  	if err := p.VerboseEqual(msg); err != nil {
  2833  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2834  	}
  2835  	if !p.Equal(msg) {
  2836  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2837  	}
  2838  }
  2839  
  2840  func BenchmarkDeepTreeProtoMarshal(b *testing.B) {
  2841  	popr := math_rand.New(math_rand.NewSource(616))
  2842  	total := 0
  2843  	pops := make([]*DeepTree, 10000)
  2844  	for i := 0; i < 10000; i++ {
  2845  		pops[i] = NewPopulatedDeepTree(popr, false)
  2846  	}
  2847  	b.ResetTimer()
  2848  	for i := 0; i < b.N; i++ {
  2849  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2850  		if err != nil {
  2851  			panic(err)
  2852  		}
  2853  		total += len(dAtA)
  2854  	}
  2855  	b.SetBytes(int64(total / b.N))
  2856  }
  2857  
  2858  func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) {
  2859  	popr := math_rand.New(math_rand.NewSource(616))
  2860  	total := 0
  2861  	datas := make([][]byte, 10000)
  2862  	for i := 0; i < 10000; i++ {
  2863  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false))
  2864  		if err != nil {
  2865  			panic(err)
  2866  		}
  2867  		datas[i] = dAtA
  2868  	}
  2869  	msg := &DeepTree{}
  2870  	b.ResetTimer()
  2871  	for i := 0; i < b.N; i++ {
  2872  		total += len(datas[i%10000])
  2873  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2874  			panic(err)
  2875  		}
  2876  	}
  2877  	b.SetBytes(int64(total / b.N))
  2878  }
  2879  
  2880  func TestADeepBranchProto(t *testing.T) {
  2881  	seed := time.Now().UnixNano()
  2882  	popr := math_rand.New(math_rand.NewSource(seed))
  2883  	p := NewPopulatedADeepBranch(popr, false)
  2884  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2885  	if err != nil {
  2886  		t.Fatalf("seed = %d, err = %v", seed, err)
  2887  	}
  2888  	msg := &ADeepBranch{}
  2889  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2890  		t.Fatalf("seed = %d, err = %v", seed, err)
  2891  	}
  2892  	littlefuzz := make([]byte, len(dAtA))
  2893  	copy(littlefuzz, dAtA)
  2894  	for i := range dAtA {
  2895  		dAtA[i] = byte(popr.Intn(256))
  2896  	}
  2897  	if err := p.VerboseEqual(msg); err != nil {
  2898  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2899  	}
  2900  	if !p.Equal(msg) {
  2901  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2902  	}
  2903  	if len(littlefuzz) > 0 {
  2904  		fuzzamount := 100
  2905  		for i := 0; i < fuzzamount; i++ {
  2906  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2907  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2908  		}
  2909  		// shouldn't panic
  2910  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2911  	}
  2912  }
  2913  
  2914  func TestADeepBranchMarshalTo(t *testing.T) {
  2915  	seed := time.Now().UnixNano()
  2916  	popr := math_rand.New(math_rand.NewSource(seed))
  2917  	p := NewPopulatedADeepBranch(popr, false)
  2918  	size := p.Size()
  2919  	dAtA := make([]byte, size)
  2920  	for i := range dAtA {
  2921  		dAtA[i] = byte(popr.Intn(256))
  2922  	}
  2923  	_, err := p.MarshalTo(dAtA)
  2924  	if err != nil {
  2925  		t.Fatalf("seed = %d, err = %v", seed, err)
  2926  	}
  2927  	msg := &ADeepBranch{}
  2928  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2929  		t.Fatalf("seed = %d, err = %v", seed, err)
  2930  	}
  2931  	for i := range dAtA {
  2932  		dAtA[i] = byte(popr.Intn(256))
  2933  	}
  2934  	if err := p.VerboseEqual(msg); err != nil {
  2935  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2936  	}
  2937  	if !p.Equal(msg) {
  2938  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2939  	}
  2940  }
  2941  
  2942  func BenchmarkADeepBranchProtoMarshal(b *testing.B) {
  2943  	popr := math_rand.New(math_rand.NewSource(616))
  2944  	total := 0
  2945  	pops := make([]*ADeepBranch, 10000)
  2946  	for i := 0; i < 10000; i++ {
  2947  		pops[i] = NewPopulatedADeepBranch(popr, false)
  2948  	}
  2949  	b.ResetTimer()
  2950  	for i := 0; i < b.N; i++ {
  2951  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2952  		if err != nil {
  2953  			panic(err)
  2954  		}
  2955  		total += len(dAtA)
  2956  	}
  2957  	b.SetBytes(int64(total / b.N))
  2958  }
  2959  
  2960  func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) {
  2961  	popr := math_rand.New(math_rand.NewSource(616))
  2962  	total := 0
  2963  	datas := make([][]byte, 10000)
  2964  	for i := 0; i < 10000; i++ {
  2965  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false))
  2966  		if err != nil {
  2967  			panic(err)
  2968  		}
  2969  		datas[i] = dAtA
  2970  	}
  2971  	msg := &ADeepBranch{}
  2972  	b.ResetTimer()
  2973  	for i := 0; i < b.N; i++ {
  2974  		total += len(datas[i%10000])
  2975  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2976  			panic(err)
  2977  		}
  2978  	}
  2979  	b.SetBytes(int64(total / b.N))
  2980  }
  2981  
  2982  func TestAndDeepBranchProto(t *testing.T) {
  2983  	seed := time.Now().UnixNano()
  2984  	popr := math_rand.New(math_rand.NewSource(seed))
  2985  	p := NewPopulatedAndDeepBranch(popr, false)
  2986  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2987  	if err != nil {
  2988  		t.Fatalf("seed = %d, err = %v", seed, err)
  2989  	}
  2990  	msg := &AndDeepBranch{}
  2991  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2992  		t.Fatalf("seed = %d, err = %v", seed, err)
  2993  	}
  2994  	littlefuzz := make([]byte, len(dAtA))
  2995  	copy(littlefuzz, dAtA)
  2996  	for i := range dAtA {
  2997  		dAtA[i] = byte(popr.Intn(256))
  2998  	}
  2999  	if err := p.VerboseEqual(msg); err != nil {
  3000  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3001  	}
  3002  	if !p.Equal(msg) {
  3003  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3004  	}
  3005  	if len(littlefuzz) > 0 {
  3006  		fuzzamount := 100
  3007  		for i := 0; i < fuzzamount; i++ {
  3008  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3009  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3010  		}
  3011  		// shouldn't panic
  3012  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3013  	}
  3014  }
  3015  
  3016  func TestAndDeepBranchMarshalTo(t *testing.T) {
  3017  	seed := time.Now().UnixNano()
  3018  	popr := math_rand.New(math_rand.NewSource(seed))
  3019  	p := NewPopulatedAndDeepBranch(popr, false)
  3020  	size := p.Size()
  3021  	dAtA := make([]byte, size)
  3022  	for i := range dAtA {
  3023  		dAtA[i] = byte(popr.Intn(256))
  3024  	}
  3025  	_, err := p.MarshalTo(dAtA)
  3026  	if err != nil {
  3027  		t.Fatalf("seed = %d, err = %v", seed, err)
  3028  	}
  3029  	msg := &AndDeepBranch{}
  3030  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3031  		t.Fatalf("seed = %d, err = %v", seed, err)
  3032  	}
  3033  	for i := range dAtA {
  3034  		dAtA[i] = byte(popr.Intn(256))
  3035  	}
  3036  	if err := p.VerboseEqual(msg); err != nil {
  3037  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3038  	}
  3039  	if !p.Equal(msg) {
  3040  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3041  	}
  3042  }
  3043  
  3044  func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) {
  3045  	popr := math_rand.New(math_rand.NewSource(616))
  3046  	total := 0
  3047  	pops := make([]*AndDeepBranch, 10000)
  3048  	for i := 0; i < 10000; i++ {
  3049  		pops[i] = NewPopulatedAndDeepBranch(popr, false)
  3050  	}
  3051  	b.ResetTimer()
  3052  	for i := 0; i < b.N; i++ {
  3053  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3054  		if err != nil {
  3055  			panic(err)
  3056  		}
  3057  		total += len(dAtA)
  3058  	}
  3059  	b.SetBytes(int64(total / b.N))
  3060  }
  3061  
  3062  func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) {
  3063  	popr := math_rand.New(math_rand.NewSource(616))
  3064  	total := 0
  3065  	datas := make([][]byte, 10000)
  3066  	for i := 0; i < 10000; i++ {
  3067  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false))
  3068  		if err != nil {
  3069  			panic(err)
  3070  		}
  3071  		datas[i] = dAtA
  3072  	}
  3073  	msg := &AndDeepBranch{}
  3074  	b.ResetTimer()
  3075  	for i := 0; i < b.N; i++ {
  3076  		total += len(datas[i%10000])
  3077  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3078  			panic(err)
  3079  		}
  3080  	}
  3081  	b.SetBytes(int64(total / b.N))
  3082  }
  3083  
  3084  func TestDeepLeafProto(t *testing.T) {
  3085  	seed := time.Now().UnixNano()
  3086  	popr := math_rand.New(math_rand.NewSource(seed))
  3087  	p := NewPopulatedDeepLeaf(popr, false)
  3088  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3089  	if err != nil {
  3090  		t.Fatalf("seed = %d, err = %v", seed, err)
  3091  	}
  3092  	msg := &DeepLeaf{}
  3093  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3094  		t.Fatalf("seed = %d, err = %v", seed, err)
  3095  	}
  3096  	littlefuzz := make([]byte, len(dAtA))
  3097  	copy(littlefuzz, dAtA)
  3098  	for i := range dAtA {
  3099  		dAtA[i] = byte(popr.Intn(256))
  3100  	}
  3101  	if err := p.VerboseEqual(msg); err != nil {
  3102  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3103  	}
  3104  	if !p.Equal(msg) {
  3105  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3106  	}
  3107  	if len(littlefuzz) > 0 {
  3108  		fuzzamount := 100
  3109  		for i := 0; i < fuzzamount; i++ {
  3110  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3111  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3112  		}
  3113  		// shouldn't panic
  3114  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3115  	}
  3116  }
  3117  
  3118  func TestDeepLeafMarshalTo(t *testing.T) {
  3119  	seed := time.Now().UnixNano()
  3120  	popr := math_rand.New(math_rand.NewSource(seed))
  3121  	p := NewPopulatedDeepLeaf(popr, false)
  3122  	size := p.Size()
  3123  	dAtA := make([]byte, size)
  3124  	for i := range dAtA {
  3125  		dAtA[i] = byte(popr.Intn(256))
  3126  	}
  3127  	_, err := p.MarshalTo(dAtA)
  3128  	if err != nil {
  3129  		t.Fatalf("seed = %d, err = %v", seed, err)
  3130  	}
  3131  	msg := &DeepLeaf{}
  3132  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3133  		t.Fatalf("seed = %d, err = %v", seed, err)
  3134  	}
  3135  	for i := range dAtA {
  3136  		dAtA[i] = byte(popr.Intn(256))
  3137  	}
  3138  	if err := p.VerboseEqual(msg); err != nil {
  3139  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3140  	}
  3141  	if !p.Equal(msg) {
  3142  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3143  	}
  3144  }
  3145  
  3146  func BenchmarkDeepLeafProtoMarshal(b *testing.B) {
  3147  	popr := math_rand.New(math_rand.NewSource(616))
  3148  	total := 0
  3149  	pops := make([]*DeepLeaf, 10000)
  3150  	for i := 0; i < 10000; i++ {
  3151  		pops[i] = NewPopulatedDeepLeaf(popr, false)
  3152  	}
  3153  	b.ResetTimer()
  3154  	for i := 0; i < b.N; i++ {
  3155  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3156  		if err != nil {
  3157  			panic(err)
  3158  		}
  3159  		total += len(dAtA)
  3160  	}
  3161  	b.SetBytes(int64(total / b.N))
  3162  }
  3163  
  3164  func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) {
  3165  	popr := math_rand.New(math_rand.NewSource(616))
  3166  	total := 0
  3167  	datas := make([][]byte, 10000)
  3168  	for i := 0; i < 10000; i++ {
  3169  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false))
  3170  		if err != nil {
  3171  			panic(err)
  3172  		}
  3173  		datas[i] = dAtA
  3174  	}
  3175  	msg := &DeepLeaf{}
  3176  	b.ResetTimer()
  3177  	for i := 0; i < b.N; i++ {
  3178  		total += len(datas[i%10000])
  3179  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3180  			panic(err)
  3181  		}
  3182  	}
  3183  	b.SetBytes(int64(total / b.N))
  3184  }
  3185  
  3186  func TestNilProto(t *testing.T) {
  3187  	seed := time.Now().UnixNano()
  3188  	popr := math_rand.New(math_rand.NewSource(seed))
  3189  	p := NewPopulatedNil(popr, false)
  3190  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3191  	if err != nil {
  3192  		t.Fatalf("seed = %d, err = %v", seed, err)
  3193  	}
  3194  	msg := &Nil{}
  3195  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3196  		t.Fatalf("seed = %d, err = %v", seed, err)
  3197  	}
  3198  	littlefuzz := make([]byte, len(dAtA))
  3199  	copy(littlefuzz, dAtA)
  3200  	for i := range dAtA {
  3201  		dAtA[i] = byte(popr.Intn(256))
  3202  	}
  3203  	if err := p.VerboseEqual(msg); err != nil {
  3204  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3205  	}
  3206  	if !p.Equal(msg) {
  3207  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3208  	}
  3209  	if len(littlefuzz) > 0 {
  3210  		fuzzamount := 100
  3211  		for i := 0; i < fuzzamount; i++ {
  3212  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3213  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3214  		}
  3215  		// shouldn't panic
  3216  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3217  	}
  3218  }
  3219  
  3220  func TestNilMarshalTo(t *testing.T) {
  3221  	seed := time.Now().UnixNano()
  3222  	popr := math_rand.New(math_rand.NewSource(seed))
  3223  	p := NewPopulatedNil(popr, false)
  3224  	size := p.Size()
  3225  	dAtA := make([]byte, size)
  3226  	for i := range dAtA {
  3227  		dAtA[i] = byte(popr.Intn(256))
  3228  	}
  3229  	_, err := p.MarshalTo(dAtA)
  3230  	if err != nil {
  3231  		t.Fatalf("seed = %d, err = %v", seed, err)
  3232  	}
  3233  	msg := &Nil{}
  3234  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3235  		t.Fatalf("seed = %d, err = %v", seed, err)
  3236  	}
  3237  	for i := range dAtA {
  3238  		dAtA[i] = byte(popr.Intn(256))
  3239  	}
  3240  	if err := p.VerboseEqual(msg); err != nil {
  3241  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3242  	}
  3243  	if !p.Equal(msg) {
  3244  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3245  	}
  3246  }
  3247  
  3248  func BenchmarkNilProtoMarshal(b *testing.B) {
  3249  	popr := math_rand.New(math_rand.NewSource(616))
  3250  	total := 0
  3251  	pops := make([]*Nil, 10000)
  3252  	for i := 0; i < 10000; i++ {
  3253  		pops[i] = NewPopulatedNil(popr, false)
  3254  	}
  3255  	b.ResetTimer()
  3256  	for i := 0; i < b.N; i++ {
  3257  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3258  		if err != nil {
  3259  			panic(err)
  3260  		}
  3261  		total += len(dAtA)
  3262  	}
  3263  	b.SetBytes(int64(total / b.N))
  3264  }
  3265  
  3266  func BenchmarkNilProtoUnmarshal(b *testing.B) {
  3267  	popr := math_rand.New(math_rand.NewSource(616))
  3268  	total := 0
  3269  	datas := make([][]byte, 10000)
  3270  	for i := 0; i < 10000; i++ {
  3271  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false))
  3272  		if err != nil {
  3273  			panic(err)
  3274  		}
  3275  		datas[i] = dAtA
  3276  	}
  3277  	msg := &Nil{}
  3278  	b.ResetTimer()
  3279  	for i := 0; i < b.N; i++ {
  3280  		total += len(datas[i%10000])
  3281  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3282  			panic(err)
  3283  		}
  3284  	}
  3285  	b.SetBytes(int64(total / b.N))
  3286  }
  3287  
  3288  func TestNidOptEnumProto(t *testing.T) {
  3289  	seed := time.Now().UnixNano()
  3290  	popr := math_rand.New(math_rand.NewSource(seed))
  3291  	p := NewPopulatedNidOptEnum(popr, false)
  3292  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3293  	if err != nil {
  3294  		t.Fatalf("seed = %d, err = %v", seed, err)
  3295  	}
  3296  	msg := &NidOptEnum{}
  3297  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3298  		t.Fatalf("seed = %d, err = %v", seed, err)
  3299  	}
  3300  	littlefuzz := make([]byte, len(dAtA))
  3301  	copy(littlefuzz, dAtA)
  3302  	for i := range dAtA {
  3303  		dAtA[i] = byte(popr.Intn(256))
  3304  	}
  3305  	if err := p.VerboseEqual(msg); err != nil {
  3306  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3307  	}
  3308  	if !p.Equal(msg) {
  3309  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3310  	}
  3311  	if len(littlefuzz) > 0 {
  3312  		fuzzamount := 100
  3313  		for i := 0; i < fuzzamount; i++ {
  3314  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3315  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3316  		}
  3317  		// shouldn't panic
  3318  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3319  	}
  3320  }
  3321  
  3322  func TestNidOptEnumMarshalTo(t *testing.T) {
  3323  	seed := time.Now().UnixNano()
  3324  	popr := math_rand.New(math_rand.NewSource(seed))
  3325  	p := NewPopulatedNidOptEnum(popr, false)
  3326  	size := p.Size()
  3327  	dAtA := make([]byte, size)
  3328  	for i := range dAtA {
  3329  		dAtA[i] = byte(popr.Intn(256))
  3330  	}
  3331  	_, err := p.MarshalTo(dAtA)
  3332  	if err != nil {
  3333  		t.Fatalf("seed = %d, err = %v", seed, err)
  3334  	}
  3335  	msg := &NidOptEnum{}
  3336  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3337  		t.Fatalf("seed = %d, err = %v", seed, err)
  3338  	}
  3339  	for i := range dAtA {
  3340  		dAtA[i] = byte(popr.Intn(256))
  3341  	}
  3342  	if err := p.VerboseEqual(msg); err != nil {
  3343  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3344  	}
  3345  	if !p.Equal(msg) {
  3346  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3347  	}
  3348  }
  3349  
  3350  func BenchmarkNidOptEnumProtoMarshal(b *testing.B) {
  3351  	popr := math_rand.New(math_rand.NewSource(616))
  3352  	total := 0
  3353  	pops := make([]*NidOptEnum, 10000)
  3354  	for i := 0; i < 10000; i++ {
  3355  		pops[i] = NewPopulatedNidOptEnum(popr, false)
  3356  	}
  3357  	b.ResetTimer()
  3358  	for i := 0; i < b.N; i++ {
  3359  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3360  		if err != nil {
  3361  			panic(err)
  3362  		}
  3363  		total += len(dAtA)
  3364  	}
  3365  	b.SetBytes(int64(total / b.N))
  3366  }
  3367  
  3368  func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) {
  3369  	popr := math_rand.New(math_rand.NewSource(616))
  3370  	total := 0
  3371  	datas := make([][]byte, 10000)
  3372  	for i := 0; i < 10000; i++ {
  3373  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false))
  3374  		if err != nil {
  3375  			panic(err)
  3376  		}
  3377  		datas[i] = dAtA
  3378  	}
  3379  	msg := &NidOptEnum{}
  3380  	b.ResetTimer()
  3381  	for i := 0; i < b.N; i++ {
  3382  		total += len(datas[i%10000])
  3383  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3384  			panic(err)
  3385  		}
  3386  	}
  3387  	b.SetBytes(int64(total / b.N))
  3388  }
  3389  
  3390  func TestNinOptEnumProto(t *testing.T) {
  3391  	seed := time.Now().UnixNano()
  3392  	popr := math_rand.New(math_rand.NewSource(seed))
  3393  	p := NewPopulatedNinOptEnum(popr, false)
  3394  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3395  	if err != nil {
  3396  		t.Fatalf("seed = %d, err = %v", seed, err)
  3397  	}
  3398  	msg := &NinOptEnum{}
  3399  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3400  		t.Fatalf("seed = %d, err = %v", seed, err)
  3401  	}
  3402  	littlefuzz := make([]byte, len(dAtA))
  3403  	copy(littlefuzz, dAtA)
  3404  	for i := range dAtA {
  3405  		dAtA[i] = byte(popr.Intn(256))
  3406  	}
  3407  	if err := p.VerboseEqual(msg); err != nil {
  3408  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3409  	}
  3410  	if !p.Equal(msg) {
  3411  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3412  	}
  3413  	if len(littlefuzz) > 0 {
  3414  		fuzzamount := 100
  3415  		for i := 0; i < fuzzamount; i++ {
  3416  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3417  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3418  		}
  3419  		// shouldn't panic
  3420  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3421  	}
  3422  }
  3423  
  3424  func TestNinOptEnumMarshalTo(t *testing.T) {
  3425  	seed := time.Now().UnixNano()
  3426  	popr := math_rand.New(math_rand.NewSource(seed))
  3427  	p := NewPopulatedNinOptEnum(popr, false)
  3428  	size := p.Size()
  3429  	dAtA := make([]byte, size)
  3430  	for i := range dAtA {
  3431  		dAtA[i] = byte(popr.Intn(256))
  3432  	}
  3433  	_, err := p.MarshalTo(dAtA)
  3434  	if err != nil {
  3435  		t.Fatalf("seed = %d, err = %v", seed, err)
  3436  	}
  3437  	msg := &NinOptEnum{}
  3438  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3439  		t.Fatalf("seed = %d, err = %v", seed, err)
  3440  	}
  3441  	for i := range dAtA {
  3442  		dAtA[i] = byte(popr.Intn(256))
  3443  	}
  3444  	if err := p.VerboseEqual(msg); err != nil {
  3445  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3446  	}
  3447  	if !p.Equal(msg) {
  3448  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3449  	}
  3450  }
  3451  
  3452  func BenchmarkNinOptEnumProtoMarshal(b *testing.B) {
  3453  	popr := math_rand.New(math_rand.NewSource(616))
  3454  	total := 0
  3455  	pops := make([]*NinOptEnum, 10000)
  3456  	for i := 0; i < 10000; i++ {
  3457  		pops[i] = NewPopulatedNinOptEnum(popr, false)
  3458  	}
  3459  	b.ResetTimer()
  3460  	for i := 0; i < b.N; i++ {
  3461  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3462  		if err != nil {
  3463  			panic(err)
  3464  		}
  3465  		total += len(dAtA)
  3466  	}
  3467  	b.SetBytes(int64(total / b.N))
  3468  }
  3469  
  3470  func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) {
  3471  	popr := math_rand.New(math_rand.NewSource(616))
  3472  	total := 0
  3473  	datas := make([][]byte, 10000)
  3474  	for i := 0; i < 10000; i++ {
  3475  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false))
  3476  		if err != nil {
  3477  			panic(err)
  3478  		}
  3479  		datas[i] = dAtA
  3480  	}
  3481  	msg := &NinOptEnum{}
  3482  	b.ResetTimer()
  3483  	for i := 0; i < b.N; i++ {
  3484  		total += len(datas[i%10000])
  3485  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3486  			panic(err)
  3487  		}
  3488  	}
  3489  	b.SetBytes(int64(total / b.N))
  3490  }
  3491  
  3492  func TestNidRepEnumProto(t *testing.T) {
  3493  	seed := time.Now().UnixNano()
  3494  	popr := math_rand.New(math_rand.NewSource(seed))
  3495  	p := NewPopulatedNidRepEnum(popr, false)
  3496  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3497  	if err != nil {
  3498  		t.Fatalf("seed = %d, err = %v", seed, err)
  3499  	}
  3500  	msg := &NidRepEnum{}
  3501  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3502  		t.Fatalf("seed = %d, err = %v", seed, err)
  3503  	}
  3504  	littlefuzz := make([]byte, len(dAtA))
  3505  	copy(littlefuzz, dAtA)
  3506  	for i := range dAtA {
  3507  		dAtA[i] = byte(popr.Intn(256))
  3508  	}
  3509  	if err := p.VerboseEqual(msg); err != nil {
  3510  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3511  	}
  3512  	if !p.Equal(msg) {
  3513  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3514  	}
  3515  	if len(littlefuzz) > 0 {
  3516  		fuzzamount := 100
  3517  		for i := 0; i < fuzzamount; i++ {
  3518  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3519  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3520  		}
  3521  		// shouldn't panic
  3522  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3523  	}
  3524  }
  3525  
  3526  func TestNidRepEnumMarshalTo(t *testing.T) {
  3527  	seed := time.Now().UnixNano()
  3528  	popr := math_rand.New(math_rand.NewSource(seed))
  3529  	p := NewPopulatedNidRepEnum(popr, false)
  3530  	size := p.Size()
  3531  	dAtA := make([]byte, size)
  3532  	for i := range dAtA {
  3533  		dAtA[i] = byte(popr.Intn(256))
  3534  	}
  3535  	_, err := p.MarshalTo(dAtA)
  3536  	if err != nil {
  3537  		t.Fatalf("seed = %d, err = %v", seed, err)
  3538  	}
  3539  	msg := &NidRepEnum{}
  3540  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3541  		t.Fatalf("seed = %d, err = %v", seed, err)
  3542  	}
  3543  	for i := range dAtA {
  3544  		dAtA[i] = byte(popr.Intn(256))
  3545  	}
  3546  	if err := p.VerboseEqual(msg); err != nil {
  3547  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3548  	}
  3549  	if !p.Equal(msg) {
  3550  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3551  	}
  3552  }
  3553  
  3554  func BenchmarkNidRepEnumProtoMarshal(b *testing.B) {
  3555  	popr := math_rand.New(math_rand.NewSource(616))
  3556  	total := 0
  3557  	pops := make([]*NidRepEnum, 10000)
  3558  	for i := 0; i < 10000; i++ {
  3559  		pops[i] = NewPopulatedNidRepEnum(popr, false)
  3560  	}
  3561  	b.ResetTimer()
  3562  	for i := 0; i < b.N; i++ {
  3563  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3564  		if err != nil {
  3565  			panic(err)
  3566  		}
  3567  		total += len(dAtA)
  3568  	}
  3569  	b.SetBytes(int64(total / b.N))
  3570  }
  3571  
  3572  func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) {
  3573  	popr := math_rand.New(math_rand.NewSource(616))
  3574  	total := 0
  3575  	datas := make([][]byte, 10000)
  3576  	for i := 0; i < 10000; i++ {
  3577  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false))
  3578  		if err != nil {
  3579  			panic(err)
  3580  		}
  3581  		datas[i] = dAtA
  3582  	}
  3583  	msg := &NidRepEnum{}
  3584  	b.ResetTimer()
  3585  	for i := 0; i < b.N; i++ {
  3586  		total += len(datas[i%10000])
  3587  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3588  			panic(err)
  3589  		}
  3590  	}
  3591  	b.SetBytes(int64(total / b.N))
  3592  }
  3593  
  3594  func TestNinRepEnumProto(t *testing.T) {
  3595  	seed := time.Now().UnixNano()
  3596  	popr := math_rand.New(math_rand.NewSource(seed))
  3597  	p := NewPopulatedNinRepEnum(popr, false)
  3598  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3599  	if err != nil {
  3600  		t.Fatalf("seed = %d, err = %v", seed, err)
  3601  	}
  3602  	msg := &NinRepEnum{}
  3603  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3604  		t.Fatalf("seed = %d, err = %v", seed, err)
  3605  	}
  3606  	littlefuzz := make([]byte, len(dAtA))
  3607  	copy(littlefuzz, dAtA)
  3608  	for i := range dAtA {
  3609  		dAtA[i] = byte(popr.Intn(256))
  3610  	}
  3611  	if err := p.VerboseEqual(msg); err != nil {
  3612  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3613  	}
  3614  	if !p.Equal(msg) {
  3615  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3616  	}
  3617  	if len(littlefuzz) > 0 {
  3618  		fuzzamount := 100
  3619  		for i := 0; i < fuzzamount; i++ {
  3620  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3621  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3622  		}
  3623  		// shouldn't panic
  3624  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3625  	}
  3626  }
  3627  
  3628  func TestNinRepEnumMarshalTo(t *testing.T) {
  3629  	seed := time.Now().UnixNano()
  3630  	popr := math_rand.New(math_rand.NewSource(seed))
  3631  	p := NewPopulatedNinRepEnum(popr, false)
  3632  	size := p.Size()
  3633  	dAtA := make([]byte, size)
  3634  	for i := range dAtA {
  3635  		dAtA[i] = byte(popr.Intn(256))
  3636  	}
  3637  	_, err := p.MarshalTo(dAtA)
  3638  	if err != nil {
  3639  		t.Fatalf("seed = %d, err = %v", seed, err)
  3640  	}
  3641  	msg := &NinRepEnum{}
  3642  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3643  		t.Fatalf("seed = %d, err = %v", seed, err)
  3644  	}
  3645  	for i := range dAtA {
  3646  		dAtA[i] = byte(popr.Intn(256))
  3647  	}
  3648  	if err := p.VerboseEqual(msg); err != nil {
  3649  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3650  	}
  3651  	if !p.Equal(msg) {
  3652  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3653  	}
  3654  }
  3655  
  3656  func BenchmarkNinRepEnumProtoMarshal(b *testing.B) {
  3657  	popr := math_rand.New(math_rand.NewSource(616))
  3658  	total := 0
  3659  	pops := make([]*NinRepEnum, 10000)
  3660  	for i := 0; i < 10000; i++ {
  3661  		pops[i] = NewPopulatedNinRepEnum(popr, false)
  3662  	}
  3663  	b.ResetTimer()
  3664  	for i := 0; i < b.N; i++ {
  3665  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3666  		if err != nil {
  3667  			panic(err)
  3668  		}
  3669  		total += len(dAtA)
  3670  	}
  3671  	b.SetBytes(int64(total / b.N))
  3672  }
  3673  
  3674  func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) {
  3675  	popr := math_rand.New(math_rand.NewSource(616))
  3676  	total := 0
  3677  	datas := make([][]byte, 10000)
  3678  	for i := 0; i < 10000; i++ {
  3679  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false))
  3680  		if err != nil {
  3681  			panic(err)
  3682  		}
  3683  		datas[i] = dAtA
  3684  	}
  3685  	msg := &NinRepEnum{}
  3686  	b.ResetTimer()
  3687  	for i := 0; i < b.N; i++ {
  3688  		total += len(datas[i%10000])
  3689  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3690  			panic(err)
  3691  		}
  3692  	}
  3693  	b.SetBytes(int64(total / b.N))
  3694  }
  3695  
  3696  func TestNinOptEnumDefaultProto(t *testing.T) {
  3697  	seed := time.Now().UnixNano()
  3698  	popr := math_rand.New(math_rand.NewSource(seed))
  3699  	p := NewPopulatedNinOptEnumDefault(popr, false)
  3700  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3701  	if err != nil {
  3702  		t.Fatalf("seed = %d, err = %v", seed, err)
  3703  	}
  3704  	msg := &NinOptEnumDefault{}
  3705  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3706  		t.Fatalf("seed = %d, err = %v", seed, err)
  3707  	}
  3708  	littlefuzz := make([]byte, len(dAtA))
  3709  	copy(littlefuzz, dAtA)
  3710  	for i := range dAtA {
  3711  		dAtA[i] = byte(popr.Intn(256))
  3712  	}
  3713  	if err := p.VerboseEqual(msg); err != nil {
  3714  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3715  	}
  3716  	if !p.Equal(msg) {
  3717  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3718  	}
  3719  	if len(littlefuzz) > 0 {
  3720  		fuzzamount := 100
  3721  		for i := 0; i < fuzzamount; i++ {
  3722  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3723  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3724  		}
  3725  		// shouldn't panic
  3726  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3727  	}
  3728  }
  3729  
  3730  func TestNinOptEnumDefaultMarshalTo(t *testing.T) {
  3731  	seed := time.Now().UnixNano()
  3732  	popr := math_rand.New(math_rand.NewSource(seed))
  3733  	p := NewPopulatedNinOptEnumDefault(popr, false)
  3734  	size := p.Size()
  3735  	dAtA := make([]byte, size)
  3736  	for i := range dAtA {
  3737  		dAtA[i] = byte(popr.Intn(256))
  3738  	}
  3739  	_, err := p.MarshalTo(dAtA)
  3740  	if err != nil {
  3741  		t.Fatalf("seed = %d, err = %v", seed, err)
  3742  	}
  3743  	msg := &NinOptEnumDefault{}
  3744  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3745  		t.Fatalf("seed = %d, err = %v", seed, err)
  3746  	}
  3747  	for i := range dAtA {
  3748  		dAtA[i] = byte(popr.Intn(256))
  3749  	}
  3750  	if err := p.VerboseEqual(msg); err != nil {
  3751  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3752  	}
  3753  	if !p.Equal(msg) {
  3754  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3755  	}
  3756  }
  3757  
  3758  func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) {
  3759  	popr := math_rand.New(math_rand.NewSource(616))
  3760  	total := 0
  3761  	pops := make([]*NinOptEnumDefault, 10000)
  3762  	for i := 0; i < 10000; i++ {
  3763  		pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
  3764  	}
  3765  	b.ResetTimer()
  3766  	for i := 0; i < b.N; i++ {
  3767  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3768  		if err != nil {
  3769  			panic(err)
  3770  		}
  3771  		total += len(dAtA)
  3772  	}
  3773  	b.SetBytes(int64(total / b.N))
  3774  }
  3775  
  3776  func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
  3777  	popr := math_rand.New(math_rand.NewSource(616))
  3778  	total := 0
  3779  	datas := make([][]byte, 10000)
  3780  	for i := 0; i < 10000; i++ {
  3781  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false))
  3782  		if err != nil {
  3783  			panic(err)
  3784  		}
  3785  		datas[i] = dAtA
  3786  	}
  3787  	msg := &NinOptEnumDefault{}
  3788  	b.ResetTimer()
  3789  	for i := 0; i < b.N; i++ {
  3790  		total += len(datas[i%10000])
  3791  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3792  			panic(err)
  3793  		}
  3794  	}
  3795  	b.SetBytes(int64(total / b.N))
  3796  }
  3797  
  3798  func TestAnotherNinOptEnumProto(t *testing.T) {
  3799  	seed := time.Now().UnixNano()
  3800  	popr := math_rand.New(math_rand.NewSource(seed))
  3801  	p := NewPopulatedAnotherNinOptEnum(popr, false)
  3802  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3803  	if err != nil {
  3804  		t.Fatalf("seed = %d, err = %v", seed, err)
  3805  	}
  3806  	msg := &AnotherNinOptEnum{}
  3807  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3808  		t.Fatalf("seed = %d, err = %v", seed, err)
  3809  	}
  3810  	littlefuzz := make([]byte, len(dAtA))
  3811  	copy(littlefuzz, dAtA)
  3812  	for i := range dAtA {
  3813  		dAtA[i] = byte(popr.Intn(256))
  3814  	}
  3815  	if err := p.VerboseEqual(msg); err != nil {
  3816  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3817  	}
  3818  	if !p.Equal(msg) {
  3819  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3820  	}
  3821  	if len(littlefuzz) > 0 {
  3822  		fuzzamount := 100
  3823  		for i := 0; i < fuzzamount; i++ {
  3824  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3825  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3826  		}
  3827  		// shouldn't panic
  3828  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3829  	}
  3830  }
  3831  
  3832  func TestAnotherNinOptEnumMarshalTo(t *testing.T) {
  3833  	seed := time.Now().UnixNano()
  3834  	popr := math_rand.New(math_rand.NewSource(seed))
  3835  	p := NewPopulatedAnotherNinOptEnum(popr, false)
  3836  	size := p.Size()
  3837  	dAtA := make([]byte, size)
  3838  	for i := range dAtA {
  3839  		dAtA[i] = byte(popr.Intn(256))
  3840  	}
  3841  	_, err := p.MarshalTo(dAtA)
  3842  	if err != nil {
  3843  		t.Fatalf("seed = %d, err = %v", seed, err)
  3844  	}
  3845  	msg := &AnotherNinOptEnum{}
  3846  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3847  		t.Fatalf("seed = %d, err = %v", seed, err)
  3848  	}
  3849  	for i := range dAtA {
  3850  		dAtA[i] = byte(popr.Intn(256))
  3851  	}
  3852  	if err := p.VerboseEqual(msg); err != nil {
  3853  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3854  	}
  3855  	if !p.Equal(msg) {
  3856  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3857  	}
  3858  }
  3859  
  3860  func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) {
  3861  	popr := math_rand.New(math_rand.NewSource(616))
  3862  	total := 0
  3863  	pops := make([]*AnotherNinOptEnum, 10000)
  3864  	for i := 0; i < 10000; i++ {
  3865  		pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
  3866  	}
  3867  	b.ResetTimer()
  3868  	for i := 0; i < b.N; i++ {
  3869  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3870  		if err != nil {
  3871  			panic(err)
  3872  		}
  3873  		total += len(dAtA)
  3874  	}
  3875  	b.SetBytes(int64(total / b.N))
  3876  }
  3877  
  3878  func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) {
  3879  	popr := math_rand.New(math_rand.NewSource(616))
  3880  	total := 0
  3881  	datas := make([][]byte, 10000)
  3882  	for i := 0; i < 10000; i++ {
  3883  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false))
  3884  		if err != nil {
  3885  			panic(err)
  3886  		}
  3887  		datas[i] = dAtA
  3888  	}
  3889  	msg := &AnotherNinOptEnum{}
  3890  	b.ResetTimer()
  3891  	for i := 0; i < b.N; i++ {
  3892  		total += len(datas[i%10000])
  3893  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3894  			panic(err)
  3895  		}
  3896  	}
  3897  	b.SetBytes(int64(total / b.N))
  3898  }
  3899  
  3900  func TestAnotherNinOptEnumDefaultProto(t *testing.T) {
  3901  	seed := time.Now().UnixNano()
  3902  	popr := math_rand.New(math_rand.NewSource(seed))
  3903  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
  3904  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3905  	if err != nil {
  3906  		t.Fatalf("seed = %d, err = %v", seed, err)
  3907  	}
  3908  	msg := &AnotherNinOptEnumDefault{}
  3909  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3910  		t.Fatalf("seed = %d, err = %v", seed, err)
  3911  	}
  3912  	littlefuzz := make([]byte, len(dAtA))
  3913  	copy(littlefuzz, dAtA)
  3914  	for i := range dAtA {
  3915  		dAtA[i] = byte(popr.Intn(256))
  3916  	}
  3917  	if err := p.VerboseEqual(msg); err != nil {
  3918  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3919  	}
  3920  	if !p.Equal(msg) {
  3921  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3922  	}
  3923  	if len(littlefuzz) > 0 {
  3924  		fuzzamount := 100
  3925  		for i := 0; i < fuzzamount; i++ {
  3926  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3927  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3928  		}
  3929  		// shouldn't panic
  3930  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3931  	}
  3932  }
  3933  
  3934  func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) {
  3935  	seed := time.Now().UnixNano()
  3936  	popr := math_rand.New(math_rand.NewSource(seed))
  3937  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
  3938  	size := p.Size()
  3939  	dAtA := make([]byte, size)
  3940  	for i := range dAtA {
  3941  		dAtA[i] = byte(popr.Intn(256))
  3942  	}
  3943  	_, err := p.MarshalTo(dAtA)
  3944  	if err != nil {
  3945  		t.Fatalf("seed = %d, err = %v", seed, err)
  3946  	}
  3947  	msg := &AnotherNinOptEnumDefault{}
  3948  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3949  		t.Fatalf("seed = %d, err = %v", seed, err)
  3950  	}
  3951  	for i := range dAtA {
  3952  		dAtA[i] = byte(popr.Intn(256))
  3953  	}
  3954  	if err := p.VerboseEqual(msg); err != nil {
  3955  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3956  	}
  3957  	if !p.Equal(msg) {
  3958  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3959  	}
  3960  }
  3961  
  3962  func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) {
  3963  	popr := math_rand.New(math_rand.NewSource(616))
  3964  	total := 0
  3965  	pops := make([]*AnotherNinOptEnumDefault, 10000)
  3966  	for i := 0; i < 10000; i++ {
  3967  		pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
  3968  	}
  3969  	b.ResetTimer()
  3970  	for i := 0; i < b.N; i++ {
  3971  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3972  		if err != nil {
  3973  			panic(err)
  3974  		}
  3975  		total += len(dAtA)
  3976  	}
  3977  	b.SetBytes(int64(total / b.N))
  3978  }
  3979  
  3980  func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
  3981  	popr := math_rand.New(math_rand.NewSource(616))
  3982  	total := 0
  3983  	datas := make([][]byte, 10000)
  3984  	for i := 0; i < 10000; i++ {
  3985  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false))
  3986  		if err != nil {
  3987  			panic(err)
  3988  		}
  3989  		datas[i] = dAtA
  3990  	}
  3991  	msg := &AnotherNinOptEnumDefault{}
  3992  	b.ResetTimer()
  3993  	for i := 0; i < b.N; i++ {
  3994  		total += len(datas[i%10000])
  3995  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3996  			panic(err)
  3997  		}
  3998  	}
  3999  	b.SetBytes(int64(total / b.N))
  4000  }
  4001  
  4002  func TestTimerProto(t *testing.T) {
  4003  	seed := time.Now().UnixNano()
  4004  	popr := math_rand.New(math_rand.NewSource(seed))
  4005  	p := NewPopulatedTimer(popr, false)
  4006  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4007  	if err != nil {
  4008  		t.Fatalf("seed = %d, err = %v", seed, err)
  4009  	}
  4010  	msg := &Timer{}
  4011  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4012  		t.Fatalf("seed = %d, err = %v", seed, err)
  4013  	}
  4014  	littlefuzz := make([]byte, len(dAtA))
  4015  	copy(littlefuzz, dAtA)
  4016  	for i := range dAtA {
  4017  		dAtA[i] = byte(popr.Intn(256))
  4018  	}
  4019  	if err := p.VerboseEqual(msg); err != nil {
  4020  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4021  	}
  4022  	if !p.Equal(msg) {
  4023  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4024  	}
  4025  	if len(littlefuzz) > 0 {
  4026  		fuzzamount := 100
  4027  		for i := 0; i < fuzzamount; i++ {
  4028  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4029  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4030  		}
  4031  		// shouldn't panic
  4032  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4033  	}
  4034  }
  4035  
  4036  func TestTimerMarshalTo(t *testing.T) {
  4037  	seed := time.Now().UnixNano()
  4038  	popr := math_rand.New(math_rand.NewSource(seed))
  4039  	p := NewPopulatedTimer(popr, false)
  4040  	size := p.Size()
  4041  	dAtA := make([]byte, size)
  4042  	for i := range dAtA {
  4043  		dAtA[i] = byte(popr.Intn(256))
  4044  	}
  4045  	_, err := p.MarshalTo(dAtA)
  4046  	if err != nil {
  4047  		t.Fatalf("seed = %d, err = %v", seed, err)
  4048  	}
  4049  	msg := &Timer{}
  4050  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4051  		t.Fatalf("seed = %d, err = %v", seed, err)
  4052  	}
  4053  	for i := range dAtA {
  4054  		dAtA[i] = byte(popr.Intn(256))
  4055  	}
  4056  	if err := p.VerboseEqual(msg); err != nil {
  4057  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4058  	}
  4059  	if !p.Equal(msg) {
  4060  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4061  	}
  4062  }
  4063  
  4064  func BenchmarkTimerProtoMarshal(b *testing.B) {
  4065  	popr := math_rand.New(math_rand.NewSource(616))
  4066  	total := 0
  4067  	pops := make([]*Timer, 10000)
  4068  	for i := 0; i < 10000; i++ {
  4069  		pops[i] = NewPopulatedTimer(popr, false)
  4070  	}
  4071  	b.ResetTimer()
  4072  	for i := 0; i < b.N; i++ {
  4073  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4074  		if err != nil {
  4075  			panic(err)
  4076  		}
  4077  		total += len(dAtA)
  4078  	}
  4079  	b.SetBytes(int64(total / b.N))
  4080  }
  4081  
  4082  func BenchmarkTimerProtoUnmarshal(b *testing.B) {
  4083  	popr := math_rand.New(math_rand.NewSource(616))
  4084  	total := 0
  4085  	datas := make([][]byte, 10000)
  4086  	for i := 0; i < 10000; i++ {
  4087  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false))
  4088  		if err != nil {
  4089  			panic(err)
  4090  		}
  4091  		datas[i] = dAtA
  4092  	}
  4093  	msg := &Timer{}
  4094  	b.ResetTimer()
  4095  	for i := 0; i < b.N; i++ {
  4096  		total += len(datas[i%10000])
  4097  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4098  			panic(err)
  4099  		}
  4100  	}
  4101  	b.SetBytes(int64(total / b.N))
  4102  }
  4103  
  4104  func TestMyExtendableProto(t *testing.T) {
  4105  	seed := time.Now().UnixNano()
  4106  	popr := math_rand.New(math_rand.NewSource(seed))
  4107  	p := NewPopulatedMyExtendable(popr, false)
  4108  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4109  	if err != nil {
  4110  		t.Fatalf("seed = %d, err = %v", seed, err)
  4111  	}
  4112  	msg := &MyExtendable{}
  4113  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4114  		t.Fatalf("seed = %d, err = %v", seed, err)
  4115  	}
  4116  	littlefuzz := make([]byte, len(dAtA))
  4117  	copy(littlefuzz, dAtA)
  4118  	for i := range dAtA {
  4119  		dAtA[i] = byte(popr.Intn(256))
  4120  	}
  4121  	if err := p.VerboseEqual(msg); err != nil {
  4122  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4123  	}
  4124  	if !p.Equal(msg) {
  4125  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4126  	}
  4127  	if len(littlefuzz) > 0 {
  4128  		fuzzamount := 100
  4129  		for i := 0; i < fuzzamount; i++ {
  4130  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4131  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4132  		}
  4133  		// shouldn't panic
  4134  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4135  	}
  4136  }
  4137  
  4138  func TestMyExtendableMarshalTo(t *testing.T) {
  4139  	seed := time.Now().UnixNano()
  4140  	popr := math_rand.New(math_rand.NewSource(seed))
  4141  	p := NewPopulatedMyExtendable(popr, false)
  4142  	size := p.Size()
  4143  	dAtA := make([]byte, size)
  4144  	for i := range dAtA {
  4145  		dAtA[i] = byte(popr.Intn(256))
  4146  	}
  4147  	_, err := p.MarshalTo(dAtA)
  4148  	if err != nil {
  4149  		t.Fatalf("seed = %d, err = %v", seed, err)
  4150  	}
  4151  	msg := &MyExtendable{}
  4152  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4153  		t.Fatalf("seed = %d, err = %v", seed, err)
  4154  	}
  4155  	for i := range dAtA {
  4156  		dAtA[i] = byte(popr.Intn(256))
  4157  	}
  4158  	if err := p.VerboseEqual(msg); err != nil {
  4159  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4160  	}
  4161  	if !p.Equal(msg) {
  4162  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4163  	}
  4164  }
  4165  
  4166  func BenchmarkMyExtendableProtoMarshal(b *testing.B) {
  4167  	popr := math_rand.New(math_rand.NewSource(616))
  4168  	total := 0
  4169  	pops := make([]*MyExtendable, 10000)
  4170  	for i := 0; i < 10000; i++ {
  4171  		pops[i] = NewPopulatedMyExtendable(popr, false)
  4172  	}
  4173  	b.ResetTimer()
  4174  	for i := 0; i < b.N; i++ {
  4175  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4176  		if err != nil {
  4177  			panic(err)
  4178  		}
  4179  		total += len(dAtA)
  4180  	}
  4181  	b.SetBytes(int64(total / b.N))
  4182  }
  4183  
  4184  func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) {
  4185  	popr := math_rand.New(math_rand.NewSource(616))
  4186  	total := 0
  4187  	datas := make([][]byte, 10000)
  4188  	for i := 0; i < 10000; i++ {
  4189  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false))
  4190  		if err != nil {
  4191  			panic(err)
  4192  		}
  4193  		datas[i] = dAtA
  4194  	}
  4195  	msg := &MyExtendable{}
  4196  	b.ResetTimer()
  4197  	for i := 0; i < b.N; i++ {
  4198  		total += len(datas[i%10000])
  4199  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4200  			panic(err)
  4201  		}
  4202  	}
  4203  	b.SetBytes(int64(total / b.N))
  4204  }
  4205  
  4206  func TestOtherExtenableProto(t *testing.T) {
  4207  	seed := time.Now().UnixNano()
  4208  	popr := math_rand.New(math_rand.NewSource(seed))
  4209  	p := NewPopulatedOtherExtenable(popr, false)
  4210  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4211  	if err != nil {
  4212  		t.Fatalf("seed = %d, err = %v", seed, err)
  4213  	}
  4214  	msg := &OtherExtenable{}
  4215  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4216  		t.Fatalf("seed = %d, err = %v", seed, err)
  4217  	}
  4218  	littlefuzz := make([]byte, len(dAtA))
  4219  	copy(littlefuzz, dAtA)
  4220  	for i := range dAtA {
  4221  		dAtA[i] = byte(popr.Intn(256))
  4222  	}
  4223  	if err := p.VerboseEqual(msg); err != nil {
  4224  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4225  	}
  4226  	if !p.Equal(msg) {
  4227  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4228  	}
  4229  	if len(littlefuzz) > 0 {
  4230  		fuzzamount := 100
  4231  		for i := 0; i < fuzzamount; i++ {
  4232  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4233  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4234  		}
  4235  		// shouldn't panic
  4236  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4237  	}
  4238  }
  4239  
  4240  func TestOtherExtenableMarshalTo(t *testing.T) {
  4241  	seed := time.Now().UnixNano()
  4242  	popr := math_rand.New(math_rand.NewSource(seed))
  4243  	p := NewPopulatedOtherExtenable(popr, false)
  4244  	size := p.Size()
  4245  	dAtA := make([]byte, size)
  4246  	for i := range dAtA {
  4247  		dAtA[i] = byte(popr.Intn(256))
  4248  	}
  4249  	_, err := p.MarshalTo(dAtA)
  4250  	if err != nil {
  4251  		t.Fatalf("seed = %d, err = %v", seed, err)
  4252  	}
  4253  	msg := &OtherExtenable{}
  4254  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4255  		t.Fatalf("seed = %d, err = %v", seed, err)
  4256  	}
  4257  	for i := range dAtA {
  4258  		dAtA[i] = byte(popr.Intn(256))
  4259  	}
  4260  	if err := p.VerboseEqual(msg); err != nil {
  4261  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4262  	}
  4263  	if !p.Equal(msg) {
  4264  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4265  	}
  4266  }
  4267  
  4268  func BenchmarkOtherExtenableProtoMarshal(b *testing.B) {
  4269  	popr := math_rand.New(math_rand.NewSource(616))
  4270  	total := 0
  4271  	pops := make([]*OtherExtenable, 10000)
  4272  	for i := 0; i < 10000; i++ {
  4273  		pops[i] = NewPopulatedOtherExtenable(popr, false)
  4274  	}
  4275  	b.ResetTimer()
  4276  	for i := 0; i < b.N; i++ {
  4277  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4278  		if err != nil {
  4279  			panic(err)
  4280  		}
  4281  		total += len(dAtA)
  4282  	}
  4283  	b.SetBytes(int64(total / b.N))
  4284  }
  4285  
  4286  func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) {
  4287  	popr := math_rand.New(math_rand.NewSource(616))
  4288  	total := 0
  4289  	datas := make([][]byte, 10000)
  4290  	for i := 0; i < 10000; i++ {
  4291  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false))
  4292  		if err != nil {
  4293  			panic(err)
  4294  		}
  4295  		datas[i] = dAtA
  4296  	}
  4297  	msg := &OtherExtenable{}
  4298  	b.ResetTimer()
  4299  	for i := 0; i < b.N; i++ {
  4300  		total += len(datas[i%10000])
  4301  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4302  			panic(err)
  4303  		}
  4304  	}
  4305  	b.SetBytes(int64(total / b.N))
  4306  }
  4307  
  4308  func TestNestedDefinitionProto(t *testing.T) {
  4309  	seed := time.Now().UnixNano()
  4310  	popr := math_rand.New(math_rand.NewSource(seed))
  4311  	p := NewPopulatedNestedDefinition(popr, false)
  4312  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4313  	if err != nil {
  4314  		t.Fatalf("seed = %d, err = %v", seed, err)
  4315  	}
  4316  	msg := &NestedDefinition{}
  4317  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4318  		t.Fatalf("seed = %d, err = %v", seed, err)
  4319  	}
  4320  	littlefuzz := make([]byte, len(dAtA))
  4321  	copy(littlefuzz, dAtA)
  4322  	for i := range dAtA {
  4323  		dAtA[i] = byte(popr.Intn(256))
  4324  	}
  4325  	if err := p.VerboseEqual(msg); err != nil {
  4326  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4327  	}
  4328  	if !p.Equal(msg) {
  4329  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4330  	}
  4331  	if len(littlefuzz) > 0 {
  4332  		fuzzamount := 100
  4333  		for i := 0; i < fuzzamount; i++ {
  4334  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4335  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4336  		}
  4337  		// shouldn't panic
  4338  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4339  	}
  4340  }
  4341  
  4342  func TestNestedDefinitionMarshalTo(t *testing.T) {
  4343  	seed := time.Now().UnixNano()
  4344  	popr := math_rand.New(math_rand.NewSource(seed))
  4345  	p := NewPopulatedNestedDefinition(popr, false)
  4346  	size := p.Size()
  4347  	dAtA := make([]byte, size)
  4348  	for i := range dAtA {
  4349  		dAtA[i] = byte(popr.Intn(256))
  4350  	}
  4351  	_, err := p.MarshalTo(dAtA)
  4352  	if err != nil {
  4353  		t.Fatalf("seed = %d, err = %v", seed, err)
  4354  	}
  4355  	msg := &NestedDefinition{}
  4356  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4357  		t.Fatalf("seed = %d, err = %v", seed, err)
  4358  	}
  4359  	for i := range dAtA {
  4360  		dAtA[i] = byte(popr.Intn(256))
  4361  	}
  4362  	if err := p.VerboseEqual(msg); err != nil {
  4363  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4364  	}
  4365  	if !p.Equal(msg) {
  4366  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4367  	}
  4368  }
  4369  
  4370  func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) {
  4371  	popr := math_rand.New(math_rand.NewSource(616))
  4372  	total := 0
  4373  	pops := make([]*NestedDefinition, 10000)
  4374  	for i := 0; i < 10000; i++ {
  4375  		pops[i] = NewPopulatedNestedDefinition(popr, false)
  4376  	}
  4377  	b.ResetTimer()
  4378  	for i := 0; i < b.N; i++ {
  4379  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4380  		if err != nil {
  4381  			panic(err)
  4382  		}
  4383  		total += len(dAtA)
  4384  	}
  4385  	b.SetBytes(int64(total / b.N))
  4386  }
  4387  
  4388  func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) {
  4389  	popr := math_rand.New(math_rand.NewSource(616))
  4390  	total := 0
  4391  	datas := make([][]byte, 10000)
  4392  	for i := 0; i < 10000; i++ {
  4393  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false))
  4394  		if err != nil {
  4395  			panic(err)
  4396  		}
  4397  		datas[i] = dAtA
  4398  	}
  4399  	msg := &NestedDefinition{}
  4400  	b.ResetTimer()
  4401  	for i := 0; i < b.N; i++ {
  4402  		total += len(datas[i%10000])
  4403  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4404  			panic(err)
  4405  		}
  4406  	}
  4407  	b.SetBytes(int64(total / b.N))
  4408  }
  4409  
  4410  func TestNestedDefinition_NestedMessageProto(t *testing.T) {
  4411  	seed := time.Now().UnixNano()
  4412  	popr := math_rand.New(math_rand.NewSource(seed))
  4413  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
  4414  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4415  	if err != nil {
  4416  		t.Fatalf("seed = %d, err = %v", seed, err)
  4417  	}
  4418  	msg := &NestedDefinition_NestedMessage{}
  4419  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4420  		t.Fatalf("seed = %d, err = %v", seed, err)
  4421  	}
  4422  	littlefuzz := make([]byte, len(dAtA))
  4423  	copy(littlefuzz, dAtA)
  4424  	for i := range dAtA {
  4425  		dAtA[i] = byte(popr.Intn(256))
  4426  	}
  4427  	if err := p.VerboseEqual(msg); err != nil {
  4428  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4429  	}
  4430  	if !p.Equal(msg) {
  4431  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4432  	}
  4433  	if len(littlefuzz) > 0 {
  4434  		fuzzamount := 100
  4435  		for i := 0; i < fuzzamount; i++ {
  4436  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4437  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4438  		}
  4439  		// shouldn't panic
  4440  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4441  	}
  4442  }
  4443  
  4444  func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) {
  4445  	seed := time.Now().UnixNano()
  4446  	popr := math_rand.New(math_rand.NewSource(seed))
  4447  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
  4448  	size := p.Size()
  4449  	dAtA := make([]byte, size)
  4450  	for i := range dAtA {
  4451  		dAtA[i] = byte(popr.Intn(256))
  4452  	}
  4453  	_, err := p.MarshalTo(dAtA)
  4454  	if err != nil {
  4455  		t.Fatalf("seed = %d, err = %v", seed, err)
  4456  	}
  4457  	msg := &NestedDefinition_NestedMessage{}
  4458  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4459  		t.Fatalf("seed = %d, err = %v", seed, err)
  4460  	}
  4461  	for i := range dAtA {
  4462  		dAtA[i] = byte(popr.Intn(256))
  4463  	}
  4464  	if err := p.VerboseEqual(msg); err != nil {
  4465  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4466  	}
  4467  	if !p.Equal(msg) {
  4468  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4469  	}
  4470  }
  4471  
  4472  func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) {
  4473  	popr := math_rand.New(math_rand.NewSource(616))
  4474  	total := 0
  4475  	pops := make([]*NestedDefinition_NestedMessage, 10000)
  4476  	for i := 0; i < 10000; i++ {
  4477  		pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
  4478  	}
  4479  	b.ResetTimer()
  4480  	for i := 0; i < b.N; i++ {
  4481  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4482  		if err != nil {
  4483  			panic(err)
  4484  		}
  4485  		total += len(dAtA)
  4486  	}
  4487  	b.SetBytes(int64(total / b.N))
  4488  }
  4489  
  4490  func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) {
  4491  	popr := math_rand.New(math_rand.NewSource(616))
  4492  	total := 0
  4493  	datas := make([][]byte, 10000)
  4494  	for i := 0; i < 10000; i++ {
  4495  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false))
  4496  		if err != nil {
  4497  			panic(err)
  4498  		}
  4499  		datas[i] = dAtA
  4500  	}
  4501  	msg := &NestedDefinition_NestedMessage{}
  4502  	b.ResetTimer()
  4503  	for i := 0; i < b.N; i++ {
  4504  		total += len(datas[i%10000])
  4505  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4506  			panic(err)
  4507  		}
  4508  	}
  4509  	b.SetBytes(int64(total / b.N))
  4510  }
  4511  
  4512  func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) {
  4513  	seed := time.Now().UnixNano()
  4514  	popr := math_rand.New(math_rand.NewSource(seed))
  4515  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  4516  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4517  	if err != nil {
  4518  		t.Fatalf("seed = %d, err = %v", seed, err)
  4519  	}
  4520  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  4521  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4522  		t.Fatalf("seed = %d, err = %v", seed, err)
  4523  	}
  4524  	littlefuzz := make([]byte, len(dAtA))
  4525  	copy(littlefuzz, dAtA)
  4526  	for i := range dAtA {
  4527  		dAtA[i] = byte(popr.Intn(256))
  4528  	}
  4529  	if err := p.VerboseEqual(msg); err != nil {
  4530  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4531  	}
  4532  	if !p.Equal(msg) {
  4533  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4534  	}
  4535  	if len(littlefuzz) > 0 {
  4536  		fuzzamount := 100
  4537  		for i := 0; i < fuzzamount; i++ {
  4538  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4539  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4540  		}
  4541  		// shouldn't panic
  4542  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4543  	}
  4544  }
  4545  
  4546  func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) {
  4547  	seed := time.Now().UnixNano()
  4548  	popr := math_rand.New(math_rand.NewSource(seed))
  4549  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  4550  	size := p.Size()
  4551  	dAtA := make([]byte, size)
  4552  	for i := range dAtA {
  4553  		dAtA[i] = byte(popr.Intn(256))
  4554  	}
  4555  	_, err := p.MarshalTo(dAtA)
  4556  	if err != nil {
  4557  		t.Fatalf("seed = %d, err = %v", seed, err)
  4558  	}
  4559  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  4560  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4561  		t.Fatalf("seed = %d, err = %v", seed, err)
  4562  	}
  4563  	for i := range dAtA {
  4564  		dAtA[i] = byte(popr.Intn(256))
  4565  	}
  4566  	if err := p.VerboseEqual(msg); err != nil {
  4567  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4568  	}
  4569  	if !p.Equal(msg) {
  4570  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4571  	}
  4572  }
  4573  
  4574  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) {
  4575  	popr := math_rand.New(math_rand.NewSource(616))
  4576  	total := 0
  4577  	pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000)
  4578  	for i := 0; i < 10000; i++ {
  4579  		pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  4580  	}
  4581  	b.ResetTimer()
  4582  	for i := 0; i < b.N; i++ {
  4583  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4584  		if err != nil {
  4585  			panic(err)
  4586  		}
  4587  		total += len(dAtA)
  4588  	}
  4589  	b.SetBytes(int64(total / b.N))
  4590  }
  4591  
  4592  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) {
  4593  	popr := math_rand.New(math_rand.NewSource(616))
  4594  	total := 0
  4595  	datas := make([][]byte, 10000)
  4596  	for i := 0; i < 10000; i++ {
  4597  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false))
  4598  		if err != nil {
  4599  			panic(err)
  4600  		}
  4601  		datas[i] = dAtA
  4602  	}
  4603  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  4604  	b.ResetTimer()
  4605  	for i := 0; i < b.N; i++ {
  4606  		total += len(datas[i%10000])
  4607  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4608  			panic(err)
  4609  		}
  4610  	}
  4611  	b.SetBytes(int64(total / b.N))
  4612  }
  4613  
  4614  func TestNestedScopeProto(t *testing.T) {
  4615  	seed := time.Now().UnixNano()
  4616  	popr := math_rand.New(math_rand.NewSource(seed))
  4617  	p := NewPopulatedNestedScope(popr, false)
  4618  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4619  	if err != nil {
  4620  		t.Fatalf("seed = %d, err = %v", seed, err)
  4621  	}
  4622  	msg := &NestedScope{}
  4623  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4624  		t.Fatalf("seed = %d, err = %v", seed, err)
  4625  	}
  4626  	littlefuzz := make([]byte, len(dAtA))
  4627  	copy(littlefuzz, dAtA)
  4628  	for i := range dAtA {
  4629  		dAtA[i] = byte(popr.Intn(256))
  4630  	}
  4631  	if err := p.VerboseEqual(msg); err != nil {
  4632  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4633  	}
  4634  	if !p.Equal(msg) {
  4635  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4636  	}
  4637  	if len(littlefuzz) > 0 {
  4638  		fuzzamount := 100
  4639  		for i := 0; i < fuzzamount; i++ {
  4640  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4641  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4642  		}
  4643  		// shouldn't panic
  4644  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4645  	}
  4646  }
  4647  
  4648  func TestNestedScopeMarshalTo(t *testing.T) {
  4649  	seed := time.Now().UnixNano()
  4650  	popr := math_rand.New(math_rand.NewSource(seed))
  4651  	p := NewPopulatedNestedScope(popr, false)
  4652  	size := p.Size()
  4653  	dAtA := make([]byte, size)
  4654  	for i := range dAtA {
  4655  		dAtA[i] = byte(popr.Intn(256))
  4656  	}
  4657  	_, err := p.MarshalTo(dAtA)
  4658  	if err != nil {
  4659  		t.Fatalf("seed = %d, err = %v", seed, err)
  4660  	}
  4661  	msg := &NestedScope{}
  4662  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4663  		t.Fatalf("seed = %d, err = %v", seed, err)
  4664  	}
  4665  	for i := range dAtA {
  4666  		dAtA[i] = byte(popr.Intn(256))
  4667  	}
  4668  	if err := p.VerboseEqual(msg); err != nil {
  4669  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4670  	}
  4671  	if !p.Equal(msg) {
  4672  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4673  	}
  4674  }
  4675  
  4676  func BenchmarkNestedScopeProtoMarshal(b *testing.B) {
  4677  	popr := math_rand.New(math_rand.NewSource(616))
  4678  	total := 0
  4679  	pops := make([]*NestedScope, 10000)
  4680  	for i := 0; i < 10000; i++ {
  4681  		pops[i] = NewPopulatedNestedScope(popr, false)
  4682  	}
  4683  	b.ResetTimer()
  4684  	for i := 0; i < b.N; i++ {
  4685  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4686  		if err != nil {
  4687  			panic(err)
  4688  		}
  4689  		total += len(dAtA)
  4690  	}
  4691  	b.SetBytes(int64(total / b.N))
  4692  }
  4693  
  4694  func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) {
  4695  	popr := math_rand.New(math_rand.NewSource(616))
  4696  	total := 0
  4697  	datas := make([][]byte, 10000)
  4698  	for i := 0; i < 10000; i++ {
  4699  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false))
  4700  		if err != nil {
  4701  			panic(err)
  4702  		}
  4703  		datas[i] = dAtA
  4704  	}
  4705  	msg := &NestedScope{}
  4706  	b.ResetTimer()
  4707  	for i := 0; i < b.N; i++ {
  4708  		total += len(datas[i%10000])
  4709  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4710  			panic(err)
  4711  		}
  4712  	}
  4713  	b.SetBytes(int64(total / b.N))
  4714  }
  4715  
  4716  func TestNinOptNativeDefaultProto(t *testing.T) {
  4717  	seed := time.Now().UnixNano()
  4718  	popr := math_rand.New(math_rand.NewSource(seed))
  4719  	p := NewPopulatedNinOptNativeDefault(popr, false)
  4720  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4721  	if err != nil {
  4722  		t.Fatalf("seed = %d, err = %v", seed, err)
  4723  	}
  4724  	msg := &NinOptNativeDefault{}
  4725  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4726  		t.Fatalf("seed = %d, err = %v", seed, err)
  4727  	}
  4728  	littlefuzz := make([]byte, len(dAtA))
  4729  	copy(littlefuzz, dAtA)
  4730  	for i := range dAtA {
  4731  		dAtA[i] = byte(popr.Intn(256))
  4732  	}
  4733  	if err := p.VerboseEqual(msg); err != nil {
  4734  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4735  	}
  4736  	if !p.Equal(msg) {
  4737  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4738  	}
  4739  	if len(littlefuzz) > 0 {
  4740  		fuzzamount := 100
  4741  		for i := 0; i < fuzzamount; i++ {
  4742  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4743  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4744  		}
  4745  		// shouldn't panic
  4746  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4747  	}
  4748  }
  4749  
  4750  func TestNinOptNativeDefaultMarshalTo(t *testing.T) {
  4751  	seed := time.Now().UnixNano()
  4752  	popr := math_rand.New(math_rand.NewSource(seed))
  4753  	p := NewPopulatedNinOptNativeDefault(popr, false)
  4754  	size := p.Size()
  4755  	dAtA := make([]byte, size)
  4756  	for i := range dAtA {
  4757  		dAtA[i] = byte(popr.Intn(256))
  4758  	}
  4759  	_, err := p.MarshalTo(dAtA)
  4760  	if err != nil {
  4761  		t.Fatalf("seed = %d, err = %v", seed, err)
  4762  	}
  4763  	msg := &NinOptNativeDefault{}
  4764  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4765  		t.Fatalf("seed = %d, err = %v", seed, err)
  4766  	}
  4767  	for i := range dAtA {
  4768  		dAtA[i] = byte(popr.Intn(256))
  4769  	}
  4770  	if err := p.VerboseEqual(msg); err != nil {
  4771  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4772  	}
  4773  	if !p.Equal(msg) {
  4774  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4775  	}
  4776  }
  4777  
  4778  func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) {
  4779  	popr := math_rand.New(math_rand.NewSource(616))
  4780  	total := 0
  4781  	pops := make([]*NinOptNativeDefault, 10000)
  4782  	for i := 0; i < 10000; i++ {
  4783  		pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
  4784  	}
  4785  	b.ResetTimer()
  4786  	for i := 0; i < b.N; i++ {
  4787  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4788  		if err != nil {
  4789  			panic(err)
  4790  		}
  4791  		total += len(dAtA)
  4792  	}
  4793  	b.SetBytes(int64(total / b.N))
  4794  }
  4795  
  4796  func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) {
  4797  	popr := math_rand.New(math_rand.NewSource(616))
  4798  	total := 0
  4799  	datas := make([][]byte, 10000)
  4800  	for i := 0; i < 10000; i++ {
  4801  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false))
  4802  		if err != nil {
  4803  			panic(err)
  4804  		}
  4805  		datas[i] = dAtA
  4806  	}
  4807  	msg := &NinOptNativeDefault{}
  4808  	b.ResetTimer()
  4809  	for i := 0; i < b.N; i++ {
  4810  		total += len(datas[i%10000])
  4811  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4812  			panic(err)
  4813  		}
  4814  	}
  4815  	b.SetBytes(int64(total / b.N))
  4816  }
  4817  
  4818  func TestCustomContainerProto(t *testing.T) {
  4819  	seed := time.Now().UnixNano()
  4820  	popr := math_rand.New(math_rand.NewSource(seed))
  4821  	p := NewPopulatedCustomContainer(popr, false)
  4822  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4823  	if err != nil {
  4824  		t.Fatalf("seed = %d, err = %v", seed, err)
  4825  	}
  4826  	msg := &CustomContainer{}
  4827  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4828  		t.Fatalf("seed = %d, err = %v", seed, err)
  4829  	}
  4830  	littlefuzz := make([]byte, len(dAtA))
  4831  	copy(littlefuzz, dAtA)
  4832  	for i := range dAtA {
  4833  		dAtA[i] = byte(popr.Intn(256))
  4834  	}
  4835  	if err := p.VerboseEqual(msg); err != nil {
  4836  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4837  	}
  4838  	if !p.Equal(msg) {
  4839  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4840  	}
  4841  	if len(littlefuzz) > 0 {
  4842  		fuzzamount := 100
  4843  		for i := 0; i < fuzzamount; i++ {
  4844  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4845  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4846  		}
  4847  		// shouldn't panic
  4848  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4849  	}
  4850  }
  4851  
  4852  func TestCustomContainerMarshalTo(t *testing.T) {
  4853  	seed := time.Now().UnixNano()
  4854  	popr := math_rand.New(math_rand.NewSource(seed))
  4855  	p := NewPopulatedCustomContainer(popr, false)
  4856  	size := p.Size()
  4857  	dAtA := make([]byte, size)
  4858  	for i := range dAtA {
  4859  		dAtA[i] = byte(popr.Intn(256))
  4860  	}
  4861  	_, err := p.MarshalTo(dAtA)
  4862  	if err != nil {
  4863  		t.Fatalf("seed = %d, err = %v", seed, err)
  4864  	}
  4865  	msg := &CustomContainer{}
  4866  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4867  		t.Fatalf("seed = %d, err = %v", seed, err)
  4868  	}
  4869  	for i := range dAtA {
  4870  		dAtA[i] = byte(popr.Intn(256))
  4871  	}
  4872  	if err := p.VerboseEqual(msg); err != nil {
  4873  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4874  	}
  4875  	if !p.Equal(msg) {
  4876  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4877  	}
  4878  }
  4879  
  4880  func BenchmarkCustomContainerProtoMarshal(b *testing.B) {
  4881  	popr := math_rand.New(math_rand.NewSource(616))
  4882  	total := 0
  4883  	pops := make([]*CustomContainer, 10000)
  4884  	for i := 0; i < 10000; i++ {
  4885  		pops[i] = NewPopulatedCustomContainer(popr, false)
  4886  	}
  4887  	b.ResetTimer()
  4888  	for i := 0; i < b.N; i++ {
  4889  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4890  		if err != nil {
  4891  			panic(err)
  4892  		}
  4893  		total += len(dAtA)
  4894  	}
  4895  	b.SetBytes(int64(total / b.N))
  4896  }
  4897  
  4898  func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) {
  4899  	popr := math_rand.New(math_rand.NewSource(616))
  4900  	total := 0
  4901  	datas := make([][]byte, 10000)
  4902  	for i := 0; i < 10000; i++ {
  4903  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false))
  4904  		if err != nil {
  4905  			panic(err)
  4906  		}
  4907  		datas[i] = dAtA
  4908  	}
  4909  	msg := &CustomContainer{}
  4910  	b.ResetTimer()
  4911  	for i := 0; i < b.N; i++ {
  4912  		total += len(datas[i%10000])
  4913  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4914  			panic(err)
  4915  		}
  4916  	}
  4917  	b.SetBytes(int64(total / b.N))
  4918  }
  4919  
  4920  func TestCustomNameNidOptNativeProto(t *testing.T) {
  4921  	seed := time.Now().UnixNano()
  4922  	popr := math_rand.New(math_rand.NewSource(seed))
  4923  	p := NewPopulatedCustomNameNidOptNative(popr, false)
  4924  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4925  	if err != nil {
  4926  		t.Fatalf("seed = %d, err = %v", seed, err)
  4927  	}
  4928  	msg := &CustomNameNidOptNative{}
  4929  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4930  		t.Fatalf("seed = %d, err = %v", seed, err)
  4931  	}
  4932  	littlefuzz := make([]byte, len(dAtA))
  4933  	copy(littlefuzz, dAtA)
  4934  	for i := range dAtA {
  4935  		dAtA[i] = byte(popr.Intn(256))
  4936  	}
  4937  	if err := p.VerboseEqual(msg); err != nil {
  4938  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4939  	}
  4940  	if !p.Equal(msg) {
  4941  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4942  	}
  4943  	if len(littlefuzz) > 0 {
  4944  		fuzzamount := 100
  4945  		for i := 0; i < fuzzamount; i++ {
  4946  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4947  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4948  		}
  4949  		// shouldn't panic
  4950  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4951  	}
  4952  }
  4953  
  4954  func TestCustomNameNidOptNativeMarshalTo(t *testing.T) {
  4955  	seed := time.Now().UnixNano()
  4956  	popr := math_rand.New(math_rand.NewSource(seed))
  4957  	p := NewPopulatedCustomNameNidOptNative(popr, false)
  4958  	size := p.Size()
  4959  	dAtA := make([]byte, size)
  4960  	for i := range dAtA {
  4961  		dAtA[i] = byte(popr.Intn(256))
  4962  	}
  4963  	_, err := p.MarshalTo(dAtA)
  4964  	if err != nil {
  4965  		t.Fatalf("seed = %d, err = %v", seed, err)
  4966  	}
  4967  	msg := &CustomNameNidOptNative{}
  4968  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4969  		t.Fatalf("seed = %d, err = %v", seed, err)
  4970  	}
  4971  	for i := range dAtA {
  4972  		dAtA[i] = byte(popr.Intn(256))
  4973  	}
  4974  	if err := p.VerboseEqual(msg); err != nil {
  4975  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4976  	}
  4977  	if !p.Equal(msg) {
  4978  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4979  	}
  4980  }
  4981  
  4982  func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) {
  4983  	popr := math_rand.New(math_rand.NewSource(616))
  4984  	total := 0
  4985  	pops := make([]*CustomNameNidOptNative, 10000)
  4986  	for i := 0; i < 10000; i++ {
  4987  		pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
  4988  	}
  4989  	b.ResetTimer()
  4990  	for i := 0; i < b.N; i++ {
  4991  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4992  		if err != nil {
  4993  			panic(err)
  4994  		}
  4995  		total += len(dAtA)
  4996  	}
  4997  	b.SetBytes(int64(total / b.N))
  4998  }
  4999  
  5000  func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) {
  5001  	popr := math_rand.New(math_rand.NewSource(616))
  5002  	total := 0
  5003  	datas := make([][]byte, 10000)
  5004  	for i := 0; i < 10000; i++ {
  5005  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false))
  5006  		if err != nil {
  5007  			panic(err)
  5008  		}
  5009  		datas[i] = dAtA
  5010  	}
  5011  	msg := &CustomNameNidOptNative{}
  5012  	b.ResetTimer()
  5013  	for i := 0; i < b.N; i++ {
  5014  		total += len(datas[i%10000])
  5015  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5016  			panic(err)
  5017  		}
  5018  	}
  5019  	b.SetBytes(int64(total / b.N))
  5020  }
  5021  
  5022  func TestCustomNameNinOptNativeProto(t *testing.T) {
  5023  	seed := time.Now().UnixNano()
  5024  	popr := math_rand.New(math_rand.NewSource(seed))
  5025  	p := NewPopulatedCustomNameNinOptNative(popr, false)
  5026  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5027  	if err != nil {
  5028  		t.Fatalf("seed = %d, err = %v", seed, err)
  5029  	}
  5030  	msg := &CustomNameNinOptNative{}
  5031  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5032  		t.Fatalf("seed = %d, err = %v", seed, err)
  5033  	}
  5034  	littlefuzz := make([]byte, len(dAtA))
  5035  	copy(littlefuzz, dAtA)
  5036  	for i := range dAtA {
  5037  		dAtA[i] = byte(popr.Intn(256))
  5038  	}
  5039  	if err := p.VerboseEqual(msg); err != nil {
  5040  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5041  	}
  5042  	if !p.Equal(msg) {
  5043  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5044  	}
  5045  	if len(littlefuzz) > 0 {
  5046  		fuzzamount := 100
  5047  		for i := 0; i < fuzzamount; i++ {
  5048  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5049  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5050  		}
  5051  		// shouldn't panic
  5052  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5053  	}
  5054  }
  5055  
  5056  func TestCustomNameNinOptNativeMarshalTo(t *testing.T) {
  5057  	seed := time.Now().UnixNano()
  5058  	popr := math_rand.New(math_rand.NewSource(seed))
  5059  	p := NewPopulatedCustomNameNinOptNative(popr, false)
  5060  	size := p.Size()
  5061  	dAtA := make([]byte, size)
  5062  	for i := range dAtA {
  5063  		dAtA[i] = byte(popr.Intn(256))
  5064  	}
  5065  	_, err := p.MarshalTo(dAtA)
  5066  	if err != nil {
  5067  		t.Fatalf("seed = %d, err = %v", seed, err)
  5068  	}
  5069  	msg := &CustomNameNinOptNative{}
  5070  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5071  		t.Fatalf("seed = %d, err = %v", seed, err)
  5072  	}
  5073  	for i := range dAtA {
  5074  		dAtA[i] = byte(popr.Intn(256))
  5075  	}
  5076  	if err := p.VerboseEqual(msg); err != nil {
  5077  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5078  	}
  5079  	if !p.Equal(msg) {
  5080  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5081  	}
  5082  }
  5083  
  5084  func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) {
  5085  	popr := math_rand.New(math_rand.NewSource(616))
  5086  	total := 0
  5087  	pops := make([]*CustomNameNinOptNative, 10000)
  5088  	for i := 0; i < 10000; i++ {
  5089  		pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
  5090  	}
  5091  	b.ResetTimer()
  5092  	for i := 0; i < b.N; i++ {
  5093  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5094  		if err != nil {
  5095  			panic(err)
  5096  		}
  5097  		total += len(dAtA)
  5098  	}
  5099  	b.SetBytes(int64(total / b.N))
  5100  }
  5101  
  5102  func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) {
  5103  	popr := math_rand.New(math_rand.NewSource(616))
  5104  	total := 0
  5105  	datas := make([][]byte, 10000)
  5106  	for i := 0; i < 10000; i++ {
  5107  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false))
  5108  		if err != nil {
  5109  			panic(err)
  5110  		}
  5111  		datas[i] = dAtA
  5112  	}
  5113  	msg := &CustomNameNinOptNative{}
  5114  	b.ResetTimer()
  5115  	for i := 0; i < b.N; i++ {
  5116  		total += len(datas[i%10000])
  5117  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5118  			panic(err)
  5119  		}
  5120  	}
  5121  	b.SetBytes(int64(total / b.N))
  5122  }
  5123  
  5124  func TestCustomNameNinRepNativeProto(t *testing.T) {
  5125  	seed := time.Now().UnixNano()
  5126  	popr := math_rand.New(math_rand.NewSource(seed))
  5127  	p := NewPopulatedCustomNameNinRepNative(popr, false)
  5128  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5129  	if err != nil {
  5130  		t.Fatalf("seed = %d, err = %v", seed, err)
  5131  	}
  5132  	msg := &CustomNameNinRepNative{}
  5133  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5134  		t.Fatalf("seed = %d, err = %v", seed, err)
  5135  	}
  5136  	littlefuzz := make([]byte, len(dAtA))
  5137  	copy(littlefuzz, dAtA)
  5138  	for i := range dAtA {
  5139  		dAtA[i] = byte(popr.Intn(256))
  5140  	}
  5141  	if err := p.VerboseEqual(msg); err != nil {
  5142  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5143  	}
  5144  	if !p.Equal(msg) {
  5145  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5146  	}
  5147  	if len(littlefuzz) > 0 {
  5148  		fuzzamount := 100
  5149  		for i := 0; i < fuzzamount; i++ {
  5150  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5151  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5152  		}
  5153  		// shouldn't panic
  5154  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5155  	}
  5156  }
  5157  
  5158  func TestCustomNameNinRepNativeMarshalTo(t *testing.T) {
  5159  	seed := time.Now().UnixNano()
  5160  	popr := math_rand.New(math_rand.NewSource(seed))
  5161  	p := NewPopulatedCustomNameNinRepNative(popr, false)
  5162  	size := p.Size()
  5163  	dAtA := make([]byte, size)
  5164  	for i := range dAtA {
  5165  		dAtA[i] = byte(popr.Intn(256))
  5166  	}
  5167  	_, err := p.MarshalTo(dAtA)
  5168  	if err != nil {
  5169  		t.Fatalf("seed = %d, err = %v", seed, err)
  5170  	}
  5171  	msg := &CustomNameNinRepNative{}
  5172  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5173  		t.Fatalf("seed = %d, err = %v", seed, err)
  5174  	}
  5175  	for i := range dAtA {
  5176  		dAtA[i] = byte(popr.Intn(256))
  5177  	}
  5178  	if err := p.VerboseEqual(msg); err != nil {
  5179  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5180  	}
  5181  	if !p.Equal(msg) {
  5182  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5183  	}
  5184  }
  5185  
  5186  func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) {
  5187  	popr := math_rand.New(math_rand.NewSource(616))
  5188  	total := 0
  5189  	pops := make([]*CustomNameNinRepNative, 10000)
  5190  	for i := 0; i < 10000; i++ {
  5191  		pops[i] = NewPopulatedCustomNameNinRepNative(popr, false)
  5192  	}
  5193  	b.ResetTimer()
  5194  	for i := 0; i < b.N; i++ {
  5195  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5196  		if err != nil {
  5197  			panic(err)
  5198  		}
  5199  		total += len(dAtA)
  5200  	}
  5201  	b.SetBytes(int64(total / b.N))
  5202  }
  5203  
  5204  func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) {
  5205  	popr := math_rand.New(math_rand.NewSource(616))
  5206  	total := 0
  5207  	datas := make([][]byte, 10000)
  5208  	for i := 0; i < 10000; i++ {
  5209  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false))
  5210  		if err != nil {
  5211  			panic(err)
  5212  		}
  5213  		datas[i] = dAtA
  5214  	}
  5215  	msg := &CustomNameNinRepNative{}
  5216  	b.ResetTimer()
  5217  	for i := 0; i < b.N; i++ {
  5218  		total += len(datas[i%10000])
  5219  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5220  			panic(err)
  5221  		}
  5222  	}
  5223  	b.SetBytes(int64(total / b.N))
  5224  }
  5225  
  5226  func TestCustomNameNinStructProto(t *testing.T) {
  5227  	seed := time.Now().UnixNano()
  5228  	popr := math_rand.New(math_rand.NewSource(seed))
  5229  	p := NewPopulatedCustomNameNinStruct(popr, false)
  5230  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5231  	if err != nil {
  5232  		t.Fatalf("seed = %d, err = %v", seed, err)
  5233  	}
  5234  	msg := &CustomNameNinStruct{}
  5235  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5236  		t.Fatalf("seed = %d, err = %v", seed, err)
  5237  	}
  5238  	littlefuzz := make([]byte, len(dAtA))
  5239  	copy(littlefuzz, dAtA)
  5240  	for i := range dAtA {
  5241  		dAtA[i] = byte(popr.Intn(256))
  5242  	}
  5243  	if err := p.VerboseEqual(msg); err != nil {
  5244  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5245  	}
  5246  	if !p.Equal(msg) {
  5247  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5248  	}
  5249  	if len(littlefuzz) > 0 {
  5250  		fuzzamount := 100
  5251  		for i := 0; i < fuzzamount; i++ {
  5252  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5253  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5254  		}
  5255  		// shouldn't panic
  5256  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5257  	}
  5258  }
  5259  
  5260  func TestCustomNameNinStructMarshalTo(t *testing.T) {
  5261  	seed := time.Now().UnixNano()
  5262  	popr := math_rand.New(math_rand.NewSource(seed))
  5263  	p := NewPopulatedCustomNameNinStruct(popr, false)
  5264  	size := p.Size()
  5265  	dAtA := make([]byte, size)
  5266  	for i := range dAtA {
  5267  		dAtA[i] = byte(popr.Intn(256))
  5268  	}
  5269  	_, err := p.MarshalTo(dAtA)
  5270  	if err != nil {
  5271  		t.Fatalf("seed = %d, err = %v", seed, err)
  5272  	}
  5273  	msg := &CustomNameNinStruct{}
  5274  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5275  		t.Fatalf("seed = %d, err = %v", seed, err)
  5276  	}
  5277  	for i := range dAtA {
  5278  		dAtA[i] = byte(popr.Intn(256))
  5279  	}
  5280  	if err := p.VerboseEqual(msg); err != nil {
  5281  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5282  	}
  5283  	if !p.Equal(msg) {
  5284  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5285  	}
  5286  }
  5287  
  5288  func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) {
  5289  	popr := math_rand.New(math_rand.NewSource(616))
  5290  	total := 0
  5291  	pops := make([]*CustomNameNinStruct, 10000)
  5292  	for i := 0; i < 10000; i++ {
  5293  		pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
  5294  	}
  5295  	b.ResetTimer()
  5296  	for i := 0; i < b.N; i++ {
  5297  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5298  		if err != nil {
  5299  			panic(err)
  5300  		}
  5301  		total += len(dAtA)
  5302  	}
  5303  	b.SetBytes(int64(total / b.N))
  5304  }
  5305  
  5306  func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) {
  5307  	popr := math_rand.New(math_rand.NewSource(616))
  5308  	total := 0
  5309  	datas := make([][]byte, 10000)
  5310  	for i := 0; i < 10000; i++ {
  5311  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false))
  5312  		if err != nil {
  5313  			panic(err)
  5314  		}
  5315  		datas[i] = dAtA
  5316  	}
  5317  	msg := &CustomNameNinStruct{}
  5318  	b.ResetTimer()
  5319  	for i := 0; i < b.N; i++ {
  5320  		total += len(datas[i%10000])
  5321  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5322  			panic(err)
  5323  		}
  5324  	}
  5325  	b.SetBytes(int64(total / b.N))
  5326  }
  5327  
  5328  func TestCustomNameCustomTypeProto(t *testing.T) {
  5329  	seed := time.Now().UnixNano()
  5330  	popr := math_rand.New(math_rand.NewSource(seed))
  5331  	p := NewPopulatedCustomNameCustomType(popr, false)
  5332  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5333  	if err != nil {
  5334  		t.Fatalf("seed = %d, err = %v", seed, err)
  5335  	}
  5336  	msg := &CustomNameCustomType{}
  5337  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5338  		t.Fatalf("seed = %d, err = %v", seed, err)
  5339  	}
  5340  	littlefuzz := make([]byte, len(dAtA))
  5341  	copy(littlefuzz, dAtA)
  5342  	for i := range dAtA {
  5343  		dAtA[i] = byte(popr.Intn(256))
  5344  	}
  5345  	if err := p.VerboseEqual(msg); err != nil {
  5346  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5347  	}
  5348  	if !p.Equal(msg) {
  5349  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5350  	}
  5351  	if len(littlefuzz) > 0 {
  5352  		fuzzamount := 100
  5353  		for i := 0; i < fuzzamount; i++ {
  5354  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5355  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5356  		}
  5357  		// shouldn't panic
  5358  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5359  	}
  5360  }
  5361  
  5362  func TestCustomNameCustomTypeMarshalTo(t *testing.T) {
  5363  	seed := time.Now().UnixNano()
  5364  	popr := math_rand.New(math_rand.NewSource(seed))
  5365  	p := NewPopulatedCustomNameCustomType(popr, false)
  5366  	size := p.Size()
  5367  	dAtA := make([]byte, size)
  5368  	for i := range dAtA {
  5369  		dAtA[i] = byte(popr.Intn(256))
  5370  	}
  5371  	_, err := p.MarshalTo(dAtA)
  5372  	if err != nil {
  5373  		t.Fatalf("seed = %d, err = %v", seed, err)
  5374  	}
  5375  	msg := &CustomNameCustomType{}
  5376  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5377  		t.Fatalf("seed = %d, err = %v", seed, err)
  5378  	}
  5379  	for i := range dAtA {
  5380  		dAtA[i] = byte(popr.Intn(256))
  5381  	}
  5382  	if err := p.VerboseEqual(msg); err != nil {
  5383  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5384  	}
  5385  	if !p.Equal(msg) {
  5386  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5387  	}
  5388  }
  5389  
  5390  func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) {
  5391  	popr := math_rand.New(math_rand.NewSource(616))
  5392  	total := 0
  5393  	pops := make([]*CustomNameCustomType, 10000)
  5394  	for i := 0; i < 10000; i++ {
  5395  		pops[i] = NewPopulatedCustomNameCustomType(popr, false)
  5396  	}
  5397  	b.ResetTimer()
  5398  	for i := 0; i < b.N; i++ {
  5399  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5400  		if err != nil {
  5401  			panic(err)
  5402  		}
  5403  		total += len(dAtA)
  5404  	}
  5405  	b.SetBytes(int64(total / b.N))
  5406  }
  5407  
  5408  func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) {
  5409  	popr := math_rand.New(math_rand.NewSource(616))
  5410  	total := 0
  5411  	datas := make([][]byte, 10000)
  5412  	for i := 0; i < 10000; i++ {
  5413  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false))
  5414  		if err != nil {
  5415  			panic(err)
  5416  		}
  5417  		datas[i] = dAtA
  5418  	}
  5419  	msg := &CustomNameCustomType{}
  5420  	b.ResetTimer()
  5421  	for i := 0; i < b.N; i++ {
  5422  		total += len(datas[i%10000])
  5423  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5424  			panic(err)
  5425  		}
  5426  	}
  5427  	b.SetBytes(int64(total / b.N))
  5428  }
  5429  
  5430  func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) {
  5431  	seed := time.Now().UnixNano()
  5432  	popr := math_rand.New(math_rand.NewSource(seed))
  5433  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
  5434  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5435  	if err != nil {
  5436  		t.Fatalf("seed = %d, err = %v", seed, err)
  5437  	}
  5438  	msg := &CustomNameNinEmbeddedStructUnion{}
  5439  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5440  		t.Fatalf("seed = %d, err = %v", seed, err)
  5441  	}
  5442  	littlefuzz := make([]byte, len(dAtA))
  5443  	copy(littlefuzz, dAtA)
  5444  	for i := range dAtA {
  5445  		dAtA[i] = byte(popr.Intn(256))
  5446  	}
  5447  	if err := p.VerboseEqual(msg); err != nil {
  5448  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5449  	}
  5450  	if !p.Equal(msg) {
  5451  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5452  	}
  5453  	if len(littlefuzz) > 0 {
  5454  		fuzzamount := 100
  5455  		for i := 0; i < fuzzamount; i++ {
  5456  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5457  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5458  		}
  5459  		// shouldn't panic
  5460  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5461  	}
  5462  }
  5463  
  5464  func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) {
  5465  	seed := time.Now().UnixNano()
  5466  	popr := math_rand.New(math_rand.NewSource(seed))
  5467  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
  5468  	size := p.Size()
  5469  	dAtA := make([]byte, size)
  5470  	for i := range dAtA {
  5471  		dAtA[i] = byte(popr.Intn(256))
  5472  	}
  5473  	_, err := p.MarshalTo(dAtA)
  5474  	if err != nil {
  5475  		t.Fatalf("seed = %d, err = %v", seed, err)
  5476  	}
  5477  	msg := &CustomNameNinEmbeddedStructUnion{}
  5478  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5479  		t.Fatalf("seed = %d, err = %v", seed, err)
  5480  	}
  5481  	for i := range dAtA {
  5482  		dAtA[i] = byte(popr.Intn(256))
  5483  	}
  5484  	if err := p.VerboseEqual(msg); err != nil {
  5485  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5486  	}
  5487  	if !p.Equal(msg) {
  5488  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5489  	}
  5490  }
  5491  
  5492  func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
  5493  	popr := math_rand.New(math_rand.NewSource(616))
  5494  	total := 0
  5495  	pops := make([]*CustomNameNinEmbeddedStructUnion, 10000)
  5496  	for i := 0; i < 10000; i++ {
  5497  		pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
  5498  	}
  5499  	b.ResetTimer()
  5500  	for i := 0; i < b.N; i++ {
  5501  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5502  		if err != nil {
  5503  			panic(err)
  5504  		}
  5505  		total += len(dAtA)
  5506  	}
  5507  	b.SetBytes(int64(total / b.N))
  5508  }
  5509  
  5510  func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
  5511  	popr := math_rand.New(math_rand.NewSource(616))
  5512  	total := 0
  5513  	datas := make([][]byte, 10000)
  5514  	for i := 0; i < 10000; i++ {
  5515  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false))
  5516  		if err != nil {
  5517  			panic(err)
  5518  		}
  5519  		datas[i] = dAtA
  5520  	}
  5521  	msg := &CustomNameNinEmbeddedStructUnion{}
  5522  	b.ResetTimer()
  5523  	for i := 0; i < b.N; i++ {
  5524  		total += len(datas[i%10000])
  5525  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5526  			panic(err)
  5527  		}
  5528  	}
  5529  	b.SetBytes(int64(total / b.N))
  5530  }
  5531  
  5532  func TestCustomNameEnumProto(t *testing.T) {
  5533  	seed := time.Now().UnixNano()
  5534  	popr := math_rand.New(math_rand.NewSource(seed))
  5535  	p := NewPopulatedCustomNameEnum(popr, false)
  5536  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5537  	if err != nil {
  5538  		t.Fatalf("seed = %d, err = %v", seed, err)
  5539  	}
  5540  	msg := &CustomNameEnum{}
  5541  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5542  		t.Fatalf("seed = %d, err = %v", seed, err)
  5543  	}
  5544  	littlefuzz := make([]byte, len(dAtA))
  5545  	copy(littlefuzz, dAtA)
  5546  	for i := range dAtA {
  5547  		dAtA[i] = byte(popr.Intn(256))
  5548  	}
  5549  	if err := p.VerboseEqual(msg); err != nil {
  5550  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5551  	}
  5552  	if !p.Equal(msg) {
  5553  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5554  	}
  5555  	if len(littlefuzz) > 0 {
  5556  		fuzzamount := 100
  5557  		for i := 0; i < fuzzamount; i++ {
  5558  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5559  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5560  		}
  5561  		// shouldn't panic
  5562  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5563  	}
  5564  }
  5565  
  5566  func TestCustomNameEnumMarshalTo(t *testing.T) {
  5567  	seed := time.Now().UnixNano()
  5568  	popr := math_rand.New(math_rand.NewSource(seed))
  5569  	p := NewPopulatedCustomNameEnum(popr, false)
  5570  	size := p.Size()
  5571  	dAtA := make([]byte, size)
  5572  	for i := range dAtA {
  5573  		dAtA[i] = byte(popr.Intn(256))
  5574  	}
  5575  	_, err := p.MarshalTo(dAtA)
  5576  	if err != nil {
  5577  		t.Fatalf("seed = %d, err = %v", seed, err)
  5578  	}
  5579  	msg := &CustomNameEnum{}
  5580  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5581  		t.Fatalf("seed = %d, err = %v", seed, err)
  5582  	}
  5583  	for i := range dAtA {
  5584  		dAtA[i] = byte(popr.Intn(256))
  5585  	}
  5586  	if err := p.VerboseEqual(msg); err != nil {
  5587  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5588  	}
  5589  	if !p.Equal(msg) {
  5590  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5591  	}
  5592  }
  5593  
  5594  func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) {
  5595  	popr := math_rand.New(math_rand.NewSource(616))
  5596  	total := 0
  5597  	pops := make([]*CustomNameEnum, 10000)
  5598  	for i := 0; i < 10000; i++ {
  5599  		pops[i] = NewPopulatedCustomNameEnum(popr, false)
  5600  	}
  5601  	b.ResetTimer()
  5602  	for i := 0; i < b.N; i++ {
  5603  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5604  		if err != nil {
  5605  			panic(err)
  5606  		}
  5607  		total += len(dAtA)
  5608  	}
  5609  	b.SetBytes(int64(total / b.N))
  5610  }
  5611  
  5612  func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) {
  5613  	popr := math_rand.New(math_rand.NewSource(616))
  5614  	total := 0
  5615  	datas := make([][]byte, 10000)
  5616  	for i := 0; i < 10000; i++ {
  5617  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false))
  5618  		if err != nil {
  5619  			panic(err)
  5620  		}
  5621  		datas[i] = dAtA
  5622  	}
  5623  	msg := &CustomNameEnum{}
  5624  	b.ResetTimer()
  5625  	for i := 0; i < b.N; i++ {
  5626  		total += len(datas[i%10000])
  5627  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5628  			panic(err)
  5629  		}
  5630  	}
  5631  	b.SetBytes(int64(total / b.N))
  5632  }
  5633  
  5634  func TestNoExtensionsMapProto(t *testing.T) {
  5635  	seed := time.Now().UnixNano()
  5636  	popr := math_rand.New(math_rand.NewSource(seed))
  5637  	p := NewPopulatedNoExtensionsMap(popr, false)
  5638  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5639  	if err != nil {
  5640  		t.Fatalf("seed = %d, err = %v", seed, err)
  5641  	}
  5642  	msg := &NoExtensionsMap{}
  5643  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5644  		t.Fatalf("seed = %d, err = %v", seed, err)
  5645  	}
  5646  	littlefuzz := make([]byte, len(dAtA))
  5647  	copy(littlefuzz, dAtA)
  5648  	for i := range dAtA {
  5649  		dAtA[i] = byte(popr.Intn(256))
  5650  	}
  5651  	if err := p.VerboseEqual(msg); err != nil {
  5652  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5653  	}
  5654  	if !p.Equal(msg) {
  5655  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5656  	}
  5657  	if len(littlefuzz) > 0 {
  5658  		fuzzamount := 100
  5659  		for i := 0; i < fuzzamount; i++ {
  5660  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5661  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5662  		}
  5663  		// shouldn't panic
  5664  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5665  	}
  5666  }
  5667  
  5668  func TestNoExtensionsMapMarshalTo(t *testing.T) {
  5669  	seed := time.Now().UnixNano()
  5670  	popr := math_rand.New(math_rand.NewSource(seed))
  5671  	p := NewPopulatedNoExtensionsMap(popr, false)
  5672  	size := p.Size()
  5673  	dAtA := make([]byte, size)
  5674  	for i := range dAtA {
  5675  		dAtA[i] = byte(popr.Intn(256))
  5676  	}
  5677  	_, err := p.MarshalTo(dAtA)
  5678  	if err != nil {
  5679  		t.Fatalf("seed = %d, err = %v", seed, err)
  5680  	}
  5681  	msg := &NoExtensionsMap{}
  5682  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5683  		t.Fatalf("seed = %d, err = %v", seed, err)
  5684  	}
  5685  	for i := range dAtA {
  5686  		dAtA[i] = byte(popr.Intn(256))
  5687  	}
  5688  	if err := p.VerboseEqual(msg); err != nil {
  5689  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5690  	}
  5691  	if !p.Equal(msg) {
  5692  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5693  	}
  5694  }
  5695  
  5696  func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) {
  5697  	popr := math_rand.New(math_rand.NewSource(616))
  5698  	total := 0
  5699  	pops := make([]*NoExtensionsMap, 10000)
  5700  	for i := 0; i < 10000; i++ {
  5701  		pops[i] = NewPopulatedNoExtensionsMap(popr, false)
  5702  	}
  5703  	b.ResetTimer()
  5704  	for i := 0; i < b.N; i++ {
  5705  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5706  		if err != nil {
  5707  			panic(err)
  5708  		}
  5709  		total += len(dAtA)
  5710  	}
  5711  	b.SetBytes(int64(total / b.N))
  5712  }
  5713  
  5714  func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) {
  5715  	popr := math_rand.New(math_rand.NewSource(616))
  5716  	total := 0
  5717  	datas := make([][]byte, 10000)
  5718  	for i := 0; i < 10000; i++ {
  5719  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false))
  5720  		if err != nil {
  5721  			panic(err)
  5722  		}
  5723  		datas[i] = dAtA
  5724  	}
  5725  	msg := &NoExtensionsMap{}
  5726  	b.ResetTimer()
  5727  	for i := 0; i < b.N; i++ {
  5728  		total += len(datas[i%10000])
  5729  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5730  			panic(err)
  5731  		}
  5732  	}
  5733  	b.SetBytes(int64(total / b.N))
  5734  }
  5735  
  5736  func TestUnrecognizedProto(t *testing.T) {
  5737  	seed := time.Now().UnixNano()
  5738  	popr := math_rand.New(math_rand.NewSource(seed))
  5739  	p := NewPopulatedUnrecognized(popr, false)
  5740  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5741  	if err != nil {
  5742  		t.Fatalf("seed = %d, err = %v", seed, err)
  5743  	}
  5744  	msg := &Unrecognized{}
  5745  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5746  		t.Fatalf("seed = %d, err = %v", seed, err)
  5747  	}
  5748  	littlefuzz := make([]byte, len(dAtA))
  5749  	copy(littlefuzz, dAtA)
  5750  	for i := range dAtA {
  5751  		dAtA[i] = byte(popr.Intn(256))
  5752  	}
  5753  	if err := p.VerboseEqual(msg); err != nil {
  5754  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5755  	}
  5756  	if !p.Equal(msg) {
  5757  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5758  	}
  5759  	if len(littlefuzz) > 0 {
  5760  		fuzzamount := 100
  5761  		for i := 0; i < fuzzamount; i++ {
  5762  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5763  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5764  		}
  5765  		// shouldn't panic
  5766  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5767  	}
  5768  }
  5769  
  5770  func TestUnrecognizedMarshalTo(t *testing.T) {
  5771  	seed := time.Now().UnixNano()
  5772  	popr := math_rand.New(math_rand.NewSource(seed))
  5773  	p := NewPopulatedUnrecognized(popr, false)
  5774  	size := p.Size()
  5775  	dAtA := make([]byte, size)
  5776  	for i := range dAtA {
  5777  		dAtA[i] = byte(popr.Intn(256))
  5778  	}
  5779  	_, err := p.MarshalTo(dAtA)
  5780  	if err != nil {
  5781  		t.Fatalf("seed = %d, err = %v", seed, err)
  5782  	}
  5783  	msg := &Unrecognized{}
  5784  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5785  		t.Fatalf("seed = %d, err = %v", seed, err)
  5786  	}
  5787  	for i := range dAtA {
  5788  		dAtA[i] = byte(popr.Intn(256))
  5789  	}
  5790  	if err := p.VerboseEqual(msg); err != nil {
  5791  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5792  	}
  5793  	if !p.Equal(msg) {
  5794  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5795  	}
  5796  }
  5797  
  5798  func BenchmarkUnrecognizedProtoMarshal(b *testing.B) {
  5799  	popr := math_rand.New(math_rand.NewSource(616))
  5800  	total := 0
  5801  	pops := make([]*Unrecognized, 10000)
  5802  	for i := 0; i < 10000; i++ {
  5803  		pops[i] = NewPopulatedUnrecognized(popr, false)
  5804  	}
  5805  	b.ResetTimer()
  5806  	for i := 0; i < b.N; i++ {
  5807  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5808  		if err != nil {
  5809  			panic(err)
  5810  		}
  5811  		total += len(dAtA)
  5812  	}
  5813  	b.SetBytes(int64(total / b.N))
  5814  }
  5815  
  5816  func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) {
  5817  	popr := math_rand.New(math_rand.NewSource(616))
  5818  	total := 0
  5819  	datas := make([][]byte, 10000)
  5820  	for i := 0; i < 10000; i++ {
  5821  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false))
  5822  		if err != nil {
  5823  			panic(err)
  5824  		}
  5825  		datas[i] = dAtA
  5826  	}
  5827  	msg := &Unrecognized{}
  5828  	b.ResetTimer()
  5829  	for i := 0; i < b.N; i++ {
  5830  		total += len(datas[i%10000])
  5831  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5832  			panic(err)
  5833  		}
  5834  	}
  5835  	b.SetBytes(int64(total / b.N))
  5836  }
  5837  
  5838  func TestUnrecognizedWithInnerProto(t *testing.T) {
  5839  	seed := time.Now().UnixNano()
  5840  	popr := math_rand.New(math_rand.NewSource(seed))
  5841  	p := NewPopulatedUnrecognizedWithInner(popr, false)
  5842  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5843  	if err != nil {
  5844  		t.Fatalf("seed = %d, err = %v", seed, err)
  5845  	}
  5846  	msg := &UnrecognizedWithInner{}
  5847  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5848  		t.Fatalf("seed = %d, err = %v", seed, err)
  5849  	}
  5850  	littlefuzz := make([]byte, len(dAtA))
  5851  	copy(littlefuzz, dAtA)
  5852  	for i := range dAtA {
  5853  		dAtA[i] = byte(popr.Intn(256))
  5854  	}
  5855  	if err := p.VerboseEqual(msg); err != nil {
  5856  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5857  	}
  5858  	if !p.Equal(msg) {
  5859  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5860  	}
  5861  	if len(littlefuzz) > 0 {
  5862  		fuzzamount := 100
  5863  		for i := 0; i < fuzzamount; i++ {
  5864  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5865  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5866  		}
  5867  		// shouldn't panic
  5868  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5869  	}
  5870  }
  5871  
  5872  func TestUnrecognizedWithInnerMarshalTo(t *testing.T) {
  5873  	seed := time.Now().UnixNano()
  5874  	popr := math_rand.New(math_rand.NewSource(seed))
  5875  	p := NewPopulatedUnrecognizedWithInner(popr, false)
  5876  	size := p.Size()
  5877  	dAtA := make([]byte, size)
  5878  	for i := range dAtA {
  5879  		dAtA[i] = byte(popr.Intn(256))
  5880  	}
  5881  	_, err := p.MarshalTo(dAtA)
  5882  	if err != nil {
  5883  		t.Fatalf("seed = %d, err = %v", seed, err)
  5884  	}
  5885  	msg := &UnrecognizedWithInner{}
  5886  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5887  		t.Fatalf("seed = %d, err = %v", seed, err)
  5888  	}
  5889  	for i := range dAtA {
  5890  		dAtA[i] = byte(popr.Intn(256))
  5891  	}
  5892  	if err := p.VerboseEqual(msg); err != nil {
  5893  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5894  	}
  5895  	if !p.Equal(msg) {
  5896  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5897  	}
  5898  }
  5899  
  5900  func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) {
  5901  	popr := math_rand.New(math_rand.NewSource(616))
  5902  	total := 0
  5903  	pops := make([]*UnrecognizedWithInner, 10000)
  5904  	for i := 0; i < 10000; i++ {
  5905  		pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
  5906  	}
  5907  	b.ResetTimer()
  5908  	for i := 0; i < b.N; i++ {
  5909  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5910  		if err != nil {
  5911  			panic(err)
  5912  		}
  5913  		total += len(dAtA)
  5914  	}
  5915  	b.SetBytes(int64(total / b.N))
  5916  }
  5917  
  5918  func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) {
  5919  	popr := math_rand.New(math_rand.NewSource(616))
  5920  	total := 0
  5921  	datas := make([][]byte, 10000)
  5922  	for i := 0; i < 10000; i++ {
  5923  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false))
  5924  		if err != nil {
  5925  			panic(err)
  5926  		}
  5927  		datas[i] = dAtA
  5928  	}
  5929  	msg := &UnrecognizedWithInner{}
  5930  	b.ResetTimer()
  5931  	for i := 0; i < b.N; i++ {
  5932  		total += len(datas[i%10000])
  5933  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5934  			panic(err)
  5935  		}
  5936  	}
  5937  	b.SetBytes(int64(total / b.N))
  5938  }
  5939  
  5940  func TestUnrecognizedWithInner_InnerProto(t *testing.T) {
  5941  	seed := time.Now().UnixNano()
  5942  	popr := math_rand.New(math_rand.NewSource(seed))
  5943  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
  5944  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  5945  	if err != nil {
  5946  		t.Fatalf("seed = %d, err = %v", seed, err)
  5947  	}
  5948  	msg := &UnrecognizedWithInner_Inner{}
  5949  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5950  		t.Fatalf("seed = %d, err = %v", seed, err)
  5951  	}
  5952  	littlefuzz := make([]byte, len(dAtA))
  5953  	copy(littlefuzz, dAtA)
  5954  	for i := range dAtA {
  5955  		dAtA[i] = byte(popr.Intn(256))
  5956  	}
  5957  	if err := p.VerboseEqual(msg); err != nil {
  5958  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5959  	}
  5960  	if !p.Equal(msg) {
  5961  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5962  	}
  5963  	if len(littlefuzz) > 0 {
  5964  		fuzzamount := 100
  5965  		for i := 0; i < fuzzamount; i++ {
  5966  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5967  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5968  		}
  5969  		// shouldn't panic
  5970  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5971  	}
  5972  }
  5973  
  5974  func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) {
  5975  	seed := time.Now().UnixNano()
  5976  	popr := math_rand.New(math_rand.NewSource(seed))
  5977  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
  5978  	size := p.Size()
  5979  	dAtA := make([]byte, size)
  5980  	for i := range dAtA {
  5981  		dAtA[i] = byte(popr.Intn(256))
  5982  	}
  5983  	_, err := p.MarshalTo(dAtA)
  5984  	if err != nil {
  5985  		t.Fatalf("seed = %d, err = %v", seed, err)
  5986  	}
  5987  	msg := &UnrecognizedWithInner_Inner{}
  5988  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  5989  		t.Fatalf("seed = %d, err = %v", seed, err)
  5990  	}
  5991  	for i := range dAtA {
  5992  		dAtA[i] = byte(popr.Intn(256))
  5993  	}
  5994  	if err := p.VerboseEqual(msg); err != nil {
  5995  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5996  	}
  5997  	if !p.Equal(msg) {
  5998  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5999  	}
  6000  }
  6001  
  6002  func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) {
  6003  	popr := math_rand.New(math_rand.NewSource(616))
  6004  	total := 0
  6005  	pops := make([]*UnrecognizedWithInner_Inner, 10000)
  6006  	for i := 0; i < 10000; i++ {
  6007  		pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
  6008  	}
  6009  	b.ResetTimer()
  6010  	for i := 0; i < b.N; i++ {
  6011  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6012  		if err != nil {
  6013  			panic(err)
  6014  		}
  6015  		total += len(dAtA)
  6016  	}
  6017  	b.SetBytes(int64(total / b.N))
  6018  }
  6019  
  6020  func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) {
  6021  	popr := math_rand.New(math_rand.NewSource(616))
  6022  	total := 0
  6023  	datas := make([][]byte, 10000)
  6024  	for i := 0; i < 10000; i++ {
  6025  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false))
  6026  		if err != nil {
  6027  			panic(err)
  6028  		}
  6029  		datas[i] = dAtA
  6030  	}
  6031  	msg := &UnrecognizedWithInner_Inner{}
  6032  	b.ResetTimer()
  6033  	for i := 0; i < b.N; i++ {
  6034  		total += len(datas[i%10000])
  6035  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6036  			panic(err)
  6037  		}
  6038  	}
  6039  	b.SetBytes(int64(total / b.N))
  6040  }
  6041  
  6042  func TestUnrecognizedWithEmbedProto(t *testing.T) {
  6043  	seed := time.Now().UnixNano()
  6044  	popr := math_rand.New(math_rand.NewSource(seed))
  6045  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
  6046  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6047  	if err != nil {
  6048  		t.Fatalf("seed = %d, err = %v", seed, err)
  6049  	}
  6050  	msg := &UnrecognizedWithEmbed{}
  6051  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6052  		t.Fatalf("seed = %d, err = %v", seed, err)
  6053  	}
  6054  	littlefuzz := make([]byte, len(dAtA))
  6055  	copy(littlefuzz, dAtA)
  6056  	for i := range dAtA {
  6057  		dAtA[i] = byte(popr.Intn(256))
  6058  	}
  6059  	if err := p.VerboseEqual(msg); err != nil {
  6060  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6061  	}
  6062  	if !p.Equal(msg) {
  6063  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6064  	}
  6065  	if len(littlefuzz) > 0 {
  6066  		fuzzamount := 100
  6067  		for i := 0; i < fuzzamount; i++ {
  6068  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6069  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6070  		}
  6071  		// shouldn't panic
  6072  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6073  	}
  6074  }
  6075  
  6076  func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) {
  6077  	seed := time.Now().UnixNano()
  6078  	popr := math_rand.New(math_rand.NewSource(seed))
  6079  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
  6080  	size := p.Size()
  6081  	dAtA := make([]byte, size)
  6082  	for i := range dAtA {
  6083  		dAtA[i] = byte(popr.Intn(256))
  6084  	}
  6085  	_, err := p.MarshalTo(dAtA)
  6086  	if err != nil {
  6087  		t.Fatalf("seed = %d, err = %v", seed, err)
  6088  	}
  6089  	msg := &UnrecognizedWithEmbed{}
  6090  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6091  		t.Fatalf("seed = %d, err = %v", seed, err)
  6092  	}
  6093  	for i := range dAtA {
  6094  		dAtA[i] = byte(popr.Intn(256))
  6095  	}
  6096  	if err := p.VerboseEqual(msg); err != nil {
  6097  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6098  	}
  6099  	if !p.Equal(msg) {
  6100  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6101  	}
  6102  }
  6103  
  6104  func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) {
  6105  	popr := math_rand.New(math_rand.NewSource(616))
  6106  	total := 0
  6107  	pops := make([]*UnrecognizedWithEmbed, 10000)
  6108  	for i := 0; i < 10000; i++ {
  6109  		pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
  6110  	}
  6111  	b.ResetTimer()
  6112  	for i := 0; i < b.N; i++ {
  6113  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6114  		if err != nil {
  6115  			panic(err)
  6116  		}
  6117  		total += len(dAtA)
  6118  	}
  6119  	b.SetBytes(int64(total / b.N))
  6120  }
  6121  
  6122  func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) {
  6123  	popr := math_rand.New(math_rand.NewSource(616))
  6124  	total := 0
  6125  	datas := make([][]byte, 10000)
  6126  	for i := 0; i < 10000; i++ {
  6127  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false))
  6128  		if err != nil {
  6129  			panic(err)
  6130  		}
  6131  		datas[i] = dAtA
  6132  	}
  6133  	msg := &UnrecognizedWithEmbed{}
  6134  	b.ResetTimer()
  6135  	for i := 0; i < b.N; i++ {
  6136  		total += len(datas[i%10000])
  6137  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6138  			panic(err)
  6139  		}
  6140  	}
  6141  	b.SetBytes(int64(total / b.N))
  6142  }
  6143  
  6144  func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) {
  6145  	seed := time.Now().UnixNano()
  6146  	popr := math_rand.New(math_rand.NewSource(seed))
  6147  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
  6148  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6149  	if err != nil {
  6150  		t.Fatalf("seed = %d, err = %v", seed, err)
  6151  	}
  6152  	msg := &UnrecognizedWithEmbed_Embedded{}
  6153  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6154  		t.Fatalf("seed = %d, err = %v", seed, err)
  6155  	}
  6156  	littlefuzz := make([]byte, len(dAtA))
  6157  	copy(littlefuzz, dAtA)
  6158  	for i := range dAtA {
  6159  		dAtA[i] = byte(popr.Intn(256))
  6160  	}
  6161  	if err := p.VerboseEqual(msg); err != nil {
  6162  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6163  	}
  6164  	if !p.Equal(msg) {
  6165  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6166  	}
  6167  	if len(littlefuzz) > 0 {
  6168  		fuzzamount := 100
  6169  		for i := 0; i < fuzzamount; i++ {
  6170  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6171  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6172  		}
  6173  		// shouldn't panic
  6174  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6175  	}
  6176  }
  6177  
  6178  func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) {
  6179  	seed := time.Now().UnixNano()
  6180  	popr := math_rand.New(math_rand.NewSource(seed))
  6181  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
  6182  	size := p.Size()
  6183  	dAtA := make([]byte, size)
  6184  	for i := range dAtA {
  6185  		dAtA[i] = byte(popr.Intn(256))
  6186  	}
  6187  	_, err := p.MarshalTo(dAtA)
  6188  	if err != nil {
  6189  		t.Fatalf("seed = %d, err = %v", seed, err)
  6190  	}
  6191  	msg := &UnrecognizedWithEmbed_Embedded{}
  6192  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6193  		t.Fatalf("seed = %d, err = %v", seed, err)
  6194  	}
  6195  	for i := range dAtA {
  6196  		dAtA[i] = byte(popr.Intn(256))
  6197  	}
  6198  	if err := p.VerboseEqual(msg); err != nil {
  6199  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6200  	}
  6201  	if !p.Equal(msg) {
  6202  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6203  	}
  6204  }
  6205  
  6206  func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) {
  6207  	popr := math_rand.New(math_rand.NewSource(616))
  6208  	total := 0
  6209  	pops := make([]*UnrecognizedWithEmbed_Embedded, 10000)
  6210  	for i := 0; i < 10000; i++ {
  6211  		pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
  6212  	}
  6213  	b.ResetTimer()
  6214  	for i := 0; i < b.N; i++ {
  6215  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6216  		if err != nil {
  6217  			panic(err)
  6218  		}
  6219  		total += len(dAtA)
  6220  	}
  6221  	b.SetBytes(int64(total / b.N))
  6222  }
  6223  
  6224  func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) {
  6225  	popr := math_rand.New(math_rand.NewSource(616))
  6226  	total := 0
  6227  	datas := make([][]byte, 10000)
  6228  	for i := 0; i < 10000; i++ {
  6229  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false))
  6230  		if err != nil {
  6231  			panic(err)
  6232  		}
  6233  		datas[i] = dAtA
  6234  	}
  6235  	msg := &UnrecognizedWithEmbed_Embedded{}
  6236  	b.ResetTimer()
  6237  	for i := 0; i < b.N; i++ {
  6238  		total += len(datas[i%10000])
  6239  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6240  			panic(err)
  6241  		}
  6242  	}
  6243  	b.SetBytes(int64(total / b.N))
  6244  }
  6245  
  6246  func TestNodeProto(t *testing.T) {
  6247  	seed := time.Now().UnixNano()
  6248  	popr := math_rand.New(math_rand.NewSource(seed))
  6249  	p := NewPopulatedNode(popr, false)
  6250  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6251  	if err != nil {
  6252  		t.Fatalf("seed = %d, err = %v", seed, err)
  6253  	}
  6254  	msg := &Node{}
  6255  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6256  		t.Fatalf("seed = %d, err = %v", seed, err)
  6257  	}
  6258  	littlefuzz := make([]byte, len(dAtA))
  6259  	copy(littlefuzz, dAtA)
  6260  	for i := range dAtA {
  6261  		dAtA[i] = byte(popr.Intn(256))
  6262  	}
  6263  	if err := p.VerboseEqual(msg); err != nil {
  6264  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6265  	}
  6266  	if !p.Equal(msg) {
  6267  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6268  	}
  6269  	if len(littlefuzz) > 0 {
  6270  		fuzzamount := 100
  6271  		for i := 0; i < fuzzamount; i++ {
  6272  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6273  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6274  		}
  6275  		// shouldn't panic
  6276  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6277  	}
  6278  }
  6279  
  6280  func TestNodeMarshalTo(t *testing.T) {
  6281  	seed := time.Now().UnixNano()
  6282  	popr := math_rand.New(math_rand.NewSource(seed))
  6283  	p := NewPopulatedNode(popr, false)
  6284  	size := p.Size()
  6285  	dAtA := make([]byte, size)
  6286  	for i := range dAtA {
  6287  		dAtA[i] = byte(popr.Intn(256))
  6288  	}
  6289  	_, err := p.MarshalTo(dAtA)
  6290  	if err != nil {
  6291  		t.Fatalf("seed = %d, err = %v", seed, err)
  6292  	}
  6293  	msg := &Node{}
  6294  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6295  		t.Fatalf("seed = %d, err = %v", seed, err)
  6296  	}
  6297  	for i := range dAtA {
  6298  		dAtA[i] = byte(popr.Intn(256))
  6299  	}
  6300  	if err := p.VerboseEqual(msg); err != nil {
  6301  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6302  	}
  6303  	if !p.Equal(msg) {
  6304  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6305  	}
  6306  }
  6307  
  6308  func BenchmarkNodeProtoMarshal(b *testing.B) {
  6309  	popr := math_rand.New(math_rand.NewSource(616))
  6310  	total := 0
  6311  	pops := make([]*Node, 10000)
  6312  	for i := 0; i < 10000; i++ {
  6313  		pops[i] = NewPopulatedNode(popr, false)
  6314  	}
  6315  	b.ResetTimer()
  6316  	for i := 0; i < b.N; i++ {
  6317  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6318  		if err != nil {
  6319  			panic(err)
  6320  		}
  6321  		total += len(dAtA)
  6322  	}
  6323  	b.SetBytes(int64(total / b.N))
  6324  }
  6325  
  6326  func BenchmarkNodeProtoUnmarshal(b *testing.B) {
  6327  	popr := math_rand.New(math_rand.NewSource(616))
  6328  	total := 0
  6329  	datas := make([][]byte, 10000)
  6330  	for i := 0; i < 10000; i++ {
  6331  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNode(popr, false))
  6332  		if err != nil {
  6333  			panic(err)
  6334  		}
  6335  		datas[i] = dAtA
  6336  	}
  6337  	msg := &Node{}
  6338  	b.ResetTimer()
  6339  	for i := 0; i < b.N; i++ {
  6340  		total += len(datas[i%10000])
  6341  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6342  			panic(err)
  6343  		}
  6344  	}
  6345  	b.SetBytes(int64(total / b.N))
  6346  }
  6347  
  6348  func TestNonByteCustomTypeProto(t *testing.T) {
  6349  	seed := time.Now().UnixNano()
  6350  	popr := math_rand.New(math_rand.NewSource(seed))
  6351  	p := NewPopulatedNonByteCustomType(popr, false)
  6352  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6353  	if err != nil {
  6354  		t.Fatalf("seed = %d, err = %v", seed, err)
  6355  	}
  6356  	msg := &NonByteCustomType{}
  6357  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6358  		t.Fatalf("seed = %d, err = %v", seed, err)
  6359  	}
  6360  	littlefuzz := make([]byte, len(dAtA))
  6361  	copy(littlefuzz, dAtA)
  6362  	for i := range dAtA {
  6363  		dAtA[i] = byte(popr.Intn(256))
  6364  	}
  6365  	if err := p.VerboseEqual(msg); err != nil {
  6366  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6367  	}
  6368  	if !p.Equal(msg) {
  6369  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6370  	}
  6371  	if len(littlefuzz) > 0 {
  6372  		fuzzamount := 100
  6373  		for i := 0; i < fuzzamount; i++ {
  6374  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6375  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6376  		}
  6377  		// shouldn't panic
  6378  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6379  	}
  6380  }
  6381  
  6382  func TestNonByteCustomTypeMarshalTo(t *testing.T) {
  6383  	seed := time.Now().UnixNano()
  6384  	popr := math_rand.New(math_rand.NewSource(seed))
  6385  	p := NewPopulatedNonByteCustomType(popr, false)
  6386  	size := p.Size()
  6387  	dAtA := make([]byte, size)
  6388  	for i := range dAtA {
  6389  		dAtA[i] = byte(popr.Intn(256))
  6390  	}
  6391  	_, err := p.MarshalTo(dAtA)
  6392  	if err != nil {
  6393  		t.Fatalf("seed = %d, err = %v", seed, err)
  6394  	}
  6395  	msg := &NonByteCustomType{}
  6396  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6397  		t.Fatalf("seed = %d, err = %v", seed, err)
  6398  	}
  6399  	for i := range dAtA {
  6400  		dAtA[i] = byte(popr.Intn(256))
  6401  	}
  6402  	if err := p.VerboseEqual(msg); err != nil {
  6403  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6404  	}
  6405  	if !p.Equal(msg) {
  6406  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6407  	}
  6408  }
  6409  
  6410  func BenchmarkNonByteCustomTypeProtoMarshal(b *testing.B) {
  6411  	popr := math_rand.New(math_rand.NewSource(616))
  6412  	total := 0
  6413  	pops := make([]*NonByteCustomType, 10000)
  6414  	for i := 0; i < 10000; i++ {
  6415  		pops[i] = NewPopulatedNonByteCustomType(popr, false)
  6416  	}
  6417  	b.ResetTimer()
  6418  	for i := 0; i < b.N; i++ {
  6419  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6420  		if err != nil {
  6421  			panic(err)
  6422  		}
  6423  		total += len(dAtA)
  6424  	}
  6425  	b.SetBytes(int64(total / b.N))
  6426  }
  6427  
  6428  func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  6429  	popr := math_rand.New(math_rand.NewSource(616))
  6430  	total := 0
  6431  	datas := make([][]byte, 10000)
  6432  	for i := 0; i < 10000; i++ {
  6433  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNonByteCustomType(popr, false))
  6434  		if err != nil {
  6435  			panic(err)
  6436  		}
  6437  		datas[i] = dAtA
  6438  	}
  6439  	msg := &NonByteCustomType{}
  6440  	b.ResetTimer()
  6441  	for i := 0; i < b.N; i++ {
  6442  		total += len(datas[i%10000])
  6443  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6444  			panic(err)
  6445  		}
  6446  	}
  6447  	b.SetBytes(int64(total / b.N))
  6448  }
  6449  
  6450  func TestNidOptNonByteCustomTypeProto(t *testing.T) {
  6451  	seed := time.Now().UnixNano()
  6452  	popr := math_rand.New(math_rand.NewSource(seed))
  6453  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
  6454  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6455  	if err != nil {
  6456  		t.Fatalf("seed = %d, err = %v", seed, err)
  6457  	}
  6458  	msg := &NidOptNonByteCustomType{}
  6459  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6460  		t.Fatalf("seed = %d, err = %v", seed, err)
  6461  	}
  6462  	littlefuzz := make([]byte, len(dAtA))
  6463  	copy(littlefuzz, dAtA)
  6464  	for i := range dAtA {
  6465  		dAtA[i] = byte(popr.Intn(256))
  6466  	}
  6467  	if err := p.VerboseEqual(msg); err != nil {
  6468  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6469  	}
  6470  	if !p.Equal(msg) {
  6471  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6472  	}
  6473  	if len(littlefuzz) > 0 {
  6474  		fuzzamount := 100
  6475  		for i := 0; i < fuzzamount; i++ {
  6476  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6477  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6478  		}
  6479  		// shouldn't panic
  6480  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6481  	}
  6482  }
  6483  
  6484  func TestNidOptNonByteCustomTypeMarshalTo(t *testing.T) {
  6485  	seed := time.Now().UnixNano()
  6486  	popr := math_rand.New(math_rand.NewSource(seed))
  6487  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
  6488  	size := p.Size()
  6489  	dAtA := make([]byte, size)
  6490  	for i := range dAtA {
  6491  		dAtA[i] = byte(popr.Intn(256))
  6492  	}
  6493  	_, err := p.MarshalTo(dAtA)
  6494  	if err != nil {
  6495  		t.Fatalf("seed = %d, err = %v", seed, err)
  6496  	}
  6497  	msg := &NidOptNonByteCustomType{}
  6498  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6499  		t.Fatalf("seed = %d, err = %v", seed, err)
  6500  	}
  6501  	for i := range dAtA {
  6502  		dAtA[i] = byte(popr.Intn(256))
  6503  	}
  6504  	if err := p.VerboseEqual(msg); err != nil {
  6505  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6506  	}
  6507  	if !p.Equal(msg) {
  6508  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6509  	}
  6510  }
  6511  
  6512  func BenchmarkNidOptNonByteCustomTypeProtoMarshal(b *testing.B) {
  6513  	popr := math_rand.New(math_rand.NewSource(616))
  6514  	total := 0
  6515  	pops := make([]*NidOptNonByteCustomType, 10000)
  6516  	for i := 0; i < 10000; i++ {
  6517  		pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
  6518  	}
  6519  	b.ResetTimer()
  6520  	for i := 0; i < b.N; i++ {
  6521  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6522  		if err != nil {
  6523  			panic(err)
  6524  		}
  6525  		total += len(dAtA)
  6526  	}
  6527  	b.SetBytes(int64(total / b.N))
  6528  }
  6529  
  6530  func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  6531  	popr := math_rand.New(math_rand.NewSource(616))
  6532  	total := 0
  6533  	datas := make([][]byte, 10000)
  6534  	for i := 0; i < 10000; i++ {
  6535  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNonByteCustomType(popr, false))
  6536  		if err != nil {
  6537  			panic(err)
  6538  		}
  6539  		datas[i] = dAtA
  6540  	}
  6541  	msg := &NidOptNonByteCustomType{}
  6542  	b.ResetTimer()
  6543  	for i := 0; i < b.N; i++ {
  6544  		total += len(datas[i%10000])
  6545  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6546  			panic(err)
  6547  		}
  6548  	}
  6549  	b.SetBytes(int64(total / b.N))
  6550  }
  6551  
  6552  func TestNinOptNonByteCustomTypeProto(t *testing.T) {
  6553  	seed := time.Now().UnixNano()
  6554  	popr := math_rand.New(math_rand.NewSource(seed))
  6555  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
  6556  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6557  	if err != nil {
  6558  		t.Fatalf("seed = %d, err = %v", seed, err)
  6559  	}
  6560  	msg := &NinOptNonByteCustomType{}
  6561  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6562  		t.Fatalf("seed = %d, err = %v", seed, err)
  6563  	}
  6564  	littlefuzz := make([]byte, len(dAtA))
  6565  	copy(littlefuzz, dAtA)
  6566  	for i := range dAtA {
  6567  		dAtA[i] = byte(popr.Intn(256))
  6568  	}
  6569  	if err := p.VerboseEqual(msg); err != nil {
  6570  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6571  	}
  6572  	if !p.Equal(msg) {
  6573  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6574  	}
  6575  	if len(littlefuzz) > 0 {
  6576  		fuzzamount := 100
  6577  		for i := 0; i < fuzzamount; i++ {
  6578  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6579  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6580  		}
  6581  		// shouldn't panic
  6582  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6583  	}
  6584  }
  6585  
  6586  func TestNinOptNonByteCustomTypeMarshalTo(t *testing.T) {
  6587  	seed := time.Now().UnixNano()
  6588  	popr := math_rand.New(math_rand.NewSource(seed))
  6589  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
  6590  	size := p.Size()
  6591  	dAtA := make([]byte, size)
  6592  	for i := range dAtA {
  6593  		dAtA[i] = byte(popr.Intn(256))
  6594  	}
  6595  	_, err := p.MarshalTo(dAtA)
  6596  	if err != nil {
  6597  		t.Fatalf("seed = %d, err = %v", seed, err)
  6598  	}
  6599  	msg := &NinOptNonByteCustomType{}
  6600  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6601  		t.Fatalf("seed = %d, err = %v", seed, err)
  6602  	}
  6603  	for i := range dAtA {
  6604  		dAtA[i] = byte(popr.Intn(256))
  6605  	}
  6606  	if err := p.VerboseEqual(msg); err != nil {
  6607  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6608  	}
  6609  	if !p.Equal(msg) {
  6610  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6611  	}
  6612  }
  6613  
  6614  func BenchmarkNinOptNonByteCustomTypeProtoMarshal(b *testing.B) {
  6615  	popr := math_rand.New(math_rand.NewSource(616))
  6616  	total := 0
  6617  	pops := make([]*NinOptNonByteCustomType, 10000)
  6618  	for i := 0; i < 10000; i++ {
  6619  		pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
  6620  	}
  6621  	b.ResetTimer()
  6622  	for i := 0; i < b.N; i++ {
  6623  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6624  		if err != nil {
  6625  			panic(err)
  6626  		}
  6627  		total += len(dAtA)
  6628  	}
  6629  	b.SetBytes(int64(total / b.N))
  6630  }
  6631  
  6632  func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  6633  	popr := math_rand.New(math_rand.NewSource(616))
  6634  	total := 0
  6635  	datas := make([][]byte, 10000)
  6636  	for i := 0; i < 10000; i++ {
  6637  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNonByteCustomType(popr, false))
  6638  		if err != nil {
  6639  			panic(err)
  6640  		}
  6641  		datas[i] = dAtA
  6642  	}
  6643  	msg := &NinOptNonByteCustomType{}
  6644  	b.ResetTimer()
  6645  	for i := 0; i < b.N; i++ {
  6646  		total += len(datas[i%10000])
  6647  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6648  			panic(err)
  6649  		}
  6650  	}
  6651  	b.SetBytes(int64(total / b.N))
  6652  }
  6653  
  6654  func TestNidRepNonByteCustomTypeProto(t *testing.T) {
  6655  	seed := time.Now().UnixNano()
  6656  	popr := math_rand.New(math_rand.NewSource(seed))
  6657  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
  6658  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6659  	if err != nil {
  6660  		t.Fatalf("seed = %d, err = %v", seed, err)
  6661  	}
  6662  	msg := &NidRepNonByteCustomType{}
  6663  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6664  		t.Fatalf("seed = %d, err = %v", seed, err)
  6665  	}
  6666  	littlefuzz := make([]byte, len(dAtA))
  6667  	copy(littlefuzz, dAtA)
  6668  	for i := range dAtA {
  6669  		dAtA[i] = byte(popr.Intn(256))
  6670  	}
  6671  	if err := p.VerboseEqual(msg); err != nil {
  6672  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6673  	}
  6674  	if !p.Equal(msg) {
  6675  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6676  	}
  6677  	if len(littlefuzz) > 0 {
  6678  		fuzzamount := 100
  6679  		for i := 0; i < fuzzamount; i++ {
  6680  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6681  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6682  		}
  6683  		// shouldn't panic
  6684  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6685  	}
  6686  }
  6687  
  6688  func TestNidRepNonByteCustomTypeMarshalTo(t *testing.T) {
  6689  	seed := time.Now().UnixNano()
  6690  	popr := math_rand.New(math_rand.NewSource(seed))
  6691  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
  6692  	size := p.Size()
  6693  	dAtA := make([]byte, size)
  6694  	for i := range dAtA {
  6695  		dAtA[i] = byte(popr.Intn(256))
  6696  	}
  6697  	_, err := p.MarshalTo(dAtA)
  6698  	if err != nil {
  6699  		t.Fatalf("seed = %d, err = %v", seed, err)
  6700  	}
  6701  	msg := &NidRepNonByteCustomType{}
  6702  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6703  		t.Fatalf("seed = %d, err = %v", seed, err)
  6704  	}
  6705  	for i := range dAtA {
  6706  		dAtA[i] = byte(popr.Intn(256))
  6707  	}
  6708  	if err := p.VerboseEqual(msg); err != nil {
  6709  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6710  	}
  6711  	if !p.Equal(msg) {
  6712  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6713  	}
  6714  }
  6715  
  6716  func BenchmarkNidRepNonByteCustomTypeProtoMarshal(b *testing.B) {
  6717  	popr := math_rand.New(math_rand.NewSource(616))
  6718  	total := 0
  6719  	pops := make([]*NidRepNonByteCustomType, 10000)
  6720  	for i := 0; i < 10000; i++ {
  6721  		pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
  6722  	}
  6723  	b.ResetTimer()
  6724  	for i := 0; i < b.N; i++ {
  6725  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6726  		if err != nil {
  6727  			panic(err)
  6728  		}
  6729  		total += len(dAtA)
  6730  	}
  6731  	b.SetBytes(int64(total / b.N))
  6732  }
  6733  
  6734  func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  6735  	popr := math_rand.New(math_rand.NewSource(616))
  6736  	total := 0
  6737  	datas := make([][]byte, 10000)
  6738  	for i := 0; i < 10000; i++ {
  6739  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNonByteCustomType(popr, false))
  6740  		if err != nil {
  6741  			panic(err)
  6742  		}
  6743  		datas[i] = dAtA
  6744  	}
  6745  	msg := &NidRepNonByteCustomType{}
  6746  	b.ResetTimer()
  6747  	for i := 0; i < b.N; i++ {
  6748  		total += len(datas[i%10000])
  6749  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6750  			panic(err)
  6751  		}
  6752  	}
  6753  	b.SetBytes(int64(total / b.N))
  6754  }
  6755  
  6756  func TestNinRepNonByteCustomTypeProto(t *testing.T) {
  6757  	seed := time.Now().UnixNano()
  6758  	popr := math_rand.New(math_rand.NewSource(seed))
  6759  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
  6760  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6761  	if err != nil {
  6762  		t.Fatalf("seed = %d, err = %v", seed, err)
  6763  	}
  6764  	msg := &NinRepNonByteCustomType{}
  6765  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6766  		t.Fatalf("seed = %d, err = %v", seed, err)
  6767  	}
  6768  	littlefuzz := make([]byte, len(dAtA))
  6769  	copy(littlefuzz, dAtA)
  6770  	for i := range dAtA {
  6771  		dAtA[i] = byte(popr.Intn(256))
  6772  	}
  6773  	if err := p.VerboseEqual(msg); err != nil {
  6774  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6775  	}
  6776  	if !p.Equal(msg) {
  6777  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6778  	}
  6779  	if len(littlefuzz) > 0 {
  6780  		fuzzamount := 100
  6781  		for i := 0; i < fuzzamount; i++ {
  6782  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6783  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6784  		}
  6785  		// shouldn't panic
  6786  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6787  	}
  6788  }
  6789  
  6790  func TestNinRepNonByteCustomTypeMarshalTo(t *testing.T) {
  6791  	seed := time.Now().UnixNano()
  6792  	popr := math_rand.New(math_rand.NewSource(seed))
  6793  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
  6794  	size := p.Size()
  6795  	dAtA := make([]byte, size)
  6796  	for i := range dAtA {
  6797  		dAtA[i] = byte(popr.Intn(256))
  6798  	}
  6799  	_, err := p.MarshalTo(dAtA)
  6800  	if err != nil {
  6801  		t.Fatalf("seed = %d, err = %v", seed, err)
  6802  	}
  6803  	msg := &NinRepNonByteCustomType{}
  6804  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6805  		t.Fatalf("seed = %d, err = %v", seed, err)
  6806  	}
  6807  	for i := range dAtA {
  6808  		dAtA[i] = byte(popr.Intn(256))
  6809  	}
  6810  	if err := p.VerboseEqual(msg); err != nil {
  6811  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6812  	}
  6813  	if !p.Equal(msg) {
  6814  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6815  	}
  6816  }
  6817  
  6818  func BenchmarkNinRepNonByteCustomTypeProtoMarshal(b *testing.B) {
  6819  	popr := math_rand.New(math_rand.NewSource(616))
  6820  	total := 0
  6821  	pops := make([]*NinRepNonByteCustomType, 10000)
  6822  	for i := 0; i < 10000; i++ {
  6823  		pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
  6824  	}
  6825  	b.ResetTimer()
  6826  	for i := 0; i < b.N; i++ {
  6827  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6828  		if err != nil {
  6829  			panic(err)
  6830  		}
  6831  		total += len(dAtA)
  6832  	}
  6833  	b.SetBytes(int64(total / b.N))
  6834  }
  6835  
  6836  func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  6837  	popr := math_rand.New(math_rand.NewSource(616))
  6838  	total := 0
  6839  	datas := make([][]byte, 10000)
  6840  	for i := 0; i < 10000; i++ {
  6841  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNonByteCustomType(popr, false))
  6842  		if err != nil {
  6843  			panic(err)
  6844  		}
  6845  		datas[i] = dAtA
  6846  	}
  6847  	msg := &NinRepNonByteCustomType{}
  6848  	b.ResetTimer()
  6849  	for i := 0; i < b.N; i++ {
  6850  		total += len(datas[i%10000])
  6851  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6852  			panic(err)
  6853  		}
  6854  	}
  6855  	b.SetBytes(int64(total / b.N))
  6856  }
  6857  
  6858  func TestProtoTypeProto(t *testing.T) {
  6859  	seed := time.Now().UnixNano()
  6860  	popr := math_rand.New(math_rand.NewSource(seed))
  6861  	p := NewPopulatedProtoType(popr, false)
  6862  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  6863  	if err != nil {
  6864  		t.Fatalf("seed = %d, err = %v", seed, err)
  6865  	}
  6866  	msg := &ProtoType{}
  6867  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6868  		t.Fatalf("seed = %d, err = %v", seed, err)
  6869  	}
  6870  	littlefuzz := make([]byte, len(dAtA))
  6871  	copy(littlefuzz, dAtA)
  6872  	for i := range dAtA {
  6873  		dAtA[i] = byte(popr.Intn(256))
  6874  	}
  6875  	if err := p.VerboseEqual(msg); err != nil {
  6876  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6877  	}
  6878  	if !p.Equal(msg) {
  6879  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6880  	}
  6881  	if len(littlefuzz) > 0 {
  6882  		fuzzamount := 100
  6883  		for i := 0; i < fuzzamount; i++ {
  6884  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  6885  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  6886  		}
  6887  		// shouldn't panic
  6888  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  6889  	}
  6890  }
  6891  
  6892  func TestProtoTypeMarshalTo(t *testing.T) {
  6893  	seed := time.Now().UnixNano()
  6894  	popr := math_rand.New(math_rand.NewSource(seed))
  6895  	p := NewPopulatedProtoType(popr, false)
  6896  	size := p.Size()
  6897  	dAtA := make([]byte, size)
  6898  	for i := range dAtA {
  6899  		dAtA[i] = byte(popr.Intn(256))
  6900  	}
  6901  	_, err := p.MarshalTo(dAtA)
  6902  	if err != nil {
  6903  		t.Fatalf("seed = %d, err = %v", seed, err)
  6904  	}
  6905  	msg := &ProtoType{}
  6906  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  6907  		t.Fatalf("seed = %d, err = %v", seed, err)
  6908  	}
  6909  	for i := range dAtA {
  6910  		dAtA[i] = byte(popr.Intn(256))
  6911  	}
  6912  	if err := p.VerboseEqual(msg); err != nil {
  6913  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6914  	}
  6915  	if !p.Equal(msg) {
  6916  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6917  	}
  6918  }
  6919  
  6920  func BenchmarkProtoTypeProtoMarshal(b *testing.B) {
  6921  	popr := math_rand.New(math_rand.NewSource(616))
  6922  	total := 0
  6923  	pops := make([]*ProtoType, 10000)
  6924  	for i := 0; i < 10000; i++ {
  6925  		pops[i] = NewPopulatedProtoType(popr, false)
  6926  	}
  6927  	b.ResetTimer()
  6928  	for i := 0; i < b.N; i++ {
  6929  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  6930  		if err != nil {
  6931  			panic(err)
  6932  		}
  6933  		total += len(dAtA)
  6934  	}
  6935  	b.SetBytes(int64(total / b.N))
  6936  }
  6937  
  6938  func BenchmarkProtoTypeProtoUnmarshal(b *testing.B) {
  6939  	popr := math_rand.New(math_rand.NewSource(616))
  6940  	total := 0
  6941  	datas := make([][]byte, 10000)
  6942  	for i := 0; i < 10000; i++ {
  6943  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedProtoType(popr, false))
  6944  		if err != nil {
  6945  			panic(err)
  6946  		}
  6947  		datas[i] = dAtA
  6948  	}
  6949  	msg := &ProtoType{}
  6950  	b.ResetTimer()
  6951  	for i := 0; i < b.N; i++ {
  6952  		total += len(datas[i%10000])
  6953  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  6954  			panic(err)
  6955  		}
  6956  	}
  6957  	b.SetBytes(int64(total / b.N))
  6958  }
  6959  
  6960  func TestNidOptNativeJSON(t *testing.T) {
  6961  	seed := time.Now().UnixNano()
  6962  	popr := math_rand.New(math_rand.NewSource(seed))
  6963  	p := NewPopulatedNidOptNative(popr, true)
  6964  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6965  	jsondata, err := marshaler.MarshalToString(p)
  6966  	if err != nil {
  6967  		t.Fatalf("seed = %d, err = %v", seed, err)
  6968  	}
  6969  	msg := &NidOptNative{}
  6970  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6971  	if err != nil {
  6972  		t.Fatalf("seed = %d, err = %v", seed, err)
  6973  	}
  6974  	if err := p.VerboseEqual(msg); err != nil {
  6975  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6976  	}
  6977  	if !p.Equal(msg) {
  6978  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6979  	}
  6980  }
  6981  func TestNinOptNativeJSON(t *testing.T) {
  6982  	seed := time.Now().UnixNano()
  6983  	popr := math_rand.New(math_rand.NewSource(seed))
  6984  	p := NewPopulatedNinOptNative(popr, true)
  6985  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6986  	jsondata, err := marshaler.MarshalToString(p)
  6987  	if err != nil {
  6988  		t.Fatalf("seed = %d, err = %v", seed, err)
  6989  	}
  6990  	msg := &NinOptNative{}
  6991  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6992  	if err != nil {
  6993  		t.Fatalf("seed = %d, err = %v", seed, err)
  6994  	}
  6995  	if err := p.VerboseEqual(msg); err != nil {
  6996  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6997  	}
  6998  	if !p.Equal(msg) {
  6999  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7000  	}
  7001  }
  7002  func TestNidRepNativeJSON(t *testing.T) {
  7003  	seed := time.Now().UnixNano()
  7004  	popr := math_rand.New(math_rand.NewSource(seed))
  7005  	p := NewPopulatedNidRepNative(popr, true)
  7006  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7007  	jsondata, err := marshaler.MarshalToString(p)
  7008  	if err != nil {
  7009  		t.Fatalf("seed = %d, err = %v", seed, err)
  7010  	}
  7011  	msg := &NidRepNative{}
  7012  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7013  	if err != nil {
  7014  		t.Fatalf("seed = %d, err = %v", seed, err)
  7015  	}
  7016  	if err := p.VerboseEqual(msg); err != nil {
  7017  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7018  	}
  7019  	if !p.Equal(msg) {
  7020  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7021  	}
  7022  }
  7023  func TestNinRepNativeJSON(t *testing.T) {
  7024  	seed := time.Now().UnixNano()
  7025  	popr := math_rand.New(math_rand.NewSource(seed))
  7026  	p := NewPopulatedNinRepNative(popr, true)
  7027  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7028  	jsondata, err := marshaler.MarshalToString(p)
  7029  	if err != nil {
  7030  		t.Fatalf("seed = %d, err = %v", seed, err)
  7031  	}
  7032  	msg := &NinRepNative{}
  7033  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7034  	if err != nil {
  7035  		t.Fatalf("seed = %d, err = %v", seed, err)
  7036  	}
  7037  	if err := p.VerboseEqual(msg); err != nil {
  7038  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7039  	}
  7040  	if !p.Equal(msg) {
  7041  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7042  	}
  7043  }
  7044  func TestNidRepPackedNativeJSON(t *testing.T) {
  7045  	seed := time.Now().UnixNano()
  7046  	popr := math_rand.New(math_rand.NewSource(seed))
  7047  	p := NewPopulatedNidRepPackedNative(popr, true)
  7048  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7049  	jsondata, err := marshaler.MarshalToString(p)
  7050  	if err != nil {
  7051  		t.Fatalf("seed = %d, err = %v", seed, err)
  7052  	}
  7053  	msg := &NidRepPackedNative{}
  7054  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7055  	if err != nil {
  7056  		t.Fatalf("seed = %d, err = %v", seed, err)
  7057  	}
  7058  	if err := p.VerboseEqual(msg); err != nil {
  7059  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7060  	}
  7061  	if !p.Equal(msg) {
  7062  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7063  	}
  7064  }
  7065  func TestNinRepPackedNativeJSON(t *testing.T) {
  7066  	seed := time.Now().UnixNano()
  7067  	popr := math_rand.New(math_rand.NewSource(seed))
  7068  	p := NewPopulatedNinRepPackedNative(popr, true)
  7069  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7070  	jsondata, err := marshaler.MarshalToString(p)
  7071  	if err != nil {
  7072  		t.Fatalf("seed = %d, err = %v", seed, err)
  7073  	}
  7074  	msg := &NinRepPackedNative{}
  7075  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7076  	if err != nil {
  7077  		t.Fatalf("seed = %d, err = %v", seed, err)
  7078  	}
  7079  	if err := p.VerboseEqual(msg); err != nil {
  7080  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7081  	}
  7082  	if !p.Equal(msg) {
  7083  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7084  	}
  7085  }
  7086  func TestNidOptStructJSON(t *testing.T) {
  7087  	seed := time.Now().UnixNano()
  7088  	popr := math_rand.New(math_rand.NewSource(seed))
  7089  	p := NewPopulatedNidOptStruct(popr, true)
  7090  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7091  	jsondata, err := marshaler.MarshalToString(p)
  7092  	if err != nil {
  7093  		t.Fatalf("seed = %d, err = %v", seed, err)
  7094  	}
  7095  	msg := &NidOptStruct{}
  7096  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7097  	if err != nil {
  7098  		t.Fatalf("seed = %d, err = %v", seed, err)
  7099  	}
  7100  	if err := p.VerboseEqual(msg); err != nil {
  7101  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7102  	}
  7103  	if !p.Equal(msg) {
  7104  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7105  	}
  7106  }
  7107  func TestNinOptStructJSON(t *testing.T) {
  7108  	seed := time.Now().UnixNano()
  7109  	popr := math_rand.New(math_rand.NewSource(seed))
  7110  	p := NewPopulatedNinOptStruct(popr, true)
  7111  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7112  	jsondata, err := marshaler.MarshalToString(p)
  7113  	if err != nil {
  7114  		t.Fatalf("seed = %d, err = %v", seed, err)
  7115  	}
  7116  	msg := &NinOptStruct{}
  7117  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7118  	if err != nil {
  7119  		t.Fatalf("seed = %d, err = %v", seed, err)
  7120  	}
  7121  	if err := p.VerboseEqual(msg); err != nil {
  7122  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7123  	}
  7124  	if !p.Equal(msg) {
  7125  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7126  	}
  7127  }
  7128  func TestNidRepStructJSON(t *testing.T) {
  7129  	seed := time.Now().UnixNano()
  7130  	popr := math_rand.New(math_rand.NewSource(seed))
  7131  	p := NewPopulatedNidRepStruct(popr, true)
  7132  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7133  	jsondata, err := marshaler.MarshalToString(p)
  7134  	if err != nil {
  7135  		t.Fatalf("seed = %d, err = %v", seed, err)
  7136  	}
  7137  	msg := &NidRepStruct{}
  7138  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7139  	if err != nil {
  7140  		t.Fatalf("seed = %d, err = %v", seed, err)
  7141  	}
  7142  	if err := p.VerboseEqual(msg); err != nil {
  7143  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7144  	}
  7145  	if !p.Equal(msg) {
  7146  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7147  	}
  7148  }
  7149  func TestNinRepStructJSON(t *testing.T) {
  7150  	seed := time.Now().UnixNano()
  7151  	popr := math_rand.New(math_rand.NewSource(seed))
  7152  	p := NewPopulatedNinRepStruct(popr, true)
  7153  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7154  	jsondata, err := marshaler.MarshalToString(p)
  7155  	if err != nil {
  7156  		t.Fatalf("seed = %d, err = %v", seed, err)
  7157  	}
  7158  	msg := &NinRepStruct{}
  7159  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7160  	if err != nil {
  7161  		t.Fatalf("seed = %d, err = %v", seed, err)
  7162  	}
  7163  	if err := p.VerboseEqual(msg); err != nil {
  7164  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7165  	}
  7166  	if !p.Equal(msg) {
  7167  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7168  	}
  7169  }
  7170  func TestNidEmbeddedStructJSON(t *testing.T) {
  7171  	seed := time.Now().UnixNano()
  7172  	popr := math_rand.New(math_rand.NewSource(seed))
  7173  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  7174  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7175  	jsondata, err := marshaler.MarshalToString(p)
  7176  	if err != nil {
  7177  		t.Fatalf("seed = %d, err = %v", seed, err)
  7178  	}
  7179  	msg := &NidEmbeddedStruct{}
  7180  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7181  	if err != nil {
  7182  		t.Fatalf("seed = %d, err = %v", seed, err)
  7183  	}
  7184  	if err := p.VerboseEqual(msg); err != nil {
  7185  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7186  	}
  7187  	if !p.Equal(msg) {
  7188  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7189  	}
  7190  }
  7191  func TestNinEmbeddedStructJSON(t *testing.T) {
  7192  	seed := time.Now().UnixNano()
  7193  	popr := math_rand.New(math_rand.NewSource(seed))
  7194  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  7195  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7196  	jsondata, err := marshaler.MarshalToString(p)
  7197  	if err != nil {
  7198  		t.Fatalf("seed = %d, err = %v", seed, err)
  7199  	}
  7200  	msg := &NinEmbeddedStruct{}
  7201  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7202  	if err != nil {
  7203  		t.Fatalf("seed = %d, err = %v", seed, err)
  7204  	}
  7205  	if err := p.VerboseEqual(msg); err != nil {
  7206  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7207  	}
  7208  	if !p.Equal(msg) {
  7209  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7210  	}
  7211  }
  7212  func TestNidNestedStructJSON(t *testing.T) {
  7213  	seed := time.Now().UnixNano()
  7214  	popr := math_rand.New(math_rand.NewSource(seed))
  7215  	p := NewPopulatedNidNestedStruct(popr, true)
  7216  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7217  	jsondata, err := marshaler.MarshalToString(p)
  7218  	if err != nil {
  7219  		t.Fatalf("seed = %d, err = %v", seed, err)
  7220  	}
  7221  	msg := &NidNestedStruct{}
  7222  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7223  	if err != nil {
  7224  		t.Fatalf("seed = %d, err = %v", seed, err)
  7225  	}
  7226  	if err := p.VerboseEqual(msg); err != nil {
  7227  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7228  	}
  7229  	if !p.Equal(msg) {
  7230  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7231  	}
  7232  }
  7233  func TestNinNestedStructJSON(t *testing.T) {
  7234  	seed := time.Now().UnixNano()
  7235  	popr := math_rand.New(math_rand.NewSource(seed))
  7236  	p := NewPopulatedNinNestedStruct(popr, true)
  7237  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7238  	jsondata, err := marshaler.MarshalToString(p)
  7239  	if err != nil {
  7240  		t.Fatalf("seed = %d, err = %v", seed, err)
  7241  	}
  7242  	msg := &NinNestedStruct{}
  7243  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7244  	if err != nil {
  7245  		t.Fatalf("seed = %d, err = %v", seed, err)
  7246  	}
  7247  	if err := p.VerboseEqual(msg); err != nil {
  7248  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7249  	}
  7250  	if !p.Equal(msg) {
  7251  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7252  	}
  7253  }
  7254  func TestNidOptCustomJSON(t *testing.T) {
  7255  	seed := time.Now().UnixNano()
  7256  	popr := math_rand.New(math_rand.NewSource(seed))
  7257  	p := NewPopulatedNidOptCustom(popr, true)
  7258  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7259  	jsondata, err := marshaler.MarshalToString(p)
  7260  	if err != nil {
  7261  		t.Fatalf("seed = %d, err = %v", seed, err)
  7262  	}
  7263  	msg := &NidOptCustom{}
  7264  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7265  	if err != nil {
  7266  		t.Fatalf("seed = %d, err = %v", seed, err)
  7267  	}
  7268  	if err := p.VerboseEqual(msg); err != nil {
  7269  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7270  	}
  7271  	if !p.Equal(msg) {
  7272  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7273  	}
  7274  }
  7275  func TestCustomDashJSON(t *testing.T) {
  7276  	seed := time.Now().UnixNano()
  7277  	popr := math_rand.New(math_rand.NewSource(seed))
  7278  	p := NewPopulatedCustomDash(popr, true)
  7279  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7280  	jsondata, err := marshaler.MarshalToString(p)
  7281  	if err != nil {
  7282  		t.Fatalf("seed = %d, err = %v", seed, err)
  7283  	}
  7284  	msg := &CustomDash{}
  7285  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7286  	if err != nil {
  7287  		t.Fatalf("seed = %d, err = %v", seed, err)
  7288  	}
  7289  	if err := p.VerboseEqual(msg); err != nil {
  7290  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7291  	}
  7292  	if !p.Equal(msg) {
  7293  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7294  	}
  7295  }
  7296  func TestNinOptCustomJSON(t *testing.T) {
  7297  	seed := time.Now().UnixNano()
  7298  	popr := math_rand.New(math_rand.NewSource(seed))
  7299  	p := NewPopulatedNinOptCustom(popr, true)
  7300  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7301  	jsondata, err := marshaler.MarshalToString(p)
  7302  	if err != nil {
  7303  		t.Fatalf("seed = %d, err = %v", seed, err)
  7304  	}
  7305  	msg := &NinOptCustom{}
  7306  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7307  	if err != nil {
  7308  		t.Fatalf("seed = %d, err = %v", seed, err)
  7309  	}
  7310  	if err := p.VerboseEqual(msg); err != nil {
  7311  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7312  	}
  7313  	if !p.Equal(msg) {
  7314  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7315  	}
  7316  }
  7317  func TestNidRepCustomJSON(t *testing.T) {
  7318  	seed := time.Now().UnixNano()
  7319  	popr := math_rand.New(math_rand.NewSource(seed))
  7320  	p := NewPopulatedNidRepCustom(popr, true)
  7321  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7322  	jsondata, err := marshaler.MarshalToString(p)
  7323  	if err != nil {
  7324  		t.Fatalf("seed = %d, err = %v", seed, err)
  7325  	}
  7326  	msg := &NidRepCustom{}
  7327  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7328  	if err != nil {
  7329  		t.Fatalf("seed = %d, err = %v", seed, err)
  7330  	}
  7331  	if err := p.VerboseEqual(msg); err != nil {
  7332  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7333  	}
  7334  	if !p.Equal(msg) {
  7335  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7336  	}
  7337  }
  7338  func TestNinRepCustomJSON(t *testing.T) {
  7339  	seed := time.Now().UnixNano()
  7340  	popr := math_rand.New(math_rand.NewSource(seed))
  7341  	p := NewPopulatedNinRepCustom(popr, true)
  7342  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7343  	jsondata, err := marshaler.MarshalToString(p)
  7344  	if err != nil {
  7345  		t.Fatalf("seed = %d, err = %v", seed, err)
  7346  	}
  7347  	msg := &NinRepCustom{}
  7348  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7349  	if err != nil {
  7350  		t.Fatalf("seed = %d, err = %v", seed, err)
  7351  	}
  7352  	if err := p.VerboseEqual(msg); err != nil {
  7353  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7354  	}
  7355  	if !p.Equal(msg) {
  7356  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7357  	}
  7358  }
  7359  func TestNinOptNativeUnionJSON(t *testing.T) {
  7360  	seed := time.Now().UnixNano()
  7361  	popr := math_rand.New(math_rand.NewSource(seed))
  7362  	p := NewPopulatedNinOptNativeUnion(popr, true)
  7363  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7364  	jsondata, err := marshaler.MarshalToString(p)
  7365  	if err != nil {
  7366  		t.Fatalf("seed = %d, err = %v", seed, err)
  7367  	}
  7368  	msg := &NinOptNativeUnion{}
  7369  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7370  	if err != nil {
  7371  		t.Fatalf("seed = %d, err = %v", seed, err)
  7372  	}
  7373  	if err := p.VerboseEqual(msg); err != nil {
  7374  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7375  	}
  7376  	if !p.Equal(msg) {
  7377  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7378  	}
  7379  }
  7380  func TestNinOptStructUnionJSON(t *testing.T) {
  7381  	seed := time.Now().UnixNano()
  7382  	popr := math_rand.New(math_rand.NewSource(seed))
  7383  	p := NewPopulatedNinOptStructUnion(popr, true)
  7384  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7385  	jsondata, err := marshaler.MarshalToString(p)
  7386  	if err != nil {
  7387  		t.Fatalf("seed = %d, err = %v", seed, err)
  7388  	}
  7389  	msg := &NinOptStructUnion{}
  7390  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7391  	if err != nil {
  7392  		t.Fatalf("seed = %d, err = %v", seed, err)
  7393  	}
  7394  	if err := p.VerboseEqual(msg); err != nil {
  7395  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7396  	}
  7397  	if !p.Equal(msg) {
  7398  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7399  	}
  7400  }
  7401  func TestNinEmbeddedStructUnionJSON(t *testing.T) {
  7402  	seed := time.Now().UnixNano()
  7403  	popr := math_rand.New(math_rand.NewSource(seed))
  7404  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  7405  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7406  	jsondata, err := marshaler.MarshalToString(p)
  7407  	if err != nil {
  7408  		t.Fatalf("seed = %d, err = %v", seed, err)
  7409  	}
  7410  	msg := &NinEmbeddedStructUnion{}
  7411  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7412  	if err != nil {
  7413  		t.Fatalf("seed = %d, err = %v", seed, err)
  7414  	}
  7415  	if err := p.VerboseEqual(msg); err != nil {
  7416  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7417  	}
  7418  	if !p.Equal(msg) {
  7419  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7420  	}
  7421  }
  7422  func TestNinNestedStructUnionJSON(t *testing.T) {
  7423  	seed := time.Now().UnixNano()
  7424  	popr := math_rand.New(math_rand.NewSource(seed))
  7425  	p := NewPopulatedNinNestedStructUnion(popr, true)
  7426  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7427  	jsondata, err := marshaler.MarshalToString(p)
  7428  	if err != nil {
  7429  		t.Fatalf("seed = %d, err = %v", seed, err)
  7430  	}
  7431  	msg := &NinNestedStructUnion{}
  7432  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7433  	if err != nil {
  7434  		t.Fatalf("seed = %d, err = %v", seed, err)
  7435  	}
  7436  	if err := p.VerboseEqual(msg); err != nil {
  7437  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7438  	}
  7439  	if !p.Equal(msg) {
  7440  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7441  	}
  7442  }
  7443  func TestTreeJSON(t *testing.T) {
  7444  	seed := time.Now().UnixNano()
  7445  	popr := math_rand.New(math_rand.NewSource(seed))
  7446  	p := NewPopulatedTree(popr, true)
  7447  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7448  	jsondata, err := marshaler.MarshalToString(p)
  7449  	if err != nil {
  7450  		t.Fatalf("seed = %d, err = %v", seed, err)
  7451  	}
  7452  	msg := &Tree{}
  7453  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7454  	if err != nil {
  7455  		t.Fatalf("seed = %d, err = %v", seed, err)
  7456  	}
  7457  	if err := p.VerboseEqual(msg); err != nil {
  7458  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7459  	}
  7460  	if !p.Equal(msg) {
  7461  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7462  	}
  7463  }
  7464  func TestOrBranchJSON(t *testing.T) {
  7465  	seed := time.Now().UnixNano()
  7466  	popr := math_rand.New(math_rand.NewSource(seed))
  7467  	p := NewPopulatedOrBranch(popr, true)
  7468  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7469  	jsondata, err := marshaler.MarshalToString(p)
  7470  	if err != nil {
  7471  		t.Fatalf("seed = %d, err = %v", seed, err)
  7472  	}
  7473  	msg := &OrBranch{}
  7474  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7475  	if err != nil {
  7476  		t.Fatalf("seed = %d, err = %v", seed, err)
  7477  	}
  7478  	if err := p.VerboseEqual(msg); err != nil {
  7479  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7480  	}
  7481  	if !p.Equal(msg) {
  7482  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7483  	}
  7484  }
  7485  func TestAndBranchJSON(t *testing.T) {
  7486  	seed := time.Now().UnixNano()
  7487  	popr := math_rand.New(math_rand.NewSource(seed))
  7488  	p := NewPopulatedAndBranch(popr, true)
  7489  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7490  	jsondata, err := marshaler.MarshalToString(p)
  7491  	if err != nil {
  7492  		t.Fatalf("seed = %d, err = %v", seed, err)
  7493  	}
  7494  	msg := &AndBranch{}
  7495  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7496  	if err != nil {
  7497  		t.Fatalf("seed = %d, err = %v", seed, err)
  7498  	}
  7499  	if err := p.VerboseEqual(msg); err != nil {
  7500  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7501  	}
  7502  	if !p.Equal(msg) {
  7503  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7504  	}
  7505  }
  7506  func TestLeafJSON(t *testing.T) {
  7507  	seed := time.Now().UnixNano()
  7508  	popr := math_rand.New(math_rand.NewSource(seed))
  7509  	p := NewPopulatedLeaf(popr, true)
  7510  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7511  	jsondata, err := marshaler.MarshalToString(p)
  7512  	if err != nil {
  7513  		t.Fatalf("seed = %d, err = %v", seed, err)
  7514  	}
  7515  	msg := &Leaf{}
  7516  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7517  	if err != nil {
  7518  		t.Fatalf("seed = %d, err = %v", seed, err)
  7519  	}
  7520  	if err := p.VerboseEqual(msg); err != nil {
  7521  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7522  	}
  7523  	if !p.Equal(msg) {
  7524  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7525  	}
  7526  }
  7527  func TestDeepTreeJSON(t *testing.T) {
  7528  	seed := time.Now().UnixNano()
  7529  	popr := math_rand.New(math_rand.NewSource(seed))
  7530  	p := NewPopulatedDeepTree(popr, true)
  7531  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7532  	jsondata, err := marshaler.MarshalToString(p)
  7533  	if err != nil {
  7534  		t.Fatalf("seed = %d, err = %v", seed, err)
  7535  	}
  7536  	msg := &DeepTree{}
  7537  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7538  	if err != nil {
  7539  		t.Fatalf("seed = %d, err = %v", seed, err)
  7540  	}
  7541  	if err := p.VerboseEqual(msg); err != nil {
  7542  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7543  	}
  7544  	if !p.Equal(msg) {
  7545  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7546  	}
  7547  }
  7548  func TestADeepBranchJSON(t *testing.T) {
  7549  	seed := time.Now().UnixNano()
  7550  	popr := math_rand.New(math_rand.NewSource(seed))
  7551  	p := NewPopulatedADeepBranch(popr, true)
  7552  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7553  	jsondata, err := marshaler.MarshalToString(p)
  7554  	if err != nil {
  7555  		t.Fatalf("seed = %d, err = %v", seed, err)
  7556  	}
  7557  	msg := &ADeepBranch{}
  7558  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7559  	if err != nil {
  7560  		t.Fatalf("seed = %d, err = %v", seed, err)
  7561  	}
  7562  	if err := p.VerboseEqual(msg); err != nil {
  7563  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7564  	}
  7565  	if !p.Equal(msg) {
  7566  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7567  	}
  7568  }
  7569  func TestAndDeepBranchJSON(t *testing.T) {
  7570  	seed := time.Now().UnixNano()
  7571  	popr := math_rand.New(math_rand.NewSource(seed))
  7572  	p := NewPopulatedAndDeepBranch(popr, true)
  7573  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7574  	jsondata, err := marshaler.MarshalToString(p)
  7575  	if err != nil {
  7576  		t.Fatalf("seed = %d, err = %v", seed, err)
  7577  	}
  7578  	msg := &AndDeepBranch{}
  7579  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7580  	if err != nil {
  7581  		t.Fatalf("seed = %d, err = %v", seed, err)
  7582  	}
  7583  	if err := p.VerboseEqual(msg); err != nil {
  7584  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7585  	}
  7586  	if !p.Equal(msg) {
  7587  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7588  	}
  7589  }
  7590  func TestDeepLeafJSON(t *testing.T) {
  7591  	seed := time.Now().UnixNano()
  7592  	popr := math_rand.New(math_rand.NewSource(seed))
  7593  	p := NewPopulatedDeepLeaf(popr, true)
  7594  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7595  	jsondata, err := marshaler.MarshalToString(p)
  7596  	if err != nil {
  7597  		t.Fatalf("seed = %d, err = %v", seed, err)
  7598  	}
  7599  	msg := &DeepLeaf{}
  7600  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7601  	if err != nil {
  7602  		t.Fatalf("seed = %d, err = %v", seed, err)
  7603  	}
  7604  	if err := p.VerboseEqual(msg); err != nil {
  7605  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7606  	}
  7607  	if !p.Equal(msg) {
  7608  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7609  	}
  7610  }
  7611  func TestNilJSON(t *testing.T) {
  7612  	seed := time.Now().UnixNano()
  7613  	popr := math_rand.New(math_rand.NewSource(seed))
  7614  	p := NewPopulatedNil(popr, true)
  7615  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7616  	jsondata, err := marshaler.MarshalToString(p)
  7617  	if err != nil {
  7618  		t.Fatalf("seed = %d, err = %v", seed, err)
  7619  	}
  7620  	msg := &Nil{}
  7621  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7622  	if err != nil {
  7623  		t.Fatalf("seed = %d, err = %v", seed, err)
  7624  	}
  7625  	if err := p.VerboseEqual(msg); err != nil {
  7626  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7627  	}
  7628  	if !p.Equal(msg) {
  7629  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7630  	}
  7631  }
  7632  func TestNidOptEnumJSON(t *testing.T) {
  7633  	seed := time.Now().UnixNano()
  7634  	popr := math_rand.New(math_rand.NewSource(seed))
  7635  	p := NewPopulatedNidOptEnum(popr, true)
  7636  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7637  	jsondata, err := marshaler.MarshalToString(p)
  7638  	if err != nil {
  7639  		t.Fatalf("seed = %d, err = %v", seed, err)
  7640  	}
  7641  	msg := &NidOptEnum{}
  7642  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7643  	if err != nil {
  7644  		t.Fatalf("seed = %d, err = %v", seed, err)
  7645  	}
  7646  	if err := p.VerboseEqual(msg); err != nil {
  7647  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7648  	}
  7649  	if !p.Equal(msg) {
  7650  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7651  	}
  7652  }
  7653  func TestNinOptEnumJSON(t *testing.T) {
  7654  	seed := time.Now().UnixNano()
  7655  	popr := math_rand.New(math_rand.NewSource(seed))
  7656  	p := NewPopulatedNinOptEnum(popr, true)
  7657  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7658  	jsondata, err := marshaler.MarshalToString(p)
  7659  	if err != nil {
  7660  		t.Fatalf("seed = %d, err = %v", seed, err)
  7661  	}
  7662  	msg := &NinOptEnum{}
  7663  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7664  	if err != nil {
  7665  		t.Fatalf("seed = %d, err = %v", seed, err)
  7666  	}
  7667  	if err := p.VerboseEqual(msg); err != nil {
  7668  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7669  	}
  7670  	if !p.Equal(msg) {
  7671  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7672  	}
  7673  }
  7674  func TestNidRepEnumJSON(t *testing.T) {
  7675  	seed := time.Now().UnixNano()
  7676  	popr := math_rand.New(math_rand.NewSource(seed))
  7677  	p := NewPopulatedNidRepEnum(popr, true)
  7678  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7679  	jsondata, err := marshaler.MarshalToString(p)
  7680  	if err != nil {
  7681  		t.Fatalf("seed = %d, err = %v", seed, err)
  7682  	}
  7683  	msg := &NidRepEnum{}
  7684  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7685  	if err != nil {
  7686  		t.Fatalf("seed = %d, err = %v", seed, err)
  7687  	}
  7688  	if err := p.VerboseEqual(msg); err != nil {
  7689  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7690  	}
  7691  	if !p.Equal(msg) {
  7692  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7693  	}
  7694  }
  7695  func TestNinRepEnumJSON(t *testing.T) {
  7696  	seed := time.Now().UnixNano()
  7697  	popr := math_rand.New(math_rand.NewSource(seed))
  7698  	p := NewPopulatedNinRepEnum(popr, true)
  7699  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7700  	jsondata, err := marshaler.MarshalToString(p)
  7701  	if err != nil {
  7702  		t.Fatalf("seed = %d, err = %v", seed, err)
  7703  	}
  7704  	msg := &NinRepEnum{}
  7705  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7706  	if err != nil {
  7707  		t.Fatalf("seed = %d, err = %v", seed, err)
  7708  	}
  7709  	if err := p.VerboseEqual(msg); err != nil {
  7710  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7711  	}
  7712  	if !p.Equal(msg) {
  7713  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7714  	}
  7715  }
  7716  func TestNinOptEnumDefaultJSON(t *testing.T) {
  7717  	seed := time.Now().UnixNano()
  7718  	popr := math_rand.New(math_rand.NewSource(seed))
  7719  	p := NewPopulatedNinOptEnumDefault(popr, true)
  7720  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7721  	jsondata, err := marshaler.MarshalToString(p)
  7722  	if err != nil {
  7723  		t.Fatalf("seed = %d, err = %v", seed, err)
  7724  	}
  7725  	msg := &NinOptEnumDefault{}
  7726  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7727  	if err != nil {
  7728  		t.Fatalf("seed = %d, err = %v", seed, err)
  7729  	}
  7730  	if err := p.VerboseEqual(msg); err != nil {
  7731  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7732  	}
  7733  	if !p.Equal(msg) {
  7734  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7735  	}
  7736  }
  7737  func TestAnotherNinOptEnumJSON(t *testing.T) {
  7738  	seed := time.Now().UnixNano()
  7739  	popr := math_rand.New(math_rand.NewSource(seed))
  7740  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  7741  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7742  	jsondata, err := marshaler.MarshalToString(p)
  7743  	if err != nil {
  7744  		t.Fatalf("seed = %d, err = %v", seed, err)
  7745  	}
  7746  	msg := &AnotherNinOptEnum{}
  7747  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7748  	if err != nil {
  7749  		t.Fatalf("seed = %d, err = %v", seed, err)
  7750  	}
  7751  	if err := p.VerboseEqual(msg); err != nil {
  7752  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7753  	}
  7754  	if !p.Equal(msg) {
  7755  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7756  	}
  7757  }
  7758  func TestAnotherNinOptEnumDefaultJSON(t *testing.T) {
  7759  	seed := time.Now().UnixNano()
  7760  	popr := math_rand.New(math_rand.NewSource(seed))
  7761  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  7762  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7763  	jsondata, err := marshaler.MarshalToString(p)
  7764  	if err != nil {
  7765  		t.Fatalf("seed = %d, err = %v", seed, err)
  7766  	}
  7767  	msg := &AnotherNinOptEnumDefault{}
  7768  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7769  	if err != nil {
  7770  		t.Fatalf("seed = %d, err = %v", seed, err)
  7771  	}
  7772  	if err := p.VerboseEqual(msg); err != nil {
  7773  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7774  	}
  7775  	if !p.Equal(msg) {
  7776  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7777  	}
  7778  }
  7779  func TestTimerJSON(t *testing.T) {
  7780  	seed := time.Now().UnixNano()
  7781  	popr := math_rand.New(math_rand.NewSource(seed))
  7782  	p := NewPopulatedTimer(popr, true)
  7783  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7784  	jsondata, err := marshaler.MarshalToString(p)
  7785  	if err != nil {
  7786  		t.Fatalf("seed = %d, err = %v", seed, err)
  7787  	}
  7788  	msg := &Timer{}
  7789  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7790  	if err != nil {
  7791  		t.Fatalf("seed = %d, err = %v", seed, err)
  7792  	}
  7793  	if err := p.VerboseEqual(msg); err != nil {
  7794  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7795  	}
  7796  	if !p.Equal(msg) {
  7797  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7798  	}
  7799  }
  7800  func TestMyExtendableJSON(t *testing.T) {
  7801  	seed := time.Now().UnixNano()
  7802  	popr := math_rand.New(math_rand.NewSource(seed))
  7803  	p := NewPopulatedMyExtendable(popr, true)
  7804  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7805  	jsondata, err := marshaler.MarshalToString(p)
  7806  	if err != nil {
  7807  		t.Fatalf("seed = %d, err = %v", seed, err)
  7808  	}
  7809  	msg := &MyExtendable{}
  7810  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7811  	if err != nil {
  7812  		t.Fatalf("seed = %d, err = %v", seed, err)
  7813  	}
  7814  	if err := p.VerboseEqual(msg); err != nil {
  7815  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7816  	}
  7817  	if !p.Equal(msg) {
  7818  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7819  	}
  7820  }
  7821  func TestOtherExtenableJSON(t *testing.T) {
  7822  	seed := time.Now().UnixNano()
  7823  	popr := math_rand.New(math_rand.NewSource(seed))
  7824  	p := NewPopulatedOtherExtenable(popr, true)
  7825  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7826  	jsondata, err := marshaler.MarshalToString(p)
  7827  	if err != nil {
  7828  		t.Fatalf("seed = %d, err = %v", seed, err)
  7829  	}
  7830  	msg := &OtherExtenable{}
  7831  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7832  	if err != nil {
  7833  		t.Fatalf("seed = %d, err = %v", seed, err)
  7834  	}
  7835  	if err := p.VerboseEqual(msg); err != nil {
  7836  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7837  	}
  7838  	if !p.Equal(msg) {
  7839  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7840  	}
  7841  }
  7842  func TestNestedDefinitionJSON(t *testing.T) {
  7843  	seed := time.Now().UnixNano()
  7844  	popr := math_rand.New(math_rand.NewSource(seed))
  7845  	p := NewPopulatedNestedDefinition(popr, true)
  7846  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7847  	jsondata, err := marshaler.MarshalToString(p)
  7848  	if err != nil {
  7849  		t.Fatalf("seed = %d, err = %v", seed, err)
  7850  	}
  7851  	msg := &NestedDefinition{}
  7852  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7853  	if err != nil {
  7854  		t.Fatalf("seed = %d, err = %v", seed, err)
  7855  	}
  7856  	if err := p.VerboseEqual(msg); err != nil {
  7857  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7858  	}
  7859  	if !p.Equal(msg) {
  7860  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7861  	}
  7862  }
  7863  func TestNestedDefinition_NestedMessageJSON(t *testing.T) {
  7864  	seed := time.Now().UnixNano()
  7865  	popr := math_rand.New(math_rand.NewSource(seed))
  7866  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  7867  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7868  	jsondata, err := marshaler.MarshalToString(p)
  7869  	if err != nil {
  7870  		t.Fatalf("seed = %d, err = %v", seed, err)
  7871  	}
  7872  	msg := &NestedDefinition_NestedMessage{}
  7873  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7874  	if err != nil {
  7875  		t.Fatalf("seed = %d, err = %v", seed, err)
  7876  	}
  7877  	if err := p.VerboseEqual(msg); err != nil {
  7878  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7879  	}
  7880  	if !p.Equal(msg) {
  7881  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7882  	}
  7883  }
  7884  func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) {
  7885  	seed := time.Now().UnixNano()
  7886  	popr := math_rand.New(math_rand.NewSource(seed))
  7887  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  7888  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7889  	jsondata, err := marshaler.MarshalToString(p)
  7890  	if err != nil {
  7891  		t.Fatalf("seed = %d, err = %v", seed, err)
  7892  	}
  7893  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  7894  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7895  	if err != nil {
  7896  		t.Fatalf("seed = %d, err = %v", seed, err)
  7897  	}
  7898  	if err := p.VerboseEqual(msg); err != nil {
  7899  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7900  	}
  7901  	if !p.Equal(msg) {
  7902  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7903  	}
  7904  }
  7905  func TestNestedScopeJSON(t *testing.T) {
  7906  	seed := time.Now().UnixNano()
  7907  	popr := math_rand.New(math_rand.NewSource(seed))
  7908  	p := NewPopulatedNestedScope(popr, true)
  7909  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7910  	jsondata, err := marshaler.MarshalToString(p)
  7911  	if err != nil {
  7912  		t.Fatalf("seed = %d, err = %v", seed, err)
  7913  	}
  7914  	msg := &NestedScope{}
  7915  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7916  	if err != nil {
  7917  		t.Fatalf("seed = %d, err = %v", seed, err)
  7918  	}
  7919  	if err := p.VerboseEqual(msg); err != nil {
  7920  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7921  	}
  7922  	if !p.Equal(msg) {
  7923  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7924  	}
  7925  }
  7926  func TestNinOptNativeDefaultJSON(t *testing.T) {
  7927  	seed := time.Now().UnixNano()
  7928  	popr := math_rand.New(math_rand.NewSource(seed))
  7929  	p := NewPopulatedNinOptNativeDefault(popr, true)
  7930  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7931  	jsondata, err := marshaler.MarshalToString(p)
  7932  	if err != nil {
  7933  		t.Fatalf("seed = %d, err = %v", seed, err)
  7934  	}
  7935  	msg := &NinOptNativeDefault{}
  7936  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7937  	if err != nil {
  7938  		t.Fatalf("seed = %d, err = %v", seed, err)
  7939  	}
  7940  	if err := p.VerboseEqual(msg); err != nil {
  7941  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7942  	}
  7943  	if !p.Equal(msg) {
  7944  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7945  	}
  7946  }
  7947  func TestCustomContainerJSON(t *testing.T) {
  7948  	seed := time.Now().UnixNano()
  7949  	popr := math_rand.New(math_rand.NewSource(seed))
  7950  	p := NewPopulatedCustomContainer(popr, true)
  7951  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7952  	jsondata, err := marshaler.MarshalToString(p)
  7953  	if err != nil {
  7954  		t.Fatalf("seed = %d, err = %v", seed, err)
  7955  	}
  7956  	msg := &CustomContainer{}
  7957  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7958  	if err != nil {
  7959  		t.Fatalf("seed = %d, err = %v", seed, err)
  7960  	}
  7961  	if err := p.VerboseEqual(msg); err != nil {
  7962  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7963  	}
  7964  	if !p.Equal(msg) {
  7965  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7966  	}
  7967  }
  7968  func TestCustomNameNidOptNativeJSON(t *testing.T) {
  7969  	seed := time.Now().UnixNano()
  7970  	popr := math_rand.New(math_rand.NewSource(seed))
  7971  	p := NewPopulatedCustomNameNidOptNative(popr, true)
  7972  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7973  	jsondata, err := marshaler.MarshalToString(p)
  7974  	if err != nil {
  7975  		t.Fatalf("seed = %d, err = %v", seed, err)
  7976  	}
  7977  	msg := &CustomNameNidOptNative{}
  7978  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  7979  	if err != nil {
  7980  		t.Fatalf("seed = %d, err = %v", seed, err)
  7981  	}
  7982  	if err := p.VerboseEqual(msg); err != nil {
  7983  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7984  	}
  7985  	if !p.Equal(msg) {
  7986  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  7987  	}
  7988  }
  7989  func TestCustomNameNinOptNativeJSON(t *testing.T) {
  7990  	seed := time.Now().UnixNano()
  7991  	popr := math_rand.New(math_rand.NewSource(seed))
  7992  	p := NewPopulatedCustomNameNinOptNative(popr, true)
  7993  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  7994  	jsondata, err := marshaler.MarshalToString(p)
  7995  	if err != nil {
  7996  		t.Fatalf("seed = %d, err = %v", seed, err)
  7997  	}
  7998  	msg := &CustomNameNinOptNative{}
  7999  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8000  	if err != nil {
  8001  		t.Fatalf("seed = %d, err = %v", seed, err)
  8002  	}
  8003  	if err := p.VerboseEqual(msg); err != nil {
  8004  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8005  	}
  8006  	if !p.Equal(msg) {
  8007  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8008  	}
  8009  }
  8010  func TestCustomNameNinRepNativeJSON(t *testing.T) {
  8011  	seed := time.Now().UnixNano()
  8012  	popr := math_rand.New(math_rand.NewSource(seed))
  8013  	p := NewPopulatedCustomNameNinRepNative(popr, true)
  8014  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8015  	jsondata, err := marshaler.MarshalToString(p)
  8016  	if err != nil {
  8017  		t.Fatalf("seed = %d, err = %v", seed, err)
  8018  	}
  8019  	msg := &CustomNameNinRepNative{}
  8020  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8021  	if err != nil {
  8022  		t.Fatalf("seed = %d, err = %v", seed, err)
  8023  	}
  8024  	if err := p.VerboseEqual(msg); err != nil {
  8025  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8026  	}
  8027  	if !p.Equal(msg) {
  8028  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8029  	}
  8030  }
  8031  func TestCustomNameNinStructJSON(t *testing.T) {
  8032  	seed := time.Now().UnixNano()
  8033  	popr := math_rand.New(math_rand.NewSource(seed))
  8034  	p := NewPopulatedCustomNameNinStruct(popr, true)
  8035  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8036  	jsondata, err := marshaler.MarshalToString(p)
  8037  	if err != nil {
  8038  		t.Fatalf("seed = %d, err = %v", seed, err)
  8039  	}
  8040  	msg := &CustomNameNinStruct{}
  8041  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8042  	if err != nil {
  8043  		t.Fatalf("seed = %d, err = %v", seed, err)
  8044  	}
  8045  	if err := p.VerboseEqual(msg); err != nil {
  8046  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8047  	}
  8048  	if !p.Equal(msg) {
  8049  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8050  	}
  8051  }
  8052  func TestCustomNameCustomTypeJSON(t *testing.T) {
  8053  	seed := time.Now().UnixNano()
  8054  	popr := math_rand.New(math_rand.NewSource(seed))
  8055  	p := NewPopulatedCustomNameCustomType(popr, true)
  8056  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8057  	jsondata, err := marshaler.MarshalToString(p)
  8058  	if err != nil {
  8059  		t.Fatalf("seed = %d, err = %v", seed, err)
  8060  	}
  8061  	msg := &CustomNameCustomType{}
  8062  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8063  	if err != nil {
  8064  		t.Fatalf("seed = %d, err = %v", seed, err)
  8065  	}
  8066  	if err := p.VerboseEqual(msg); err != nil {
  8067  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8068  	}
  8069  	if !p.Equal(msg) {
  8070  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8071  	}
  8072  }
  8073  func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) {
  8074  	seed := time.Now().UnixNano()
  8075  	popr := math_rand.New(math_rand.NewSource(seed))
  8076  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
  8077  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8078  	jsondata, err := marshaler.MarshalToString(p)
  8079  	if err != nil {
  8080  		t.Fatalf("seed = %d, err = %v", seed, err)
  8081  	}
  8082  	msg := &CustomNameNinEmbeddedStructUnion{}
  8083  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8084  	if err != nil {
  8085  		t.Fatalf("seed = %d, err = %v", seed, err)
  8086  	}
  8087  	if err := p.VerboseEqual(msg); err != nil {
  8088  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8089  	}
  8090  	if !p.Equal(msg) {
  8091  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8092  	}
  8093  }
  8094  func TestCustomNameEnumJSON(t *testing.T) {
  8095  	seed := time.Now().UnixNano()
  8096  	popr := math_rand.New(math_rand.NewSource(seed))
  8097  	p := NewPopulatedCustomNameEnum(popr, true)
  8098  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8099  	jsondata, err := marshaler.MarshalToString(p)
  8100  	if err != nil {
  8101  		t.Fatalf("seed = %d, err = %v", seed, err)
  8102  	}
  8103  	msg := &CustomNameEnum{}
  8104  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8105  	if err != nil {
  8106  		t.Fatalf("seed = %d, err = %v", seed, err)
  8107  	}
  8108  	if err := p.VerboseEqual(msg); err != nil {
  8109  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8110  	}
  8111  	if !p.Equal(msg) {
  8112  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8113  	}
  8114  }
  8115  func TestNoExtensionsMapJSON(t *testing.T) {
  8116  	seed := time.Now().UnixNano()
  8117  	popr := math_rand.New(math_rand.NewSource(seed))
  8118  	p := NewPopulatedNoExtensionsMap(popr, true)
  8119  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8120  	jsondata, err := marshaler.MarshalToString(p)
  8121  	if err != nil {
  8122  		t.Fatalf("seed = %d, err = %v", seed, err)
  8123  	}
  8124  	msg := &NoExtensionsMap{}
  8125  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8126  	if err != nil {
  8127  		t.Fatalf("seed = %d, err = %v", seed, err)
  8128  	}
  8129  	if err := p.VerboseEqual(msg); err != nil {
  8130  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8131  	}
  8132  	if !p.Equal(msg) {
  8133  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8134  	}
  8135  }
  8136  func TestUnrecognizedJSON(t *testing.T) {
  8137  	seed := time.Now().UnixNano()
  8138  	popr := math_rand.New(math_rand.NewSource(seed))
  8139  	p := NewPopulatedUnrecognized(popr, true)
  8140  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8141  	jsondata, err := marshaler.MarshalToString(p)
  8142  	if err != nil {
  8143  		t.Fatalf("seed = %d, err = %v", seed, err)
  8144  	}
  8145  	msg := &Unrecognized{}
  8146  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8147  	if err != nil {
  8148  		t.Fatalf("seed = %d, err = %v", seed, err)
  8149  	}
  8150  	if err := p.VerboseEqual(msg); err != nil {
  8151  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8152  	}
  8153  	if !p.Equal(msg) {
  8154  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8155  	}
  8156  }
  8157  func TestUnrecognizedWithInnerJSON(t *testing.T) {
  8158  	seed := time.Now().UnixNano()
  8159  	popr := math_rand.New(math_rand.NewSource(seed))
  8160  	p := NewPopulatedUnrecognizedWithInner(popr, true)
  8161  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8162  	jsondata, err := marshaler.MarshalToString(p)
  8163  	if err != nil {
  8164  		t.Fatalf("seed = %d, err = %v", seed, err)
  8165  	}
  8166  	msg := &UnrecognizedWithInner{}
  8167  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8168  	if err != nil {
  8169  		t.Fatalf("seed = %d, err = %v", seed, err)
  8170  	}
  8171  	if err := p.VerboseEqual(msg); err != nil {
  8172  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8173  	}
  8174  	if !p.Equal(msg) {
  8175  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8176  	}
  8177  }
  8178  func TestUnrecognizedWithInner_InnerJSON(t *testing.T) {
  8179  	seed := time.Now().UnixNano()
  8180  	popr := math_rand.New(math_rand.NewSource(seed))
  8181  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
  8182  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8183  	jsondata, err := marshaler.MarshalToString(p)
  8184  	if err != nil {
  8185  		t.Fatalf("seed = %d, err = %v", seed, err)
  8186  	}
  8187  	msg := &UnrecognizedWithInner_Inner{}
  8188  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8189  	if err != nil {
  8190  		t.Fatalf("seed = %d, err = %v", seed, err)
  8191  	}
  8192  	if err := p.VerboseEqual(msg); err != nil {
  8193  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8194  	}
  8195  	if !p.Equal(msg) {
  8196  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8197  	}
  8198  }
  8199  func TestUnrecognizedWithEmbedJSON(t *testing.T) {
  8200  	seed := time.Now().UnixNano()
  8201  	popr := math_rand.New(math_rand.NewSource(seed))
  8202  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
  8203  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8204  	jsondata, err := marshaler.MarshalToString(p)
  8205  	if err != nil {
  8206  		t.Fatalf("seed = %d, err = %v", seed, err)
  8207  	}
  8208  	msg := &UnrecognizedWithEmbed{}
  8209  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8210  	if err != nil {
  8211  		t.Fatalf("seed = %d, err = %v", seed, err)
  8212  	}
  8213  	if err := p.VerboseEqual(msg); err != nil {
  8214  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8215  	}
  8216  	if !p.Equal(msg) {
  8217  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8218  	}
  8219  }
  8220  func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) {
  8221  	seed := time.Now().UnixNano()
  8222  	popr := math_rand.New(math_rand.NewSource(seed))
  8223  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
  8224  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8225  	jsondata, err := marshaler.MarshalToString(p)
  8226  	if err != nil {
  8227  		t.Fatalf("seed = %d, err = %v", seed, err)
  8228  	}
  8229  	msg := &UnrecognizedWithEmbed_Embedded{}
  8230  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8231  	if err != nil {
  8232  		t.Fatalf("seed = %d, err = %v", seed, err)
  8233  	}
  8234  	if err := p.VerboseEqual(msg); err != nil {
  8235  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8236  	}
  8237  	if !p.Equal(msg) {
  8238  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8239  	}
  8240  }
  8241  func TestNodeJSON(t *testing.T) {
  8242  	seed := time.Now().UnixNano()
  8243  	popr := math_rand.New(math_rand.NewSource(seed))
  8244  	p := NewPopulatedNode(popr, true)
  8245  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8246  	jsondata, err := marshaler.MarshalToString(p)
  8247  	if err != nil {
  8248  		t.Fatalf("seed = %d, err = %v", seed, err)
  8249  	}
  8250  	msg := &Node{}
  8251  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8252  	if err != nil {
  8253  		t.Fatalf("seed = %d, err = %v", seed, err)
  8254  	}
  8255  	if err := p.VerboseEqual(msg); err != nil {
  8256  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8257  	}
  8258  	if !p.Equal(msg) {
  8259  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8260  	}
  8261  }
  8262  func TestNonByteCustomTypeJSON(t *testing.T) {
  8263  	seed := time.Now().UnixNano()
  8264  	popr := math_rand.New(math_rand.NewSource(seed))
  8265  	p := NewPopulatedNonByteCustomType(popr, true)
  8266  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8267  	jsondata, err := marshaler.MarshalToString(p)
  8268  	if err != nil {
  8269  		t.Fatalf("seed = %d, err = %v", seed, err)
  8270  	}
  8271  	msg := &NonByteCustomType{}
  8272  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8273  	if err != nil {
  8274  		t.Fatalf("seed = %d, err = %v", seed, err)
  8275  	}
  8276  	if err := p.VerboseEqual(msg); err != nil {
  8277  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8278  	}
  8279  	if !p.Equal(msg) {
  8280  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8281  	}
  8282  }
  8283  func TestNidOptNonByteCustomTypeJSON(t *testing.T) {
  8284  	seed := time.Now().UnixNano()
  8285  	popr := math_rand.New(math_rand.NewSource(seed))
  8286  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
  8287  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8288  	jsondata, err := marshaler.MarshalToString(p)
  8289  	if err != nil {
  8290  		t.Fatalf("seed = %d, err = %v", seed, err)
  8291  	}
  8292  	msg := &NidOptNonByteCustomType{}
  8293  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8294  	if err != nil {
  8295  		t.Fatalf("seed = %d, err = %v", seed, err)
  8296  	}
  8297  	if err := p.VerboseEqual(msg); err != nil {
  8298  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8299  	}
  8300  	if !p.Equal(msg) {
  8301  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8302  	}
  8303  }
  8304  func TestNinOptNonByteCustomTypeJSON(t *testing.T) {
  8305  	seed := time.Now().UnixNano()
  8306  	popr := math_rand.New(math_rand.NewSource(seed))
  8307  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
  8308  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8309  	jsondata, err := marshaler.MarshalToString(p)
  8310  	if err != nil {
  8311  		t.Fatalf("seed = %d, err = %v", seed, err)
  8312  	}
  8313  	msg := &NinOptNonByteCustomType{}
  8314  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8315  	if err != nil {
  8316  		t.Fatalf("seed = %d, err = %v", seed, err)
  8317  	}
  8318  	if err := p.VerboseEqual(msg); err != nil {
  8319  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8320  	}
  8321  	if !p.Equal(msg) {
  8322  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8323  	}
  8324  }
  8325  func TestNidRepNonByteCustomTypeJSON(t *testing.T) {
  8326  	seed := time.Now().UnixNano()
  8327  	popr := math_rand.New(math_rand.NewSource(seed))
  8328  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
  8329  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8330  	jsondata, err := marshaler.MarshalToString(p)
  8331  	if err != nil {
  8332  		t.Fatalf("seed = %d, err = %v", seed, err)
  8333  	}
  8334  	msg := &NidRepNonByteCustomType{}
  8335  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8336  	if err != nil {
  8337  		t.Fatalf("seed = %d, err = %v", seed, err)
  8338  	}
  8339  	if err := p.VerboseEqual(msg); err != nil {
  8340  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8341  	}
  8342  	if !p.Equal(msg) {
  8343  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8344  	}
  8345  }
  8346  func TestNinRepNonByteCustomTypeJSON(t *testing.T) {
  8347  	seed := time.Now().UnixNano()
  8348  	popr := math_rand.New(math_rand.NewSource(seed))
  8349  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
  8350  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8351  	jsondata, err := marshaler.MarshalToString(p)
  8352  	if err != nil {
  8353  		t.Fatalf("seed = %d, err = %v", seed, err)
  8354  	}
  8355  	msg := &NinRepNonByteCustomType{}
  8356  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8357  	if err != nil {
  8358  		t.Fatalf("seed = %d, err = %v", seed, err)
  8359  	}
  8360  	if err := p.VerboseEqual(msg); err != nil {
  8361  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8362  	}
  8363  	if !p.Equal(msg) {
  8364  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8365  	}
  8366  }
  8367  func TestProtoTypeJSON(t *testing.T) {
  8368  	seed := time.Now().UnixNano()
  8369  	popr := math_rand.New(math_rand.NewSource(seed))
  8370  	p := NewPopulatedProtoType(popr, true)
  8371  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  8372  	jsondata, err := marshaler.MarshalToString(p)
  8373  	if err != nil {
  8374  		t.Fatalf("seed = %d, err = %v", seed, err)
  8375  	}
  8376  	msg := &ProtoType{}
  8377  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  8378  	if err != nil {
  8379  		t.Fatalf("seed = %d, err = %v", seed, err)
  8380  	}
  8381  	if err := p.VerboseEqual(msg); err != nil {
  8382  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8383  	}
  8384  	if !p.Equal(msg) {
  8385  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  8386  	}
  8387  }
  8388  func TestNidOptNativeProtoText(t *testing.T) {
  8389  	seed := time.Now().UnixNano()
  8390  	popr := math_rand.New(math_rand.NewSource(seed))
  8391  	p := NewPopulatedNidOptNative(popr, true)
  8392  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8393  	msg := &NidOptNative{}
  8394  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8395  		t.Fatalf("seed = %d, err = %v", seed, err)
  8396  	}
  8397  	if err := p.VerboseEqual(msg); err != nil {
  8398  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8399  	}
  8400  	if !p.Equal(msg) {
  8401  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8402  	}
  8403  }
  8404  
  8405  func TestNidOptNativeProtoCompactText(t *testing.T) {
  8406  	seed := time.Now().UnixNano()
  8407  	popr := math_rand.New(math_rand.NewSource(seed))
  8408  	p := NewPopulatedNidOptNative(popr, true)
  8409  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8410  	msg := &NidOptNative{}
  8411  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8412  		t.Fatalf("seed = %d, err = %v", seed, err)
  8413  	}
  8414  	if err := p.VerboseEqual(msg); err != nil {
  8415  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8416  	}
  8417  	if !p.Equal(msg) {
  8418  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8419  	}
  8420  }
  8421  
  8422  func TestNinOptNativeProtoText(t *testing.T) {
  8423  	seed := time.Now().UnixNano()
  8424  	popr := math_rand.New(math_rand.NewSource(seed))
  8425  	p := NewPopulatedNinOptNative(popr, true)
  8426  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8427  	msg := &NinOptNative{}
  8428  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8429  		t.Fatalf("seed = %d, err = %v", seed, err)
  8430  	}
  8431  	if err := p.VerboseEqual(msg); err != nil {
  8432  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8433  	}
  8434  	if !p.Equal(msg) {
  8435  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8436  	}
  8437  }
  8438  
  8439  func TestNinOptNativeProtoCompactText(t *testing.T) {
  8440  	seed := time.Now().UnixNano()
  8441  	popr := math_rand.New(math_rand.NewSource(seed))
  8442  	p := NewPopulatedNinOptNative(popr, true)
  8443  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8444  	msg := &NinOptNative{}
  8445  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8446  		t.Fatalf("seed = %d, err = %v", seed, err)
  8447  	}
  8448  	if err := p.VerboseEqual(msg); err != nil {
  8449  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8450  	}
  8451  	if !p.Equal(msg) {
  8452  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8453  	}
  8454  }
  8455  
  8456  func TestNidRepNativeProtoText(t *testing.T) {
  8457  	seed := time.Now().UnixNano()
  8458  	popr := math_rand.New(math_rand.NewSource(seed))
  8459  	p := NewPopulatedNidRepNative(popr, true)
  8460  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8461  	msg := &NidRepNative{}
  8462  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8463  		t.Fatalf("seed = %d, err = %v", seed, err)
  8464  	}
  8465  	if err := p.VerboseEqual(msg); err != nil {
  8466  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8467  	}
  8468  	if !p.Equal(msg) {
  8469  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8470  	}
  8471  }
  8472  
  8473  func TestNidRepNativeProtoCompactText(t *testing.T) {
  8474  	seed := time.Now().UnixNano()
  8475  	popr := math_rand.New(math_rand.NewSource(seed))
  8476  	p := NewPopulatedNidRepNative(popr, true)
  8477  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8478  	msg := &NidRepNative{}
  8479  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8480  		t.Fatalf("seed = %d, err = %v", seed, err)
  8481  	}
  8482  	if err := p.VerboseEqual(msg); err != nil {
  8483  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8484  	}
  8485  	if !p.Equal(msg) {
  8486  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8487  	}
  8488  }
  8489  
  8490  func TestNinRepNativeProtoText(t *testing.T) {
  8491  	seed := time.Now().UnixNano()
  8492  	popr := math_rand.New(math_rand.NewSource(seed))
  8493  	p := NewPopulatedNinRepNative(popr, true)
  8494  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8495  	msg := &NinRepNative{}
  8496  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8497  		t.Fatalf("seed = %d, err = %v", seed, err)
  8498  	}
  8499  	if err := p.VerboseEqual(msg); err != nil {
  8500  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8501  	}
  8502  	if !p.Equal(msg) {
  8503  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8504  	}
  8505  }
  8506  
  8507  func TestNinRepNativeProtoCompactText(t *testing.T) {
  8508  	seed := time.Now().UnixNano()
  8509  	popr := math_rand.New(math_rand.NewSource(seed))
  8510  	p := NewPopulatedNinRepNative(popr, true)
  8511  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8512  	msg := &NinRepNative{}
  8513  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8514  		t.Fatalf("seed = %d, err = %v", seed, err)
  8515  	}
  8516  	if err := p.VerboseEqual(msg); err != nil {
  8517  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8518  	}
  8519  	if !p.Equal(msg) {
  8520  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8521  	}
  8522  }
  8523  
  8524  func TestNidRepPackedNativeProtoText(t *testing.T) {
  8525  	seed := time.Now().UnixNano()
  8526  	popr := math_rand.New(math_rand.NewSource(seed))
  8527  	p := NewPopulatedNidRepPackedNative(popr, true)
  8528  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8529  	msg := &NidRepPackedNative{}
  8530  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8531  		t.Fatalf("seed = %d, err = %v", seed, err)
  8532  	}
  8533  	if err := p.VerboseEqual(msg); err != nil {
  8534  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8535  	}
  8536  	if !p.Equal(msg) {
  8537  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8538  	}
  8539  }
  8540  
  8541  func TestNidRepPackedNativeProtoCompactText(t *testing.T) {
  8542  	seed := time.Now().UnixNano()
  8543  	popr := math_rand.New(math_rand.NewSource(seed))
  8544  	p := NewPopulatedNidRepPackedNative(popr, true)
  8545  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8546  	msg := &NidRepPackedNative{}
  8547  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8548  		t.Fatalf("seed = %d, err = %v", seed, err)
  8549  	}
  8550  	if err := p.VerboseEqual(msg); err != nil {
  8551  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8552  	}
  8553  	if !p.Equal(msg) {
  8554  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8555  	}
  8556  }
  8557  
  8558  func TestNinRepPackedNativeProtoText(t *testing.T) {
  8559  	seed := time.Now().UnixNano()
  8560  	popr := math_rand.New(math_rand.NewSource(seed))
  8561  	p := NewPopulatedNinRepPackedNative(popr, true)
  8562  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8563  	msg := &NinRepPackedNative{}
  8564  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8565  		t.Fatalf("seed = %d, err = %v", seed, err)
  8566  	}
  8567  	if err := p.VerboseEqual(msg); err != nil {
  8568  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8569  	}
  8570  	if !p.Equal(msg) {
  8571  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8572  	}
  8573  }
  8574  
  8575  func TestNinRepPackedNativeProtoCompactText(t *testing.T) {
  8576  	seed := time.Now().UnixNano()
  8577  	popr := math_rand.New(math_rand.NewSource(seed))
  8578  	p := NewPopulatedNinRepPackedNative(popr, true)
  8579  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8580  	msg := &NinRepPackedNative{}
  8581  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8582  		t.Fatalf("seed = %d, err = %v", seed, err)
  8583  	}
  8584  	if err := p.VerboseEqual(msg); err != nil {
  8585  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8586  	}
  8587  	if !p.Equal(msg) {
  8588  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8589  	}
  8590  }
  8591  
  8592  func TestNidOptStructProtoText(t *testing.T) {
  8593  	seed := time.Now().UnixNano()
  8594  	popr := math_rand.New(math_rand.NewSource(seed))
  8595  	p := NewPopulatedNidOptStruct(popr, true)
  8596  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8597  	msg := &NidOptStruct{}
  8598  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8599  		t.Fatalf("seed = %d, err = %v", seed, err)
  8600  	}
  8601  	if err := p.VerboseEqual(msg); err != nil {
  8602  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8603  	}
  8604  	if !p.Equal(msg) {
  8605  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8606  	}
  8607  }
  8608  
  8609  func TestNidOptStructProtoCompactText(t *testing.T) {
  8610  	seed := time.Now().UnixNano()
  8611  	popr := math_rand.New(math_rand.NewSource(seed))
  8612  	p := NewPopulatedNidOptStruct(popr, true)
  8613  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8614  	msg := &NidOptStruct{}
  8615  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8616  		t.Fatalf("seed = %d, err = %v", seed, err)
  8617  	}
  8618  	if err := p.VerboseEqual(msg); err != nil {
  8619  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8620  	}
  8621  	if !p.Equal(msg) {
  8622  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8623  	}
  8624  }
  8625  
  8626  func TestNinOptStructProtoText(t *testing.T) {
  8627  	seed := time.Now().UnixNano()
  8628  	popr := math_rand.New(math_rand.NewSource(seed))
  8629  	p := NewPopulatedNinOptStruct(popr, true)
  8630  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8631  	msg := &NinOptStruct{}
  8632  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8633  		t.Fatalf("seed = %d, err = %v", seed, err)
  8634  	}
  8635  	if err := p.VerboseEqual(msg); err != nil {
  8636  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8637  	}
  8638  	if !p.Equal(msg) {
  8639  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8640  	}
  8641  }
  8642  
  8643  func TestNinOptStructProtoCompactText(t *testing.T) {
  8644  	seed := time.Now().UnixNano()
  8645  	popr := math_rand.New(math_rand.NewSource(seed))
  8646  	p := NewPopulatedNinOptStruct(popr, true)
  8647  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8648  	msg := &NinOptStruct{}
  8649  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8650  		t.Fatalf("seed = %d, err = %v", seed, err)
  8651  	}
  8652  	if err := p.VerboseEqual(msg); err != nil {
  8653  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8654  	}
  8655  	if !p.Equal(msg) {
  8656  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8657  	}
  8658  }
  8659  
  8660  func TestNidRepStructProtoText(t *testing.T) {
  8661  	seed := time.Now().UnixNano()
  8662  	popr := math_rand.New(math_rand.NewSource(seed))
  8663  	p := NewPopulatedNidRepStruct(popr, true)
  8664  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8665  	msg := &NidRepStruct{}
  8666  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8667  		t.Fatalf("seed = %d, err = %v", seed, err)
  8668  	}
  8669  	if err := p.VerboseEqual(msg); err != nil {
  8670  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8671  	}
  8672  	if !p.Equal(msg) {
  8673  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8674  	}
  8675  }
  8676  
  8677  func TestNidRepStructProtoCompactText(t *testing.T) {
  8678  	seed := time.Now().UnixNano()
  8679  	popr := math_rand.New(math_rand.NewSource(seed))
  8680  	p := NewPopulatedNidRepStruct(popr, true)
  8681  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8682  	msg := &NidRepStruct{}
  8683  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8684  		t.Fatalf("seed = %d, err = %v", seed, err)
  8685  	}
  8686  	if err := p.VerboseEqual(msg); err != nil {
  8687  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8688  	}
  8689  	if !p.Equal(msg) {
  8690  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8691  	}
  8692  }
  8693  
  8694  func TestNinRepStructProtoText(t *testing.T) {
  8695  	seed := time.Now().UnixNano()
  8696  	popr := math_rand.New(math_rand.NewSource(seed))
  8697  	p := NewPopulatedNinRepStruct(popr, true)
  8698  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8699  	msg := &NinRepStruct{}
  8700  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8701  		t.Fatalf("seed = %d, err = %v", seed, err)
  8702  	}
  8703  	if err := p.VerboseEqual(msg); err != nil {
  8704  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8705  	}
  8706  	if !p.Equal(msg) {
  8707  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8708  	}
  8709  }
  8710  
  8711  func TestNinRepStructProtoCompactText(t *testing.T) {
  8712  	seed := time.Now().UnixNano()
  8713  	popr := math_rand.New(math_rand.NewSource(seed))
  8714  	p := NewPopulatedNinRepStruct(popr, true)
  8715  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8716  	msg := &NinRepStruct{}
  8717  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8718  		t.Fatalf("seed = %d, err = %v", seed, err)
  8719  	}
  8720  	if err := p.VerboseEqual(msg); err != nil {
  8721  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8722  	}
  8723  	if !p.Equal(msg) {
  8724  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8725  	}
  8726  }
  8727  
  8728  func TestNidEmbeddedStructProtoText(t *testing.T) {
  8729  	seed := time.Now().UnixNano()
  8730  	popr := math_rand.New(math_rand.NewSource(seed))
  8731  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  8732  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8733  	msg := &NidEmbeddedStruct{}
  8734  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8735  		t.Fatalf("seed = %d, err = %v", seed, err)
  8736  	}
  8737  	if err := p.VerboseEqual(msg); err != nil {
  8738  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8739  	}
  8740  	if !p.Equal(msg) {
  8741  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8742  	}
  8743  }
  8744  
  8745  func TestNidEmbeddedStructProtoCompactText(t *testing.T) {
  8746  	seed := time.Now().UnixNano()
  8747  	popr := math_rand.New(math_rand.NewSource(seed))
  8748  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  8749  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8750  	msg := &NidEmbeddedStruct{}
  8751  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8752  		t.Fatalf("seed = %d, err = %v", seed, err)
  8753  	}
  8754  	if err := p.VerboseEqual(msg); err != nil {
  8755  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8756  	}
  8757  	if !p.Equal(msg) {
  8758  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8759  	}
  8760  }
  8761  
  8762  func TestNinEmbeddedStructProtoText(t *testing.T) {
  8763  	seed := time.Now().UnixNano()
  8764  	popr := math_rand.New(math_rand.NewSource(seed))
  8765  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  8766  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8767  	msg := &NinEmbeddedStruct{}
  8768  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8769  		t.Fatalf("seed = %d, err = %v", seed, err)
  8770  	}
  8771  	if err := p.VerboseEqual(msg); err != nil {
  8772  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8773  	}
  8774  	if !p.Equal(msg) {
  8775  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8776  	}
  8777  }
  8778  
  8779  func TestNinEmbeddedStructProtoCompactText(t *testing.T) {
  8780  	seed := time.Now().UnixNano()
  8781  	popr := math_rand.New(math_rand.NewSource(seed))
  8782  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  8783  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8784  	msg := &NinEmbeddedStruct{}
  8785  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8786  		t.Fatalf("seed = %d, err = %v", seed, err)
  8787  	}
  8788  	if err := p.VerboseEqual(msg); err != nil {
  8789  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8790  	}
  8791  	if !p.Equal(msg) {
  8792  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8793  	}
  8794  }
  8795  
  8796  func TestNidNestedStructProtoText(t *testing.T) {
  8797  	seed := time.Now().UnixNano()
  8798  	popr := math_rand.New(math_rand.NewSource(seed))
  8799  	p := NewPopulatedNidNestedStruct(popr, true)
  8800  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8801  	msg := &NidNestedStruct{}
  8802  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8803  		t.Fatalf("seed = %d, err = %v", seed, err)
  8804  	}
  8805  	if err := p.VerboseEqual(msg); err != nil {
  8806  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8807  	}
  8808  	if !p.Equal(msg) {
  8809  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8810  	}
  8811  }
  8812  
  8813  func TestNidNestedStructProtoCompactText(t *testing.T) {
  8814  	seed := time.Now().UnixNano()
  8815  	popr := math_rand.New(math_rand.NewSource(seed))
  8816  	p := NewPopulatedNidNestedStruct(popr, true)
  8817  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8818  	msg := &NidNestedStruct{}
  8819  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8820  		t.Fatalf("seed = %d, err = %v", seed, err)
  8821  	}
  8822  	if err := p.VerboseEqual(msg); err != nil {
  8823  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8824  	}
  8825  	if !p.Equal(msg) {
  8826  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8827  	}
  8828  }
  8829  
  8830  func TestNinNestedStructProtoText(t *testing.T) {
  8831  	seed := time.Now().UnixNano()
  8832  	popr := math_rand.New(math_rand.NewSource(seed))
  8833  	p := NewPopulatedNinNestedStruct(popr, true)
  8834  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8835  	msg := &NinNestedStruct{}
  8836  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8837  		t.Fatalf("seed = %d, err = %v", seed, err)
  8838  	}
  8839  	if err := p.VerboseEqual(msg); err != nil {
  8840  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8841  	}
  8842  	if !p.Equal(msg) {
  8843  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8844  	}
  8845  }
  8846  
  8847  func TestNinNestedStructProtoCompactText(t *testing.T) {
  8848  	seed := time.Now().UnixNano()
  8849  	popr := math_rand.New(math_rand.NewSource(seed))
  8850  	p := NewPopulatedNinNestedStruct(popr, true)
  8851  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8852  	msg := &NinNestedStruct{}
  8853  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8854  		t.Fatalf("seed = %d, err = %v", seed, err)
  8855  	}
  8856  	if err := p.VerboseEqual(msg); err != nil {
  8857  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8858  	}
  8859  	if !p.Equal(msg) {
  8860  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8861  	}
  8862  }
  8863  
  8864  func TestNidOptCustomProtoText(t *testing.T) {
  8865  	seed := time.Now().UnixNano()
  8866  	popr := math_rand.New(math_rand.NewSource(seed))
  8867  	p := NewPopulatedNidOptCustom(popr, true)
  8868  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8869  	msg := &NidOptCustom{}
  8870  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8871  		t.Fatalf("seed = %d, err = %v", seed, err)
  8872  	}
  8873  	if err := p.VerboseEqual(msg); err != nil {
  8874  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8875  	}
  8876  	if !p.Equal(msg) {
  8877  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8878  	}
  8879  }
  8880  
  8881  func TestNidOptCustomProtoCompactText(t *testing.T) {
  8882  	seed := time.Now().UnixNano()
  8883  	popr := math_rand.New(math_rand.NewSource(seed))
  8884  	p := NewPopulatedNidOptCustom(popr, true)
  8885  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8886  	msg := &NidOptCustom{}
  8887  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8888  		t.Fatalf("seed = %d, err = %v", seed, err)
  8889  	}
  8890  	if err := p.VerboseEqual(msg); err != nil {
  8891  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8892  	}
  8893  	if !p.Equal(msg) {
  8894  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8895  	}
  8896  }
  8897  
  8898  func TestCustomDashProtoText(t *testing.T) {
  8899  	seed := time.Now().UnixNano()
  8900  	popr := math_rand.New(math_rand.NewSource(seed))
  8901  	p := NewPopulatedCustomDash(popr, true)
  8902  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8903  	msg := &CustomDash{}
  8904  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8905  		t.Fatalf("seed = %d, err = %v", seed, err)
  8906  	}
  8907  	if err := p.VerboseEqual(msg); err != nil {
  8908  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8909  	}
  8910  	if !p.Equal(msg) {
  8911  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8912  	}
  8913  }
  8914  
  8915  func TestCustomDashProtoCompactText(t *testing.T) {
  8916  	seed := time.Now().UnixNano()
  8917  	popr := math_rand.New(math_rand.NewSource(seed))
  8918  	p := NewPopulatedCustomDash(popr, true)
  8919  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8920  	msg := &CustomDash{}
  8921  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8922  		t.Fatalf("seed = %d, err = %v", seed, err)
  8923  	}
  8924  	if err := p.VerboseEqual(msg); err != nil {
  8925  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8926  	}
  8927  	if !p.Equal(msg) {
  8928  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8929  	}
  8930  }
  8931  
  8932  func TestNinOptCustomProtoText(t *testing.T) {
  8933  	seed := time.Now().UnixNano()
  8934  	popr := math_rand.New(math_rand.NewSource(seed))
  8935  	p := NewPopulatedNinOptCustom(popr, true)
  8936  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8937  	msg := &NinOptCustom{}
  8938  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8939  		t.Fatalf("seed = %d, err = %v", seed, err)
  8940  	}
  8941  	if err := p.VerboseEqual(msg); err != nil {
  8942  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8943  	}
  8944  	if !p.Equal(msg) {
  8945  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8946  	}
  8947  }
  8948  
  8949  func TestNinOptCustomProtoCompactText(t *testing.T) {
  8950  	seed := time.Now().UnixNano()
  8951  	popr := math_rand.New(math_rand.NewSource(seed))
  8952  	p := NewPopulatedNinOptCustom(popr, true)
  8953  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8954  	msg := &NinOptCustom{}
  8955  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8956  		t.Fatalf("seed = %d, err = %v", seed, err)
  8957  	}
  8958  	if err := p.VerboseEqual(msg); err != nil {
  8959  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8960  	}
  8961  	if !p.Equal(msg) {
  8962  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8963  	}
  8964  }
  8965  
  8966  func TestNidRepCustomProtoText(t *testing.T) {
  8967  	seed := time.Now().UnixNano()
  8968  	popr := math_rand.New(math_rand.NewSource(seed))
  8969  	p := NewPopulatedNidRepCustom(popr, true)
  8970  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8971  	msg := &NidRepCustom{}
  8972  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8973  		t.Fatalf("seed = %d, err = %v", seed, err)
  8974  	}
  8975  	if err := p.VerboseEqual(msg); err != nil {
  8976  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8977  	}
  8978  	if !p.Equal(msg) {
  8979  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8980  	}
  8981  }
  8982  
  8983  func TestNidRepCustomProtoCompactText(t *testing.T) {
  8984  	seed := time.Now().UnixNano()
  8985  	popr := math_rand.New(math_rand.NewSource(seed))
  8986  	p := NewPopulatedNidRepCustom(popr, true)
  8987  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8988  	msg := &NidRepCustom{}
  8989  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8990  		t.Fatalf("seed = %d, err = %v", seed, err)
  8991  	}
  8992  	if err := p.VerboseEqual(msg); err != nil {
  8993  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8994  	}
  8995  	if !p.Equal(msg) {
  8996  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8997  	}
  8998  }
  8999  
  9000  func TestNinRepCustomProtoText(t *testing.T) {
  9001  	seed := time.Now().UnixNano()
  9002  	popr := math_rand.New(math_rand.NewSource(seed))
  9003  	p := NewPopulatedNinRepCustom(popr, true)
  9004  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9005  	msg := &NinRepCustom{}
  9006  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9007  		t.Fatalf("seed = %d, err = %v", seed, err)
  9008  	}
  9009  	if err := p.VerboseEqual(msg); err != nil {
  9010  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9011  	}
  9012  	if !p.Equal(msg) {
  9013  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9014  	}
  9015  }
  9016  
  9017  func TestNinRepCustomProtoCompactText(t *testing.T) {
  9018  	seed := time.Now().UnixNano()
  9019  	popr := math_rand.New(math_rand.NewSource(seed))
  9020  	p := NewPopulatedNinRepCustom(popr, true)
  9021  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9022  	msg := &NinRepCustom{}
  9023  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9024  		t.Fatalf("seed = %d, err = %v", seed, err)
  9025  	}
  9026  	if err := p.VerboseEqual(msg); err != nil {
  9027  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9028  	}
  9029  	if !p.Equal(msg) {
  9030  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9031  	}
  9032  }
  9033  
  9034  func TestNinOptNativeUnionProtoText(t *testing.T) {
  9035  	seed := time.Now().UnixNano()
  9036  	popr := math_rand.New(math_rand.NewSource(seed))
  9037  	p := NewPopulatedNinOptNativeUnion(popr, true)
  9038  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9039  	msg := &NinOptNativeUnion{}
  9040  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9041  		t.Fatalf("seed = %d, err = %v", seed, err)
  9042  	}
  9043  	if err := p.VerboseEqual(msg); err != nil {
  9044  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9045  	}
  9046  	if !p.Equal(msg) {
  9047  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9048  	}
  9049  }
  9050  
  9051  func TestNinOptNativeUnionProtoCompactText(t *testing.T) {
  9052  	seed := time.Now().UnixNano()
  9053  	popr := math_rand.New(math_rand.NewSource(seed))
  9054  	p := NewPopulatedNinOptNativeUnion(popr, true)
  9055  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9056  	msg := &NinOptNativeUnion{}
  9057  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9058  		t.Fatalf("seed = %d, err = %v", seed, err)
  9059  	}
  9060  	if err := p.VerboseEqual(msg); err != nil {
  9061  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9062  	}
  9063  	if !p.Equal(msg) {
  9064  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9065  	}
  9066  }
  9067  
  9068  func TestNinOptStructUnionProtoText(t *testing.T) {
  9069  	seed := time.Now().UnixNano()
  9070  	popr := math_rand.New(math_rand.NewSource(seed))
  9071  	p := NewPopulatedNinOptStructUnion(popr, true)
  9072  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9073  	msg := &NinOptStructUnion{}
  9074  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9075  		t.Fatalf("seed = %d, err = %v", seed, err)
  9076  	}
  9077  	if err := p.VerboseEqual(msg); err != nil {
  9078  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9079  	}
  9080  	if !p.Equal(msg) {
  9081  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9082  	}
  9083  }
  9084  
  9085  func TestNinOptStructUnionProtoCompactText(t *testing.T) {
  9086  	seed := time.Now().UnixNano()
  9087  	popr := math_rand.New(math_rand.NewSource(seed))
  9088  	p := NewPopulatedNinOptStructUnion(popr, true)
  9089  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9090  	msg := &NinOptStructUnion{}
  9091  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9092  		t.Fatalf("seed = %d, err = %v", seed, err)
  9093  	}
  9094  	if err := p.VerboseEqual(msg); err != nil {
  9095  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9096  	}
  9097  	if !p.Equal(msg) {
  9098  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9099  	}
  9100  }
  9101  
  9102  func TestNinEmbeddedStructUnionProtoText(t *testing.T) {
  9103  	seed := time.Now().UnixNano()
  9104  	popr := math_rand.New(math_rand.NewSource(seed))
  9105  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  9106  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9107  	msg := &NinEmbeddedStructUnion{}
  9108  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9109  		t.Fatalf("seed = %d, err = %v", seed, err)
  9110  	}
  9111  	if err := p.VerboseEqual(msg); err != nil {
  9112  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9113  	}
  9114  	if !p.Equal(msg) {
  9115  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9116  	}
  9117  }
  9118  
  9119  func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
  9120  	seed := time.Now().UnixNano()
  9121  	popr := math_rand.New(math_rand.NewSource(seed))
  9122  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  9123  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9124  	msg := &NinEmbeddedStructUnion{}
  9125  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9126  		t.Fatalf("seed = %d, err = %v", seed, err)
  9127  	}
  9128  	if err := p.VerboseEqual(msg); err != nil {
  9129  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9130  	}
  9131  	if !p.Equal(msg) {
  9132  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9133  	}
  9134  }
  9135  
  9136  func TestNinNestedStructUnionProtoText(t *testing.T) {
  9137  	seed := time.Now().UnixNano()
  9138  	popr := math_rand.New(math_rand.NewSource(seed))
  9139  	p := NewPopulatedNinNestedStructUnion(popr, true)
  9140  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9141  	msg := &NinNestedStructUnion{}
  9142  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9143  		t.Fatalf("seed = %d, err = %v", seed, err)
  9144  	}
  9145  	if err := p.VerboseEqual(msg); err != nil {
  9146  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9147  	}
  9148  	if !p.Equal(msg) {
  9149  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9150  	}
  9151  }
  9152  
  9153  func TestNinNestedStructUnionProtoCompactText(t *testing.T) {
  9154  	seed := time.Now().UnixNano()
  9155  	popr := math_rand.New(math_rand.NewSource(seed))
  9156  	p := NewPopulatedNinNestedStructUnion(popr, true)
  9157  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9158  	msg := &NinNestedStructUnion{}
  9159  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9160  		t.Fatalf("seed = %d, err = %v", seed, err)
  9161  	}
  9162  	if err := p.VerboseEqual(msg); err != nil {
  9163  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9164  	}
  9165  	if !p.Equal(msg) {
  9166  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9167  	}
  9168  }
  9169  
  9170  func TestTreeProtoText(t *testing.T) {
  9171  	seed := time.Now().UnixNano()
  9172  	popr := math_rand.New(math_rand.NewSource(seed))
  9173  	p := NewPopulatedTree(popr, true)
  9174  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9175  	msg := &Tree{}
  9176  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9177  		t.Fatalf("seed = %d, err = %v", seed, err)
  9178  	}
  9179  	if err := p.VerboseEqual(msg); err != nil {
  9180  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9181  	}
  9182  	if !p.Equal(msg) {
  9183  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9184  	}
  9185  }
  9186  
  9187  func TestTreeProtoCompactText(t *testing.T) {
  9188  	seed := time.Now().UnixNano()
  9189  	popr := math_rand.New(math_rand.NewSource(seed))
  9190  	p := NewPopulatedTree(popr, true)
  9191  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9192  	msg := &Tree{}
  9193  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9194  		t.Fatalf("seed = %d, err = %v", seed, err)
  9195  	}
  9196  	if err := p.VerboseEqual(msg); err != nil {
  9197  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9198  	}
  9199  	if !p.Equal(msg) {
  9200  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9201  	}
  9202  }
  9203  
  9204  func TestOrBranchProtoText(t *testing.T) {
  9205  	seed := time.Now().UnixNano()
  9206  	popr := math_rand.New(math_rand.NewSource(seed))
  9207  	p := NewPopulatedOrBranch(popr, true)
  9208  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9209  	msg := &OrBranch{}
  9210  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9211  		t.Fatalf("seed = %d, err = %v", seed, err)
  9212  	}
  9213  	if err := p.VerboseEqual(msg); err != nil {
  9214  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9215  	}
  9216  	if !p.Equal(msg) {
  9217  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9218  	}
  9219  }
  9220  
  9221  func TestOrBranchProtoCompactText(t *testing.T) {
  9222  	seed := time.Now().UnixNano()
  9223  	popr := math_rand.New(math_rand.NewSource(seed))
  9224  	p := NewPopulatedOrBranch(popr, true)
  9225  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9226  	msg := &OrBranch{}
  9227  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9228  		t.Fatalf("seed = %d, err = %v", seed, err)
  9229  	}
  9230  	if err := p.VerboseEqual(msg); err != nil {
  9231  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9232  	}
  9233  	if !p.Equal(msg) {
  9234  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9235  	}
  9236  }
  9237  
  9238  func TestAndBranchProtoText(t *testing.T) {
  9239  	seed := time.Now().UnixNano()
  9240  	popr := math_rand.New(math_rand.NewSource(seed))
  9241  	p := NewPopulatedAndBranch(popr, true)
  9242  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9243  	msg := &AndBranch{}
  9244  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9245  		t.Fatalf("seed = %d, err = %v", seed, err)
  9246  	}
  9247  	if err := p.VerboseEqual(msg); err != nil {
  9248  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9249  	}
  9250  	if !p.Equal(msg) {
  9251  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9252  	}
  9253  }
  9254  
  9255  func TestAndBranchProtoCompactText(t *testing.T) {
  9256  	seed := time.Now().UnixNano()
  9257  	popr := math_rand.New(math_rand.NewSource(seed))
  9258  	p := NewPopulatedAndBranch(popr, true)
  9259  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9260  	msg := &AndBranch{}
  9261  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9262  		t.Fatalf("seed = %d, err = %v", seed, err)
  9263  	}
  9264  	if err := p.VerboseEqual(msg); err != nil {
  9265  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9266  	}
  9267  	if !p.Equal(msg) {
  9268  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9269  	}
  9270  }
  9271  
  9272  func TestLeafProtoText(t *testing.T) {
  9273  	seed := time.Now().UnixNano()
  9274  	popr := math_rand.New(math_rand.NewSource(seed))
  9275  	p := NewPopulatedLeaf(popr, true)
  9276  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9277  	msg := &Leaf{}
  9278  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9279  		t.Fatalf("seed = %d, err = %v", seed, err)
  9280  	}
  9281  	if err := p.VerboseEqual(msg); err != nil {
  9282  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9283  	}
  9284  	if !p.Equal(msg) {
  9285  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9286  	}
  9287  }
  9288  
  9289  func TestLeafProtoCompactText(t *testing.T) {
  9290  	seed := time.Now().UnixNano()
  9291  	popr := math_rand.New(math_rand.NewSource(seed))
  9292  	p := NewPopulatedLeaf(popr, true)
  9293  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9294  	msg := &Leaf{}
  9295  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9296  		t.Fatalf("seed = %d, err = %v", seed, err)
  9297  	}
  9298  	if err := p.VerboseEqual(msg); err != nil {
  9299  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9300  	}
  9301  	if !p.Equal(msg) {
  9302  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9303  	}
  9304  }
  9305  
  9306  func TestDeepTreeProtoText(t *testing.T) {
  9307  	seed := time.Now().UnixNano()
  9308  	popr := math_rand.New(math_rand.NewSource(seed))
  9309  	p := NewPopulatedDeepTree(popr, true)
  9310  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9311  	msg := &DeepTree{}
  9312  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9313  		t.Fatalf("seed = %d, err = %v", seed, err)
  9314  	}
  9315  	if err := p.VerboseEqual(msg); err != nil {
  9316  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9317  	}
  9318  	if !p.Equal(msg) {
  9319  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9320  	}
  9321  }
  9322  
  9323  func TestDeepTreeProtoCompactText(t *testing.T) {
  9324  	seed := time.Now().UnixNano()
  9325  	popr := math_rand.New(math_rand.NewSource(seed))
  9326  	p := NewPopulatedDeepTree(popr, true)
  9327  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9328  	msg := &DeepTree{}
  9329  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9330  		t.Fatalf("seed = %d, err = %v", seed, err)
  9331  	}
  9332  	if err := p.VerboseEqual(msg); err != nil {
  9333  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9334  	}
  9335  	if !p.Equal(msg) {
  9336  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9337  	}
  9338  }
  9339  
  9340  func TestADeepBranchProtoText(t *testing.T) {
  9341  	seed := time.Now().UnixNano()
  9342  	popr := math_rand.New(math_rand.NewSource(seed))
  9343  	p := NewPopulatedADeepBranch(popr, true)
  9344  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9345  	msg := &ADeepBranch{}
  9346  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9347  		t.Fatalf("seed = %d, err = %v", seed, err)
  9348  	}
  9349  	if err := p.VerboseEqual(msg); err != nil {
  9350  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9351  	}
  9352  	if !p.Equal(msg) {
  9353  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9354  	}
  9355  }
  9356  
  9357  func TestADeepBranchProtoCompactText(t *testing.T) {
  9358  	seed := time.Now().UnixNano()
  9359  	popr := math_rand.New(math_rand.NewSource(seed))
  9360  	p := NewPopulatedADeepBranch(popr, true)
  9361  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9362  	msg := &ADeepBranch{}
  9363  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9364  		t.Fatalf("seed = %d, err = %v", seed, err)
  9365  	}
  9366  	if err := p.VerboseEqual(msg); err != nil {
  9367  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9368  	}
  9369  	if !p.Equal(msg) {
  9370  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9371  	}
  9372  }
  9373  
  9374  func TestAndDeepBranchProtoText(t *testing.T) {
  9375  	seed := time.Now().UnixNano()
  9376  	popr := math_rand.New(math_rand.NewSource(seed))
  9377  	p := NewPopulatedAndDeepBranch(popr, true)
  9378  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9379  	msg := &AndDeepBranch{}
  9380  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9381  		t.Fatalf("seed = %d, err = %v", seed, err)
  9382  	}
  9383  	if err := p.VerboseEqual(msg); err != nil {
  9384  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9385  	}
  9386  	if !p.Equal(msg) {
  9387  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9388  	}
  9389  }
  9390  
  9391  func TestAndDeepBranchProtoCompactText(t *testing.T) {
  9392  	seed := time.Now().UnixNano()
  9393  	popr := math_rand.New(math_rand.NewSource(seed))
  9394  	p := NewPopulatedAndDeepBranch(popr, true)
  9395  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9396  	msg := &AndDeepBranch{}
  9397  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9398  		t.Fatalf("seed = %d, err = %v", seed, err)
  9399  	}
  9400  	if err := p.VerboseEqual(msg); err != nil {
  9401  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9402  	}
  9403  	if !p.Equal(msg) {
  9404  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9405  	}
  9406  }
  9407  
  9408  func TestDeepLeafProtoText(t *testing.T) {
  9409  	seed := time.Now().UnixNano()
  9410  	popr := math_rand.New(math_rand.NewSource(seed))
  9411  	p := NewPopulatedDeepLeaf(popr, true)
  9412  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9413  	msg := &DeepLeaf{}
  9414  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9415  		t.Fatalf("seed = %d, err = %v", seed, err)
  9416  	}
  9417  	if err := p.VerboseEqual(msg); err != nil {
  9418  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9419  	}
  9420  	if !p.Equal(msg) {
  9421  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9422  	}
  9423  }
  9424  
  9425  func TestDeepLeafProtoCompactText(t *testing.T) {
  9426  	seed := time.Now().UnixNano()
  9427  	popr := math_rand.New(math_rand.NewSource(seed))
  9428  	p := NewPopulatedDeepLeaf(popr, true)
  9429  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9430  	msg := &DeepLeaf{}
  9431  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9432  		t.Fatalf("seed = %d, err = %v", seed, err)
  9433  	}
  9434  	if err := p.VerboseEqual(msg); err != nil {
  9435  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9436  	}
  9437  	if !p.Equal(msg) {
  9438  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9439  	}
  9440  }
  9441  
  9442  func TestNilProtoText(t *testing.T) {
  9443  	seed := time.Now().UnixNano()
  9444  	popr := math_rand.New(math_rand.NewSource(seed))
  9445  	p := NewPopulatedNil(popr, true)
  9446  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9447  	msg := &Nil{}
  9448  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9449  		t.Fatalf("seed = %d, err = %v", seed, err)
  9450  	}
  9451  	if err := p.VerboseEqual(msg); err != nil {
  9452  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9453  	}
  9454  	if !p.Equal(msg) {
  9455  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9456  	}
  9457  }
  9458  
  9459  func TestNilProtoCompactText(t *testing.T) {
  9460  	seed := time.Now().UnixNano()
  9461  	popr := math_rand.New(math_rand.NewSource(seed))
  9462  	p := NewPopulatedNil(popr, true)
  9463  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9464  	msg := &Nil{}
  9465  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9466  		t.Fatalf("seed = %d, err = %v", seed, err)
  9467  	}
  9468  	if err := p.VerboseEqual(msg); err != nil {
  9469  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9470  	}
  9471  	if !p.Equal(msg) {
  9472  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9473  	}
  9474  }
  9475  
  9476  func TestNidOptEnumProtoText(t *testing.T) {
  9477  	seed := time.Now().UnixNano()
  9478  	popr := math_rand.New(math_rand.NewSource(seed))
  9479  	p := NewPopulatedNidOptEnum(popr, true)
  9480  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9481  	msg := &NidOptEnum{}
  9482  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9483  		t.Fatalf("seed = %d, err = %v", seed, err)
  9484  	}
  9485  	if err := p.VerboseEqual(msg); err != nil {
  9486  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9487  	}
  9488  	if !p.Equal(msg) {
  9489  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9490  	}
  9491  }
  9492  
  9493  func TestNidOptEnumProtoCompactText(t *testing.T) {
  9494  	seed := time.Now().UnixNano()
  9495  	popr := math_rand.New(math_rand.NewSource(seed))
  9496  	p := NewPopulatedNidOptEnum(popr, true)
  9497  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9498  	msg := &NidOptEnum{}
  9499  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9500  		t.Fatalf("seed = %d, err = %v", seed, err)
  9501  	}
  9502  	if err := p.VerboseEqual(msg); err != nil {
  9503  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9504  	}
  9505  	if !p.Equal(msg) {
  9506  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9507  	}
  9508  }
  9509  
  9510  func TestNinOptEnumProtoText(t *testing.T) {
  9511  	seed := time.Now().UnixNano()
  9512  	popr := math_rand.New(math_rand.NewSource(seed))
  9513  	p := NewPopulatedNinOptEnum(popr, true)
  9514  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9515  	msg := &NinOptEnum{}
  9516  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9517  		t.Fatalf("seed = %d, err = %v", seed, err)
  9518  	}
  9519  	if err := p.VerboseEqual(msg); err != nil {
  9520  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9521  	}
  9522  	if !p.Equal(msg) {
  9523  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9524  	}
  9525  }
  9526  
  9527  func TestNinOptEnumProtoCompactText(t *testing.T) {
  9528  	seed := time.Now().UnixNano()
  9529  	popr := math_rand.New(math_rand.NewSource(seed))
  9530  	p := NewPopulatedNinOptEnum(popr, true)
  9531  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9532  	msg := &NinOptEnum{}
  9533  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9534  		t.Fatalf("seed = %d, err = %v", seed, err)
  9535  	}
  9536  	if err := p.VerboseEqual(msg); err != nil {
  9537  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9538  	}
  9539  	if !p.Equal(msg) {
  9540  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9541  	}
  9542  }
  9543  
  9544  func TestNidRepEnumProtoText(t *testing.T) {
  9545  	seed := time.Now().UnixNano()
  9546  	popr := math_rand.New(math_rand.NewSource(seed))
  9547  	p := NewPopulatedNidRepEnum(popr, true)
  9548  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9549  	msg := &NidRepEnum{}
  9550  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9551  		t.Fatalf("seed = %d, err = %v", seed, err)
  9552  	}
  9553  	if err := p.VerboseEqual(msg); err != nil {
  9554  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9555  	}
  9556  	if !p.Equal(msg) {
  9557  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9558  	}
  9559  }
  9560  
  9561  func TestNidRepEnumProtoCompactText(t *testing.T) {
  9562  	seed := time.Now().UnixNano()
  9563  	popr := math_rand.New(math_rand.NewSource(seed))
  9564  	p := NewPopulatedNidRepEnum(popr, true)
  9565  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9566  	msg := &NidRepEnum{}
  9567  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9568  		t.Fatalf("seed = %d, err = %v", seed, err)
  9569  	}
  9570  	if err := p.VerboseEqual(msg); err != nil {
  9571  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9572  	}
  9573  	if !p.Equal(msg) {
  9574  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9575  	}
  9576  }
  9577  
  9578  func TestNinRepEnumProtoText(t *testing.T) {
  9579  	seed := time.Now().UnixNano()
  9580  	popr := math_rand.New(math_rand.NewSource(seed))
  9581  	p := NewPopulatedNinRepEnum(popr, true)
  9582  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9583  	msg := &NinRepEnum{}
  9584  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9585  		t.Fatalf("seed = %d, err = %v", seed, err)
  9586  	}
  9587  	if err := p.VerboseEqual(msg); err != nil {
  9588  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9589  	}
  9590  	if !p.Equal(msg) {
  9591  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9592  	}
  9593  }
  9594  
  9595  func TestNinRepEnumProtoCompactText(t *testing.T) {
  9596  	seed := time.Now().UnixNano()
  9597  	popr := math_rand.New(math_rand.NewSource(seed))
  9598  	p := NewPopulatedNinRepEnum(popr, true)
  9599  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9600  	msg := &NinRepEnum{}
  9601  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9602  		t.Fatalf("seed = %d, err = %v", seed, err)
  9603  	}
  9604  	if err := p.VerboseEqual(msg); err != nil {
  9605  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9606  	}
  9607  	if !p.Equal(msg) {
  9608  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9609  	}
  9610  }
  9611  
  9612  func TestNinOptEnumDefaultProtoText(t *testing.T) {
  9613  	seed := time.Now().UnixNano()
  9614  	popr := math_rand.New(math_rand.NewSource(seed))
  9615  	p := NewPopulatedNinOptEnumDefault(popr, true)
  9616  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9617  	msg := &NinOptEnumDefault{}
  9618  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9619  		t.Fatalf("seed = %d, err = %v", seed, err)
  9620  	}
  9621  	if err := p.VerboseEqual(msg); err != nil {
  9622  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9623  	}
  9624  	if !p.Equal(msg) {
  9625  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9626  	}
  9627  }
  9628  
  9629  func TestNinOptEnumDefaultProtoCompactText(t *testing.T) {
  9630  	seed := time.Now().UnixNano()
  9631  	popr := math_rand.New(math_rand.NewSource(seed))
  9632  	p := NewPopulatedNinOptEnumDefault(popr, true)
  9633  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9634  	msg := &NinOptEnumDefault{}
  9635  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9636  		t.Fatalf("seed = %d, err = %v", seed, err)
  9637  	}
  9638  	if err := p.VerboseEqual(msg); err != nil {
  9639  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9640  	}
  9641  	if !p.Equal(msg) {
  9642  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9643  	}
  9644  }
  9645  
  9646  func TestAnotherNinOptEnumProtoText(t *testing.T) {
  9647  	seed := time.Now().UnixNano()
  9648  	popr := math_rand.New(math_rand.NewSource(seed))
  9649  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  9650  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9651  	msg := &AnotherNinOptEnum{}
  9652  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9653  		t.Fatalf("seed = %d, err = %v", seed, err)
  9654  	}
  9655  	if err := p.VerboseEqual(msg); err != nil {
  9656  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9657  	}
  9658  	if !p.Equal(msg) {
  9659  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9660  	}
  9661  }
  9662  
  9663  func TestAnotherNinOptEnumProtoCompactText(t *testing.T) {
  9664  	seed := time.Now().UnixNano()
  9665  	popr := math_rand.New(math_rand.NewSource(seed))
  9666  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  9667  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9668  	msg := &AnotherNinOptEnum{}
  9669  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9670  		t.Fatalf("seed = %d, err = %v", seed, err)
  9671  	}
  9672  	if err := p.VerboseEqual(msg); err != nil {
  9673  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9674  	}
  9675  	if !p.Equal(msg) {
  9676  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9677  	}
  9678  }
  9679  
  9680  func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) {
  9681  	seed := time.Now().UnixNano()
  9682  	popr := math_rand.New(math_rand.NewSource(seed))
  9683  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  9684  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9685  	msg := &AnotherNinOptEnumDefault{}
  9686  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9687  		t.Fatalf("seed = %d, err = %v", seed, err)
  9688  	}
  9689  	if err := p.VerboseEqual(msg); err != nil {
  9690  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9691  	}
  9692  	if !p.Equal(msg) {
  9693  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9694  	}
  9695  }
  9696  
  9697  func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) {
  9698  	seed := time.Now().UnixNano()
  9699  	popr := math_rand.New(math_rand.NewSource(seed))
  9700  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  9701  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9702  	msg := &AnotherNinOptEnumDefault{}
  9703  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9704  		t.Fatalf("seed = %d, err = %v", seed, err)
  9705  	}
  9706  	if err := p.VerboseEqual(msg); err != nil {
  9707  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9708  	}
  9709  	if !p.Equal(msg) {
  9710  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9711  	}
  9712  }
  9713  
  9714  func TestTimerProtoText(t *testing.T) {
  9715  	seed := time.Now().UnixNano()
  9716  	popr := math_rand.New(math_rand.NewSource(seed))
  9717  	p := NewPopulatedTimer(popr, true)
  9718  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9719  	msg := &Timer{}
  9720  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9721  		t.Fatalf("seed = %d, err = %v", seed, err)
  9722  	}
  9723  	if err := p.VerboseEqual(msg); err != nil {
  9724  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9725  	}
  9726  	if !p.Equal(msg) {
  9727  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9728  	}
  9729  }
  9730  
  9731  func TestTimerProtoCompactText(t *testing.T) {
  9732  	seed := time.Now().UnixNano()
  9733  	popr := math_rand.New(math_rand.NewSource(seed))
  9734  	p := NewPopulatedTimer(popr, true)
  9735  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9736  	msg := &Timer{}
  9737  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9738  		t.Fatalf("seed = %d, err = %v", seed, err)
  9739  	}
  9740  	if err := p.VerboseEqual(msg); err != nil {
  9741  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9742  	}
  9743  	if !p.Equal(msg) {
  9744  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9745  	}
  9746  }
  9747  
  9748  func TestMyExtendableProtoText(t *testing.T) {
  9749  	seed := time.Now().UnixNano()
  9750  	popr := math_rand.New(math_rand.NewSource(seed))
  9751  	p := NewPopulatedMyExtendable(popr, true)
  9752  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9753  	msg := &MyExtendable{}
  9754  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9755  		t.Fatalf("seed = %d, err = %v", seed, err)
  9756  	}
  9757  	if err := p.VerboseEqual(msg); err != nil {
  9758  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9759  	}
  9760  	if !p.Equal(msg) {
  9761  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9762  	}
  9763  }
  9764  
  9765  func TestMyExtendableProtoCompactText(t *testing.T) {
  9766  	seed := time.Now().UnixNano()
  9767  	popr := math_rand.New(math_rand.NewSource(seed))
  9768  	p := NewPopulatedMyExtendable(popr, true)
  9769  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9770  	msg := &MyExtendable{}
  9771  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9772  		t.Fatalf("seed = %d, err = %v", seed, err)
  9773  	}
  9774  	if err := p.VerboseEqual(msg); err != nil {
  9775  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9776  	}
  9777  	if !p.Equal(msg) {
  9778  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9779  	}
  9780  }
  9781  
  9782  func TestOtherExtenableProtoText(t *testing.T) {
  9783  	seed := time.Now().UnixNano()
  9784  	popr := math_rand.New(math_rand.NewSource(seed))
  9785  	p := NewPopulatedOtherExtenable(popr, true)
  9786  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9787  	msg := &OtherExtenable{}
  9788  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9789  		t.Fatalf("seed = %d, err = %v", seed, err)
  9790  	}
  9791  	if err := p.VerboseEqual(msg); err != nil {
  9792  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9793  	}
  9794  	if !p.Equal(msg) {
  9795  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9796  	}
  9797  }
  9798  
  9799  func TestOtherExtenableProtoCompactText(t *testing.T) {
  9800  	seed := time.Now().UnixNano()
  9801  	popr := math_rand.New(math_rand.NewSource(seed))
  9802  	p := NewPopulatedOtherExtenable(popr, true)
  9803  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9804  	msg := &OtherExtenable{}
  9805  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9806  		t.Fatalf("seed = %d, err = %v", seed, err)
  9807  	}
  9808  	if err := p.VerboseEqual(msg); err != nil {
  9809  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9810  	}
  9811  	if !p.Equal(msg) {
  9812  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9813  	}
  9814  }
  9815  
  9816  func TestNestedDefinitionProtoText(t *testing.T) {
  9817  	seed := time.Now().UnixNano()
  9818  	popr := math_rand.New(math_rand.NewSource(seed))
  9819  	p := NewPopulatedNestedDefinition(popr, true)
  9820  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9821  	msg := &NestedDefinition{}
  9822  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9823  		t.Fatalf("seed = %d, err = %v", seed, err)
  9824  	}
  9825  	if err := p.VerboseEqual(msg); err != nil {
  9826  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9827  	}
  9828  	if !p.Equal(msg) {
  9829  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9830  	}
  9831  }
  9832  
  9833  func TestNestedDefinitionProtoCompactText(t *testing.T) {
  9834  	seed := time.Now().UnixNano()
  9835  	popr := math_rand.New(math_rand.NewSource(seed))
  9836  	p := NewPopulatedNestedDefinition(popr, true)
  9837  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9838  	msg := &NestedDefinition{}
  9839  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9840  		t.Fatalf("seed = %d, err = %v", seed, err)
  9841  	}
  9842  	if err := p.VerboseEqual(msg); err != nil {
  9843  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9844  	}
  9845  	if !p.Equal(msg) {
  9846  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9847  	}
  9848  }
  9849  
  9850  func TestNestedDefinition_NestedMessageProtoText(t *testing.T) {
  9851  	seed := time.Now().UnixNano()
  9852  	popr := math_rand.New(math_rand.NewSource(seed))
  9853  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  9854  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9855  	msg := &NestedDefinition_NestedMessage{}
  9856  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9857  		t.Fatalf("seed = %d, err = %v", seed, err)
  9858  	}
  9859  	if err := p.VerboseEqual(msg); err != nil {
  9860  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9861  	}
  9862  	if !p.Equal(msg) {
  9863  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9864  	}
  9865  }
  9866  
  9867  func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) {
  9868  	seed := time.Now().UnixNano()
  9869  	popr := math_rand.New(math_rand.NewSource(seed))
  9870  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  9871  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9872  	msg := &NestedDefinition_NestedMessage{}
  9873  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9874  		t.Fatalf("seed = %d, err = %v", seed, err)
  9875  	}
  9876  	if err := p.VerboseEqual(msg); err != nil {
  9877  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9878  	}
  9879  	if !p.Equal(msg) {
  9880  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9881  	}
  9882  }
  9883  
  9884  func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) {
  9885  	seed := time.Now().UnixNano()
  9886  	popr := math_rand.New(math_rand.NewSource(seed))
  9887  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  9888  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9889  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  9890  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9891  		t.Fatalf("seed = %d, err = %v", seed, err)
  9892  	}
  9893  	if err := p.VerboseEqual(msg); err != nil {
  9894  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9895  	}
  9896  	if !p.Equal(msg) {
  9897  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9898  	}
  9899  }
  9900  
  9901  func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) {
  9902  	seed := time.Now().UnixNano()
  9903  	popr := math_rand.New(math_rand.NewSource(seed))
  9904  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  9905  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9906  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  9907  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9908  		t.Fatalf("seed = %d, err = %v", seed, err)
  9909  	}
  9910  	if err := p.VerboseEqual(msg); err != nil {
  9911  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9912  	}
  9913  	if !p.Equal(msg) {
  9914  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9915  	}
  9916  }
  9917  
  9918  func TestNestedScopeProtoText(t *testing.T) {
  9919  	seed := time.Now().UnixNano()
  9920  	popr := math_rand.New(math_rand.NewSource(seed))
  9921  	p := NewPopulatedNestedScope(popr, true)
  9922  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9923  	msg := &NestedScope{}
  9924  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9925  		t.Fatalf("seed = %d, err = %v", seed, err)
  9926  	}
  9927  	if err := p.VerboseEqual(msg); err != nil {
  9928  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9929  	}
  9930  	if !p.Equal(msg) {
  9931  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9932  	}
  9933  }
  9934  
  9935  func TestNestedScopeProtoCompactText(t *testing.T) {
  9936  	seed := time.Now().UnixNano()
  9937  	popr := math_rand.New(math_rand.NewSource(seed))
  9938  	p := NewPopulatedNestedScope(popr, true)
  9939  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9940  	msg := &NestedScope{}
  9941  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9942  		t.Fatalf("seed = %d, err = %v", seed, err)
  9943  	}
  9944  	if err := p.VerboseEqual(msg); err != nil {
  9945  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9946  	}
  9947  	if !p.Equal(msg) {
  9948  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9949  	}
  9950  }
  9951  
  9952  func TestNinOptNativeDefaultProtoText(t *testing.T) {
  9953  	seed := time.Now().UnixNano()
  9954  	popr := math_rand.New(math_rand.NewSource(seed))
  9955  	p := NewPopulatedNinOptNativeDefault(popr, true)
  9956  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9957  	msg := &NinOptNativeDefault{}
  9958  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9959  		t.Fatalf("seed = %d, err = %v", seed, err)
  9960  	}
  9961  	if err := p.VerboseEqual(msg); err != nil {
  9962  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9963  	}
  9964  	if !p.Equal(msg) {
  9965  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9966  	}
  9967  }
  9968  
  9969  func TestNinOptNativeDefaultProtoCompactText(t *testing.T) {
  9970  	seed := time.Now().UnixNano()
  9971  	popr := math_rand.New(math_rand.NewSource(seed))
  9972  	p := NewPopulatedNinOptNativeDefault(popr, true)
  9973  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  9974  	msg := &NinOptNativeDefault{}
  9975  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9976  		t.Fatalf("seed = %d, err = %v", seed, err)
  9977  	}
  9978  	if err := p.VerboseEqual(msg); err != nil {
  9979  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9980  	}
  9981  	if !p.Equal(msg) {
  9982  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  9983  	}
  9984  }
  9985  
  9986  func TestCustomContainerProtoText(t *testing.T) {
  9987  	seed := time.Now().UnixNano()
  9988  	popr := math_rand.New(math_rand.NewSource(seed))
  9989  	p := NewPopulatedCustomContainer(popr, true)
  9990  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  9991  	msg := &CustomContainer{}
  9992  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  9993  		t.Fatalf("seed = %d, err = %v", seed, err)
  9994  	}
  9995  	if err := p.VerboseEqual(msg); err != nil {
  9996  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  9997  	}
  9998  	if !p.Equal(msg) {
  9999  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10000  	}
 10001  }
 10002  
 10003  func TestCustomContainerProtoCompactText(t *testing.T) {
 10004  	seed := time.Now().UnixNano()
 10005  	popr := math_rand.New(math_rand.NewSource(seed))
 10006  	p := NewPopulatedCustomContainer(popr, true)
 10007  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10008  	msg := &CustomContainer{}
 10009  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10010  		t.Fatalf("seed = %d, err = %v", seed, err)
 10011  	}
 10012  	if err := p.VerboseEqual(msg); err != nil {
 10013  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10014  	}
 10015  	if !p.Equal(msg) {
 10016  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10017  	}
 10018  }
 10019  
 10020  func TestCustomNameNidOptNativeProtoText(t *testing.T) {
 10021  	seed := time.Now().UnixNano()
 10022  	popr := math_rand.New(math_rand.NewSource(seed))
 10023  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 10024  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10025  	msg := &CustomNameNidOptNative{}
 10026  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10027  		t.Fatalf("seed = %d, err = %v", seed, err)
 10028  	}
 10029  	if err := p.VerboseEqual(msg); err != nil {
 10030  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10031  	}
 10032  	if !p.Equal(msg) {
 10033  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10034  	}
 10035  }
 10036  
 10037  func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) {
 10038  	seed := time.Now().UnixNano()
 10039  	popr := math_rand.New(math_rand.NewSource(seed))
 10040  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 10041  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10042  	msg := &CustomNameNidOptNative{}
 10043  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10044  		t.Fatalf("seed = %d, err = %v", seed, err)
 10045  	}
 10046  	if err := p.VerboseEqual(msg); err != nil {
 10047  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10048  	}
 10049  	if !p.Equal(msg) {
 10050  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10051  	}
 10052  }
 10053  
 10054  func TestCustomNameNinOptNativeProtoText(t *testing.T) {
 10055  	seed := time.Now().UnixNano()
 10056  	popr := math_rand.New(math_rand.NewSource(seed))
 10057  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 10058  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10059  	msg := &CustomNameNinOptNative{}
 10060  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10061  		t.Fatalf("seed = %d, err = %v", seed, err)
 10062  	}
 10063  	if err := p.VerboseEqual(msg); err != nil {
 10064  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10065  	}
 10066  	if !p.Equal(msg) {
 10067  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10068  	}
 10069  }
 10070  
 10071  func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) {
 10072  	seed := time.Now().UnixNano()
 10073  	popr := math_rand.New(math_rand.NewSource(seed))
 10074  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 10075  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10076  	msg := &CustomNameNinOptNative{}
 10077  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10078  		t.Fatalf("seed = %d, err = %v", seed, err)
 10079  	}
 10080  	if err := p.VerboseEqual(msg); err != nil {
 10081  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10082  	}
 10083  	if !p.Equal(msg) {
 10084  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10085  	}
 10086  }
 10087  
 10088  func TestCustomNameNinRepNativeProtoText(t *testing.T) {
 10089  	seed := time.Now().UnixNano()
 10090  	popr := math_rand.New(math_rand.NewSource(seed))
 10091  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 10092  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10093  	msg := &CustomNameNinRepNative{}
 10094  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10095  		t.Fatalf("seed = %d, err = %v", seed, err)
 10096  	}
 10097  	if err := p.VerboseEqual(msg); err != nil {
 10098  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10099  	}
 10100  	if !p.Equal(msg) {
 10101  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10102  	}
 10103  }
 10104  
 10105  func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) {
 10106  	seed := time.Now().UnixNano()
 10107  	popr := math_rand.New(math_rand.NewSource(seed))
 10108  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 10109  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10110  	msg := &CustomNameNinRepNative{}
 10111  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10112  		t.Fatalf("seed = %d, err = %v", seed, err)
 10113  	}
 10114  	if err := p.VerboseEqual(msg); err != nil {
 10115  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10116  	}
 10117  	if !p.Equal(msg) {
 10118  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10119  	}
 10120  }
 10121  
 10122  func TestCustomNameNinStructProtoText(t *testing.T) {
 10123  	seed := time.Now().UnixNano()
 10124  	popr := math_rand.New(math_rand.NewSource(seed))
 10125  	p := NewPopulatedCustomNameNinStruct(popr, true)
 10126  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10127  	msg := &CustomNameNinStruct{}
 10128  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10129  		t.Fatalf("seed = %d, err = %v", seed, err)
 10130  	}
 10131  	if err := p.VerboseEqual(msg); err != nil {
 10132  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10133  	}
 10134  	if !p.Equal(msg) {
 10135  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10136  	}
 10137  }
 10138  
 10139  func TestCustomNameNinStructProtoCompactText(t *testing.T) {
 10140  	seed := time.Now().UnixNano()
 10141  	popr := math_rand.New(math_rand.NewSource(seed))
 10142  	p := NewPopulatedCustomNameNinStruct(popr, true)
 10143  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10144  	msg := &CustomNameNinStruct{}
 10145  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10146  		t.Fatalf("seed = %d, err = %v", seed, err)
 10147  	}
 10148  	if err := p.VerboseEqual(msg); err != nil {
 10149  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10150  	}
 10151  	if !p.Equal(msg) {
 10152  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10153  	}
 10154  }
 10155  
 10156  func TestCustomNameCustomTypeProtoText(t *testing.T) {
 10157  	seed := time.Now().UnixNano()
 10158  	popr := math_rand.New(math_rand.NewSource(seed))
 10159  	p := NewPopulatedCustomNameCustomType(popr, true)
 10160  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10161  	msg := &CustomNameCustomType{}
 10162  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10163  		t.Fatalf("seed = %d, err = %v", seed, err)
 10164  	}
 10165  	if err := p.VerboseEqual(msg); err != nil {
 10166  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10167  	}
 10168  	if !p.Equal(msg) {
 10169  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10170  	}
 10171  }
 10172  
 10173  func TestCustomNameCustomTypeProtoCompactText(t *testing.T) {
 10174  	seed := time.Now().UnixNano()
 10175  	popr := math_rand.New(math_rand.NewSource(seed))
 10176  	p := NewPopulatedCustomNameCustomType(popr, true)
 10177  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10178  	msg := &CustomNameCustomType{}
 10179  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10180  		t.Fatalf("seed = %d, err = %v", seed, err)
 10181  	}
 10182  	if err := p.VerboseEqual(msg); err != nil {
 10183  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10184  	}
 10185  	if !p.Equal(msg) {
 10186  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10187  	}
 10188  }
 10189  
 10190  func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) {
 10191  	seed := time.Now().UnixNano()
 10192  	popr := math_rand.New(math_rand.NewSource(seed))
 10193  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 10194  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10195  	msg := &CustomNameNinEmbeddedStructUnion{}
 10196  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10197  		t.Fatalf("seed = %d, err = %v", seed, err)
 10198  	}
 10199  	if err := p.VerboseEqual(msg); err != nil {
 10200  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10201  	}
 10202  	if !p.Equal(msg) {
 10203  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10204  	}
 10205  }
 10206  
 10207  func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
 10208  	seed := time.Now().UnixNano()
 10209  	popr := math_rand.New(math_rand.NewSource(seed))
 10210  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 10211  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10212  	msg := &CustomNameNinEmbeddedStructUnion{}
 10213  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10214  		t.Fatalf("seed = %d, err = %v", seed, err)
 10215  	}
 10216  	if err := p.VerboseEqual(msg); err != nil {
 10217  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10218  	}
 10219  	if !p.Equal(msg) {
 10220  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10221  	}
 10222  }
 10223  
 10224  func TestCustomNameEnumProtoText(t *testing.T) {
 10225  	seed := time.Now().UnixNano()
 10226  	popr := math_rand.New(math_rand.NewSource(seed))
 10227  	p := NewPopulatedCustomNameEnum(popr, true)
 10228  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10229  	msg := &CustomNameEnum{}
 10230  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10231  		t.Fatalf("seed = %d, err = %v", seed, err)
 10232  	}
 10233  	if err := p.VerboseEqual(msg); err != nil {
 10234  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10235  	}
 10236  	if !p.Equal(msg) {
 10237  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10238  	}
 10239  }
 10240  
 10241  func TestCustomNameEnumProtoCompactText(t *testing.T) {
 10242  	seed := time.Now().UnixNano()
 10243  	popr := math_rand.New(math_rand.NewSource(seed))
 10244  	p := NewPopulatedCustomNameEnum(popr, true)
 10245  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10246  	msg := &CustomNameEnum{}
 10247  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10248  		t.Fatalf("seed = %d, err = %v", seed, err)
 10249  	}
 10250  	if err := p.VerboseEqual(msg); err != nil {
 10251  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10252  	}
 10253  	if !p.Equal(msg) {
 10254  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10255  	}
 10256  }
 10257  
 10258  func TestNoExtensionsMapProtoText(t *testing.T) {
 10259  	seed := time.Now().UnixNano()
 10260  	popr := math_rand.New(math_rand.NewSource(seed))
 10261  	p := NewPopulatedNoExtensionsMap(popr, true)
 10262  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10263  	msg := &NoExtensionsMap{}
 10264  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10265  		t.Fatalf("seed = %d, err = %v", seed, err)
 10266  	}
 10267  	if err := p.VerboseEqual(msg); err != nil {
 10268  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10269  	}
 10270  	if !p.Equal(msg) {
 10271  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10272  	}
 10273  }
 10274  
 10275  func TestNoExtensionsMapProtoCompactText(t *testing.T) {
 10276  	seed := time.Now().UnixNano()
 10277  	popr := math_rand.New(math_rand.NewSource(seed))
 10278  	p := NewPopulatedNoExtensionsMap(popr, true)
 10279  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10280  	msg := &NoExtensionsMap{}
 10281  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10282  		t.Fatalf("seed = %d, err = %v", seed, err)
 10283  	}
 10284  	if err := p.VerboseEqual(msg); err != nil {
 10285  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10286  	}
 10287  	if !p.Equal(msg) {
 10288  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10289  	}
 10290  }
 10291  
 10292  func TestUnrecognizedProtoText(t *testing.T) {
 10293  	seed := time.Now().UnixNano()
 10294  	popr := math_rand.New(math_rand.NewSource(seed))
 10295  	p := NewPopulatedUnrecognized(popr, true)
 10296  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10297  	msg := &Unrecognized{}
 10298  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10299  		t.Fatalf("seed = %d, err = %v", seed, err)
 10300  	}
 10301  	if err := p.VerboseEqual(msg); err != nil {
 10302  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10303  	}
 10304  	if !p.Equal(msg) {
 10305  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10306  	}
 10307  }
 10308  
 10309  func TestUnrecognizedProtoCompactText(t *testing.T) {
 10310  	seed := time.Now().UnixNano()
 10311  	popr := math_rand.New(math_rand.NewSource(seed))
 10312  	p := NewPopulatedUnrecognized(popr, true)
 10313  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10314  	msg := &Unrecognized{}
 10315  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10316  		t.Fatalf("seed = %d, err = %v", seed, err)
 10317  	}
 10318  	if err := p.VerboseEqual(msg); err != nil {
 10319  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10320  	}
 10321  	if !p.Equal(msg) {
 10322  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10323  	}
 10324  }
 10325  
 10326  func TestUnrecognizedWithInnerProtoText(t *testing.T) {
 10327  	seed := time.Now().UnixNano()
 10328  	popr := math_rand.New(math_rand.NewSource(seed))
 10329  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 10330  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10331  	msg := &UnrecognizedWithInner{}
 10332  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10333  		t.Fatalf("seed = %d, err = %v", seed, err)
 10334  	}
 10335  	if err := p.VerboseEqual(msg); err != nil {
 10336  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10337  	}
 10338  	if !p.Equal(msg) {
 10339  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10340  	}
 10341  }
 10342  
 10343  func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) {
 10344  	seed := time.Now().UnixNano()
 10345  	popr := math_rand.New(math_rand.NewSource(seed))
 10346  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 10347  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10348  	msg := &UnrecognizedWithInner{}
 10349  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10350  		t.Fatalf("seed = %d, err = %v", seed, err)
 10351  	}
 10352  	if err := p.VerboseEqual(msg); err != nil {
 10353  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10354  	}
 10355  	if !p.Equal(msg) {
 10356  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10357  	}
 10358  }
 10359  
 10360  func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) {
 10361  	seed := time.Now().UnixNano()
 10362  	popr := math_rand.New(math_rand.NewSource(seed))
 10363  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 10364  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10365  	msg := &UnrecognizedWithInner_Inner{}
 10366  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10367  		t.Fatalf("seed = %d, err = %v", seed, err)
 10368  	}
 10369  	if err := p.VerboseEqual(msg); err != nil {
 10370  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10371  	}
 10372  	if !p.Equal(msg) {
 10373  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10374  	}
 10375  }
 10376  
 10377  func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) {
 10378  	seed := time.Now().UnixNano()
 10379  	popr := math_rand.New(math_rand.NewSource(seed))
 10380  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 10381  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10382  	msg := &UnrecognizedWithInner_Inner{}
 10383  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10384  		t.Fatalf("seed = %d, err = %v", seed, err)
 10385  	}
 10386  	if err := p.VerboseEqual(msg); err != nil {
 10387  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10388  	}
 10389  	if !p.Equal(msg) {
 10390  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10391  	}
 10392  }
 10393  
 10394  func TestUnrecognizedWithEmbedProtoText(t *testing.T) {
 10395  	seed := time.Now().UnixNano()
 10396  	popr := math_rand.New(math_rand.NewSource(seed))
 10397  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 10398  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10399  	msg := &UnrecognizedWithEmbed{}
 10400  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10401  		t.Fatalf("seed = %d, err = %v", seed, err)
 10402  	}
 10403  	if err := p.VerboseEqual(msg); err != nil {
 10404  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10405  	}
 10406  	if !p.Equal(msg) {
 10407  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10408  	}
 10409  }
 10410  
 10411  func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) {
 10412  	seed := time.Now().UnixNano()
 10413  	popr := math_rand.New(math_rand.NewSource(seed))
 10414  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 10415  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10416  	msg := &UnrecognizedWithEmbed{}
 10417  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10418  		t.Fatalf("seed = %d, err = %v", seed, err)
 10419  	}
 10420  	if err := p.VerboseEqual(msg); err != nil {
 10421  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10422  	}
 10423  	if !p.Equal(msg) {
 10424  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10425  	}
 10426  }
 10427  
 10428  func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) {
 10429  	seed := time.Now().UnixNano()
 10430  	popr := math_rand.New(math_rand.NewSource(seed))
 10431  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 10432  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10433  	msg := &UnrecognizedWithEmbed_Embedded{}
 10434  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10435  		t.Fatalf("seed = %d, err = %v", seed, err)
 10436  	}
 10437  	if err := p.VerboseEqual(msg); err != nil {
 10438  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10439  	}
 10440  	if !p.Equal(msg) {
 10441  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10442  	}
 10443  }
 10444  
 10445  func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) {
 10446  	seed := time.Now().UnixNano()
 10447  	popr := math_rand.New(math_rand.NewSource(seed))
 10448  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 10449  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10450  	msg := &UnrecognizedWithEmbed_Embedded{}
 10451  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10452  		t.Fatalf("seed = %d, err = %v", seed, err)
 10453  	}
 10454  	if err := p.VerboseEqual(msg); err != nil {
 10455  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10456  	}
 10457  	if !p.Equal(msg) {
 10458  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10459  	}
 10460  }
 10461  
 10462  func TestNodeProtoText(t *testing.T) {
 10463  	seed := time.Now().UnixNano()
 10464  	popr := math_rand.New(math_rand.NewSource(seed))
 10465  	p := NewPopulatedNode(popr, true)
 10466  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10467  	msg := &Node{}
 10468  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10469  		t.Fatalf("seed = %d, err = %v", seed, err)
 10470  	}
 10471  	if err := p.VerboseEqual(msg); err != nil {
 10472  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10473  	}
 10474  	if !p.Equal(msg) {
 10475  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10476  	}
 10477  }
 10478  
 10479  func TestNodeProtoCompactText(t *testing.T) {
 10480  	seed := time.Now().UnixNano()
 10481  	popr := math_rand.New(math_rand.NewSource(seed))
 10482  	p := NewPopulatedNode(popr, true)
 10483  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10484  	msg := &Node{}
 10485  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10486  		t.Fatalf("seed = %d, err = %v", seed, err)
 10487  	}
 10488  	if err := p.VerboseEqual(msg); err != nil {
 10489  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10490  	}
 10491  	if !p.Equal(msg) {
 10492  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10493  	}
 10494  }
 10495  
 10496  func TestNonByteCustomTypeProtoText(t *testing.T) {
 10497  	seed := time.Now().UnixNano()
 10498  	popr := math_rand.New(math_rand.NewSource(seed))
 10499  	p := NewPopulatedNonByteCustomType(popr, true)
 10500  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10501  	msg := &NonByteCustomType{}
 10502  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10503  		t.Fatalf("seed = %d, err = %v", seed, err)
 10504  	}
 10505  	if err := p.VerboseEqual(msg); err != nil {
 10506  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10507  	}
 10508  	if !p.Equal(msg) {
 10509  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10510  	}
 10511  }
 10512  
 10513  func TestNonByteCustomTypeProtoCompactText(t *testing.T) {
 10514  	seed := time.Now().UnixNano()
 10515  	popr := math_rand.New(math_rand.NewSource(seed))
 10516  	p := NewPopulatedNonByteCustomType(popr, true)
 10517  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10518  	msg := &NonByteCustomType{}
 10519  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10520  		t.Fatalf("seed = %d, err = %v", seed, err)
 10521  	}
 10522  	if err := p.VerboseEqual(msg); err != nil {
 10523  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10524  	}
 10525  	if !p.Equal(msg) {
 10526  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10527  	}
 10528  }
 10529  
 10530  func TestNidOptNonByteCustomTypeProtoText(t *testing.T) {
 10531  	seed := time.Now().UnixNano()
 10532  	popr := math_rand.New(math_rand.NewSource(seed))
 10533  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 10534  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10535  	msg := &NidOptNonByteCustomType{}
 10536  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10537  		t.Fatalf("seed = %d, err = %v", seed, err)
 10538  	}
 10539  	if err := p.VerboseEqual(msg); err != nil {
 10540  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10541  	}
 10542  	if !p.Equal(msg) {
 10543  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10544  	}
 10545  }
 10546  
 10547  func TestNidOptNonByteCustomTypeProtoCompactText(t *testing.T) {
 10548  	seed := time.Now().UnixNano()
 10549  	popr := math_rand.New(math_rand.NewSource(seed))
 10550  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 10551  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10552  	msg := &NidOptNonByteCustomType{}
 10553  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10554  		t.Fatalf("seed = %d, err = %v", seed, err)
 10555  	}
 10556  	if err := p.VerboseEqual(msg); err != nil {
 10557  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10558  	}
 10559  	if !p.Equal(msg) {
 10560  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10561  	}
 10562  }
 10563  
 10564  func TestNinOptNonByteCustomTypeProtoText(t *testing.T) {
 10565  	seed := time.Now().UnixNano()
 10566  	popr := math_rand.New(math_rand.NewSource(seed))
 10567  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 10568  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10569  	msg := &NinOptNonByteCustomType{}
 10570  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10571  		t.Fatalf("seed = %d, err = %v", seed, err)
 10572  	}
 10573  	if err := p.VerboseEqual(msg); err != nil {
 10574  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10575  	}
 10576  	if !p.Equal(msg) {
 10577  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10578  	}
 10579  }
 10580  
 10581  func TestNinOptNonByteCustomTypeProtoCompactText(t *testing.T) {
 10582  	seed := time.Now().UnixNano()
 10583  	popr := math_rand.New(math_rand.NewSource(seed))
 10584  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 10585  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10586  	msg := &NinOptNonByteCustomType{}
 10587  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10588  		t.Fatalf("seed = %d, err = %v", seed, err)
 10589  	}
 10590  	if err := p.VerboseEqual(msg); err != nil {
 10591  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10592  	}
 10593  	if !p.Equal(msg) {
 10594  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10595  	}
 10596  }
 10597  
 10598  func TestNidRepNonByteCustomTypeProtoText(t *testing.T) {
 10599  	seed := time.Now().UnixNano()
 10600  	popr := math_rand.New(math_rand.NewSource(seed))
 10601  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 10602  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10603  	msg := &NidRepNonByteCustomType{}
 10604  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10605  		t.Fatalf("seed = %d, err = %v", seed, err)
 10606  	}
 10607  	if err := p.VerboseEqual(msg); err != nil {
 10608  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10609  	}
 10610  	if !p.Equal(msg) {
 10611  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10612  	}
 10613  }
 10614  
 10615  func TestNidRepNonByteCustomTypeProtoCompactText(t *testing.T) {
 10616  	seed := time.Now().UnixNano()
 10617  	popr := math_rand.New(math_rand.NewSource(seed))
 10618  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 10619  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10620  	msg := &NidRepNonByteCustomType{}
 10621  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10622  		t.Fatalf("seed = %d, err = %v", seed, err)
 10623  	}
 10624  	if err := p.VerboseEqual(msg); err != nil {
 10625  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10626  	}
 10627  	if !p.Equal(msg) {
 10628  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10629  	}
 10630  }
 10631  
 10632  func TestNinRepNonByteCustomTypeProtoText(t *testing.T) {
 10633  	seed := time.Now().UnixNano()
 10634  	popr := math_rand.New(math_rand.NewSource(seed))
 10635  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 10636  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10637  	msg := &NinRepNonByteCustomType{}
 10638  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10639  		t.Fatalf("seed = %d, err = %v", seed, err)
 10640  	}
 10641  	if err := p.VerboseEqual(msg); err != nil {
 10642  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10643  	}
 10644  	if !p.Equal(msg) {
 10645  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10646  	}
 10647  }
 10648  
 10649  func TestNinRepNonByteCustomTypeProtoCompactText(t *testing.T) {
 10650  	seed := time.Now().UnixNano()
 10651  	popr := math_rand.New(math_rand.NewSource(seed))
 10652  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 10653  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10654  	msg := &NinRepNonByteCustomType{}
 10655  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10656  		t.Fatalf("seed = %d, err = %v", seed, err)
 10657  	}
 10658  	if err := p.VerboseEqual(msg); err != nil {
 10659  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10660  	}
 10661  	if !p.Equal(msg) {
 10662  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10663  	}
 10664  }
 10665  
 10666  func TestProtoTypeProtoText(t *testing.T) {
 10667  	seed := time.Now().UnixNano()
 10668  	popr := math_rand.New(math_rand.NewSource(seed))
 10669  	p := NewPopulatedProtoType(popr, true)
 10670  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
 10671  	msg := &ProtoType{}
 10672  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10673  		t.Fatalf("seed = %d, err = %v", seed, err)
 10674  	}
 10675  	if err := p.VerboseEqual(msg); err != nil {
 10676  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10677  	}
 10678  	if !p.Equal(msg) {
 10679  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10680  	}
 10681  }
 10682  
 10683  func TestProtoTypeProtoCompactText(t *testing.T) {
 10684  	seed := time.Now().UnixNano()
 10685  	popr := math_rand.New(math_rand.NewSource(seed))
 10686  	p := NewPopulatedProtoType(popr, true)
 10687  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
 10688  	msg := &ProtoType{}
 10689  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 10690  		t.Fatalf("seed = %d, err = %v", seed, err)
 10691  	}
 10692  	if err := p.VerboseEqual(msg); err != nil {
 10693  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
 10694  	}
 10695  	if !p.Equal(msg) {
 10696  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
 10697  	}
 10698  }
 10699  
 10700  func TestNidOptNativeCompare(t *testing.T) {
 10701  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10702  	p := NewPopulatedNidOptNative(popr, false)
 10703  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10704  	if err != nil {
 10705  		panic(err)
 10706  	}
 10707  	msg := &NidOptNative{}
 10708  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10709  		panic(err)
 10710  	}
 10711  	if c := p.Compare(msg); c != 0 {
 10712  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10713  	}
 10714  	p2 := NewPopulatedNidOptNative(popr, false)
 10715  	c := p.Compare(p2)
 10716  	c2 := p2.Compare(p)
 10717  	if c != (-1 * c2) {
 10718  		t.Errorf("p.Compare(p2) = %d", c)
 10719  		t.Errorf("p2.Compare(p) = %d", c2)
 10720  		t.Errorf("p = %#v", p)
 10721  		t.Errorf("p2 = %#v", p2)
 10722  	}
 10723  }
 10724  func TestNinOptNativeCompare(t *testing.T) {
 10725  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10726  	p := NewPopulatedNinOptNative(popr, false)
 10727  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10728  	if err != nil {
 10729  		panic(err)
 10730  	}
 10731  	msg := &NinOptNative{}
 10732  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10733  		panic(err)
 10734  	}
 10735  	if c := p.Compare(msg); c != 0 {
 10736  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10737  	}
 10738  	p2 := NewPopulatedNinOptNative(popr, false)
 10739  	c := p.Compare(p2)
 10740  	c2 := p2.Compare(p)
 10741  	if c != (-1 * c2) {
 10742  		t.Errorf("p.Compare(p2) = %d", c)
 10743  		t.Errorf("p2.Compare(p) = %d", c2)
 10744  		t.Errorf("p = %#v", p)
 10745  		t.Errorf("p2 = %#v", p2)
 10746  	}
 10747  }
 10748  func TestNidRepNativeCompare(t *testing.T) {
 10749  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10750  	p := NewPopulatedNidRepNative(popr, false)
 10751  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10752  	if err != nil {
 10753  		panic(err)
 10754  	}
 10755  	msg := &NidRepNative{}
 10756  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10757  		panic(err)
 10758  	}
 10759  	if c := p.Compare(msg); c != 0 {
 10760  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10761  	}
 10762  	p2 := NewPopulatedNidRepNative(popr, false)
 10763  	c := p.Compare(p2)
 10764  	c2 := p2.Compare(p)
 10765  	if c != (-1 * c2) {
 10766  		t.Errorf("p.Compare(p2) = %d", c)
 10767  		t.Errorf("p2.Compare(p) = %d", c2)
 10768  		t.Errorf("p = %#v", p)
 10769  		t.Errorf("p2 = %#v", p2)
 10770  	}
 10771  }
 10772  func TestNinRepNativeCompare(t *testing.T) {
 10773  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10774  	p := NewPopulatedNinRepNative(popr, false)
 10775  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10776  	if err != nil {
 10777  		panic(err)
 10778  	}
 10779  	msg := &NinRepNative{}
 10780  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10781  		panic(err)
 10782  	}
 10783  	if c := p.Compare(msg); c != 0 {
 10784  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10785  	}
 10786  	p2 := NewPopulatedNinRepNative(popr, false)
 10787  	c := p.Compare(p2)
 10788  	c2 := p2.Compare(p)
 10789  	if c != (-1 * c2) {
 10790  		t.Errorf("p.Compare(p2) = %d", c)
 10791  		t.Errorf("p2.Compare(p) = %d", c2)
 10792  		t.Errorf("p = %#v", p)
 10793  		t.Errorf("p2 = %#v", p2)
 10794  	}
 10795  }
 10796  func TestNidRepPackedNativeCompare(t *testing.T) {
 10797  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10798  	p := NewPopulatedNidRepPackedNative(popr, false)
 10799  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10800  	if err != nil {
 10801  		panic(err)
 10802  	}
 10803  	msg := &NidRepPackedNative{}
 10804  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10805  		panic(err)
 10806  	}
 10807  	if c := p.Compare(msg); c != 0 {
 10808  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10809  	}
 10810  	p2 := NewPopulatedNidRepPackedNative(popr, false)
 10811  	c := p.Compare(p2)
 10812  	c2 := p2.Compare(p)
 10813  	if c != (-1 * c2) {
 10814  		t.Errorf("p.Compare(p2) = %d", c)
 10815  		t.Errorf("p2.Compare(p) = %d", c2)
 10816  		t.Errorf("p = %#v", p)
 10817  		t.Errorf("p2 = %#v", p2)
 10818  	}
 10819  }
 10820  func TestNinRepPackedNativeCompare(t *testing.T) {
 10821  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10822  	p := NewPopulatedNinRepPackedNative(popr, false)
 10823  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10824  	if err != nil {
 10825  		panic(err)
 10826  	}
 10827  	msg := &NinRepPackedNative{}
 10828  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10829  		panic(err)
 10830  	}
 10831  	if c := p.Compare(msg); c != 0 {
 10832  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10833  	}
 10834  	p2 := NewPopulatedNinRepPackedNative(popr, false)
 10835  	c := p.Compare(p2)
 10836  	c2 := p2.Compare(p)
 10837  	if c != (-1 * c2) {
 10838  		t.Errorf("p.Compare(p2) = %d", c)
 10839  		t.Errorf("p2.Compare(p) = %d", c2)
 10840  		t.Errorf("p = %#v", p)
 10841  		t.Errorf("p2 = %#v", p2)
 10842  	}
 10843  }
 10844  func TestNidOptStructCompare(t *testing.T) {
 10845  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10846  	p := NewPopulatedNidOptStruct(popr, false)
 10847  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10848  	if err != nil {
 10849  		panic(err)
 10850  	}
 10851  	msg := &NidOptStruct{}
 10852  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10853  		panic(err)
 10854  	}
 10855  	if c := p.Compare(msg); c != 0 {
 10856  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10857  	}
 10858  	p2 := NewPopulatedNidOptStruct(popr, false)
 10859  	c := p.Compare(p2)
 10860  	c2 := p2.Compare(p)
 10861  	if c != (-1 * c2) {
 10862  		t.Errorf("p.Compare(p2) = %d", c)
 10863  		t.Errorf("p2.Compare(p) = %d", c2)
 10864  		t.Errorf("p = %#v", p)
 10865  		t.Errorf("p2 = %#v", p2)
 10866  	}
 10867  }
 10868  func TestNinOptStructCompare(t *testing.T) {
 10869  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10870  	p := NewPopulatedNinOptStruct(popr, false)
 10871  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10872  	if err != nil {
 10873  		panic(err)
 10874  	}
 10875  	msg := &NinOptStruct{}
 10876  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10877  		panic(err)
 10878  	}
 10879  	if c := p.Compare(msg); c != 0 {
 10880  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10881  	}
 10882  	p2 := NewPopulatedNinOptStruct(popr, false)
 10883  	c := p.Compare(p2)
 10884  	c2 := p2.Compare(p)
 10885  	if c != (-1 * c2) {
 10886  		t.Errorf("p.Compare(p2) = %d", c)
 10887  		t.Errorf("p2.Compare(p) = %d", c2)
 10888  		t.Errorf("p = %#v", p)
 10889  		t.Errorf("p2 = %#v", p2)
 10890  	}
 10891  }
 10892  func TestNidRepStructCompare(t *testing.T) {
 10893  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10894  	p := NewPopulatedNidRepStruct(popr, false)
 10895  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10896  	if err != nil {
 10897  		panic(err)
 10898  	}
 10899  	msg := &NidRepStruct{}
 10900  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10901  		panic(err)
 10902  	}
 10903  	if c := p.Compare(msg); c != 0 {
 10904  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10905  	}
 10906  	p2 := NewPopulatedNidRepStruct(popr, false)
 10907  	c := p.Compare(p2)
 10908  	c2 := p2.Compare(p)
 10909  	if c != (-1 * c2) {
 10910  		t.Errorf("p.Compare(p2) = %d", c)
 10911  		t.Errorf("p2.Compare(p) = %d", c2)
 10912  		t.Errorf("p = %#v", p)
 10913  		t.Errorf("p2 = %#v", p2)
 10914  	}
 10915  }
 10916  func TestNinRepStructCompare(t *testing.T) {
 10917  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10918  	p := NewPopulatedNinRepStruct(popr, false)
 10919  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10920  	if err != nil {
 10921  		panic(err)
 10922  	}
 10923  	msg := &NinRepStruct{}
 10924  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10925  		panic(err)
 10926  	}
 10927  	if c := p.Compare(msg); c != 0 {
 10928  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10929  	}
 10930  	p2 := NewPopulatedNinRepStruct(popr, false)
 10931  	c := p.Compare(p2)
 10932  	c2 := p2.Compare(p)
 10933  	if c != (-1 * c2) {
 10934  		t.Errorf("p.Compare(p2) = %d", c)
 10935  		t.Errorf("p2.Compare(p) = %d", c2)
 10936  		t.Errorf("p = %#v", p)
 10937  		t.Errorf("p2 = %#v", p2)
 10938  	}
 10939  }
 10940  func TestNidEmbeddedStructCompare(t *testing.T) {
 10941  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10942  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 10943  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10944  	if err != nil {
 10945  		panic(err)
 10946  	}
 10947  	msg := &NidEmbeddedStruct{}
 10948  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10949  		panic(err)
 10950  	}
 10951  	if c := p.Compare(msg); c != 0 {
 10952  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10953  	}
 10954  	p2 := NewPopulatedNidEmbeddedStruct(popr, false)
 10955  	c := p.Compare(p2)
 10956  	c2 := p2.Compare(p)
 10957  	if c != (-1 * c2) {
 10958  		t.Errorf("p.Compare(p2) = %d", c)
 10959  		t.Errorf("p2.Compare(p) = %d", c2)
 10960  		t.Errorf("p = %#v", p)
 10961  		t.Errorf("p2 = %#v", p2)
 10962  	}
 10963  }
 10964  func TestNinEmbeddedStructCompare(t *testing.T) {
 10965  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10966  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 10967  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10968  	if err != nil {
 10969  		panic(err)
 10970  	}
 10971  	msg := &NinEmbeddedStruct{}
 10972  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10973  		panic(err)
 10974  	}
 10975  	if c := p.Compare(msg); c != 0 {
 10976  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10977  	}
 10978  	p2 := NewPopulatedNinEmbeddedStruct(popr, false)
 10979  	c := p.Compare(p2)
 10980  	c2 := p2.Compare(p)
 10981  	if c != (-1 * c2) {
 10982  		t.Errorf("p.Compare(p2) = %d", c)
 10983  		t.Errorf("p2.Compare(p) = %d", c2)
 10984  		t.Errorf("p = %#v", p)
 10985  		t.Errorf("p2 = %#v", p2)
 10986  	}
 10987  }
 10988  func TestNidNestedStructCompare(t *testing.T) {
 10989  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10990  	p := NewPopulatedNidNestedStruct(popr, false)
 10991  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10992  	if err != nil {
 10993  		panic(err)
 10994  	}
 10995  	msg := &NidNestedStruct{}
 10996  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10997  		panic(err)
 10998  	}
 10999  	if c := p.Compare(msg); c != 0 {
 11000  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11001  	}
 11002  	p2 := NewPopulatedNidNestedStruct(popr, false)
 11003  	c := p.Compare(p2)
 11004  	c2 := p2.Compare(p)
 11005  	if c != (-1 * c2) {
 11006  		t.Errorf("p.Compare(p2) = %d", c)
 11007  		t.Errorf("p2.Compare(p) = %d", c2)
 11008  		t.Errorf("p = %#v", p)
 11009  		t.Errorf("p2 = %#v", p2)
 11010  	}
 11011  }
 11012  func TestNinNestedStructCompare(t *testing.T) {
 11013  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11014  	p := NewPopulatedNinNestedStruct(popr, false)
 11015  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11016  	if err != nil {
 11017  		panic(err)
 11018  	}
 11019  	msg := &NinNestedStruct{}
 11020  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11021  		panic(err)
 11022  	}
 11023  	if c := p.Compare(msg); c != 0 {
 11024  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11025  	}
 11026  	p2 := NewPopulatedNinNestedStruct(popr, false)
 11027  	c := p.Compare(p2)
 11028  	c2 := p2.Compare(p)
 11029  	if c != (-1 * c2) {
 11030  		t.Errorf("p.Compare(p2) = %d", c)
 11031  		t.Errorf("p2.Compare(p) = %d", c2)
 11032  		t.Errorf("p = %#v", p)
 11033  		t.Errorf("p2 = %#v", p2)
 11034  	}
 11035  }
 11036  func TestNidOptCustomCompare(t *testing.T) {
 11037  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11038  	p := NewPopulatedNidOptCustom(popr, false)
 11039  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11040  	if err != nil {
 11041  		panic(err)
 11042  	}
 11043  	msg := &NidOptCustom{}
 11044  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11045  		panic(err)
 11046  	}
 11047  	if c := p.Compare(msg); c != 0 {
 11048  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11049  	}
 11050  	p2 := NewPopulatedNidOptCustom(popr, false)
 11051  	c := p.Compare(p2)
 11052  	c2 := p2.Compare(p)
 11053  	if c != (-1 * c2) {
 11054  		t.Errorf("p.Compare(p2) = %d", c)
 11055  		t.Errorf("p2.Compare(p) = %d", c2)
 11056  		t.Errorf("p = %#v", p)
 11057  		t.Errorf("p2 = %#v", p2)
 11058  	}
 11059  }
 11060  func TestCustomDashCompare(t *testing.T) {
 11061  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11062  	p := NewPopulatedCustomDash(popr, false)
 11063  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11064  	if err != nil {
 11065  		panic(err)
 11066  	}
 11067  	msg := &CustomDash{}
 11068  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11069  		panic(err)
 11070  	}
 11071  	if c := p.Compare(msg); c != 0 {
 11072  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11073  	}
 11074  	p2 := NewPopulatedCustomDash(popr, false)
 11075  	c := p.Compare(p2)
 11076  	c2 := p2.Compare(p)
 11077  	if c != (-1 * c2) {
 11078  		t.Errorf("p.Compare(p2) = %d", c)
 11079  		t.Errorf("p2.Compare(p) = %d", c2)
 11080  		t.Errorf("p = %#v", p)
 11081  		t.Errorf("p2 = %#v", p2)
 11082  	}
 11083  }
 11084  func TestNinOptCustomCompare(t *testing.T) {
 11085  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11086  	p := NewPopulatedNinOptCustom(popr, false)
 11087  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11088  	if err != nil {
 11089  		panic(err)
 11090  	}
 11091  	msg := &NinOptCustom{}
 11092  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11093  		panic(err)
 11094  	}
 11095  	if c := p.Compare(msg); c != 0 {
 11096  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11097  	}
 11098  	p2 := NewPopulatedNinOptCustom(popr, false)
 11099  	c := p.Compare(p2)
 11100  	c2 := p2.Compare(p)
 11101  	if c != (-1 * c2) {
 11102  		t.Errorf("p.Compare(p2) = %d", c)
 11103  		t.Errorf("p2.Compare(p) = %d", c2)
 11104  		t.Errorf("p = %#v", p)
 11105  		t.Errorf("p2 = %#v", p2)
 11106  	}
 11107  }
 11108  func TestNidRepCustomCompare(t *testing.T) {
 11109  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11110  	p := NewPopulatedNidRepCustom(popr, false)
 11111  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11112  	if err != nil {
 11113  		panic(err)
 11114  	}
 11115  	msg := &NidRepCustom{}
 11116  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11117  		panic(err)
 11118  	}
 11119  	if c := p.Compare(msg); c != 0 {
 11120  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11121  	}
 11122  	p2 := NewPopulatedNidRepCustom(popr, false)
 11123  	c := p.Compare(p2)
 11124  	c2 := p2.Compare(p)
 11125  	if c != (-1 * c2) {
 11126  		t.Errorf("p.Compare(p2) = %d", c)
 11127  		t.Errorf("p2.Compare(p) = %d", c2)
 11128  		t.Errorf("p = %#v", p)
 11129  		t.Errorf("p2 = %#v", p2)
 11130  	}
 11131  }
 11132  func TestNinRepCustomCompare(t *testing.T) {
 11133  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11134  	p := NewPopulatedNinRepCustom(popr, false)
 11135  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11136  	if err != nil {
 11137  		panic(err)
 11138  	}
 11139  	msg := &NinRepCustom{}
 11140  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11141  		panic(err)
 11142  	}
 11143  	if c := p.Compare(msg); c != 0 {
 11144  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11145  	}
 11146  	p2 := NewPopulatedNinRepCustom(popr, false)
 11147  	c := p.Compare(p2)
 11148  	c2 := p2.Compare(p)
 11149  	if c != (-1 * c2) {
 11150  		t.Errorf("p.Compare(p2) = %d", c)
 11151  		t.Errorf("p2.Compare(p) = %d", c2)
 11152  		t.Errorf("p = %#v", p)
 11153  		t.Errorf("p2 = %#v", p2)
 11154  	}
 11155  }
 11156  func TestNinOptNativeUnionCompare(t *testing.T) {
 11157  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11158  	p := NewPopulatedNinOptNativeUnion(popr, false)
 11159  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11160  	if err != nil {
 11161  		panic(err)
 11162  	}
 11163  	msg := &NinOptNativeUnion{}
 11164  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11165  		panic(err)
 11166  	}
 11167  	if c := p.Compare(msg); c != 0 {
 11168  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11169  	}
 11170  	p2 := NewPopulatedNinOptNativeUnion(popr, false)
 11171  	c := p.Compare(p2)
 11172  	c2 := p2.Compare(p)
 11173  	if c != (-1 * c2) {
 11174  		t.Errorf("p.Compare(p2) = %d", c)
 11175  		t.Errorf("p2.Compare(p) = %d", c2)
 11176  		t.Errorf("p = %#v", p)
 11177  		t.Errorf("p2 = %#v", p2)
 11178  	}
 11179  }
 11180  func TestNinOptStructUnionCompare(t *testing.T) {
 11181  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11182  	p := NewPopulatedNinOptStructUnion(popr, false)
 11183  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11184  	if err != nil {
 11185  		panic(err)
 11186  	}
 11187  	msg := &NinOptStructUnion{}
 11188  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11189  		panic(err)
 11190  	}
 11191  	if c := p.Compare(msg); c != 0 {
 11192  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11193  	}
 11194  	p2 := NewPopulatedNinOptStructUnion(popr, false)
 11195  	c := p.Compare(p2)
 11196  	c2 := p2.Compare(p)
 11197  	if c != (-1 * c2) {
 11198  		t.Errorf("p.Compare(p2) = %d", c)
 11199  		t.Errorf("p2.Compare(p) = %d", c2)
 11200  		t.Errorf("p = %#v", p)
 11201  		t.Errorf("p2 = %#v", p2)
 11202  	}
 11203  }
 11204  func TestNinEmbeddedStructUnionCompare(t *testing.T) {
 11205  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11206  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 11207  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11208  	if err != nil {
 11209  		panic(err)
 11210  	}
 11211  	msg := &NinEmbeddedStructUnion{}
 11212  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11213  		panic(err)
 11214  	}
 11215  	if c := p.Compare(msg); c != 0 {
 11216  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11217  	}
 11218  	p2 := NewPopulatedNinEmbeddedStructUnion(popr, false)
 11219  	c := p.Compare(p2)
 11220  	c2 := p2.Compare(p)
 11221  	if c != (-1 * c2) {
 11222  		t.Errorf("p.Compare(p2) = %d", c)
 11223  		t.Errorf("p2.Compare(p) = %d", c2)
 11224  		t.Errorf("p = %#v", p)
 11225  		t.Errorf("p2 = %#v", p2)
 11226  	}
 11227  }
 11228  func TestNinNestedStructUnionCompare(t *testing.T) {
 11229  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11230  	p := NewPopulatedNinNestedStructUnion(popr, false)
 11231  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11232  	if err != nil {
 11233  		panic(err)
 11234  	}
 11235  	msg := &NinNestedStructUnion{}
 11236  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11237  		panic(err)
 11238  	}
 11239  	if c := p.Compare(msg); c != 0 {
 11240  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11241  	}
 11242  	p2 := NewPopulatedNinNestedStructUnion(popr, false)
 11243  	c := p.Compare(p2)
 11244  	c2 := p2.Compare(p)
 11245  	if c != (-1 * c2) {
 11246  		t.Errorf("p.Compare(p2) = %d", c)
 11247  		t.Errorf("p2.Compare(p) = %d", c2)
 11248  		t.Errorf("p = %#v", p)
 11249  		t.Errorf("p2 = %#v", p2)
 11250  	}
 11251  }
 11252  func TestTreeCompare(t *testing.T) {
 11253  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11254  	p := NewPopulatedTree(popr, false)
 11255  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11256  	if err != nil {
 11257  		panic(err)
 11258  	}
 11259  	msg := &Tree{}
 11260  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11261  		panic(err)
 11262  	}
 11263  	if c := p.Compare(msg); c != 0 {
 11264  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11265  	}
 11266  	p2 := NewPopulatedTree(popr, false)
 11267  	c := p.Compare(p2)
 11268  	c2 := p2.Compare(p)
 11269  	if c != (-1 * c2) {
 11270  		t.Errorf("p.Compare(p2) = %d", c)
 11271  		t.Errorf("p2.Compare(p) = %d", c2)
 11272  		t.Errorf("p = %#v", p)
 11273  		t.Errorf("p2 = %#v", p2)
 11274  	}
 11275  }
 11276  func TestOrBranchCompare(t *testing.T) {
 11277  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11278  	p := NewPopulatedOrBranch(popr, false)
 11279  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11280  	if err != nil {
 11281  		panic(err)
 11282  	}
 11283  	msg := &OrBranch{}
 11284  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11285  		panic(err)
 11286  	}
 11287  	if c := p.Compare(msg); c != 0 {
 11288  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11289  	}
 11290  	p2 := NewPopulatedOrBranch(popr, false)
 11291  	c := p.Compare(p2)
 11292  	c2 := p2.Compare(p)
 11293  	if c != (-1 * c2) {
 11294  		t.Errorf("p.Compare(p2) = %d", c)
 11295  		t.Errorf("p2.Compare(p) = %d", c2)
 11296  		t.Errorf("p = %#v", p)
 11297  		t.Errorf("p2 = %#v", p2)
 11298  	}
 11299  }
 11300  func TestAndBranchCompare(t *testing.T) {
 11301  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11302  	p := NewPopulatedAndBranch(popr, false)
 11303  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11304  	if err != nil {
 11305  		panic(err)
 11306  	}
 11307  	msg := &AndBranch{}
 11308  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11309  		panic(err)
 11310  	}
 11311  	if c := p.Compare(msg); c != 0 {
 11312  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11313  	}
 11314  	p2 := NewPopulatedAndBranch(popr, false)
 11315  	c := p.Compare(p2)
 11316  	c2 := p2.Compare(p)
 11317  	if c != (-1 * c2) {
 11318  		t.Errorf("p.Compare(p2) = %d", c)
 11319  		t.Errorf("p2.Compare(p) = %d", c2)
 11320  		t.Errorf("p = %#v", p)
 11321  		t.Errorf("p2 = %#v", p2)
 11322  	}
 11323  }
 11324  func TestLeafCompare(t *testing.T) {
 11325  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11326  	p := NewPopulatedLeaf(popr, false)
 11327  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11328  	if err != nil {
 11329  		panic(err)
 11330  	}
 11331  	msg := &Leaf{}
 11332  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11333  		panic(err)
 11334  	}
 11335  	if c := p.Compare(msg); c != 0 {
 11336  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11337  	}
 11338  	p2 := NewPopulatedLeaf(popr, false)
 11339  	c := p.Compare(p2)
 11340  	c2 := p2.Compare(p)
 11341  	if c != (-1 * c2) {
 11342  		t.Errorf("p.Compare(p2) = %d", c)
 11343  		t.Errorf("p2.Compare(p) = %d", c2)
 11344  		t.Errorf("p = %#v", p)
 11345  		t.Errorf("p2 = %#v", p2)
 11346  	}
 11347  }
 11348  func TestDeepTreeCompare(t *testing.T) {
 11349  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11350  	p := NewPopulatedDeepTree(popr, false)
 11351  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11352  	if err != nil {
 11353  		panic(err)
 11354  	}
 11355  	msg := &DeepTree{}
 11356  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11357  		panic(err)
 11358  	}
 11359  	if c := p.Compare(msg); c != 0 {
 11360  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11361  	}
 11362  	p2 := NewPopulatedDeepTree(popr, false)
 11363  	c := p.Compare(p2)
 11364  	c2 := p2.Compare(p)
 11365  	if c != (-1 * c2) {
 11366  		t.Errorf("p.Compare(p2) = %d", c)
 11367  		t.Errorf("p2.Compare(p) = %d", c2)
 11368  		t.Errorf("p = %#v", p)
 11369  		t.Errorf("p2 = %#v", p2)
 11370  	}
 11371  }
 11372  func TestADeepBranchCompare(t *testing.T) {
 11373  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11374  	p := NewPopulatedADeepBranch(popr, false)
 11375  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11376  	if err != nil {
 11377  		panic(err)
 11378  	}
 11379  	msg := &ADeepBranch{}
 11380  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11381  		panic(err)
 11382  	}
 11383  	if c := p.Compare(msg); c != 0 {
 11384  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11385  	}
 11386  	p2 := NewPopulatedADeepBranch(popr, false)
 11387  	c := p.Compare(p2)
 11388  	c2 := p2.Compare(p)
 11389  	if c != (-1 * c2) {
 11390  		t.Errorf("p.Compare(p2) = %d", c)
 11391  		t.Errorf("p2.Compare(p) = %d", c2)
 11392  		t.Errorf("p = %#v", p)
 11393  		t.Errorf("p2 = %#v", p2)
 11394  	}
 11395  }
 11396  func TestAndDeepBranchCompare(t *testing.T) {
 11397  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11398  	p := NewPopulatedAndDeepBranch(popr, false)
 11399  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11400  	if err != nil {
 11401  		panic(err)
 11402  	}
 11403  	msg := &AndDeepBranch{}
 11404  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11405  		panic(err)
 11406  	}
 11407  	if c := p.Compare(msg); c != 0 {
 11408  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11409  	}
 11410  	p2 := NewPopulatedAndDeepBranch(popr, false)
 11411  	c := p.Compare(p2)
 11412  	c2 := p2.Compare(p)
 11413  	if c != (-1 * c2) {
 11414  		t.Errorf("p.Compare(p2) = %d", c)
 11415  		t.Errorf("p2.Compare(p) = %d", c2)
 11416  		t.Errorf("p = %#v", p)
 11417  		t.Errorf("p2 = %#v", p2)
 11418  	}
 11419  }
 11420  func TestDeepLeafCompare(t *testing.T) {
 11421  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11422  	p := NewPopulatedDeepLeaf(popr, false)
 11423  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11424  	if err != nil {
 11425  		panic(err)
 11426  	}
 11427  	msg := &DeepLeaf{}
 11428  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11429  		panic(err)
 11430  	}
 11431  	if c := p.Compare(msg); c != 0 {
 11432  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11433  	}
 11434  	p2 := NewPopulatedDeepLeaf(popr, false)
 11435  	c := p.Compare(p2)
 11436  	c2 := p2.Compare(p)
 11437  	if c != (-1 * c2) {
 11438  		t.Errorf("p.Compare(p2) = %d", c)
 11439  		t.Errorf("p2.Compare(p) = %d", c2)
 11440  		t.Errorf("p = %#v", p)
 11441  		t.Errorf("p2 = %#v", p2)
 11442  	}
 11443  }
 11444  func TestNilCompare(t *testing.T) {
 11445  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11446  	p := NewPopulatedNil(popr, false)
 11447  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11448  	if err != nil {
 11449  		panic(err)
 11450  	}
 11451  	msg := &Nil{}
 11452  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11453  		panic(err)
 11454  	}
 11455  	if c := p.Compare(msg); c != 0 {
 11456  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11457  	}
 11458  	p2 := NewPopulatedNil(popr, false)
 11459  	c := p.Compare(p2)
 11460  	c2 := p2.Compare(p)
 11461  	if c != (-1 * c2) {
 11462  		t.Errorf("p.Compare(p2) = %d", c)
 11463  		t.Errorf("p2.Compare(p) = %d", c2)
 11464  		t.Errorf("p = %#v", p)
 11465  		t.Errorf("p2 = %#v", p2)
 11466  	}
 11467  }
 11468  func TestNidOptEnumCompare(t *testing.T) {
 11469  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11470  	p := NewPopulatedNidOptEnum(popr, false)
 11471  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11472  	if err != nil {
 11473  		panic(err)
 11474  	}
 11475  	msg := &NidOptEnum{}
 11476  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11477  		panic(err)
 11478  	}
 11479  	if c := p.Compare(msg); c != 0 {
 11480  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11481  	}
 11482  	p2 := NewPopulatedNidOptEnum(popr, false)
 11483  	c := p.Compare(p2)
 11484  	c2 := p2.Compare(p)
 11485  	if c != (-1 * c2) {
 11486  		t.Errorf("p.Compare(p2) = %d", c)
 11487  		t.Errorf("p2.Compare(p) = %d", c2)
 11488  		t.Errorf("p = %#v", p)
 11489  		t.Errorf("p2 = %#v", p2)
 11490  	}
 11491  }
 11492  func TestNinOptEnumCompare(t *testing.T) {
 11493  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11494  	p := NewPopulatedNinOptEnum(popr, false)
 11495  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11496  	if err != nil {
 11497  		panic(err)
 11498  	}
 11499  	msg := &NinOptEnum{}
 11500  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11501  		panic(err)
 11502  	}
 11503  	if c := p.Compare(msg); c != 0 {
 11504  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11505  	}
 11506  	p2 := NewPopulatedNinOptEnum(popr, false)
 11507  	c := p.Compare(p2)
 11508  	c2 := p2.Compare(p)
 11509  	if c != (-1 * c2) {
 11510  		t.Errorf("p.Compare(p2) = %d", c)
 11511  		t.Errorf("p2.Compare(p) = %d", c2)
 11512  		t.Errorf("p = %#v", p)
 11513  		t.Errorf("p2 = %#v", p2)
 11514  	}
 11515  }
 11516  func TestNidRepEnumCompare(t *testing.T) {
 11517  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11518  	p := NewPopulatedNidRepEnum(popr, false)
 11519  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11520  	if err != nil {
 11521  		panic(err)
 11522  	}
 11523  	msg := &NidRepEnum{}
 11524  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11525  		panic(err)
 11526  	}
 11527  	if c := p.Compare(msg); c != 0 {
 11528  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11529  	}
 11530  	p2 := NewPopulatedNidRepEnum(popr, false)
 11531  	c := p.Compare(p2)
 11532  	c2 := p2.Compare(p)
 11533  	if c != (-1 * c2) {
 11534  		t.Errorf("p.Compare(p2) = %d", c)
 11535  		t.Errorf("p2.Compare(p) = %d", c2)
 11536  		t.Errorf("p = %#v", p)
 11537  		t.Errorf("p2 = %#v", p2)
 11538  	}
 11539  }
 11540  func TestNinRepEnumCompare(t *testing.T) {
 11541  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11542  	p := NewPopulatedNinRepEnum(popr, false)
 11543  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11544  	if err != nil {
 11545  		panic(err)
 11546  	}
 11547  	msg := &NinRepEnum{}
 11548  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11549  		panic(err)
 11550  	}
 11551  	if c := p.Compare(msg); c != 0 {
 11552  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11553  	}
 11554  	p2 := NewPopulatedNinRepEnum(popr, false)
 11555  	c := p.Compare(p2)
 11556  	c2 := p2.Compare(p)
 11557  	if c != (-1 * c2) {
 11558  		t.Errorf("p.Compare(p2) = %d", c)
 11559  		t.Errorf("p2.Compare(p) = %d", c2)
 11560  		t.Errorf("p = %#v", p)
 11561  		t.Errorf("p2 = %#v", p2)
 11562  	}
 11563  }
 11564  func TestNinOptEnumDefaultCompare(t *testing.T) {
 11565  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11566  	p := NewPopulatedNinOptEnumDefault(popr, false)
 11567  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11568  	if err != nil {
 11569  		panic(err)
 11570  	}
 11571  	msg := &NinOptEnumDefault{}
 11572  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11573  		panic(err)
 11574  	}
 11575  	if c := p.Compare(msg); c != 0 {
 11576  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11577  	}
 11578  	p2 := NewPopulatedNinOptEnumDefault(popr, false)
 11579  	c := p.Compare(p2)
 11580  	c2 := p2.Compare(p)
 11581  	if c != (-1 * c2) {
 11582  		t.Errorf("p.Compare(p2) = %d", c)
 11583  		t.Errorf("p2.Compare(p) = %d", c2)
 11584  		t.Errorf("p = %#v", p)
 11585  		t.Errorf("p2 = %#v", p2)
 11586  	}
 11587  }
 11588  func TestAnotherNinOptEnumCompare(t *testing.T) {
 11589  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11590  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 11591  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11592  	if err != nil {
 11593  		panic(err)
 11594  	}
 11595  	msg := &AnotherNinOptEnum{}
 11596  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11597  		panic(err)
 11598  	}
 11599  	if c := p.Compare(msg); c != 0 {
 11600  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11601  	}
 11602  	p2 := NewPopulatedAnotherNinOptEnum(popr, false)
 11603  	c := p.Compare(p2)
 11604  	c2 := p2.Compare(p)
 11605  	if c != (-1 * c2) {
 11606  		t.Errorf("p.Compare(p2) = %d", c)
 11607  		t.Errorf("p2.Compare(p) = %d", c2)
 11608  		t.Errorf("p = %#v", p)
 11609  		t.Errorf("p2 = %#v", p2)
 11610  	}
 11611  }
 11612  func TestAnotherNinOptEnumDefaultCompare(t *testing.T) {
 11613  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11614  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 11615  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11616  	if err != nil {
 11617  		panic(err)
 11618  	}
 11619  	msg := &AnotherNinOptEnumDefault{}
 11620  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11621  		panic(err)
 11622  	}
 11623  	if c := p.Compare(msg); c != 0 {
 11624  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11625  	}
 11626  	p2 := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 11627  	c := p.Compare(p2)
 11628  	c2 := p2.Compare(p)
 11629  	if c != (-1 * c2) {
 11630  		t.Errorf("p.Compare(p2) = %d", c)
 11631  		t.Errorf("p2.Compare(p) = %d", c2)
 11632  		t.Errorf("p = %#v", p)
 11633  		t.Errorf("p2 = %#v", p2)
 11634  	}
 11635  }
 11636  func TestTimerCompare(t *testing.T) {
 11637  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11638  	p := NewPopulatedTimer(popr, false)
 11639  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11640  	if err != nil {
 11641  		panic(err)
 11642  	}
 11643  	msg := &Timer{}
 11644  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11645  		panic(err)
 11646  	}
 11647  	if c := p.Compare(msg); c != 0 {
 11648  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11649  	}
 11650  	p2 := NewPopulatedTimer(popr, false)
 11651  	c := p.Compare(p2)
 11652  	c2 := p2.Compare(p)
 11653  	if c != (-1 * c2) {
 11654  		t.Errorf("p.Compare(p2) = %d", c)
 11655  		t.Errorf("p2.Compare(p) = %d", c2)
 11656  		t.Errorf("p = %#v", p)
 11657  		t.Errorf("p2 = %#v", p2)
 11658  	}
 11659  }
 11660  func TestMyExtendableCompare(t *testing.T) {
 11661  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11662  	p := NewPopulatedMyExtendable(popr, false)
 11663  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11664  	if err != nil {
 11665  		panic(err)
 11666  	}
 11667  	msg := &MyExtendable{}
 11668  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11669  		panic(err)
 11670  	}
 11671  	if c := p.Compare(msg); c != 0 {
 11672  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11673  	}
 11674  	p2 := NewPopulatedMyExtendable(popr, false)
 11675  	c := p.Compare(p2)
 11676  	c2 := p2.Compare(p)
 11677  	if c != (-1 * c2) {
 11678  		t.Errorf("p.Compare(p2) = %d", c)
 11679  		t.Errorf("p2.Compare(p) = %d", c2)
 11680  		t.Errorf("p = %#v", p)
 11681  		t.Errorf("p2 = %#v", p2)
 11682  	}
 11683  }
 11684  func TestOtherExtenableCompare(t *testing.T) {
 11685  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11686  	p := NewPopulatedOtherExtenable(popr, false)
 11687  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11688  	if err != nil {
 11689  		panic(err)
 11690  	}
 11691  	msg := &OtherExtenable{}
 11692  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11693  		panic(err)
 11694  	}
 11695  	if c := p.Compare(msg); c != 0 {
 11696  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11697  	}
 11698  	p2 := NewPopulatedOtherExtenable(popr, false)
 11699  	c := p.Compare(p2)
 11700  	c2 := p2.Compare(p)
 11701  	if c != (-1 * c2) {
 11702  		t.Errorf("p.Compare(p2) = %d", c)
 11703  		t.Errorf("p2.Compare(p) = %d", c2)
 11704  		t.Errorf("p = %#v", p)
 11705  		t.Errorf("p2 = %#v", p2)
 11706  	}
 11707  }
 11708  func TestNestedDefinitionCompare(t *testing.T) {
 11709  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11710  	p := NewPopulatedNestedDefinition(popr, false)
 11711  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11712  	if err != nil {
 11713  		panic(err)
 11714  	}
 11715  	msg := &NestedDefinition{}
 11716  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11717  		panic(err)
 11718  	}
 11719  	if c := p.Compare(msg); c != 0 {
 11720  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11721  	}
 11722  	p2 := NewPopulatedNestedDefinition(popr, false)
 11723  	c := p.Compare(p2)
 11724  	c2 := p2.Compare(p)
 11725  	if c != (-1 * c2) {
 11726  		t.Errorf("p.Compare(p2) = %d", c)
 11727  		t.Errorf("p2.Compare(p) = %d", c2)
 11728  		t.Errorf("p = %#v", p)
 11729  		t.Errorf("p2 = %#v", p2)
 11730  	}
 11731  }
 11732  func TestNestedDefinition_NestedMessageCompare(t *testing.T) {
 11733  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11734  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 11735  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11736  	if err != nil {
 11737  		panic(err)
 11738  	}
 11739  	msg := &NestedDefinition_NestedMessage{}
 11740  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11741  		panic(err)
 11742  	}
 11743  	if c := p.Compare(msg); c != 0 {
 11744  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11745  	}
 11746  	p2 := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 11747  	c := p.Compare(p2)
 11748  	c2 := p2.Compare(p)
 11749  	if c != (-1 * c2) {
 11750  		t.Errorf("p.Compare(p2) = %d", c)
 11751  		t.Errorf("p2.Compare(p) = %d", c2)
 11752  		t.Errorf("p = %#v", p)
 11753  		t.Errorf("p2 = %#v", p2)
 11754  	}
 11755  }
 11756  func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) {
 11757  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11758  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 11759  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11760  	if err != nil {
 11761  		panic(err)
 11762  	}
 11763  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
 11764  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11765  		panic(err)
 11766  	}
 11767  	if c := p.Compare(msg); c != 0 {
 11768  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11769  	}
 11770  	p2 := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 11771  	c := p.Compare(p2)
 11772  	c2 := p2.Compare(p)
 11773  	if c != (-1 * c2) {
 11774  		t.Errorf("p.Compare(p2) = %d", c)
 11775  		t.Errorf("p2.Compare(p) = %d", c2)
 11776  		t.Errorf("p = %#v", p)
 11777  		t.Errorf("p2 = %#v", p2)
 11778  	}
 11779  }
 11780  func TestNestedScopeCompare(t *testing.T) {
 11781  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11782  	p := NewPopulatedNestedScope(popr, false)
 11783  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11784  	if err != nil {
 11785  		panic(err)
 11786  	}
 11787  	msg := &NestedScope{}
 11788  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11789  		panic(err)
 11790  	}
 11791  	if c := p.Compare(msg); c != 0 {
 11792  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11793  	}
 11794  	p2 := NewPopulatedNestedScope(popr, false)
 11795  	c := p.Compare(p2)
 11796  	c2 := p2.Compare(p)
 11797  	if c != (-1 * c2) {
 11798  		t.Errorf("p.Compare(p2) = %d", c)
 11799  		t.Errorf("p2.Compare(p) = %d", c2)
 11800  		t.Errorf("p = %#v", p)
 11801  		t.Errorf("p2 = %#v", p2)
 11802  	}
 11803  }
 11804  func TestNinOptNativeDefaultCompare(t *testing.T) {
 11805  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11806  	p := NewPopulatedNinOptNativeDefault(popr, false)
 11807  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11808  	if err != nil {
 11809  		panic(err)
 11810  	}
 11811  	msg := &NinOptNativeDefault{}
 11812  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11813  		panic(err)
 11814  	}
 11815  	if c := p.Compare(msg); c != 0 {
 11816  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11817  	}
 11818  	p2 := NewPopulatedNinOptNativeDefault(popr, false)
 11819  	c := p.Compare(p2)
 11820  	c2 := p2.Compare(p)
 11821  	if c != (-1 * c2) {
 11822  		t.Errorf("p.Compare(p2) = %d", c)
 11823  		t.Errorf("p2.Compare(p) = %d", c2)
 11824  		t.Errorf("p = %#v", p)
 11825  		t.Errorf("p2 = %#v", p2)
 11826  	}
 11827  }
 11828  func TestCustomContainerCompare(t *testing.T) {
 11829  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11830  	p := NewPopulatedCustomContainer(popr, false)
 11831  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11832  	if err != nil {
 11833  		panic(err)
 11834  	}
 11835  	msg := &CustomContainer{}
 11836  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11837  		panic(err)
 11838  	}
 11839  	if c := p.Compare(msg); c != 0 {
 11840  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11841  	}
 11842  	p2 := NewPopulatedCustomContainer(popr, false)
 11843  	c := p.Compare(p2)
 11844  	c2 := p2.Compare(p)
 11845  	if c != (-1 * c2) {
 11846  		t.Errorf("p.Compare(p2) = %d", c)
 11847  		t.Errorf("p2.Compare(p) = %d", c2)
 11848  		t.Errorf("p = %#v", p)
 11849  		t.Errorf("p2 = %#v", p2)
 11850  	}
 11851  }
 11852  func TestCustomNameNidOptNativeCompare(t *testing.T) {
 11853  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11854  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 11855  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11856  	if err != nil {
 11857  		panic(err)
 11858  	}
 11859  	msg := &CustomNameNidOptNative{}
 11860  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11861  		panic(err)
 11862  	}
 11863  	if c := p.Compare(msg); c != 0 {
 11864  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11865  	}
 11866  	p2 := NewPopulatedCustomNameNidOptNative(popr, false)
 11867  	c := p.Compare(p2)
 11868  	c2 := p2.Compare(p)
 11869  	if c != (-1 * c2) {
 11870  		t.Errorf("p.Compare(p2) = %d", c)
 11871  		t.Errorf("p2.Compare(p) = %d", c2)
 11872  		t.Errorf("p = %#v", p)
 11873  		t.Errorf("p2 = %#v", p2)
 11874  	}
 11875  }
 11876  func TestCustomNameNinOptNativeCompare(t *testing.T) {
 11877  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11878  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 11879  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11880  	if err != nil {
 11881  		panic(err)
 11882  	}
 11883  	msg := &CustomNameNinOptNative{}
 11884  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11885  		panic(err)
 11886  	}
 11887  	if c := p.Compare(msg); c != 0 {
 11888  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11889  	}
 11890  	p2 := NewPopulatedCustomNameNinOptNative(popr, false)
 11891  	c := p.Compare(p2)
 11892  	c2 := p2.Compare(p)
 11893  	if c != (-1 * c2) {
 11894  		t.Errorf("p.Compare(p2) = %d", c)
 11895  		t.Errorf("p2.Compare(p) = %d", c2)
 11896  		t.Errorf("p = %#v", p)
 11897  		t.Errorf("p2 = %#v", p2)
 11898  	}
 11899  }
 11900  func TestCustomNameNinRepNativeCompare(t *testing.T) {
 11901  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11902  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 11903  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11904  	if err != nil {
 11905  		panic(err)
 11906  	}
 11907  	msg := &CustomNameNinRepNative{}
 11908  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11909  		panic(err)
 11910  	}
 11911  	if c := p.Compare(msg); c != 0 {
 11912  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11913  	}
 11914  	p2 := NewPopulatedCustomNameNinRepNative(popr, false)
 11915  	c := p.Compare(p2)
 11916  	c2 := p2.Compare(p)
 11917  	if c != (-1 * c2) {
 11918  		t.Errorf("p.Compare(p2) = %d", c)
 11919  		t.Errorf("p2.Compare(p) = %d", c2)
 11920  		t.Errorf("p = %#v", p)
 11921  		t.Errorf("p2 = %#v", p2)
 11922  	}
 11923  }
 11924  func TestCustomNameNinStructCompare(t *testing.T) {
 11925  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11926  	p := NewPopulatedCustomNameNinStruct(popr, false)
 11927  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11928  	if err != nil {
 11929  		panic(err)
 11930  	}
 11931  	msg := &CustomNameNinStruct{}
 11932  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11933  		panic(err)
 11934  	}
 11935  	if c := p.Compare(msg); c != 0 {
 11936  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11937  	}
 11938  	p2 := NewPopulatedCustomNameNinStruct(popr, false)
 11939  	c := p.Compare(p2)
 11940  	c2 := p2.Compare(p)
 11941  	if c != (-1 * c2) {
 11942  		t.Errorf("p.Compare(p2) = %d", c)
 11943  		t.Errorf("p2.Compare(p) = %d", c2)
 11944  		t.Errorf("p = %#v", p)
 11945  		t.Errorf("p2 = %#v", p2)
 11946  	}
 11947  }
 11948  func TestCustomNameCustomTypeCompare(t *testing.T) {
 11949  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11950  	p := NewPopulatedCustomNameCustomType(popr, false)
 11951  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11952  	if err != nil {
 11953  		panic(err)
 11954  	}
 11955  	msg := &CustomNameCustomType{}
 11956  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11957  		panic(err)
 11958  	}
 11959  	if c := p.Compare(msg); c != 0 {
 11960  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11961  	}
 11962  	p2 := NewPopulatedCustomNameCustomType(popr, false)
 11963  	c := p.Compare(p2)
 11964  	c2 := p2.Compare(p)
 11965  	if c != (-1 * c2) {
 11966  		t.Errorf("p.Compare(p2) = %d", c)
 11967  		t.Errorf("p2.Compare(p) = %d", c2)
 11968  		t.Errorf("p = %#v", p)
 11969  		t.Errorf("p2 = %#v", p2)
 11970  	}
 11971  }
 11972  func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) {
 11973  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11974  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 11975  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11976  	if err != nil {
 11977  		panic(err)
 11978  	}
 11979  	msg := &CustomNameNinEmbeddedStructUnion{}
 11980  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11981  		panic(err)
 11982  	}
 11983  	if c := p.Compare(msg); c != 0 {
 11984  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 11985  	}
 11986  	p2 := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 11987  	c := p.Compare(p2)
 11988  	c2 := p2.Compare(p)
 11989  	if c != (-1 * c2) {
 11990  		t.Errorf("p.Compare(p2) = %d", c)
 11991  		t.Errorf("p2.Compare(p) = %d", c2)
 11992  		t.Errorf("p = %#v", p)
 11993  		t.Errorf("p2 = %#v", p2)
 11994  	}
 11995  }
 11996  func TestCustomNameEnumCompare(t *testing.T) {
 11997  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11998  	p := NewPopulatedCustomNameEnum(popr, false)
 11999  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12000  	if err != nil {
 12001  		panic(err)
 12002  	}
 12003  	msg := &CustomNameEnum{}
 12004  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12005  		panic(err)
 12006  	}
 12007  	if c := p.Compare(msg); c != 0 {
 12008  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12009  	}
 12010  	p2 := NewPopulatedCustomNameEnum(popr, false)
 12011  	c := p.Compare(p2)
 12012  	c2 := p2.Compare(p)
 12013  	if c != (-1 * c2) {
 12014  		t.Errorf("p.Compare(p2) = %d", c)
 12015  		t.Errorf("p2.Compare(p) = %d", c2)
 12016  		t.Errorf("p = %#v", p)
 12017  		t.Errorf("p2 = %#v", p2)
 12018  	}
 12019  }
 12020  func TestNoExtensionsMapCompare(t *testing.T) {
 12021  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12022  	p := NewPopulatedNoExtensionsMap(popr, false)
 12023  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12024  	if err != nil {
 12025  		panic(err)
 12026  	}
 12027  	msg := &NoExtensionsMap{}
 12028  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12029  		panic(err)
 12030  	}
 12031  	if c := p.Compare(msg); c != 0 {
 12032  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12033  	}
 12034  	p2 := NewPopulatedNoExtensionsMap(popr, false)
 12035  	c := p.Compare(p2)
 12036  	c2 := p2.Compare(p)
 12037  	if c != (-1 * c2) {
 12038  		t.Errorf("p.Compare(p2) = %d", c)
 12039  		t.Errorf("p2.Compare(p) = %d", c2)
 12040  		t.Errorf("p = %#v", p)
 12041  		t.Errorf("p2 = %#v", p2)
 12042  	}
 12043  }
 12044  func TestUnrecognizedCompare(t *testing.T) {
 12045  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12046  	p := NewPopulatedUnrecognized(popr, false)
 12047  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12048  	if err != nil {
 12049  		panic(err)
 12050  	}
 12051  	msg := &Unrecognized{}
 12052  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12053  		panic(err)
 12054  	}
 12055  	if c := p.Compare(msg); c != 0 {
 12056  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12057  	}
 12058  	p2 := NewPopulatedUnrecognized(popr, false)
 12059  	c := p.Compare(p2)
 12060  	c2 := p2.Compare(p)
 12061  	if c != (-1 * c2) {
 12062  		t.Errorf("p.Compare(p2) = %d", c)
 12063  		t.Errorf("p2.Compare(p) = %d", c2)
 12064  		t.Errorf("p = %#v", p)
 12065  		t.Errorf("p2 = %#v", p2)
 12066  	}
 12067  }
 12068  func TestUnrecognizedWithInnerCompare(t *testing.T) {
 12069  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12070  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 12071  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12072  	if err != nil {
 12073  		panic(err)
 12074  	}
 12075  	msg := &UnrecognizedWithInner{}
 12076  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12077  		panic(err)
 12078  	}
 12079  	if c := p.Compare(msg); c != 0 {
 12080  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12081  	}
 12082  	p2 := NewPopulatedUnrecognizedWithInner(popr, false)
 12083  	c := p.Compare(p2)
 12084  	c2 := p2.Compare(p)
 12085  	if c != (-1 * c2) {
 12086  		t.Errorf("p.Compare(p2) = %d", c)
 12087  		t.Errorf("p2.Compare(p) = %d", c2)
 12088  		t.Errorf("p = %#v", p)
 12089  		t.Errorf("p2 = %#v", p2)
 12090  	}
 12091  }
 12092  func TestUnrecognizedWithInner_InnerCompare(t *testing.T) {
 12093  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12094  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 12095  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12096  	if err != nil {
 12097  		panic(err)
 12098  	}
 12099  	msg := &UnrecognizedWithInner_Inner{}
 12100  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12101  		panic(err)
 12102  	}
 12103  	if c := p.Compare(msg); c != 0 {
 12104  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12105  	}
 12106  	p2 := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 12107  	c := p.Compare(p2)
 12108  	c2 := p2.Compare(p)
 12109  	if c != (-1 * c2) {
 12110  		t.Errorf("p.Compare(p2) = %d", c)
 12111  		t.Errorf("p2.Compare(p) = %d", c2)
 12112  		t.Errorf("p = %#v", p)
 12113  		t.Errorf("p2 = %#v", p2)
 12114  	}
 12115  }
 12116  func TestUnrecognizedWithEmbedCompare(t *testing.T) {
 12117  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12118  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 12119  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12120  	if err != nil {
 12121  		panic(err)
 12122  	}
 12123  	msg := &UnrecognizedWithEmbed{}
 12124  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12125  		panic(err)
 12126  	}
 12127  	if c := p.Compare(msg); c != 0 {
 12128  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12129  	}
 12130  	p2 := NewPopulatedUnrecognizedWithEmbed(popr, false)
 12131  	c := p.Compare(p2)
 12132  	c2 := p2.Compare(p)
 12133  	if c != (-1 * c2) {
 12134  		t.Errorf("p.Compare(p2) = %d", c)
 12135  		t.Errorf("p2.Compare(p) = %d", c2)
 12136  		t.Errorf("p = %#v", p)
 12137  		t.Errorf("p2 = %#v", p2)
 12138  	}
 12139  }
 12140  func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) {
 12141  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12142  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 12143  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12144  	if err != nil {
 12145  		panic(err)
 12146  	}
 12147  	msg := &UnrecognizedWithEmbed_Embedded{}
 12148  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12149  		panic(err)
 12150  	}
 12151  	if c := p.Compare(msg); c != 0 {
 12152  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12153  	}
 12154  	p2 := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 12155  	c := p.Compare(p2)
 12156  	c2 := p2.Compare(p)
 12157  	if c != (-1 * c2) {
 12158  		t.Errorf("p.Compare(p2) = %d", c)
 12159  		t.Errorf("p2.Compare(p) = %d", c2)
 12160  		t.Errorf("p = %#v", p)
 12161  		t.Errorf("p2 = %#v", p2)
 12162  	}
 12163  }
 12164  func TestNodeCompare(t *testing.T) {
 12165  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12166  	p := NewPopulatedNode(popr, false)
 12167  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12168  	if err != nil {
 12169  		panic(err)
 12170  	}
 12171  	msg := &Node{}
 12172  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12173  		panic(err)
 12174  	}
 12175  	if c := p.Compare(msg); c != 0 {
 12176  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12177  	}
 12178  	p2 := NewPopulatedNode(popr, false)
 12179  	c := p.Compare(p2)
 12180  	c2 := p2.Compare(p)
 12181  	if c != (-1 * c2) {
 12182  		t.Errorf("p.Compare(p2) = %d", c)
 12183  		t.Errorf("p2.Compare(p) = %d", c2)
 12184  		t.Errorf("p = %#v", p)
 12185  		t.Errorf("p2 = %#v", p2)
 12186  	}
 12187  }
 12188  func TestNonByteCustomTypeCompare(t *testing.T) {
 12189  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12190  	p := NewPopulatedNonByteCustomType(popr, false)
 12191  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12192  	if err != nil {
 12193  		panic(err)
 12194  	}
 12195  	msg := &NonByteCustomType{}
 12196  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12197  		panic(err)
 12198  	}
 12199  	if c := p.Compare(msg); c != 0 {
 12200  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12201  	}
 12202  	p2 := NewPopulatedNonByteCustomType(popr, false)
 12203  	c := p.Compare(p2)
 12204  	c2 := p2.Compare(p)
 12205  	if c != (-1 * c2) {
 12206  		t.Errorf("p.Compare(p2) = %d", c)
 12207  		t.Errorf("p2.Compare(p) = %d", c2)
 12208  		t.Errorf("p = %#v", p)
 12209  		t.Errorf("p2 = %#v", p2)
 12210  	}
 12211  }
 12212  func TestNidOptNonByteCustomTypeCompare(t *testing.T) {
 12213  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12214  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 12215  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12216  	if err != nil {
 12217  		panic(err)
 12218  	}
 12219  	msg := &NidOptNonByteCustomType{}
 12220  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12221  		panic(err)
 12222  	}
 12223  	if c := p.Compare(msg); c != 0 {
 12224  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12225  	}
 12226  	p2 := NewPopulatedNidOptNonByteCustomType(popr, false)
 12227  	c := p.Compare(p2)
 12228  	c2 := p2.Compare(p)
 12229  	if c != (-1 * c2) {
 12230  		t.Errorf("p.Compare(p2) = %d", c)
 12231  		t.Errorf("p2.Compare(p) = %d", c2)
 12232  		t.Errorf("p = %#v", p)
 12233  		t.Errorf("p2 = %#v", p2)
 12234  	}
 12235  }
 12236  func TestNinOptNonByteCustomTypeCompare(t *testing.T) {
 12237  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12238  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 12239  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12240  	if err != nil {
 12241  		panic(err)
 12242  	}
 12243  	msg := &NinOptNonByteCustomType{}
 12244  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12245  		panic(err)
 12246  	}
 12247  	if c := p.Compare(msg); c != 0 {
 12248  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12249  	}
 12250  	p2 := NewPopulatedNinOptNonByteCustomType(popr, false)
 12251  	c := p.Compare(p2)
 12252  	c2 := p2.Compare(p)
 12253  	if c != (-1 * c2) {
 12254  		t.Errorf("p.Compare(p2) = %d", c)
 12255  		t.Errorf("p2.Compare(p) = %d", c2)
 12256  		t.Errorf("p = %#v", p)
 12257  		t.Errorf("p2 = %#v", p2)
 12258  	}
 12259  }
 12260  func TestNidRepNonByteCustomTypeCompare(t *testing.T) {
 12261  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12262  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 12263  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12264  	if err != nil {
 12265  		panic(err)
 12266  	}
 12267  	msg := &NidRepNonByteCustomType{}
 12268  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12269  		panic(err)
 12270  	}
 12271  	if c := p.Compare(msg); c != 0 {
 12272  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12273  	}
 12274  	p2 := NewPopulatedNidRepNonByteCustomType(popr, false)
 12275  	c := p.Compare(p2)
 12276  	c2 := p2.Compare(p)
 12277  	if c != (-1 * c2) {
 12278  		t.Errorf("p.Compare(p2) = %d", c)
 12279  		t.Errorf("p2.Compare(p) = %d", c2)
 12280  		t.Errorf("p = %#v", p)
 12281  		t.Errorf("p2 = %#v", p2)
 12282  	}
 12283  }
 12284  func TestNinRepNonByteCustomTypeCompare(t *testing.T) {
 12285  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12286  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 12287  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12288  	if err != nil {
 12289  		panic(err)
 12290  	}
 12291  	msg := &NinRepNonByteCustomType{}
 12292  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12293  		panic(err)
 12294  	}
 12295  	if c := p.Compare(msg); c != 0 {
 12296  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12297  	}
 12298  	p2 := NewPopulatedNinRepNonByteCustomType(popr, false)
 12299  	c := p.Compare(p2)
 12300  	c2 := p2.Compare(p)
 12301  	if c != (-1 * c2) {
 12302  		t.Errorf("p.Compare(p2) = %d", c)
 12303  		t.Errorf("p2.Compare(p) = %d", c2)
 12304  		t.Errorf("p = %#v", p)
 12305  		t.Errorf("p2 = %#v", p2)
 12306  	}
 12307  }
 12308  func TestProtoTypeCompare(t *testing.T) {
 12309  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12310  	p := NewPopulatedProtoType(popr, false)
 12311  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12312  	if err != nil {
 12313  		panic(err)
 12314  	}
 12315  	msg := &ProtoType{}
 12316  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12317  		panic(err)
 12318  	}
 12319  	if c := p.Compare(msg); c != 0 {
 12320  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 12321  	}
 12322  	p2 := NewPopulatedProtoType(popr, false)
 12323  	c := p.Compare(p2)
 12324  	c2 := p2.Compare(p)
 12325  	if c != (-1 * c2) {
 12326  		t.Errorf("p.Compare(p2) = %d", c)
 12327  		t.Errorf("p2.Compare(p) = %d", c2)
 12328  		t.Errorf("p = %#v", p)
 12329  		t.Errorf("p2 = %#v", p2)
 12330  	}
 12331  }
 12332  func TestThetestDescription(t *testing.T) {
 12333  	ThetestDescription()
 12334  }
 12335  func TestNidOptNativeVerboseEqual(t *testing.T) {
 12336  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12337  	p := NewPopulatedNidOptNative(popr, false)
 12338  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12339  	if err != nil {
 12340  		panic(err)
 12341  	}
 12342  	msg := &NidOptNative{}
 12343  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12344  		panic(err)
 12345  	}
 12346  	if err := p.VerboseEqual(msg); err != nil {
 12347  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12348  	}
 12349  }
 12350  func TestNinOptNativeVerboseEqual(t *testing.T) {
 12351  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12352  	p := NewPopulatedNinOptNative(popr, false)
 12353  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12354  	if err != nil {
 12355  		panic(err)
 12356  	}
 12357  	msg := &NinOptNative{}
 12358  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12359  		panic(err)
 12360  	}
 12361  	if err := p.VerboseEqual(msg); err != nil {
 12362  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12363  	}
 12364  }
 12365  func TestNidRepNativeVerboseEqual(t *testing.T) {
 12366  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12367  	p := NewPopulatedNidRepNative(popr, false)
 12368  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12369  	if err != nil {
 12370  		panic(err)
 12371  	}
 12372  	msg := &NidRepNative{}
 12373  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12374  		panic(err)
 12375  	}
 12376  	if err := p.VerboseEqual(msg); err != nil {
 12377  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12378  	}
 12379  }
 12380  func TestNinRepNativeVerboseEqual(t *testing.T) {
 12381  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12382  	p := NewPopulatedNinRepNative(popr, false)
 12383  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12384  	if err != nil {
 12385  		panic(err)
 12386  	}
 12387  	msg := &NinRepNative{}
 12388  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12389  		panic(err)
 12390  	}
 12391  	if err := p.VerboseEqual(msg); err != nil {
 12392  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12393  	}
 12394  }
 12395  func TestNidRepPackedNativeVerboseEqual(t *testing.T) {
 12396  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12397  	p := NewPopulatedNidRepPackedNative(popr, false)
 12398  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12399  	if err != nil {
 12400  		panic(err)
 12401  	}
 12402  	msg := &NidRepPackedNative{}
 12403  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12404  		panic(err)
 12405  	}
 12406  	if err := p.VerboseEqual(msg); err != nil {
 12407  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12408  	}
 12409  }
 12410  func TestNinRepPackedNativeVerboseEqual(t *testing.T) {
 12411  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12412  	p := NewPopulatedNinRepPackedNative(popr, false)
 12413  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12414  	if err != nil {
 12415  		panic(err)
 12416  	}
 12417  	msg := &NinRepPackedNative{}
 12418  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12419  		panic(err)
 12420  	}
 12421  	if err := p.VerboseEqual(msg); err != nil {
 12422  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12423  	}
 12424  }
 12425  func TestNidOptStructVerboseEqual(t *testing.T) {
 12426  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12427  	p := NewPopulatedNidOptStruct(popr, false)
 12428  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12429  	if err != nil {
 12430  		panic(err)
 12431  	}
 12432  	msg := &NidOptStruct{}
 12433  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12434  		panic(err)
 12435  	}
 12436  	if err := p.VerboseEqual(msg); err != nil {
 12437  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12438  	}
 12439  }
 12440  func TestNinOptStructVerboseEqual(t *testing.T) {
 12441  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12442  	p := NewPopulatedNinOptStruct(popr, false)
 12443  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12444  	if err != nil {
 12445  		panic(err)
 12446  	}
 12447  	msg := &NinOptStruct{}
 12448  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12449  		panic(err)
 12450  	}
 12451  	if err := p.VerboseEqual(msg); err != nil {
 12452  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12453  	}
 12454  }
 12455  func TestNidRepStructVerboseEqual(t *testing.T) {
 12456  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12457  	p := NewPopulatedNidRepStruct(popr, false)
 12458  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12459  	if err != nil {
 12460  		panic(err)
 12461  	}
 12462  	msg := &NidRepStruct{}
 12463  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12464  		panic(err)
 12465  	}
 12466  	if err := p.VerboseEqual(msg); err != nil {
 12467  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12468  	}
 12469  }
 12470  func TestNinRepStructVerboseEqual(t *testing.T) {
 12471  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12472  	p := NewPopulatedNinRepStruct(popr, false)
 12473  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12474  	if err != nil {
 12475  		panic(err)
 12476  	}
 12477  	msg := &NinRepStruct{}
 12478  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12479  		panic(err)
 12480  	}
 12481  	if err := p.VerboseEqual(msg); err != nil {
 12482  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12483  	}
 12484  }
 12485  func TestNidEmbeddedStructVerboseEqual(t *testing.T) {
 12486  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12487  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 12488  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12489  	if err != nil {
 12490  		panic(err)
 12491  	}
 12492  	msg := &NidEmbeddedStruct{}
 12493  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12494  		panic(err)
 12495  	}
 12496  	if err := p.VerboseEqual(msg); err != nil {
 12497  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12498  	}
 12499  }
 12500  func TestNinEmbeddedStructVerboseEqual(t *testing.T) {
 12501  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12502  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 12503  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12504  	if err != nil {
 12505  		panic(err)
 12506  	}
 12507  	msg := &NinEmbeddedStruct{}
 12508  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12509  		panic(err)
 12510  	}
 12511  	if err := p.VerboseEqual(msg); err != nil {
 12512  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12513  	}
 12514  }
 12515  func TestNidNestedStructVerboseEqual(t *testing.T) {
 12516  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12517  	p := NewPopulatedNidNestedStruct(popr, false)
 12518  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12519  	if err != nil {
 12520  		panic(err)
 12521  	}
 12522  	msg := &NidNestedStruct{}
 12523  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12524  		panic(err)
 12525  	}
 12526  	if err := p.VerboseEqual(msg); err != nil {
 12527  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12528  	}
 12529  }
 12530  func TestNinNestedStructVerboseEqual(t *testing.T) {
 12531  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12532  	p := NewPopulatedNinNestedStruct(popr, false)
 12533  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12534  	if err != nil {
 12535  		panic(err)
 12536  	}
 12537  	msg := &NinNestedStruct{}
 12538  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12539  		panic(err)
 12540  	}
 12541  	if err := p.VerboseEqual(msg); err != nil {
 12542  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12543  	}
 12544  }
 12545  func TestNidOptCustomVerboseEqual(t *testing.T) {
 12546  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12547  	p := NewPopulatedNidOptCustom(popr, false)
 12548  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12549  	if err != nil {
 12550  		panic(err)
 12551  	}
 12552  	msg := &NidOptCustom{}
 12553  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12554  		panic(err)
 12555  	}
 12556  	if err := p.VerboseEqual(msg); err != nil {
 12557  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12558  	}
 12559  }
 12560  func TestCustomDashVerboseEqual(t *testing.T) {
 12561  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12562  	p := NewPopulatedCustomDash(popr, false)
 12563  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12564  	if err != nil {
 12565  		panic(err)
 12566  	}
 12567  	msg := &CustomDash{}
 12568  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12569  		panic(err)
 12570  	}
 12571  	if err := p.VerboseEqual(msg); err != nil {
 12572  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12573  	}
 12574  }
 12575  func TestNinOptCustomVerboseEqual(t *testing.T) {
 12576  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12577  	p := NewPopulatedNinOptCustom(popr, false)
 12578  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12579  	if err != nil {
 12580  		panic(err)
 12581  	}
 12582  	msg := &NinOptCustom{}
 12583  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12584  		panic(err)
 12585  	}
 12586  	if err := p.VerboseEqual(msg); err != nil {
 12587  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12588  	}
 12589  }
 12590  func TestNidRepCustomVerboseEqual(t *testing.T) {
 12591  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12592  	p := NewPopulatedNidRepCustom(popr, false)
 12593  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12594  	if err != nil {
 12595  		panic(err)
 12596  	}
 12597  	msg := &NidRepCustom{}
 12598  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12599  		panic(err)
 12600  	}
 12601  	if err := p.VerboseEqual(msg); err != nil {
 12602  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12603  	}
 12604  }
 12605  func TestNinRepCustomVerboseEqual(t *testing.T) {
 12606  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12607  	p := NewPopulatedNinRepCustom(popr, false)
 12608  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12609  	if err != nil {
 12610  		panic(err)
 12611  	}
 12612  	msg := &NinRepCustom{}
 12613  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12614  		panic(err)
 12615  	}
 12616  	if err := p.VerboseEqual(msg); err != nil {
 12617  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12618  	}
 12619  }
 12620  func TestNinOptNativeUnionVerboseEqual(t *testing.T) {
 12621  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12622  	p := NewPopulatedNinOptNativeUnion(popr, false)
 12623  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12624  	if err != nil {
 12625  		panic(err)
 12626  	}
 12627  	msg := &NinOptNativeUnion{}
 12628  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12629  		panic(err)
 12630  	}
 12631  	if err := p.VerboseEqual(msg); err != nil {
 12632  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12633  	}
 12634  }
 12635  func TestNinOptStructUnionVerboseEqual(t *testing.T) {
 12636  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12637  	p := NewPopulatedNinOptStructUnion(popr, false)
 12638  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12639  	if err != nil {
 12640  		panic(err)
 12641  	}
 12642  	msg := &NinOptStructUnion{}
 12643  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12644  		panic(err)
 12645  	}
 12646  	if err := p.VerboseEqual(msg); err != nil {
 12647  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12648  	}
 12649  }
 12650  func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
 12651  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12652  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 12653  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12654  	if err != nil {
 12655  		panic(err)
 12656  	}
 12657  	msg := &NinEmbeddedStructUnion{}
 12658  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12659  		panic(err)
 12660  	}
 12661  	if err := p.VerboseEqual(msg); err != nil {
 12662  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12663  	}
 12664  }
 12665  func TestNinNestedStructUnionVerboseEqual(t *testing.T) {
 12666  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12667  	p := NewPopulatedNinNestedStructUnion(popr, false)
 12668  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12669  	if err != nil {
 12670  		panic(err)
 12671  	}
 12672  	msg := &NinNestedStructUnion{}
 12673  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12674  		panic(err)
 12675  	}
 12676  	if err := p.VerboseEqual(msg); err != nil {
 12677  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12678  	}
 12679  }
 12680  func TestTreeVerboseEqual(t *testing.T) {
 12681  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12682  	p := NewPopulatedTree(popr, false)
 12683  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12684  	if err != nil {
 12685  		panic(err)
 12686  	}
 12687  	msg := &Tree{}
 12688  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12689  		panic(err)
 12690  	}
 12691  	if err := p.VerboseEqual(msg); err != nil {
 12692  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12693  	}
 12694  }
 12695  func TestOrBranchVerboseEqual(t *testing.T) {
 12696  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12697  	p := NewPopulatedOrBranch(popr, false)
 12698  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12699  	if err != nil {
 12700  		panic(err)
 12701  	}
 12702  	msg := &OrBranch{}
 12703  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12704  		panic(err)
 12705  	}
 12706  	if err := p.VerboseEqual(msg); err != nil {
 12707  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12708  	}
 12709  }
 12710  func TestAndBranchVerboseEqual(t *testing.T) {
 12711  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12712  	p := NewPopulatedAndBranch(popr, false)
 12713  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12714  	if err != nil {
 12715  		panic(err)
 12716  	}
 12717  	msg := &AndBranch{}
 12718  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12719  		panic(err)
 12720  	}
 12721  	if err := p.VerboseEqual(msg); err != nil {
 12722  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12723  	}
 12724  }
 12725  func TestLeafVerboseEqual(t *testing.T) {
 12726  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12727  	p := NewPopulatedLeaf(popr, false)
 12728  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12729  	if err != nil {
 12730  		panic(err)
 12731  	}
 12732  	msg := &Leaf{}
 12733  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12734  		panic(err)
 12735  	}
 12736  	if err := p.VerboseEqual(msg); err != nil {
 12737  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12738  	}
 12739  }
 12740  func TestDeepTreeVerboseEqual(t *testing.T) {
 12741  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12742  	p := NewPopulatedDeepTree(popr, false)
 12743  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12744  	if err != nil {
 12745  		panic(err)
 12746  	}
 12747  	msg := &DeepTree{}
 12748  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12749  		panic(err)
 12750  	}
 12751  	if err := p.VerboseEqual(msg); err != nil {
 12752  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12753  	}
 12754  }
 12755  func TestADeepBranchVerboseEqual(t *testing.T) {
 12756  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12757  	p := NewPopulatedADeepBranch(popr, false)
 12758  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12759  	if err != nil {
 12760  		panic(err)
 12761  	}
 12762  	msg := &ADeepBranch{}
 12763  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12764  		panic(err)
 12765  	}
 12766  	if err := p.VerboseEqual(msg); err != nil {
 12767  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12768  	}
 12769  }
 12770  func TestAndDeepBranchVerboseEqual(t *testing.T) {
 12771  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12772  	p := NewPopulatedAndDeepBranch(popr, false)
 12773  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12774  	if err != nil {
 12775  		panic(err)
 12776  	}
 12777  	msg := &AndDeepBranch{}
 12778  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12779  		panic(err)
 12780  	}
 12781  	if err := p.VerboseEqual(msg); err != nil {
 12782  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12783  	}
 12784  }
 12785  func TestDeepLeafVerboseEqual(t *testing.T) {
 12786  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12787  	p := NewPopulatedDeepLeaf(popr, false)
 12788  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12789  	if err != nil {
 12790  		panic(err)
 12791  	}
 12792  	msg := &DeepLeaf{}
 12793  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12794  		panic(err)
 12795  	}
 12796  	if err := p.VerboseEqual(msg); err != nil {
 12797  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12798  	}
 12799  }
 12800  func TestNilVerboseEqual(t *testing.T) {
 12801  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12802  	p := NewPopulatedNil(popr, false)
 12803  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12804  	if err != nil {
 12805  		panic(err)
 12806  	}
 12807  	msg := &Nil{}
 12808  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12809  		panic(err)
 12810  	}
 12811  	if err := p.VerboseEqual(msg); err != nil {
 12812  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12813  	}
 12814  }
 12815  func TestNidOptEnumVerboseEqual(t *testing.T) {
 12816  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12817  	p := NewPopulatedNidOptEnum(popr, false)
 12818  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12819  	if err != nil {
 12820  		panic(err)
 12821  	}
 12822  	msg := &NidOptEnum{}
 12823  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12824  		panic(err)
 12825  	}
 12826  	if err := p.VerboseEqual(msg); err != nil {
 12827  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12828  	}
 12829  }
 12830  func TestNinOptEnumVerboseEqual(t *testing.T) {
 12831  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12832  	p := NewPopulatedNinOptEnum(popr, false)
 12833  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12834  	if err != nil {
 12835  		panic(err)
 12836  	}
 12837  	msg := &NinOptEnum{}
 12838  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12839  		panic(err)
 12840  	}
 12841  	if err := p.VerboseEqual(msg); err != nil {
 12842  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12843  	}
 12844  }
 12845  func TestNidRepEnumVerboseEqual(t *testing.T) {
 12846  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12847  	p := NewPopulatedNidRepEnum(popr, false)
 12848  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12849  	if err != nil {
 12850  		panic(err)
 12851  	}
 12852  	msg := &NidRepEnum{}
 12853  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12854  		panic(err)
 12855  	}
 12856  	if err := p.VerboseEqual(msg); err != nil {
 12857  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12858  	}
 12859  }
 12860  func TestNinRepEnumVerboseEqual(t *testing.T) {
 12861  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12862  	p := NewPopulatedNinRepEnum(popr, false)
 12863  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12864  	if err != nil {
 12865  		panic(err)
 12866  	}
 12867  	msg := &NinRepEnum{}
 12868  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12869  		panic(err)
 12870  	}
 12871  	if err := p.VerboseEqual(msg); err != nil {
 12872  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12873  	}
 12874  }
 12875  func TestNinOptEnumDefaultVerboseEqual(t *testing.T) {
 12876  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12877  	p := NewPopulatedNinOptEnumDefault(popr, false)
 12878  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12879  	if err != nil {
 12880  		panic(err)
 12881  	}
 12882  	msg := &NinOptEnumDefault{}
 12883  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12884  		panic(err)
 12885  	}
 12886  	if err := p.VerboseEqual(msg); err != nil {
 12887  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12888  	}
 12889  }
 12890  func TestAnotherNinOptEnumVerboseEqual(t *testing.T) {
 12891  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12892  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 12893  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12894  	if err != nil {
 12895  		panic(err)
 12896  	}
 12897  	msg := &AnotherNinOptEnum{}
 12898  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12899  		panic(err)
 12900  	}
 12901  	if err := p.VerboseEqual(msg); err != nil {
 12902  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12903  	}
 12904  }
 12905  func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) {
 12906  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12907  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 12908  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12909  	if err != nil {
 12910  		panic(err)
 12911  	}
 12912  	msg := &AnotherNinOptEnumDefault{}
 12913  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12914  		panic(err)
 12915  	}
 12916  	if err := p.VerboseEqual(msg); err != nil {
 12917  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12918  	}
 12919  }
 12920  func TestTimerVerboseEqual(t *testing.T) {
 12921  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12922  	p := NewPopulatedTimer(popr, false)
 12923  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12924  	if err != nil {
 12925  		panic(err)
 12926  	}
 12927  	msg := &Timer{}
 12928  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12929  		panic(err)
 12930  	}
 12931  	if err := p.VerboseEqual(msg); err != nil {
 12932  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12933  	}
 12934  }
 12935  func TestMyExtendableVerboseEqual(t *testing.T) {
 12936  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12937  	p := NewPopulatedMyExtendable(popr, false)
 12938  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12939  	if err != nil {
 12940  		panic(err)
 12941  	}
 12942  	msg := &MyExtendable{}
 12943  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12944  		panic(err)
 12945  	}
 12946  	if err := p.VerboseEqual(msg); err != nil {
 12947  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12948  	}
 12949  }
 12950  func TestOtherExtenableVerboseEqual(t *testing.T) {
 12951  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12952  	p := NewPopulatedOtherExtenable(popr, false)
 12953  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12954  	if err != nil {
 12955  		panic(err)
 12956  	}
 12957  	msg := &OtherExtenable{}
 12958  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12959  		panic(err)
 12960  	}
 12961  	if err := p.VerboseEqual(msg); err != nil {
 12962  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12963  	}
 12964  }
 12965  func TestNestedDefinitionVerboseEqual(t *testing.T) {
 12966  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12967  	p := NewPopulatedNestedDefinition(popr, false)
 12968  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12969  	if err != nil {
 12970  		panic(err)
 12971  	}
 12972  	msg := &NestedDefinition{}
 12973  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12974  		panic(err)
 12975  	}
 12976  	if err := p.VerboseEqual(msg); err != nil {
 12977  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12978  	}
 12979  }
 12980  func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) {
 12981  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12982  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 12983  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12984  	if err != nil {
 12985  		panic(err)
 12986  	}
 12987  	msg := &NestedDefinition_NestedMessage{}
 12988  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 12989  		panic(err)
 12990  	}
 12991  	if err := p.VerboseEqual(msg); err != nil {
 12992  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 12993  	}
 12994  }
 12995  func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) {
 12996  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12997  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 12998  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12999  	if err != nil {
 13000  		panic(err)
 13001  	}
 13002  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
 13003  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13004  		panic(err)
 13005  	}
 13006  	if err := p.VerboseEqual(msg); err != nil {
 13007  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13008  	}
 13009  }
 13010  func TestNestedScopeVerboseEqual(t *testing.T) {
 13011  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13012  	p := NewPopulatedNestedScope(popr, false)
 13013  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13014  	if err != nil {
 13015  		panic(err)
 13016  	}
 13017  	msg := &NestedScope{}
 13018  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13019  		panic(err)
 13020  	}
 13021  	if err := p.VerboseEqual(msg); err != nil {
 13022  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13023  	}
 13024  }
 13025  func TestNinOptNativeDefaultVerboseEqual(t *testing.T) {
 13026  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13027  	p := NewPopulatedNinOptNativeDefault(popr, false)
 13028  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13029  	if err != nil {
 13030  		panic(err)
 13031  	}
 13032  	msg := &NinOptNativeDefault{}
 13033  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13034  		panic(err)
 13035  	}
 13036  	if err := p.VerboseEqual(msg); err != nil {
 13037  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13038  	}
 13039  }
 13040  func TestCustomContainerVerboseEqual(t *testing.T) {
 13041  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13042  	p := NewPopulatedCustomContainer(popr, false)
 13043  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13044  	if err != nil {
 13045  		panic(err)
 13046  	}
 13047  	msg := &CustomContainer{}
 13048  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13049  		panic(err)
 13050  	}
 13051  	if err := p.VerboseEqual(msg); err != nil {
 13052  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13053  	}
 13054  }
 13055  func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) {
 13056  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13057  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 13058  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13059  	if err != nil {
 13060  		panic(err)
 13061  	}
 13062  	msg := &CustomNameNidOptNative{}
 13063  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13064  		panic(err)
 13065  	}
 13066  	if err := p.VerboseEqual(msg); err != nil {
 13067  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13068  	}
 13069  }
 13070  func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) {
 13071  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13072  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 13073  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13074  	if err != nil {
 13075  		panic(err)
 13076  	}
 13077  	msg := &CustomNameNinOptNative{}
 13078  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13079  		panic(err)
 13080  	}
 13081  	if err := p.VerboseEqual(msg); err != nil {
 13082  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13083  	}
 13084  }
 13085  func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) {
 13086  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13087  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 13088  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13089  	if err != nil {
 13090  		panic(err)
 13091  	}
 13092  	msg := &CustomNameNinRepNative{}
 13093  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13094  		panic(err)
 13095  	}
 13096  	if err := p.VerboseEqual(msg); err != nil {
 13097  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13098  	}
 13099  }
 13100  func TestCustomNameNinStructVerboseEqual(t *testing.T) {
 13101  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13102  	p := NewPopulatedCustomNameNinStruct(popr, false)
 13103  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13104  	if err != nil {
 13105  		panic(err)
 13106  	}
 13107  	msg := &CustomNameNinStruct{}
 13108  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13109  		panic(err)
 13110  	}
 13111  	if err := p.VerboseEqual(msg); err != nil {
 13112  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13113  	}
 13114  }
 13115  func TestCustomNameCustomTypeVerboseEqual(t *testing.T) {
 13116  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13117  	p := NewPopulatedCustomNameCustomType(popr, false)
 13118  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13119  	if err != nil {
 13120  		panic(err)
 13121  	}
 13122  	msg := &CustomNameCustomType{}
 13123  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13124  		panic(err)
 13125  	}
 13126  	if err := p.VerboseEqual(msg); err != nil {
 13127  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13128  	}
 13129  }
 13130  func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
 13131  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13132  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 13133  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13134  	if err != nil {
 13135  		panic(err)
 13136  	}
 13137  	msg := &CustomNameNinEmbeddedStructUnion{}
 13138  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13139  		panic(err)
 13140  	}
 13141  	if err := p.VerboseEqual(msg); err != nil {
 13142  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13143  	}
 13144  }
 13145  func TestCustomNameEnumVerboseEqual(t *testing.T) {
 13146  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13147  	p := NewPopulatedCustomNameEnum(popr, false)
 13148  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13149  	if err != nil {
 13150  		panic(err)
 13151  	}
 13152  	msg := &CustomNameEnum{}
 13153  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13154  		panic(err)
 13155  	}
 13156  	if err := p.VerboseEqual(msg); err != nil {
 13157  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13158  	}
 13159  }
 13160  func TestNoExtensionsMapVerboseEqual(t *testing.T) {
 13161  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13162  	p := NewPopulatedNoExtensionsMap(popr, false)
 13163  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13164  	if err != nil {
 13165  		panic(err)
 13166  	}
 13167  	msg := &NoExtensionsMap{}
 13168  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13169  		panic(err)
 13170  	}
 13171  	if err := p.VerboseEqual(msg); err != nil {
 13172  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13173  	}
 13174  }
 13175  func TestUnrecognizedVerboseEqual(t *testing.T) {
 13176  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13177  	p := NewPopulatedUnrecognized(popr, false)
 13178  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13179  	if err != nil {
 13180  		panic(err)
 13181  	}
 13182  	msg := &Unrecognized{}
 13183  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13184  		panic(err)
 13185  	}
 13186  	if err := p.VerboseEqual(msg); err != nil {
 13187  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13188  	}
 13189  }
 13190  func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) {
 13191  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13192  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 13193  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13194  	if err != nil {
 13195  		panic(err)
 13196  	}
 13197  	msg := &UnrecognizedWithInner{}
 13198  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13199  		panic(err)
 13200  	}
 13201  	if err := p.VerboseEqual(msg); err != nil {
 13202  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13203  	}
 13204  }
 13205  func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) {
 13206  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13207  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 13208  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13209  	if err != nil {
 13210  		panic(err)
 13211  	}
 13212  	msg := &UnrecognizedWithInner_Inner{}
 13213  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13214  		panic(err)
 13215  	}
 13216  	if err := p.VerboseEqual(msg); err != nil {
 13217  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13218  	}
 13219  }
 13220  func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) {
 13221  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13222  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 13223  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13224  	if err != nil {
 13225  		panic(err)
 13226  	}
 13227  	msg := &UnrecognizedWithEmbed{}
 13228  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13229  		panic(err)
 13230  	}
 13231  	if err := p.VerboseEqual(msg); err != nil {
 13232  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13233  	}
 13234  }
 13235  func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) {
 13236  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13237  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 13238  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13239  	if err != nil {
 13240  		panic(err)
 13241  	}
 13242  	msg := &UnrecognizedWithEmbed_Embedded{}
 13243  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13244  		panic(err)
 13245  	}
 13246  	if err := p.VerboseEqual(msg); err != nil {
 13247  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13248  	}
 13249  }
 13250  func TestNodeVerboseEqual(t *testing.T) {
 13251  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13252  	p := NewPopulatedNode(popr, false)
 13253  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13254  	if err != nil {
 13255  		panic(err)
 13256  	}
 13257  	msg := &Node{}
 13258  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13259  		panic(err)
 13260  	}
 13261  	if err := p.VerboseEqual(msg); err != nil {
 13262  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13263  	}
 13264  }
 13265  func TestNonByteCustomTypeVerboseEqual(t *testing.T) {
 13266  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13267  	p := NewPopulatedNonByteCustomType(popr, false)
 13268  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13269  	if err != nil {
 13270  		panic(err)
 13271  	}
 13272  	msg := &NonByteCustomType{}
 13273  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13274  		panic(err)
 13275  	}
 13276  	if err := p.VerboseEqual(msg); err != nil {
 13277  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13278  	}
 13279  }
 13280  func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) {
 13281  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13282  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 13283  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13284  	if err != nil {
 13285  		panic(err)
 13286  	}
 13287  	msg := &NidOptNonByteCustomType{}
 13288  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13289  		panic(err)
 13290  	}
 13291  	if err := p.VerboseEqual(msg); err != nil {
 13292  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13293  	}
 13294  }
 13295  func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) {
 13296  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13297  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 13298  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13299  	if err != nil {
 13300  		panic(err)
 13301  	}
 13302  	msg := &NinOptNonByteCustomType{}
 13303  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13304  		panic(err)
 13305  	}
 13306  	if err := p.VerboseEqual(msg); err != nil {
 13307  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13308  	}
 13309  }
 13310  func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) {
 13311  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13312  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 13313  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13314  	if err != nil {
 13315  		panic(err)
 13316  	}
 13317  	msg := &NidRepNonByteCustomType{}
 13318  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13319  		panic(err)
 13320  	}
 13321  	if err := p.VerboseEqual(msg); err != nil {
 13322  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13323  	}
 13324  }
 13325  func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) {
 13326  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13327  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 13328  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13329  	if err != nil {
 13330  		panic(err)
 13331  	}
 13332  	msg := &NinRepNonByteCustomType{}
 13333  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13334  		panic(err)
 13335  	}
 13336  	if err := p.VerboseEqual(msg); err != nil {
 13337  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13338  	}
 13339  }
 13340  func TestProtoTypeVerboseEqual(t *testing.T) {
 13341  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13342  	p := NewPopulatedProtoType(popr, false)
 13343  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13344  	if err != nil {
 13345  		panic(err)
 13346  	}
 13347  	msg := &ProtoType{}
 13348  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 13349  		panic(err)
 13350  	}
 13351  	if err := p.VerboseEqual(msg); err != nil {
 13352  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 13353  	}
 13354  }
 13355  func TestNidOptNativeFace(t *testing.T) {
 13356  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13357  	p := NewPopulatedNidOptNative(popr, true)
 13358  	msg := p.TestProto()
 13359  	if !p.Equal(msg) {
 13360  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13361  	}
 13362  }
 13363  func TestNinOptNativeFace(t *testing.T) {
 13364  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13365  	p := NewPopulatedNinOptNative(popr, true)
 13366  	msg := p.TestProto()
 13367  	if !p.Equal(msg) {
 13368  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13369  	}
 13370  }
 13371  func TestNidRepNativeFace(t *testing.T) {
 13372  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13373  	p := NewPopulatedNidRepNative(popr, true)
 13374  	msg := p.TestProto()
 13375  	if !p.Equal(msg) {
 13376  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13377  	}
 13378  }
 13379  func TestNinRepNativeFace(t *testing.T) {
 13380  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13381  	p := NewPopulatedNinRepNative(popr, true)
 13382  	msg := p.TestProto()
 13383  	if !p.Equal(msg) {
 13384  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13385  	}
 13386  }
 13387  func TestNidRepPackedNativeFace(t *testing.T) {
 13388  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13389  	p := NewPopulatedNidRepPackedNative(popr, true)
 13390  	msg := p.TestProto()
 13391  	if !p.Equal(msg) {
 13392  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13393  	}
 13394  }
 13395  func TestNinRepPackedNativeFace(t *testing.T) {
 13396  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13397  	p := NewPopulatedNinRepPackedNative(popr, true)
 13398  	msg := p.TestProto()
 13399  	if !p.Equal(msg) {
 13400  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13401  	}
 13402  }
 13403  func TestNidOptStructFace(t *testing.T) {
 13404  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13405  	p := NewPopulatedNidOptStruct(popr, true)
 13406  	msg := p.TestProto()
 13407  	if !p.Equal(msg) {
 13408  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13409  	}
 13410  }
 13411  func TestNinOptStructFace(t *testing.T) {
 13412  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13413  	p := NewPopulatedNinOptStruct(popr, true)
 13414  	msg := p.TestProto()
 13415  	if !p.Equal(msg) {
 13416  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13417  	}
 13418  }
 13419  func TestNidRepStructFace(t *testing.T) {
 13420  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13421  	p := NewPopulatedNidRepStruct(popr, true)
 13422  	msg := p.TestProto()
 13423  	if !p.Equal(msg) {
 13424  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13425  	}
 13426  }
 13427  func TestNinRepStructFace(t *testing.T) {
 13428  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13429  	p := NewPopulatedNinRepStruct(popr, true)
 13430  	msg := p.TestProto()
 13431  	if !p.Equal(msg) {
 13432  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13433  	}
 13434  }
 13435  func TestNidEmbeddedStructFace(t *testing.T) {
 13436  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13437  	p := NewPopulatedNidEmbeddedStruct(popr, true)
 13438  	msg := p.TestProto()
 13439  	if !p.Equal(msg) {
 13440  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13441  	}
 13442  }
 13443  func TestNinEmbeddedStructFace(t *testing.T) {
 13444  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13445  	p := NewPopulatedNinEmbeddedStruct(popr, true)
 13446  	msg := p.TestProto()
 13447  	if !p.Equal(msg) {
 13448  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13449  	}
 13450  }
 13451  func TestNidNestedStructFace(t *testing.T) {
 13452  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13453  	p := NewPopulatedNidNestedStruct(popr, true)
 13454  	msg := p.TestProto()
 13455  	if !p.Equal(msg) {
 13456  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13457  	}
 13458  }
 13459  func TestNinNestedStructFace(t *testing.T) {
 13460  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13461  	p := NewPopulatedNinNestedStruct(popr, true)
 13462  	msg := p.TestProto()
 13463  	if !p.Equal(msg) {
 13464  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13465  	}
 13466  }
 13467  func TestNidOptCustomFace(t *testing.T) {
 13468  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13469  	p := NewPopulatedNidOptCustom(popr, true)
 13470  	msg := p.TestProto()
 13471  	if !p.Equal(msg) {
 13472  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13473  	}
 13474  }
 13475  func TestCustomDashFace(t *testing.T) {
 13476  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13477  	p := NewPopulatedCustomDash(popr, true)
 13478  	msg := p.TestProto()
 13479  	if !p.Equal(msg) {
 13480  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13481  	}
 13482  }
 13483  func TestNinOptCustomFace(t *testing.T) {
 13484  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13485  	p := NewPopulatedNinOptCustom(popr, true)
 13486  	msg := p.TestProto()
 13487  	if !p.Equal(msg) {
 13488  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13489  	}
 13490  }
 13491  func TestNidRepCustomFace(t *testing.T) {
 13492  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13493  	p := NewPopulatedNidRepCustom(popr, true)
 13494  	msg := p.TestProto()
 13495  	if !p.Equal(msg) {
 13496  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13497  	}
 13498  }
 13499  func TestNinRepCustomFace(t *testing.T) {
 13500  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13501  	p := NewPopulatedNinRepCustom(popr, true)
 13502  	msg := p.TestProto()
 13503  	if !p.Equal(msg) {
 13504  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13505  	}
 13506  }
 13507  func TestNinOptNativeUnionFace(t *testing.T) {
 13508  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13509  	p := NewPopulatedNinOptNativeUnion(popr, true)
 13510  	msg := p.TestProto()
 13511  	if !p.Equal(msg) {
 13512  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13513  	}
 13514  }
 13515  func TestNinOptStructUnionFace(t *testing.T) {
 13516  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13517  	p := NewPopulatedNinOptStructUnion(popr, true)
 13518  	msg := p.TestProto()
 13519  	if !p.Equal(msg) {
 13520  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13521  	}
 13522  }
 13523  func TestNinEmbeddedStructUnionFace(t *testing.T) {
 13524  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13525  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 13526  	msg := p.TestProto()
 13527  	if !p.Equal(msg) {
 13528  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13529  	}
 13530  }
 13531  func TestNinNestedStructUnionFace(t *testing.T) {
 13532  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13533  	p := NewPopulatedNinNestedStructUnion(popr, true)
 13534  	msg := p.TestProto()
 13535  	if !p.Equal(msg) {
 13536  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13537  	}
 13538  }
 13539  func TestTreeFace(t *testing.T) {
 13540  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13541  	p := NewPopulatedTree(popr, true)
 13542  	msg := p.TestProto()
 13543  	if !p.Equal(msg) {
 13544  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13545  	}
 13546  }
 13547  func TestOrBranchFace(t *testing.T) {
 13548  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13549  	p := NewPopulatedOrBranch(popr, true)
 13550  	msg := p.TestProto()
 13551  	if !p.Equal(msg) {
 13552  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13553  	}
 13554  }
 13555  func TestAndBranchFace(t *testing.T) {
 13556  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13557  	p := NewPopulatedAndBranch(popr, true)
 13558  	msg := p.TestProto()
 13559  	if !p.Equal(msg) {
 13560  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13561  	}
 13562  }
 13563  func TestLeafFace(t *testing.T) {
 13564  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13565  	p := NewPopulatedLeaf(popr, true)
 13566  	msg := p.TestProto()
 13567  	if !p.Equal(msg) {
 13568  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13569  	}
 13570  }
 13571  func TestDeepTreeFace(t *testing.T) {
 13572  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13573  	p := NewPopulatedDeepTree(popr, true)
 13574  	msg := p.TestProto()
 13575  	if !p.Equal(msg) {
 13576  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13577  	}
 13578  }
 13579  func TestADeepBranchFace(t *testing.T) {
 13580  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13581  	p := NewPopulatedADeepBranch(popr, true)
 13582  	msg := p.TestProto()
 13583  	if !p.Equal(msg) {
 13584  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13585  	}
 13586  }
 13587  func TestAndDeepBranchFace(t *testing.T) {
 13588  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13589  	p := NewPopulatedAndDeepBranch(popr, true)
 13590  	msg := p.TestProto()
 13591  	if !p.Equal(msg) {
 13592  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13593  	}
 13594  }
 13595  func TestDeepLeafFace(t *testing.T) {
 13596  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13597  	p := NewPopulatedDeepLeaf(popr, true)
 13598  	msg := p.TestProto()
 13599  	if !p.Equal(msg) {
 13600  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13601  	}
 13602  }
 13603  func TestNilFace(t *testing.T) {
 13604  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13605  	p := NewPopulatedNil(popr, true)
 13606  	msg := p.TestProto()
 13607  	if !p.Equal(msg) {
 13608  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13609  	}
 13610  }
 13611  func TestNidOptEnumFace(t *testing.T) {
 13612  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13613  	p := NewPopulatedNidOptEnum(popr, true)
 13614  	msg := p.TestProto()
 13615  	if !p.Equal(msg) {
 13616  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13617  	}
 13618  }
 13619  func TestNinOptEnumFace(t *testing.T) {
 13620  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13621  	p := NewPopulatedNinOptEnum(popr, true)
 13622  	msg := p.TestProto()
 13623  	if !p.Equal(msg) {
 13624  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13625  	}
 13626  }
 13627  func TestNidRepEnumFace(t *testing.T) {
 13628  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13629  	p := NewPopulatedNidRepEnum(popr, true)
 13630  	msg := p.TestProto()
 13631  	if !p.Equal(msg) {
 13632  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13633  	}
 13634  }
 13635  func TestNinRepEnumFace(t *testing.T) {
 13636  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13637  	p := NewPopulatedNinRepEnum(popr, true)
 13638  	msg := p.TestProto()
 13639  	if !p.Equal(msg) {
 13640  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13641  	}
 13642  }
 13643  func TestAnotherNinOptEnumFace(t *testing.T) {
 13644  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13645  	p := NewPopulatedAnotherNinOptEnum(popr, true)
 13646  	msg := p.TestProto()
 13647  	if !p.Equal(msg) {
 13648  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13649  	}
 13650  }
 13651  func TestTimerFace(t *testing.T) {
 13652  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13653  	p := NewPopulatedTimer(popr, true)
 13654  	msg := p.TestProto()
 13655  	if !p.Equal(msg) {
 13656  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13657  	}
 13658  }
 13659  func TestNestedDefinitionFace(t *testing.T) {
 13660  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13661  	p := NewPopulatedNestedDefinition(popr, true)
 13662  	msg := p.TestProto()
 13663  	if !p.Equal(msg) {
 13664  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13665  	}
 13666  }
 13667  func TestNestedDefinition_NestedMessageFace(t *testing.T) {
 13668  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13669  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
 13670  	msg := p.TestProto()
 13671  	if !p.Equal(msg) {
 13672  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13673  	}
 13674  }
 13675  func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) {
 13676  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13677  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
 13678  	msg := p.TestProto()
 13679  	if !p.Equal(msg) {
 13680  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13681  	}
 13682  }
 13683  func TestNestedScopeFace(t *testing.T) {
 13684  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13685  	p := NewPopulatedNestedScope(popr, true)
 13686  	msg := p.TestProto()
 13687  	if !p.Equal(msg) {
 13688  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13689  	}
 13690  }
 13691  func TestCustomContainerFace(t *testing.T) {
 13692  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13693  	p := NewPopulatedCustomContainer(popr, true)
 13694  	msg := p.TestProto()
 13695  	if !p.Equal(msg) {
 13696  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13697  	}
 13698  }
 13699  func TestCustomNameNidOptNativeFace(t *testing.T) {
 13700  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13701  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 13702  	msg := p.TestProto()
 13703  	if !p.Equal(msg) {
 13704  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13705  	}
 13706  }
 13707  func TestCustomNameNinOptNativeFace(t *testing.T) {
 13708  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13709  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 13710  	msg := p.TestProto()
 13711  	if !p.Equal(msg) {
 13712  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13713  	}
 13714  }
 13715  func TestCustomNameNinRepNativeFace(t *testing.T) {
 13716  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13717  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 13718  	msg := p.TestProto()
 13719  	if !p.Equal(msg) {
 13720  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13721  	}
 13722  }
 13723  func TestCustomNameNinStructFace(t *testing.T) {
 13724  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13725  	p := NewPopulatedCustomNameNinStruct(popr, true)
 13726  	msg := p.TestProto()
 13727  	if !p.Equal(msg) {
 13728  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13729  	}
 13730  }
 13731  func TestCustomNameCustomTypeFace(t *testing.T) {
 13732  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13733  	p := NewPopulatedCustomNameCustomType(popr, true)
 13734  	msg := p.TestProto()
 13735  	if !p.Equal(msg) {
 13736  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13737  	}
 13738  }
 13739  func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) {
 13740  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13741  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 13742  	msg := p.TestProto()
 13743  	if !p.Equal(msg) {
 13744  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13745  	}
 13746  }
 13747  func TestCustomNameEnumFace(t *testing.T) {
 13748  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13749  	p := NewPopulatedCustomNameEnum(popr, true)
 13750  	msg := p.TestProto()
 13751  	if !p.Equal(msg) {
 13752  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13753  	}
 13754  }
 13755  func TestUnrecognizedFace(t *testing.T) {
 13756  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13757  	p := NewPopulatedUnrecognized(popr, true)
 13758  	msg := p.TestProto()
 13759  	if !p.Equal(msg) {
 13760  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13761  	}
 13762  }
 13763  func TestUnrecognizedWithInnerFace(t *testing.T) {
 13764  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13765  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 13766  	msg := p.TestProto()
 13767  	if !p.Equal(msg) {
 13768  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13769  	}
 13770  }
 13771  func TestUnrecognizedWithInner_InnerFace(t *testing.T) {
 13772  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13773  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 13774  	msg := p.TestProto()
 13775  	if !p.Equal(msg) {
 13776  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13777  	}
 13778  }
 13779  func TestUnrecognizedWithEmbedFace(t *testing.T) {
 13780  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13781  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 13782  	msg := p.TestProto()
 13783  	if !p.Equal(msg) {
 13784  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13785  	}
 13786  }
 13787  func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) {
 13788  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13789  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 13790  	msg := p.TestProto()
 13791  	if !p.Equal(msg) {
 13792  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13793  	}
 13794  }
 13795  func TestNodeFace(t *testing.T) {
 13796  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13797  	p := NewPopulatedNode(popr, true)
 13798  	msg := p.TestProto()
 13799  	if !p.Equal(msg) {
 13800  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13801  	}
 13802  }
 13803  func TestNonByteCustomTypeFace(t *testing.T) {
 13804  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13805  	p := NewPopulatedNonByteCustomType(popr, true)
 13806  	msg := p.TestProto()
 13807  	if !p.Equal(msg) {
 13808  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13809  	}
 13810  }
 13811  func TestNidOptNonByteCustomTypeFace(t *testing.T) {
 13812  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13813  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 13814  	msg := p.TestProto()
 13815  	if !p.Equal(msg) {
 13816  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13817  	}
 13818  }
 13819  func TestNinOptNonByteCustomTypeFace(t *testing.T) {
 13820  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13821  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 13822  	msg := p.TestProto()
 13823  	if !p.Equal(msg) {
 13824  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13825  	}
 13826  }
 13827  func TestNidRepNonByteCustomTypeFace(t *testing.T) {
 13828  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13829  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 13830  	msg := p.TestProto()
 13831  	if !p.Equal(msg) {
 13832  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13833  	}
 13834  }
 13835  func TestNinRepNonByteCustomTypeFace(t *testing.T) {
 13836  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13837  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 13838  	msg := p.TestProto()
 13839  	if !p.Equal(msg) {
 13840  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13841  	}
 13842  }
 13843  func TestProtoTypeFace(t *testing.T) {
 13844  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13845  	p := NewPopulatedProtoType(popr, true)
 13846  	msg := p.TestProto()
 13847  	if !p.Equal(msg) {
 13848  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 13849  	}
 13850  }
 13851  func TestNidOptNativeGoString(t *testing.T) {
 13852  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13853  	p := NewPopulatedNidOptNative(popr, false)
 13854  	s1 := p.GoString()
 13855  	s2 := fmt.Sprintf("%#v", p)
 13856  	if s1 != s2 {
 13857  		t.Fatalf("GoString want %v got %v", s1, s2)
 13858  	}
 13859  	_, err := go_parser.ParseExpr(s1)
 13860  	if err != nil {
 13861  		t.Fatal(err)
 13862  	}
 13863  }
 13864  func TestNinOptNativeGoString(t *testing.T) {
 13865  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13866  	p := NewPopulatedNinOptNative(popr, false)
 13867  	s1 := p.GoString()
 13868  	s2 := fmt.Sprintf("%#v", p)
 13869  	if s1 != s2 {
 13870  		t.Fatalf("GoString want %v got %v", s1, s2)
 13871  	}
 13872  	_, err := go_parser.ParseExpr(s1)
 13873  	if err != nil {
 13874  		t.Fatal(err)
 13875  	}
 13876  }
 13877  func TestNidRepNativeGoString(t *testing.T) {
 13878  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13879  	p := NewPopulatedNidRepNative(popr, false)
 13880  	s1 := p.GoString()
 13881  	s2 := fmt.Sprintf("%#v", p)
 13882  	if s1 != s2 {
 13883  		t.Fatalf("GoString want %v got %v", s1, s2)
 13884  	}
 13885  	_, err := go_parser.ParseExpr(s1)
 13886  	if err != nil {
 13887  		t.Fatal(err)
 13888  	}
 13889  }
 13890  func TestNinRepNativeGoString(t *testing.T) {
 13891  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13892  	p := NewPopulatedNinRepNative(popr, false)
 13893  	s1 := p.GoString()
 13894  	s2 := fmt.Sprintf("%#v", p)
 13895  	if s1 != s2 {
 13896  		t.Fatalf("GoString want %v got %v", s1, s2)
 13897  	}
 13898  	_, err := go_parser.ParseExpr(s1)
 13899  	if err != nil {
 13900  		t.Fatal(err)
 13901  	}
 13902  }
 13903  func TestNidRepPackedNativeGoString(t *testing.T) {
 13904  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13905  	p := NewPopulatedNidRepPackedNative(popr, false)
 13906  	s1 := p.GoString()
 13907  	s2 := fmt.Sprintf("%#v", p)
 13908  	if s1 != s2 {
 13909  		t.Fatalf("GoString want %v got %v", s1, s2)
 13910  	}
 13911  	_, err := go_parser.ParseExpr(s1)
 13912  	if err != nil {
 13913  		t.Fatal(err)
 13914  	}
 13915  }
 13916  func TestNinRepPackedNativeGoString(t *testing.T) {
 13917  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13918  	p := NewPopulatedNinRepPackedNative(popr, false)
 13919  	s1 := p.GoString()
 13920  	s2 := fmt.Sprintf("%#v", p)
 13921  	if s1 != s2 {
 13922  		t.Fatalf("GoString want %v got %v", s1, s2)
 13923  	}
 13924  	_, err := go_parser.ParseExpr(s1)
 13925  	if err != nil {
 13926  		t.Fatal(err)
 13927  	}
 13928  }
 13929  func TestNidOptStructGoString(t *testing.T) {
 13930  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13931  	p := NewPopulatedNidOptStruct(popr, false)
 13932  	s1 := p.GoString()
 13933  	s2 := fmt.Sprintf("%#v", p)
 13934  	if s1 != s2 {
 13935  		t.Fatalf("GoString want %v got %v", s1, s2)
 13936  	}
 13937  	_, err := go_parser.ParseExpr(s1)
 13938  	if err != nil {
 13939  		t.Fatal(err)
 13940  	}
 13941  }
 13942  func TestNinOptStructGoString(t *testing.T) {
 13943  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13944  	p := NewPopulatedNinOptStruct(popr, false)
 13945  	s1 := p.GoString()
 13946  	s2 := fmt.Sprintf("%#v", p)
 13947  	if s1 != s2 {
 13948  		t.Fatalf("GoString want %v got %v", s1, s2)
 13949  	}
 13950  	_, err := go_parser.ParseExpr(s1)
 13951  	if err != nil {
 13952  		t.Fatal(err)
 13953  	}
 13954  }
 13955  func TestNidRepStructGoString(t *testing.T) {
 13956  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13957  	p := NewPopulatedNidRepStruct(popr, false)
 13958  	s1 := p.GoString()
 13959  	s2 := fmt.Sprintf("%#v", p)
 13960  	if s1 != s2 {
 13961  		t.Fatalf("GoString want %v got %v", s1, s2)
 13962  	}
 13963  	_, err := go_parser.ParseExpr(s1)
 13964  	if err != nil {
 13965  		t.Fatal(err)
 13966  	}
 13967  }
 13968  func TestNinRepStructGoString(t *testing.T) {
 13969  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13970  	p := NewPopulatedNinRepStruct(popr, false)
 13971  	s1 := p.GoString()
 13972  	s2 := fmt.Sprintf("%#v", p)
 13973  	if s1 != s2 {
 13974  		t.Fatalf("GoString want %v got %v", s1, s2)
 13975  	}
 13976  	_, err := go_parser.ParseExpr(s1)
 13977  	if err != nil {
 13978  		t.Fatal(err)
 13979  	}
 13980  }
 13981  func TestNidEmbeddedStructGoString(t *testing.T) {
 13982  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13983  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 13984  	s1 := p.GoString()
 13985  	s2 := fmt.Sprintf("%#v", p)
 13986  	if s1 != s2 {
 13987  		t.Fatalf("GoString want %v got %v", s1, s2)
 13988  	}
 13989  	_, err := go_parser.ParseExpr(s1)
 13990  	if err != nil {
 13991  		t.Fatal(err)
 13992  	}
 13993  }
 13994  func TestNinEmbeddedStructGoString(t *testing.T) {
 13995  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 13996  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 13997  	s1 := p.GoString()
 13998  	s2 := fmt.Sprintf("%#v", p)
 13999  	if s1 != s2 {
 14000  		t.Fatalf("GoString want %v got %v", s1, s2)
 14001  	}
 14002  	_, err := go_parser.ParseExpr(s1)
 14003  	if err != nil {
 14004  		t.Fatal(err)
 14005  	}
 14006  }
 14007  func TestNidNestedStructGoString(t *testing.T) {
 14008  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14009  	p := NewPopulatedNidNestedStruct(popr, false)
 14010  	s1 := p.GoString()
 14011  	s2 := fmt.Sprintf("%#v", p)
 14012  	if s1 != s2 {
 14013  		t.Fatalf("GoString want %v got %v", s1, s2)
 14014  	}
 14015  	_, err := go_parser.ParseExpr(s1)
 14016  	if err != nil {
 14017  		t.Fatal(err)
 14018  	}
 14019  }
 14020  func TestNinNestedStructGoString(t *testing.T) {
 14021  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14022  	p := NewPopulatedNinNestedStruct(popr, false)
 14023  	s1 := p.GoString()
 14024  	s2 := fmt.Sprintf("%#v", p)
 14025  	if s1 != s2 {
 14026  		t.Fatalf("GoString want %v got %v", s1, s2)
 14027  	}
 14028  	_, err := go_parser.ParseExpr(s1)
 14029  	if err != nil {
 14030  		t.Fatal(err)
 14031  	}
 14032  }
 14033  func TestNidOptCustomGoString(t *testing.T) {
 14034  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14035  	p := NewPopulatedNidOptCustom(popr, false)
 14036  	s1 := p.GoString()
 14037  	s2 := fmt.Sprintf("%#v", p)
 14038  	if s1 != s2 {
 14039  		t.Fatalf("GoString want %v got %v", s1, s2)
 14040  	}
 14041  	_, err := go_parser.ParseExpr(s1)
 14042  	if err != nil {
 14043  		t.Fatal(err)
 14044  	}
 14045  }
 14046  func TestCustomDashGoString(t *testing.T) {
 14047  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14048  	p := NewPopulatedCustomDash(popr, false)
 14049  	s1 := p.GoString()
 14050  	s2 := fmt.Sprintf("%#v", p)
 14051  	if s1 != s2 {
 14052  		t.Fatalf("GoString want %v got %v", s1, s2)
 14053  	}
 14054  	_, err := go_parser.ParseExpr(s1)
 14055  	if err != nil {
 14056  		t.Fatal(err)
 14057  	}
 14058  }
 14059  func TestNinOptCustomGoString(t *testing.T) {
 14060  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14061  	p := NewPopulatedNinOptCustom(popr, false)
 14062  	s1 := p.GoString()
 14063  	s2 := fmt.Sprintf("%#v", p)
 14064  	if s1 != s2 {
 14065  		t.Fatalf("GoString want %v got %v", s1, s2)
 14066  	}
 14067  	_, err := go_parser.ParseExpr(s1)
 14068  	if err != nil {
 14069  		t.Fatal(err)
 14070  	}
 14071  }
 14072  func TestNidRepCustomGoString(t *testing.T) {
 14073  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14074  	p := NewPopulatedNidRepCustom(popr, false)
 14075  	s1 := p.GoString()
 14076  	s2 := fmt.Sprintf("%#v", p)
 14077  	if s1 != s2 {
 14078  		t.Fatalf("GoString want %v got %v", s1, s2)
 14079  	}
 14080  	_, err := go_parser.ParseExpr(s1)
 14081  	if err != nil {
 14082  		t.Fatal(err)
 14083  	}
 14084  }
 14085  func TestNinRepCustomGoString(t *testing.T) {
 14086  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14087  	p := NewPopulatedNinRepCustom(popr, false)
 14088  	s1 := p.GoString()
 14089  	s2 := fmt.Sprintf("%#v", p)
 14090  	if s1 != s2 {
 14091  		t.Fatalf("GoString want %v got %v", s1, s2)
 14092  	}
 14093  	_, err := go_parser.ParseExpr(s1)
 14094  	if err != nil {
 14095  		t.Fatal(err)
 14096  	}
 14097  }
 14098  func TestNinOptNativeUnionGoString(t *testing.T) {
 14099  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14100  	p := NewPopulatedNinOptNativeUnion(popr, false)
 14101  	s1 := p.GoString()
 14102  	s2 := fmt.Sprintf("%#v", p)
 14103  	if s1 != s2 {
 14104  		t.Fatalf("GoString want %v got %v", s1, s2)
 14105  	}
 14106  	_, err := go_parser.ParseExpr(s1)
 14107  	if err != nil {
 14108  		t.Fatal(err)
 14109  	}
 14110  }
 14111  func TestNinOptStructUnionGoString(t *testing.T) {
 14112  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14113  	p := NewPopulatedNinOptStructUnion(popr, false)
 14114  	s1 := p.GoString()
 14115  	s2 := fmt.Sprintf("%#v", p)
 14116  	if s1 != s2 {
 14117  		t.Fatalf("GoString want %v got %v", s1, s2)
 14118  	}
 14119  	_, err := go_parser.ParseExpr(s1)
 14120  	if err != nil {
 14121  		t.Fatal(err)
 14122  	}
 14123  }
 14124  func TestNinEmbeddedStructUnionGoString(t *testing.T) {
 14125  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14126  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 14127  	s1 := p.GoString()
 14128  	s2 := fmt.Sprintf("%#v", p)
 14129  	if s1 != s2 {
 14130  		t.Fatalf("GoString want %v got %v", s1, s2)
 14131  	}
 14132  	_, err := go_parser.ParseExpr(s1)
 14133  	if err != nil {
 14134  		t.Fatal(err)
 14135  	}
 14136  }
 14137  func TestNinNestedStructUnionGoString(t *testing.T) {
 14138  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14139  	p := NewPopulatedNinNestedStructUnion(popr, false)
 14140  	s1 := p.GoString()
 14141  	s2 := fmt.Sprintf("%#v", p)
 14142  	if s1 != s2 {
 14143  		t.Fatalf("GoString want %v got %v", s1, s2)
 14144  	}
 14145  	_, err := go_parser.ParseExpr(s1)
 14146  	if err != nil {
 14147  		t.Fatal(err)
 14148  	}
 14149  }
 14150  func TestTreeGoString(t *testing.T) {
 14151  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14152  	p := NewPopulatedTree(popr, false)
 14153  	s1 := p.GoString()
 14154  	s2 := fmt.Sprintf("%#v", p)
 14155  	if s1 != s2 {
 14156  		t.Fatalf("GoString want %v got %v", s1, s2)
 14157  	}
 14158  	_, err := go_parser.ParseExpr(s1)
 14159  	if err != nil {
 14160  		t.Fatal(err)
 14161  	}
 14162  }
 14163  func TestOrBranchGoString(t *testing.T) {
 14164  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14165  	p := NewPopulatedOrBranch(popr, false)
 14166  	s1 := p.GoString()
 14167  	s2 := fmt.Sprintf("%#v", p)
 14168  	if s1 != s2 {
 14169  		t.Fatalf("GoString want %v got %v", s1, s2)
 14170  	}
 14171  	_, err := go_parser.ParseExpr(s1)
 14172  	if err != nil {
 14173  		t.Fatal(err)
 14174  	}
 14175  }
 14176  func TestAndBranchGoString(t *testing.T) {
 14177  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14178  	p := NewPopulatedAndBranch(popr, false)
 14179  	s1 := p.GoString()
 14180  	s2 := fmt.Sprintf("%#v", p)
 14181  	if s1 != s2 {
 14182  		t.Fatalf("GoString want %v got %v", s1, s2)
 14183  	}
 14184  	_, err := go_parser.ParseExpr(s1)
 14185  	if err != nil {
 14186  		t.Fatal(err)
 14187  	}
 14188  }
 14189  func TestLeafGoString(t *testing.T) {
 14190  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14191  	p := NewPopulatedLeaf(popr, false)
 14192  	s1 := p.GoString()
 14193  	s2 := fmt.Sprintf("%#v", p)
 14194  	if s1 != s2 {
 14195  		t.Fatalf("GoString want %v got %v", s1, s2)
 14196  	}
 14197  	_, err := go_parser.ParseExpr(s1)
 14198  	if err != nil {
 14199  		t.Fatal(err)
 14200  	}
 14201  }
 14202  func TestDeepTreeGoString(t *testing.T) {
 14203  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14204  	p := NewPopulatedDeepTree(popr, false)
 14205  	s1 := p.GoString()
 14206  	s2 := fmt.Sprintf("%#v", p)
 14207  	if s1 != s2 {
 14208  		t.Fatalf("GoString want %v got %v", s1, s2)
 14209  	}
 14210  	_, err := go_parser.ParseExpr(s1)
 14211  	if err != nil {
 14212  		t.Fatal(err)
 14213  	}
 14214  }
 14215  func TestADeepBranchGoString(t *testing.T) {
 14216  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14217  	p := NewPopulatedADeepBranch(popr, false)
 14218  	s1 := p.GoString()
 14219  	s2 := fmt.Sprintf("%#v", p)
 14220  	if s1 != s2 {
 14221  		t.Fatalf("GoString want %v got %v", s1, s2)
 14222  	}
 14223  	_, err := go_parser.ParseExpr(s1)
 14224  	if err != nil {
 14225  		t.Fatal(err)
 14226  	}
 14227  }
 14228  func TestAndDeepBranchGoString(t *testing.T) {
 14229  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14230  	p := NewPopulatedAndDeepBranch(popr, false)
 14231  	s1 := p.GoString()
 14232  	s2 := fmt.Sprintf("%#v", p)
 14233  	if s1 != s2 {
 14234  		t.Fatalf("GoString want %v got %v", s1, s2)
 14235  	}
 14236  	_, err := go_parser.ParseExpr(s1)
 14237  	if err != nil {
 14238  		t.Fatal(err)
 14239  	}
 14240  }
 14241  func TestDeepLeafGoString(t *testing.T) {
 14242  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14243  	p := NewPopulatedDeepLeaf(popr, false)
 14244  	s1 := p.GoString()
 14245  	s2 := fmt.Sprintf("%#v", p)
 14246  	if s1 != s2 {
 14247  		t.Fatalf("GoString want %v got %v", s1, s2)
 14248  	}
 14249  	_, err := go_parser.ParseExpr(s1)
 14250  	if err != nil {
 14251  		t.Fatal(err)
 14252  	}
 14253  }
 14254  func TestNilGoString(t *testing.T) {
 14255  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14256  	p := NewPopulatedNil(popr, false)
 14257  	s1 := p.GoString()
 14258  	s2 := fmt.Sprintf("%#v", p)
 14259  	if s1 != s2 {
 14260  		t.Fatalf("GoString want %v got %v", s1, s2)
 14261  	}
 14262  	_, err := go_parser.ParseExpr(s1)
 14263  	if err != nil {
 14264  		t.Fatal(err)
 14265  	}
 14266  }
 14267  func TestNidOptEnumGoString(t *testing.T) {
 14268  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14269  	p := NewPopulatedNidOptEnum(popr, false)
 14270  	s1 := p.GoString()
 14271  	s2 := fmt.Sprintf("%#v", p)
 14272  	if s1 != s2 {
 14273  		t.Fatalf("GoString want %v got %v", s1, s2)
 14274  	}
 14275  	_, err := go_parser.ParseExpr(s1)
 14276  	if err != nil {
 14277  		t.Fatal(err)
 14278  	}
 14279  }
 14280  func TestNinOptEnumGoString(t *testing.T) {
 14281  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14282  	p := NewPopulatedNinOptEnum(popr, false)
 14283  	s1 := p.GoString()
 14284  	s2 := fmt.Sprintf("%#v", p)
 14285  	if s1 != s2 {
 14286  		t.Fatalf("GoString want %v got %v", s1, s2)
 14287  	}
 14288  	_, err := go_parser.ParseExpr(s1)
 14289  	if err != nil {
 14290  		t.Fatal(err)
 14291  	}
 14292  }
 14293  func TestNidRepEnumGoString(t *testing.T) {
 14294  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14295  	p := NewPopulatedNidRepEnum(popr, false)
 14296  	s1 := p.GoString()
 14297  	s2 := fmt.Sprintf("%#v", p)
 14298  	if s1 != s2 {
 14299  		t.Fatalf("GoString want %v got %v", s1, s2)
 14300  	}
 14301  	_, err := go_parser.ParseExpr(s1)
 14302  	if err != nil {
 14303  		t.Fatal(err)
 14304  	}
 14305  }
 14306  func TestNinRepEnumGoString(t *testing.T) {
 14307  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14308  	p := NewPopulatedNinRepEnum(popr, false)
 14309  	s1 := p.GoString()
 14310  	s2 := fmt.Sprintf("%#v", p)
 14311  	if s1 != s2 {
 14312  		t.Fatalf("GoString want %v got %v", s1, s2)
 14313  	}
 14314  	_, err := go_parser.ParseExpr(s1)
 14315  	if err != nil {
 14316  		t.Fatal(err)
 14317  	}
 14318  }
 14319  func TestNinOptEnumDefaultGoString(t *testing.T) {
 14320  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14321  	p := NewPopulatedNinOptEnumDefault(popr, false)
 14322  	s1 := p.GoString()
 14323  	s2 := fmt.Sprintf("%#v", p)
 14324  	if s1 != s2 {
 14325  		t.Fatalf("GoString want %v got %v", s1, s2)
 14326  	}
 14327  	_, err := go_parser.ParseExpr(s1)
 14328  	if err != nil {
 14329  		t.Fatal(err)
 14330  	}
 14331  }
 14332  func TestAnotherNinOptEnumGoString(t *testing.T) {
 14333  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14334  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 14335  	s1 := p.GoString()
 14336  	s2 := fmt.Sprintf("%#v", p)
 14337  	if s1 != s2 {
 14338  		t.Fatalf("GoString want %v got %v", s1, s2)
 14339  	}
 14340  	_, err := go_parser.ParseExpr(s1)
 14341  	if err != nil {
 14342  		t.Fatal(err)
 14343  	}
 14344  }
 14345  func TestAnotherNinOptEnumDefaultGoString(t *testing.T) {
 14346  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14347  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 14348  	s1 := p.GoString()
 14349  	s2 := fmt.Sprintf("%#v", p)
 14350  	if s1 != s2 {
 14351  		t.Fatalf("GoString want %v got %v", s1, s2)
 14352  	}
 14353  	_, err := go_parser.ParseExpr(s1)
 14354  	if err != nil {
 14355  		t.Fatal(err)
 14356  	}
 14357  }
 14358  func TestTimerGoString(t *testing.T) {
 14359  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14360  	p := NewPopulatedTimer(popr, false)
 14361  	s1 := p.GoString()
 14362  	s2 := fmt.Sprintf("%#v", p)
 14363  	if s1 != s2 {
 14364  		t.Fatalf("GoString want %v got %v", s1, s2)
 14365  	}
 14366  	_, err := go_parser.ParseExpr(s1)
 14367  	if err != nil {
 14368  		t.Fatal(err)
 14369  	}
 14370  }
 14371  func TestMyExtendableGoString(t *testing.T) {
 14372  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14373  	p := NewPopulatedMyExtendable(popr, false)
 14374  	s1 := p.GoString()
 14375  	s2 := fmt.Sprintf("%#v", p)
 14376  	if s1 != s2 {
 14377  		t.Fatalf("GoString want %v got %v", s1, s2)
 14378  	}
 14379  	_, err := go_parser.ParseExpr(s1)
 14380  	if err != nil {
 14381  		t.Fatal(err)
 14382  	}
 14383  }
 14384  func TestOtherExtenableGoString(t *testing.T) {
 14385  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14386  	p := NewPopulatedOtherExtenable(popr, false)
 14387  	s1 := p.GoString()
 14388  	s2 := fmt.Sprintf("%#v", p)
 14389  	if s1 != s2 {
 14390  		t.Fatalf("GoString want %v got %v", s1, s2)
 14391  	}
 14392  	_, err := go_parser.ParseExpr(s1)
 14393  	if err != nil {
 14394  		t.Fatal(err)
 14395  	}
 14396  }
 14397  func TestNestedDefinitionGoString(t *testing.T) {
 14398  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14399  	p := NewPopulatedNestedDefinition(popr, false)
 14400  	s1 := p.GoString()
 14401  	s2 := fmt.Sprintf("%#v", p)
 14402  	if s1 != s2 {
 14403  		t.Fatalf("GoString want %v got %v", s1, s2)
 14404  	}
 14405  	_, err := go_parser.ParseExpr(s1)
 14406  	if err != nil {
 14407  		t.Fatal(err)
 14408  	}
 14409  }
 14410  func TestNestedDefinition_NestedMessageGoString(t *testing.T) {
 14411  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14412  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 14413  	s1 := p.GoString()
 14414  	s2 := fmt.Sprintf("%#v", p)
 14415  	if s1 != s2 {
 14416  		t.Fatalf("GoString want %v got %v", s1, s2)
 14417  	}
 14418  	_, err := go_parser.ParseExpr(s1)
 14419  	if err != nil {
 14420  		t.Fatal(err)
 14421  	}
 14422  }
 14423  func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) {
 14424  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14425  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 14426  	s1 := p.GoString()
 14427  	s2 := fmt.Sprintf("%#v", p)
 14428  	if s1 != s2 {
 14429  		t.Fatalf("GoString want %v got %v", s1, s2)
 14430  	}
 14431  	_, err := go_parser.ParseExpr(s1)
 14432  	if err != nil {
 14433  		t.Fatal(err)
 14434  	}
 14435  }
 14436  func TestNestedScopeGoString(t *testing.T) {
 14437  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14438  	p := NewPopulatedNestedScope(popr, false)
 14439  	s1 := p.GoString()
 14440  	s2 := fmt.Sprintf("%#v", p)
 14441  	if s1 != s2 {
 14442  		t.Fatalf("GoString want %v got %v", s1, s2)
 14443  	}
 14444  	_, err := go_parser.ParseExpr(s1)
 14445  	if err != nil {
 14446  		t.Fatal(err)
 14447  	}
 14448  }
 14449  func TestNinOptNativeDefaultGoString(t *testing.T) {
 14450  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14451  	p := NewPopulatedNinOptNativeDefault(popr, false)
 14452  	s1 := p.GoString()
 14453  	s2 := fmt.Sprintf("%#v", p)
 14454  	if s1 != s2 {
 14455  		t.Fatalf("GoString want %v got %v", s1, s2)
 14456  	}
 14457  	_, err := go_parser.ParseExpr(s1)
 14458  	if err != nil {
 14459  		t.Fatal(err)
 14460  	}
 14461  }
 14462  func TestCustomContainerGoString(t *testing.T) {
 14463  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14464  	p := NewPopulatedCustomContainer(popr, false)
 14465  	s1 := p.GoString()
 14466  	s2 := fmt.Sprintf("%#v", p)
 14467  	if s1 != s2 {
 14468  		t.Fatalf("GoString want %v got %v", s1, s2)
 14469  	}
 14470  	_, err := go_parser.ParseExpr(s1)
 14471  	if err != nil {
 14472  		t.Fatal(err)
 14473  	}
 14474  }
 14475  func TestCustomNameNidOptNativeGoString(t *testing.T) {
 14476  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14477  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 14478  	s1 := p.GoString()
 14479  	s2 := fmt.Sprintf("%#v", p)
 14480  	if s1 != s2 {
 14481  		t.Fatalf("GoString want %v got %v", s1, s2)
 14482  	}
 14483  	_, err := go_parser.ParseExpr(s1)
 14484  	if err != nil {
 14485  		t.Fatal(err)
 14486  	}
 14487  }
 14488  func TestCustomNameNinOptNativeGoString(t *testing.T) {
 14489  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14490  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 14491  	s1 := p.GoString()
 14492  	s2 := fmt.Sprintf("%#v", p)
 14493  	if s1 != s2 {
 14494  		t.Fatalf("GoString want %v got %v", s1, s2)
 14495  	}
 14496  	_, err := go_parser.ParseExpr(s1)
 14497  	if err != nil {
 14498  		t.Fatal(err)
 14499  	}
 14500  }
 14501  func TestCustomNameNinRepNativeGoString(t *testing.T) {
 14502  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14503  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 14504  	s1 := p.GoString()
 14505  	s2 := fmt.Sprintf("%#v", p)
 14506  	if s1 != s2 {
 14507  		t.Fatalf("GoString want %v got %v", s1, s2)
 14508  	}
 14509  	_, err := go_parser.ParseExpr(s1)
 14510  	if err != nil {
 14511  		t.Fatal(err)
 14512  	}
 14513  }
 14514  func TestCustomNameNinStructGoString(t *testing.T) {
 14515  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14516  	p := NewPopulatedCustomNameNinStruct(popr, false)
 14517  	s1 := p.GoString()
 14518  	s2 := fmt.Sprintf("%#v", p)
 14519  	if s1 != s2 {
 14520  		t.Fatalf("GoString want %v got %v", s1, s2)
 14521  	}
 14522  	_, err := go_parser.ParseExpr(s1)
 14523  	if err != nil {
 14524  		t.Fatal(err)
 14525  	}
 14526  }
 14527  func TestCustomNameCustomTypeGoString(t *testing.T) {
 14528  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14529  	p := NewPopulatedCustomNameCustomType(popr, false)
 14530  	s1 := p.GoString()
 14531  	s2 := fmt.Sprintf("%#v", p)
 14532  	if s1 != s2 {
 14533  		t.Fatalf("GoString want %v got %v", s1, s2)
 14534  	}
 14535  	_, err := go_parser.ParseExpr(s1)
 14536  	if err != nil {
 14537  		t.Fatal(err)
 14538  	}
 14539  }
 14540  func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) {
 14541  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14542  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 14543  	s1 := p.GoString()
 14544  	s2 := fmt.Sprintf("%#v", p)
 14545  	if s1 != s2 {
 14546  		t.Fatalf("GoString want %v got %v", s1, s2)
 14547  	}
 14548  	_, err := go_parser.ParseExpr(s1)
 14549  	if err != nil {
 14550  		t.Fatal(err)
 14551  	}
 14552  }
 14553  func TestCustomNameEnumGoString(t *testing.T) {
 14554  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14555  	p := NewPopulatedCustomNameEnum(popr, false)
 14556  	s1 := p.GoString()
 14557  	s2 := fmt.Sprintf("%#v", p)
 14558  	if s1 != s2 {
 14559  		t.Fatalf("GoString want %v got %v", s1, s2)
 14560  	}
 14561  	_, err := go_parser.ParseExpr(s1)
 14562  	if err != nil {
 14563  		t.Fatal(err)
 14564  	}
 14565  }
 14566  func TestNoExtensionsMapGoString(t *testing.T) {
 14567  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14568  	p := NewPopulatedNoExtensionsMap(popr, false)
 14569  	s1 := p.GoString()
 14570  	s2 := fmt.Sprintf("%#v", p)
 14571  	if s1 != s2 {
 14572  		t.Fatalf("GoString want %v got %v", s1, s2)
 14573  	}
 14574  	_, err := go_parser.ParseExpr(s1)
 14575  	if err != nil {
 14576  		t.Fatal(err)
 14577  	}
 14578  }
 14579  func TestUnrecognizedGoString(t *testing.T) {
 14580  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14581  	p := NewPopulatedUnrecognized(popr, false)
 14582  	s1 := p.GoString()
 14583  	s2 := fmt.Sprintf("%#v", p)
 14584  	if s1 != s2 {
 14585  		t.Fatalf("GoString want %v got %v", s1, s2)
 14586  	}
 14587  	_, err := go_parser.ParseExpr(s1)
 14588  	if err != nil {
 14589  		t.Fatal(err)
 14590  	}
 14591  }
 14592  func TestUnrecognizedWithInnerGoString(t *testing.T) {
 14593  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14594  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 14595  	s1 := p.GoString()
 14596  	s2 := fmt.Sprintf("%#v", p)
 14597  	if s1 != s2 {
 14598  		t.Fatalf("GoString want %v got %v", s1, s2)
 14599  	}
 14600  	_, err := go_parser.ParseExpr(s1)
 14601  	if err != nil {
 14602  		t.Fatal(err)
 14603  	}
 14604  }
 14605  func TestUnrecognizedWithInner_InnerGoString(t *testing.T) {
 14606  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14607  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 14608  	s1 := p.GoString()
 14609  	s2 := fmt.Sprintf("%#v", p)
 14610  	if s1 != s2 {
 14611  		t.Fatalf("GoString want %v got %v", s1, s2)
 14612  	}
 14613  	_, err := go_parser.ParseExpr(s1)
 14614  	if err != nil {
 14615  		t.Fatal(err)
 14616  	}
 14617  }
 14618  func TestUnrecognizedWithEmbedGoString(t *testing.T) {
 14619  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14620  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 14621  	s1 := p.GoString()
 14622  	s2 := fmt.Sprintf("%#v", p)
 14623  	if s1 != s2 {
 14624  		t.Fatalf("GoString want %v got %v", s1, s2)
 14625  	}
 14626  	_, err := go_parser.ParseExpr(s1)
 14627  	if err != nil {
 14628  		t.Fatal(err)
 14629  	}
 14630  }
 14631  func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) {
 14632  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14633  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 14634  	s1 := p.GoString()
 14635  	s2 := fmt.Sprintf("%#v", p)
 14636  	if s1 != s2 {
 14637  		t.Fatalf("GoString want %v got %v", s1, s2)
 14638  	}
 14639  	_, err := go_parser.ParseExpr(s1)
 14640  	if err != nil {
 14641  		t.Fatal(err)
 14642  	}
 14643  }
 14644  func TestNodeGoString(t *testing.T) {
 14645  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14646  	p := NewPopulatedNode(popr, false)
 14647  	s1 := p.GoString()
 14648  	s2 := fmt.Sprintf("%#v", p)
 14649  	if s1 != s2 {
 14650  		t.Fatalf("GoString want %v got %v", s1, s2)
 14651  	}
 14652  	_, err := go_parser.ParseExpr(s1)
 14653  	if err != nil {
 14654  		t.Fatal(err)
 14655  	}
 14656  }
 14657  func TestNonByteCustomTypeGoString(t *testing.T) {
 14658  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14659  	p := NewPopulatedNonByteCustomType(popr, false)
 14660  	s1 := p.GoString()
 14661  	s2 := fmt.Sprintf("%#v", p)
 14662  	if s1 != s2 {
 14663  		t.Fatalf("GoString want %v got %v", s1, s2)
 14664  	}
 14665  	_, err := go_parser.ParseExpr(s1)
 14666  	if err != nil {
 14667  		t.Fatal(err)
 14668  	}
 14669  }
 14670  func TestNidOptNonByteCustomTypeGoString(t *testing.T) {
 14671  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14672  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 14673  	s1 := p.GoString()
 14674  	s2 := fmt.Sprintf("%#v", p)
 14675  	if s1 != s2 {
 14676  		t.Fatalf("GoString want %v got %v", s1, s2)
 14677  	}
 14678  	_, err := go_parser.ParseExpr(s1)
 14679  	if err != nil {
 14680  		t.Fatal(err)
 14681  	}
 14682  }
 14683  func TestNinOptNonByteCustomTypeGoString(t *testing.T) {
 14684  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14685  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 14686  	s1 := p.GoString()
 14687  	s2 := fmt.Sprintf("%#v", p)
 14688  	if s1 != s2 {
 14689  		t.Fatalf("GoString want %v got %v", s1, s2)
 14690  	}
 14691  	_, err := go_parser.ParseExpr(s1)
 14692  	if err != nil {
 14693  		t.Fatal(err)
 14694  	}
 14695  }
 14696  func TestNidRepNonByteCustomTypeGoString(t *testing.T) {
 14697  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14698  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 14699  	s1 := p.GoString()
 14700  	s2 := fmt.Sprintf("%#v", p)
 14701  	if s1 != s2 {
 14702  		t.Fatalf("GoString want %v got %v", s1, s2)
 14703  	}
 14704  	_, err := go_parser.ParseExpr(s1)
 14705  	if err != nil {
 14706  		t.Fatal(err)
 14707  	}
 14708  }
 14709  func TestNinRepNonByteCustomTypeGoString(t *testing.T) {
 14710  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14711  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 14712  	s1 := p.GoString()
 14713  	s2 := fmt.Sprintf("%#v", p)
 14714  	if s1 != s2 {
 14715  		t.Fatalf("GoString want %v got %v", s1, s2)
 14716  	}
 14717  	_, err := go_parser.ParseExpr(s1)
 14718  	if err != nil {
 14719  		t.Fatal(err)
 14720  	}
 14721  }
 14722  func TestProtoTypeGoString(t *testing.T) {
 14723  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 14724  	p := NewPopulatedProtoType(popr, false)
 14725  	s1 := p.GoString()
 14726  	s2 := fmt.Sprintf("%#v", p)
 14727  	if s1 != s2 {
 14728  		t.Fatalf("GoString want %v got %v", s1, s2)
 14729  	}
 14730  	_, err := go_parser.ParseExpr(s1)
 14731  	if err != nil {
 14732  		t.Fatal(err)
 14733  	}
 14734  }
 14735  func TestNidOptNativeSize(t *testing.T) {
 14736  	seed := time.Now().UnixNano()
 14737  	popr := math_rand.New(math_rand.NewSource(seed))
 14738  	p := NewPopulatedNidOptNative(popr, true)
 14739  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14740  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14741  	if err != nil {
 14742  		t.Fatalf("seed = %d, err = %v", seed, err)
 14743  	}
 14744  	size := p.Size()
 14745  	if len(dAtA) != size {
 14746  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14747  	}
 14748  	if size2 != size {
 14749  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14750  	}
 14751  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14752  	if size3 != size {
 14753  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14754  	}
 14755  }
 14756  
 14757  func BenchmarkNidOptNativeSize(b *testing.B) {
 14758  	popr := math_rand.New(math_rand.NewSource(616))
 14759  	total := 0
 14760  	pops := make([]*NidOptNative, 1000)
 14761  	for i := 0; i < 1000; i++ {
 14762  		pops[i] = NewPopulatedNidOptNative(popr, false)
 14763  	}
 14764  	b.ResetTimer()
 14765  	for i := 0; i < b.N; i++ {
 14766  		total += pops[i%1000].Size()
 14767  	}
 14768  	b.SetBytes(int64(total / b.N))
 14769  }
 14770  
 14771  func TestNinOptNativeSize(t *testing.T) {
 14772  	seed := time.Now().UnixNano()
 14773  	popr := math_rand.New(math_rand.NewSource(seed))
 14774  	p := NewPopulatedNinOptNative(popr, true)
 14775  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14776  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14777  	if err != nil {
 14778  		t.Fatalf("seed = %d, err = %v", seed, err)
 14779  	}
 14780  	size := p.Size()
 14781  	if len(dAtA) != size {
 14782  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14783  	}
 14784  	if size2 != size {
 14785  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14786  	}
 14787  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14788  	if size3 != size {
 14789  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14790  	}
 14791  }
 14792  
 14793  func BenchmarkNinOptNativeSize(b *testing.B) {
 14794  	popr := math_rand.New(math_rand.NewSource(616))
 14795  	total := 0
 14796  	pops := make([]*NinOptNative, 1000)
 14797  	for i := 0; i < 1000; i++ {
 14798  		pops[i] = NewPopulatedNinOptNative(popr, false)
 14799  	}
 14800  	b.ResetTimer()
 14801  	for i := 0; i < b.N; i++ {
 14802  		total += pops[i%1000].Size()
 14803  	}
 14804  	b.SetBytes(int64(total / b.N))
 14805  }
 14806  
 14807  func TestNidRepNativeSize(t *testing.T) {
 14808  	seed := time.Now().UnixNano()
 14809  	popr := math_rand.New(math_rand.NewSource(seed))
 14810  	p := NewPopulatedNidRepNative(popr, true)
 14811  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14812  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14813  	if err != nil {
 14814  		t.Fatalf("seed = %d, err = %v", seed, err)
 14815  	}
 14816  	size := p.Size()
 14817  	if len(dAtA) != size {
 14818  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14819  	}
 14820  	if size2 != size {
 14821  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14822  	}
 14823  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14824  	if size3 != size {
 14825  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14826  	}
 14827  }
 14828  
 14829  func BenchmarkNidRepNativeSize(b *testing.B) {
 14830  	popr := math_rand.New(math_rand.NewSource(616))
 14831  	total := 0
 14832  	pops := make([]*NidRepNative, 1000)
 14833  	for i := 0; i < 1000; i++ {
 14834  		pops[i] = NewPopulatedNidRepNative(popr, false)
 14835  	}
 14836  	b.ResetTimer()
 14837  	for i := 0; i < b.N; i++ {
 14838  		total += pops[i%1000].Size()
 14839  	}
 14840  	b.SetBytes(int64(total / b.N))
 14841  }
 14842  
 14843  func TestNinRepNativeSize(t *testing.T) {
 14844  	seed := time.Now().UnixNano()
 14845  	popr := math_rand.New(math_rand.NewSource(seed))
 14846  	p := NewPopulatedNinRepNative(popr, true)
 14847  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14848  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14849  	if err != nil {
 14850  		t.Fatalf("seed = %d, err = %v", seed, err)
 14851  	}
 14852  	size := p.Size()
 14853  	if len(dAtA) != size {
 14854  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14855  	}
 14856  	if size2 != size {
 14857  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14858  	}
 14859  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14860  	if size3 != size {
 14861  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14862  	}
 14863  }
 14864  
 14865  func BenchmarkNinRepNativeSize(b *testing.B) {
 14866  	popr := math_rand.New(math_rand.NewSource(616))
 14867  	total := 0
 14868  	pops := make([]*NinRepNative, 1000)
 14869  	for i := 0; i < 1000; i++ {
 14870  		pops[i] = NewPopulatedNinRepNative(popr, false)
 14871  	}
 14872  	b.ResetTimer()
 14873  	for i := 0; i < b.N; i++ {
 14874  		total += pops[i%1000].Size()
 14875  	}
 14876  	b.SetBytes(int64(total / b.N))
 14877  }
 14878  
 14879  func TestNidRepPackedNativeSize(t *testing.T) {
 14880  	seed := time.Now().UnixNano()
 14881  	popr := math_rand.New(math_rand.NewSource(seed))
 14882  	p := NewPopulatedNidRepPackedNative(popr, true)
 14883  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14884  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14885  	if err != nil {
 14886  		t.Fatalf("seed = %d, err = %v", seed, err)
 14887  	}
 14888  	size := p.Size()
 14889  	if len(dAtA) != size {
 14890  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14891  	}
 14892  	if size2 != size {
 14893  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14894  	}
 14895  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14896  	if size3 != size {
 14897  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14898  	}
 14899  }
 14900  
 14901  func BenchmarkNidRepPackedNativeSize(b *testing.B) {
 14902  	popr := math_rand.New(math_rand.NewSource(616))
 14903  	total := 0
 14904  	pops := make([]*NidRepPackedNative, 1000)
 14905  	for i := 0; i < 1000; i++ {
 14906  		pops[i] = NewPopulatedNidRepPackedNative(popr, false)
 14907  	}
 14908  	b.ResetTimer()
 14909  	for i := 0; i < b.N; i++ {
 14910  		total += pops[i%1000].Size()
 14911  	}
 14912  	b.SetBytes(int64(total / b.N))
 14913  }
 14914  
 14915  func TestNinRepPackedNativeSize(t *testing.T) {
 14916  	seed := time.Now().UnixNano()
 14917  	popr := math_rand.New(math_rand.NewSource(seed))
 14918  	p := NewPopulatedNinRepPackedNative(popr, true)
 14919  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14920  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14921  	if err != nil {
 14922  		t.Fatalf("seed = %d, err = %v", seed, err)
 14923  	}
 14924  	size := p.Size()
 14925  	if len(dAtA) != size {
 14926  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14927  	}
 14928  	if size2 != size {
 14929  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14930  	}
 14931  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14932  	if size3 != size {
 14933  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14934  	}
 14935  }
 14936  
 14937  func BenchmarkNinRepPackedNativeSize(b *testing.B) {
 14938  	popr := math_rand.New(math_rand.NewSource(616))
 14939  	total := 0
 14940  	pops := make([]*NinRepPackedNative, 1000)
 14941  	for i := 0; i < 1000; i++ {
 14942  		pops[i] = NewPopulatedNinRepPackedNative(popr, false)
 14943  	}
 14944  	b.ResetTimer()
 14945  	for i := 0; i < b.N; i++ {
 14946  		total += pops[i%1000].Size()
 14947  	}
 14948  	b.SetBytes(int64(total / b.N))
 14949  }
 14950  
 14951  func TestNidOptStructSize(t *testing.T) {
 14952  	seed := time.Now().UnixNano()
 14953  	popr := math_rand.New(math_rand.NewSource(seed))
 14954  	p := NewPopulatedNidOptStruct(popr, true)
 14955  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14956  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14957  	if err != nil {
 14958  		t.Fatalf("seed = %d, err = %v", seed, err)
 14959  	}
 14960  	size := p.Size()
 14961  	if len(dAtA) != size {
 14962  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14963  	}
 14964  	if size2 != size {
 14965  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14966  	}
 14967  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14968  	if size3 != size {
 14969  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14970  	}
 14971  }
 14972  
 14973  func BenchmarkNidOptStructSize(b *testing.B) {
 14974  	popr := math_rand.New(math_rand.NewSource(616))
 14975  	total := 0
 14976  	pops := make([]*NidOptStruct, 1000)
 14977  	for i := 0; i < 1000; i++ {
 14978  		pops[i] = NewPopulatedNidOptStruct(popr, false)
 14979  	}
 14980  	b.ResetTimer()
 14981  	for i := 0; i < b.N; i++ {
 14982  		total += pops[i%1000].Size()
 14983  	}
 14984  	b.SetBytes(int64(total / b.N))
 14985  }
 14986  
 14987  func TestNinOptStructSize(t *testing.T) {
 14988  	seed := time.Now().UnixNano()
 14989  	popr := math_rand.New(math_rand.NewSource(seed))
 14990  	p := NewPopulatedNinOptStruct(popr, true)
 14991  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14992  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14993  	if err != nil {
 14994  		t.Fatalf("seed = %d, err = %v", seed, err)
 14995  	}
 14996  	size := p.Size()
 14997  	if len(dAtA) != size {
 14998  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14999  	}
 15000  	if size2 != size {
 15001  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15002  	}
 15003  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15004  	if size3 != size {
 15005  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15006  	}
 15007  }
 15008  
 15009  func BenchmarkNinOptStructSize(b *testing.B) {
 15010  	popr := math_rand.New(math_rand.NewSource(616))
 15011  	total := 0
 15012  	pops := make([]*NinOptStruct, 1000)
 15013  	for i := 0; i < 1000; i++ {
 15014  		pops[i] = NewPopulatedNinOptStruct(popr, false)
 15015  	}
 15016  	b.ResetTimer()
 15017  	for i := 0; i < b.N; i++ {
 15018  		total += pops[i%1000].Size()
 15019  	}
 15020  	b.SetBytes(int64(total / b.N))
 15021  }
 15022  
 15023  func TestNidRepStructSize(t *testing.T) {
 15024  	seed := time.Now().UnixNano()
 15025  	popr := math_rand.New(math_rand.NewSource(seed))
 15026  	p := NewPopulatedNidRepStruct(popr, true)
 15027  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15028  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15029  	if err != nil {
 15030  		t.Fatalf("seed = %d, err = %v", seed, err)
 15031  	}
 15032  	size := p.Size()
 15033  	if len(dAtA) != size {
 15034  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15035  	}
 15036  	if size2 != size {
 15037  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15038  	}
 15039  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15040  	if size3 != size {
 15041  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15042  	}
 15043  }
 15044  
 15045  func BenchmarkNidRepStructSize(b *testing.B) {
 15046  	popr := math_rand.New(math_rand.NewSource(616))
 15047  	total := 0
 15048  	pops := make([]*NidRepStruct, 1000)
 15049  	for i := 0; i < 1000; i++ {
 15050  		pops[i] = NewPopulatedNidRepStruct(popr, false)
 15051  	}
 15052  	b.ResetTimer()
 15053  	for i := 0; i < b.N; i++ {
 15054  		total += pops[i%1000].Size()
 15055  	}
 15056  	b.SetBytes(int64(total / b.N))
 15057  }
 15058  
 15059  func TestNinRepStructSize(t *testing.T) {
 15060  	seed := time.Now().UnixNano()
 15061  	popr := math_rand.New(math_rand.NewSource(seed))
 15062  	p := NewPopulatedNinRepStruct(popr, true)
 15063  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15064  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15065  	if err != nil {
 15066  		t.Fatalf("seed = %d, err = %v", seed, err)
 15067  	}
 15068  	size := p.Size()
 15069  	if len(dAtA) != size {
 15070  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15071  	}
 15072  	if size2 != size {
 15073  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15074  	}
 15075  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15076  	if size3 != size {
 15077  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15078  	}
 15079  }
 15080  
 15081  func BenchmarkNinRepStructSize(b *testing.B) {
 15082  	popr := math_rand.New(math_rand.NewSource(616))
 15083  	total := 0
 15084  	pops := make([]*NinRepStruct, 1000)
 15085  	for i := 0; i < 1000; i++ {
 15086  		pops[i] = NewPopulatedNinRepStruct(popr, false)
 15087  	}
 15088  	b.ResetTimer()
 15089  	for i := 0; i < b.N; i++ {
 15090  		total += pops[i%1000].Size()
 15091  	}
 15092  	b.SetBytes(int64(total / b.N))
 15093  }
 15094  
 15095  func TestNidEmbeddedStructSize(t *testing.T) {
 15096  	seed := time.Now().UnixNano()
 15097  	popr := math_rand.New(math_rand.NewSource(seed))
 15098  	p := NewPopulatedNidEmbeddedStruct(popr, true)
 15099  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15100  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15101  	if err != nil {
 15102  		t.Fatalf("seed = %d, err = %v", seed, err)
 15103  	}
 15104  	size := p.Size()
 15105  	if len(dAtA) != size {
 15106  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15107  	}
 15108  	if size2 != size {
 15109  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15110  	}
 15111  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15112  	if size3 != size {
 15113  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15114  	}
 15115  }
 15116  
 15117  func BenchmarkNidEmbeddedStructSize(b *testing.B) {
 15118  	popr := math_rand.New(math_rand.NewSource(616))
 15119  	total := 0
 15120  	pops := make([]*NidEmbeddedStruct, 1000)
 15121  	for i := 0; i < 1000; i++ {
 15122  		pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
 15123  	}
 15124  	b.ResetTimer()
 15125  	for i := 0; i < b.N; i++ {
 15126  		total += pops[i%1000].Size()
 15127  	}
 15128  	b.SetBytes(int64(total / b.N))
 15129  }
 15130  
 15131  func TestNinEmbeddedStructSize(t *testing.T) {
 15132  	seed := time.Now().UnixNano()
 15133  	popr := math_rand.New(math_rand.NewSource(seed))
 15134  	p := NewPopulatedNinEmbeddedStruct(popr, true)
 15135  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15136  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15137  	if err != nil {
 15138  		t.Fatalf("seed = %d, err = %v", seed, err)
 15139  	}
 15140  	size := p.Size()
 15141  	if len(dAtA) != size {
 15142  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15143  	}
 15144  	if size2 != size {
 15145  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15146  	}
 15147  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15148  	if size3 != size {
 15149  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15150  	}
 15151  }
 15152  
 15153  func BenchmarkNinEmbeddedStructSize(b *testing.B) {
 15154  	popr := math_rand.New(math_rand.NewSource(616))
 15155  	total := 0
 15156  	pops := make([]*NinEmbeddedStruct, 1000)
 15157  	for i := 0; i < 1000; i++ {
 15158  		pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
 15159  	}
 15160  	b.ResetTimer()
 15161  	for i := 0; i < b.N; i++ {
 15162  		total += pops[i%1000].Size()
 15163  	}
 15164  	b.SetBytes(int64(total / b.N))
 15165  }
 15166  
 15167  func TestNidNestedStructSize(t *testing.T) {
 15168  	seed := time.Now().UnixNano()
 15169  	popr := math_rand.New(math_rand.NewSource(seed))
 15170  	p := NewPopulatedNidNestedStruct(popr, true)
 15171  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15172  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15173  	if err != nil {
 15174  		t.Fatalf("seed = %d, err = %v", seed, err)
 15175  	}
 15176  	size := p.Size()
 15177  	if len(dAtA) != size {
 15178  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15179  	}
 15180  	if size2 != size {
 15181  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15182  	}
 15183  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15184  	if size3 != size {
 15185  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15186  	}
 15187  }
 15188  
 15189  func BenchmarkNidNestedStructSize(b *testing.B) {
 15190  	popr := math_rand.New(math_rand.NewSource(616))
 15191  	total := 0
 15192  	pops := make([]*NidNestedStruct, 1000)
 15193  	for i := 0; i < 1000; i++ {
 15194  		pops[i] = NewPopulatedNidNestedStruct(popr, false)
 15195  	}
 15196  	b.ResetTimer()
 15197  	for i := 0; i < b.N; i++ {
 15198  		total += pops[i%1000].Size()
 15199  	}
 15200  	b.SetBytes(int64(total / b.N))
 15201  }
 15202  
 15203  func TestNinNestedStructSize(t *testing.T) {
 15204  	seed := time.Now().UnixNano()
 15205  	popr := math_rand.New(math_rand.NewSource(seed))
 15206  	p := NewPopulatedNinNestedStruct(popr, true)
 15207  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15208  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15209  	if err != nil {
 15210  		t.Fatalf("seed = %d, err = %v", seed, err)
 15211  	}
 15212  	size := p.Size()
 15213  	if len(dAtA) != size {
 15214  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15215  	}
 15216  	if size2 != size {
 15217  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15218  	}
 15219  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15220  	if size3 != size {
 15221  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15222  	}
 15223  }
 15224  
 15225  func BenchmarkNinNestedStructSize(b *testing.B) {
 15226  	popr := math_rand.New(math_rand.NewSource(616))
 15227  	total := 0
 15228  	pops := make([]*NinNestedStruct, 1000)
 15229  	for i := 0; i < 1000; i++ {
 15230  		pops[i] = NewPopulatedNinNestedStruct(popr, false)
 15231  	}
 15232  	b.ResetTimer()
 15233  	for i := 0; i < b.N; i++ {
 15234  		total += pops[i%1000].Size()
 15235  	}
 15236  	b.SetBytes(int64(total / b.N))
 15237  }
 15238  
 15239  func TestNidOptCustomSize(t *testing.T) {
 15240  	seed := time.Now().UnixNano()
 15241  	popr := math_rand.New(math_rand.NewSource(seed))
 15242  	p := NewPopulatedNidOptCustom(popr, true)
 15243  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15244  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15245  	if err != nil {
 15246  		t.Fatalf("seed = %d, err = %v", seed, err)
 15247  	}
 15248  	size := p.Size()
 15249  	if len(dAtA) != size {
 15250  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15251  	}
 15252  	if size2 != size {
 15253  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15254  	}
 15255  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15256  	if size3 != size {
 15257  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15258  	}
 15259  }
 15260  
 15261  func BenchmarkNidOptCustomSize(b *testing.B) {
 15262  	popr := math_rand.New(math_rand.NewSource(616))
 15263  	total := 0
 15264  	pops := make([]*NidOptCustom, 1000)
 15265  	for i := 0; i < 1000; i++ {
 15266  		pops[i] = NewPopulatedNidOptCustom(popr, false)
 15267  	}
 15268  	b.ResetTimer()
 15269  	for i := 0; i < b.N; i++ {
 15270  		total += pops[i%1000].Size()
 15271  	}
 15272  	b.SetBytes(int64(total / b.N))
 15273  }
 15274  
 15275  func TestCustomDashSize(t *testing.T) {
 15276  	seed := time.Now().UnixNano()
 15277  	popr := math_rand.New(math_rand.NewSource(seed))
 15278  	p := NewPopulatedCustomDash(popr, true)
 15279  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15280  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15281  	if err != nil {
 15282  		t.Fatalf("seed = %d, err = %v", seed, err)
 15283  	}
 15284  	size := p.Size()
 15285  	if len(dAtA) != size {
 15286  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15287  	}
 15288  	if size2 != size {
 15289  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15290  	}
 15291  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15292  	if size3 != size {
 15293  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15294  	}
 15295  }
 15296  
 15297  func BenchmarkCustomDashSize(b *testing.B) {
 15298  	popr := math_rand.New(math_rand.NewSource(616))
 15299  	total := 0
 15300  	pops := make([]*CustomDash, 1000)
 15301  	for i := 0; i < 1000; i++ {
 15302  		pops[i] = NewPopulatedCustomDash(popr, false)
 15303  	}
 15304  	b.ResetTimer()
 15305  	for i := 0; i < b.N; i++ {
 15306  		total += pops[i%1000].Size()
 15307  	}
 15308  	b.SetBytes(int64(total / b.N))
 15309  }
 15310  
 15311  func TestNinOptCustomSize(t *testing.T) {
 15312  	seed := time.Now().UnixNano()
 15313  	popr := math_rand.New(math_rand.NewSource(seed))
 15314  	p := NewPopulatedNinOptCustom(popr, true)
 15315  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15316  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15317  	if err != nil {
 15318  		t.Fatalf("seed = %d, err = %v", seed, err)
 15319  	}
 15320  	size := p.Size()
 15321  	if len(dAtA) != size {
 15322  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15323  	}
 15324  	if size2 != size {
 15325  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15326  	}
 15327  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15328  	if size3 != size {
 15329  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15330  	}
 15331  }
 15332  
 15333  func BenchmarkNinOptCustomSize(b *testing.B) {
 15334  	popr := math_rand.New(math_rand.NewSource(616))
 15335  	total := 0
 15336  	pops := make([]*NinOptCustom, 1000)
 15337  	for i := 0; i < 1000; i++ {
 15338  		pops[i] = NewPopulatedNinOptCustom(popr, false)
 15339  	}
 15340  	b.ResetTimer()
 15341  	for i := 0; i < b.N; i++ {
 15342  		total += pops[i%1000].Size()
 15343  	}
 15344  	b.SetBytes(int64(total / b.N))
 15345  }
 15346  
 15347  func TestNidRepCustomSize(t *testing.T) {
 15348  	seed := time.Now().UnixNano()
 15349  	popr := math_rand.New(math_rand.NewSource(seed))
 15350  	p := NewPopulatedNidRepCustom(popr, true)
 15351  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15352  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15353  	if err != nil {
 15354  		t.Fatalf("seed = %d, err = %v", seed, err)
 15355  	}
 15356  	size := p.Size()
 15357  	if len(dAtA) != size {
 15358  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15359  	}
 15360  	if size2 != size {
 15361  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15362  	}
 15363  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15364  	if size3 != size {
 15365  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15366  	}
 15367  }
 15368  
 15369  func BenchmarkNidRepCustomSize(b *testing.B) {
 15370  	popr := math_rand.New(math_rand.NewSource(616))
 15371  	total := 0
 15372  	pops := make([]*NidRepCustom, 1000)
 15373  	for i := 0; i < 1000; i++ {
 15374  		pops[i] = NewPopulatedNidRepCustom(popr, false)
 15375  	}
 15376  	b.ResetTimer()
 15377  	for i := 0; i < b.N; i++ {
 15378  		total += pops[i%1000].Size()
 15379  	}
 15380  	b.SetBytes(int64(total / b.N))
 15381  }
 15382  
 15383  func TestNinRepCustomSize(t *testing.T) {
 15384  	seed := time.Now().UnixNano()
 15385  	popr := math_rand.New(math_rand.NewSource(seed))
 15386  	p := NewPopulatedNinRepCustom(popr, true)
 15387  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15388  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15389  	if err != nil {
 15390  		t.Fatalf("seed = %d, err = %v", seed, err)
 15391  	}
 15392  	size := p.Size()
 15393  	if len(dAtA) != size {
 15394  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15395  	}
 15396  	if size2 != size {
 15397  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15398  	}
 15399  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15400  	if size3 != size {
 15401  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15402  	}
 15403  }
 15404  
 15405  func BenchmarkNinRepCustomSize(b *testing.B) {
 15406  	popr := math_rand.New(math_rand.NewSource(616))
 15407  	total := 0
 15408  	pops := make([]*NinRepCustom, 1000)
 15409  	for i := 0; i < 1000; i++ {
 15410  		pops[i] = NewPopulatedNinRepCustom(popr, false)
 15411  	}
 15412  	b.ResetTimer()
 15413  	for i := 0; i < b.N; i++ {
 15414  		total += pops[i%1000].Size()
 15415  	}
 15416  	b.SetBytes(int64(total / b.N))
 15417  }
 15418  
 15419  func TestNinOptNativeUnionSize(t *testing.T) {
 15420  	seed := time.Now().UnixNano()
 15421  	popr := math_rand.New(math_rand.NewSource(seed))
 15422  	p := NewPopulatedNinOptNativeUnion(popr, true)
 15423  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15424  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15425  	if err != nil {
 15426  		t.Fatalf("seed = %d, err = %v", seed, err)
 15427  	}
 15428  	size := p.Size()
 15429  	if len(dAtA) != size {
 15430  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15431  	}
 15432  	if size2 != size {
 15433  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15434  	}
 15435  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15436  	if size3 != size {
 15437  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15438  	}
 15439  }
 15440  
 15441  func BenchmarkNinOptNativeUnionSize(b *testing.B) {
 15442  	popr := math_rand.New(math_rand.NewSource(616))
 15443  	total := 0
 15444  	pops := make([]*NinOptNativeUnion, 1000)
 15445  	for i := 0; i < 1000; i++ {
 15446  		pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
 15447  	}
 15448  	b.ResetTimer()
 15449  	for i := 0; i < b.N; i++ {
 15450  		total += pops[i%1000].Size()
 15451  	}
 15452  	b.SetBytes(int64(total / b.N))
 15453  }
 15454  
 15455  func TestNinOptStructUnionSize(t *testing.T) {
 15456  	seed := time.Now().UnixNano()
 15457  	popr := math_rand.New(math_rand.NewSource(seed))
 15458  	p := NewPopulatedNinOptStructUnion(popr, true)
 15459  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15460  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15461  	if err != nil {
 15462  		t.Fatalf("seed = %d, err = %v", seed, err)
 15463  	}
 15464  	size := p.Size()
 15465  	if len(dAtA) != size {
 15466  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15467  	}
 15468  	if size2 != size {
 15469  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15470  	}
 15471  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15472  	if size3 != size {
 15473  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15474  	}
 15475  }
 15476  
 15477  func BenchmarkNinOptStructUnionSize(b *testing.B) {
 15478  	popr := math_rand.New(math_rand.NewSource(616))
 15479  	total := 0
 15480  	pops := make([]*NinOptStructUnion, 1000)
 15481  	for i := 0; i < 1000; i++ {
 15482  		pops[i] = NewPopulatedNinOptStructUnion(popr, false)
 15483  	}
 15484  	b.ResetTimer()
 15485  	for i := 0; i < b.N; i++ {
 15486  		total += pops[i%1000].Size()
 15487  	}
 15488  	b.SetBytes(int64(total / b.N))
 15489  }
 15490  
 15491  func TestNinEmbeddedStructUnionSize(t *testing.T) {
 15492  	seed := time.Now().UnixNano()
 15493  	popr := math_rand.New(math_rand.NewSource(seed))
 15494  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 15495  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15496  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15497  	if err != nil {
 15498  		t.Fatalf("seed = %d, err = %v", seed, err)
 15499  	}
 15500  	size := p.Size()
 15501  	if len(dAtA) != size {
 15502  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15503  	}
 15504  	if size2 != size {
 15505  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15506  	}
 15507  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15508  	if size3 != size {
 15509  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15510  	}
 15511  }
 15512  
 15513  func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) {
 15514  	popr := math_rand.New(math_rand.NewSource(616))
 15515  	total := 0
 15516  	pops := make([]*NinEmbeddedStructUnion, 1000)
 15517  	for i := 0; i < 1000; i++ {
 15518  		pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
 15519  	}
 15520  	b.ResetTimer()
 15521  	for i := 0; i < b.N; i++ {
 15522  		total += pops[i%1000].Size()
 15523  	}
 15524  	b.SetBytes(int64(total / b.N))
 15525  }
 15526  
 15527  func TestNinNestedStructUnionSize(t *testing.T) {
 15528  	seed := time.Now().UnixNano()
 15529  	popr := math_rand.New(math_rand.NewSource(seed))
 15530  	p := NewPopulatedNinNestedStructUnion(popr, true)
 15531  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15532  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15533  	if err != nil {
 15534  		t.Fatalf("seed = %d, err = %v", seed, err)
 15535  	}
 15536  	size := p.Size()
 15537  	if len(dAtA) != size {
 15538  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15539  	}
 15540  	if size2 != size {
 15541  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15542  	}
 15543  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15544  	if size3 != size {
 15545  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15546  	}
 15547  }
 15548  
 15549  func BenchmarkNinNestedStructUnionSize(b *testing.B) {
 15550  	popr := math_rand.New(math_rand.NewSource(616))
 15551  	total := 0
 15552  	pops := make([]*NinNestedStructUnion, 1000)
 15553  	for i := 0; i < 1000; i++ {
 15554  		pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
 15555  	}
 15556  	b.ResetTimer()
 15557  	for i := 0; i < b.N; i++ {
 15558  		total += pops[i%1000].Size()
 15559  	}
 15560  	b.SetBytes(int64(total / b.N))
 15561  }
 15562  
 15563  func TestTreeSize(t *testing.T) {
 15564  	seed := time.Now().UnixNano()
 15565  	popr := math_rand.New(math_rand.NewSource(seed))
 15566  	p := NewPopulatedTree(popr, true)
 15567  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15568  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15569  	if err != nil {
 15570  		t.Fatalf("seed = %d, err = %v", seed, err)
 15571  	}
 15572  	size := p.Size()
 15573  	if len(dAtA) != size {
 15574  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15575  	}
 15576  	if size2 != size {
 15577  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15578  	}
 15579  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15580  	if size3 != size {
 15581  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15582  	}
 15583  }
 15584  
 15585  func BenchmarkTreeSize(b *testing.B) {
 15586  	popr := math_rand.New(math_rand.NewSource(616))
 15587  	total := 0
 15588  	pops := make([]*Tree, 1000)
 15589  	for i := 0; i < 1000; i++ {
 15590  		pops[i] = NewPopulatedTree(popr, false)
 15591  	}
 15592  	b.ResetTimer()
 15593  	for i := 0; i < b.N; i++ {
 15594  		total += pops[i%1000].Size()
 15595  	}
 15596  	b.SetBytes(int64(total / b.N))
 15597  }
 15598  
 15599  func TestOrBranchSize(t *testing.T) {
 15600  	seed := time.Now().UnixNano()
 15601  	popr := math_rand.New(math_rand.NewSource(seed))
 15602  	p := NewPopulatedOrBranch(popr, true)
 15603  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15604  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15605  	if err != nil {
 15606  		t.Fatalf("seed = %d, err = %v", seed, err)
 15607  	}
 15608  	size := p.Size()
 15609  	if len(dAtA) != size {
 15610  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15611  	}
 15612  	if size2 != size {
 15613  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15614  	}
 15615  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15616  	if size3 != size {
 15617  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15618  	}
 15619  }
 15620  
 15621  func BenchmarkOrBranchSize(b *testing.B) {
 15622  	popr := math_rand.New(math_rand.NewSource(616))
 15623  	total := 0
 15624  	pops := make([]*OrBranch, 1000)
 15625  	for i := 0; i < 1000; i++ {
 15626  		pops[i] = NewPopulatedOrBranch(popr, false)
 15627  	}
 15628  	b.ResetTimer()
 15629  	for i := 0; i < b.N; i++ {
 15630  		total += pops[i%1000].Size()
 15631  	}
 15632  	b.SetBytes(int64(total / b.N))
 15633  }
 15634  
 15635  func TestAndBranchSize(t *testing.T) {
 15636  	seed := time.Now().UnixNano()
 15637  	popr := math_rand.New(math_rand.NewSource(seed))
 15638  	p := NewPopulatedAndBranch(popr, true)
 15639  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15640  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15641  	if err != nil {
 15642  		t.Fatalf("seed = %d, err = %v", seed, err)
 15643  	}
 15644  	size := p.Size()
 15645  	if len(dAtA) != size {
 15646  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15647  	}
 15648  	if size2 != size {
 15649  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15650  	}
 15651  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15652  	if size3 != size {
 15653  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15654  	}
 15655  }
 15656  
 15657  func BenchmarkAndBranchSize(b *testing.B) {
 15658  	popr := math_rand.New(math_rand.NewSource(616))
 15659  	total := 0
 15660  	pops := make([]*AndBranch, 1000)
 15661  	for i := 0; i < 1000; i++ {
 15662  		pops[i] = NewPopulatedAndBranch(popr, false)
 15663  	}
 15664  	b.ResetTimer()
 15665  	for i := 0; i < b.N; i++ {
 15666  		total += pops[i%1000].Size()
 15667  	}
 15668  	b.SetBytes(int64(total / b.N))
 15669  }
 15670  
 15671  func TestLeafSize(t *testing.T) {
 15672  	seed := time.Now().UnixNano()
 15673  	popr := math_rand.New(math_rand.NewSource(seed))
 15674  	p := NewPopulatedLeaf(popr, true)
 15675  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15676  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15677  	if err != nil {
 15678  		t.Fatalf("seed = %d, err = %v", seed, err)
 15679  	}
 15680  	size := p.Size()
 15681  	if len(dAtA) != size {
 15682  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15683  	}
 15684  	if size2 != size {
 15685  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15686  	}
 15687  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15688  	if size3 != size {
 15689  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15690  	}
 15691  }
 15692  
 15693  func BenchmarkLeafSize(b *testing.B) {
 15694  	popr := math_rand.New(math_rand.NewSource(616))
 15695  	total := 0
 15696  	pops := make([]*Leaf, 1000)
 15697  	for i := 0; i < 1000; i++ {
 15698  		pops[i] = NewPopulatedLeaf(popr, false)
 15699  	}
 15700  	b.ResetTimer()
 15701  	for i := 0; i < b.N; i++ {
 15702  		total += pops[i%1000].Size()
 15703  	}
 15704  	b.SetBytes(int64(total / b.N))
 15705  }
 15706  
 15707  func TestDeepTreeSize(t *testing.T) {
 15708  	seed := time.Now().UnixNano()
 15709  	popr := math_rand.New(math_rand.NewSource(seed))
 15710  	p := NewPopulatedDeepTree(popr, true)
 15711  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15712  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15713  	if err != nil {
 15714  		t.Fatalf("seed = %d, err = %v", seed, err)
 15715  	}
 15716  	size := p.Size()
 15717  	if len(dAtA) != size {
 15718  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15719  	}
 15720  	if size2 != size {
 15721  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15722  	}
 15723  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15724  	if size3 != size {
 15725  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15726  	}
 15727  }
 15728  
 15729  func BenchmarkDeepTreeSize(b *testing.B) {
 15730  	popr := math_rand.New(math_rand.NewSource(616))
 15731  	total := 0
 15732  	pops := make([]*DeepTree, 1000)
 15733  	for i := 0; i < 1000; i++ {
 15734  		pops[i] = NewPopulatedDeepTree(popr, false)
 15735  	}
 15736  	b.ResetTimer()
 15737  	for i := 0; i < b.N; i++ {
 15738  		total += pops[i%1000].Size()
 15739  	}
 15740  	b.SetBytes(int64(total / b.N))
 15741  }
 15742  
 15743  func TestADeepBranchSize(t *testing.T) {
 15744  	seed := time.Now().UnixNano()
 15745  	popr := math_rand.New(math_rand.NewSource(seed))
 15746  	p := NewPopulatedADeepBranch(popr, true)
 15747  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15748  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15749  	if err != nil {
 15750  		t.Fatalf("seed = %d, err = %v", seed, err)
 15751  	}
 15752  	size := p.Size()
 15753  	if len(dAtA) != size {
 15754  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15755  	}
 15756  	if size2 != size {
 15757  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15758  	}
 15759  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15760  	if size3 != size {
 15761  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15762  	}
 15763  }
 15764  
 15765  func BenchmarkADeepBranchSize(b *testing.B) {
 15766  	popr := math_rand.New(math_rand.NewSource(616))
 15767  	total := 0
 15768  	pops := make([]*ADeepBranch, 1000)
 15769  	for i := 0; i < 1000; i++ {
 15770  		pops[i] = NewPopulatedADeepBranch(popr, false)
 15771  	}
 15772  	b.ResetTimer()
 15773  	for i := 0; i < b.N; i++ {
 15774  		total += pops[i%1000].Size()
 15775  	}
 15776  	b.SetBytes(int64(total / b.N))
 15777  }
 15778  
 15779  func TestAndDeepBranchSize(t *testing.T) {
 15780  	seed := time.Now().UnixNano()
 15781  	popr := math_rand.New(math_rand.NewSource(seed))
 15782  	p := NewPopulatedAndDeepBranch(popr, true)
 15783  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15784  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15785  	if err != nil {
 15786  		t.Fatalf("seed = %d, err = %v", seed, err)
 15787  	}
 15788  	size := p.Size()
 15789  	if len(dAtA) != size {
 15790  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15791  	}
 15792  	if size2 != size {
 15793  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15794  	}
 15795  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15796  	if size3 != size {
 15797  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15798  	}
 15799  }
 15800  
 15801  func BenchmarkAndDeepBranchSize(b *testing.B) {
 15802  	popr := math_rand.New(math_rand.NewSource(616))
 15803  	total := 0
 15804  	pops := make([]*AndDeepBranch, 1000)
 15805  	for i := 0; i < 1000; i++ {
 15806  		pops[i] = NewPopulatedAndDeepBranch(popr, false)
 15807  	}
 15808  	b.ResetTimer()
 15809  	for i := 0; i < b.N; i++ {
 15810  		total += pops[i%1000].Size()
 15811  	}
 15812  	b.SetBytes(int64(total / b.N))
 15813  }
 15814  
 15815  func TestDeepLeafSize(t *testing.T) {
 15816  	seed := time.Now().UnixNano()
 15817  	popr := math_rand.New(math_rand.NewSource(seed))
 15818  	p := NewPopulatedDeepLeaf(popr, true)
 15819  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15820  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15821  	if err != nil {
 15822  		t.Fatalf("seed = %d, err = %v", seed, err)
 15823  	}
 15824  	size := p.Size()
 15825  	if len(dAtA) != size {
 15826  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15827  	}
 15828  	if size2 != size {
 15829  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15830  	}
 15831  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15832  	if size3 != size {
 15833  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15834  	}
 15835  }
 15836  
 15837  func BenchmarkDeepLeafSize(b *testing.B) {
 15838  	popr := math_rand.New(math_rand.NewSource(616))
 15839  	total := 0
 15840  	pops := make([]*DeepLeaf, 1000)
 15841  	for i := 0; i < 1000; i++ {
 15842  		pops[i] = NewPopulatedDeepLeaf(popr, false)
 15843  	}
 15844  	b.ResetTimer()
 15845  	for i := 0; i < b.N; i++ {
 15846  		total += pops[i%1000].Size()
 15847  	}
 15848  	b.SetBytes(int64(total / b.N))
 15849  }
 15850  
 15851  func TestNilSize(t *testing.T) {
 15852  	seed := time.Now().UnixNano()
 15853  	popr := math_rand.New(math_rand.NewSource(seed))
 15854  	p := NewPopulatedNil(popr, true)
 15855  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15856  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15857  	if err != nil {
 15858  		t.Fatalf("seed = %d, err = %v", seed, err)
 15859  	}
 15860  	size := p.Size()
 15861  	if len(dAtA) != size {
 15862  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15863  	}
 15864  	if size2 != size {
 15865  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15866  	}
 15867  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15868  	if size3 != size {
 15869  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15870  	}
 15871  }
 15872  
 15873  func BenchmarkNilSize(b *testing.B) {
 15874  	popr := math_rand.New(math_rand.NewSource(616))
 15875  	total := 0
 15876  	pops := make([]*Nil, 1000)
 15877  	for i := 0; i < 1000; i++ {
 15878  		pops[i] = NewPopulatedNil(popr, false)
 15879  	}
 15880  	b.ResetTimer()
 15881  	for i := 0; i < b.N; i++ {
 15882  		total += pops[i%1000].Size()
 15883  	}
 15884  	b.SetBytes(int64(total / b.N))
 15885  }
 15886  
 15887  func TestNidOptEnumSize(t *testing.T) {
 15888  	seed := time.Now().UnixNano()
 15889  	popr := math_rand.New(math_rand.NewSource(seed))
 15890  	p := NewPopulatedNidOptEnum(popr, true)
 15891  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15892  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15893  	if err != nil {
 15894  		t.Fatalf("seed = %d, err = %v", seed, err)
 15895  	}
 15896  	size := p.Size()
 15897  	if len(dAtA) != size {
 15898  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15899  	}
 15900  	if size2 != size {
 15901  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15902  	}
 15903  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15904  	if size3 != size {
 15905  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15906  	}
 15907  }
 15908  
 15909  func BenchmarkNidOptEnumSize(b *testing.B) {
 15910  	popr := math_rand.New(math_rand.NewSource(616))
 15911  	total := 0
 15912  	pops := make([]*NidOptEnum, 1000)
 15913  	for i := 0; i < 1000; i++ {
 15914  		pops[i] = NewPopulatedNidOptEnum(popr, false)
 15915  	}
 15916  	b.ResetTimer()
 15917  	for i := 0; i < b.N; i++ {
 15918  		total += pops[i%1000].Size()
 15919  	}
 15920  	b.SetBytes(int64(total / b.N))
 15921  }
 15922  
 15923  func TestNinOptEnumSize(t *testing.T) {
 15924  	seed := time.Now().UnixNano()
 15925  	popr := math_rand.New(math_rand.NewSource(seed))
 15926  	p := NewPopulatedNinOptEnum(popr, true)
 15927  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15928  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15929  	if err != nil {
 15930  		t.Fatalf("seed = %d, err = %v", seed, err)
 15931  	}
 15932  	size := p.Size()
 15933  	if len(dAtA) != size {
 15934  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15935  	}
 15936  	if size2 != size {
 15937  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15938  	}
 15939  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15940  	if size3 != size {
 15941  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15942  	}
 15943  }
 15944  
 15945  func BenchmarkNinOptEnumSize(b *testing.B) {
 15946  	popr := math_rand.New(math_rand.NewSource(616))
 15947  	total := 0
 15948  	pops := make([]*NinOptEnum, 1000)
 15949  	for i := 0; i < 1000; i++ {
 15950  		pops[i] = NewPopulatedNinOptEnum(popr, false)
 15951  	}
 15952  	b.ResetTimer()
 15953  	for i := 0; i < b.N; i++ {
 15954  		total += pops[i%1000].Size()
 15955  	}
 15956  	b.SetBytes(int64(total / b.N))
 15957  }
 15958  
 15959  func TestNidRepEnumSize(t *testing.T) {
 15960  	seed := time.Now().UnixNano()
 15961  	popr := math_rand.New(math_rand.NewSource(seed))
 15962  	p := NewPopulatedNidRepEnum(popr, true)
 15963  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15964  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15965  	if err != nil {
 15966  		t.Fatalf("seed = %d, err = %v", seed, err)
 15967  	}
 15968  	size := p.Size()
 15969  	if len(dAtA) != size {
 15970  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15971  	}
 15972  	if size2 != size {
 15973  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15974  	}
 15975  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15976  	if size3 != size {
 15977  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15978  	}
 15979  }
 15980  
 15981  func BenchmarkNidRepEnumSize(b *testing.B) {
 15982  	popr := math_rand.New(math_rand.NewSource(616))
 15983  	total := 0
 15984  	pops := make([]*NidRepEnum, 1000)
 15985  	for i := 0; i < 1000; i++ {
 15986  		pops[i] = NewPopulatedNidRepEnum(popr, false)
 15987  	}
 15988  	b.ResetTimer()
 15989  	for i := 0; i < b.N; i++ {
 15990  		total += pops[i%1000].Size()
 15991  	}
 15992  	b.SetBytes(int64(total / b.N))
 15993  }
 15994  
 15995  func TestNinRepEnumSize(t *testing.T) {
 15996  	seed := time.Now().UnixNano()
 15997  	popr := math_rand.New(math_rand.NewSource(seed))
 15998  	p := NewPopulatedNinRepEnum(popr, true)
 15999  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16000  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16001  	if err != nil {
 16002  		t.Fatalf("seed = %d, err = %v", seed, err)
 16003  	}
 16004  	size := p.Size()
 16005  	if len(dAtA) != size {
 16006  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16007  	}
 16008  	if size2 != size {
 16009  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16010  	}
 16011  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16012  	if size3 != size {
 16013  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16014  	}
 16015  }
 16016  
 16017  func BenchmarkNinRepEnumSize(b *testing.B) {
 16018  	popr := math_rand.New(math_rand.NewSource(616))
 16019  	total := 0
 16020  	pops := make([]*NinRepEnum, 1000)
 16021  	for i := 0; i < 1000; i++ {
 16022  		pops[i] = NewPopulatedNinRepEnum(popr, false)
 16023  	}
 16024  	b.ResetTimer()
 16025  	for i := 0; i < b.N; i++ {
 16026  		total += pops[i%1000].Size()
 16027  	}
 16028  	b.SetBytes(int64(total / b.N))
 16029  }
 16030  
 16031  func TestNinOptEnumDefaultSize(t *testing.T) {
 16032  	seed := time.Now().UnixNano()
 16033  	popr := math_rand.New(math_rand.NewSource(seed))
 16034  	p := NewPopulatedNinOptEnumDefault(popr, true)
 16035  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16036  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16037  	if err != nil {
 16038  		t.Fatalf("seed = %d, err = %v", seed, err)
 16039  	}
 16040  	size := p.Size()
 16041  	if len(dAtA) != size {
 16042  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16043  	}
 16044  	if size2 != size {
 16045  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16046  	}
 16047  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16048  	if size3 != size {
 16049  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16050  	}
 16051  }
 16052  
 16053  func BenchmarkNinOptEnumDefaultSize(b *testing.B) {
 16054  	popr := math_rand.New(math_rand.NewSource(616))
 16055  	total := 0
 16056  	pops := make([]*NinOptEnumDefault, 1000)
 16057  	for i := 0; i < 1000; i++ {
 16058  		pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
 16059  	}
 16060  	b.ResetTimer()
 16061  	for i := 0; i < b.N; i++ {
 16062  		total += pops[i%1000].Size()
 16063  	}
 16064  	b.SetBytes(int64(total / b.N))
 16065  }
 16066  
 16067  func TestAnotherNinOptEnumSize(t *testing.T) {
 16068  	seed := time.Now().UnixNano()
 16069  	popr := math_rand.New(math_rand.NewSource(seed))
 16070  	p := NewPopulatedAnotherNinOptEnum(popr, true)
 16071  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16072  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16073  	if err != nil {
 16074  		t.Fatalf("seed = %d, err = %v", seed, err)
 16075  	}
 16076  	size := p.Size()
 16077  	if len(dAtA) != size {
 16078  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16079  	}
 16080  	if size2 != size {
 16081  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16082  	}
 16083  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16084  	if size3 != size {
 16085  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16086  	}
 16087  }
 16088  
 16089  func BenchmarkAnotherNinOptEnumSize(b *testing.B) {
 16090  	popr := math_rand.New(math_rand.NewSource(616))
 16091  	total := 0
 16092  	pops := make([]*AnotherNinOptEnum, 1000)
 16093  	for i := 0; i < 1000; i++ {
 16094  		pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
 16095  	}
 16096  	b.ResetTimer()
 16097  	for i := 0; i < b.N; i++ {
 16098  		total += pops[i%1000].Size()
 16099  	}
 16100  	b.SetBytes(int64(total / b.N))
 16101  }
 16102  
 16103  func TestAnotherNinOptEnumDefaultSize(t *testing.T) {
 16104  	seed := time.Now().UnixNano()
 16105  	popr := math_rand.New(math_rand.NewSource(seed))
 16106  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
 16107  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16108  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16109  	if err != nil {
 16110  		t.Fatalf("seed = %d, err = %v", seed, err)
 16111  	}
 16112  	size := p.Size()
 16113  	if len(dAtA) != size {
 16114  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16115  	}
 16116  	if size2 != size {
 16117  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16118  	}
 16119  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16120  	if size3 != size {
 16121  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16122  	}
 16123  }
 16124  
 16125  func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) {
 16126  	popr := math_rand.New(math_rand.NewSource(616))
 16127  	total := 0
 16128  	pops := make([]*AnotherNinOptEnumDefault, 1000)
 16129  	for i := 0; i < 1000; i++ {
 16130  		pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
 16131  	}
 16132  	b.ResetTimer()
 16133  	for i := 0; i < b.N; i++ {
 16134  		total += pops[i%1000].Size()
 16135  	}
 16136  	b.SetBytes(int64(total / b.N))
 16137  }
 16138  
 16139  func TestTimerSize(t *testing.T) {
 16140  	seed := time.Now().UnixNano()
 16141  	popr := math_rand.New(math_rand.NewSource(seed))
 16142  	p := NewPopulatedTimer(popr, true)
 16143  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16144  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16145  	if err != nil {
 16146  		t.Fatalf("seed = %d, err = %v", seed, err)
 16147  	}
 16148  	size := p.Size()
 16149  	if len(dAtA) != size {
 16150  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16151  	}
 16152  	if size2 != size {
 16153  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16154  	}
 16155  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16156  	if size3 != size {
 16157  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16158  	}
 16159  }
 16160  
 16161  func BenchmarkTimerSize(b *testing.B) {
 16162  	popr := math_rand.New(math_rand.NewSource(616))
 16163  	total := 0
 16164  	pops := make([]*Timer, 1000)
 16165  	for i := 0; i < 1000; i++ {
 16166  		pops[i] = NewPopulatedTimer(popr, false)
 16167  	}
 16168  	b.ResetTimer()
 16169  	for i := 0; i < b.N; i++ {
 16170  		total += pops[i%1000].Size()
 16171  	}
 16172  	b.SetBytes(int64(total / b.N))
 16173  }
 16174  
 16175  func TestMyExtendableSize(t *testing.T) {
 16176  	seed := time.Now().UnixNano()
 16177  	popr := math_rand.New(math_rand.NewSource(seed))
 16178  	p := NewPopulatedMyExtendable(popr, true)
 16179  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16180  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16181  	if err != nil {
 16182  		t.Fatalf("seed = %d, err = %v", seed, err)
 16183  	}
 16184  	size := p.Size()
 16185  	if len(dAtA) != size {
 16186  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16187  	}
 16188  	if size2 != size {
 16189  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16190  	}
 16191  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16192  	if size3 != size {
 16193  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16194  	}
 16195  }
 16196  
 16197  func BenchmarkMyExtendableSize(b *testing.B) {
 16198  	popr := math_rand.New(math_rand.NewSource(616))
 16199  	total := 0
 16200  	pops := make([]*MyExtendable, 1000)
 16201  	for i := 0; i < 1000; i++ {
 16202  		pops[i] = NewPopulatedMyExtendable(popr, false)
 16203  	}
 16204  	b.ResetTimer()
 16205  	for i := 0; i < b.N; i++ {
 16206  		total += pops[i%1000].Size()
 16207  	}
 16208  	b.SetBytes(int64(total / b.N))
 16209  }
 16210  
 16211  func TestOtherExtenableSize(t *testing.T) {
 16212  	seed := time.Now().UnixNano()
 16213  	popr := math_rand.New(math_rand.NewSource(seed))
 16214  	p := NewPopulatedOtherExtenable(popr, true)
 16215  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16216  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16217  	if err != nil {
 16218  		t.Fatalf("seed = %d, err = %v", seed, err)
 16219  	}
 16220  	size := p.Size()
 16221  	if len(dAtA) != size {
 16222  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16223  	}
 16224  	if size2 != size {
 16225  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16226  	}
 16227  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16228  	if size3 != size {
 16229  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16230  	}
 16231  }
 16232  
 16233  func BenchmarkOtherExtenableSize(b *testing.B) {
 16234  	popr := math_rand.New(math_rand.NewSource(616))
 16235  	total := 0
 16236  	pops := make([]*OtherExtenable, 1000)
 16237  	for i := 0; i < 1000; i++ {
 16238  		pops[i] = NewPopulatedOtherExtenable(popr, false)
 16239  	}
 16240  	b.ResetTimer()
 16241  	for i := 0; i < b.N; i++ {
 16242  		total += pops[i%1000].Size()
 16243  	}
 16244  	b.SetBytes(int64(total / b.N))
 16245  }
 16246  
 16247  func TestNestedDefinitionSize(t *testing.T) {
 16248  	seed := time.Now().UnixNano()
 16249  	popr := math_rand.New(math_rand.NewSource(seed))
 16250  	p := NewPopulatedNestedDefinition(popr, true)
 16251  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16252  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16253  	if err != nil {
 16254  		t.Fatalf("seed = %d, err = %v", seed, err)
 16255  	}
 16256  	size := p.Size()
 16257  	if len(dAtA) != size {
 16258  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16259  	}
 16260  	if size2 != size {
 16261  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16262  	}
 16263  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16264  	if size3 != size {
 16265  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16266  	}
 16267  }
 16268  
 16269  func BenchmarkNestedDefinitionSize(b *testing.B) {
 16270  	popr := math_rand.New(math_rand.NewSource(616))
 16271  	total := 0
 16272  	pops := make([]*NestedDefinition, 1000)
 16273  	for i := 0; i < 1000; i++ {
 16274  		pops[i] = NewPopulatedNestedDefinition(popr, false)
 16275  	}
 16276  	b.ResetTimer()
 16277  	for i := 0; i < b.N; i++ {
 16278  		total += pops[i%1000].Size()
 16279  	}
 16280  	b.SetBytes(int64(total / b.N))
 16281  }
 16282  
 16283  func TestNestedDefinition_NestedMessageSize(t *testing.T) {
 16284  	seed := time.Now().UnixNano()
 16285  	popr := math_rand.New(math_rand.NewSource(seed))
 16286  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
 16287  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16288  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16289  	if err != nil {
 16290  		t.Fatalf("seed = %d, err = %v", seed, err)
 16291  	}
 16292  	size := p.Size()
 16293  	if len(dAtA) != size {
 16294  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16295  	}
 16296  	if size2 != size {
 16297  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16298  	}
 16299  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16300  	if size3 != size {
 16301  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16302  	}
 16303  }
 16304  
 16305  func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) {
 16306  	popr := math_rand.New(math_rand.NewSource(616))
 16307  	total := 0
 16308  	pops := make([]*NestedDefinition_NestedMessage, 1000)
 16309  	for i := 0; i < 1000; i++ {
 16310  		pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
 16311  	}
 16312  	b.ResetTimer()
 16313  	for i := 0; i < b.N; i++ {
 16314  		total += pops[i%1000].Size()
 16315  	}
 16316  	b.SetBytes(int64(total / b.N))
 16317  }
 16318  
 16319  func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) {
 16320  	seed := time.Now().UnixNano()
 16321  	popr := math_rand.New(math_rand.NewSource(seed))
 16322  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
 16323  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16324  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16325  	if err != nil {
 16326  		t.Fatalf("seed = %d, err = %v", seed, err)
 16327  	}
 16328  	size := p.Size()
 16329  	if len(dAtA) != size {
 16330  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16331  	}
 16332  	if size2 != size {
 16333  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16334  	}
 16335  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16336  	if size3 != size {
 16337  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16338  	}
 16339  }
 16340  
 16341  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) {
 16342  	popr := math_rand.New(math_rand.NewSource(616))
 16343  	total := 0
 16344  	pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000)
 16345  	for i := 0; i < 1000; i++ {
 16346  		pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 16347  	}
 16348  	b.ResetTimer()
 16349  	for i := 0; i < b.N; i++ {
 16350  		total += pops[i%1000].Size()
 16351  	}
 16352  	b.SetBytes(int64(total / b.N))
 16353  }
 16354  
 16355  func TestNestedScopeSize(t *testing.T) {
 16356  	seed := time.Now().UnixNano()
 16357  	popr := math_rand.New(math_rand.NewSource(seed))
 16358  	p := NewPopulatedNestedScope(popr, true)
 16359  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16360  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16361  	if err != nil {
 16362  		t.Fatalf("seed = %d, err = %v", seed, err)
 16363  	}
 16364  	size := p.Size()
 16365  	if len(dAtA) != size {
 16366  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16367  	}
 16368  	if size2 != size {
 16369  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16370  	}
 16371  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16372  	if size3 != size {
 16373  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16374  	}
 16375  }
 16376  
 16377  func BenchmarkNestedScopeSize(b *testing.B) {
 16378  	popr := math_rand.New(math_rand.NewSource(616))
 16379  	total := 0
 16380  	pops := make([]*NestedScope, 1000)
 16381  	for i := 0; i < 1000; i++ {
 16382  		pops[i] = NewPopulatedNestedScope(popr, false)
 16383  	}
 16384  	b.ResetTimer()
 16385  	for i := 0; i < b.N; i++ {
 16386  		total += pops[i%1000].Size()
 16387  	}
 16388  	b.SetBytes(int64(total / b.N))
 16389  }
 16390  
 16391  func TestNinOptNativeDefaultSize(t *testing.T) {
 16392  	seed := time.Now().UnixNano()
 16393  	popr := math_rand.New(math_rand.NewSource(seed))
 16394  	p := NewPopulatedNinOptNativeDefault(popr, true)
 16395  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16396  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16397  	if err != nil {
 16398  		t.Fatalf("seed = %d, err = %v", seed, err)
 16399  	}
 16400  	size := p.Size()
 16401  	if len(dAtA) != size {
 16402  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16403  	}
 16404  	if size2 != size {
 16405  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16406  	}
 16407  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16408  	if size3 != size {
 16409  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16410  	}
 16411  }
 16412  
 16413  func BenchmarkNinOptNativeDefaultSize(b *testing.B) {
 16414  	popr := math_rand.New(math_rand.NewSource(616))
 16415  	total := 0
 16416  	pops := make([]*NinOptNativeDefault, 1000)
 16417  	for i := 0; i < 1000; i++ {
 16418  		pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
 16419  	}
 16420  	b.ResetTimer()
 16421  	for i := 0; i < b.N; i++ {
 16422  		total += pops[i%1000].Size()
 16423  	}
 16424  	b.SetBytes(int64(total / b.N))
 16425  }
 16426  
 16427  func TestCustomContainerSize(t *testing.T) {
 16428  	seed := time.Now().UnixNano()
 16429  	popr := math_rand.New(math_rand.NewSource(seed))
 16430  	p := NewPopulatedCustomContainer(popr, true)
 16431  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16432  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16433  	if err != nil {
 16434  		t.Fatalf("seed = %d, err = %v", seed, err)
 16435  	}
 16436  	size := p.Size()
 16437  	if len(dAtA) != size {
 16438  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16439  	}
 16440  	if size2 != size {
 16441  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16442  	}
 16443  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16444  	if size3 != size {
 16445  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16446  	}
 16447  }
 16448  
 16449  func BenchmarkCustomContainerSize(b *testing.B) {
 16450  	popr := math_rand.New(math_rand.NewSource(616))
 16451  	total := 0
 16452  	pops := make([]*CustomContainer, 1000)
 16453  	for i := 0; i < 1000; i++ {
 16454  		pops[i] = NewPopulatedCustomContainer(popr, false)
 16455  	}
 16456  	b.ResetTimer()
 16457  	for i := 0; i < b.N; i++ {
 16458  		total += pops[i%1000].Size()
 16459  	}
 16460  	b.SetBytes(int64(total / b.N))
 16461  }
 16462  
 16463  func TestCustomNameNidOptNativeSize(t *testing.T) {
 16464  	seed := time.Now().UnixNano()
 16465  	popr := math_rand.New(math_rand.NewSource(seed))
 16466  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 16467  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16468  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16469  	if err != nil {
 16470  		t.Fatalf("seed = %d, err = %v", seed, err)
 16471  	}
 16472  	size := p.Size()
 16473  	if len(dAtA) != size {
 16474  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16475  	}
 16476  	if size2 != size {
 16477  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16478  	}
 16479  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16480  	if size3 != size {
 16481  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16482  	}
 16483  }
 16484  
 16485  func BenchmarkCustomNameNidOptNativeSize(b *testing.B) {
 16486  	popr := math_rand.New(math_rand.NewSource(616))
 16487  	total := 0
 16488  	pops := make([]*CustomNameNidOptNative, 1000)
 16489  	for i := 0; i < 1000; i++ {
 16490  		pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
 16491  	}
 16492  	b.ResetTimer()
 16493  	for i := 0; i < b.N; i++ {
 16494  		total += pops[i%1000].Size()
 16495  	}
 16496  	b.SetBytes(int64(total / b.N))
 16497  }
 16498  
 16499  func TestCustomNameNinOptNativeSize(t *testing.T) {
 16500  	seed := time.Now().UnixNano()
 16501  	popr := math_rand.New(math_rand.NewSource(seed))
 16502  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 16503  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16504  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16505  	if err != nil {
 16506  		t.Fatalf("seed = %d, err = %v", seed, err)
 16507  	}
 16508  	size := p.Size()
 16509  	if len(dAtA) != size {
 16510  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16511  	}
 16512  	if size2 != size {
 16513  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16514  	}
 16515  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16516  	if size3 != size {
 16517  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16518  	}
 16519  }
 16520  
 16521  func BenchmarkCustomNameNinOptNativeSize(b *testing.B) {
 16522  	popr := math_rand.New(math_rand.NewSource(616))
 16523  	total := 0
 16524  	pops := make([]*CustomNameNinOptNative, 1000)
 16525  	for i := 0; i < 1000; i++ {
 16526  		pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
 16527  	}
 16528  	b.ResetTimer()
 16529  	for i := 0; i < b.N; i++ {
 16530  		total += pops[i%1000].Size()
 16531  	}
 16532  	b.SetBytes(int64(total / b.N))
 16533  }
 16534  
 16535  func TestCustomNameNinRepNativeSize(t *testing.T) {
 16536  	seed := time.Now().UnixNano()
 16537  	popr := math_rand.New(math_rand.NewSource(seed))
 16538  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 16539  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16540  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16541  	if err != nil {
 16542  		t.Fatalf("seed = %d, err = %v", seed, err)
 16543  	}
 16544  	size := p.Size()
 16545  	if len(dAtA) != size {
 16546  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16547  	}
 16548  	if size2 != size {
 16549  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16550  	}
 16551  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16552  	if size3 != size {
 16553  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16554  	}
 16555  }
 16556  
 16557  func BenchmarkCustomNameNinRepNativeSize(b *testing.B) {
 16558  	popr := math_rand.New(math_rand.NewSource(616))
 16559  	total := 0
 16560  	pops := make([]*CustomNameNinRepNative, 1000)
 16561  	for i := 0; i < 1000; i++ {
 16562  		pops[i] = NewPopulatedCustomNameNinRepNative(popr, false)
 16563  	}
 16564  	b.ResetTimer()
 16565  	for i := 0; i < b.N; i++ {
 16566  		total += pops[i%1000].Size()
 16567  	}
 16568  	b.SetBytes(int64(total / b.N))
 16569  }
 16570  
 16571  func TestCustomNameNinStructSize(t *testing.T) {
 16572  	seed := time.Now().UnixNano()
 16573  	popr := math_rand.New(math_rand.NewSource(seed))
 16574  	p := NewPopulatedCustomNameNinStruct(popr, true)
 16575  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16576  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16577  	if err != nil {
 16578  		t.Fatalf("seed = %d, err = %v", seed, err)
 16579  	}
 16580  	size := p.Size()
 16581  	if len(dAtA) != size {
 16582  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16583  	}
 16584  	if size2 != size {
 16585  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16586  	}
 16587  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16588  	if size3 != size {
 16589  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16590  	}
 16591  }
 16592  
 16593  func BenchmarkCustomNameNinStructSize(b *testing.B) {
 16594  	popr := math_rand.New(math_rand.NewSource(616))
 16595  	total := 0
 16596  	pops := make([]*CustomNameNinStruct, 1000)
 16597  	for i := 0; i < 1000; i++ {
 16598  		pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
 16599  	}
 16600  	b.ResetTimer()
 16601  	for i := 0; i < b.N; i++ {
 16602  		total += pops[i%1000].Size()
 16603  	}
 16604  	b.SetBytes(int64(total / b.N))
 16605  }
 16606  
 16607  func TestCustomNameCustomTypeSize(t *testing.T) {
 16608  	seed := time.Now().UnixNano()
 16609  	popr := math_rand.New(math_rand.NewSource(seed))
 16610  	p := NewPopulatedCustomNameCustomType(popr, true)
 16611  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16612  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16613  	if err != nil {
 16614  		t.Fatalf("seed = %d, err = %v", seed, err)
 16615  	}
 16616  	size := p.Size()
 16617  	if len(dAtA) != size {
 16618  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16619  	}
 16620  	if size2 != size {
 16621  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16622  	}
 16623  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16624  	if size3 != size {
 16625  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16626  	}
 16627  }
 16628  
 16629  func BenchmarkCustomNameCustomTypeSize(b *testing.B) {
 16630  	popr := math_rand.New(math_rand.NewSource(616))
 16631  	total := 0
 16632  	pops := make([]*CustomNameCustomType, 1000)
 16633  	for i := 0; i < 1000; i++ {
 16634  		pops[i] = NewPopulatedCustomNameCustomType(popr, false)
 16635  	}
 16636  	b.ResetTimer()
 16637  	for i := 0; i < b.N; i++ {
 16638  		total += pops[i%1000].Size()
 16639  	}
 16640  	b.SetBytes(int64(total / b.N))
 16641  }
 16642  
 16643  func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) {
 16644  	seed := time.Now().UnixNano()
 16645  	popr := math_rand.New(math_rand.NewSource(seed))
 16646  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 16647  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16648  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16649  	if err != nil {
 16650  		t.Fatalf("seed = %d, err = %v", seed, err)
 16651  	}
 16652  	size := p.Size()
 16653  	if len(dAtA) != size {
 16654  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16655  	}
 16656  	if size2 != size {
 16657  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16658  	}
 16659  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16660  	if size3 != size {
 16661  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16662  	}
 16663  }
 16664  
 16665  func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) {
 16666  	popr := math_rand.New(math_rand.NewSource(616))
 16667  	total := 0
 16668  	pops := make([]*CustomNameNinEmbeddedStructUnion, 1000)
 16669  	for i := 0; i < 1000; i++ {
 16670  		pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 16671  	}
 16672  	b.ResetTimer()
 16673  	for i := 0; i < b.N; i++ {
 16674  		total += pops[i%1000].Size()
 16675  	}
 16676  	b.SetBytes(int64(total / b.N))
 16677  }
 16678  
 16679  func TestCustomNameEnumSize(t *testing.T) {
 16680  	seed := time.Now().UnixNano()
 16681  	popr := math_rand.New(math_rand.NewSource(seed))
 16682  	p := NewPopulatedCustomNameEnum(popr, true)
 16683  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16684  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16685  	if err != nil {
 16686  		t.Fatalf("seed = %d, err = %v", seed, err)
 16687  	}
 16688  	size := p.Size()
 16689  	if len(dAtA) != size {
 16690  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16691  	}
 16692  	if size2 != size {
 16693  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16694  	}
 16695  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16696  	if size3 != size {
 16697  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16698  	}
 16699  }
 16700  
 16701  func BenchmarkCustomNameEnumSize(b *testing.B) {
 16702  	popr := math_rand.New(math_rand.NewSource(616))
 16703  	total := 0
 16704  	pops := make([]*CustomNameEnum, 1000)
 16705  	for i := 0; i < 1000; i++ {
 16706  		pops[i] = NewPopulatedCustomNameEnum(popr, false)
 16707  	}
 16708  	b.ResetTimer()
 16709  	for i := 0; i < b.N; i++ {
 16710  		total += pops[i%1000].Size()
 16711  	}
 16712  	b.SetBytes(int64(total / b.N))
 16713  }
 16714  
 16715  func TestNoExtensionsMapSize(t *testing.T) {
 16716  	seed := time.Now().UnixNano()
 16717  	popr := math_rand.New(math_rand.NewSource(seed))
 16718  	p := NewPopulatedNoExtensionsMap(popr, true)
 16719  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16720  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16721  	if err != nil {
 16722  		t.Fatalf("seed = %d, err = %v", seed, err)
 16723  	}
 16724  	size := p.Size()
 16725  	if len(dAtA) != size {
 16726  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16727  	}
 16728  	if size2 != size {
 16729  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16730  	}
 16731  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16732  	if size3 != size {
 16733  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16734  	}
 16735  }
 16736  
 16737  func BenchmarkNoExtensionsMapSize(b *testing.B) {
 16738  	popr := math_rand.New(math_rand.NewSource(616))
 16739  	total := 0
 16740  	pops := make([]*NoExtensionsMap, 1000)
 16741  	for i := 0; i < 1000; i++ {
 16742  		pops[i] = NewPopulatedNoExtensionsMap(popr, false)
 16743  	}
 16744  	b.ResetTimer()
 16745  	for i := 0; i < b.N; i++ {
 16746  		total += pops[i%1000].Size()
 16747  	}
 16748  	b.SetBytes(int64(total / b.N))
 16749  }
 16750  
 16751  func TestUnrecognizedSize(t *testing.T) {
 16752  	seed := time.Now().UnixNano()
 16753  	popr := math_rand.New(math_rand.NewSource(seed))
 16754  	p := NewPopulatedUnrecognized(popr, true)
 16755  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16756  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16757  	if err != nil {
 16758  		t.Fatalf("seed = %d, err = %v", seed, err)
 16759  	}
 16760  	size := p.Size()
 16761  	if len(dAtA) != size {
 16762  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16763  	}
 16764  	if size2 != size {
 16765  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16766  	}
 16767  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16768  	if size3 != size {
 16769  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16770  	}
 16771  }
 16772  
 16773  func BenchmarkUnrecognizedSize(b *testing.B) {
 16774  	popr := math_rand.New(math_rand.NewSource(616))
 16775  	total := 0
 16776  	pops := make([]*Unrecognized, 1000)
 16777  	for i := 0; i < 1000; i++ {
 16778  		pops[i] = NewPopulatedUnrecognized(popr, false)
 16779  	}
 16780  	b.ResetTimer()
 16781  	for i := 0; i < b.N; i++ {
 16782  		total += pops[i%1000].Size()
 16783  	}
 16784  	b.SetBytes(int64(total / b.N))
 16785  }
 16786  
 16787  func TestUnrecognizedWithInnerSize(t *testing.T) {
 16788  	seed := time.Now().UnixNano()
 16789  	popr := math_rand.New(math_rand.NewSource(seed))
 16790  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 16791  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16792  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16793  	if err != nil {
 16794  		t.Fatalf("seed = %d, err = %v", seed, err)
 16795  	}
 16796  	size := p.Size()
 16797  	if len(dAtA) != size {
 16798  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16799  	}
 16800  	if size2 != size {
 16801  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16802  	}
 16803  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16804  	if size3 != size {
 16805  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16806  	}
 16807  }
 16808  
 16809  func BenchmarkUnrecognizedWithInnerSize(b *testing.B) {
 16810  	popr := math_rand.New(math_rand.NewSource(616))
 16811  	total := 0
 16812  	pops := make([]*UnrecognizedWithInner, 1000)
 16813  	for i := 0; i < 1000; i++ {
 16814  		pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
 16815  	}
 16816  	b.ResetTimer()
 16817  	for i := 0; i < b.N; i++ {
 16818  		total += pops[i%1000].Size()
 16819  	}
 16820  	b.SetBytes(int64(total / b.N))
 16821  }
 16822  
 16823  func TestUnrecognizedWithInner_InnerSize(t *testing.T) {
 16824  	seed := time.Now().UnixNano()
 16825  	popr := math_rand.New(math_rand.NewSource(seed))
 16826  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 16827  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16828  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16829  	if err != nil {
 16830  		t.Fatalf("seed = %d, err = %v", seed, err)
 16831  	}
 16832  	size := p.Size()
 16833  	if len(dAtA) != size {
 16834  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16835  	}
 16836  	if size2 != size {
 16837  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16838  	}
 16839  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16840  	if size3 != size {
 16841  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16842  	}
 16843  }
 16844  
 16845  func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) {
 16846  	popr := math_rand.New(math_rand.NewSource(616))
 16847  	total := 0
 16848  	pops := make([]*UnrecognizedWithInner_Inner, 1000)
 16849  	for i := 0; i < 1000; i++ {
 16850  		pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 16851  	}
 16852  	b.ResetTimer()
 16853  	for i := 0; i < b.N; i++ {
 16854  		total += pops[i%1000].Size()
 16855  	}
 16856  	b.SetBytes(int64(total / b.N))
 16857  }
 16858  
 16859  func TestUnrecognizedWithEmbedSize(t *testing.T) {
 16860  	seed := time.Now().UnixNano()
 16861  	popr := math_rand.New(math_rand.NewSource(seed))
 16862  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 16863  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16864  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16865  	if err != nil {
 16866  		t.Fatalf("seed = %d, err = %v", seed, err)
 16867  	}
 16868  	size := p.Size()
 16869  	if len(dAtA) != size {
 16870  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16871  	}
 16872  	if size2 != size {
 16873  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16874  	}
 16875  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16876  	if size3 != size {
 16877  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16878  	}
 16879  }
 16880  
 16881  func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) {
 16882  	popr := math_rand.New(math_rand.NewSource(616))
 16883  	total := 0
 16884  	pops := make([]*UnrecognizedWithEmbed, 1000)
 16885  	for i := 0; i < 1000; i++ {
 16886  		pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
 16887  	}
 16888  	b.ResetTimer()
 16889  	for i := 0; i < b.N; i++ {
 16890  		total += pops[i%1000].Size()
 16891  	}
 16892  	b.SetBytes(int64(total / b.N))
 16893  }
 16894  
 16895  func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) {
 16896  	seed := time.Now().UnixNano()
 16897  	popr := math_rand.New(math_rand.NewSource(seed))
 16898  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 16899  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16900  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16901  	if err != nil {
 16902  		t.Fatalf("seed = %d, err = %v", seed, err)
 16903  	}
 16904  	size := p.Size()
 16905  	if len(dAtA) != size {
 16906  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16907  	}
 16908  	if size2 != size {
 16909  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16910  	}
 16911  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16912  	if size3 != size {
 16913  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16914  	}
 16915  }
 16916  
 16917  func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) {
 16918  	popr := math_rand.New(math_rand.NewSource(616))
 16919  	total := 0
 16920  	pops := make([]*UnrecognizedWithEmbed_Embedded, 1000)
 16921  	for i := 0; i < 1000; i++ {
 16922  		pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 16923  	}
 16924  	b.ResetTimer()
 16925  	for i := 0; i < b.N; i++ {
 16926  		total += pops[i%1000].Size()
 16927  	}
 16928  	b.SetBytes(int64(total / b.N))
 16929  }
 16930  
 16931  func TestNodeSize(t *testing.T) {
 16932  	seed := time.Now().UnixNano()
 16933  	popr := math_rand.New(math_rand.NewSource(seed))
 16934  	p := NewPopulatedNode(popr, true)
 16935  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16936  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16937  	if err != nil {
 16938  		t.Fatalf("seed = %d, err = %v", seed, err)
 16939  	}
 16940  	size := p.Size()
 16941  	if len(dAtA) != size {
 16942  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16943  	}
 16944  	if size2 != size {
 16945  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16946  	}
 16947  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16948  	if size3 != size {
 16949  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16950  	}
 16951  }
 16952  
 16953  func BenchmarkNodeSize(b *testing.B) {
 16954  	popr := math_rand.New(math_rand.NewSource(616))
 16955  	total := 0
 16956  	pops := make([]*Node, 1000)
 16957  	for i := 0; i < 1000; i++ {
 16958  		pops[i] = NewPopulatedNode(popr, false)
 16959  	}
 16960  	b.ResetTimer()
 16961  	for i := 0; i < b.N; i++ {
 16962  		total += pops[i%1000].Size()
 16963  	}
 16964  	b.SetBytes(int64(total / b.N))
 16965  }
 16966  
 16967  func TestNonByteCustomTypeSize(t *testing.T) {
 16968  	seed := time.Now().UnixNano()
 16969  	popr := math_rand.New(math_rand.NewSource(seed))
 16970  	p := NewPopulatedNonByteCustomType(popr, true)
 16971  	size2 := github_com_gogo_protobuf_proto.Size(p)
 16972  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 16973  	if err != nil {
 16974  		t.Fatalf("seed = %d, err = %v", seed, err)
 16975  	}
 16976  	size := p.Size()
 16977  	if len(dAtA) != size {
 16978  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 16979  	}
 16980  	if size2 != size {
 16981  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 16982  	}
 16983  	size3 := github_com_gogo_protobuf_proto.Size(p)
 16984  	if size3 != size {
 16985  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 16986  	}
 16987  }
 16988  
 16989  func BenchmarkNonByteCustomTypeSize(b *testing.B) {
 16990  	popr := math_rand.New(math_rand.NewSource(616))
 16991  	total := 0
 16992  	pops := make([]*NonByteCustomType, 1000)
 16993  	for i := 0; i < 1000; i++ {
 16994  		pops[i] = NewPopulatedNonByteCustomType(popr, false)
 16995  	}
 16996  	b.ResetTimer()
 16997  	for i := 0; i < b.N; i++ {
 16998  		total += pops[i%1000].Size()
 16999  	}
 17000  	b.SetBytes(int64(total / b.N))
 17001  }
 17002  
 17003  func TestNidOptNonByteCustomTypeSize(t *testing.T) {
 17004  	seed := time.Now().UnixNano()
 17005  	popr := math_rand.New(math_rand.NewSource(seed))
 17006  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 17007  	size2 := github_com_gogo_protobuf_proto.Size(p)
 17008  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 17009  	if err != nil {
 17010  		t.Fatalf("seed = %d, err = %v", seed, err)
 17011  	}
 17012  	size := p.Size()
 17013  	if len(dAtA) != size {
 17014  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 17015  	}
 17016  	if size2 != size {
 17017  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 17018  	}
 17019  	size3 := github_com_gogo_protobuf_proto.Size(p)
 17020  	if size3 != size {
 17021  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 17022  	}
 17023  }
 17024  
 17025  func BenchmarkNidOptNonByteCustomTypeSize(b *testing.B) {
 17026  	popr := math_rand.New(math_rand.NewSource(616))
 17027  	total := 0
 17028  	pops := make([]*NidOptNonByteCustomType, 1000)
 17029  	for i := 0; i < 1000; i++ {
 17030  		pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
 17031  	}
 17032  	b.ResetTimer()
 17033  	for i := 0; i < b.N; i++ {
 17034  		total += pops[i%1000].Size()
 17035  	}
 17036  	b.SetBytes(int64(total / b.N))
 17037  }
 17038  
 17039  func TestNinOptNonByteCustomTypeSize(t *testing.T) {
 17040  	seed := time.Now().UnixNano()
 17041  	popr := math_rand.New(math_rand.NewSource(seed))
 17042  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 17043  	size2 := github_com_gogo_protobuf_proto.Size(p)
 17044  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 17045  	if err != nil {
 17046  		t.Fatalf("seed = %d, err = %v", seed, err)
 17047  	}
 17048  	size := p.Size()
 17049  	if len(dAtA) != size {
 17050  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 17051  	}
 17052  	if size2 != size {
 17053  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 17054  	}
 17055  	size3 := github_com_gogo_protobuf_proto.Size(p)
 17056  	if size3 != size {
 17057  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 17058  	}
 17059  }
 17060  
 17061  func BenchmarkNinOptNonByteCustomTypeSize(b *testing.B) {
 17062  	popr := math_rand.New(math_rand.NewSource(616))
 17063  	total := 0
 17064  	pops := make([]*NinOptNonByteCustomType, 1000)
 17065  	for i := 0; i < 1000; i++ {
 17066  		pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
 17067  	}
 17068  	b.ResetTimer()
 17069  	for i := 0; i < b.N; i++ {
 17070  		total += pops[i%1000].Size()
 17071  	}
 17072  	b.SetBytes(int64(total / b.N))
 17073  }
 17074  
 17075  func TestNidRepNonByteCustomTypeSize(t *testing.T) {
 17076  	seed := time.Now().UnixNano()
 17077  	popr := math_rand.New(math_rand.NewSource(seed))
 17078  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 17079  	size2 := github_com_gogo_protobuf_proto.Size(p)
 17080  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 17081  	if err != nil {
 17082  		t.Fatalf("seed = %d, err = %v", seed, err)
 17083  	}
 17084  	size := p.Size()
 17085  	if len(dAtA) != size {
 17086  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 17087  	}
 17088  	if size2 != size {
 17089  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 17090  	}
 17091  	size3 := github_com_gogo_protobuf_proto.Size(p)
 17092  	if size3 != size {
 17093  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 17094  	}
 17095  }
 17096  
 17097  func BenchmarkNidRepNonByteCustomTypeSize(b *testing.B) {
 17098  	popr := math_rand.New(math_rand.NewSource(616))
 17099  	total := 0
 17100  	pops := make([]*NidRepNonByteCustomType, 1000)
 17101  	for i := 0; i < 1000; i++ {
 17102  		pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
 17103  	}
 17104  	b.ResetTimer()
 17105  	for i := 0; i < b.N; i++ {
 17106  		total += pops[i%1000].Size()
 17107  	}
 17108  	b.SetBytes(int64(total / b.N))
 17109  }
 17110  
 17111  func TestNinRepNonByteCustomTypeSize(t *testing.T) {
 17112  	seed := time.Now().UnixNano()
 17113  	popr := math_rand.New(math_rand.NewSource(seed))
 17114  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 17115  	size2 := github_com_gogo_protobuf_proto.Size(p)
 17116  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 17117  	if err != nil {
 17118  		t.Fatalf("seed = %d, err = %v", seed, err)
 17119  	}
 17120  	size := p.Size()
 17121  	if len(dAtA) != size {
 17122  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 17123  	}
 17124  	if size2 != size {
 17125  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 17126  	}
 17127  	size3 := github_com_gogo_protobuf_proto.Size(p)
 17128  	if size3 != size {
 17129  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 17130  	}
 17131  }
 17132  
 17133  func BenchmarkNinRepNonByteCustomTypeSize(b *testing.B) {
 17134  	popr := math_rand.New(math_rand.NewSource(616))
 17135  	total := 0
 17136  	pops := make([]*NinRepNonByteCustomType, 1000)
 17137  	for i := 0; i < 1000; i++ {
 17138  		pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
 17139  	}
 17140  	b.ResetTimer()
 17141  	for i := 0; i < b.N; i++ {
 17142  		total += pops[i%1000].Size()
 17143  	}
 17144  	b.SetBytes(int64(total / b.N))
 17145  }
 17146  
 17147  func TestProtoTypeSize(t *testing.T) {
 17148  	seed := time.Now().UnixNano()
 17149  	popr := math_rand.New(math_rand.NewSource(seed))
 17150  	p := NewPopulatedProtoType(popr, true)
 17151  	size2 := github_com_gogo_protobuf_proto.Size(p)
 17152  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 17153  	if err != nil {
 17154  		t.Fatalf("seed = %d, err = %v", seed, err)
 17155  	}
 17156  	size := p.Size()
 17157  	if len(dAtA) != size {
 17158  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 17159  	}
 17160  	if size2 != size {
 17161  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 17162  	}
 17163  	size3 := github_com_gogo_protobuf_proto.Size(p)
 17164  	if size3 != size {
 17165  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 17166  	}
 17167  }
 17168  
 17169  func BenchmarkProtoTypeSize(b *testing.B) {
 17170  	popr := math_rand.New(math_rand.NewSource(616))
 17171  	total := 0
 17172  	pops := make([]*ProtoType, 1000)
 17173  	for i := 0; i < 1000; i++ {
 17174  		pops[i] = NewPopulatedProtoType(popr, false)
 17175  	}
 17176  	b.ResetTimer()
 17177  	for i := 0; i < b.N; i++ {
 17178  		total += pops[i%1000].Size()
 17179  	}
 17180  	b.SetBytes(int64(total / b.N))
 17181  }
 17182  
 17183  func TestNidOptNativeStringer(t *testing.T) {
 17184  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17185  	p := NewPopulatedNidOptNative(popr, false)
 17186  	s1 := p.String()
 17187  	s2 := fmt.Sprintf("%v", p)
 17188  	if s1 != s2 {
 17189  		t.Fatalf("String want %v got %v", s1, s2)
 17190  	}
 17191  }
 17192  func TestNinOptNativeStringer(t *testing.T) {
 17193  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17194  	p := NewPopulatedNinOptNative(popr, false)
 17195  	s1 := p.String()
 17196  	s2 := fmt.Sprintf("%v", p)
 17197  	if s1 != s2 {
 17198  		t.Fatalf("String want %v got %v", s1, s2)
 17199  	}
 17200  }
 17201  func TestNidRepNativeStringer(t *testing.T) {
 17202  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17203  	p := NewPopulatedNidRepNative(popr, false)
 17204  	s1 := p.String()
 17205  	s2 := fmt.Sprintf("%v", p)
 17206  	if s1 != s2 {
 17207  		t.Fatalf("String want %v got %v", s1, s2)
 17208  	}
 17209  }
 17210  func TestNinRepNativeStringer(t *testing.T) {
 17211  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17212  	p := NewPopulatedNinRepNative(popr, false)
 17213  	s1 := p.String()
 17214  	s2 := fmt.Sprintf("%v", p)
 17215  	if s1 != s2 {
 17216  		t.Fatalf("String want %v got %v", s1, s2)
 17217  	}
 17218  }
 17219  func TestNidRepPackedNativeStringer(t *testing.T) {
 17220  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17221  	p := NewPopulatedNidRepPackedNative(popr, false)
 17222  	s1 := p.String()
 17223  	s2 := fmt.Sprintf("%v", p)
 17224  	if s1 != s2 {
 17225  		t.Fatalf("String want %v got %v", s1, s2)
 17226  	}
 17227  }
 17228  func TestNinRepPackedNativeStringer(t *testing.T) {
 17229  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17230  	p := NewPopulatedNinRepPackedNative(popr, false)
 17231  	s1 := p.String()
 17232  	s2 := fmt.Sprintf("%v", p)
 17233  	if s1 != s2 {
 17234  		t.Fatalf("String want %v got %v", s1, s2)
 17235  	}
 17236  }
 17237  func TestNidOptStructStringer(t *testing.T) {
 17238  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17239  	p := NewPopulatedNidOptStruct(popr, false)
 17240  	s1 := p.String()
 17241  	s2 := fmt.Sprintf("%v", p)
 17242  	if s1 != s2 {
 17243  		t.Fatalf("String want %v got %v", s1, s2)
 17244  	}
 17245  }
 17246  func TestNinOptStructStringer(t *testing.T) {
 17247  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17248  	p := NewPopulatedNinOptStruct(popr, false)
 17249  	s1 := p.String()
 17250  	s2 := fmt.Sprintf("%v", p)
 17251  	if s1 != s2 {
 17252  		t.Fatalf("String want %v got %v", s1, s2)
 17253  	}
 17254  }
 17255  func TestNidRepStructStringer(t *testing.T) {
 17256  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17257  	p := NewPopulatedNidRepStruct(popr, false)
 17258  	s1 := p.String()
 17259  	s2 := fmt.Sprintf("%v", p)
 17260  	if s1 != s2 {
 17261  		t.Fatalf("String want %v got %v", s1, s2)
 17262  	}
 17263  }
 17264  func TestNinRepStructStringer(t *testing.T) {
 17265  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17266  	p := NewPopulatedNinRepStruct(popr, false)
 17267  	s1 := p.String()
 17268  	s2 := fmt.Sprintf("%v", p)
 17269  	if s1 != s2 {
 17270  		t.Fatalf("String want %v got %v", s1, s2)
 17271  	}
 17272  }
 17273  func TestNidEmbeddedStructStringer(t *testing.T) {
 17274  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17275  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 17276  	s1 := p.String()
 17277  	s2 := fmt.Sprintf("%v", p)
 17278  	if s1 != s2 {
 17279  		t.Fatalf("String want %v got %v", s1, s2)
 17280  	}
 17281  }
 17282  func TestNinEmbeddedStructStringer(t *testing.T) {
 17283  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17284  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 17285  	s1 := p.String()
 17286  	s2 := fmt.Sprintf("%v", p)
 17287  	if s1 != s2 {
 17288  		t.Fatalf("String want %v got %v", s1, s2)
 17289  	}
 17290  }
 17291  func TestNidNestedStructStringer(t *testing.T) {
 17292  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17293  	p := NewPopulatedNidNestedStruct(popr, false)
 17294  	s1 := p.String()
 17295  	s2 := fmt.Sprintf("%v", p)
 17296  	if s1 != s2 {
 17297  		t.Fatalf("String want %v got %v", s1, s2)
 17298  	}
 17299  }
 17300  func TestNinNestedStructStringer(t *testing.T) {
 17301  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17302  	p := NewPopulatedNinNestedStruct(popr, false)
 17303  	s1 := p.String()
 17304  	s2 := fmt.Sprintf("%v", p)
 17305  	if s1 != s2 {
 17306  		t.Fatalf("String want %v got %v", s1, s2)
 17307  	}
 17308  }
 17309  func TestNidOptCustomStringer(t *testing.T) {
 17310  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17311  	p := NewPopulatedNidOptCustom(popr, false)
 17312  	s1 := p.String()
 17313  	s2 := fmt.Sprintf("%v", p)
 17314  	if s1 != s2 {
 17315  		t.Fatalf("String want %v got %v", s1, s2)
 17316  	}
 17317  }
 17318  func TestCustomDashStringer(t *testing.T) {
 17319  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17320  	p := NewPopulatedCustomDash(popr, false)
 17321  	s1 := p.String()
 17322  	s2 := fmt.Sprintf("%v", p)
 17323  	if s1 != s2 {
 17324  		t.Fatalf("String want %v got %v", s1, s2)
 17325  	}
 17326  }
 17327  func TestNinOptCustomStringer(t *testing.T) {
 17328  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17329  	p := NewPopulatedNinOptCustom(popr, false)
 17330  	s1 := p.String()
 17331  	s2 := fmt.Sprintf("%v", p)
 17332  	if s1 != s2 {
 17333  		t.Fatalf("String want %v got %v", s1, s2)
 17334  	}
 17335  }
 17336  func TestNidRepCustomStringer(t *testing.T) {
 17337  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17338  	p := NewPopulatedNidRepCustom(popr, false)
 17339  	s1 := p.String()
 17340  	s2 := fmt.Sprintf("%v", p)
 17341  	if s1 != s2 {
 17342  		t.Fatalf("String want %v got %v", s1, s2)
 17343  	}
 17344  }
 17345  func TestNinRepCustomStringer(t *testing.T) {
 17346  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17347  	p := NewPopulatedNinRepCustom(popr, false)
 17348  	s1 := p.String()
 17349  	s2 := fmt.Sprintf("%v", p)
 17350  	if s1 != s2 {
 17351  		t.Fatalf("String want %v got %v", s1, s2)
 17352  	}
 17353  }
 17354  func TestNinOptNativeUnionStringer(t *testing.T) {
 17355  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17356  	p := NewPopulatedNinOptNativeUnion(popr, false)
 17357  	s1 := p.String()
 17358  	s2 := fmt.Sprintf("%v", p)
 17359  	if s1 != s2 {
 17360  		t.Fatalf("String want %v got %v", s1, s2)
 17361  	}
 17362  }
 17363  func TestNinOptStructUnionStringer(t *testing.T) {
 17364  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17365  	p := NewPopulatedNinOptStructUnion(popr, false)
 17366  	s1 := p.String()
 17367  	s2 := fmt.Sprintf("%v", p)
 17368  	if s1 != s2 {
 17369  		t.Fatalf("String want %v got %v", s1, s2)
 17370  	}
 17371  }
 17372  func TestNinEmbeddedStructUnionStringer(t *testing.T) {
 17373  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17374  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 17375  	s1 := p.String()
 17376  	s2 := fmt.Sprintf("%v", p)
 17377  	if s1 != s2 {
 17378  		t.Fatalf("String want %v got %v", s1, s2)
 17379  	}
 17380  }
 17381  func TestNinNestedStructUnionStringer(t *testing.T) {
 17382  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17383  	p := NewPopulatedNinNestedStructUnion(popr, false)
 17384  	s1 := p.String()
 17385  	s2 := fmt.Sprintf("%v", p)
 17386  	if s1 != s2 {
 17387  		t.Fatalf("String want %v got %v", s1, s2)
 17388  	}
 17389  }
 17390  func TestTreeStringer(t *testing.T) {
 17391  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17392  	p := NewPopulatedTree(popr, false)
 17393  	s1 := p.String()
 17394  	s2 := fmt.Sprintf("%v", p)
 17395  	if s1 != s2 {
 17396  		t.Fatalf("String want %v got %v", s1, s2)
 17397  	}
 17398  }
 17399  func TestOrBranchStringer(t *testing.T) {
 17400  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17401  	p := NewPopulatedOrBranch(popr, false)
 17402  	s1 := p.String()
 17403  	s2 := fmt.Sprintf("%v", p)
 17404  	if s1 != s2 {
 17405  		t.Fatalf("String want %v got %v", s1, s2)
 17406  	}
 17407  }
 17408  func TestAndBranchStringer(t *testing.T) {
 17409  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17410  	p := NewPopulatedAndBranch(popr, false)
 17411  	s1 := p.String()
 17412  	s2 := fmt.Sprintf("%v", p)
 17413  	if s1 != s2 {
 17414  		t.Fatalf("String want %v got %v", s1, s2)
 17415  	}
 17416  }
 17417  func TestLeafStringer(t *testing.T) {
 17418  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17419  	p := NewPopulatedLeaf(popr, false)
 17420  	s1 := p.String()
 17421  	s2 := fmt.Sprintf("%v", p)
 17422  	if s1 != s2 {
 17423  		t.Fatalf("String want %v got %v", s1, s2)
 17424  	}
 17425  }
 17426  func TestDeepTreeStringer(t *testing.T) {
 17427  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17428  	p := NewPopulatedDeepTree(popr, false)
 17429  	s1 := p.String()
 17430  	s2 := fmt.Sprintf("%v", p)
 17431  	if s1 != s2 {
 17432  		t.Fatalf("String want %v got %v", s1, s2)
 17433  	}
 17434  }
 17435  func TestADeepBranchStringer(t *testing.T) {
 17436  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17437  	p := NewPopulatedADeepBranch(popr, false)
 17438  	s1 := p.String()
 17439  	s2 := fmt.Sprintf("%v", p)
 17440  	if s1 != s2 {
 17441  		t.Fatalf("String want %v got %v", s1, s2)
 17442  	}
 17443  }
 17444  func TestAndDeepBranchStringer(t *testing.T) {
 17445  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17446  	p := NewPopulatedAndDeepBranch(popr, false)
 17447  	s1 := p.String()
 17448  	s2 := fmt.Sprintf("%v", p)
 17449  	if s1 != s2 {
 17450  		t.Fatalf("String want %v got %v", s1, s2)
 17451  	}
 17452  }
 17453  func TestDeepLeafStringer(t *testing.T) {
 17454  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17455  	p := NewPopulatedDeepLeaf(popr, false)
 17456  	s1 := p.String()
 17457  	s2 := fmt.Sprintf("%v", p)
 17458  	if s1 != s2 {
 17459  		t.Fatalf("String want %v got %v", s1, s2)
 17460  	}
 17461  }
 17462  func TestNilStringer(t *testing.T) {
 17463  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17464  	p := NewPopulatedNil(popr, false)
 17465  	s1 := p.String()
 17466  	s2 := fmt.Sprintf("%v", p)
 17467  	if s1 != s2 {
 17468  		t.Fatalf("String want %v got %v", s1, s2)
 17469  	}
 17470  }
 17471  func TestNidOptEnumStringer(t *testing.T) {
 17472  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17473  	p := NewPopulatedNidOptEnum(popr, false)
 17474  	s1 := p.String()
 17475  	s2 := fmt.Sprintf("%v", p)
 17476  	if s1 != s2 {
 17477  		t.Fatalf("String want %v got %v", s1, s2)
 17478  	}
 17479  }
 17480  func TestNinOptEnumStringer(t *testing.T) {
 17481  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17482  	p := NewPopulatedNinOptEnum(popr, false)
 17483  	s1 := p.String()
 17484  	s2 := fmt.Sprintf("%v", p)
 17485  	if s1 != s2 {
 17486  		t.Fatalf("String want %v got %v", s1, s2)
 17487  	}
 17488  }
 17489  func TestNidRepEnumStringer(t *testing.T) {
 17490  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17491  	p := NewPopulatedNidRepEnum(popr, false)
 17492  	s1 := p.String()
 17493  	s2 := fmt.Sprintf("%v", p)
 17494  	if s1 != s2 {
 17495  		t.Fatalf("String want %v got %v", s1, s2)
 17496  	}
 17497  }
 17498  func TestNinRepEnumStringer(t *testing.T) {
 17499  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17500  	p := NewPopulatedNinRepEnum(popr, false)
 17501  	s1 := p.String()
 17502  	s2 := fmt.Sprintf("%v", p)
 17503  	if s1 != s2 {
 17504  		t.Fatalf("String want %v got %v", s1, s2)
 17505  	}
 17506  }
 17507  func TestNinOptEnumDefaultStringer(t *testing.T) {
 17508  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17509  	p := NewPopulatedNinOptEnumDefault(popr, false)
 17510  	s1 := p.String()
 17511  	s2 := fmt.Sprintf("%v", p)
 17512  	if s1 != s2 {
 17513  		t.Fatalf("String want %v got %v", s1, s2)
 17514  	}
 17515  }
 17516  func TestAnotherNinOptEnumStringer(t *testing.T) {
 17517  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17518  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 17519  	s1 := p.String()
 17520  	s2 := fmt.Sprintf("%v", p)
 17521  	if s1 != s2 {
 17522  		t.Fatalf("String want %v got %v", s1, s2)
 17523  	}
 17524  }
 17525  func TestAnotherNinOptEnumDefaultStringer(t *testing.T) {
 17526  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17527  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 17528  	s1 := p.String()
 17529  	s2 := fmt.Sprintf("%v", p)
 17530  	if s1 != s2 {
 17531  		t.Fatalf("String want %v got %v", s1, s2)
 17532  	}
 17533  }
 17534  func TestTimerStringer(t *testing.T) {
 17535  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17536  	p := NewPopulatedTimer(popr, false)
 17537  	s1 := p.String()
 17538  	s2 := fmt.Sprintf("%v", p)
 17539  	if s1 != s2 {
 17540  		t.Fatalf("String want %v got %v", s1, s2)
 17541  	}
 17542  }
 17543  func TestMyExtendableStringer(t *testing.T) {
 17544  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17545  	p := NewPopulatedMyExtendable(popr, false)
 17546  	s1 := p.String()
 17547  	s2 := fmt.Sprintf("%v", p)
 17548  	if s1 != s2 {
 17549  		t.Fatalf("String want %v got %v", s1, s2)
 17550  	}
 17551  }
 17552  func TestOtherExtenableStringer(t *testing.T) {
 17553  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17554  	p := NewPopulatedOtherExtenable(popr, false)
 17555  	s1 := p.String()
 17556  	s2 := fmt.Sprintf("%v", p)
 17557  	if s1 != s2 {
 17558  		t.Fatalf("String want %v got %v", s1, s2)
 17559  	}
 17560  }
 17561  func TestNestedDefinitionStringer(t *testing.T) {
 17562  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17563  	p := NewPopulatedNestedDefinition(popr, false)
 17564  	s1 := p.String()
 17565  	s2 := fmt.Sprintf("%v", p)
 17566  	if s1 != s2 {
 17567  		t.Fatalf("String want %v got %v", s1, s2)
 17568  	}
 17569  }
 17570  func TestNestedDefinition_NestedMessageStringer(t *testing.T) {
 17571  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17572  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 17573  	s1 := p.String()
 17574  	s2 := fmt.Sprintf("%v", p)
 17575  	if s1 != s2 {
 17576  		t.Fatalf("String want %v got %v", s1, s2)
 17577  	}
 17578  }
 17579  func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) {
 17580  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17581  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 17582  	s1 := p.String()
 17583  	s2 := fmt.Sprintf("%v", p)
 17584  	if s1 != s2 {
 17585  		t.Fatalf("String want %v got %v", s1, s2)
 17586  	}
 17587  }
 17588  func TestNestedScopeStringer(t *testing.T) {
 17589  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17590  	p := NewPopulatedNestedScope(popr, false)
 17591  	s1 := p.String()
 17592  	s2 := fmt.Sprintf("%v", p)
 17593  	if s1 != s2 {
 17594  		t.Fatalf("String want %v got %v", s1, s2)
 17595  	}
 17596  }
 17597  func TestNinOptNativeDefaultStringer(t *testing.T) {
 17598  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17599  	p := NewPopulatedNinOptNativeDefault(popr, false)
 17600  	s1 := p.String()
 17601  	s2 := fmt.Sprintf("%v", p)
 17602  	if s1 != s2 {
 17603  		t.Fatalf("String want %v got %v", s1, s2)
 17604  	}
 17605  }
 17606  func TestCustomContainerStringer(t *testing.T) {
 17607  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17608  	p := NewPopulatedCustomContainer(popr, false)
 17609  	s1 := p.String()
 17610  	s2 := fmt.Sprintf("%v", p)
 17611  	if s1 != s2 {
 17612  		t.Fatalf("String want %v got %v", s1, s2)
 17613  	}
 17614  }
 17615  func TestCustomNameNidOptNativeStringer(t *testing.T) {
 17616  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17617  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 17618  	s1 := p.String()
 17619  	s2 := fmt.Sprintf("%v", p)
 17620  	if s1 != s2 {
 17621  		t.Fatalf("String want %v got %v", s1, s2)
 17622  	}
 17623  }
 17624  func TestCustomNameNinOptNativeStringer(t *testing.T) {
 17625  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17626  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 17627  	s1 := p.String()
 17628  	s2 := fmt.Sprintf("%v", p)
 17629  	if s1 != s2 {
 17630  		t.Fatalf("String want %v got %v", s1, s2)
 17631  	}
 17632  }
 17633  func TestCustomNameNinRepNativeStringer(t *testing.T) {
 17634  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17635  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 17636  	s1 := p.String()
 17637  	s2 := fmt.Sprintf("%v", p)
 17638  	if s1 != s2 {
 17639  		t.Fatalf("String want %v got %v", s1, s2)
 17640  	}
 17641  }
 17642  func TestCustomNameNinStructStringer(t *testing.T) {
 17643  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17644  	p := NewPopulatedCustomNameNinStruct(popr, false)
 17645  	s1 := p.String()
 17646  	s2 := fmt.Sprintf("%v", p)
 17647  	if s1 != s2 {
 17648  		t.Fatalf("String want %v got %v", s1, s2)
 17649  	}
 17650  }
 17651  func TestCustomNameCustomTypeStringer(t *testing.T) {
 17652  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17653  	p := NewPopulatedCustomNameCustomType(popr, false)
 17654  	s1 := p.String()
 17655  	s2 := fmt.Sprintf("%v", p)
 17656  	if s1 != s2 {
 17657  		t.Fatalf("String want %v got %v", s1, s2)
 17658  	}
 17659  }
 17660  func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) {
 17661  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17662  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 17663  	s1 := p.String()
 17664  	s2 := fmt.Sprintf("%v", p)
 17665  	if s1 != s2 {
 17666  		t.Fatalf("String want %v got %v", s1, s2)
 17667  	}
 17668  }
 17669  func TestCustomNameEnumStringer(t *testing.T) {
 17670  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17671  	p := NewPopulatedCustomNameEnum(popr, false)
 17672  	s1 := p.String()
 17673  	s2 := fmt.Sprintf("%v", p)
 17674  	if s1 != s2 {
 17675  		t.Fatalf("String want %v got %v", s1, s2)
 17676  	}
 17677  }
 17678  func TestNoExtensionsMapStringer(t *testing.T) {
 17679  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17680  	p := NewPopulatedNoExtensionsMap(popr, false)
 17681  	s1 := p.String()
 17682  	s2 := fmt.Sprintf("%v", p)
 17683  	if s1 != s2 {
 17684  		t.Fatalf("String want %v got %v", s1, s2)
 17685  	}
 17686  }
 17687  func TestUnrecognizedStringer(t *testing.T) {
 17688  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17689  	p := NewPopulatedUnrecognized(popr, false)
 17690  	s1 := p.String()
 17691  	s2 := fmt.Sprintf("%v", p)
 17692  	if s1 != s2 {
 17693  		t.Fatalf("String want %v got %v", s1, s2)
 17694  	}
 17695  }
 17696  func TestUnrecognizedWithInnerStringer(t *testing.T) {
 17697  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17698  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 17699  	s1 := p.String()
 17700  	s2 := fmt.Sprintf("%v", p)
 17701  	if s1 != s2 {
 17702  		t.Fatalf("String want %v got %v", s1, s2)
 17703  	}
 17704  }
 17705  func TestUnrecognizedWithInner_InnerStringer(t *testing.T) {
 17706  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17707  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 17708  	s1 := p.String()
 17709  	s2 := fmt.Sprintf("%v", p)
 17710  	if s1 != s2 {
 17711  		t.Fatalf("String want %v got %v", s1, s2)
 17712  	}
 17713  }
 17714  func TestUnrecognizedWithEmbedStringer(t *testing.T) {
 17715  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17716  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 17717  	s1 := p.String()
 17718  	s2 := fmt.Sprintf("%v", p)
 17719  	if s1 != s2 {
 17720  		t.Fatalf("String want %v got %v", s1, s2)
 17721  	}
 17722  }
 17723  func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) {
 17724  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17725  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 17726  	s1 := p.String()
 17727  	s2 := fmt.Sprintf("%v", p)
 17728  	if s1 != s2 {
 17729  		t.Fatalf("String want %v got %v", s1, s2)
 17730  	}
 17731  }
 17732  func TestNodeStringer(t *testing.T) {
 17733  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17734  	p := NewPopulatedNode(popr, false)
 17735  	s1 := p.String()
 17736  	s2 := fmt.Sprintf("%v", p)
 17737  	if s1 != s2 {
 17738  		t.Fatalf("String want %v got %v", s1, s2)
 17739  	}
 17740  }
 17741  func TestNonByteCustomTypeStringer(t *testing.T) {
 17742  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17743  	p := NewPopulatedNonByteCustomType(popr, false)
 17744  	s1 := p.String()
 17745  	s2 := fmt.Sprintf("%v", p)
 17746  	if s1 != s2 {
 17747  		t.Fatalf("String want %v got %v", s1, s2)
 17748  	}
 17749  }
 17750  func TestNidOptNonByteCustomTypeStringer(t *testing.T) {
 17751  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17752  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 17753  	s1 := p.String()
 17754  	s2 := fmt.Sprintf("%v", p)
 17755  	if s1 != s2 {
 17756  		t.Fatalf("String want %v got %v", s1, s2)
 17757  	}
 17758  }
 17759  func TestNinOptNonByteCustomTypeStringer(t *testing.T) {
 17760  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17761  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 17762  	s1 := p.String()
 17763  	s2 := fmt.Sprintf("%v", p)
 17764  	if s1 != s2 {
 17765  		t.Fatalf("String want %v got %v", s1, s2)
 17766  	}
 17767  }
 17768  func TestNidRepNonByteCustomTypeStringer(t *testing.T) {
 17769  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17770  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 17771  	s1 := p.String()
 17772  	s2 := fmt.Sprintf("%v", p)
 17773  	if s1 != s2 {
 17774  		t.Fatalf("String want %v got %v", s1, s2)
 17775  	}
 17776  }
 17777  func TestNinRepNonByteCustomTypeStringer(t *testing.T) {
 17778  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17779  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 17780  	s1 := p.String()
 17781  	s2 := fmt.Sprintf("%v", p)
 17782  	if s1 != s2 {
 17783  		t.Fatalf("String want %v got %v", s1, s2)
 17784  	}
 17785  }
 17786  func TestProtoTypeStringer(t *testing.T) {
 17787  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17788  	p := NewPopulatedProtoType(popr, false)
 17789  	s1 := p.String()
 17790  	s2 := fmt.Sprintf("%v", p)
 17791  	if s1 != s2 {
 17792  		t.Fatalf("String want %v got %v", s1, s2)
 17793  	}
 17794  }
 17795  func TestNinOptNativeUnionOnlyOne(t *testing.T) {
 17796  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17797  	p := NewPopulatedNinOptNativeUnion(popr, true)
 17798  	v := p.GetValue()
 17799  	msg := &NinOptNativeUnion{}
 17800  	if !msg.SetValue(v) {
 17801  		t.Fatalf("OnlyOne: Could not set Value")
 17802  	}
 17803  	if !p.Equal(msg) {
 17804  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17805  	}
 17806  }
 17807  func TestNinOptStructUnionOnlyOne(t *testing.T) {
 17808  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17809  	p := NewPopulatedNinOptStructUnion(popr, true)
 17810  	v := p.GetValue()
 17811  	msg := &NinOptStructUnion{}
 17812  	if !msg.SetValue(v) {
 17813  		t.Fatalf("OnlyOne: Could not set Value")
 17814  	}
 17815  	if !p.Equal(msg) {
 17816  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17817  	}
 17818  }
 17819  func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) {
 17820  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17821  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 17822  	v := p.GetValue()
 17823  	msg := &NinEmbeddedStructUnion{}
 17824  	if !msg.SetValue(v) {
 17825  		t.Fatalf("OnlyOne: Could not set Value")
 17826  	}
 17827  	if !p.Equal(msg) {
 17828  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17829  	}
 17830  }
 17831  func TestNinNestedStructUnionOnlyOne(t *testing.T) {
 17832  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17833  	p := NewPopulatedNinNestedStructUnion(popr, true)
 17834  	v := p.GetValue()
 17835  	msg := &NinNestedStructUnion{}
 17836  	if !msg.SetValue(v) {
 17837  		t.Fatalf("OnlyOne: Could not set Value")
 17838  	}
 17839  	if !p.Equal(msg) {
 17840  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17841  	}
 17842  }
 17843  func TestTreeOnlyOne(t *testing.T) {
 17844  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17845  	p := NewPopulatedTree(popr, true)
 17846  	v := p.GetValue()
 17847  	msg := &Tree{}
 17848  	if !msg.SetValue(v) {
 17849  		t.Fatalf("OnlyOne: Could not set Value")
 17850  	}
 17851  	if !p.Equal(msg) {
 17852  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17853  	}
 17854  }
 17855  func TestDeepTreeOnlyOne(t *testing.T) {
 17856  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17857  	p := NewPopulatedDeepTree(popr, true)
 17858  	v := p.GetValue()
 17859  	msg := &DeepTree{}
 17860  	if !msg.SetValue(v) {
 17861  		t.Fatalf("OnlyOne: Could not set Value")
 17862  	}
 17863  	if !p.Equal(msg) {
 17864  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17865  	}
 17866  }
 17867  func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) {
 17868  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 17869  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 17870  	v := p.GetValue()
 17871  	msg := &CustomNameNinEmbeddedStructUnion{}
 17872  	if !msg.SetValue(v) {
 17873  		t.Fatalf("OnlyOne: Could not set Value")
 17874  	}
 17875  	if !p.Equal(msg) {
 17876  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 17877  	}
 17878  }
 17879  
 17880  //These tests are generated by github.com/gogo/protobuf/plugin/testgen
 17881  

View as plain text