▽

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

Documentation: github.com/gogo/protobuf/test

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: 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 BenchmarkNidOptNativeProtoMarshal(b *testing.B) {
    59  	popr := math_rand.New(math_rand.NewSource(616))
    60  	total := 0
    61  	pops := make([]*NidOptNative, 10000)
    62  	for i := 0; i < 10000; i++ {
    63  		pops[i] = NewPopulatedNidOptNative(popr, false)
    64  	}
    65  	b.ResetTimer()
    66  	for i := 0; i < b.N; i++ {
    67  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
    68  		if err != nil {
    69  			panic(err)
    70  		}
    71  		total += len(dAtA)
    72  	}
    73  	b.SetBytes(int64(total / b.N))
    74  }
    75  
    76  func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) {
    77  	popr := math_rand.New(math_rand.NewSource(616))
    78  	total := 0
    79  	datas := make([][]byte, 10000)
    80  	for i := 0; i < 10000; i++ {
    81  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false))
    82  		if err != nil {
    83  			panic(err)
    84  		}
    85  		datas[i] = dAtA
    86  	}
    87  	msg := &NidOptNative{}
    88  	b.ResetTimer()
    89  	for i := 0; i < b.N; i++ {
    90  		total += len(datas[i%10000])
    91  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
    92  			panic(err)
    93  		}
    94  	}
    95  	b.SetBytes(int64(total / b.N))
    96  }
    97  
    98  func TestNinOptNativeProto(t *testing.T) {
    99  	seed := time.Now().UnixNano()
   100  	popr := math_rand.New(math_rand.NewSource(seed))
   101  	p := NewPopulatedNinOptNative(popr, false)
   102  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   103  	if err != nil {
   104  		t.Fatalf("seed = %d, err = %v", seed, err)
   105  	}
   106  	msg := &NinOptNative{}
   107  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   108  		t.Fatalf("seed = %d, err = %v", seed, err)
   109  	}
   110  	littlefuzz := make([]byte, len(dAtA))
   111  	copy(littlefuzz, dAtA)
   112  	for i := range dAtA {
   113  		dAtA[i] = byte(popr.Intn(256))
   114  	}
   115  	if err := p.VerboseEqual(msg); err != nil {
   116  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   117  	}
   118  	if !p.Equal(msg) {
   119  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   120  	}
   121  	if len(littlefuzz) > 0 {
   122  		fuzzamount := 100
   123  		for i := 0; i < fuzzamount; i++ {
   124  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   125  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   126  		}
   127  		// shouldn't panic
   128  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   129  	}
   130  }
   131  
   132  func BenchmarkNinOptNativeProtoMarshal(b *testing.B) {
   133  	popr := math_rand.New(math_rand.NewSource(616))
   134  	total := 0
   135  	pops := make([]*NinOptNative, 10000)
   136  	for i := 0; i < 10000; i++ {
   137  		pops[i] = NewPopulatedNinOptNative(popr, false)
   138  	}
   139  	b.ResetTimer()
   140  	for i := 0; i < b.N; i++ {
   141  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   142  		if err != nil {
   143  			panic(err)
   144  		}
   145  		total += len(dAtA)
   146  	}
   147  	b.SetBytes(int64(total / b.N))
   148  }
   149  
   150  func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) {
   151  	popr := math_rand.New(math_rand.NewSource(616))
   152  	total := 0
   153  	datas := make([][]byte, 10000)
   154  	for i := 0; i < 10000; i++ {
   155  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false))
   156  		if err != nil {
   157  			panic(err)
   158  		}
   159  		datas[i] = dAtA
   160  	}
   161  	msg := &NinOptNative{}
   162  	b.ResetTimer()
   163  	for i := 0; i < b.N; i++ {
   164  		total += len(datas[i%10000])
   165  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   166  			panic(err)
   167  		}
   168  	}
   169  	b.SetBytes(int64(total / b.N))
   170  }
   171  
   172  func TestNidRepNativeProto(t *testing.T) {
   173  	seed := time.Now().UnixNano()
   174  	popr := math_rand.New(math_rand.NewSource(seed))
   175  	p := NewPopulatedNidRepNative(popr, false)
   176  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   177  	if err != nil {
   178  		t.Fatalf("seed = %d, err = %v", seed, err)
   179  	}
   180  	msg := &NidRepNative{}
   181  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   182  		t.Fatalf("seed = %d, err = %v", seed, err)
   183  	}
   184  	littlefuzz := make([]byte, len(dAtA))
   185  	copy(littlefuzz, dAtA)
   186  	for i := range dAtA {
   187  		dAtA[i] = byte(popr.Intn(256))
   188  	}
   189  	if err := p.VerboseEqual(msg); err != nil {
   190  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   191  	}
   192  	if !p.Equal(msg) {
   193  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   194  	}
   195  	if len(littlefuzz) > 0 {
   196  		fuzzamount := 100
   197  		for i := 0; i < fuzzamount; i++ {
   198  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   199  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   200  		}
   201  		// shouldn't panic
   202  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   203  	}
   204  }
   205  
   206  func BenchmarkNidRepNativeProtoMarshal(b *testing.B) {
   207  	popr := math_rand.New(math_rand.NewSource(616))
   208  	total := 0
   209  	pops := make([]*NidRepNative, 10000)
   210  	for i := 0; i < 10000; i++ {
   211  		pops[i] = NewPopulatedNidRepNative(popr, false)
   212  	}
   213  	b.ResetTimer()
   214  	for i := 0; i < b.N; i++ {
   215  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   216  		if err != nil {
   217  			panic(err)
   218  		}
   219  		total += len(dAtA)
   220  	}
   221  	b.SetBytes(int64(total / b.N))
   222  }
   223  
   224  func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) {
   225  	popr := math_rand.New(math_rand.NewSource(616))
   226  	total := 0
   227  	datas := make([][]byte, 10000)
   228  	for i := 0; i < 10000; i++ {
   229  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false))
   230  		if err != nil {
   231  			panic(err)
   232  		}
   233  		datas[i] = dAtA
   234  	}
   235  	msg := &NidRepNative{}
   236  	b.ResetTimer()
   237  	for i := 0; i < b.N; i++ {
   238  		total += len(datas[i%10000])
   239  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   240  			panic(err)
   241  		}
   242  	}
   243  	b.SetBytes(int64(total / b.N))
   244  }
   245  
   246  func TestNinRepNativeProto(t *testing.T) {
   247  	seed := time.Now().UnixNano()
   248  	popr := math_rand.New(math_rand.NewSource(seed))
   249  	p := NewPopulatedNinRepNative(popr, false)
   250  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   251  	if err != nil {
   252  		t.Fatalf("seed = %d, err = %v", seed, err)
   253  	}
   254  	msg := &NinRepNative{}
   255  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   256  		t.Fatalf("seed = %d, err = %v", seed, err)
   257  	}
   258  	littlefuzz := make([]byte, len(dAtA))
   259  	copy(littlefuzz, dAtA)
   260  	for i := range dAtA {
   261  		dAtA[i] = byte(popr.Intn(256))
   262  	}
   263  	if err := p.VerboseEqual(msg); err != nil {
   264  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   265  	}
   266  	if !p.Equal(msg) {
   267  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   268  	}
   269  	if len(littlefuzz) > 0 {
   270  		fuzzamount := 100
   271  		for i := 0; i < fuzzamount; i++ {
   272  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   273  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   274  		}
   275  		// shouldn't panic
   276  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   277  	}
   278  }
   279  
   280  func BenchmarkNinRepNativeProtoMarshal(b *testing.B) {
   281  	popr := math_rand.New(math_rand.NewSource(616))
   282  	total := 0
   283  	pops := make([]*NinRepNative, 10000)
   284  	for i := 0; i < 10000; i++ {
   285  		pops[i] = NewPopulatedNinRepNative(popr, false)
   286  	}
   287  	b.ResetTimer()
   288  	for i := 0; i < b.N; i++ {
   289  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   290  		if err != nil {
   291  			panic(err)
   292  		}
   293  		total += len(dAtA)
   294  	}
   295  	b.SetBytes(int64(total / b.N))
   296  }
   297  
   298  func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) {
   299  	popr := math_rand.New(math_rand.NewSource(616))
   300  	total := 0
   301  	datas := make([][]byte, 10000)
   302  	for i := 0; i < 10000; i++ {
   303  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false))
   304  		if err != nil {
   305  			panic(err)
   306  		}
   307  		datas[i] = dAtA
   308  	}
   309  	msg := &NinRepNative{}
   310  	b.ResetTimer()
   311  	for i := 0; i < b.N; i++ {
   312  		total += len(datas[i%10000])
   313  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   314  			panic(err)
   315  		}
   316  	}
   317  	b.SetBytes(int64(total / b.N))
   318  }
   319  
   320  func TestNidRepPackedNativeProto(t *testing.T) {
   321  	seed := time.Now().UnixNano()
   322  	popr := math_rand.New(math_rand.NewSource(seed))
   323  	p := NewPopulatedNidRepPackedNative(popr, false)
   324  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   325  	if err != nil {
   326  		t.Fatalf("seed = %d, err = %v", seed, err)
   327  	}
   328  	msg := &NidRepPackedNative{}
   329  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   330  		t.Fatalf("seed = %d, err = %v", seed, err)
   331  	}
   332  	littlefuzz := make([]byte, len(dAtA))
   333  	copy(littlefuzz, dAtA)
   334  	for i := range dAtA {
   335  		dAtA[i] = byte(popr.Intn(256))
   336  	}
   337  	if err := p.VerboseEqual(msg); err != nil {
   338  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   339  	}
   340  	if !p.Equal(msg) {
   341  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   342  	}
   343  	if len(littlefuzz) > 0 {
   344  		fuzzamount := 100
   345  		for i := 0; i < fuzzamount; i++ {
   346  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   347  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   348  		}
   349  		// shouldn't panic
   350  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   351  	}
   352  }
   353  
   354  func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) {
   355  	popr := math_rand.New(math_rand.NewSource(616))
   356  	total := 0
   357  	pops := make([]*NidRepPackedNative, 10000)
   358  	for i := 0; i < 10000; i++ {
   359  		pops[i] = NewPopulatedNidRepPackedNative(popr, false)
   360  	}
   361  	b.ResetTimer()
   362  	for i := 0; i < b.N; i++ {
   363  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   364  		if err != nil {
   365  			panic(err)
   366  		}
   367  		total += len(dAtA)
   368  	}
   369  	b.SetBytes(int64(total / b.N))
   370  }
   371  
   372  func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) {
   373  	popr := math_rand.New(math_rand.NewSource(616))
   374  	total := 0
   375  	datas := make([][]byte, 10000)
   376  	for i := 0; i < 10000; i++ {
   377  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false))
   378  		if err != nil {
   379  			panic(err)
   380  		}
   381  		datas[i] = dAtA
   382  	}
   383  	msg := &NidRepPackedNative{}
   384  	b.ResetTimer()
   385  	for i := 0; i < b.N; i++ {
   386  		total += len(datas[i%10000])
   387  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   388  			panic(err)
   389  		}
   390  	}
   391  	b.SetBytes(int64(total / b.N))
   392  }
   393  
   394  func TestNinRepPackedNativeProto(t *testing.T) {
   395  	seed := time.Now().UnixNano()
   396  	popr := math_rand.New(math_rand.NewSource(seed))
   397  	p := NewPopulatedNinRepPackedNative(popr, false)
   398  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   399  	if err != nil {
   400  		t.Fatalf("seed = %d, err = %v", seed, err)
   401  	}
   402  	msg := &NinRepPackedNative{}
   403  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   404  		t.Fatalf("seed = %d, err = %v", seed, err)
   405  	}
   406  	littlefuzz := make([]byte, len(dAtA))
   407  	copy(littlefuzz, dAtA)
   408  	for i := range dAtA {
   409  		dAtA[i] = byte(popr.Intn(256))
   410  	}
   411  	if err := p.VerboseEqual(msg); err != nil {
   412  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   413  	}
   414  	if !p.Equal(msg) {
   415  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   416  	}
   417  	if len(littlefuzz) > 0 {
   418  		fuzzamount := 100
   419  		for i := 0; i < fuzzamount; i++ {
   420  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   421  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   422  		}
   423  		// shouldn't panic
   424  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   425  	}
   426  }
   427  
   428  func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) {
   429  	popr := math_rand.New(math_rand.NewSource(616))
   430  	total := 0
   431  	pops := make([]*NinRepPackedNative, 10000)
   432  	for i := 0; i < 10000; i++ {
   433  		pops[i] = NewPopulatedNinRepPackedNative(popr, false)
   434  	}
   435  	b.ResetTimer()
   436  	for i := 0; i < b.N; i++ {
   437  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   438  		if err != nil {
   439  			panic(err)
   440  		}
   441  		total += len(dAtA)
   442  	}
   443  	b.SetBytes(int64(total / b.N))
   444  }
   445  
   446  func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) {
   447  	popr := math_rand.New(math_rand.NewSource(616))
   448  	total := 0
   449  	datas := make([][]byte, 10000)
   450  	for i := 0; i < 10000; i++ {
   451  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false))
   452  		if err != nil {
   453  			panic(err)
   454  		}
   455  		datas[i] = dAtA
   456  	}
   457  	msg := &NinRepPackedNative{}
   458  	b.ResetTimer()
   459  	for i := 0; i < b.N; i++ {
   460  		total += len(datas[i%10000])
   461  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   462  			panic(err)
   463  		}
   464  	}
   465  	b.SetBytes(int64(total / b.N))
   466  }
   467  
   468  func TestNidOptStructProto(t *testing.T) {
   469  	seed := time.Now().UnixNano()
   470  	popr := math_rand.New(math_rand.NewSource(seed))
   471  	p := NewPopulatedNidOptStruct(popr, false)
   472  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   473  	if err != nil {
   474  		t.Fatalf("seed = %d, err = %v", seed, err)
   475  	}
   476  	msg := &NidOptStruct{}
   477  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   478  		t.Fatalf("seed = %d, err = %v", seed, err)
   479  	}
   480  	littlefuzz := make([]byte, len(dAtA))
   481  	copy(littlefuzz, dAtA)
   482  	for i := range dAtA {
   483  		dAtA[i] = byte(popr.Intn(256))
   484  	}
   485  	if err := p.VerboseEqual(msg); err != nil {
   486  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   487  	}
   488  	if !p.Equal(msg) {
   489  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   490  	}
   491  	if len(littlefuzz) > 0 {
   492  		fuzzamount := 100
   493  		for i := 0; i < fuzzamount; i++ {
   494  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   495  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   496  		}
   497  		// shouldn't panic
   498  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   499  	}
   500  }
   501  
   502  func BenchmarkNidOptStructProtoMarshal(b *testing.B) {
   503  	popr := math_rand.New(math_rand.NewSource(616))
   504  	total := 0
   505  	pops := make([]*NidOptStruct, 10000)
   506  	for i := 0; i < 10000; i++ {
   507  		pops[i] = NewPopulatedNidOptStruct(popr, false)
   508  	}
   509  	b.ResetTimer()
   510  	for i := 0; i < b.N; i++ {
   511  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   512  		if err != nil {
   513  			panic(err)
   514  		}
   515  		total += len(dAtA)
   516  	}
   517  	b.SetBytes(int64(total / b.N))
   518  }
   519  
   520  func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) {
   521  	popr := math_rand.New(math_rand.NewSource(616))
   522  	total := 0
   523  	datas := make([][]byte, 10000)
   524  	for i := 0; i < 10000; i++ {
   525  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false))
   526  		if err != nil {
   527  			panic(err)
   528  		}
   529  		datas[i] = dAtA
   530  	}
   531  	msg := &NidOptStruct{}
   532  	b.ResetTimer()
   533  	for i := 0; i < b.N; i++ {
   534  		total += len(datas[i%10000])
   535  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   536  			panic(err)
   537  		}
   538  	}
   539  	b.SetBytes(int64(total / b.N))
   540  }
   541  
   542  func TestNinOptStructProto(t *testing.T) {
   543  	seed := time.Now().UnixNano()
   544  	popr := math_rand.New(math_rand.NewSource(seed))
   545  	p := NewPopulatedNinOptStruct(popr, false)
   546  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   547  	if err != nil {
   548  		t.Fatalf("seed = %d, err = %v", seed, err)
   549  	}
   550  	msg := &NinOptStruct{}
   551  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   552  		t.Fatalf("seed = %d, err = %v", seed, err)
   553  	}
   554  	littlefuzz := make([]byte, len(dAtA))
   555  	copy(littlefuzz, dAtA)
   556  	for i := range dAtA {
   557  		dAtA[i] = byte(popr.Intn(256))
   558  	}
   559  	if err := p.VerboseEqual(msg); err != nil {
   560  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   561  	}
   562  	if !p.Equal(msg) {
   563  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   564  	}
   565  	if len(littlefuzz) > 0 {
   566  		fuzzamount := 100
   567  		for i := 0; i < fuzzamount; i++ {
   568  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   569  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   570  		}
   571  		// shouldn't panic
   572  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   573  	}
   574  }
   575  
   576  func BenchmarkNinOptStructProtoMarshal(b *testing.B) {
   577  	popr := math_rand.New(math_rand.NewSource(616))
   578  	total := 0
   579  	pops := make([]*NinOptStruct, 10000)
   580  	for i := 0; i < 10000; i++ {
   581  		pops[i] = NewPopulatedNinOptStruct(popr, false)
   582  	}
   583  	b.ResetTimer()
   584  	for i := 0; i < b.N; i++ {
   585  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   586  		if err != nil {
   587  			panic(err)
   588  		}
   589  		total += len(dAtA)
   590  	}
   591  	b.SetBytes(int64(total / b.N))
   592  }
   593  
   594  func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) {
   595  	popr := math_rand.New(math_rand.NewSource(616))
   596  	total := 0
   597  	datas := make([][]byte, 10000)
   598  	for i := 0; i < 10000; i++ {
   599  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false))
   600  		if err != nil {
   601  			panic(err)
   602  		}
   603  		datas[i] = dAtA
   604  	}
   605  	msg := &NinOptStruct{}
   606  	b.ResetTimer()
   607  	for i := 0; i < b.N; i++ {
   608  		total += len(datas[i%10000])
   609  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   610  			panic(err)
   611  		}
   612  	}
   613  	b.SetBytes(int64(total / b.N))
   614  }
   615  
   616  func TestNidRepStructProto(t *testing.T) {
   617  	seed := time.Now().UnixNano()
   618  	popr := math_rand.New(math_rand.NewSource(seed))
   619  	p := NewPopulatedNidRepStruct(popr, false)
   620  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   621  	if err != nil {
   622  		t.Fatalf("seed = %d, err = %v", seed, err)
   623  	}
   624  	msg := &NidRepStruct{}
   625  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   626  		t.Fatalf("seed = %d, err = %v", seed, err)
   627  	}
   628  	littlefuzz := make([]byte, len(dAtA))
   629  	copy(littlefuzz, dAtA)
   630  	for i := range dAtA {
   631  		dAtA[i] = byte(popr.Intn(256))
   632  	}
   633  	if err := p.VerboseEqual(msg); err != nil {
   634  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   635  	}
   636  	if !p.Equal(msg) {
   637  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   638  	}
   639  	if len(littlefuzz) > 0 {
   640  		fuzzamount := 100
   641  		for i := 0; i < fuzzamount; i++ {
   642  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   643  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   644  		}
   645  		// shouldn't panic
   646  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   647  	}
   648  }
   649  
   650  func BenchmarkNidRepStructProtoMarshal(b *testing.B) {
   651  	popr := math_rand.New(math_rand.NewSource(616))
   652  	total := 0
   653  	pops := make([]*NidRepStruct, 10000)
   654  	for i := 0; i < 10000; i++ {
   655  		pops[i] = NewPopulatedNidRepStruct(popr, false)
   656  	}
   657  	b.ResetTimer()
   658  	for i := 0; i < b.N; i++ {
   659  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   660  		if err != nil {
   661  			panic(err)
   662  		}
   663  		total += len(dAtA)
   664  	}
   665  	b.SetBytes(int64(total / b.N))
   666  }
   667  
   668  func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) {
   669  	popr := math_rand.New(math_rand.NewSource(616))
   670  	total := 0
   671  	datas := make([][]byte, 10000)
   672  	for i := 0; i < 10000; i++ {
   673  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false))
   674  		if err != nil {
   675  			panic(err)
   676  		}
   677  		datas[i] = dAtA
   678  	}
   679  	msg := &NidRepStruct{}
   680  	b.ResetTimer()
   681  	for i := 0; i < b.N; i++ {
   682  		total += len(datas[i%10000])
   683  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   684  			panic(err)
   685  		}
   686  	}
   687  	b.SetBytes(int64(total / b.N))
   688  }
   689  
   690  func TestNinRepStructProto(t *testing.T) {
   691  	seed := time.Now().UnixNano()
   692  	popr := math_rand.New(math_rand.NewSource(seed))
   693  	p := NewPopulatedNinRepStruct(popr, false)
   694  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   695  	if err != nil {
   696  		t.Fatalf("seed = %d, err = %v", seed, err)
   697  	}
   698  	msg := &NinRepStruct{}
   699  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   700  		t.Fatalf("seed = %d, err = %v", seed, err)
   701  	}
   702  	littlefuzz := make([]byte, len(dAtA))
   703  	copy(littlefuzz, dAtA)
   704  	for i := range dAtA {
   705  		dAtA[i] = byte(popr.Intn(256))
   706  	}
   707  	if err := p.VerboseEqual(msg); err != nil {
   708  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   709  	}
   710  	if !p.Equal(msg) {
   711  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   712  	}
   713  	if len(littlefuzz) > 0 {
   714  		fuzzamount := 100
   715  		for i := 0; i < fuzzamount; i++ {
   716  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   717  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   718  		}
   719  		// shouldn't panic
   720  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   721  	}
   722  }
   723  
   724  func BenchmarkNinRepStructProtoMarshal(b *testing.B) {
   725  	popr := math_rand.New(math_rand.NewSource(616))
   726  	total := 0
   727  	pops := make([]*NinRepStruct, 10000)
   728  	for i := 0; i < 10000; i++ {
   729  		pops[i] = NewPopulatedNinRepStruct(popr, false)
   730  	}
   731  	b.ResetTimer()
   732  	for i := 0; i < b.N; i++ {
   733  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   734  		if err != nil {
   735  			panic(err)
   736  		}
   737  		total += len(dAtA)
   738  	}
   739  	b.SetBytes(int64(total / b.N))
   740  }
   741  
   742  func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) {
   743  	popr := math_rand.New(math_rand.NewSource(616))
   744  	total := 0
   745  	datas := make([][]byte, 10000)
   746  	for i := 0; i < 10000; i++ {
   747  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false))
   748  		if err != nil {
   749  			panic(err)
   750  		}
   751  		datas[i] = dAtA
   752  	}
   753  	msg := &NinRepStruct{}
   754  	b.ResetTimer()
   755  	for i := 0; i < b.N; i++ {
   756  		total += len(datas[i%10000])
   757  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   758  			panic(err)
   759  		}
   760  	}
   761  	b.SetBytes(int64(total / b.N))
   762  }
   763  
   764  func TestNidEmbeddedStructProto(t *testing.T) {
   765  	seed := time.Now().UnixNano()
   766  	popr := math_rand.New(math_rand.NewSource(seed))
   767  	p := NewPopulatedNidEmbeddedStruct(popr, false)
   768  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   769  	if err != nil {
   770  		t.Fatalf("seed = %d, err = %v", seed, err)
   771  	}
   772  	msg := &NidEmbeddedStruct{}
   773  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   774  		t.Fatalf("seed = %d, err = %v", seed, err)
   775  	}
   776  	littlefuzz := make([]byte, len(dAtA))
   777  	copy(littlefuzz, dAtA)
   778  	for i := range dAtA {
   779  		dAtA[i] = byte(popr.Intn(256))
   780  	}
   781  	if err := p.VerboseEqual(msg); err != nil {
   782  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   783  	}
   784  	if !p.Equal(msg) {
   785  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   786  	}
   787  	if len(littlefuzz) > 0 {
   788  		fuzzamount := 100
   789  		for i := 0; i < fuzzamount; i++ {
   790  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   791  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   792  		}
   793  		// shouldn't panic
   794  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   795  	}
   796  }
   797  
   798  func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) {
   799  	popr := math_rand.New(math_rand.NewSource(616))
   800  	total := 0
   801  	pops := make([]*NidEmbeddedStruct, 10000)
   802  	for i := 0; i < 10000; i++ {
   803  		pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
   804  	}
   805  	b.ResetTimer()
   806  	for i := 0; i < b.N; i++ {
   807  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   808  		if err != nil {
   809  			panic(err)
   810  		}
   811  		total += len(dAtA)
   812  	}
   813  	b.SetBytes(int64(total / b.N))
   814  }
   815  
   816  func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) {
   817  	popr := math_rand.New(math_rand.NewSource(616))
   818  	total := 0
   819  	datas := make([][]byte, 10000)
   820  	for i := 0; i < 10000; i++ {
   821  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false))
   822  		if err != nil {
   823  			panic(err)
   824  		}
   825  		datas[i] = dAtA
   826  	}
   827  	msg := &NidEmbeddedStruct{}
   828  	b.ResetTimer()
   829  	for i := 0; i < b.N; i++ {
   830  		total += len(datas[i%10000])
   831  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   832  			panic(err)
   833  		}
   834  	}
   835  	b.SetBytes(int64(total / b.N))
   836  }
   837  
   838  func TestNinEmbeddedStructProto(t *testing.T) {
   839  	seed := time.Now().UnixNano()
   840  	popr := math_rand.New(math_rand.NewSource(seed))
   841  	p := NewPopulatedNinEmbeddedStruct(popr, false)
   842  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   843  	if err != nil {
   844  		t.Fatalf("seed = %d, err = %v", seed, err)
   845  	}
   846  	msg := &NinEmbeddedStruct{}
   847  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   848  		t.Fatalf("seed = %d, err = %v", seed, err)
   849  	}
   850  	littlefuzz := make([]byte, len(dAtA))
   851  	copy(littlefuzz, dAtA)
   852  	for i := range dAtA {
   853  		dAtA[i] = byte(popr.Intn(256))
   854  	}
   855  	if err := p.VerboseEqual(msg); err != nil {
   856  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   857  	}
   858  	if !p.Equal(msg) {
   859  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   860  	}
   861  	if len(littlefuzz) > 0 {
   862  		fuzzamount := 100
   863  		for i := 0; i < fuzzamount; i++ {
   864  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   865  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   866  		}
   867  		// shouldn't panic
   868  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   869  	}
   870  }
   871  
   872  func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) {
   873  	popr := math_rand.New(math_rand.NewSource(616))
   874  	total := 0
   875  	pops := make([]*NinEmbeddedStruct, 10000)
   876  	for i := 0; i < 10000; i++ {
   877  		pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
   878  	}
   879  	b.ResetTimer()
   880  	for i := 0; i < b.N; i++ {
   881  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   882  		if err != nil {
   883  			panic(err)
   884  		}
   885  		total += len(dAtA)
   886  	}
   887  	b.SetBytes(int64(total / b.N))
   888  }
   889  
   890  func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) {
   891  	popr := math_rand.New(math_rand.NewSource(616))
   892  	total := 0
   893  	datas := make([][]byte, 10000)
   894  	for i := 0; i < 10000; i++ {
   895  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false))
   896  		if err != nil {
   897  			panic(err)
   898  		}
   899  		datas[i] = dAtA
   900  	}
   901  	msg := &NinEmbeddedStruct{}
   902  	b.ResetTimer()
   903  	for i := 0; i < b.N; i++ {
   904  		total += len(datas[i%10000])
   905  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   906  			panic(err)
   907  		}
   908  	}
   909  	b.SetBytes(int64(total / b.N))
   910  }
   911  
   912  func TestNidNestedStructProto(t *testing.T) {
   913  	seed := time.Now().UnixNano()
   914  	popr := math_rand.New(math_rand.NewSource(seed))
   915  	p := NewPopulatedNidNestedStruct(popr, false)
   916  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   917  	if err != nil {
   918  		t.Fatalf("seed = %d, err = %v", seed, err)
   919  	}
   920  	msg := &NidNestedStruct{}
   921  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   922  		t.Fatalf("seed = %d, err = %v", seed, err)
   923  	}
   924  	littlefuzz := make([]byte, len(dAtA))
   925  	copy(littlefuzz, dAtA)
   926  	for i := range dAtA {
   927  		dAtA[i] = byte(popr.Intn(256))
   928  	}
   929  	if err := p.VerboseEqual(msg); err != nil {
   930  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   931  	}
   932  	if !p.Equal(msg) {
   933  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   934  	}
   935  	if len(littlefuzz) > 0 {
   936  		fuzzamount := 100
   937  		for i := 0; i < fuzzamount; i++ {
   938  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   939  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   940  		}
   941  		// shouldn't panic
   942  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   943  	}
   944  }
   945  
   946  func BenchmarkNidNestedStructProtoMarshal(b *testing.B) {
   947  	popr := math_rand.New(math_rand.NewSource(616))
   948  	total := 0
   949  	pops := make([]*NidNestedStruct, 10000)
   950  	for i := 0; i < 10000; i++ {
   951  		pops[i] = NewPopulatedNidNestedStruct(popr, false)
   952  	}
   953  	b.ResetTimer()
   954  	for i := 0; i < b.N; i++ {
   955  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   956  		if err != nil {
   957  			panic(err)
   958  		}
   959  		total += len(dAtA)
   960  	}
   961  	b.SetBytes(int64(total / b.N))
   962  }
   963  
   964  func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) {
   965  	popr := math_rand.New(math_rand.NewSource(616))
   966  	total := 0
   967  	datas := make([][]byte, 10000)
   968  	for i := 0; i < 10000; i++ {
   969  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false))
   970  		if err != nil {
   971  			panic(err)
   972  		}
   973  		datas[i] = dAtA
   974  	}
   975  	msg := &NidNestedStruct{}
   976  	b.ResetTimer()
   977  	for i := 0; i < b.N; i++ {
   978  		total += len(datas[i%10000])
   979  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   980  			panic(err)
   981  		}
   982  	}
   983  	b.SetBytes(int64(total / b.N))
   984  }
   985  
   986  func TestNinNestedStructProto(t *testing.T) {
   987  	seed := time.Now().UnixNano()
   988  	popr := math_rand.New(math_rand.NewSource(seed))
   989  	p := NewPopulatedNinNestedStruct(popr, false)
   990  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   991  	if err != nil {
   992  		t.Fatalf("seed = %d, err = %v", seed, err)
   993  	}
   994  	msg := &NinNestedStruct{}
   995  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   996  		t.Fatalf("seed = %d, err = %v", seed, err)
   997  	}
   998  	littlefuzz := make([]byte, len(dAtA))
   999  	copy(littlefuzz, dAtA)
  1000  	for i := range dAtA {
  1001  		dAtA[i] = byte(popr.Intn(256))
  1002  	}
  1003  	if err := p.VerboseEqual(msg); err != nil {
  1004  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1005  	}
  1006  	if !p.Equal(msg) {
  1007  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1008  	}
  1009  	if len(littlefuzz) > 0 {
  1010  		fuzzamount := 100
  1011  		for i := 0; i < fuzzamount; i++ {
  1012  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1013  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1014  		}
  1015  		// shouldn't panic
  1016  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1017  	}
  1018  }
  1019  
  1020  func BenchmarkNinNestedStructProtoMarshal(b *testing.B) {
  1021  	popr := math_rand.New(math_rand.NewSource(616))
  1022  	total := 0
  1023  	pops := make([]*NinNestedStruct, 10000)
  1024  	for i := 0; i < 10000; i++ {
  1025  		pops[i] = NewPopulatedNinNestedStruct(popr, false)
  1026  	}
  1027  	b.ResetTimer()
  1028  	for i := 0; i < b.N; i++ {
  1029  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1030  		if err != nil {
  1031  			panic(err)
  1032  		}
  1033  		total += len(dAtA)
  1034  	}
  1035  	b.SetBytes(int64(total / b.N))
  1036  }
  1037  
  1038  func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) {
  1039  	popr := math_rand.New(math_rand.NewSource(616))
  1040  	total := 0
  1041  	datas := make([][]byte, 10000)
  1042  	for i := 0; i < 10000; i++ {
  1043  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false))
  1044  		if err != nil {
  1045  			panic(err)
  1046  		}
  1047  		datas[i] = dAtA
  1048  	}
  1049  	msg := &NinNestedStruct{}
  1050  	b.ResetTimer()
  1051  	for i := 0; i < b.N; i++ {
  1052  		total += len(datas[i%10000])
  1053  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1054  			panic(err)
  1055  		}
  1056  	}
  1057  	b.SetBytes(int64(total / b.N))
  1058  }
  1059  
  1060  func TestNidOptCustomProto(t *testing.T) {
  1061  	seed := time.Now().UnixNano()
  1062  	popr := math_rand.New(math_rand.NewSource(seed))
  1063  	p := NewPopulatedNidOptCustom(popr, false)
  1064  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1065  	if err != nil {
  1066  		t.Fatalf("seed = %d, err = %v", seed, err)
  1067  	}
  1068  	msg := &NidOptCustom{}
  1069  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1070  		t.Fatalf("seed = %d, err = %v", seed, err)
  1071  	}
  1072  	littlefuzz := make([]byte, len(dAtA))
  1073  	copy(littlefuzz, dAtA)
  1074  	for i := range dAtA {
  1075  		dAtA[i] = byte(popr.Intn(256))
  1076  	}
  1077  	if err := p.VerboseEqual(msg); err != nil {
  1078  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1079  	}
  1080  	if !p.Equal(msg) {
  1081  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1082  	}
  1083  	if len(littlefuzz) > 0 {
  1084  		fuzzamount := 100
  1085  		for i := 0; i < fuzzamount; i++ {
  1086  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1087  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1088  		}
  1089  		// shouldn't panic
  1090  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1091  	}
  1092  }
  1093  
  1094  func BenchmarkNidOptCustomProtoMarshal(b *testing.B) {
  1095  	popr := math_rand.New(math_rand.NewSource(616))
  1096  	total := 0
  1097  	pops := make([]*NidOptCustom, 10000)
  1098  	for i := 0; i < 10000; i++ {
  1099  		pops[i] = NewPopulatedNidOptCustom(popr, false)
  1100  	}
  1101  	b.ResetTimer()
  1102  	for i := 0; i < b.N; i++ {
  1103  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1104  		if err != nil {
  1105  			panic(err)
  1106  		}
  1107  		total += len(dAtA)
  1108  	}
  1109  	b.SetBytes(int64(total / b.N))
  1110  }
  1111  
  1112  func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) {
  1113  	popr := math_rand.New(math_rand.NewSource(616))
  1114  	total := 0
  1115  	datas := make([][]byte, 10000)
  1116  	for i := 0; i < 10000; i++ {
  1117  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false))
  1118  		if err != nil {
  1119  			panic(err)
  1120  		}
  1121  		datas[i] = dAtA
  1122  	}
  1123  	msg := &NidOptCustom{}
  1124  	b.ResetTimer()
  1125  	for i := 0; i < b.N; i++ {
  1126  		total += len(datas[i%10000])
  1127  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1128  			panic(err)
  1129  		}
  1130  	}
  1131  	b.SetBytes(int64(total / b.N))
  1132  }
  1133  
  1134  func TestCustomDashProto(t *testing.T) {
  1135  	seed := time.Now().UnixNano()
  1136  	popr := math_rand.New(math_rand.NewSource(seed))
  1137  	p := NewPopulatedCustomDash(popr, false)
  1138  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1139  	if err != nil {
  1140  		t.Fatalf("seed = %d, err = %v", seed, err)
  1141  	}
  1142  	msg := &CustomDash{}
  1143  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1144  		t.Fatalf("seed = %d, err = %v", seed, err)
  1145  	}
  1146  	littlefuzz := make([]byte, len(dAtA))
  1147  	copy(littlefuzz, dAtA)
  1148  	for i := range dAtA {
  1149  		dAtA[i] = byte(popr.Intn(256))
  1150  	}
  1151  	if err := p.VerboseEqual(msg); err != nil {
  1152  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1153  	}
  1154  	if !p.Equal(msg) {
  1155  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1156  	}
  1157  	if len(littlefuzz) > 0 {
  1158  		fuzzamount := 100
  1159  		for i := 0; i < fuzzamount; i++ {
  1160  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1161  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1162  		}
  1163  		// shouldn't panic
  1164  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1165  	}
  1166  }
  1167  
  1168  func BenchmarkCustomDashProtoMarshal(b *testing.B) {
  1169  	popr := math_rand.New(math_rand.NewSource(616))
  1170  	total := 0
  1171  	pops := make([]*CustomDash, 10000)
  1172  	for i := 0; i < 10000; i++ {
  1173  		pops[i] = NewPopulatedCustomDash(popr, false)
  1174  	}
  1175  	b.ResetTimer()
  1176  	for i := 0; i < b.N; i++ {
  1177  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1178  		if err != nil {
  1179  			panic(err)
  1180  		}
  1181  		total += len(dAtA)
  1182  	}
  1183  	b.SetBytes(int64(total / b.N))
  1184  }
  1185  
  1186  func BenchmarkCustomDashProtoUnmarshal(b *testing.B) {
  1187  	popr := math_rand.New(math_rand.NewSource(616))
  1188  	total := 0
  1189  	datas := make([][]byte, 10000)
  1190  	for i := 0; i < 10000; i++ {
  1191  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false))
  1192  		if err != nil {
  1193  			panic(err)
  1194  		}
  1195  		datas[i] = dAtA
  1196  	}
  1197  	msg := &CustomDash{}
  1198  	b.ResetTimer()
  1199  	for i := 0; i < b.N; i++ {
  1200  		total += len(datas[i%10000])
  1201  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1202  			panic(err)
  1203  		}
  1204  	}
  1205  	b.SetBytes(int64(total / b.N))
  1206  }
  1207  
  1208  func TestNinOptCustomProto(t *testing.T) {
  1209  	seed := time.Now().UnixNano()
  1210  	popr := math_rand.New(math_rand.NewSource(seed))
  1211  	p := NewPopulatedNinOptCustom(popr, false)
  1212  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1213  	if err != nil {
  1214  		t.Fatalf("seed = %d, err = %v", seed, err)
  1215  	}
  1216  	msg := &NinOptCustom{}
  1217  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1218  		t.Fatalf("seed = %d, err = %v", seed, err)
  1219  	}
  1220  	littlefuzz := make([]byte, len(dAtA))
  1221  	copy(littlefuzz, dAtA)
  1222  	for i := range dAtA {
  1223  		dAtA[i] = byte(popr.Intn(256))
  1224  	}
  1225  	if err := p.VerboseEqual(msg); err != nil {
  1226  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1227  	}
  1228  	if !p.Equal(msg) {
  1229  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1230  	}
  1231  	if len(littlefuzz) > 0 {
  1232  		fuzzamount := 100
  1233  		for i := 0; i < fuzzamount; i++ {
  1234  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1235  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1236  		}
  1237  		// shouldn't panic
  1238  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1239  	}
  1240  }
  1241  
  1242  func BenchmarkNinOptCustomProtoMarshal(b *testing.B) {
  1243  	popr := math_rand.New(math_rand.NewSource(616))
  1244  	total := 0
  1245  	pops := make([]*NinOptCustom, 10000)
  1246  	for i := 0; i < 10000; i++ {
  1247  		pops[i] = NewPopulatedNinOptCustom(popr, false)
  1248  	}
  1249  	b.ResetTimer()
  1250  	for i := 0; i < b.N; i++ {
  1251  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1252  		if err != nil {
  1253  			panic(err)
  1254  		}
  1255  		total += len(dAtA)
  1256  	}
  1257  	b.SetBytes(int64(total / b.N))
  1258  }
  1259  
  1260  func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) {
  1261  	popr := math_rand.New(math_rand.NewSource(616))
  1262  	total := 0
  1263  	datas := make([][]byte, 10000)
  1264  	for i := 0; i < 10000; i++ {
  1265  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false))
  1266  		if err != nil {
  1267  			panic(err)
  1268  		}
  1269  		datas[i] = dAtA
  1270  	}
  1271  	msg := &NinOptCustom{}
  1272  	b.ResetTimer()
  1273  	for i := 0; i < b.N; i++ {
  1274  		total += len(datas[i%10000])
  1275  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1276  			panic(err)
  1277  		}
  1278  	}
  1279  	b.SetBytes(int64(total / b.N))
  1280  }
  1281  
  1282  func TestNidRepCustomProto(t *testing.T) {
  1283  	seed := time.Now().UnixNano()
  1284  	popr := math_rand.New(math_rand.NewSource(seed))
  1285  	p := NewPopulatedNidRepCustom(popr, false)
  1286  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1287  	if err != nil {
  1288  		t.Fatalf("seed = %d, err = %v", seed, err)
  1289  	}
  1290  	msg := &NidRepCustom{}
  1291  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1292  		t.Fatalf("seed = %d, err = %v", seed, err)
  1293  	}
  1294  	littlefuzz := make([]byte, len(dAtA))
  1295  	copy(littlefuzz, dAtA)
  1296  	for i := range dAtA {
  1297  		dAtA[i] = byte(popr.Intn(256))
  1298  	}
  1299  	if err := p.VerboseEqual(msg); err != nil {
  1300  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1301  	}
  1302  	if !p.Equal(msg) {
  1303  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1304  	}
  1305  	if len(littlefuzz) > 0 {
  1306  		fuzzamount := 100
  1307  		for i := 0; i < fuzzamount; i++ {
  1308  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1309  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1310  		}
  1311  		// shouldn't panic
  1312  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1313  	}
  1314  }
  1315  
  1316  func BenchmarkNidRepCustomProtoMarshal(b *testing.B) {
  1317  	popr := math_rand.New(math_rand.NewSource(616))
  1318  	total := 0
  1319  	pops := make([]*NidRepCustom, 10000)
  1320  	for i := 0; i < 10000; i++ {
  1321  		pops[i] = NewPopulatedNidRepCustom(popr, false)
  1322  	}
  1323  	b.ResetTimer()
  1324  	for i := 0; i < b.N; i++ {
  1325  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1326  		if err != nil {
  1327  			panic(err)
  1328  		}
  1329  		total += len(dAtA)
  1330  	}
  1331  	b.SetBytes(int64(total / b.N))
  1332  }
  1333  
  1334  func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) {
  1335  	popr := math_rand.New(math_rand.NewSource(616))
  1336  	total := 0
  1337  	datas := make([][]byte, 10000)
  1338  	for i := 0; i < 10000; i++ {
  1339  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false))
  1340  		if err != nil {
  1341  			panic(err)
  1342  		}
  1343  		datas[i] = dAtA
  1344  	}
  1345  	msg := &NidRepCustom{}
  1346  	b.ResetTimer()
  1347  	for i := 0; i < b.N; i++ {
  1348  		total += len(datas[i%10000])
  1349  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1350  			panic(err)
  1351  		}
  1352  	}
  1353  	b.SetBytes(int64(total / b.N))
  1354  }
  1355  
  1356  func TestNinRepCustomProto(t *testing.T) {
  1357  	seed := time.Now().UnixNano()
  1358  	popr := math_rand.New(math_rand.NewSource(seed))
  1359  	p := NewPopulatedNinRepCustom(popr, false)
  1360  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1361  	if err != nil {
  1362  		t.Fatalf("seed = %d, err = %v", seed, err)
  1363  	}
  1364  	msg := &NinRepCustom{}
  1365  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1366  		t.Fatalf("seed = %d, err = %v", seed, err)
  1367  	}
  1368  	littlefuzz := make([]byte, len(dAtA))
  1369  	copy(littlefuzz, dAtA)
  1370  	for i := range dAtA {
  1371  		dAtA[i] = byte(popr.Intn(256))
  1372  	}
  1373  	if err := p.VerboseEqual(msg); err != nil {
  1374  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1375  	}
  1376  	if !p.Equal(msg) {
  1377  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1378  	}
  1379  	if len(littlefuzz) > 0 {
  1380  		fuzzamount := 100
  1381  		for i := 0; i < fuzzamount; i++ {
  1382  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1383  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1384  		}
  1385  		// shouldn't panic
  1386  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1387  	}
  1388  }
  1389  
  1390  func BenchmarkNinRepCustomProtoMarshal(b *testing.B) {
  1391  	popr := math_rand.New(math_rand.NewSource(616))
  1392  	total := 0
  1393  	pops := make([]*NinRepCustom, 10000)
  1394  	for i := 0; i < 10000; i++ {
  1395  		pops[i] = NewPopulatedNinRepCustom(popr, false)
  1396  	}
  1397  	b.ResetTimer()
  1398  	for i := 0; i < b.N; i++ {
  1399  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1400  		if err != nil {
  1401  			panic(err)
  1402  		}
  1403  		total += len(dAtA)
  1404  	}
  1405  	b.SetBytes(int64(total / b.N))
  1406  }
  1407  
  1408  func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) {
  1409  	popr := math_rand.New(math_rand.NewSource(616))
  1410  	total := 0
  1411  	datas := make([][]byte, 10000)
  1412  	for i := 0; i < 10000; i++ {
  1413  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false))
  1414  		if err != nil {
  1415  			panic(err)
  1416  		}
  1417  		datas[i] = dAtA
  1418  	}
  1419  	msg := &NinRepCustom{}
  1420  	b.ResetTimer()
  1421  	for i := 0; i < b.N; i++ {
  1422  		total += len(datas[i%10000])
  1423  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1424  			panic(err)
  1425  		}
  1426  	}
  1427  	b.SetBytes(int64(total / b.N))
  1428  }
  1429  
  1430  func TestNinOptNativeUnionProto(t *testing.T) {
  1431  	seed := time.Now().UnixNano()
  1432  	popr := math_rand.New(math_rand.NewSource(seed))
  1433  	p := NewPopulatedNinOptNativeUnion(popr, false)
  1434  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1435  	if err != nil {
  1436  		t.Fatalf("seed = %d, err = %v", seed, err)
  1437  	}
  1438  	msg := &NinOptNativeUnion{}
  1439  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1440  		t.Fatalf("seed = %d, err = %v", seed, err)
  1441  	}
  1442  	littlefuzz := make([]byte, len(dAtA))
  1443  	copy(littlefuzz, dAtA)
  1444  	for i := range dAtA {
  1445  		dAtA[i] = byte(popr.Intn(256))
  1446  	}
  1447  	if err := p.VerboseEqual(msg); err != nil {
  1448  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1449  	}
  1450  	if !p.Equal(msg) {
  1451  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1452  	}
  1453  	if len(littlefuzz) > 0 {
  1454  		fuzzamount := 100
  1455  		for i := 0; i < fuzzamount; i++ {
  1456  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1457  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1458  		}
  1459  		// shouldn't panic
  1460  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1461  	}
  1462  }
  1463  
  1464  func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) {
  1465  	popr := math_rand.New(math_rand.NewSource(616))
  1466  	total := 0
  1467  	pops := make([]*NinOptNativeUnion, 10000)
  1468  	for i := 0; i < 10000; i++ {
  1469  		pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
  1470  	}
  1471  	b.ResetTimer()
  1472  	for i := 0; i < b.N; i++ {
  1473  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1474  		if err != nil {
  1475  			panic(err)
  1476  		}
  1477  		total += len(dAtA)
  1478  	}
  1479  	b.SetBytes(int64(total / b.N))
  1480  }
  1481  
  1482  func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) {
  1483  	popr := math_rand.New(math_rand.NewSource(616))
  1484  	total := 0
  1485  	datas := make([][]byte, 10000)
  1486  	for i := 0; i < 10000; i++ {
  1487  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false))
  1488  		if err != nil {
  1489  			panic(err)
  1490  		}
  1491  		datas[i] = dAtA
  1492  	}
  1493  	msg := &NinOptNativeUnion{}
  1494  	b.ResetTimer()
  1495  	for i := 0; i < b.N; i++ {
  1496  		total += len(datas[i%10000])
  1497  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1498  			panic(err)
  1499  		}
  1500  	}
  1501  	b.SetBytes(int64(total / b.N))
  1502  }
  1503  
  1504  func TestNinOptStructUnionProto(t *testing.T) {
  1505  	seed := time.Now().UnixNano()
  1506  	popr := math_rand.New(math_rand.NewSource(seed))
  1507  	p := NewPopulatedNinOptStructUnion(popr, false)
  1508  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1509  	if err != nil {
  1510  		t.Fatalf("seed = %d, err = %v", seed, err)
  1511  	}
  1512  	msg := &NinOptStructUnion{}
  1513  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1514  		t.Fatalf("seed = %d, err = %v", seed, err)
  1515  	}
  1516  	littlefuzz := make([]byte, len(dAtA))
  1517  	copy(littlefuzz, dAtA)
  1518  	for i := range dAtA {
  1519  		dAtA[i] = byte(popr.Intn(256))
  1520  	}
  1521  	if err := p.VerboseEqual(msg); err != nil {
  1522  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1523  	}
  1524  	if !p.Equal(msg) {
  1525  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1526  	}
  1527  	if len(littlefuzz) > 0 {
  1528  		fuzzamount := 100
  1529  		for i := 0; i < fuzzamount; i++ {
  1530  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1531  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1532  		}
  1533  		// shouldn't panic
  1534  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1535  	}
  1536  }
  1537  
  1538  func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) {
  1539  	popr := math_rand.New(math_rand.NewSource(616))
  1540  	total := 0
  1541  	pops := make([]*NinOptStructUnion, 10000)
  1542  	for i := 0; i < 10000; i++ {
  1543  		pops[i] = NewPopulatedNinOptStructUnion(popr, false)
  1544  	}
  1545  	b.ResetTimer()
  1546  	for i := 0; i < b.N; i++ {
  1547  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1548  		if err != nil {
  1549  			panic(err)
  1550  		}
  1551  		total += len(dAtA)
  1552  	}
  1553  	b.SetBytes(int64(total / b.N))
  1554  }
  1555  
  1556  func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) {
  1557  	popr := math_rand.New(math_rand.NewSource(616))
  1558  	total := 0
  1559  	datas := make([][]byte, 10000)
  1560  	for i := 0; i < 10000; i++ {
  1561  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false))
  1562  		if err != nil {
  1563  			panic(err)
  1564  		}
  1565  		datas[i] = dAtA
  1566  	}
  1567  	msg := &NinOptStructUnion{}
  1568  	b.ResetTimer()
  1569  	for i := 0; i < b.N; i++ {
  1570  		total += len(datas[i%10000])
  1571  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1572  			panic(err)
  1573  		}
  1574  	}
  1575  	b.SetBytes(int64(total / b.N))
  1576  }
  1577  
  1578  func TestNinEmbeddedStructUnionProto(t *testing.T) {
  1579  	seed := time.Now().UnixNano()
  1580  	popr := math_rand.New(math_rand.NewSource(seed))
  1581  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
  1582  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1583  	if err != nil {
  1584  		t.Fatalf("seed = %d, err = %v", seed, err)
  1585  	}
  1586  	msg := &NinEmbeddedStructUnion{}
  1587  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1588  		t.Fatalf("seed = %d, err = %v", seed, err)
  1589  	}
  1590  	littlefuzz := make([]byte, len(dAtA))
  1591  	copy(littlefuzz, dAtA)
  1592  	for i := range dAtA {
  1593  		dAtA[i] = byte(popr.Intn(256))
  1594  	}
  1595  	if err := p.VerboseEqual(msg); err != nil {
  1596  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1597  	}
  1598  	if !p.Equal(msg) {
  1599  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1600  	}
  1601  	if len(littlefuzz) > 0 {
  1602  		fuzzamount := 100
  1603  		for i := 0; i < fuzzamount; i++ {
  1604  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1605  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1606  		}
  1607  		// shouldn't panic
  1608  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1609  	}
  1610  }
  1611  
  1612  func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
  1613  	popr := math_rand.New(math_rand.NewSource(616))
  1614  	total := 0
  1615  	pops := make([]*NinEmbeddedStructUnion, 10000)
  1616  	for i := 0; i < 10000; i++ {
  1617  		pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
  1618  	}
  1619  	b.ResetTimer()
  1620  	for i := 0; i < b.N; i++ {
  1621  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1622  		if err != nil {
  1623  			panic(err)
  1624  		}
  1625  		total += len(dAtA)
  1626  	}
  1627  	b.SetBytes(int64(total / b.N))
  1628  }
  1629  
  1630  func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
  1631  	popr := math_rand.New(math_rand.NewSource(616))
  1632  	total := 0
  1633  	datas := make([][]byte, 10000)
  1634  	for i := 0; i < 10000; i++ {
  1635  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false))
  1636  		if err != nil {
  1637  			panic(err)
  1638  		}
  1639  		datas[i] = dAtA
  1640  	}
  1641  	msg := &NinEmbeddedStructUnion{}
  1642  	b.ResetTimer()
  1643  	for i := 0; i < b.N; i++ {
  1644  		total += len(datas[i%10000])
  1645  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1646  			panic(err)
  1647  		}
  1648  	}
  1649  	b.SetBytes(int64(total / b.N))
  1650  }
  1651  
  1652  func TestNinNestedStructUnionProto(t *testing.T) {
  1653  	seed := time.Now().UnixNano()
  1654  	popr := math_rand.New(math_rand.NewSource(seed))
  1655  	p := NewPopulatedNinNestedStructUnion(popr, false)
  1656  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1657  	if err != nil {
  1658  		t.Fatalf("seed = %d, err = %v", seed, err)
  1659  	}
  1660  	msg := &NinNestedStructUnion{}
  1661  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1662  		t.Fatalf("seed = %d, err = %v", seed, err)
  1663  	}
  1664  	littlefuzz := make([]byte, len(dAtA))
  1665  	copy(littlefuzz, dAtA)
  1666  	for i := range dAtA {
  1667  		dAtA[i] = byte(popr.Intn(256))
  1668  	}
  1669  	if err := p.VerboseEqual(msg); err != nil {
  1670  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1671  	}
  1672  	if !p.Equal(msg) {
  1673  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1674  	}
  1675  	if len(littlefuzz) > 0 {
  1676  		fuzzamount := 100
  1677  		for i := 0; i < fuzzamount; i++ {
  1678  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1679  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1680  		}
  1681  		// shouldn't panic
  1682  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1683  	}
  1684  }
  1685  
  1686  func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) {
  1687  	popr := math_rand.New(math_rand.NewSource(616))
  1688  	total := 0
  1689  	pops := make([]*NinNestedStructUnion, 10000)
  1690  	for i := 0; i < 10000; i++ {
  1691  		pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
  1692  	}
  1693  	b.ResetTimer()
  1694  	for i := 0; i < b.N; i++ {
  1695  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1696  		if err != nil {
  1697  			panic(err)
  1698  		}
  1699  		total += len(dAtA)
  1700  	}
  1701  	b.SetBytes(int64(total / b.N))
  1702  }
  1703  
  1704  func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) {
  1705  	popr := math_rand.New(math_rand.NewSource(616))
  1706  	total := 0
  1707  	datas := make([][]byte, 10000)
  1708  	for i := 0; i < 10000; i++ {
  1709  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false))
  1710  		if err != nil {
  1711  			panic(err)
  1712  		}
  1713  		datas[i] = dAtA
  1714  	}
  1715  	msg := &NinNestedStructUnion{}
  1716  	b.ResetTimer()
  1717  	for i := 0; i < b.N; i++ {
  1718  		total += len(datas[i%10000])
  1719  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1720  			panic(err)
  1721  		}
  1722  	}
  1723  	b.SetBytes(int64(total / b.N))
  1724  }
  1725  
  1726  func TestTreeProto(t *testing.T) {
  1727  	seed := time.Now().UnixNano()
  1728  	popr := math_rand.New(math_rand.NewSource(seed))
  1729  	p := NewPopulatedTree(popr, false)
  1730  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1731  	if err != nil {
  1732  		t.Fatalf("seed = %d, err = %v", seed, err)
  1733  	}
  1734  	msg := &Tree{}
  1735  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1736  		t.Fatalf("seed = %d, err = %v", seed, err)
  1737  	}
  1738  	littlefuzz := make([]byte, len(dAtA))
  1739  	copy(littlefuzz, dAtA)
  1740  	for i := range dAtA {
  1741  		dAtA[i] = byte(popr.Intn(256))
  1742  	}
  1743  	if err := p.VerboseEqual(msg); err != nil {
  1744  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1745  	}
  1746  	if !p.Equal(msg) {
  1747  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1748  	}
  1749  	if len(littlefuzz) > 0 {
  1750  		fuzzamount := 100
  1751  		for i := 0; i < fuzzamount; i++ {
  1752  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1753  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1754  		}
  1755  		// shouldn't panic
  1756  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1757  	}
  1758  }
  1759  
  1760  func BenchmarkTreeProtoMarshal(b *testing.B) {
  1761  	popr := math_rand.New(math_rand.NewSource(616))
  1762  	total := 0
  1763  	pops := make([]*Tree, 10000)
  1764  	for i := 0; i < 10000; i++ {
  1765  		pops[i] = NewPopulatedTree(popr, false)
  1766  	}
  1767  	b.ResetTimer()
  1768  	for i := 0; i < b.N; i++ {
  1769  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1770  		if err != nil {
  1771  			panic(err)
  1772  		}
  1773  		total += len(dAtA)
  1774  	}
  1775  	b.SetBytes(int64(total / b.N))
  1776  }
  1777  
  1778  func BenchmarkTreeProtoUnmarshal(b *testing.B) {
  1779  	popr := math_rand.New(math_rand.NewSource(616))
  1780  	total := 0
  1781  	datas := make([][]byte, 10000)
  1782  	for i := 0; i < 10000; i++ {
  1783  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false))
  1784  		if err != nil {
  1785  			panic(err)
  1786  		}
  1787  		datas[i] = dAtA
  1788  	}
  1789  	msg := &Tree{}
  1790  	b.ResetTimer()
  1791  	for i := 0; i < b.N; i++ {
  1792  		total += len(datas[i%10000])
  1793  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1794  			panic(err)
  1795  		}
  1796  	}
  1797  	b.SetBytes(int64(total / b.N))
  1798  }
  1799  
  1800  func TestOrBranchProto(t *testing.T) {
  1801  	seed := time.Now().UnixNano()
  1802  	popr := math_rand.New(math_rand.NewSource(seed))
  1803  	p := NewPopulatedOrBranch(popr, false)
  1804  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1805  	if err != nil {
  1806  		t.Fatalf("seed = %d, err = %v", seed, err)
  1807  	}
  1808  	msg := &OrBranch{}
  1809  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1810  		t.Fatalf("seed = %d, err = %v", seed, err)
  1811  	}
  1812  	littlefuzz := make([]byte, len(dAtA))
  1813  	copy(littlefuzz, dAtA)
  1814  	for i := range dAtA {
  1815  		dAtA[i] = byte(popr.Intn(256))
  1816  	}
  1817  	if err := p.VerboseEqual(msg); err != nil {
  1818  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1819  	}
  1820  	if !p.Equal(msg) {
  1821  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1822  	}
  1823  	if len(littlefuzz) > 0 {
  1824  		fuzzamount := 100
  1825  		for i := 0; i < fuzzamount; i++ {
  1826  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1827  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1828  		}
  1829  		// shouldn't panic
  1830  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1831  	}
  1832  }
  1833  
  1834  func BenchmarkOrBranchProtoMarshal(b *testing.B) {
  1835  	popr := math_rand.New(math_rand.NewSource(616))
  1836  	total := 0
  1837  	pops := make([]*OrBranch, 10000)
  1838  	for i := 0; i < 10000; i++ {
  1839  		pops[i] = NewPopulatedOrBranch(popr, false)
  1840  	}
  1841  	b.ResetTimer()
  1842  	for i := 0; i < b.N; i++ {
  1843  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1844  		if err != nil {
  1845  			panic(err)
  1846  		}
  1847  		total += len(dAtA)
  1848  	}
  1849  	b.SetBytes(int64(total / b.N))
  1850  }
  1851  
  1852  func BenchmarkOrBranchProtoUnmarshal(b *testing.B) {
  1853  	popr := math_rand.New(math_rand.NewSource(616))
  1854  	total := 0
  1855  	datas := make([][]byte, 10000)
  1856  	for i := 0; i < 10000; i++ {
  1857  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false))
  1858  		if err != nil {
  1859  			panic(err)
  1860  		}
  1861  		datas[i] = dAtA
  1862  	}
  1863  	msg := &OrBranch{}
  1864  	b.ResetTimer()
  1865  	for i := 0; i < b.N; i++ {
  1866  		total += len(datas[i%10000])
  1867  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1868  			panic(err)
  1869  		}
  1870  	}
  1871  	b.SetBytes(int64(total / b.N))
  1872  }
  1873  
  1874  func TestAndBranchProto(t *testing.T) {
  1875  	seed := time.Now().UnixNano()
  1876  	popr := math_rand.New(math_rand.NewSource(seed))
  1877  	p := NewPopulatedAndBranch(popr, false)
  1878  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1879  	if err != nil {
  1880  		t.Fatalf("seed = %d, err = %v", seed, err)
  1881  	}
  1882  	msg := &AndBranch{}
  1883  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1884  		t.Fatalf("seed = %d, err = %v", seed, err)
  1885  	}
  1886  	littlefuzz := make([]byte, len(dAtA))
  1887  	copy(littlefuzz, dAtA)
  1888  	for i := range dAtA {
  1889  		dAtA[i] = byte(popr.Intn(256))
  1890  	}
  1891  	if err := p.VerboseEqual(msg); err != nil {
  1892  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1893  	}
  1894  	if !p.Equal(msg) {
  1895  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1896  	}
  1897  	if len(littlefuzz) > 0 {
  1898  		fuzzamount := 100
  1899  		for i := 0; i < fuzzamount; i++ {
  1900  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1901  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1902  		}
  1903  		// shouldn't panic
  1904  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1905  	}
  1906  }
  1907  
  1908  func BenchmarkAndBranchProtoMarshal(b *testing.B) {
  1909  	popr := math_rand.New(math_rand.NewSource(616))
  1910  	total := 0
  1911  	pops := make([]*AndBranch, 10000)
  1912  	for i := 0; i < 10000; i++ {
  1913  		pops[i] = NewPopulatedAndBranch(popr, false)
  1914  	}
  1915  	b.ResetTimer()
  1916  	for i := 0; i < b.N; i++ {
  1917  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1918  		if err != nil {
  1919  			panic(err)
  1920  		}
  1921  		total += len(dAtA)
  1922  	}
  1923  	b.SetBytes(int64(total / b.N))
  1924  }
  1925  
  1926  func BenchmarkAndBranchProtoUnmarshal(b *testing.B) {
  1927  	popr := math_rand.New(math_rand.NewSource(616))
  1928  	total := 0
  1929  	datas := make([][]byte, 10000)
  1930  	for i := 0; i < 10000; i++ {
  1931  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false))
  1932  		if err != nil {
  1933  			panic(err)
  1934  		}
  1935  		datas[i] = dAtA
  1936  	}
  1937  	msg := &AndBranch{}
  1938  	b.ResetTimer()
  1939  	for i := 0; i < b.N; i++ {
  1940  		total += len(datas[i%10000])
  1941  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  1942  			panic(err)
  1943  		}
  1944  	}
  1945  	b.SetBytes(int64(total / b.N))
  1946  }
  1947  
  1948  func TestLeafProto(t *testing.T) {
  1949  	seed := time.Now().UnixNano()
  1950  	popr := math_rand.New(math_rand.NewSource(seed))
  1951  	p := NewPopulatedLeaf(popr, false)
  1952  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1953  	if err != nil {
  1954  		t.Fatalf("seed = %d, err = %v", seed, err)
  1955  	}
  1956  	msg := &Leaf{}
  1957  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1958  		t.Fatalf("seed = %d, err = %v", seed, err)
  1959  	}
  1960  	littlefuzz := make([]byte, len(dAtA))
  1961  	copy(littlefuzz, dAtA)
  1962  	for i := range dAtA {
  1963  		dAtA[i] = byte(popr.Intn(256))
  1964  	}
  1965  	if err := p.VerboseEqual(msg); err != nil {
  1966  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1967  	}
  1968  	if !p.Equal(msg) {
  1969  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1970  	}
  1971  	if len(littlefuzz) > 0 {
  1972  		fuzzamount := 100
  1973  		for i := 0; i < fuzzamount; i++ {
  1974  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  1975  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  1976  		}
  1977  		// shouldn't panic
  1978  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  1979  	}
  1980  }
  1981  
  1982  func BenchmarkLeafProtoMarshal(b *testing.B) {
  1983  	popr := math_rand.New(math_rand.NewSource(616))
  1984  	total := 0
  1985  	pops := make([]*Leaf, 10000)
  1986  	for i := 0; i < 10000; i++ {
  1987  		pops[i] = NewPopulatedLeaf(popr, false)
  1988  	}
  1989  	b.ResetTimer()
  1990  	for i := 0; i < b.N; i++ {
  1991  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  1992  		if err != nil {
  1993  			panic(err)
  1994  		}
  1995  		total += len(dAtA)
  1996  	}
  1997  	b.SetBytes(int64(total / b.N))
  1998  }
  1999  
  2000  func BenchmarkLeafProtoUnmarshal(b *testing.B) {
  2001  	popr := math_rand.New(math_rand.NewSource(616))
  2002  	total := 0
  2003  	datas := make([][]byte, 10000)
  2004  	for i := 0; i < 10000; i++ {
  2005  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false))
  2006  		if err != nil {
  2007  			panic(err)
  2008  		}
  2009  		datas[i] = dAtA
  2010  	}
  2011  	msg := &Leaf{}
  2012  	b.ResetTimer()
  2013  	for i := 0; i < b.N; i++ {
  2014  		total += len(datas[i%10000])
  2015  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2016  			panic(err)
  2017  		}
  2018  	}
  2019  	b.SetBytes(int64(total / b.N))
  2020  }
  2021  
  2022  func TestDeepTreeProto(t *testing.T) {
  2023  	seed := time.Now().UnixNano()
  2024  	popr := math_rand.New(math_rand.NewSource(seed))
  2025  	p := NewPopulatedDeepTree(popr, false)
  2026  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2027  	if err != nil {
  2028  		t.Fatalf("seed = %d, err = %v", seed, err)
  2029  	}
  2030  	msg := &DeepTree{}
  2031  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2032  		t.Fatalf("seed = %d, err = %v", seed, err)
  2033  	}
  2034  	littlefuzz := make([]byte, len(dAtA))
  2035  	copy(littlefuzz, dAtA)
  2036  	for i := range dAtA {
  2037  		dAtA[i] = byte(popr.Intn(256))
  2038  	}
  2039  	if err := p.VerboseEqual(msg); err != nil {
  2040  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2041  	}
  2042  	if !p.Equal(msg) {
  2043  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2044  	}
  2045  	if len(littlefuzz) > 0 {
  2046  		fuzzamount := 100
  2047  		for i := 0; i < fuzzamount; i++ {
  2048  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2049  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2050  		}
  2051  		// shouldn't panic
  2052  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2053  	}
  2054  }
  2055  
  2056  func BenchmarkDeepTreeProtoMarshal(b *testing.B) {
  2057  	popr := math_rand.New(math_rand.NewSource(616))
  2058  	total := 0
  2059  	pops := make([]*DeepTree, 10000)
  2060  	for i := 0; i < 10000; i++ {
  2061  		pops[i] = NewPopulatedDeepTree(popr, false)
  2062  	}
  2063  	b.ResetTimer()
  2064  	for i := 0; i < b.N; i++ {
  2065  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2066  		if err != nil {
  2067  			panic(err)
  2068  		}
  2069  		total += len(dAtA)
  2070  	}
  2071  	b.SetBytes(int64(total / b.N))
  2072  }
  2073  
  2074  func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) {
  2075  	popr := math_rand.New(math_rand.NewSource(616))
  2076  	total := 0
  2077  	datas := make([][]byte, 10000)
  2078  	for i := 0; i < 10000; i++ {
  2079  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false))
  2080  		if err != nil {
  2081  			panic(err)
  2082  		}
  2083  		datas[i] = dAtA
  2084  	}
  2085  	msg := &DeepTree{}
  2086  	b.ResetTimer()
  2087  	for i := 0; i < b.N; i++ {
  2088  		total += len(datas[i%10000])
  2089  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2090  			panic(err)
  2091  		}
  2092  	}
  2093  	b.SetBytes(int64(total / b.N))
  2094  }
  2095  
  2096  func TestADeepBranchProto(t *testing.T) {
  2097  	seed := time.Now().UnixNano()
  2098  	popr := math_rand.New(math_rand.NewSource(seed))
  2099  	p := NewPopulatedADeepBranch(popr, false)
  2100  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2101  	if err != nil {
  2102  		t.Fatalf("seed = %d, err = %v", seed, err)
  2103  	}
  2104  	msg := &ADeepBranch{}
  2105  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2106  		t.Fatalf("seed = %d, err = %v", seed, err)
  2107  	}
  2108  	littlefuzz := make([]byte, len(dAtA))
  2109  	copy(littlefuzz, dAtA)
  2110  	for i := range dAtA {
  2111  		dAtA[i] = byte(popr.Intn(256))
  2112  	}
  2113  	if err := p.VerboseEqual(msg); err != nil {
  2114  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2115  	}
  2116  	if !p.Equal(msg) {
  2117  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2118  	}
  2119  	if len(littlefuzz) > 0 {
  2120  		fuzzamount := 100
  2121  		for i := 0; i < fuzzamount; i++ {
  2122  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2123  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2124  		}
  2125  		// shouldn't panic
  2126  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2127  	}
  2128  }
  2129  
  2130  func BenchmarkADeepBranchProtoMarshal(b *testing.B) {
  2131  	popr := math_rand.New(math_rand.NewSource(616))
  2132  	total := 0
  2133  	pops := make([]*ADeepBranch, 10000)
  2134  	for i := 0; i < 10000; i++ {
  2135  		pops[i] = NewPopulatedADeepBranch(popr, false)
  2136  	}
  2137  	b.ResetTimer()
  2138  	for i := 0; i < b.N; i++ {
  2139  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2140  		if err != nil {
  2141  			panic(err)
  2142  		}
  2143  		total += len(dAtA)
  2144  	}
  2145  	b.SetBytes(int64(total / b.N))
  2146  }
  2147  
  2148  func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) {
  2149  	popr := math_rand.New(math_rand.NewSource(616))
  2150  	total := 0
  2151  	datas := make([][]byte, 10000)
  2152  	for i := 0; i < 10000; i++ {
  2153  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false))
  2154  		if err != nil {
  2155  			panic(err)
  2156  		}
  2157  		datas[i] = dAtA
  2158  	}
  2159  	msg := &ADeepBranch{}
  2160  	b.ResetTimer()
  2161  	for i := 0; i < b.N; i++ {
  2162  		total += len(datas[i%10000])
  2163  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2164  			panic(err)
  2165  		}
  2166  	}
  2167  	b.SetBytes(int64(total / b.N))
  2168  }
  2169  
  2170  func TestAndDeepBranchProto(t *testing.T) {
  2171  	seed := time.Now().UnixNano()
  2172  	popr := math_rand.New(math_rand.NewSource(seed))
  2173  	p := NewPopulatedAndDeepBranch(popr, false)
  2174  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2175  	if err != nil {
  2176  		t.Fatalf("seed = %d, err = %v", seed, err)
  2177  	}
  2178  	msg := &AndDeepBranch{}
  2179  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2180  		t.Fatalf("seed = %d, err = %v", seed, err)
  2181  	}
  2182  	littlefuzz := make([]byte, len(dAtA))
  2183  	copy(littlefuzz, dAtA)
  2184  	for i := range dAtA {
  2185  		dAtA[i] = byte(popr.Intn(256))
  2186  	}
  2187  	if err := p.VerboseEqual(msg); err != nil {
  2188  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2189  	}
  2190  	if !p.Equal(msg) {
  2191  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2192  	}
  2193  	if len(littlefuzz) > 0 {
  2194  		fuzzamount := 100
  2195  		for i := 0; i < fuzzamount; i++ {
  2196  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2197  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2198  		}
  2199  		// shouldn't panic
  2200  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2201  	}
  2202  }
  2203  
  2204  func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) {
  2205  	popr := math_rand.New(math_rand.NewSource(616))
  2206  	total := 0
  2207  	pops := make([]*AndDeepBranch, 10000)
  2208  	for i := 0; i < 10000; i++ {
  2209  		pops[i] = NewPopulatedAndDeepBranch(popr, false)
  2210  	}
  2211  	b.ResetTimer()
  2212  	for i := 0; i < b.N; i++ {
  2213  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2214  		if err != nil {
  2215  			panic(err)
  2216  		}
  2217  		total += len(dAtA)
  2218  	}
  2219  	b.SetBytes(int64(total / b.N))
  2220  }
  2221  
  2222  func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) {
  2223  	popr := math_rand.New(math_rand.NewSource(616))
  2224  	total := 0
  2225  	datas := make([][]byte, 10000)
  2226  	for i := 0; i < 10000; i++ {
  2227  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false))
  2228  		if err != nil {
  2229  			panic(err)
  2230  		}
  2231  		datas[i] = dAtA
  2232  	}
  2233  	msg := &AndDeepBranch{}
  2234  	b.ResetTimer()
  2235  	for i := 0; i < b.N; i++ {
  2236  		total += len(datas[i%10000])
  2237  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2238  			panic(err)
  2239  		}
  2240  	}
  2241  	b.SetBytes(int64(total / b.N))
  2242  }
  2243  
  2244  func TestDeepLeafProto(t *testing.T) {
  2245  	seed := time.Now().UnixNano()
  2246  	popr := math_rand.New(math_rand.NewSource(seed))
  2247  	p := NewPopulatedDeepLeaf(popr, false)
  2248  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2249  	if err != nil {
  2250  		t.Fatalf("seed = %d, err = %v", seed, err)
  2251  	}
  2252  	msg := &DeepLeaf{}
  2253  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2254  		t.Fatalf("seed = %d, err = %v", seed, err)
  2255  	}
  2256  	littlefuzz := make([]byte, len(dAtA))
  2257  	copy(littlefuzz, dAtA)
  2258  	for i := range dAtA {
  2259  		dAtA[i] = byte(popr.Intn(256))
  2260  	}
  2261  	if err := p.VerboseEqual(msg); err != nil {
  2262  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2263  	}
  2264  	if !p.Equal(msg) {
  2265  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2266  	}
  2267  	if len(littlefuzz) > 0 {
  2268  		fuzzamount := 100
  2269  		for i := 0; i < fuzzamount; i++ {
  2270  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2271  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2272  		}
  2273  		// shouldn't panic
  2274  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2275  	}
  2276  }
  2277  
  2278  func BenchmarkDeepLeafProtoMarshal(b *testing.B) {
  2279  	popr := math_rand.New(math_rand.NewSource(616))
  2280  	total := 0
  2281  	pops := make([]*DeepLeaf, 10000)
  2282  	for i := 0; i < 10000; i++ {
  2283  		pops[i] = NewPopulatedDeepLeaf(popr, false)
  2284  	}
  2285  	b.ResetTimer()
  2286  	for i := 0; i < b.N; i++ {
  2287  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2288  		if err != nil {
  2289  			panic(err)
  2290  		}
  2291  		total += len(dAtA)
  2292  	}
  2293  	b.SetBytes(int64(total / b.N))
  2294  }
  2295  
  2296  func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) {
  2297  	popr := math_rand.New(math_rand.NewSource(616))
  2298  	total := 0
  2299  	datas := make([][]byte, 10000)
  2300  	for i := 0; i < 10000; i++ {
  2301  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false))
  2302  		if err != nil {
  2303  			panic(err)
  2304  		}
  2305  		datas[i] = dAtA
  2306  	}
  2307  	msg := &DeepLeaf{}
  2308  	b.ResetTimer()
  2309  	for i := 0; i < b.N; i++ {
  2310  		total += len(datas[i%10000])
  2311  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2312  			panic(err)
  2313  		}
  2314  	}
  2315  	b.SetBytes(int64(total / b.N))
  2316  }
  2317  
  2318  func TestNilProto(t *testing.T) {
  2319  	seed := time.Now().UnixNano()
  2320  	popr := math_rand.New(math_rand.NewSource(seed))
  2321  	p := NewPopulatedNil(popr, false)
  2322  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2323  	if err != nil {
  2324  		t.Fatalf("seed = %d, err = %v", seed, err)
  2325  	}
  2326  	msg := &Nil{}
  2327  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2328  		t.Fatalf("seed = %d, err = %v", seed, err)
  2329  	}
  2330  	littlefuzz := make([]byte, len(dAtA))
  2331  	copy(littlefuzz, dAtA)
  2332  	for i := range dAtA {
  2333  		dAtA[i] = byte(popr.Intn(256))
  2334  	}
  2335  	if err := p.VerboseEqual(msg); err != nil {
  2336  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2337  	}
  2338  	if !p.Equal(msg) {
  2339  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2340  	}
  2341  	if len(littlefuzz) > 0 {
  2342  		fuzzamount := 100
  2343  		for i := 0; i < fuzzamount; i++ {
  2344  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2345  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2346  		}
  2347  		// shouldn't panic
  2348  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2349  	}
  2350  }
  2351  
  2352  func BenchmarkNilProtoMarshal(b *testing.B) {
  2353  	popr := math_rand.New(math_rand.NewSource(616))
  2354  	total := 0
  2355  	pops := make([]*Nil, 10000)
  2356  	for i := 0; i < 10000; i++ {
  2357  		pops[i] = NewPopulatedNil(popr, false)
  2358  	}
  2359  	b.ResetTimer()
  2360  	for i := 0; i < b.N; i++ {
  2361  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2362  		if err != nil {
  2363  			panic(err)
  2364  		}
  2365  		total += len(dAtA)
  2366  	}
  2367  	b.SetBytes(int64(total / b.N))
  2368  }
  2369  
  2370  func BenchmarkNilProtoUnmarshal(b *testing.B) {
  2371  	popr := math_rand.New(math_rand.NewSource(616))
  2372  	total := 0
  2373  	datas := make([][]byte, 10000)
  2374  	for i := 0; i < 10000; i++ {
  2375  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false))
  2376  		if err != nil {
  2377  			panic(err)
  2378  		}
  2379  		datas[i] = dAtA
  2380  	}
  2381  	msg := &Nil{}
  2382  	b.ResetTimer()
  2383  	for i := 0; i < b.N; i++ {
  2384  		total += len(datas[i%10000])
  2385  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2386  			panic(err)
  2387  		}
  2388  	}
  2389  	b.SetBytes(int64(total / b.N))
  2390  }
  2391  
  2392  func TestNidOptEnumProto(t *testing.T) {
  2393  	seed := time.Now().UnixNano()
  2394  	popr := math_rand.New(math_rand.NewSource(seed))
  2395  	p := NewPopulatedNidOptEnum(popr, false)
  2396  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2397  	if err != nil {
  2398  		t.Fatalf("seed = %d, err = %v", seed, err)
  2399  	}
  2400  	msg := &NidOptEnum{}
  2401  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2402  		t.Fatalf("seed = %d, err = %v", seed, err)
  2403  	}
  2404  	littlefuzz := make([]byte, len(dAtA))
  2405  	copy(littlefuzz, dAtA)
  2406  	for i := range dAtA {
  2407  		dAtA[i] = byte(popr.Intn(256))
  2408  	}
  2409  	if err := p.VerboseEqual(msg); err != nil {
  2410  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2411  	}
  2412  	if !p.Equal(msg) {
  2413  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2414  	}
  2415  	if len(littlefuzz) > 0 {
  2416  		fuzzamount := 100
  2417  		for i := 0; i < fuzzamount; i++ {
  2418  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2419  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2420  		}
  2421  		// shouldn't panic
  2422  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2423  	}
  2424  }
  2425  
  2426  func BenchmarkNidOptEnumProtoMarshal(b *testing.B) {
  2427  	popr := math_rand.New(math_rand.NewSource(616))
  2428  	total := 0
  2429  	pops := make([]*NidOptEnum, 10000)
  2430  	for i := 0; i < 10000; i++ {
  2431  		pops[i] = NewPopulatedNidOptEnum(popr, false)
  2432  	}
  2433  	b.ResetTimer()
  2434  	for i := 0; i < b.N; i++ {
  2435  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2436  		if err != nil {
  2437  			panic(err)
  2438  		}
  2439  		total += len(dAtA)
  2440  	}
  2441  	b.SetBytes(int64(total / b.N))
  2442  }
  2443  
  2444  func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) {
  2445  	popr := math_rand.New(math_rand.NewSource(616))
  2446  	total := 0
  2447  	datas := make([][]byte, 10000)
  2448  	for i := 0; i < 10000; i++ {
  2449  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false))
  2450  		if err != nil {
  2451  			panic(err)
  2452  		}
  2453  		datas[i] = dAtA
  2454  	}
  2455  	msg := &NidOptEnum{}
  2456  	b.ResetTimer()
  2457  	for i := 0; i < b.N; i++ {
  2458  		total += len(datas[i%10000])
  2459  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2460  			panic(err)
  2461  		}
  2462  	}
  2463  	b.SetBytes(int64(total / b.N))
  2464  }
  2465  
  2466  func TestNinOptEnumProto(t *testing.T) {
  2467  	seed := time.Now().UnixNano()
  2468  	popr := math_rand.New(math_rand.NewSource(seed))
  2469  	p := NewPopulatedNinOptEnum(popr, false)
  2470  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2471  	if err != nil {
  2472  		t.Fatalf("seed = %d, err = %v", seed, err)
  2473  	}
  2474  	msg := &NinOptEnum{}
  2475  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2476  		t.Fatalf("seed = %d, err = %v", seed, err)
  2477  	}
  2478  	littlefuzz := make([]byte, len(dAtA))
  2479  	copy(littlefuzz, dAtA)
  2480  	for i := range dAtA {
  2481  		dAtA[i] = byte(popr.Intn(256))
  2482  	}
  2483  	if err := p.VerboseEqual(msg); err != nil {
  2484  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2485  	}
  2486  	if !p.Equal(msg) {
  2487  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2488  	}
  2489  	if len(littlefuzz) > 0 {
  2490  		fuzzamount := 100
  2491  		for i := 0; i < fuzzamount; i++ {
  2492  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2493  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2494  		}
  2495  		// shouldn't panic
  2496  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2497  	}
  2498  }
  2499  
  2500  func BenchmarkNinOptEnumProtoMarshal(b *testing.B) {
  2501  	popr := math_rand.New(math_rand.NewSource(616))
  2502  	total := 0
  2503  	pops := make([]*NinOptEnum, 10000)
  2504  	for i := 0; i < 10000; i++ {
  2505  		pops[i] = NewPopulatedNinOptEnum(popr, false)
  2506  	}
  2507  	b.ResetTimer()
  2508  	for i := 0; i < b.N; i++ {
  2509  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2510  		if err != nil {
  2511  			panic(err)
  2512  		}
  2513  		total += len(dAtA)
  2514  	}
  2515  	b.SetBytes(int64(total / b.N))
  2516  }
  2517  
  2518  func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) {
  2519  	popr := math_rand.New(math_rand.NewSource(616))
  2520  	total := 0
  2521  	datas := make([][]byte, 10000)
  2522  	for i := 0; i < 10000; i++ {
  2523  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false))
  2524  		if err != nil {
  2525  			panic(err)
  2526  		}
  2527  		datas[i] = dAtA
  2528  	}
  2529  	msg := &NinOptEnum{}
  2530  	b.ResetTimer()
  2531  	for i := 0; i < b.N; i++ {
  2532  		total += len(datas[i%10000])
  2533  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2534  			panic(err)
  2535  		}
  2536  	}
  2537  	b.SetBytes(int64(total / b.N))
  2538  }
  2539  
  2540  func TestNidRepEnumProto(t *testing.T) {
  2541  	seed := time.Now().UnixNano()
  2542  	popr := math_rand.New(math_rand.NewSource(seed))
  2543  	p := NewPopulatedNidRepEnum(popr, false)
  2544  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2545  	if err != nil {
  2546  		t.Fatalf("seed = %d, err = %v", seed, err)
  2547  	}
  2548  	msg := &NidRepEnum{}
  2549  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2550  		t.Fatalf("seed = %d, err = %v", seed, err)
  2551  	}
  2552  	littlefuzz := make([]byte, len(dAtA))
  2553  	copy(littlefuzz, dAtA)
  2554  	for i := range dAtA {
  2555  		dAtA[i] = byte(popr.Intn(256))
  2556  	}
  2557  	if err := p.VerboseEqual(msg); err != nil {
  2558  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2559  	}
  2560  	if !p.Equal(msg) {
  2561  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2562  	}
  2563  	if len(littlefuzz) > 0 {
  2564  		fuzzamount := 100
  2565  		for i := 0; i < fuzzamount; i++ {
  2566  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2567  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2568  		}
  2569  		// shouldn't panic
  2570  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2571  	}
  2572  }
  2573  
  2574  func BenchmarkNidRepEnumProtoMarshal(b *testing.B) {
  2575  	popr := math_rand.New(math_rand.NewSource(616))
  2576  	total := 0
  2577  	pops := make([]*NidRepEnum, 10000)
  2578  	for i := 0; i < 10000; i++ {
  2579  		pops[i] = NewPopulatedNidRepEnum(popr, false)
  2580  	}
  2581  	b.ResetTimer()
  2582  	for i := 0; i < b.N; i++ {
  2583  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2584  		if err != nil {
  2585  			panic(err)
  2586  		}
  2587  		total += len(dAtA)
  2588  	}
  2589  	b.SetBytes(int64(total / b.N))
  2590  }
  2591  
  2592  func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) {
  2593  	popr := math_rand.New(math_rand.NewSource(616))
  2594  	total := 0
  2595  	datas := make([][]byte, 10000)
  2596  	for i := 0; i < 10000; i++ {
  2597  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false))
  2598  		if err != nil {
  2599  			panic(err)
  2600  		}
  2601  		datas[i] = dAtA
  2602  	}
  2603  	msg := &NidRepEnum{}
  2604  	b.ResetTimer()
  2605  	for i := 0; i < b.N; i++ {
  2606  		total += len(datas[i%10000])
  2607  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2608  			panic(err)
  2609  		}
  2610  	}
  2611  	b.SetBytes(int64(total / b.N))
  2612  }
  2613  
  2614  func TestNinRepEnumProto(t *testing.T) {
  2615  	seed := time.Now().UnixNano()
  2616  	popr := math_rand.New(math_rand.NewSource(seed))
  2617  	p := NewPopulatedNinRepEnum(popr, false)
  2618  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2619  	if err != nil {
  2620  		t.Fatalf("seed = %d, err = %v", seed, err)
  2621  	}
  2622  	msg := &NinRepEnum{}
  2623  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2624  		t.Fatalf("seed = %d, err = %v", seed, err)
  2625  	}
  2626  	littlefuzz := make([]byte, len(dAtA))
  2627  	copy(littlefuzz, dAtA)
  2628  	for i := range dAtA {
  2629  		dAtA[i] = byte(popr.Intn(256))
  2630  	}
  2631  	if err := p.VerboseEqual(msg); err != nil {
  2632  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2633  	}
  2634  	if !p.Equal(msg) {
  2635  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2636  	}
  2637  	if len(littlefuzz) > 0 {
  2638  		fuzzamount := 100
  2639  		for i := 0; i < fuzzamount; i++ {
  2640  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2641  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2642  		}
  2643  		// shouldn't panic
  2644  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2645  	}
  2646  }
  2647  
  2648  func BenchmarkNinRepEnumProtoMarshal(b *testing.B) {
  2649  	popr := math_rand.New(math_rand.NewSource(616))
  2650  	total := 0
  2651  	pops := make([]*NinRepEnum, 10000)
  2652  	for i := 0; i < 10000; i++ {
  2653  		pops[i] = NewPopulatedNinRepEnum(popr, false)
  2654  	}
  2655  	b.ResetTimer()
  2656  	for i := 0; i < b.N; i++ {
  2657  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2658  		if err != nil {
  2659  			panic(err)
  2660  		}
  2661  		total += len(dAtA)
  2662  	}
  2663  	b.SetBytes(int64(total / b.N))
  2664  }
  2665  
  2666  func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) {
  2667  	popr := math_rand.New(math_rand.NewSource(616))
  2668  	total := 0
  2669  	datas := make([][]byte, 10000)
  2670  	for i := 0; i < 10000; i++ {
  2671  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false))
  2672  		if err != nil {
  2673  			panic(err)
  2674  		}
  2675  		datas[i] = dAtA
  2676  	}
  2677  	msg := &NinRepEnum{}
  2678  	b.ResetTimer()
  2679  	for i := 0; i < b.N; i++ {
  2680  		total += len(datas[i%10000])
  2681  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2682  			panic(err)
  2683  		}
  2684  	}
  2685  	b.SetBytes(int64(total / b.N))
  2686  }
  2687  
  2688  func TestNinOptEnumDefaultProto(t *testing.T) {
  2689  	seed := time.Now().UnixNano()
  2690  	popr := math_rand.New(math_rand.NewSource(seed))
  2691  	p := NewPopulatedNinOptEnumDefault(popr, false)
  2692  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2693  	if err != nil {
  2694  		t.Fatalf("seed = %d, err = %v", seed, err)
  2695  	}
  2696  	msg := &NinOptEnumDefault{}
  2697  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2698  		t.Fatalf("seed = %d, err = %v", seed, err)
  2699  	}
  2700  	littlefuzz := make([]byte, len(dAtA))
  2701  	copy(littlefuzz, dAtA)
  2702  	for i := range dAtA {
  2703  		dAtA[i] = byte(popr.Intn(256))
  2704  	}
  2705  	if err := p.VerboseEqual(msg); err != nil {
  2706  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2707  	}
  2708  	if !p.Equal(msg) {
  2709  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2710  	}
  2711  	if len(littlefuzz) > 0 {
  2712  		fuzzamount := 100
  2713  		for i := 0; i < fuzzamount; i++ {
  2714  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2715  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2716  		}
  2717  		// shouldn't panic
  2718  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2719  	}
  2720  }
  2721  
  2722  func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) {
  2723  	popr := math_rand.New(math_rand.NewSource(616))
  2724  	total := 0
  2725  	pops := make([]*NinOptEnumDefault, 10000)
  2726  	for i := 0; i < 10000; i++ {
  2727  		pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
  2728  	}
  2729  	b.ResetTimer()
  2730  	for i := 0; i < b.N; i++ {
  2731  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2732  		if err != nil {
  2733  			panic(err)
  2734  		}
  2735  		total += len(dAtA)
  2736  	}
  2737  	b.SetBytes(int64(total / b.N))
  2738  }
  2739  
  2740  func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
  2741  	popr := math_rand.New(math_rand.NewSource(616))
  2742  	total := 0
  2743  	datas := make([][]byte, 10000)
  2744  	for i := 0; i < 10000; i++ {
  2745  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false))
  2746  		if err != nil {
  2747  			panic(err)
  2748  		}
  2749  		datas[i] = dAtA
  2750  	}
  2751  	msg := &NinOptEnumDefault{}
  2752  	b.ResetTimer()
  2753  	for i := 0; i < b.N; i++ {
  2754  		total += len(datas[i%10000])
  2755  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2756  			panic(err)
  2757  		}
  2758  	}
  2759  	b.SetBytes(int64(total / b.N))
  2760  }
  2761  
  2762  func TestAnotherNinOptEnumProto(t *testing.T) {
  2763  	seed := time.Now().UnixNano()
  2764  	popr := math_rand.New(math_rand.NewSource(seed))
  2765  	p := NewPopulatedAnotherNinOptEnum(popr, false)
  2766  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2767  	if err != nil {
  2768  		t.Fatalf("seed = %d, err = %v", seed, err)
  2769  	}
  2770  	msg := &AnotherNinOptEnum{}
  2771  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2772  		t.Fatalf("seed = %d, err = %v", seed, err)
  2773  	}
  2774  	littlefuzz := make([]byte, len(dAtA))
  2775  	copy(littlefuzz, dAtA)
  2776  	for i := range dAtA {
  2777  		dAtA[i] = byte(popr.Intn(256))
  2778  	}
  2779  	if err := p.VerboseEqual(msg); err != nil {
  2780  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2781  	}
  2782  	if !p.Equal(msg) {
  2783  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2784  	}
  2785  	if len(littlefuzz) > 0 {
  2786  		fuzzamount := 100
  2787  		for i := 0; i < fuzzamount; i++ {
  2788  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2789  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2790  		}
  2791  		// shouldn't panic
  2792  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2793  	}
  2794  }
  2795  
  2796  func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) {
  2797  	popr := math_rand.New(math_rand.NewSource(616))
  2798  	total := 0
  2799  	pops := make([]*AnotherNinOptEnum, 10000)
  2800  	for i := 0; i < 10000; i++ {
  2801  		pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
  2802  	}
  2803  	b.ResetTimer()
  2804  	for i := 0; i < b.N; i++ {
  2805  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2806  		if err != nil {
  2807  			panic(err)
  2808  		}
  2809  		total += len(dAtA)
  2810  	}
  2811  	b.SetBytes(int64(total / b.N))
  2812  }
  2813  
  2814  func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) {
  2815  	popr := math_rand.New(math_rand.NewSource(616))
  2816  	total := 0
  2817  	datas := make([][]byte, 10000)
  2818  	for i := 0; i < 10000; i++ {
  2819  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false))
  2820  		if err != nil {
  2821  			panic(err)
  2822  		}
  2823  		datas[i] = dAtA
  2824  	}
  2825  	msg := &AnotherNinOptEnum{}
  2826  	b.ResetTimer()
  2827  	for i := 0; i < b.N; i++ {
  2828  		total += len(datas[i%10000])
  2829  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2830  			panic(err)
  2831  		}
  2832  	}
  2833  	b.SetBytes(int64(total / b.N))
  2834  }
  2835  
  2836  func TestAnotherNinOptEnumDefaultProto(t *testing.T) {
  2837  	seed := time.Now().UnixNano()
  2838  	popr := math_rand.New(math_rand.NewSource(seed))
  2839  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
  2840  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2841  	if err != nil {
  2842  		t.Fatalf("seed = %d, err = %v", seed, err)
  2843  	}
  2844  	msg := &AnotherNinOptEnumDefault{}
  2845  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2846  		t.Fatalf("seed = %d, err = %v", seed, err)
  2847  	}
  2848  	littlefuzz := make([]byte, len(dAtA))
  2849  	copy(littlefuzz, dAtA)
  2850  	for i := range dAtA {
  2851  		dAtA[i] = byte(popr.Intn(256))
  2852  	}
  2853  	if err := p.VerboseEqual(msg); err != nil {
  2854  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2855  	}
  2856  	if !p.Equal(msg) {
  2857  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2858  	}
  2859  	if len(littlefuzz) > 0 {
  2860  		fuzzamount := 100
  2861  		for i := 0; i < fuzzamount; i++ {
  2862  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2863  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2864  		}
  2865  		// shouldn't panic
  2866  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2867  	}
  2868  }
  2869  
  2870  func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) {
  2871  	popr := math_rand.New(math_rand.NewSource(616))
  2872  	total := 0
  2873  	pops := make([]*AnotherNinOptEnumDefault, 10000)
  2874  	for i := 0; i < 10000; i++ {
  2875  		pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
  2876  	}
  2877  	b.ResetTimer()
  2878  	for i := 0; i < b.N; i++ {
  2879  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2880  		if err != nil {
  2881  			panic(err)
  2882  		}
  2883  		total += len(dAtA)
  2884  	}
  2885  	b.SetBytes(int64(total / b.N))
  2886  }
  2887  
  2888  func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) {
  2889  	popr := math_rand.New(math_rand.NewSource(616))
  2890  	total := 0
  2891  	datas := make([][]byte, 10000)
  2892  	for i := 0; i < 10000; i++ {
  2893  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false))
  2894  		if err != nil {
  2895  			panic(err)
  2896  		}
  2897  		datas[i] = dAtA
  2898  	}
  2899  	msg := &AnotherNinOptEnumDefault{}
  2900  	b.ResetTimer()
  2901  	for i := 0; i < b.N; i++ {
  2902  		total += len(datas[i%10000])
  2903  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2904  			panic(err)
  2905  		}
  2906  	}
  2907  	b.SetBytes(int64(total / b.N))
  2908  }
  2909  
  2910  func TestTimerProto(t *testing.T) {
  2911  	seed := time.Now().UnixNano()
  2912  	popr := math_rand.New(math_rand.NewSource(seed))
  2913  	p := NewPopulatedTimer(popr, false)
  2914  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2915  	if err != nil {
  2916  		t.Fatalf("seed = %d, err = %v", seed, err)
  2917  	}
  2918  	msg := &Timer{}
  2919  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2920  		t.Fatalf("seed = %d, err = %v", seed, err)
  2921  	}
  2922  	littlefuzz := make([]byte, len(dAtA))
  2923  	copy(littlefuzz, dAtA)
  2924  	for i := range dAtA {
  2925  		dAtA[i] = byte(popr.Intn(256))
  2926  	}
  2927  	if err := p.VerboseEqual(msg); err != nil {
  2928  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  2929  	}
  2930  	if !p.Equal(msg) {
  2931  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  2932  	}
  2933  	if len(littlefuzz) > 0 {
  2934  		fuzzamount := 100
  2935  		for i := 0; i < fuzzamount; i++ {
  2936  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  2937  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  2938  		}
  2939  		// shouldn't panic
  2940  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  2941  	}
  2942  }
  2943  
  2944  func BenchmarkTimerProtoMarshal(b *testing.B) {
  2945  	popr := math_rand.New(math_rand.NewSource(616))
  2946  	total := 0
  2947  	pops := make([]*Timer, 10000)
  2948  	for i := 0; i < 10000; i++ {
  2949  		pops[i] = NewPopulatedTimer(popr, false)
  2950  	}
  2951  	b.ResetTimer()
  2952  	for i := 0; i < b.N; i++ {
  2953  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  2954  		if err != nil {
  2955  			panic(err)
  2956  		}
  2957  		total += len(dAtA)
  2958  	}
  2959  	b.SetBytes(int64(total / b.N))
  2960  }
  2961  
  2962  func BenchmarkTimerProtoUnmarshal(b *testing.B) {
  2963  	popr := math_rand.New(math_rand.NewSource(616))
  2964  	total := 0
  2965  	datas := make([][]byte, 10000)
  2966  	for i := 0; i < 10000; i++ {
  2967  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false))
  2968  		if err != nil {
  2969  			panic(err)
  2970  		}
  2971  		datas[i] = dAtA
  2972  	}
  2973  	msg := &Timer{}
  2974  	b.ResetTimer()
  2975  	for i := 0; i < b.N; i++ {
  2976  		total += len(datas[i%10000])
  2977  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  2978  			panic(err)
  2979  		}
  2980  	}
  2981  	b.SetBytes(int64(total / b.N))
  2982  }
  2983  
  2984  func TestMyExtendableProto(t *testing.T) {
  2985  	seed := time.Now().UnixNano()
  2986  	popr := math_rand.New(math_rand.NewSource(seed))
  2987  	p := NewPopulatedMyExtendable(popr, false)
  2988  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2989  	if err != nil {
  2990  		t.Fatalf("seed = %d, err = %v", seed, err)
  2991  	}
  2992  	msg := &MyExtendable{}
  2993  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  2994  		t.Fatalf("seed = %d, err = %v", seed, err)
  2995  	}
  2996  	littlefuzz := make([]byte, len(dAtA))
  2997  	copy(littlefuzz, dAtA)
  2998  	for i := range dAtA {
  2999  		dAtA[i] = byte(popr.Intn(256))
  3000  	}
  3001  	if err := p.VerboseEqual(msg); err != nil {
  3002  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3003  	}
  3004  	if !p.Equal(msg) {
  3005  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3006  	}
  3007  	if len(littlefuzz) > 0 {
  3008  		fuzzamount := 100
  3009  		for i := 0; i < fuzzamount; i++ {
  3010  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3011  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3012  		}
  3013  		// shouldn't panic
  3014  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3015  	}
  3016  }
  3017  
  3018  func BenchmarkMyExtendableProtoMarshal(b *testing.B) {
  3019  	popr := math_rand.New(math_rand.NewSource(616))
  3020  	total := 0
  3021  	pops := make([]*MyExtendable, 10000)
  3022  	for i := 0; i < 10000; i++ {
  3023  		pops[i] = NewPopulatedMyExtendable(popr, false)
  3024  	}
  3025  	b.ResetTimer()
  3026  	for i := 0; i < b.N; i++ {
  3027  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3028  		if err != nil {
  3029  			panic(err)
  3030  		}
  3031  		total += len(dAtA)
  3032  	}
  3033  	b.SetBytes(int64(total / b.N))
  3034  }
  3035  
  3036  func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) {
  3037  	popr := math_rand.New(math_rand.NewSource(616))
  3038  	total := 0
  3039  	datas := make([][]byte, 10000)
  3040  	for i := 0; i < 10000; i++ {
  3041  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false))
  3042  		if err != nil {
  3043  			panic(err)
  3044  		}
  3045  		datas[i] = dAtA
  3046  	}
  3047  	msg := &MyExtendable{}
  3048  	b.ResetTimer()
  3049  	for i := 0; i < b.N; i++ {
  3050  		total += len(datas[i%10000])
  3051  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3052  			panic(err)
  3053  		}
  3054  	}
  3055  	b.SetBytes(int64(total / b.N))
  3056  }
  3057  
  3058  func TestOtherExtenableProto(t *testing.T) {
  3059  	seed := time.Now().UnixNano()
  3060  	popr := math_rand.New(math_rand.NewSource(seed))
  3061  	p := NewPopulatedOtherExtenable(popr, false)
  3062  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3063  	if err != nil {
  3064  		t.Fatalf("seed = %d, err = %v", seed, err)
  3065  	}
  3066  	msg := &OtherExtenable{}
  3067  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3068  		t.Fatalf("seed = %d, err = %v", seed, err)
  3069  	}
  3070  	littlefuzz := make([]byte, len(dAtA))
  3071  	copy(littlefuzz, dAtA)
  3072  	for i := range dAtA {
  3073  		dAtA[i] = byte(popr.Intn(256))
  3074  	}
  3075  	if err := p.VerboseEqual(msg); err != nil {
  3076  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3077  	}
  3078  	if !p.Equal(msg) {
  3079  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3080  	}
  3081  	if len(littlefuzz) > 0 {
  3082  		fuzzamount := 100
  3083  		for i := 0; i < fuzzamount; i++ {
  3084  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3085  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3086  		}
  3087  		// shouldn't panic
  3088  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3089  	}
  3090  }
  3091  
  3092  func BenchmarkOtherExtenableProtoMarshal(b *testing.B) {
  3093  	popr := math_rand.New(math_rand.NewSource(616))
  3094  	total := 0
  3095  	pops := make([]*OtherExtenable, 10000)
  3096  	for i := 0; i < 10000; i++ {
  3097  		pops[i] = NewPopulatedOtherExtenable(popr, false)
  3098  	}
  3099  	b.ResetTimer()
  3100  	for i := 0; i < b.N; i++ {
  3101  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3102  		if err != nil {
  3103  			panic(err)
  3104  		}
  3105  		total += len(dAtA)
  3106  	}
  3107  	b.SetBytes(int64(total / b.N))
  3108  }
  3109  
  3110  func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) {
  3111  	popr := math_rand.New(math_rand.NewSource(616))
  3112  	total := 0
  3113  	datas := make([][]byte, 10000)
  3114  	for i := 0; i < 10000; i++ {
  3115  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false))
  3116  		if err != nil {
  3117  			panic(err)
  3118  		}
  3119  		datas[i] = dAtA
  3120  	}
  3121  	msg := &OtherExtenable{}
  3122  	b.ResetTimer()
  3123  	for i := 0; i < b.N; i++ {
  3124  		total += len(datas[i%10000])
  3125  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3126  			panic(err)
  3127  		}
  3128  	}
  3129  	b.SetBytes(int64(total / b.N))
  3130  }
  3131  
  3132  func TestNestedDefinitionProto(t *testing.T) {
  3133  	seed := time.Now().UnixNano()
  3134  	popr := math_rand.New(math_rand.NewSource(seed))
  3135  	p := NewPopulatedNestedDefinition(popr, false)
  3136  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3137  	if err != nil {
  3138  		t.Fatalf("seed = %d, err = %v", seed, err)
  3139  	}
  3140  	msg := &NestedDefinition{}
  3141  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3142  		t.Fatalf("seed = %d, err = %v", seed, err)
  3143  	}
  3144  	littlefuzz := make([]byte, len(dAtA))
  3145  	copy(littlefuzz, dAtA)
  3146  	for i := range dAtA {
  3147  		dAtA[i] = byte(popr.Intn(256))
  3148  	}
  3149  	if err := p.VerboseEqual(msg); err != nil {
  3150  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3151  	}
  3152  	if !p.Equal(msg) {
  3153  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3154  	}
  3155  	if len(littlefuzz) > 0 {
  3156  		fuzzamount := 100
  3157  		for i := 0; i < fuzzamount; i++ {
  3158  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3159  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3160  		}
  3161  		// shouldn't panic
  3162  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3163  	}
  3164  }
  3165  
  3166  func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) {
  3167  	popr := math_rand.New(math_rand.NewSource(616))
  3168  	total := 0
  3169  	pops := make([]*NestedDefinition, 10000)
  3170  	for i := 0; i < 10000; i++ {
  3171  		pops[i] = NewPopulatedNestedDefinition(popr, false)
  3172  	}
  3173  	b.ResetTimer()
  3174  	for i := 0; i < b.N; i++ {
  3175  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3176  		if err != nil {
  3177  			panic(err)
  3178  		}
  3179  		total += len(dAtA)
  3180  	}
  3181  	b.SetBytes(int64(total / b.N))
  3182  }
  3183  
  3184  func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) {
  3185  	popr := math_rand.New(math_rand.NewSource(616))
  3186  	total := 0
  3187  	datas := make([][]byte, 10000)
  3188  	for i := 0; i < 10000; i++ {
  3189  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false))
  3190  		if err != nil {
  3191  			panic(err)
  3192  		}
  3193  		datas[i] = dAtA
  3194  	}
  3195  	msg := &NestedDefinition{}
  3196  	b.ResetTimer()
  3197  	for i := 0; i < b.N; i++ {
  3198  		total += len(datas[i%10000])
  3199  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3200  			panic(err)
  3201  		}
  3202  	}
  3203  	b.SetBytes(int64(total / b.N))
  3204  }
  3205  
  3206  func TestNestedDefinition_NestedMessageProto(t *testing.T) {
  3207  	seed := time.Now().UnixNano()
  3208  	popr := math_rand.New(math_rand.NewSource(seed))
  3209  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
  3210  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3211  	if err != nil {
  3212  		t.Fatalf("seed = %d, err = %v", seed, err)
  3213  	}
  3214  	msg := &NestedDefinition_NestedMessage{}
  3215  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3216  		t.Fatalf("seed = %d, err = %v", seed, err)
  3217  	}
  3218  	littlefuzz := make([]byte, len(dAtA))
  3219  	copy(littlefuzz, dAtA)
  3220  	for i := range dAtA {
  3221  		dAtA[i] = byte(popr.Intn(256))
  3222  	}
  3223  	if err := p.VerboseEqual(msg); err != nil {
  3224  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3225  	}
  3226  	if !p.Equal(msg) {
  3227  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3228  	}
  3229  	if len(littlefuzz) > 0 {
  3230  		fuzzamount := 100
  3231  		for i := 0; i < fuzzamount; i++ {
  3232  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3233  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3234  		}
  3235  		// shouldn't panic
  3236  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3237  	}
  3238  }
  3239  
  3240  func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) {
  3241  	popr := math_rand.New(math_rand.NewSource(616))
  3242  	total := 0
  3243  	pops := make([]*NestedDefinition_NestedMessage, 10000)
  3244  	for i := 0; i < 10000; i++ {
  3245  		pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
  3246  	}
  3247  	b.ResetTimer()
  3248  	for i := 0; i < b.N; i++ {
  3249  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3250  		if err != nil {
  3251  			panic(err)
  3252  		}
  3253  		total += len(dAtA)
  3254  	}
  3255  	b.SetBytes(int64(total / b.N))
  3256  }
  3257  
  3258  func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) {
  3259  	popr := math_rand.New(math_rand.NewSource(616))
  3260  	total := 0
  3261  	datas := make([][]byte, 10000)
  3262  	for i := 0; i < 10000; i++ {
  3263  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false))
  3264  		if err != nil {
  3265  			panic(err)
  3266  		}
  3267  		datas[i] = dAtA
  3268  	}
  3269  	msg := &NestedDefinition_NestedMessage{}
  3270  	b.ResetTimer()
  3271  	for i := 0; i < b.N; i++ {
  3272  		total += len(datas[i%10000])
  3273  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3274  			panic(err)
  3275  		}
  3276  	}
  3277  	b.SetBytes(int64(total / b.N))
  3278  }
  3279  
  3280  func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) {
  3281  	seed := time.Now().UnixNano()
  3282  	popr := math_rand.New(math_rand.NewSource(seed))
  3283  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  3284  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3285  	if err != nil {
  3286  		t.Fatalf("seed = %d, err = %v", seed, err)
  3287  	}
  3288  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  3289  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3290  		t.Fatalf("seed = %d, err = %v", seed, err)
  3291  	}
  3292  	littlefuzz := make([]byte, len(dAtA))
  3293  	copy(littlefuzz, dAtA)
  3294  	for i := range dAtA {
  3295  		dAtA[i] = byte(popr.Intn(256))
  3296  	}
  3297  	if err := p.VerboseEqual(msg); err != nil {
  3298  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3299  	}
  3300  	if !p.Equal(msg) {
  3301  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3302  	}
  3303  	if len(littlefuzz) > 0 {
  3304  		fuzzamount := 100
  3305  		for i := 0; i < fuzzamount; i++ {
  3306  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3307  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3308  		}
  3309  		// shouldn't panic
  3310  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3311  	}
  3312  }
  3313  
  3314  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) {
  3315  	popr := math_rand.New(math_rand.NewSource(616))
  3316  	total := 0
  3317  	pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000)
  3318  	for i := 0; i < 10000; i++ {
  3319  		pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  3320  	}
  3321  	b.ResetTimer()
  3322  	for i := 0; i < b.N; i++ {
  3323  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3324  		if err != nil {
  3325  			panic(err)
  3326  		}
  3327  		total += len(dAtA)
  3328  	}
  3329  	b.SetBytes(int64(total / b.N))
  3330  }
  3331  
  3332  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) {
  3333  	popr := math_rand.New(math_rand.NewSource(616))
  3334  	total := 0
  3335  	datas := make([][]byte, 10000)
  3336  	for i := 0; i < 10000; i++ {
  3337  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false))
  3338  		if err != nil {
  3339  			panic(err)
  3340  		}
  3341  		datas[i] = dAtA
  3342  	}
  3343  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  3344  	b.ResetTimer()
  3345  	for i := 0; i < b.N; i++ {
  3346  		total += len(datas[i%10000])
  3347  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3348  			panic(err)
  3349  		}
  3350  	}
  3351  	b.SetBytes(int64(total / b.N))
  3352  }
  3353  
  3354  func TestNestedScopeProto(t *testing.T) {
  3355  	seed := time.Now().UnixNano()
  3356  	popr := math_rand.New(math_rand.NewSource(seed))
  3357  	p := NewPopulatedNestedScope(popr, false)
  3358  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3359  	if err != nil {
  3360  		t.Fatalf("seed = %d, err = %v", seed, err)
  3361  	}
  3362  	msg := &NestedScope{}
  3363  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3364  		t.Fatalf("seed = %d, err = %v", seed, err)
  3365  	}
  3366  	littlefuzz := make([]byte, len(dAtA))
  3367  	copy(littlefuzz, dAtA)
  3368  	for i := range dAtA {
  3369  		dAtA[i] = byte(popr.Intn(256))
  3370  	}
  3371  	if err := p.VerboseEqual(msg); err != nil {
  3372  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3373  	}
  3374  	if !p.Equal(msg) {
  3375  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3376  	}
  3377  	if len(littlefuzz) > 0 {
  3378  		fuzzamount := 100
  3379  		for i := 0; i < fuzzamount; i++ {
  3380  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3381  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3382  		}
  3383  		// shouldn't panic
  3384  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3385  	}
  3386  }
  3387  
  3388  func BenchmarkNestedScopeProtoMarshal(b *testing.B) {
  3389  	popr := math_rand.New(math_rand.NewSource(616))
  3390  	total := 0
  3391  	pops := make([]*NestedScope, 10000)
  3392  	for i := 0; i < 10000; i++ {
  3393  		pops[i] = NewPopulatedNestedScope(popr, false)
  3394  	}
  3395  	b.ResetTimer()
  3396  	for i := 0; i < b.N; i++ {
  3397  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3398  		if err != nil {
  3399  			panic(err)
  3400  		}
  3401  		total += len(dAtA)
  3402  	}
  3403  	b.SetBytes(int64(total / b.N))
  3404  }
  3405  
  3406  func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) {
  3407  	popr := math_rand.New(math_rand.NewSource(616))
  3408  	total := 0
  3409  	datas := make([][]byte, 10000)
  3410  	for i := 0; i < 10000; i++ {
  3411  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false))
  3412  		if err != nil {
  3413  			panic(err)
  3414  		}
  3415  		datas[i] = dAtA
  3416  	}
  3417  	msg := &NestedScope{}
  3418  	b.ResetTimer()
  3419  	for i := 0; i < b.N; i++ {
  3420  		total += len(datas[i%10000])
  3421  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3422  			panic(err)
  3423  		}
  3424  	}
  3425  	b.SetBytes(int64(total / b.N))
  3426  }
  3427  
  3428  func TestNinOptNativeDefaultProto(t *testing.T) {
  3429  	seed := time.Now().UnixNano()
  3430  	popr := math_rand.New(math_rand.NewSource(seed))
  3431  	p := NewPopulatedNinOptNativeDefault(popr, false)
  3432  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3433  	if err != nil {
  3434  		t.Fatalf("seed = %d, err = %v", seed, err)
  3435  	}
  3436  	msg := &NinOptNativeDefault{}
  3437  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3438  		t.Fatalf("seed = %d, err = %v", seed, err)
  3439  	}
  3440  	littlefuzz := make([]byte, len(dAtA))
  3441  	copy(littlefuzz, dAtA)
  3442  	for i := range dAtA {
  3443  		dAtA[i] = byte(popr.Intn(256))
  3444  	}
  3445  	if err := p.VerboseEqual(msg); err != nil {
  3446  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3447  	}
  3448  	if !p.Equal(msg) {
  3449  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3450  	}
  3451  	if len(littlefuzz) > 0 {
  3452  		fuzzamount := 100
  3453  		for i := 0; i < fuzzamount; i++ {
  3454  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3455  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3456  		}
  3457  		// shouldn't panic
  3458  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3459  	}
  3460  }
  3461  
  3462  func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) {
  3463  	popr := math_rand.New(math_rand.NewSource(616))
  3464  	total := 0
  3465  	pops := make([]*NinOptNativeDefault, 10000)
  3466  	for i := 0; i < 10000; i++ {
  3467  		pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
  3468  	}
  3469  	b.ResetTimer()
  3470  	for i := 0; i < b.N; i++ {
  3471  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3472  		if err != nil {
  3473  			panic(err)
  3474  		}
  3475  		total += len(dAtA)
  3476  	}
  3477  	b.SetBytes(int64(total / b.N))
  3478  }
  3479  
  3480  func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) {
  3481  	popr := math_rand.New(math_rand.NewSource(616))
  3482  	total := 0
  3483  	datas := make([][]byte, 10000)
  3484  	for i := 0; i < 10000; i++ {
  3485  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false))
  3486  		if err != nil {
  3487  			panic(err)
  3488  		}
  3489  		datas[i] = dAtA
  3490  	}
  3491  	msg := &NinOptNativeDefault{}
  3492  	b.ResetTimer()
  3493  	for i := 0; i < b.N; i++ {
  3494  		total += len(datas[i%10000])
  3495  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3496  			panic(err)
  3497  		}
  3498  	}
  3499  	b.SetBytes(int64(total / b.N))
  3500  }
  3501  
  3502  func TestCustomContainerProto(t *testing.T) {
  3503  	seed := time.Now().UnixNano()
  3504  	popr := math_rand.New(math_rand.NewSource(seed))
  3505  	p := NewPopulatedCustomContainer(popr, false)
  3506  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3507  	if err != nil {
  3508  		t.Fatalf("seed = %d, err = %v", seed, err)
  3509  	}
  3510  	msg := &CustomContainer{}
  3511  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3512  		t.Fatalf("seed = %d, err = %v", seed, err)
  3513  	}
  3514  	littlefuzz := make([]byte, len(dAtA))
  3515  	copy(littlefuzz, dAtA)
  3516  	for i := range dAtA {
  3517  		dAtA[i] = byte(popr.Intn(256))
  3518  	}
  3519  	if err := p.VerboseEqual(msg); err != nil {
  3520  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3521  	}
  3522  	if !p.Equal(msg) {
  3523  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3524  	}
  3525  	if len(littlefuzz) > 0 {
  3526  		fuzzamount := 100
  3527  		for i := 0; i < fuzzamount; i++ {
  3528  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3529  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3530  		}
  3531  		// shouldn't panic
  3532  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3533  	}
  3534  }
  3535  
  3536  func BenchmarkCustomContainerProtoMarshal(b *testing.B) {
  3537  	popr := math_rand.New(math_rand.NewSource(616))
  3538  	total := 0
  3539  	pops := make([]*CustomContainer, 10000)
  3540  	for i := 0; i < 10000; i++ {
  3541  		pops[i] = NewPopulatedCustomContainer(popr, false)
  3542  	}
  3543  	b.ResetTimer()
  3544  	for i := 0; i < b.N; i++ {
  3545  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3546  		if err != nil {
  3547  			panic(err)
  3548  		}
  3549  		total += len(dAtA)
  3550  	}
  3551  	b.SetBytes(int64(total / b.N))
  3552  }
  3553  
  3554  func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) {
  3555  	popr := math_rand.New(math_rand.NewSource(616))
  3556  	total := 0
  3557  	datas := make([][]byte, 10000)
  3558  	for i := 0; i < 10000; i++ {
  3559  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false))
  3560  		if err != nil {
  3561  			panic(err)
  3562  		}
  3563  		datas[i] = dAtA
  3564  	}
  3565  	msg := &CustomContainer{}
  3566  	b.ResetTimer()
  3567  	for i := 0; i < b.N; i++ {
  3568  		total += len(datas[i%10000])
  3569  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3570  			panic(err)
  3571  		}
  3572  	}
  3573  	b.SetBytes(int64(total / b.N))
  3574  }
  3575  
  3576  func TestCustomNameNidOptNativeProto(t *testing.T) {
  3577  	seed := time.Now().UnixNano()
  3578  	popr := math_rand.New(math_rand.NewSource(seed))
  3579  	p := NewPopulatedCustomNameNidOptNative(popr, false)
  3580  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3581  	if err != nil {
  3582  		t.Fatalf("seed = %d, err = %v", seed, err)
  3583  	}
  3584  	msg := &CustomNameNidOptNative{}
  3585  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3586  		t.Fatalf("seed = %d, err = %v", seed, err)
  3587  	}
  3588  	littlefuzz := make([]byte, len(dAtA))
  3589  	copy(littlefuzz, dAtA)
  3590  	for i := range dAtA {
  3591  		dAtA[i] = byte(popr.Intn(256))
  3592  	}
  3593  	if err := p.VerboseEqual(msg); err != nil {
  3594  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3595  	}
  3596  	if !p.Equal(msg) {
  3597  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3598  	}
  3599  	if len(littlefuzz) > 0 {
  3600  		fuzzamount := 100
  3601  		for i := 0; i < fuzzamount; i++ {
  3602  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3603  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3604  		}
  3605  		// shouldn't panic
  3606  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3607  	}
  3608  }
  3609  
  3610  func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) {
  3611  	popr := math_rand.New(math_rand.NewSource(616))
  3612  	total := 0
  3613  	pops := make([]*CustomNameNidOptNative, 10000)
  3614  	for i := 0; i < 10000; i++ {
  3615  		pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
  3616  	}
  3617  	b.ResetTimer()
  3618  	for i := 0; i < b.N; i++ {
  3619  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3620  		if err != nil {
  3621  			panic(err)
  3622  		}
  3623  		total += len(dAtA)
  3624  	}
  3625  	b.SetBytes(int64(total / b.N))
  3626  }
  3627  
  3628  func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) {
  3629  	popr := math_rand.New(math_rand.NewSource(616))
  3630  	total := 0
  3631  	datas := make([][]byte, 10000)
  3632  	for i := 0; i < 10000; i++ {
  3633  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false))
  3634  		if err != nil {
  3635  			panic(err)
  3636  		}
  3637  		datas[i] = dAtA
  3638  	}
  3639  	msg := &CustomNameNidOptNative{}
  3640  	b.ResetTimer()
  3641  	for i := 0; i < b.N; i++ {
  3642  		total += len(datas[i%10000])
  3643  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3644  			panic(err)
  3645  		}
  3646  	}
  3647  	b.SetBytes(int64(total / b.N))
  3648  }
  3649  
  3650  func TestCustomNameNinOptNativeProto(t *testing.T) {
  3651  	seed := time.Now().UnixNano()
  3652  	popr := math_rand.New(math_rand.NewSource(seed))
  3653  	p := NewPopulatedCustomNameNinOptNative(popr, false)
  3654  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3655  	if err != nil {
  3656  		t.Fatalf("seed = %d, err = %v", seed, err)
  3657  	}
  3658  	msg := &CustomNameNinOptNative{}
  3659  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3660  		t.Fatalf("seed = %d, err = %v", seed, err)
  3661  	}
  3662  	littlefuzz := make([]byte, len(dAtA))
  3663  	copy(littlefuzz, dAtA)
  3664  	for i := range dAtA {
  3665  		dAtA[i] = byte(popr.Intn(256))
  3666  	}
  3667  	if err := p.VerboseEqual(msg); err != nil {
  3668  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3669  	}
  3670  	if !p.Equal(msg) {
  3671  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3672  	}
  3673  	if len(littlefuzz) > 0 {
  3674  		fuzzamount := 100
  3675  		for i := 0; i < fuzzamount; i++ {
  3676  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3677  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3678  		}
  3679  		// shouldn't panic
  3680  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3681  	}
  3682  }
  3683  
  3684  func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) {
  3685  	popr := math_rand.New(math_rand.NewSource(616))
  3686  	total := 0
  3687  	pops := make([]*CustomNameNinOptNative, 10000)
  3688  	for i := 0; i < 10000; i++ {
  3689  		pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
  3690  	}
  3691  	b.ResetTimer()
  3692  	for i := 0; i < b.N; i++ {
  3693  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3694  		if err != nil {
  3695  			panic(err)
  3696  		}
  3697  		total += len(dAtA)
  3698  	}
  3699  	b.SetBytes(int64(total / b.N))
  3700  }
  3701  
  3702  func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) {
  3703  	popr := math_rand.New(math_rand.NewSource(616))
  3704  	total := 0
  3705  	datas := make([][]byte, 10000)
  3706  	for i := 0; i < 10000; i++ {
  3707  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false))
  3708  		if err != nil {
  3709  			panic(err)
  3710  		}
  3711  		datas[i] = dAtA
  3712  	}
  3713  	msg := &CustomNameNinOptNative{}
  3714  	b.ResetTimer()
  3715  	for i := 0; i < b.N; i++ {
  3716  		total += len(datas[i%10000])
  3717  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3718  			panic(err)
  3719  		}
  3720  	}
  3721  	b.SetBytes(int64(total / b.N))
  3722  }
  3723  
  3724  func TestCustomNameNinRepNativeProto(t *testing.T) {
  3725  	seed := time.Now().UnixNano()
  3726  	popr := math_rand.New(math_rand.NewSource(seed))
  3727  	p := NewPopulatedCustomNameNinRepNative(popr, false)
  3728  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3729  	if err != nil {
  3730  		t.Fatalf("seed = %d, err = %v", seed, err)
  3731  	}
  3732  	msg := &CustomNameNinRepNative{}
  3733  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3734  		t.Fatalf("seed = %d, err = %v", seed, err)
  3735  	}
  3736  	littlefuzz := make([]byte, len(dAtA))
  3737  	copy(littlefuzz, dAtA)
  3738  	for i := range dAtA {
  3739  		dAtA[i] = byte(popr.Intn(256))
  3740  	}
  3741  	if err := p.VerboseEqual(msg); err != nil {
  3742  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3743  	}
  3744  	if !p.Equal(msg) {
  3745  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3746  	}
  3747  	if len(littlefuzz) > 0 {
  3748  		fuzzamount := 100
  3749  		for i := 0; i < fuzzamount; i++ {
  3750  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3751  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3752  		}
  3753  		// shouldn't panic
  3754  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3755  	}
  3756  }
  3757  
  3758  func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) {
  3759  	popr := math_rand.New(math_rand.NewSource(616))
  3760  	total := 0
  3761  	pops := make([]*CustomNameNinRepNative, 10000)
  3762  	for i := 0; i < 10000; i++ {
  3763  		pops[i] = NewPopulatedCustomNameNinRepNative(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 BenchmarkCustomNameNinRepNativeProtoUnmarshal(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(NewPopulatedCustomNameNinRepNative(popr, false))
  3782  		if err != nil {
  3783  			panic(err)
  3784  		}
  3785  		datas[i] = dAtA
  3786  	}
  3787  	msg := &CustomNameNinRepNative{}
  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 TestCustomNameNinStructProto(t *testing.T) {
  3799  	seed := time.Now().UnixNano()
  3800  	popr := math_rand.New(math_rand.NewSource(seed))
  3801  	p := NewPopulatedCustomNameNinStruct(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 := &CustomNameNinStruct{}
  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 BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) {
  3833  	popr := math_rand.New(math_rand.NewSource(616))
  3834  	total := 0
  3835  	pops := make([]*CustomNameNinStruct, 10000)
  3836  	for i := 0; i < 10000; i++ {
  3837  		pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
  3838  	}
  3839  	b.ResetTimer()
  3840  	for i := 0; i < b.N; i++ {
  3841  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3842  		if err != nil {
  3843  			panic(err)
  3844  		}
  3845  		total += len(dAtA)
  3846  	}
  3847  	b.SetBytes(int64(total / b.N))
  3848  }
  3849  
  3850  func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) {
  3851  	popr := math_rand.New(math_rand.NewSource(616))
  3852  	total := 0
  3853  	datas := make([][]byte, 10000)
  3854  	for i := 0; i < 10000; i++ {
  3855  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false))
  3856  		if err != nil {
  3857  			panic(err)
  3858  		}
  3859  		datas[i] = dAtA
  3860  	}
  3861  	msg := &CustomNameNinStruct{}
  3862  	b.ResetTimer()
  3863  	for i := 0; i < b.N; i++ {
  3864  		total += len(datas[i%10000])
  3865  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3866  			panic(err)
  3867  		}
  3868  	}
  3869  	b.SetBytes(int64(total / b.N))
  3870  }
  3871  
  3872  func TestCustomNameCustomTypeProto(t *testing.T) {
  3873  	seed := time.Now().UnixNano()
  3874  	popr := math_rand.New(math_rand.NewSource(seed))
  3875  	p := NewPopulatedCustomNameCustomType(popr, false)
  3876  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3877  	if err != nil {
  3878  		t.Fatalf("seed = %d, err = %v", seed, err)
  3879  	}
  3880  	msg := &CustomNameCustomType{}
  3881  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3882  		t.Fatalf("seed = %d, err = %v", seed, err)
  3883  	}
  3884  	littlefuzz := make([]byte, len(dAtA))
  3885  	copy(littlefuzz, dAtA)
  3886  	for i := range dAtA {
  3887  		dAtA[i] = byte(popr.Intn(256))
  3888  	}
  3889  	if err := p.VerboseEqual(msg); err != nil {
  3890  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3891  	}
  3892  	if !p.Equal(msg) {
  3893  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3894  	}
  3895  	if len(littlefuzz) > 0 {
  3896  		fuzzamount := 100
  3897  		for i := 0; i < fuzzamount; i++ {
  3898  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3899  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3900  		}
  3901  		// shouldn't panic
  3902  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3903  	}
  3904  }
  3905  
  3906  func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) {
  3907  	popr := math_rand.New(math_rand.NewSource(616))
  3908  	total := 0
  3909  	pops := make([]*CustomNameCustomType, 10000)
  3910  	for i := 0; i < 10000; i++ {
  3911  		pops[i] = NewPopulatedCustomNameCustomType(popr, false)
  3912  	}
  3913  	b.ResetTimer()
  3914  	for i := 0; i < b.N; i++ {
  3915  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3916  		if err != nil {
  3917  			panic(err)
  3918  		}
  3919  		total += len(dAtA)
  3920  	}
  3921  	b.SetBytes(int64(total / b.N))
  3922  }
  3923  
  3924  func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) {
  3925  	popr := math_rand.New(math_rand.NewSource(616))
  3926  	total := 0
  3927  	datas := make([][]byte, 10000)
  3928  	for i := 0; i < 10000; i++ {
  3929  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false))
  3930  		if err != nil {
  3931  			panic(err)
  3932  		}
  3933  		datas[i] = dAtA
  3934  	}
  3935  	msg := &CustomNameCustomType{}
  3936  	b.ResetTimer()
  3937  	for i := 0; i < b.N; i++ {
  3938  		total += len(datas[i%10000])
  3939  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  3940  			panic(err)
  3941  		}
  3942  	}
  3943  	b.SetBytes(int64(total / b.N))
  3944  }
  3945  
  3946  func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) {
  3947  	seed := time.Now().UnixNano()
  3948  	popr := math_rand.New(math_rand.NewSource(seed))
  3949  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
  3950  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  3951  	if err != nil {
  3952  		t.Fatalf("seed = %d, err = %v", seed, err)
  3953  	}
  3954  	msg := &CustomNameNinEmbeddedStructUnion{}
  3955  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  3956  		t.Fatalf("seed = %d, err = %v", seed, err)
  3957  	}
  3958  	littlefuzz := make([]byte, len(dAtA))
  3959  	copy(littlefuzz, dAtA)
  3960  	for i := range dAtA {
  3961  		dAtA[i] = byte(popr.Intn(256))
  3962  	}
  3963  	if err := p.VerboseEqual(msg); err != nil {
  3964  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  3965  	}
  3966  	if !p.Equal(msg) {
  3967  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  3968  	}
  3969  	if len(littlefuzz) > 0 {
  3970  		fuzzamount := 100
  3971  		for i := 0; i < fuzzamount; i++ {
  3972  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  3973  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  3974  		}
  3975  		// shouldn't panic
  3976  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  3977  	}
  3978  }
  3979  
  3980  func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) {
  3981  	popr := math_rand.New(math_rand.NewSource(616))
  3982  	total := 0
  3983  	pops := make([]*CustomNameNinEmbeddedStructUnion, 10000)
  3984  	for i := 0; i < 10000; i++ {
  3985  		pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
  3986  	}
  3987  	b.ResetTimer()
  3988  	for i := 0; i < b.N; i++ {
  3989  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  3990  		if err != nil {
  3991  			panic(err)
  3992  		}
  3993  		total += len(dAtA)
  3994  	}
  3995  	b.SetBytes(int64(total / b.N))
  3996  }
  3997  
  3998  func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) {
  3999  	popr := math_rand.New(math_rand.NewSource(616))
  4000  	total := 0
  4001  	datas := make([][]byte, 10000)
  4002  	for i := 0; i < 10000; i++ {
  4003  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false))
  4004  		if err != nil {
  4005  			panic(err)
  4006  		}
  4007  		datas[i] = dAtA
  4008  	}
  4009  	msg := &CustomNameNinEmbeddedStructUnion{}
  4010  	b.ResetTimer()
  4011  	for i := 0; i < b.N; i++ {
  4012  		total += len(datas[i%10000])
  4013  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4014  			panic(err)
  4015  		}
  4016  	}
  4017  	b.SetBytes(int64(total / b.N))
  4018  }
  4019  
  4020  func TestCustomNameEnumProto(t *testing.T) {
  4021  	seed := time.Now().UnixNano()
  4022  	popr := math_rand.New(math_rand.NewSource(seed))
  4023  	p := NewPopulatedCustomNameEnum(popr, false)
  4024  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4025  	if err != nil {
  4026  		t.Fatalf("seed = %d, err = %v", seed, err)
  4027  	}
  4028  	msg := &CustomNameEnum{}
  4029  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4030  		t.Fatalf("seed = %d, err = %v", seed, err)
  4031  	}
  4032  	littlefuzz := make([]byte, len(dAtA))
  4033  	copy(littlefuzz, dAtA)
  4034  	for i := range dAtA {
  4035  		dAtA[i] = byte(popr.Intn(256))
  4036  	}
  4037  	if err := p.VerboseEqual(msg); err != nil {
  4038  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4039  	}
  4040  	if !p.Equal(msg) {
  4041  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4042  	}
  4043  	if len(littlefuzz) > 0 {
  4044  		fuzzamount := 100
  4045  		for i := 0; i < fuzzamount; i++ {
  4046  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4047  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4048  		}
  4049  		// shouldn't panic
  4050  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4051  	}
  4052  }
  4053  
  4054  func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) {
  4055  	popr := math_rand.New(math_rand.NewSource(616))
  4056  	total := 0
  4057  	pops := make([]*CustomNameEnum, 10000)
  4058  	for i := 0; i < 10000; i++ {
  4059  		pops[i] = NewPopulatedCustomNameEnum(popr, false)
  4060  	}
  4061  	b.ResetTimer()
  4062  	for i := 0; i < b.N; i++ {
  4063  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4064  		if err != nil {
  4065  			panic(err)
  4066  		}
  4067  		total += len(dAtA)
  4068  	}
  4069  	b.SetBytes(int64(total / b.N))
  4070  }
  4071  
  4072  func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) {
  4073  	popr := math_rand.New(math_rand.NewSource(616))
  4074  	total := 0
  4075  	datas := make([][]byte, 10000)
  4076  	for i := 0; i < 10000; i++ {
  4077  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false))
  4078  		if err != nil {
  4079  			panic(err)
  4080  		}
  4081  		datas[i] = dAtA
  4082  	}
  4083  	msg := &CustomNameEnum{}
  4084  	b.ResetTimer()
  4085  	for i := 0; i < b.N; i++ {
  4086  		total += len(datas[i%10000])
  4087  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4088  			panic(err)
  4089  		}
  4090  	}
  4091  	b.SetBytes(int64(total / b.N))
  4092  }
  4093  
  4094  func TestNoExtensionsMapProto(t *testing.T) {
  4095  	seed := time.Now().UnixNano()
  4096  	popr := math_rand.New(math_rand.NewSource(seed))
  4097  	p := NewPopulatedNoExtensionsMap(popr, false)
  4098  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4099  	if err != nil {
  4100  		t.Fatalf("seed = %d, err = %v", seed, err)
  4101  	}
  4102  	msg := &NoExtensionsMap{}
  4103  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4104  		t.Fatalf("seed = %d, err = %v", seed, err)
  4105  	}
  4106  	littlefuzz := make([]byte, len(dAtA))
  4107  	copy(littlefuzz, dAtA)
  4108  	for i := range dAtA {
  4109  		dAtA[i] = byte(popr.Intn(256))
  4110  	}
  4111  	if err := p.VerboseEqual(msg); err != nil {
  4112  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4113  	}
  4114  	if !p.Equal(msg) {
  4115  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4116  	}
  4117  	if len(littlefuzz) > 0 {
  4118  		fuzzamount := 100
  4119  		for i := 0; i < fuzzamount; i++ {
  4120  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4121  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4122  		}
  4123  		// shouldn't panic
  4124  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4125  	}
  4126  }
  4127  
  4128  func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) {
  4129  	popr := math_rand.New(math_rand.NewSource(616))
  4130  	total := 0
  4131  	pops := make([]*NoExtensionsMap, 10000)
  4132  	for i := 0; i < 10000; i++ {
  4133  		pops[i] = NewPopulatedNoExtensionsMap(popr, false)
  4134  	}
  4135  	b.ResetTimer()
  4136  	for i := 0; i < b.N; i++ {
  4137  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4138  		if err != nil {
  4139  			panic(err)
  4140  		}
  4141  		total += len(dAtA)
  4142  	}
  4143  	b.SetBytes(int64(total / b.N))
  4144  }
  4145  
  4146  func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) {
  4147  	popr := math_rand.New(math_rand.NewSource(616))
  4148  	total := 0
  4149  	datas := make([][]byte, 10000)
  4150  	for i := 0; i < 10000; i++ {
  4151  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false))
  4152  		if err != nil {
  4153  			panic(err)
  4154  		}
  4155  		datas[i] = dAtA
  4156  	}
  4157  	msg := &NoExtensionsMap{}
  4158  	b.ResetTimer()
  4159  	for i := 0; i < b.N; i++ {
  4160  		total += len(datas[i%10000])
  4161  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4162  			panic(err)
  4163  		}
  4164  	}
  4165  	b.SetBytes(int64(total / b.N))
  4166  }
  4167  
  4168  func TestUnrecognizedProto(t *testing.T) {
  4169  	seed := time.Now().UnixNano()
  4170  	popr := math_rand.New(math_rand.NewSource(seed))
  4171  	p := NewPopulatedUnrecognized(popr, false)
  4172  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4173  	if err != nil {
  4174  		t.Fatalf("seed = %d, err = %v", seed, err)
  4175  	}
  4176  	msg := &Unrecognized{}
  4177  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4178  		t.Fatalf("seed = %d, err = %v", seed, err)
  4179  	}
  4180  	littlefuzz := make([]byte, len(dAtA))
  4181  	copy(littlefuzz, dAtA)
  4182  	for i := range dAtA {
  4183  		dAtA[i] = byte(popr.Intn(256))
  4184  	}
  4185  	if err := p.VerboseEqual(msg); err != nil {
  4186  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4187  	}
  4188  	if !p.Equal(msg) {
  4189  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4190  	}
  4191  	if len(littlefuzz) > 0 {
  4192  		fuzzamount := 100
  4193  		for i := 0; i < fuzzamount; i++ {
  4194  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4195  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4196  		}
  4197  		// shouldn't panic
  4198  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4199  	}
  4200  }
  4201  
  4202  func BenchmarkUnrecognizedProtoMarshal(b *testing.B) {
  4203  	popr := math_rand.New(math_rand.NewSource(616))
  4204  	total := 0
  4205  	pops := make([]*Unrecognized, 10000)
  4206  	for i := 0; i < 10000; i++ {
  4207  		pops[i] = NewPopulatedUnrecognized(popr, false)
  4208  	}
  4209  	b.ResetTimer()
  4210  	for i := 0; i < b.N; i++ {
  4211  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4212  		if err != nil {
  4213  			panic(err)
  4214  		}
  4215  		total += len(dAtA)
  4216  	}
  4217  	b.SetBytes(int64(total / b.N))
  4218  }
  4219  
  4220  func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) {
  4221  	popr := math_rand.New(math_rand.NewSource(616))
  4222  	total := 0
  4223  	datas := make([][]byte, 10000)
  4224  	for i := 0; i < 10000; i++ {
  4225  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false))
  4226  		if err != nil {
  4227  			panic(err)
  4228  		}
  4229  		datas[i] = dAtA
  4230  	}
  4231  	msg := &Unrecognized{}
  4232  	b.ResetTimer()
  4233  	for i := 0; i < b.N; i++ {
  4234  		total += len(datas[i%10000])
  4235  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4236  			panic(err)
  4237  		}
  4238  	}
  4239  	b.SetBytes(int64(total / b.N))
  4240  }
  4241  
  4242  func TestUnrecognizedWithInnerProto(t *testing.T) {
  4243  	seed := time.Now().UnixNano()
  4244  	popr := math_rand.New(math_rand.NewSource(seed))
  4245  	p := NewPopulatedUnrecognizedWithInner(popr, false)
  4246  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4247  	if err != nil {
  4248  		t.Fatalf("seed = %d, err = %v", seed, err)
  4249  	}
  4250  	msg := &UnrecognizedWithInner{}
  4251  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4252  		t.Fatalf("seed = %d, err = %v", seed, err)
  4253  	}
  4254  	littlefuzz := make([]byte, len(dAtA))
  4255  	copy(littlefuzz, dAtA)
  4256  	for i := range dAtA {
  4257  		dAtA[i] = byte(popr.Intn(256))
  4258  	}
  4259  	if err := p.VerboseEqual(msg); err != nil {
  4260  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4261  	}
  4262  	if !p.Equal(msg) {
  4263  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4264  	}
  4265  	if len(littlefuzz) > 0 {
  4266  		fuzzamount := 100
  4267  		for i := 0; i < fuzzamount; i++ {
  4268  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4269  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4270  		}
  4271  		// shouldn't panic
  4272  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4273  	}
  4274  }
  4275  
  4276  func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) {
  4277  	popr := math_rand.New(math_rand.NewSource(616))
  4278  	total := 0
  4279  	pops := make([]*UnrecognizedWithInner, 10000)
  4280  	for i := 0; i < 10000; i++ {
  4281  		pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
  4282  	}
  4283  	b.ResetTimer()
  4284  	for i := 0; i < b.N; i++ {
  4285  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4286  		if err != nil {
  4287  			panic(err)
  4288  		}
  4289  		total += len(dAtA)
  4290  	}
  4291  	b.SetBytes(int64(total / b.N))
  4292  }
  4293  
  4294  func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) {
  4295  	popr := math_rand.New(math_rand.NewSource(616))
  4296  	total := 0
  4297  	datas := make([][]byte, 10000)
  4298  	for i := 0; i < 10000; i++ {
  4299  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false))
  4300  		if err != nil {
  4301  			panic(err)
  4302  		}
  4303  		datas[i] = dAtA
  4304  	}
  4305  	msg := &UnrecognizedWithInner{}
  4306  	b.ResetTimer()
  4307  	for i := 0; i < b.N; i++ {
  4308  		total += len(datas[i%10000])
  4309  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4310  			panic(err)
  4311  		}
  4312  	}
  4313  	b.SetBytes(int64(total / b.N))
  4314  }
  4315  
  4316  func TestUnrecognizedWithInner_InnerProto(t *testing.T) {
  4317  	seed := time.Now().UnixNano()
  4318  	popr := math_rand.New(math_rand.NewSource(seed))
  4319  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
  4320  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4321  	if err != nil {
  4322  		t.Fatalf("seed = %d, err = %v", seed, err)
  4323  	}
  4324  	msg := &UnrecognizedWithInner_Inner{}
  4325  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4326  		t.Fatalf("seed = %d, err = %v", seed, err)
  4327  	}
  4328  	littlefuzz := make([]byte, len(dAtA))
  4329  	copy(littlefuzz, dAtA)
  4330  	for i := range dAtA {
  4331  		dAtA[i] = byte(popr.Intn(256))
  4332  	}
  4333  	if err := p.VerboseEqual(msg); err != nil {
  4334  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4335  	}
  4336  	if !p.Equal(msg) {
  4337  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4338  	}
  4339  	if len(littlefuzz) > 0 {
  4340  		fuzzamount := 100
  4341  		for i := 0; i < fuzzamount; i++ {
  4342  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4343  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4344  		}
  4345  		// shouldn't panic
  4346  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4347  	}
  4348  }
  4349  
  4350  func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) {
  4351  	popr := math_rand.New(math_rand.NewSource(616))
  4352  	total := 0
  4353  	pops := make([]*UnrecognizedWithInner_Inner, 10000)
  4354  	for i := 0; i < 10000; i++ {
  4355  		pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
  4356  	}
  4357  	b.ResetTimer()
  4358  	for i := 0; i < b.N; i++ {
  4359  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4360  		if err != nil {
  4361  			panic(err)
  4362  		}
  4363  		total += len(dAtA)
  4364  	}
  4365  	b.SetBytes(int64(total / b.N))
  4366  }
  4367  
  4368  func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) {
  4369  	popr := math_rand.New(math_rand.NewSource(616))
  4370  	total := 0
  4371  	datas := make([][]byte, 10000)
  4372  	for i := 0; i < 10000; i++ {
  4373  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false))
  4374  		if err != nil {
  4375  			panic(err)
  4376  		}
  4377  		datas[i] = dAtA
  4378  	}
  4379  	msg := &UnrecognizedWithInner_Inner{}
  4380  	b.ResetTimer()
  4381  	for i := 0; i < b.N; i++ {
  4382  		total += len(datas[i%10000])
  4383  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4384  			panic(err)
  4385  		}
  4386  	}
  4387  	b.SetBytes(int64(total / b.N))
  4388  }
  4389  
  4390  func TestUnrecognizedWithEmbedProto(t *testing.T) {
  4391  	seed := time.Now().UnixNano()
  4392  	popr := math_rand.New(math_rand.NewSource(seed))
  4393  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
  4394  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4395  	if err != nil {
  4396  		t.Fatalf("seed = %d, err = %v", seed, err)
  4397  	}
  4398  	msg := &UnrecognizedWithEmbed{}
  4399  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4400  		t.Fatalf("seed = %d, err = %v", seed, err)
  4401  	}
  4402  	littlefuzz := make([]byte, len(dAtA))
  4403  	copy(littlefuzz, dAtA)
  4404  	for i := range dAtA {
  4405  		dAtA[i] = byte(popr.Intn(256))
  4406  	}
  4407  	if err := p.VerboseEqual(msg); err != nil {
  4408  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4409  	}
  4410  	if !p.Equal(msg) {
  4411  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4412  	}
  4413  	if len(littlefuzz) > 0 {
  4414  		fuzzamount := 100
  4415  		for i := 0; i < fuzzamount; i++ {
  4416  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4417  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4418  		}
  4419  		// shouldn't panic
  4420  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4421  	}
  4422  }
  4423  
  4424  func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) {
  4425  	popr := math_rand.New(math_rand.NewSource(616))
  4426  	total := 0
  4427  	pops := make([]*UnrecognizedWithEmbed, 10000)
  4428  	for i := 0; i < 10000; i++ {
  4429  		pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
  4430  	}
  4431  	b.ResetTimer()
  4432  	for i := 0; i < b.N; i++ {
  4433  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4434  		if err != nil {
  4435  			panic(err)
  4436  		}
  4437  		total += len(dAtA)
  4438  	}
  4439  	b.SetBytes(int64(total / b.N))
  4440  }
  4441  
  4442  func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) {
  4443  	popr := math_rand.New(math_rand.NewSource(616))
  4444  	total := 0
  4445  	datas := make([][]byte, 10000)
  4446  	for i := 0; i < 10000; i++ {
  4447  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false))
  4448  		if err != nil {
  4449  			panic(err)
  4450  		}
  4451  		datas[i] = dAtA
  4452  	}
  4453  	msg := &UnrecognizedWithEmbed{}
  4454  	b.ResetTimer()
  4455  	for i := 0; i < b.N; i++ {
  4456  		total += len(datas[i%10000])
  4457  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4458  			panic(err)
  4459  		}
  4460  	}
  4461  	b.SetBytes(int64(total / b.N))
  4462  }
  4463  
  4464  func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) {
  4465  	seed := time.Now().UnixNano()
  4466  	popr := math_rand.New(math_rand.NewSource(seed))
  4467  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
  4468  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4469  	if err != nil {
  4470  		t.Fatalf("seed = %d, err = %v", seed, err)
  4471  	}
  4472  	msg := &UnrecognizedWithEmbed_Embedded{}
  4473  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4474  		t.Fatalf("seed = %d, err = %v", seed, err)
  4475  	}
  4476  	littlefuzz := make([]byte, len(dAtA))
  4477  	copy(littlefuzz, dAtA)
  4478  	for i := range dAtA {
  4479  		dAtA[i] = byte(popr.Intn(256))
  4480  	}
  4481  	if err := p.VerboseEqual(msg); err != nil {
  4482  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4483  	}
  4484  	if !p.Equal(msg) {
  4485  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4486  	}
  4487  	if len(littlefuzz) > 0 {
  4488  		fuzzamount := 100
  4489  		for i := 0; i < fuzzamount; i++ {
  4490  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4491  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4492  		}
  4493  		// shouldn't panic
  4494  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4495  	}
  4496  }
  4497  
  4498  func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) {
  4499  	popr := math_rand.New(math_rand.NewSource(616))
  4500  	total := 0
  4501  	pops := make([]*UnrecognizedWithEmbed_Embedded, 10000)
  4502  	for i := 0; i < 10000; i++ {
  4503  		pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
  4504  	}
  4505  	b.ResetTimer()
  4506  	for i := 0; i < b.N; i++ {
  4507  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4508  		if err != nil {
  4509  			panic(err)
  4510  		}
  4511  		total += len(dAtA)
  4512  	}
  4513  	b.SetBytes(int64(total / b.N))
  4514  }
  4515  
  4516  func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) {
  4517  	popr := math_rand.New(math_rand.NewSource(616))
  4518  	total := 0
  4519  	datas := make([][]byte, 10000)
  4520  	for i := 0; i < 10000; i++ {
  4521  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false))
  4522  		if err != nil {
  4523  			panic(err)
  4524  		}
  4525  		datas[i] = dAtA
  4526  	}
  4527  	msg := &UnrecognizedWithEmbed_Embedded{}
  4528  	b.ResetTimer()
  4529  	for i := 0; i < b.N; i++ {
  4530  		total += len(datas[i%10000])
  4531  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4532  			panic(err)
  4533  		}
  4534  	}
  4535  	b.SetBytes(int64(total / b.N))
  4536  }
  4537  
  4538  func TestNodeProto(t *testing.T) {
  4539  	seed := time.Now().UnixNano()
  4540  	popr := math_rand.New(math_rand.NewSource(seed))
  4541  	p := NewPopulatedNode(popr, false)
  4542  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4543  	if err != nil {
  4544  		t.Fatalf("seed = %d, err = %v", seed, err)
  4545  	}
  4546  	msg := &Node{}
  4547  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4548  		t.Fatalf("seed = %d, err = %v", seed, err)
  4549  	}
  4550  	littlefuzz := make([]byte, len(dAtA))
  4551  	copy(littlefuzz, dAtA)
  4552  	for i := range dAtA {
  4553  		dAtA[i] = byte(popr.Intn(256))
  4554  	}
  4555  	if err := p.VerboseEqual(msg); err != nil {
  4556  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4557  	}
  4558  	if !p.Equal(msg) {
  4559  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4560  	}
  4561  	if len(littlefuzz) > 0 {
  4562  		fuzzamount := 100
  4563  		for i := 0; i < fuzzamount; i++ {
  4564  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4565  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4566  		}
  4567  		// shouldn't panic
  4568  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4569  	}
  4570  }
  4571  
  4572  func BenchmarkNodeProtoMarshal(b *testing.B) {
  4573  	popr := math_rand.New(math_rand.NewSource(616))
  4574  	total := 0
  4575  	pops := make([]*Node, 10000)
  4576  	for i := 0; i < 10000; i++ {
  4577  		pops[i] = NewPopulatedNode(popr, false)
  4578  	}
  4579  	b.ResetTimer()
  4580  	for i := 0; i < b.N; i++ {
  4581  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4582  		if err != nil {
  4583  			panic(err)
  4584  		}
  4585  		total += len(dAtA)
  4586  	}
  4587  	b.SetBytes(int64(total / b.N))
  4588  }
  4589  
  4590  func BenchmarkNodeProtoUnmarshal(b *testing.B) {
  4591  	popr := math_rand.New(math_rand.NewSource(616))
  4592  	total := 0
  4593  	datas := make([][]byte, 10000)
  4594  	for i := 0; i < 10000; i++ {
  4595  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNode(popr, false))
  4596  		if err != nil {
  4597  			panic(err)
  4598  		}
  4599  		datas[i] = dAtA
  4600  	}
  4601  	msg := &Node{}
  4602  	b.ResetTimer()
  4603  	for i := 0; i < b.N; i++ {
  4604  		total += len(datas[i%10000])
  4605  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4606  			panic(err)
  4607  		}
  4608  	}
  4609  	b.SetBytes(int64(total / b.N))
  4610  }
  4611  
  4612  func TestNonByteCustomTypeProto(t *testing.T) {
  4613  	seed := time.Now().UnixNano()
  4614  	popr := math_rand.New(math_rand.NewSource(seed))
  4615  	p := NewPopulatedNonByteCustomType(popr, false)
  4616  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4617  	if err != nil {
  4618  		t.Fatalf("seed = %d, err = %v", seed, err)
  4619  	}
  4620  	msg := &NonByteCustomType{}
  4621  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4622  		t.Fatalf("seed = %d, err = %v", seed, err)
  4623  	}
  4624  	littlefuzz := make([]byte, len(dAtA))
  4625  	copy(littlefuzz, dAtA)
  4626  	for i := range dAtA {
  4627  		dAtA[i] = byte(popr.Intn(256))
  4628  	}
  4629  	if err := p.VerboseEqual(msg); err != nil {
  4630  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4631  	}
  4632  	if !p.Equal(msg) {
  4633  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4634  	}
  4635  	if len(littlefuzz) > 0 {
  4636  		fuzzamount := 100
  4637  		for i := 0; i < fuzzamount; i++ {
  4638  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4639  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4640  		}
  4641  		// shouldn't panic
  4642  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4643  	}
  4644  }
  4645  
  4646  func BenchmarkNonByteCustomTypeProtoMarshal(b *testing.B) {
  4647  	popr := math_rand.New(math_rand.NewSource(616))
  4648  	total := 0
  4649  	pops := make([]*NonByteCustomType, 10000)
  4650  	for i := 0; i < 10000; i++ {
  4651  		pops[i] = NewPopulatedNonByteCustomType(popr, false)
  4652  	}
  4653  	b.ResetTimer()
  4654  	for i := 0; i < b.N; i++ {
  4655  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4656  		if err != nil {
  4657  			panic(err)
  4658  		}
  4659  		total += len(dAtA)
  4660  	}
  4661  	b.SetBytes(int64(total / b.N))
  4662  }
  4663  
  4664  func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  4665  	popr := math_rand.New(math_rand.NewSource(616))
  4666  	total := 0
  4667  	datas := make([][]byte, 10000)
  4668  	for i := 0; i < 10000; i++ {
  4669  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNonByteCustomType(popr, false))
  4670  		if err != nil {
  4671  			panic(err)
  4672  		}
  4673  		datas[i] = dAtA
  4674  	}
  4675  	msg := &NonByteCustomType{}
  4676  	b.ResetTimer()
  4677  	for i := 0; i < b.N; i++ {
  4678  		total += len(datas[i%10000])
  4679  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4680  			panic(err)
  4681  		}
  4682  	}
  4683  	b.SetBytes(int64(total / b.N))
  4684  }
  4685  
  4686  func TestNidOptNonByteCustomTypeProto(t *testing.T) {
  4687  	seed := time.Now().UnixNano()
  4688  	popr := math_rand.New(math_rand.NewSource(seed))
  4689  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
  4690  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4691  	if err != nil {
  4692  		t.Fatalf("seed = %d, err = %v", seed, err)
  4693  	}
  4694  	msg := &NidOptNonByteCustomType{}
  4695  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4696  		t.Fatalf("seed = %d, err = %v", seed, err)
  4697  	}
  4698  	littlefuzz := make([]byte, len(dAtA))
  4699  	copy(littlefuzz, dAtA)
  4700  	for i := range dAtA {
  4701  		dAtA[i] = byte(popr.Intn(256))
  4702  	}
  4703  	if err := p.VerboseEqual(msg); err != nil {
  4704  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4705  	}
  4706  	if !p.Equal(msg) {
  4707  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4708  	}
  4709  	if len(littlefuzz) > 0 {
  4710  		fuzzamount := 100
  4711  		for i := 0; i < fuzzamount; i++ {
  4712  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4713  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4714  		}
  4715  		// shouldn't panic
  4716  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4717  	}
  4718  }
  4719  
  4720  func BenchmarkNidOptNonByteCustomTypeProtoMarshal(b *testing.B) {
  4721  	popr := math_rand.New(math_rand.NewSource(616))
  4722  	total := 0
  4723  	pops := make([]*NidOptNonByteCustomType, 10000)
  4724  	for i := 0; i < 10000; i++ {
  4725  		pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
  4726  	}
  4727  	b.ResetTimer()
  4728  	for i := 0; i < b.N; i++ {
  4729  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4730  		if err != nil {
  4731  			panic(err)
  4732  		}
  4733  		total += len(dAtA)
  4734  	}
  4735  	b.SetBytes(int64(total / b.N))
  4736  }
  4737  
  4738  func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  4739  	popr := math_rand.New(math_rand.NewSource(616))
  4740  	total := 0
  4741  	datas := make([][]byte, 10000)
  4742  	for i := 0; i < 10000; i++ {
  4743  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNonByteCustomType(popr, false))
  4744  		if err != nil {
  4745  			panic(err)
  4746  		}
  4747  		datas[i] = dAtA
  4748  	}
  4749  	msg := &NidOptNonByteCustomType{}
  4750  	b.ResetTimer()
  4751  	for i := 0; i < b.N; i++ {
  4752  		total += len(datas[i%10000])
  4753  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4754  			panic(err)
  4755  		}
  4756  	}
  4757  	b.SetBytes(int64(total / b.N))
  4758  }
  4759  
  4760  func TestNinOptNonByteCustomTypeProto(t *testing.T) {
  4761  	seed := time.Now().UnixNano()
  4762  	popr := math_rand.New(math_rand.NewSource(seed))
  4763  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
  4764  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4765  	if err != nil {
  4766  		t.Fatalf("seed = %d, err = %v", seed, err)
  4767  	}
  4768  	msg := &NinOptNonByteCustomType{}
  4769  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4770  		t.Fatalf("seed = %d, err = %v", seed, err)
  4771  	}
  4772  	littlefuzz := make([]byte, len(dAtA))
  4773  	copy(littlefuzz, dAtA)
  4774  	for i := range dAtA {
  4775  		dAtA[i] = byte(popr.Intn(256))
  4776  	}
  4777  	if err := p.VerboseEqual(msg); err != nil {
  4778  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4779  	}
  4780  	if !p.Equal(msg) {
  4781  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4782  	}
  4783  	if len(littlefuzz) > 0 {
  4784  		fuzzamount := 100
  4785  		for i := 0; i < fuzzamount; i++ {
  4786  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4787  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4788  		}
  4789  		// shouldn't panic
  4790  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4791  	}
  4792  }
  4793  
  4794  func BenchmarkNinOptNonByteCustomTypeProtoMarshal(b *testing.B) {
  4795  	popr := math_rand.New(math_rand.NewSource(616))
  4796  	total := 0
  4797  	pops := make([]*NinOptNonByteCustomType, 10000)
  4798  	for i := 0; i < 10000; i++ {
  4799  		pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
  4800  	}
  4801  	b.ResetTimer()
  4802  	for i := 0; i < b.N; i++ {
  4803  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4804  		if err != nil {
  4805  			panic(err)
  4806  		}
  4807  		total += len(dAtA)
  4808  	}
  4809  	b.SetBytes(int64(total / b.N))
  4810  }
  4811  
  4812  func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  4813  	popr := math_rand.New(math_rand.NewSource(616))
  4814  	total := 0
  4815  	datas := make([][]byte, 10000)
  4816  	for i := 0; i < 10000; i++ {
  4817  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNonByteCustomType(popr, false))
  4818  		if err != nil {
  4819  			panic(err)
  4820  		}
  4821  		datas[i] = dAtA
  4822  	}
  4823  	msg := &NinOptNonByteCustomType{}
  4824  	b.ResetTimer()
  4825  	for i := 0; i < b.N; i++ {
  4826  		total += len(datas[i%10000])
  4827  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4828  			panic(err)
  4829  		}
  4830  	}
  4831  	b.SetBytes(int64(total / b.N))
  4832  }
  4833  
  4834  func TestNidRepNonByteCustomTypeProto(t *testing.T) {
  4835  	seed := time.Now().UnixNano()
  4836  	popr := math_rand.New(math_rand.NewSource(seed))
  4837  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
  4838  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4839  	if err != nil {
  4840  		t.Fatalf("seed = %d, err = %v", seed, err)
  4841  	}
  4842  	msg := &NidRepNonByteCustomType{}
  4843  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4844  		t.Fatalf("seed = %d, err = %v", seed, err)
  4845  	}
  4846  	littlefuzz := make([]byte, len(dAtA))
  4847  	copy(littlefuzz, dAtA)
  4848  	for i := range dAtA {
  4849  		dAtA[i] = byte(popr.Intn(256))
  4850  	}
  4851  	if err := p.VerboseEqual(msg); err != nil {
  4852  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4853  	}
  4854  	if !p.Equal(msg) {
  4855  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4856  	}
  4857  	if len(littlefuzz) > 0 {
  4858  		fuzzamount := 100
  4859  		for i := 0; i < fuzzamount; i++ {
  4860  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4861  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4862  		}
  4863  		// shouldn't panic
  4864  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4865  	}
  4866  }
  4867  
  4868  func BenchmarkNidRepNonByteCustomTypeProtoMarshal(b *testing.B) {
  4869  	popr := math_rand.New(math_rand.NewSource(616))
  4870  	total := 0
  4871  	pops := make([]*NidRepNonByteCustomType, 10000)
  4872  	for i := 0; i < 10000; i++ {
  4873  		pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
  4874  	}
  4875  	b.ResetTimer()
  4876  	for i := 0; i < b.N; i++ {
  4877  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4878  		if err != nil {
  4879  			panic(err)
  4880  		}
  4881  		total += len(dAtA)
  4882  	}
  4883  	b.SetBytes(int64(total / b.N))
  4884  }
  4885  
  4886  func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  4887  	popr := math_rand.New(math_rand.NewSource(616))
  4888  	total := 0
  4889  	datas := make([][]byte, 10000)
  4890  	for i := 0; i < 10000; i++ {
  4891  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNonByteCustomType(popr, false))
  4892  		if err != nil {
  4893  			panic(err)
  4894  		}
  4895  		datas[i] = dAtA
  4896  	}
  4897  	msg := &NidRepNonByteCustomType{}
  4898  	b.ResetTimer()
  4899  	for i := 0; i < b.N; i++ {
  4900  		total += len(datas[i%10000])
  4901  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4902  			panic(err)
  4903  		}
  4904  	}
  4905  	b.SetBytes(int64(total / b.N))
  4906  }
  4907  
  4908  func TestNinRepNonByteCustomTypeProto(t *testing.T) {
  4909  	seed := time.Now().UnixNano()
  4910  	popr := math_rand.New(math_rand.NewSource(seed))
  4911  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
  4912  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4913  	if err != nil {
  4914  		t.Fatalf("seed = %d, err = %v", seed, err)
  4915  	}
  4916  	msg := &NinRepNonByteCustomType{}
  4917  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4918  		t.Fatalf("seed = %d, err = %v", seed, err)
  4919  	}
  4920  	littlefuzz := make([]byte, len(dAtA))
  4921  	copy(littlefuzz, dAtA)
  4922  	for i := range dAtA {
  4923  		dAtA[i] = byte(popr.Intn(256))
  4924  	}
  4925  	if err := p.VerboseEqual(msg); err != nil {
  4926  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  4927  	}
  4928  	if !p.Equal(msg) {
  4929  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  4930  	}
  4931  	if len(littlefuzz) > 0 {
  4932  		fuzzamount := 100
  4933  		for i := 0; i < fuzzamount; i++ {
  4934  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  4935  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  4936  		}
  4937  		// shouldn't panic
  4938  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  4939  	}
  4940  }
  4941  
  4942  func BenchmarkNinRepNonByteCustomTypeProtoMarshal(b *testing.B) {
  4943  	popr := math_rand.New(math_rand.NewSource(616))
  4944  	total := 0
  4945  	pops := make([]*NinRepNonByteCustomType, 10000)
  4946  	for i := 0; i < 10000; i++ {
  4947  		pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
  4948  	}
  4949  	b.ResetTimer()
  4950  	for i := 0; i < b.N; i++ {
  4951  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  4952  		if err != nil {
  4953  			panic(err)
  4954  		}
  4955  		total += len(dAtA)
  4956  	}
  4957  	b.SetBytes(int64(total / b.N))
  4958  }
  4959  
  4960  func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) {
  4961  	popr := math_rand.New(math_rand.NewSource(616))
  4962  	total := 0
  4963  	datas := make([][]byte, 10000)
  4964  	for i := 0; i < 10000; i++ {
  4965  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNonByteCustomType(popr, false))
  4966  		if err != nil {
  4967  			panic(err)
  4968  		}
  4969  		datas[i] = dAtA
  4970  	}
  4971  	msg := &NinRepNonByteCustomType{}
  4972  	b.ResetTimer()
  4973  	for i := 0; i < b.N; i++ {
  4974  		total += len(datas[i%10000])
  4975  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  4976  			panic(err)
  4977  		}
  4978  	}
  4979  	b.SetBytes(int64(total / b.N))
  4980  }
  4981  
  4982  func TestProtoTypeProto(t *testing.T) {
  4983  	seed := time.Now().UnixNano()
  4984  	popr := math_rand.New(math_rand.NewSource(seed))
  4985  	p := NewPopulatedProtoType(popr, false)
  4986  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  4987  	if err != nil {
  4988  		t.Fatalf("seed = %d, err = %v", seed, err)
  4989  	}
  4990  	msg := &ProtoType{}
  4991  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  4992  		t.Fatalf("seed = %d, err = %v", seed, err)
  4993  	}
  4994  	littlefuzz := make([]byte, len(dAtA))
  4995  	copy(littlefuzz, dAtA)
  4996  	for i := range dAtA {
  4997  		dAtA[i] = byte(popr.Intn(256))
  4998  	}
  4999  	if err := p.VerboseEqual(msg); err != nil {
  5000  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5001  	}
  5002  	if !p.Equal(msg) {
  5003  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  5004  	}
  5005  	if len(littlefuzz) > 0 {
  5006  		fuzzamount := 100
  5007  		for i := 0; i < fuzzamount; i++ {
  5008  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
  5009  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
  5010  		}
  5011  		// shouldn't panic
  5012  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
  5013  	}
  5014  }
  5015  
  5016  func BenchmarkProtoTypeProtoMarshal(b *testing.B) {
  5017  	popr := math_rand.New(math_rand.NewSource(616))
  5018  	total := 0
  5019  	pops := make([]*ProtoType, 10000)
  5020  	for i := 0; i < 10000; i++ {
  5021  		pops[i] = NewPopulatedProtoType(popr, false)
  5022  	}
  5023  	b.ResetTimer()
  5024  	for i := 0; i < b.N; i++ {
  5025  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
  5026  		if err != nil {
  5027  			panic(err)
  5028  		}
  5029  		total += len(dAtA)
  5030  	}
  5031  	b.SetBytes(int64(total / b.N))
  5032  }
  5033  
  5034  func BenchmarkProtoTypeProtoUnmarshal(b *testing.B) {
  5035  	popr := math_rand.New(math_rand.NewSource(616))
  5036  	total := 0
  5037  	datas := make([][]byte, 10000)
  5038  	for i := 0; i < 10000; i++ {
  5039  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedProtoType(popr, false))
  5040  		if err != nil {
  5041  			panic(err)
  5042  		}
  5043  		datas[i] = dAtA
  5044  	}
  5045  	msg := &ProtoType{}
  5046  	b.ResetTimer()
  5047  	for i := 0; i < b.N; i++ {
  5048  		total += len(datas[i%10000])
  5049  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
  5050  			panic(err)
  5051  		}
  5052  	}
  5053  	b.SetBytes(int64(total / b.N))
  5054  }
  5055  
  5056  func TestNidOptNativeJSON(t *testing.T) {
  5057  	seed := time.Now().UnixNano()
  5058  	popr := math_rand.New(math_rand.NewSource(seed))
  5059  	p := NewPopulatedNidOptNative(popr, true)
  5060  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5061  	jsondata, err := marshaler.MarshalToString(p)
  5062  	if err != nil {
  5063  		t.Fatalf("seed = %d, err = %v", seed, err)
  5064  	}
  5065  	msg := &NidOptNative{}
  5066  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5067  	if err != nil {
  5068  		t.Fatalf("seed = %d, err = %v", seed, err)
  5069  	}
  5070  	if err := p.VerboseEqual(msg); err != nil {
  5071  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5072  	}
  5073  	if !p.Equal(msg) {
  5074  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5075  	}
  5076  }
  5077  func TestNinOptNativeJSON(t *testing.T) {
  5078  	seed := time.Now().UnixNano()
  5079  	popr := math_rand.New(math_rand.NewSource(seed))
  5080  	p := NewPopulatedNinOptNative(popr, true)
  5081  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5082  	jsondata, err := marshaler.MarshalToString(p)
  5083  	if err != nil {
  5084  		t.Fatalf("seed = %d, err = %v", seed, err)
  5085  	}
  5086  	msg := &NinOptNative{}
  5087  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5088  	if err != nil {
  5089  		t.Fatalf("seed = %d, err = %v", seed, err)
  5090  	}
  5091  	if err := p.VerboseEqual(msg); err != nil {
  5092  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5093  	}
  5094  	if !p.Equal(msg) {
  5095  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5096  	}
  5097  }
  5098  func TestNidRepNativeJSON(t *testing.T) {
  5099  	seed := time.Now().UnixNano()
  5100  	popr := math_rand.New(math_rand.NewSource(seed))
  5101  	p := NewPopulatedNidRepNative(popr, true)
  5102  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5103  	jsondata, err := marshaler.MarshalToString(p)
  5104  	if err != nil {
  5105  		t.Fatalf("seed = %d, err = %v", seed, err)
  5106  	}
  5107  	msg := &NidRepNative{}
  5108  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5109  	if err != nil {
  5110  		t.Fatalf("seed = %d, err = %v", seed, err)
  5111  	}
  5112  	if err := p.VerboseEqual(msg); err != nil {
  5113  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5114  	}
  5115  	if !p.Equal(msg) {
  5116  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5117  	}
  5118  }
  5119  func TestNinRepNativeJSON(t *testing.T) {
  5120  	seed := time.Now().UnixNano()
  5121  	popr := math_rand.New(math_rand.NewSource(seed))
  5122  	p := NewPopulatedNinRepNative(popr, true)
  5123  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5124  	jsondata, err := marshaler.MarshalToString(p)
  5125  	if err != nil {
  5126  		t.Fatalf("seed = %d, err = %v", seed, err)
  5127  	}
  5128  	msg := &NinRepNative{}
  5129  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5130  	if err != nil {
  5131  		t.Fatalf("seed = %d, err = %v", seed, err)
  5132  	}
  5133  	if err := p.VerboseEqual(msg); err != nil {
  5134  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5135  	}
  5136  	if !p.Equal(msg) {
  5137  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5138  	}
  5139  }
  5140  func TestNidRepPackedNativeJSON(t *testing.T) {
  5141  	seed := time.Now().UnixNano()
  5142  	popr := math_rand.New(math_rand.NewSource(seed))
  5143  	p := NewPopulatedNidRepPackedNative(popr, true)
  5144  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5145  	jsondata, err := marshaler.MarshalToString(p)
  5146  	if err != nil {
  5147  		t.Fatalf("seed = %d, err = %v", seed, err)
  5148  	}
  5149  	msg := &NidRepPackedNative{}
  5150  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5151  	if err != nil {
  5152  		t.Fatalf("seed = %d, err = %v", seed, err)
  5153  	}
  5154  	if err := p.VerboseEqual(msg); err != nil {
  5155  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5156  	}
  5157  	if !p.Equal(msg) {
  5158  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5159  	}
  5160  }
  5161  func TestNinRepPackedNativeJSON(t *testing.T) {
  5162  	seed := time.Now().UnixNano()
  5163  	popr := math_rand.New(math_rand.NewSource(seed))
  5164  	p := NewPopulatedNinRepPackedNative(popr, true)
  5165  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5166  	jsondata, err := marshaler.MarshalToString(p)
  5167  	if err != nil {
  5168  		t.Fatalf("seed = %d, err = %v", seed, err)
  5169  	}
  5170  	msg := &NinRepPackedNative{}
  5171  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5172  	if err != nil {
  5173  		t.Fatalf("seed = %d, err = %v", seed, err)
  5174  	}
  5175  	if err := p.VerboseEqual(msg); err != nil {
  5176  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5177  	}
  5178  	if !p.Equal(msg) {
  5179  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5180  	}
  5181  }
  5182  func TestNidOptStructJSON(t *testing.T) {
  5183  	seed := time.Now().UnixNano()
  5184  	popr := math_rand.New(math_rand.NewSource(seed))
  5185  	p := NewPopulatedNidOptStruct(popr, true)
  5186  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5187  	jsondata, err := marshaler.MarshalToString(p)
  5188  	if err != nil {
  5189  		t.Fatalf("seed = %d, err = %v", seed, err)
  5190  	}
  5191  	msg := &NidOptStruct{}
  5192  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5193  	if err != nil {
  5194  		t.Fatalf("seed = %d, err = %v", seed, err)
  5195  	}
  5196  	if err := p.VerboseEqual(msg); err != nil {
  5197  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5198  	}
  5199  	if !p.Equal(msg) {
  5200  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5201  	}
  5202  }
  5203  func TestNinOptStructJSON(t *testing.T) {
  5204  	seed := time.Now().UnixNano()
  5205  	popr := math_rand.New(math_rand.NewSource(seed))
  5206  	p := NewPopulatedNinOptStruct(popr, true)
  5207  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5208  	jsondata, err := marshaler.MarshalToString(p)
  5209  	if err != nil {
  5210  		t.Fatalf("seed = %d, err = %v", seed, err)
  5211  	}
  5212  	msg := &NinOptStruct{}
  5213  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5214  	if err != nil {
  5215  		t.Fatalf("seed = %d, err = %v", seed, err)
  5216  	}
  5217  	if err := p.VerboseEqual(msg); err != nil {
  5218  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5219  	}
  5220  	if !p.Equal(msg) {
  5221  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5222  	}
  5223  }
  5224  func TestNidRepStructJSON(t *testing.T) {
  5225  	seed := time.Now().UnixNano()
  5226  	popr := math_rand.New(math_rand.NewSource(seed))
  5227  	p := NewPopulatedNidRepStruct(popr, true)
  5228  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5229  	jsondata, err := marshaler.MarshalToString(p)
  5230  	if err != nil {
  5231  		t.Fatalf("seed = %d, err = %v", seed, err)
  5232  	}
  5233  	msg := &NidRepStruct{}
  5234  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5235  	if err != nil {
  5236  		t.Fatalf("seed = %d, err = %v", seed, err)
  5237  	}
  5238  	if err := p.VerboseEqual(msg); err != nil {
  5239  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5240  	}
  5241  	if !p.Equal(msg) {
  5242  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5243  	}
  5244  }
  5245  func TestNinRepStructJSON(t *testing.T) {
  5246  	seed := time.Now().UnixNano()
  5247  	popr := math_rand.New(math_rand.NewSource(seed))
  5248  	p := NewPopulatedNinRepStruct(popr, true)
  5249  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5250  	jsondata, err := marshaler.MarshalToString(p)
  5251  	if err != nil {
  5252  		t.Fatalf("seed = %d, err = %v", seed, err)
  5253  	}
  5254  	msg := &NinRepStruct{}
  5255  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5256  	if err != nil {
  5257  		t.Fatalf("seed = %d, err = %v", seed, err)
  5258  	}
  5259  	if err := p.VerboseEqual(msg); err != nil {
  5260  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5261  	}
  5262  	if !p.Equal(msg) {
  5263  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5264  	}
  5265  }
  5266  func TestNidEmbeddedStructJSON(t *testing.T) {
  5267  	seed := time.Now().UnixNano()
  5268  	popr := math_rand.New(math_rand.NewSource(seed))
  5269  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  5270  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5271  	jsondata, err := marshaler.MarshalToString(p)
  5272  	if err != nil {
  5273  		t.Fatalf("seed = %d, err = %v", seed, err)
  5274  	}
  5275  	msg := &NidEmbeddedStruct{}
  5276  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5277  	if err != nil {
  5278  		t.Fatalf("seed = %d, err = %v", seed, err)
  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 !Json Equal %#v", seed, msg, p)
  5285  	}
  5286  }
  5287  func TestNinEmbeddedStructJSON(t *testing.T) {
  5288  	seed := time.Now().UnixNano()
  5289  	popr := math_rand.New(math_rand.NewSource(seed))
  5290  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  5291  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5292  	jsondata, err := marshaler.MarshalToString(p)
  5293  	if err != nil {
  5294  		t.Fatalf("seed = %d, err = %v", seed, err)
  5295  	}
  5296  	msg := &NinEmbeddedStruct{}
  5297  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5298  	if err != nil {
  5299  		t.Fatalf("seed = %d, err = %v", seed, err)
  5300  	}
  5301  	if err := p.VerboseEqual(msg); err != nil {
  5302  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5303  	}
  5304  	if !p.Equal(msg) {
  5305  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5306  	}
  5307  }
  5308  func TestNidNestedStructJSON(t *testing.T) {
  5309  	seed := time.Now().UnixNano()
  5310  	popr := math_rand.New(math_rand.NewSource(seed))
  5311  	p := NewPopulatedNidNestedStruct(popr, true)
  5312  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5313  	jsondata, err := marshaler.MarshalToString(p)
  5314  	if err != nil {
  5315  		t.Fatalf("seed = %d, err = %v", seed, err)
  5316  	}
  5317  	msg := &NidNestedStruct{}
  5318  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5319  	if err != nil {
  5320  		t.Fatalf("seed = %d, err = %v", seed, err)
  5321  	}
  5322  	if err := p.VerboseEqual(msg); err != nil {
  5323  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5324  	}
  5325  	if !p.Equal(msg) {
  5326  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5327  	}
  5328  }
  5329  func TestNinNestedStructJSON(t *testing.T) {
  5330  	seed := time.Now().UnixNano()
  5331  	popr := math_rand.New(math_rand.NewSource(seed))
  5332  	p := NewPopulatedNinNestedStruct(popr, true)
  5333  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5334  	jsondata, err := marshaler.MarshalToString(p)
  5335  	if err != nil {
  5336  		t.Fatalf("seed = %d, err = %v", seed, err)
  5337  	}
  5338  	msg := &NinNestedStruct{}
  5339  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5340  	if err != nil {
  5341  		t.Fatalf("seed = %d, err = %v", seed, err)
  5342  	}
  5343  	if err := p.VerboseEqual(msg); err != nil {
  5344  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5345  	}
  5346  	if !p.Equal(msg) {
  5347  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5348  	}
  5349  }
  5350  func TestNidOptCustomJSON(t *testing.T) {
  5351  	seed := time.Now().UnixNano()
  5352  	popr := math_rand.New(math_rand.NewSource(seed))
  5353  	p := NewPopulatedNidOptCustom(popr, true)
  5354  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5355  	jsondata, err := marshaler.MarshalToString(p)
  5356  	if err != nil {
  5357  		t.Fatalf("seed = %d, err = %v", seed, err)
  5358  	}
  5359  	msg := &NidOptCustom{}
  5360  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5361  	if err != nil {
  5362  		t.Fatalf("seed = %d, err = %v", seed, err)
  5363  	}
  5364  	if err := p.VerboseEqual(msg); err != nil {
  5365  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5366  	}
  5367  	if !p.Equal(msg) {
  5368  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5369  	}
  5370  }
  5371  func TestCustomDashJSON(t *testing.T) {
  5372  	seed := time.Now().UnixNano()
  5373  	popr := math_rand.New(math_rand.NewSource(seed))
  5374  	p := NewPopulatedCustomDash(popr, true)
  5375  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5376  	jsondata, err := marshaler.MarshalToString(p)
  5377  	if err != nil {
  5378  		t.Fatalf("seed = %d, err = %v", seed, err)
  5379  	}
  5380  	msg := &CustomDash{}
  5381  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5382  	if err != nil {
  5383  		t.Fatalf("seed = %d, err = %v", seed, err)
  5384  	}
  5385  	if err := p.VerboseEqual(msg); err != nil {
  5386  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5387  	}
  5388  	if !p.Equal(msg) {
  5389  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5390  	}
  5391  }
  5392  func TestNinOptCustomJSON(t *testing.T) {
  5393  	seed := time.Now().UnixNano()
  5394  	popr := math_rand.New(math_rand.NewSource(seed))
  5395  	p := NewPopulatedNinOptCustom(popr, true)
  5396  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5397  	jsondata, err := marshaler.MarshalToString(p)
  5398  	if err != nil {
  5399  		t.Fatalf("seed = %d, err = %v", seed, err)
  5400  	}
  5401  	msg := &NinOptCustom{}
  5402  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5403  	if err != nil {
  5404  		t.Fatalf("seed = %d, err = %v", seed, err)
  5405  	}
  5406  	if err := p.VerboseEqual(msg); err != nil {
  5407  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5408  	}
  5409  	if !p.Equal(msg) {
  5410  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5411  	}
  5412  }
  5413  func TestNidRepCustomJSON(t *testing.T) {
  5414  	seed := time.Now().UnixNano()
  5415  	popr := math_rand.New(math_rand.NewSource(seed))
  5416  	p := NewPopulatedNidRepCustom(popr, true)
  5417  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5418  	jsondata, err := marshaler.MarshalToString(p)
  5419  	if err != nil {
  5420  		t.Fatalf("seed = %d, err = %v", seed, err)
  5421  	}
  5422  	msg := &NidRepCustom{}
  5423  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5424  	if err != nil {
  5425  		t.Fatalf("seed = %d, err = %v", seed, err)
  5426  	}
  5427  	if err := p.VerboseEqual(msg); err != nil {
  5428  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5429  	}
  5430  	if !p.Equal(msg) {
  5431  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5432  	}
  5433  }
  5434  func TestNinRepCustomJSON(t *testing.T) {
  5435  	seed := time.Now().UnixNano()
  5436  	popr := math_rand.New(math_rand.NewSource(seed))
  5437  	p := NewPopulatedNinRepCustom(popr, true)
  5438  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5439  	jsondata, err := marshaler.MarshalToString(p)
  5440  	if err != nil {
  5441  		t.Fatalf("seed = %d, err = %v", seed, err)
  5442  	}
  5443  	msg := &NinRepCustom{}
  5444  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5445  	if err != nil {
  5446  		t.Fatalf("seed = %d, err = %v", seed, err)
  5447  	}
  5448  	if err := p.VerboseEqual(msg); err != nil {
  5449  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5450  	}
  5451  	if !p.Equal(msg) {
  5452  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5453  	}
  5454  }
  5455  func TestNinOptNativeUnionJSON(t *testing.T) {
  5456  	seed := time.Now().UnixNano()
  5457  	popr := math_rand.New(math_rand.NewSource(seed))
  5458  	p := NewPopulatedNinOptNativeUnion(popr, true)
  5459  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5460  	jsondata, err := marshaler.MarshalToString(p)
  5461  	if err != nil {
  5462  		t.Fatalf("seed = %d, err = %v", seed, err)
  5463  	}
  5464  	msg := &NinOptNativeUnion{}
  5465  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5466  	if err != nil {
  5467  		t.Fatalf("seed = %d, err = %v", seed, err)
  5468  	}
  5469  	if err := p.VerboseEqual(msg); err != nil {
  5470  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5471  	}
  5472  	if !p.Equal(msg) {
  5473  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5474  	}
  5475  }
  5476  func TestNinOptStructUnionJSON(t *testing.T) {
  5477  	seed := time.Now().UnixNano()
  5478  	popr := math_rand.New(math_rand.NewSource(seed))
  5479  	p := NewPopulatedNinOptStructUnion(popr, true)
  5480  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5481  	jsondata, err := marshaler.MarshalToString(p)
  5482  	if err != nil {
  5483  		t.Fatalf("seed = %d, err = %v", seed, err)
  5484  	}
  5485  	msg := &NinOptStructUnion{}
  5486  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5487  	if err != nil {
  5488  		t.Fatalf("seed = %d, err = %v", seed, err)
  5489  	}
  5490  	if err := p.VerboseEqual(msg); err != nil {
  5491  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5492  	}
  5493  	if !p.Equal(msg) {
  5494  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5495  	}
  5496  }
  5497  func TestNinEmbeddedStructUnionJSON(t *testing.T) {
  5498  	seed := time.Now().UnixNano()
  5499  	popr := math_rand.New(math_rand.NewSource(seed))
  5500  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  5501  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5502  	jsondata, err := marshaler.MarshalToString(p)
  5503  	if err != nil {
  5504  		t.Fatalf("seed = %d, err = %v", seed, err)
  5505  	}
  5506  	msg := &NinEmbeddedStructUnion{}
  5507  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5508  	if err != nil {
  5509  		t.Fatalf("seed = %d, err = %v", seed, err)
  5510  	}
  5511  	if err := p.VerboseEqual(msg); err != nil {
  5512  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5513  	}
  5514  	if !p.Equal(msg) {
  5515  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5516  	}
  5517  }
  5518  func TestNinNestedStructUnionJSON(t *testing.T) {
  5519  	seed := time.Now().UnixNano()
  5520  	popr := math_rand.New(math_rand.NewSource(seed))
  5521  	p := NewPopulatedNinNestedStructUnion(popr, true)
  5522  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5523  	jsondata, err := marshaler.MarshalToString(p)
  5524  	if err != nil {
  5525  		t.Fatalf("seed = %d, err = %v", seed, err)
  5526  	}
  5527  	msg := &NinNestedStructUnion{}
  5528  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5529  	if err != nil {
  5530  		t.Fatalf("seed = %d, err = %v", seed, err)
  5531  	}
  5532  	if err := p.VerboseEqual(msg); err != nil {
  5533  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5534  	}
  5535  	if !p.Equal(msg) {
  5536  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5537  	}
  5538  }
  5539  func TestTreeJSON(t *testing.T) {
  5540  	seed := time.Now().UnixNano()
  5541  	popr := math_rand.New(math_rand.NewSource(seed))
  5542  	p := NewPopulatedTree(popr, true)
  5543  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5544  	jsondata, err := marshaler.MarshalToString(p)
  5545  	if err != nil {
  5546  		t.Fatalf("seed = %d, err = %v", seed, err)
  5547  	}
  5548  	msg := &Tree{}
  5549  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5550  	if err != nil {
  5551  		t.Fatalf("seed = %d, err = %v", seed, err)
  5552  	}
  5553  	if err := p.VerboseEqual(msg); err != nil {
  5554  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5555  	}
  5556  	if !p.Equal(msg) {
  5557  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5558  	}
  5559  }
  5560  func TestOrBranchJSON(t *testing.T) {
  5561  	seed := time.Now().UnixNano()
  5562  	popr := math_rand.New(math_rand.NewSource(seed))
  5563  	p := NewPopulatedOrBranch(popr, true)
  5564  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5565  	jsondata, err := marshaler.MarshalToString(p)
  5566  	if err != nil {
  5567  		t.Fatalf("seed = %d, err = %v", seed, err)
  5568  	}
  5569  	msg := &OrBranch{}
  5570  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5571  	if err != nil {
  5572  		t.Fatalf("seed = %d, err = %v", seed, err)
  5573  	}
  5574  	if err := p.VerboseEqual(msg); err != nil {
  5575  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5576  	}
  5577  	if !p.Equal(msg) {
  5578  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5579  	}
  5580  }
  5581  func TestAndBranchJSON(t *testing.T) {
  5582  	seed := time.Now().UnixNano()
  5583  	popr := math_rand.New(math_rand.NewSource(seed))
  5584  	p := NewPopulatedAndBranch(popr, true)
  5585  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5586  	jsondata, err := marshaler.MarshalToString(p)
  5587  	if err != nil {
  5588  		t.Fatalf("seed = %d, err = %v", seed, err)
  5589  	}
  5590  	msg := &AndBranch{}
  5591  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5592  	if err != nil {
  5593  		t.Fatalf("seed = %d, err = %v", seed, err)
  5594  	}
  5595  	if err := p.VerboseEqual(msg); err != nil {
  5596  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5597  	}
  5598  	if !p.Equal(msg) {
  5599  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5600  	}
  5601  }
  5602  func TestLeafJSON(t *testing.T) {
  5603  	seed := time.Now().UnixNano()
  5604  	popr := math_rand.New(math_rand.NewSource(seed))
  5605  	p := NewPopulatedLeaf(popr, true)
  5606  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5607  	jsondata, err := marshaler.MarshalToString(p)
  5608  	if err != nil {
  5609  		t.Fatalf("seed = %d, err = %v", seed, err)
  5610  	}
  5611  	msg := &Leaf{}
  5612  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5613  	if err != nil {
  5614  		t.Fatalf("seed = %d, err = %v", seed, err)
  5615  	}
  5616  	if err := p.VerboseEqual(msg); err != nil {
  5617  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5618  	}
  5619  	if !p.Equal(msg) {
  5620  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5621  	}
  5622  }
  5623  func TestDeepTreeJSON(t *testing.T) {
  5624  	seed := time.Now().UnixNano()
  5625  	popr := math_rand.New(math_rand.NewSource(seed))
  5626  	p := NewPopulatedDeepTree(popr, true)
  5627  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5628  	jsondata, err := marshaler.MarshalToString(p)
  5629  	if err != nil {
  5630  		t.Fatalf("seed = %d, err = %v", seed, err)
  5631  	}
  5632  	msg := &DeepTree{}
  5633  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5634  	if err != nil {
  5635  		t.Fatalf("seed = %d, err = %v", seed, err)
  5636  	}
  5637  	if err := p.VerboseEqual(msg); err != nil {
  5638  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5639  	}
  5640  	if !p.Equal(msg) {
  5641  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5642  	}
  5643  }
  5644  func TestADeepBranchJSON(t *testing.T) {
  5645  	seed := time.Now().UnixNano()
  5646  	popr := math_rand.New(math_rand.NewSource(seed))
  5647  	p := NewPopulatedADeepBranch(popr, true)
  5648  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5649  	jsondata, err := marshaler.MarshalToString(p)
  5650  	if err != nil {
  5651  		t.Fatalf("seed = %d, err = %v", seed, err)
  5652  	}
  5653  	msg := &ADeepBranch{}
  5654  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5655  	if err != nil {
  5656  		t.Fatalf("seed = %d, err = %v", seed, err)
  5657  	}
  5658  	if err := p.VerboseEqual(msg); err != nil {
  5659  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5660  	}
  5661  	if !p.Equal(msg) {
  5662  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5663  	}
  5664  }
  5665  func TestAndDeepBranchJSON(t *testing.T) {
  5666  	seed := time.Now().UnixNano()
  5667  	popr := math_rand.New(math_rand.NewSource(seed))
  5668  	p := NewPopulatedAndDeepBranch(popr, true)
  5669  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5670  	jsondata, err := marshaler.MarshalToString(p)
  5671  	if err != nil {
  5672  		t.Fatalf("seed = %d, err = %v", seed, err)
  5673  	}
  5674  	msg := &AndDeepBranch{}
  5675  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5676  	if err != nil {
  5677  		t.Fatalf("seed = %d, err = %v", seed, err)
  5678  	}
  5679  	if err := p.VerboseEqual(msg); err != nil {
  5680  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5681  	}
  5682  	if !p.Equal(msg) {
  5683  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5684  	}
  5685  }
  5686  func TestDeepLeafJSON(t *testing.T) {
  5687  	seed := time.Now().UnixNano()
  5688  	popr := math_rand.New(math_rand.NewSource(seed))
  5689  	p := NewPopulatedDeepLeaf(popr, true)
  5690  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5691  	jsondata, err := marshaler.MarshalToString(p)
  5692  	if err != nil {
  5693  		t.Fatalf("seed = %d, err = %v", seed, err)
  5694  	}
  5695  	msg := &DeepLeaf{}
  5696  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5697  	if err != nil {
  5698  		t.Fatalf("seed = %d, err = %v", seed, err)
  5699  	}
  5700  	if err := p.VerboseEqual(msg); err != nil {
  5701  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5702  	}
  5703  	if !p.Equal(msg) {
  5704  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5705  	}
  5706  }
  5707  func TestNilJSON(t *testing.T) {
  5708  	seed := time.Now().UnixNano()
  5709  	popr := math_rand.New(math_rand.NewSource(seed))
  5710  	p := NewPopulatedNil(popr, true)
  5711  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5712  	jsondata, err := marshaler.MarshalToString(p)
  5713  	if err != nil {
  5714  		t.Fatalf("seed = %d, err = %v", seed, err)
  5715  	}
  5716  	msg := &Nil{}
  5717  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5718  	if err != nil {
  5719  		t.Fatalf("seed = %d, err = %v", seed, err)
  5720  	}
  5721  	if err := p.VerboseEqual(msg); err != nil {
  5722  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5723  	}
  5724  	if !p.Equal(msg) {
  5725  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5726  	}
  5727  }
  5728  func TestNidOptEnumJSON(t *testing.T) {
  5729  	seed := time.Now().UnixNano()
  5730  	popr := math_rand.New(math_rand.NewSource(seed))
  5731  	p := NewPopulatedNidOptEnum(popr, true)
  5732  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5733  	jsondata, err := marshaler.MarshalToString(p)
  5734  	if err != nil {
  5735  		t.Fatalf("seed = %d, err = %v", seed, err)
  5736  	}
  5737  	msg := &NidOptEnum{}
  5738  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5739  	if err != nil {
  5740  		t.Fatalf("seed = %d, err = %v", seed, err)
  5741  	}
  5742  	if err := p.VerboseEqual(msg); err != nil {
  5743  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5744  	}
  5745  	if !p.Equal(msg) {
  5746  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5747  	}
  5748  }
  5749  func TestNinOptEnumJSON(t *testing.T) {
  5750  	seed := time.Now().UnixNano()
  5751  	popr := math_rand.New(math_rand.NewSource(seed))
  5752  	p := NewPopulatedNinOptEnum(popr, true)
  5753  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5754  	jsondata, err := marshaler.MarshalToString(p)
  5755  	if err != nil {
  5756  		t.Fatalf("seed = %d, err = %v", seed, err)
  5757  	}
  5758  	msg := &NinOptEnum{}
  5759  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5760  	if err != nil {
  5761  		t.Fatalf("seed = %d, err = %v", seed, err)
  5762  	}
  5763  	if err := p.VerboseEqual(msg); err != nil {
  5764  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5765  	}
  5766  	if !p.Equal(msg) {
  5767  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5768  	}
  5769  }
  5770  func TestNidRepEnumJSON(t *testing.T) {
  5771  	seed := time.Now().UnixNano()
  5772  	popr := math_rand.New(math_rand.NewSource(seed))
  5773  	p := NewPopulatedNidRepEnum(popr, true)
  5774  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5775  	jsondata, err := marshaler.MarshalToString(p)
  5776  	if err != nil {
  5777  		t.Fatalf("seed = %d, err = %v", seed, err)
  5778  	}
  5779  	msg := &NidRepEnum{}
  5780  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5781  	if err != nil {
  5782  		t.Fatalf("seed = %d, err = %v", seed, err)
  5783  	}
  5784  	if err := p.VerboseEqual(msg); err != nil {
  5785  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5786  	}
  5787  	if !p.Equal(msg) {
  5788  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5789  	}
  5790  }
  5791  func TestNinRepEnumJSON(t *testing.T) {
  5792  	seed := time.Now().UnixNano()
  5793  	popr := math_rand.New(math_rand.NewSource(seed))
  5794  	p := NewPopulatedNinRepEnum(popr, true)
  5795  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5796  	jsondata, err := marshaler.MarshalToString(p)
  5797  	if err != nil {
  5798  		t.Fatalf("seed = %d, err = %v", seed, err)
  5799  	}
  5800  	msg := &NinRepEnum{}
  5801  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5802  	if err != nil {
  5803  		t.Fatalf("seed = %d, err = %v", seed, err)
  5804  	}
  5805  	if err := p.VerboseEqual(msg); err != nil {
  5806  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5807  	}
  5808  	if !p.Equal(msg) {
  5809  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5810  	}
  5811  }
  5812  func TestNinOptEnumDefaultJSON(t *testing.T) {
  5813  	seed := time.Now().UnixNano()
  5814  	popr := math_rand.New(math_rand.NewSource(seed))
  5815  	p := NewPopulatedNinOptEnumDefault(popr, true)
  5816  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5817  	jsondata, err := marshaler.MarshalToString(p)
  5818  	if err != nil {
  5819  		t.Fatalf("seed = %d, err = %v", seed, err)
  5820  	}
  5821  	msg := &NinOptEnumDefault{}
  5822  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5823  	if err != nil {
  5824  		t.Fatalf("seed = %d, err = %v", seed, err)
  5825  	}
  5826  	if err := p.VerboseEqual(msg); err != nil {
  5827  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5828  	}
  5829  	if !p.Equal(msg) {
  5830  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5831  	}
  5832  }
  5833  func TestAnotherNinOptEnumJSON(t *testing.T) {
  5834  	seed := time.Now().UnixNano()
  5835  	popr := math_rand.New(math_rand.NewSource(seed))
  5836  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  5837  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5838  	jsondata, err := marshaler.MarshalToString(p)
  5839  	if err != nil {
  5840  		t.Fatalf("seed = %d, err = %v", seed, err)
  5841  	}
  5842  	msg := &AnotherNinOptEnum{}
  5843  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5844  	if err != nil {
  5845  		t.Fatalf("seed = %d, err = %v", seed, err)
  5846  	}
  5847  	if err := p.VerboseEqual(msg); err != nil {
  5848  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5849  	}
  5850  	if !p.Equal(msg) {
  5851  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5852  	}
  5853  }
  5854  func TestAnotherNinOptEnumDefaultJSON(t *testing.T) {
  5855  	seed := time.Now().UnixNano()
  5856  	popr := math_rand.New(math_rand.NewSource(seed))
  5857  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  5858  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5859  	jsondata, err := marshaler.MarshalToString(p)
  5860  	if err != nil {
  5861  		t.Fatalf("seed = %d, err = %v", seed, err)
  5862  	}
  5863  	msg := &AnotherNinOptEnumDefault{}
  5864  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5865  	if err != nil {
  5866  		t.Fatalf("seed = %d, err = %v", seed, err)
  5867  	}
  5868  	if err := p.VerboseEqual(msg); err != nil {
  5869  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5870  	}
  5871  	if !p.Equal(msg) {
  5872  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5873  	}
  5874  }
  5875  func TestTimerJSON(t *testing.T) {
  5876  	seed := time.Now().UnixNano()
  5877  	popr := math_rand.New(math_rand.NewSource(seed))
  5878  	p := NewPopulatedTimer(popr, true)
  5879  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5880  	jsondata, err := marshaler.MarshalToString(p)
  5881  	if err != nil {
  5882  		t.Fatalf("seed = %d, err = %v", seed, err)
  5883  	}
  5884  	msg := &Timer{}
  5885  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5886  	if err != nil {
  5887  		t.Fatalf("seed = %d, err = %v", seed, err)
  5888  	}
  5889  	if err := p.VerboseEqual(msg); err != nil {
  5890  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5891  	}
  5892  	if !p.Equal(msg) {
  5893  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5894  	}
  5895  }
  5896  func TestMyExtendableJSON(t *testing.T) {
  5897  	seed := time.Now().UnixNano()
  5898  	popr := math_rand.New(math_rand.NewSource(seed))
  5899  	p := NewPopulatedMyExtendable(popr, true)
  5900  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5901  	jsondata, err := marshaler.MarshalToString(p)
  5902  	if err != nil {
  5903  		t.Fatalf("seed = %d, err = %v", seed, err)
  5904  	}
  5905  	msg := &MyExtendable{}
  5906  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5907  	if err != nil {
  5908  		t.Fatalf("seed = %d, err = %v", seed, err)
  5909  	}
  5910  	if err := p.VerboseEqual(msg); err != nil {
  5911  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5912  	}
  5913  	if !p.Equal(msg) {
  5914  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5915  	}
  5916  }
  5917  func TestOtherExtenableJSON(t *testing.T) {
  5918  	seed := time.Now().UnixNano()
  5919  	popr := math_rand.New(math_rand.NewSource(seed))
  5920  	p := NewPopulatedOtherExtenable(popr, true)
  5921  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5922  	jsondata, err := marshaler.MarshalToString(p)
  5923  	if err != nil {
  5924  		t.Fatalf("seed = %d, err = %v", seed, err)
  5925  	}
  5926  	msg := &OtherExtenable{}
  5927  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5928  	if err != nil {
  5929  		t.Fatalf("seed = %d, err = %v", seed, err)
  5930  	}
  5931  	if err := p.VerboseEqual(msg); err != nil {
  5932  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5933  	}
  5934  	if !p.Equal(msg) {
  5935  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5936  	}
  5937  }
  5938  func TestNestedDefinitionJSON(t *testing.T) {
  5939  	seed := time.Now().UnixNano()
  5940  	popr := math_rand.New(math_rand.NewSource(seed))
  5941  	p := NewPopulatedNestedDefinition(popr, true)
  5942  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5943  	jsondata, err := marshaler.MarshalToString(p)
  5944  	if err != nil {
  5945  		t.Fatalf("seed = %d, err = %v", seed, err)
  5946  	}
  5947  	msg := &NestedDefinition{}
  5948  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5949  	if err != nil {
  5950  		t.Fatalf("seed = %d, err = %v", seed, err)
  5951  	}
  5952  	if err := p.VerboseEqual(msg); err != nil {
  5953  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5954  	}
  5955  	if !p.Equal(msg) {
  5956  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5957  	}
  5958  }
  5959  func TestNestedDefinition_NestedMessageJSON(t *testing.T) {
  5960  	seed := time.Now().UnixNano()
  5961  	popr := math_rand.New(math_rand.NewSource(seed))
  5962  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  5963  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5964  	jsondata, err := marshaler.MarshalToString(p)
  5965  	if err != nil {
  5966  		t.Fatalf("seed = %d, err = %v", seed, err)
  5967  	}
  5968  	msg := &NestedDefinition_NestedMessage{}
  5969  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5970  	if err != nil {
  5971  		t.Fatalf("seed = %d, err = %v", seed, err)
  5972  	}
  5973  	if err := p.VerboseEqual(msg); err != nil {
  5974  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  5975  	}
  5976  	if !p.Equal(msg) {
  5977  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  5978  	}
  5979  }
  5980  func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) {
  5981  	seed := time.Now().UnixNano()
  5982  	popr := math_rand.New(math_rand.NewSource(seed))
  5983  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  5984  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  5985  	jsondata, err := marshaler.MarshalToString(p)
  5986  	if err != nil {
  5987  		t.Fatalf("seed = %d, err = %v", seed, err)
  5988  	}
  5989  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  5990  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  5991  	if err != nil {
  5992  		t.Fatalf("seed = %d, err = %v", seed, err)
  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 !Json Equal %#v", seed, msg, p)
  5999  	}
  6000  }
  6001  func TestNestedScopeJSON(t *testing.T) {
  6002  	seed := time.Now().UnixNano()
  6003  	popr := math_rand.New(math_rand.NewSource(seed))
  6004  	p := NewPopulatedNestedScope(popr, true)
  6005  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6006  	jsondata, err := marshaler.MarshalToString(p)
  6007  	if err != nil {
  6008  		t.Fatalf("seed = %d, err = %v", seed, err)
  6009  	}
  6010  	msg := &NestedScope{}
  6011  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6012  	if err != nil {
  6013  		t.Fatalf("seed = %d, err = %v", seed, err)
  6014  	}
  6015  	if err := p.VerboseEqual(msg); err != nil {
  6016  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6017  	}
  6018  	if !p.Equal(msg) {
  6019  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6020  	}
  6021  }
  6022  func TestNinOptNativeDefaultJSON(t *testing.T) {
  6023  	seed := time.Now().UnixNano()
  6024  	popr := math_rand.New(math_rand.NewSource(seed))
  6025  	p := NewPopulatedNinOptNativeDefault(popr, true)
  6026  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6027  	jsondata, err := marshaler.MarshalToString(p)
  6028  	if err != nil {
  6029  		t.Fatalf("seed = %d, err = %v", seed, err)
  6030  	}
  6031  	msg := &NinOptNativeDefault{}
  6032  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6033  	if err != nil {
  6034  		t.Fatalf("seed = %d, err = %v", seed, err)
  6035  	}
  6036  	if err := p.VerboseEqual(msg); err != nil {
  6037  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6038  	}
  6039  	if !p.Equal(msg) {
  6040  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6041  	}
  6042  }
  6043  func TestCustomContainerJSON(t *testing.T) {
  6044  	seed := time.Now().UnixNano()
  6045  	popr := math_rand.New(math_rand.NewSource(seed))
  6046  	p := NewPopulatedCustomContainer(popr, true)
  6047  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6048  	jsondata, err := marshaler.MarshalToString(p)
  6049  	if err != nil {
  6050  		t.Fatalf("seed = %d, err = %v", seed, err)
  6051  	}
  6052  	msg := &CustomContainer{}
  6053  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6054  	if err != nil {
  6055  		t.Fatalf("seed = %d, err = %v", seed, err)
  6056  	}
  6057  	if err := p.VerboseEqual(msg); err != nil {
  6058  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6059  	}
  6060  	if !p.Equal(msg) {
  6061  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6062  	}
  6063  }
  6064  func TestCustomNameNidOptNativeJSON(t *testing.T) {
  6065  	seed := time.Now().UnixNano()
  6066  	popr := math_rand.New(math_rand.NewSource(seed))
  6067  	p := NewPopulatedCustomNameNidOptNative(popr, true)
  6068  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6069  	jsondata, err := marshaler.MarshalToString(p)
  6070  	if err != nil {
  6071  		t.Fatalf("seed = %d, err = %v", seed, err)
  6072  	}
  6073  	msg := &CustomNameNidOptNative{}
  6074  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6075  	if err != nil {
  6076  		t.Fatalf("seed = %d, err = %v", seed, err)
  6077  	}
  6078  	if err := p.VerboseEqual(msg); err != nil {
  6079  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6080  	}
  6081  	if !p.Equal(msg) {
  6082  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6083  	}
  6084  }
  6085  func TestCustomNameNinOptNativeJSON(t *testing.T) {
  6086  	seed := time.Now().UnixNano()
  6087  	popr := math_rand.New(math_rand.NewSource(seed))
  6088  	p := NewPopulatedCustomNameNinOptNative(popr, true)
  6089  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6090  	jsondata, err := marshaler.MarshalToString(p)
  6091  	if err != nil {
  6092  		t.Fatalf("seed = %d, err = %v", seed, err)
  6093  	}
  6094  	msg := &CustomNameNinOptNative{}
  6095  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6096  	if err != nil {
  6097  		t.Fatalf("seed = %d, err = %v", seed, err)
  6098  	}
  6099  	if err := p.VerboseEqual(msg); err != nil {
  6100  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6101  	}
  6102  	if !p.Equal(msg) {
  6103  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6104  	}
  6105  }
  6106  func TestCustomNameNinRepNativeJSON(t *testing.T) {
  6107  	seed := time.Now().UnixNano()
  6108  	popr := math_rand.New(math_rand.NewSource(seed))
  6109  	p := NewPopulatedCustomNameNinRepNative(popr, true)
  6110  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6111  	jsondata, err := marshaler.MarshalToString(p)
  6112  	if err != nil {
  6113  		t.Fatalf("seed = %d, err = %v", seed, err)
  6114  	}
  6115  	msg := &CustomNameNinRepNative{}
  6116  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6117  	if err != nil {
  6118  		t.Fatalf("seed = %d, err = %v", seed, err)
  6119  	}
  6120  	if err := p.VerboseEqual(msg); err != nil {
  6121  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6122  	}
  6123  	if !p.Equal(msg) {
  6124  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6125  	}
  6126  }
  6127  func TestCustomNameNinStructJSON(t *testing.T) {
  6128  	seed := time.Now().UnixNano()
  6129  	popr := math_rand.New(math_rand.NewSource(seed))
  6130  	p := NewPopulatedCustomNameNinStruct(popr, true)
  6131  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6132  	jsondata, err := marshaler.MarshalToString(p)
  6133  	if err != nil {
  6134  		t.Fatalf("seed = %d, err = %v", seed, err)
  6135  	}
  6136  	msg := &CustomNameNinStruct{}
  6137  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6138  	if err != nil {
  6139  		t.Fatalf("seed = %d, err = %v", seed, err)
  6140  	}
  6141  	if err := p.VerboseEqual(msg); err != nil {
  6142  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6143  	}
  6144  	if !p.Equal(msg) {
  6145  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6146  	}
  6147  }
  6148  func TestCustomNameCustomTypeJSON(t *testing.T) {
  6149  	seed := time.Now().UnixNano()
  6150  	popr := math_rand.New(math_rand.NewSource(seed))
  6151  	p := NewPopulatedCustomNameCustomType(popr, true)
  6152  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6153  	jsondata, err := marshaler.MarshalToString(p)
  6154  	if err != nil {
  6155  		t.Fatalf("seed = %d, err = %v", seed, err)
  6156  	}
  6157  	msg := &CustomNameCustomType{}
  6158  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6159  	if err != nil {
  6160  		t.Fatalf("seed = %d, err = %v", seed, err)
  6161  	}
  6162  	if err := p.VerboseEqual(msg); err != nil {
  6163  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6164  	}
  6165  	if !p.Equal(msg) {
  6166  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6167  	}
  6168  }
  6169  func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) {
  6170  	seed := time.Now().UnixNano()
  6171  	popr := math_rand.New(math_rand.NewSource(seed))
  6172  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
  6173  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6174  	jsondata, err := marshaler.MarshalToString(p)
  6175  	if err != nil {
  6176  		t.Fatalf("seed = %d, err = %v", seed, err)
  6177  	}
  6178  	msg := &CustomNameNinEmbeddedStructUnion{}
  6179  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6180  	if err != nil {
  6181  		t.Fatalf("seed = %d, err = %v", seed, err)
  6182  	}
  6183  	if err := p.VerboseEqual(msg); err != nil {
  6184  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6185  	}
  6186  	if !p.Equal(msg) {
  6187  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6188  	}
  6189  }
  6190  func TestCustomNameEnumJSON(t *testing.T) {
  6191  	seed := time.Now().UnixNano()
  6192  	popr := math_rand.New(math_rand.NewSource(seed))
  6193  	p := NewPopulatedCustomNameEnum(popr, true)
  6194  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6195  	jsondata, err := marshaler.MarshalToString(p)
  6196  	if err != nil {
  6197  		t.Fatalf("seed = %d, err = %v", seed, err)
  6198  	}
  6199  	msg := &CustomNameEnum{}
  6200  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6201  	if err != nil {
  6202  		t.Fatalf("seed = %d, err = %v", seed, err)
  6203  	}
  6204  	if err := p.VerboseEqual(msg); err != nil {
  6205  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6206  	}
  6207  	if !p.Equal(msg) {
  6208  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6209  	}
  6210  }
  6211  func TestNoExtensionsMapJSON(t *testing.T) {
  6212  	seed := time.Now().UnixNano()
  6213  	popr := math_rand.New(math_rand.NewSource(seed))
  6214  	p := NewPopulatedNoExtensionsMap(popr, true)
  6215  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6216  	jsondata, err := marshaler.MarshalToString(p)
  6217  	if err != nil {
  6218  		t.Fatalf("seed = %d, err = %v", seed, err)
  6219  	}
  6220  	msg := &NoExtensionsMap{}
  6221  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6222  	if err != nil {
  6223  		t.Fatalf("seed = %d, err = %v", seed, err)
  6224  	}
  6225  	if err := p.VerboseEqual(msg); err != nil {
  6226  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6227  	}
  6228  	if !p.Equal(msg) {
  6229  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6230  	}
  6231  }
  6232  func TestUnrecognizedJSON(t *testing.T) {
  6233  	seed := time.Now().UnixNano()
  6234  	popr := math_rand.New(math_rand.NewSource(seed))
  6235  	p := NewPopulatedUnrecognized(popr, true)
  6236  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6237  	jsondata, err := marshaler.MarshalToString(p)
  6238  	if err != nil {
  6239  		t.Fatalf("seed = %d, err = %v", seed, err)
  6240  	}
  6241  	msg := &Unrecognized{}
  6242  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6243  	if err != nil {
  6244  		t.Fatalf("seed = %d, err = %v", seed, err)
  6245  	}
  6246  	if err := p.VerboseEqual(msg); err != nil {
  6247  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6248  	}
  6249  	if !p.Equal(msg) {
  6250  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6251  	}
  6252  }
  6253  func TestUnrecognizedWithInnerJSON(t *testing.T) {
  6254  	seed := time.Now().UnixNano()
  6255  	popr := math_rand.New(math_rand.NewSource(seed))
  6256  	p := NewPopulatedUnrecognizedWithInner(popr, true)
  6257  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6258  	jsondata, err := marshaler.MarshalToString(p)
  6259  	if err != nil {
  6260  		t.Fatalf("seed = %d, err = %v", seed, err)
  6261  	}
  6262  	msg := &UnrecognizedWithInner{}
  6263  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6264  	if err != nil {
  6265  		t.Fatalf("seed = %d, err = %v", seed, err)
  6266  	}
  6267  	if err := p.VerboseEqual(msg); err != nil {
  6268  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6269  	}
  6270  	if !p.Equal(msg) {
  6271  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6272  	}
  6273  }
  6274  func TestUnrecognizedWithInner_InnerJSON(t *testing.T) {
  6275  	seed := time.Now().UnixNano()
  6276  	popr := math_rand.New(math_rand.NewSource(seed))
  6277  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
  6278  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6279  	jsondata, err := marshaler.MarshalToString(p)
  6280  	if err != nil {
  6281  		t.Fatalf("seed = %d, err = %v", seed, err)
  6282  	}
  6283  	msg := &UnrecognizedWithInner_Inner{}
  6284  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6285  	if err != nil {
  6286  		t.Fatalf("seed = %d, err = %v", seed, err)
  6287  	}
  6288  	if err := p.VerboseEqual(msg); err != nil {
  6289  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6290  	}
  6291  	if !p.Equal(msg) {
  6292  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6293  	}
  6294  }
  6295  func TestUnrecognizedWithEmbedJSON(t *testing.T) {
  6296  	seed := time.Now().UnixNano()
  6297  	popr := math_rand.New(math_rand.NewSource(seed))
  6298  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
  6299  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6300  	jsondata, err := marshaler.MarshalToString(p)
  6301  	if err != nil {
  6302  		t.Fatalf("seed = %d, err = %v", seed, err)
  6303  	}
  6304  	msg := &UnrecognizedWithEmbed{}
  6305  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6306  	if err != nil {
  6307  		t.Fatalf("seed = %d, err = %v", seed, err)
  6308  	}
  6309  	if err := p.VerboseEqual(msg); err != nil {
  6310  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6311  	}
  6312  	if !p.Equal(msg) {
  6313  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6314  	}
  6315  }
  6316  func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) {
  6317  	seed := time.Now().UnixNano()
  6318  	popr := math_rand.New(math_rand.NewSource(seed))
  6319  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
  6320  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6321  	jsondata, err := marshaler.MarshalToString(p)
  6322  	if err != nil {
  6323  		t.Fatalf("seed = %d, err = %v", seed, err)
  6324  	}
  6325  	msg := &UnrecognizedWithEmbed_Embedded{}
  6326  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6327  	if err != nil {
  6328  		t.Fatalf("seed = %d, err = %v", seed, err)
  6329  	}
  6330  	if err := p.VerboseEqual(msg); err != nil {
  6331  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6332  	}
  6333  	if !p.Equal(msg) {
  6334  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6335  	}
  6336  }
  6337  func TestNodeJSON(t *testing.T) {
  6338  	seed := time.Now().UnixNano()
  6339  	popr := math_rand.New(math_rand.NewSource(seed))
  6340  	p := NewPopulatedNode(popr, true)
  6341  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6342  	jsondata, err := marshaler.MarshalToString(p)
  6343  	if err != nil {
  6344  		t.Fatalf("seed = %d, err = %v", seed, err)
  6345  	}
  6346  	msg := &Node{}
  6347  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6348  	if err != nil {
  6349  		t.Fatalf("seed = %d, err = %v", seed, err)
  6350  	}
  6351  	if err := p.VerboseEqual(msg); err != nil {
  6352  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6353  	}
  6354  	if !p.Equal(msg) {
  6355  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6356  	}
  6357  }
  6358  func TestNonByteCustomTypeJSON(t *testing.T) {
  6359  	seed := time.Now().UnixNano()
  6360  	popr := math_rand.New(math_rand.NewSource(seed))
  6361  	p := NewPopulatedNonByteCustomType(popr, true)
  6362  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6363  	jsondata, err := marshaler.MarshalToString(p)
  6364  	if err != nil {
  6365  		t.Fatalf("seed = %d, err = %v", seed, err)
  6366  	}
  6367  	msg := &NonByteCustomType{}
  6368  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6369  	if err != nil {
  6370  		t.Fatalf("seed = %d, err = %v", seed, err)
  6371  	}
  6372  	if err := p.VerboseEqual(msg); err != nil {
  6373  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6374  	}
  6375  	if !p.Equal(msg) {
  6376  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6377  	}
  6378  }
  6379  func TestNidOptNonByteCustomTypeJSON(t *testing.T) {
  6380  	seed := time.Now().UnixNano()
  6381  	popr := math_rand.New(math_rand.NewSource(seed))
  6382  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
  6383  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6384  	jsondata, err := marshaler.MarshalToString(p)
  6385  	if err != nil {
  6386  		t.Fatalf("seed = %d, err = %v", seed, err)
  6387  	}
  6388  	msg := &NidOptNonByteCustomType{}
  6389  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6390  	if err != nil {
  6391  		t.Fatalf("seed = %d, err = %v", seed, err)
  6392  	}
  6393  	if err := p.VerboseEqual(msg); err != nil {
  6394  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6395  	}
  6396  	if !p.Equal(msg) {
  6397  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6398  	}
  6399  }
  6400  func TestNinOptNonByteCustomTypeJSON(t *testing.T) {
  6401  	seed := time.Now().UnixNano()
  6402  	popr := math_rand.New(math_rand.NewSource(seed))
  6403  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
  6404  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6405  	jsondata, err := marshaler.MarshalToString(p)
  6406  	if err != nil {
  6407  		t.Fatalf("seed = %d, err = %v", seed, err)
  6408  	}
  6409  	msg := &NinOptNonByteCustomType{}
  6410  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6411  	if err != nil {
  6412  		t.Fatalf("seed = %d, err = %v", seed, err)
  6413  	}
  6414  	if err := p.VerboseEqual(msg); err != nil {
  6415  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6416  	}
  6417  	if !p.Equal(msg) {
  6418  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6419  	}
  6420  }
  6421  func TestNidRepNonByteCustomTypeJSON(t *testing.T) {
  6422  	seed := time.Now().UnixNano()
  6423  	popr := math_rand.New(math_rand.NewSource(seed))
  6424  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
  6425  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6426  	jsondata, err := marshaler.MarshalToString(p)
  6427  	if err != nil {
  6428  		t.Fatalf("seed = %d, err = %v", seed, err)
  6429  	}
  6430  	msg := &NidRepNonByteCustomType{}
  6431  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6432  	if err != nil {
  6433  		t.Fatalf("seed = %d, err = %v", seed, err)
  6434  	}
  6435  	if err := p.VerboseEqual(msg); err != nil {
  6436  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6437  	}
  6438  	if !p.Equal(msg) {
  6439  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6440  	}
  6441  }
  6442  func TestNinRepNonByteCustomTypeJSON(t *testing.T) {
  6443  	seed := time.Now().UnixNano()
  6444  	popr := math_rand.New(math_rand.NewSource(seed))
  6445  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
  6446  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6447  	jsondata, err := marshaler.MarshalToString(p)
  6448  	if err != nil {
  6449  		t.Fatalf("seed = %d, err = %v", seed, err)
  6450  	}
  6451  	msg := &NinRepNonByteCustomType{}
  6452  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6453  	if err != nil {
  6454  		t.Fatalf("seed = %d, err = %v", seed, err)
  6455  	}
  6456  	if err := p.VerboseEqual(msg); err != nil {
  6457  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6458  	}
  6459  	if !p.Equal(msg) {
  6460  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6461  	}
  6462  }
  6463  func TestProtoTypeJSON(t *testing.T) {
  6464  	seed := time.Now().UnixNano()
  6465  	popr := math_rand.New(math_rand.NewSource(seed))
  6466  	p := NewPopulatedProtoType(popr, true)
  6467  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
  6468  	jsondata, err := marshaler.MarshalToString(p)
  6469  	if err != nil {
  6470  		t.Fatalf("seed = %d, err = %v", seed, err)
  6471  	}
  6472  	msg := &ProtoType{}
  6473  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
  6474  	if err != nil {
  6475  		t.Fatalf("seed = %d, err = %v", seed, err)
  6476  	}
  6477  	if err := p.VerboseEqual(msg); err != nil {
  6478  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6479  	}
  6480  	if !p.Equal(msg) {
  6481  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
  6482  	}
  6483  }
  6484  func TestNidOptNativeProtoText(t *testing.T) {
  6485  	seed := time.Now().UnixNano()
  6486  	popr := math_rand.New(math_rand.NewSource(seed))
  6487  	p := NewPopulatedNidOptNative(popr, true)
  6488  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6489  	msg := &NidOptNative{}
  6490  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6491  		t.Fatalf("seed = %d, err = %v", seed, err)
  6492  	}
  6493  	if err := p.VerboseEqual(msg); err != nil {
  6494  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6495  	}
  6496  	if !p.Equal(msg) {
  6497  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6498  	}
  6499  }
  6500  
  6501  func TestNidOptNativeProtoCompactText(t *testing.T) {
  6502  	seed := time.Now().UnixNano()
  6503  	popr := math_rand.New(math_rand.NewSource(seed))
  6504  	p := NewPopulatedNidOptNative(popr, true)
  6505  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6506  	msg := &NidOptNative{}
  6507  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6508  		t.Fatalf("seed = %d, err = %v", seed, err)
  6509  	}
  6510  	if err := p.VerboseEqual(msg); err != nil {
  6511  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6512  	}
  6513  	if !p.Equal(msg) {
  6514  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6515  	}
  6516  }
  6517  
  6518  func TestNinOptNativeProtoText(t *testing.T) {
  6519  	seed := time.Now().UnixNano()
  6520  	popr := math_rand.New(math_rand.NewSource(seed))
  6521  	p := NewPopulatedNinOptNative(popr, true)
  6522  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6523  	msg := &NinOptNative{}
  6524  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6525  		t.Fatalf("seed = %d, err = %v", seed, err)
  6526  	}
  6527  	if err := p.VerboseEqual(msg); err != nil {
  6528  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6529  	}
  6530  	if !p.Equal(msg) {
  6531  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6532  	}
  6533  }
  6534  
  6535  func TestNinOptNativeProtoCompactText(t *testing.T) {
  6536  	seed := time.Now().UnixNano()
  6537  	popr := math_rand.New(math_rand.NewSource(seed))
  6538  	p := NewPopulatedNinOptNative(popr, true)
  6539  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6540  	msg := &NinOptNative{}
  6541  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6542  		t.Fatalf("seed = %d, err = %v", seed, err)
  6543  	}
  6544  	if err := p.VerboseEqual(msg); err != nil {
  6545  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6546  	}
  6547  	if !p.Equal(msg) {
  6548  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6549  	}
  6550  }
  6551  
  6552  func TestNidRepNativeProtoText(t *testing.T) {
  6553  	seed := time.Now().UnixNano()
  6554  	popr := math_rand.New(math_rand.NewSource(seed))
  6555  	p := NewPopulatedNidRepNative(popr, true)
  6556  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6557  	msg := &NidRepNative{}
  6558  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6559  		t.Fatalf("seed = %d, err = %v", seed, err)
  6560  	}
  6561  	if err := p.VerboseEqual(msg); err != nil {
  6562  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6563  	}
  6564  	if !p.Equal(msg) {
  6565  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6566  	}
  6567  }
  6568  
  6569  func TestNidRepNativeProtoCompactText(t *testing.T) {
  6570  	seed := time.Now().UnixNano()
  6571  	popr := math_rand.New(math_rand.NewSource(seed))
  6572  	p := NewPopulatedNidRepNative(popr, true)
  6573  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6574  	msg := &NidRepNative{}
  6575  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6576  		t.Fatalf("seed = %d, err = %v", seed, err)
  6577  	}
  6578  	if err := p.VerboseEqual(msg); err != nil {
  6579  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6580  	}
  6581  	if !p.Equal(msg) {
  6582  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6583  	}
  6584  }
  6585  
  6586  func TestNinRepNativeProtoText(t *testing.T) {
  6587  	seed := time.Now().UnixNano()
  6588  	popr := math_rand.New(math_rand.NewSource(seed))
  6589  	p := NewPopulatedNinRepNative(popr, true)
  6590  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6591  	msg := &NinRepNative{}
  6592  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6593  		t.Fatalf("seed = %d, err = %v", seed, err)
  6594  	}
  6595  	if err := p.VerboseEqual(msg); err != nil {
  6596  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6597  	}
  6598  	if !p.Equal(msg) {
  6599  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6600  	}
  6601  }
  6602  
  6603  func TestNinRepNativeProtoCompactText(t *testing.T) {
  6604  	seed := time.Now().UnixNano()
  6605  	popr := math_rand.New(math_rand.NewSource(seed))
  6606  	p := NewPopulatedNinRepNative(popr, true)
  6607  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6608  	msg := &NinRepNative{}
  6609  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6610  		t.Fatalf("seed = %d, err = %v", seed, err)
  6611  	}
  6612  	if err := p.VerboseEqual(msg); err != nil {
  6613  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6614  	}
  6615  	if !p.Equal(msg) {
  6616  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6617  	}
  6618  }
  6619  
  6620  func TestNidRepPackedNativeProtoText(t *testing.T) {
  6621  	seed := time.Now().UnixNano()
  6622  	popr := math_rand.New(math_rand.NewSource(seed))
  6623  	p := NewPopulatedNidRepPackedNative(popr, true)
  6624  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6625  	msg := &NidRepPackedNative{}
  6626  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6627  		t.Fatalf("seed = %d, err = %v", seed, err)
  6628  	}
  6629  	if err := p.VerboseEqual(msg); err != nil {
  6630  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6631  	}
  6632  	if !p.Equal(msg) {
  6633  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6634  	}
  6635  }
  6636  
  6637  func TestNidRepPackedNativeProtoCompactText(t *testing.T) {
  6638  	seed := time.Now().UnixNano()
  6639  	popr := math_rand.New(math_rand.NewSource(seed))
  6640  	p := NewPopulatedNidRepPackedNative(popr, true)
  6641  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6642  	msg := &NidRepPackedNative{}
  6643  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6644  		t.Fatalf("seed = %d, err = %v", seed, err)
  6645  	}
  6646  	if err := p.VerboseEqual(msg); err != nil {
  6647  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6648  	}
  6649  	if !p.Equal(msg) {
  6650  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6651  	}
  6652  }
  6653  
  6654  func TestNinRepPackedNativeProtoText(t *testing.T) {
  6655  	seed := time.Now().UnixNano()
  6656  	popr := math_rand.New(math_rand.NewSource(seed))
  6657  	p := NewPopulatedNinRepPackedNative(popr, true)
  6658  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6659  	msg := &NinRepPackedNative{}
  6660  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6661  		t.Fatalf("seed = %d, err = %v", seed, err)
  6662  	}
  6663  	if err := p.VerboseEqual(msg); err != nil {
  6664  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6665  	}
  6666  	if !p.Equal(msg) {
  6667  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6668  	}
  6669  }
  6670  
  6671  func TestNinRepPackedNativeProtoCompactText(t *testing.T) {
  6672  	seed := time.Now().UnixNano()
  6673  	popr := math_rand.New(math_rand.NewSource(seed))
  6674  	p := NewPopulatedNinRepPackedNative(popr, true)
  6675  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6676  	msg := &NinRepPackedNative{}
  6677  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6678  		t.Fatalf("seed = %d, err = %v", seed, err)
  6679  	}
  6680  	if err := p.VerboseEqual(msg); err != nil {
  6681  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6682  	}
  6683  	if !p.Equal(msg) {
  6684  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6685  	}
  6686  }
  6687  
  6688  func TestNidOptStructProtoText(t *testing.T) {
  6689  	seed := time.Now().UnixNano()
  6690  	popr := math_rand.New(math_rand.NewSource(seed))
  6691  	p := NewPopulatedNidOptStruct(popr, true)
  6692  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6693  	msg := &NidOptStruct{}
  6694  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6695  		t.Fatalf("seed = %d, err = %v", seed, err)
  6696  	}
  6697  	if err := p.VerboseEqual(msg); err != nil {
  6698  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6699  	}
  6700  	if !p.Equal(msg) {
  6701  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6702  	}
  6703  }
  6704  
  6705  func TestNidOptStructProtoCompactText(t *testing.T) {
  6706  	seed := time.Now().UnixNano()
  6707  	popr := math_rand.New(math_rand.NewSource(seed))
  6708  	p := NewPopulatedNidOptStruct(popr, true)
  6709  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6710  	msg := &NidOptStruct{}
  6711  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6712  		t.Fatalf("seed = %d, err = %v", seed, err)
  6713  	}
  6714  	if err := p.VerboseEqual(msg); err != nil {
  6715  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6716  	}
  6717  	if !p.Equal(msg) {
  6718  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6719  	}
  6720  }
  6721  
  6722  func TestNinOptStructProtoText(t *testing.T) {
  6723  	seed := time.Now().UnixNano()
  6724  	popr := math_rand.New(math_rand.NewSource(seed))
  6725  	p := NewPopulatedNinOptStruct(popr, true)
  6726  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6727  	msg := &NinOptStruct{}
  6728  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6729  		t.Fatalf("seed = %d, err = %v", seed, err)
  6730  	}
  6731  	if err := p.VerboseEqual(msg); err != nil {
  6732  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6733  	}
  6734  	if !p.Equal(msg) {
  6735  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6736  	}
  6737  }
  6738  
  6739  func TestNinOptStructProtoCompactText(t *testing.T) {
  6740  	seed := time.Now().UnixNano()
  6741  	popr := math_rand.New(math_rand.NewSource(seed))
  6742  	p := NewPopulatedNinOptStruct(popr, true)
  6743  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6744  	msg := &NinOptStruct{}
  6745  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6746  		t.Fatalf("seed = %d, err = %v", seed, err)
  6747  	}
  6748  	if err := p.VerboseEqual(msg); err != nil {
  6749  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6750  	}
  6751  	if !p.Equal(msg) {
  6752  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6753  	}
  6754  }
  6755  
  6756  func TestNidRepStructProtoText(t *testing.T) {
  6757  	seed := time.Now().UnixNano()
  6758  	popr := math_rand.New(math_rand.NewSource(seed))
  6759  	p := NewPopulatedNidRepStruct(popr, true)
  6760  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6761  	msg := &NidRepStruct{}
  6762  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6763  		t.Fatalf("seed = %d, err = %v", seed, err)
  6764  	}
  6765  	if err := p.VerboseEqual(msg); err != nil {
  6766  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6767  	}
  6768  	if !p.Equal(msg) {
  6769  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6770  	}
  6771  }
  6772  
  6773  func TestNidRepStructProtoCompactText(t *testing.T) {
  6774  	seed := time.Now().UnixNano()
  6775  	popr := math_rand.New(math_rand.NewSource(seed))
  6776  	p := NewPopulatedNidRepStruct(popr, true)
  6777  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6778  	msg := &NidRepStruct{}
  6779  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6780  		t.Fatalf("seed = %d, err = %v", seed, err)
  6781  	}
  6782  	if err := p.VerboseEqual(msg); err != nil {
  6783  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6784  	}
  6785  	if !p.Equal(msg) {
  6786  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6787  	}
  6788  }
  6789  
  6790  func TestNinRepStructProtoText(t *testing.T) {
  6791  	seed := time.Now().UnixNano()
  6792  	popr := math_rand.New(math_rand.NewSource(seed))
  6793  	p := NewPopulatedNinRepStruct(popr, true)
  6794  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6795  	msg := &NinRepStruct{}
  6796  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6797  		t.Fatalf("seed = %d, err = %v", seed, err)
  6798  	}
  6799  	if err := p.VerboseEqual(msg); err != nil {
  6800  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6801  	}
  6802  	if !p.Equal(msg) {
  6803  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6804  	}
  6805  }
  6806  
  6807  func TestNinRepStructProtoCompactText(t *testing.T) {
  6808  	seed := time.Now().UnixNano()
  6809  	popr := math_rand.New(math_rand.NewSource(seed))
  6810  	p := NewPopulatedNinRepStruct(popr, true)
  6811  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6812  	msg := &NinRepStruct{}
  6813  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6814  		t.Fatalf("seed = %d, err = %v", seed, err)
  6815  	}
  6816  	if err := p.VerboseEqual(msg); err != nil {
  6817  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6818  	}
  6819  	if !p.Equal(msg) {
  6820  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6821  	}
  6822  }
  6823  
  6824  func TestNidEmbeddedStructProtoText(t *testing.T) {
  6825  	seed := time.Now().UnixNano()
  6826  	popr := math_rand.New(math_rand.NewSource(seed))
  6827  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  6828  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6829  	msg := &NidEmbeddedStruct{}
  6830  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6831  		t.Fatalf("seed = %d, err = %v", seed, err)
  6832  	}
  6833  	if err := p.VerboseEqual(msg); err != nil {
  6834  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6835  	}
  6836  	if !p.Equal(msg) {
  6837  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6838  	}
  6839  }
  6840  
  6841  func TestNidEmbeddedStructProtoCompactText(t *testing.T) {
  6842  	seed := time.Now().UnixNano()
  6843  	popr := math_rand.New(math_rand.NewSource(seed))
  6844  	p := NewPopulatedNidEmbeddedStruct(popr, true)
  6845  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6846  	msg := &NidEmbeddedStruct{}
  6847  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6848  		t.Fatalf("seed = %d, err = %v", seed, err)
  6849  	}
  6850  	if err := p.VerboseEqual(msg); err != nil {
  6851  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6852  	}
  6853  	if !p.Equal(msg) {
  6854  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6855  	}
  6856  }
  6857  
  6858  func TestNinEmbeddedStructProtoText(t *testing.T) {
  6859  	seed := time.Now().UnixNano()
  6860  	popr := math_rand.New(math_rand.NewSource(seed))
  6861  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  6862  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6863  	msg := &NinEmbeddedStruct{}
  6864  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6865  		t.Fatalf("seed = %d, err = %v", seed, err)
  6866  	}
  6867  	if err := p.VerboseEqual(msg); err != nil {
  6868  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6869  	}
  6870  	if !p.Equal(msg) {
  6871  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6872  	}
  6873  }
  6874  
  6875  func TestNinEmbeddedStructProtoCompactText(t *testing.T) {
  6876  	seed := time.Now().UnixNano()
  6877  	popr := math_rand.New(math_rand.NewSource(seed))
  6878  	p := NewPopulatedNinEmbeddedStruct(popr, true)
  6879  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6880  	msg := &NinEmbeddedStruct{}
  6881  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6882  		t.Fatalf("seed = %d, err = %v", seed, err)
  6883  	}
  6884  	if err := p.VerboseEqual(msg); err != nil {
  6885  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6886  	}
  6887  	if !p.Equal(msg) {
  6888  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6889  	}
  6890  }
  6891  
  6892  func TestNidNestedStructProtoText(t *testing.T) {
  6893  	seed := time.Now().UnixNano()
  6894  	popr := math_rand.New(math_rand.NewSource(seed))
  6895  	p := NewPopulatedNidNestedStruct(popr, true)
  6896  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6897  	msg := &NidNestedStruct{}
  6898  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6899  		t.Fatalf("seed = %d, err = %v", seed, err)
  6900  	}
  6901  	if err := p.VerboseEqual(msg); err != nil {
  6902  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6903  	}
  6904  	if !p.Equal(msg) {
  6905  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6906  	}
  6907  }
  6908  
  6909  func TestNidNestedStructProtoCompactText(t *testing.T) {
  6910  	seed := time.Now().UnixNano()
  6911  	popr := math_rand.New(math_rand.NewSource(seed))
  6912  	p := NewPopulatedNidNestedStruct(popr, true)
  6913  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6914  	msg := &NidNestedStruct{}
  6915  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6916  		t.Fatalf("seed = %d, err = %v", seed, err)
  6917  	}
  6918  	if err := p.VerboseEqual(msg); err != nil {
  6919  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6920  	}
  6921  	if !p.Equal(msg) {
  6922  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6923  	}
  6924  }
  6925  
  6926  func TestNinNestedStructProtoText(t *testing.T) {
  6927  	seed := time.Now().UnixNano()
  6928  	popr := math_rand.New(math_rand.NewSource(seed))
  6929  	p := NewPopulatedNinNestedStruct(popr, true)
  6930  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6931  	msg := &NinNestedStruct{}
  6932  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6933  		t.Fatalf("seed = %d, err = %v", seed, err)
  6934  	}
  6935  	if err := p.VerboseEqual(msg); err != nil {
  6936  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6937  	}
  6938  	if !p.Equal(msg) {
  6939  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6940  	}
  6941  }
  6942  
  6943  func TestNinNestedStructProtoCompactText(t *testing.T) {
  6944  	seed := time.Now().UnixNano()
  6945  	popr := math_rand.New(math_rand.NewSource(seed))
  6946  	p := NewPopulatedNinNestedStruct(popr, true)
  6947  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6948  	msg := &NinNestedStruct{}
  6949  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6950  		t.Fatalf("seed = %d, err = %v", seed, err)
  6951  	}
  6952  	if err := p.VerboseEqual(msg); err != nil {
  6953  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6954  	}
  6955  	if !p.Equal(msg) {
  6956  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6957  	}
  6958  }
  6959  
  6960  func TestNidOptCustomProtoText(t *testing.T) {
  6961  	seed := time.Now().UnixNano()
  6962  	popr := math_rand.New(math_rand.NewSource(seed))
  6963  	p := NewPopulatedNidOptCustom(popr, true)
  6964  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6965  	msg := &NidOptCustom{}
  6966  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6967  		t.Fatalf("seed = %d, err = %v", seed, err)
  6968  	}
  6969  	if err := p.VerboseEqual(msg); err != nil {
  6970  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6971  	}
  6972  	if !p.Equal(msg) {
  6973  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6974  	}
  6975  }
  6976  
  6977  func TestNidOptCustomProtoCompactText(t *testing.T) {
  6978  	seed := time.Now().UnixNano()
  6979  	popr := math_rand.New(math_rand.NewSource(seed))
  6980  	p := NewPopulatedNidOptCustom(popr, true)
  6981  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  6982  	msg := &NidOptCustom{}
  6983  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  6984  		t.Fatalf("seed = %d, err = %v", seed, err)
  6985  	}
  6986  	if err := p.VerboseEqual(msg); err != nil {
  6987  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  6988  	}
  6989  	if !p.Equal(msg) {
  6990  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  6991  	}
  6992  }
  6993  
  6994  func TestCustomDashProtoText(t *testing.T) {
  6995  	seed := time.Now().UnixNano()
  6996  	popr := math_rand.New(math_rand.NewSource(seed))
  6997  	p := NewPopulatedCustomDash(popr, true)
  6998  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  6999  	msg := &CustomDash{}
  7000  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7001  		t.Fatalf("seed = %d, err = %v", seed, err)
  7002  	}
  7003  	if err := p.VerboseEqual(msg); err != nil {
  7004  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7005  	}
  7006  	if !p.Equal(msg) {
  7007  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7008  	}
  7009  }
  7010  
  7011  func TestCustomDashProtoCompactText(t *testing.T) {
  7012  	seed := time.Now().UnixNano()
  7013  	popr := math_rand.New(math_rand.NewSource(seed))
  7014  	p := NewPopulatedCustomDash(popr, true)
  7015  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7016  	msg := &CustomDash{}
  7017  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7018  		t.Fatalf("seed = %d, err = %v", seed, err)
  7019  	}
  7020  	if err := p.VerboseEqual(msg); err != nil {
  7021  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7022  	}
  7023  	if !p.Equal(msg) {
  7024  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7025  	}
  7026  }
  7027  
  7028  func TestNinOptCustomProtoText(t *testing.T) {
  7029  	seed := time.Now().UnixNano()
  7030  	popr := math_rand.New(math_rand.NewSource(seed))
  7031  	p := NewPopulatedNinOptCustom(popr, true)
  7032  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7033  	msg := &NinOptCustom{}
  7034  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); 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 !Proto %#v", seed, msg, p)
  7042  	}
  7043  }
  7044  
  7045  func TestNinOptCustomProtoCompactText(t *testing.T) {
  7046  	seed := time.Now().UnixNano()
  7047  	popr := math_rand.New(math_rand.NewSource(seed))
  7048  	p := NewPopulatedNinOptCustom(popr, true)
  7049  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7050  	msg := &NinOptCustom{}
  7051  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7052  		t.Fatalf("seed = %d, err = %v", seed, err)
  7053  	}
  7054  	if err := p.VerboseEqual(msg); err != nil {
  7055  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7056  	}
  7057  	if !p.Equal(msg) {
  7058  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7059  	}
  7060  }
  7061  
  7062  func TestNidRepCustomProtoText(t *testing.T) {
  7063  	seed := time.Now().UnixNano()
  7064  	popr := math_rand.New(math_rand.NewSource(seed))
  7065  	p := NewPopulatedNidRepCustom(popr, true)
  7066  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7067  	msg := &NidRepCustom{}
  7068  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7069  		t.Fatalf("seed = %d, err = %v", seed, err)
  7070  	}
  7071  	if err := p.VerboseEqual(msg); err != nil {
  7072  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7073  	}
  7074  	if !p.Equal(msg) {
  7075  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7076  	}
  7077  }
  7078  
  7079  func TestNidRepCustomProtoCompactText(t *testing.T) {
  7080  	seed := time.Now().UnixNano()
  7081  	popr := math_rand.New(math_rand.NewSource(seed))
  7082  	p := NewPopulatedNidRepCustom(popr, true)
  7083  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7084  	msg := &NidRepCustom{}
  7085  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7086  		t.Fatalf("seed = %d, err = %v", seed, err)
  7087  	}
  7088  	if err := p.VerboseEqual(msg); err != nil {
  7089  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7090  	}
  7091  	if !p.Equal(msg) {
  7092  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7093  	}
  7094  }
  7095  
  7096  func TestNinRepCustomProtoText(t *testing.T) {
  7097  	seed := time.Now().UnixNano()
  7098  	popr := math_rand.New(math_rand.NewSource(seed))
  7099  	p := NewPopulatedNinRepCustom(popr, true)
  7100  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7101  	msg := &NinRepCustom{}
  7102  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7103  		t.Fatalf("seed = %d, err = %v", seed, err)
  7104  	}
  7105  	if err := p.VerboseEqual(msg); err != nil {
  7106  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7107  	}
  7108  	if !p.Equal(msg) {
  7109  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7110  	}
  7111  }
  7112  
  7113  func TestNinRepCustomProtoCompactText(t *testing.T) {
  7114  	seed := time.Now().UnixNano()
  7115  	popr := math_rand.New(math_rand.NewSource(seed))
  7116  	p := NewPopulatedNinRepCustom(popr, true)
  7117  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7118  	msg := &NinRepCustom{}
  7119  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7120  		t.Fatalf("seed = %d, err = %v", seed, err)
  7121  	}
  7122  	if err := p.VerboseEqual(msg); err != nil {
  7123  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7124  	}
  7125  	if !p.Equal(msg) {
  7126  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7127  	}
  7128  }
  7129  
  7130  func TestNinOptNativeUnionProtoText(t *testing.T) {
  7131  	seed := time.Now().UnixNano()
  7132  	popr := math_rand.New(math_rand.NewSource(seed))
  7133  	p := NewPopulatedNinOptNativeUnion(popr, true)
  7134  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7135  	msg := &NinOptNativeUnion{}
  7136  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7137  		t.Fatalf("seed = %d, err = %v", seed, err)
  7138  	}
  7139  	if err := p.VerboseEqual(msg); err != nil {
  7140  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7141  	}
  7142  	if !p.Equal(msg) {
  7143  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7144  	}
  7145  }
  7146  
  7147  func TestNinOptNativeUnionProtoCompactText(t *testing.T) {
  7148  	seed := time.Now().UnixNano()
  7149  	popr := math_rand.New(math_rand.NewSource(seed))
  7150  	p := NewPopulatedNinOptNativeUnion(popr, true)
  7151  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7152  	msg := &NinOptNativeUnion{}
  7153  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7154  		t.Fatalf("seed = %d, err = %v", seed, err)
  7155  	}
  7156  	if err := p.VerboseEqual(msg); err != nil {
  7157  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7158  	}
  7159  	if !p.Equal(msg) {
  7160  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7161  	}
  7162  }
  7163  
  7164  func TestNinOptStructUnionProtoText(t *testing.T) {
  7165  	seed := time.Now().UnixNano()
  7166  	popr := math_rand.New(math_rand.NewSource(seed))
  7167  	p := NewPopulatedNinOptStructUnion(popr, true)
  7168  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7169  	msg := &NinOptStructUnion{}
  7170  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7171  		t.Fatalf("seed = %d, err = %v", seed, err)
  7172  	}
  7173  	if err := p.VerboseEqual(msg); err != nil {
  7174  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7175  	}
  7176  	if !p.Equal(msg) {
  7177  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7178  	}
  7179  }
  7180  
  7181  func TestNinOptStructUnionProtoCompactText(t *testing.T) {
  7182  	seed := time.Now().UnixNano()
  7183  	popr := math_rand.New(math_rand.NewSource(seed))
  7184  	p := NewPopulatedNinOptStructUnion(popr, true)
  7185  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7186  	msg := &NinOptStructUnion{}
  7187  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7188  		t.Fatalf("seed = %d, err = %v", seed, err)
  7189  	}
  7190  	if err := p.VerboseEqual(msg); err != nil {
  7191  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7192  	}
  7193  	if !p.Equal(msg) {
  7194  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7195  	}
  7196  }
  7197  
  7198  func TestNinEmbeddedStructUnionProtoText(t *testing.T) {
  7199  	seed := time.Now().UnixNano()
  7200  	popr := math_rand.New(math_rand.NewSource(seed))
  7201  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  7202  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7203  	msg := &NinEmbeddedStructUnion{}
  7204  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7205  		t.Fatalf("seed = %d, err = %v", seed, err)
  7206  	}
  7207  	if err := p.VerboseEqual(msg); err != nil {
  7208  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7209  	}
  7210  	if !p.Equal(msg) {
  7211  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7212  	}
  7213  }
  7214  
  7215  func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
  7216  	seed := time.Now().UnixNano()
  7217  	popr := math_rand.New(math_rand.NewSource(seed))
  7218  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
  7219  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7220  	msg := &NinEmbeddedStructUnion{}
  7221  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7222  		t.Fatalf("seed = %d, err = %v", seed, err)
  7223  	}
  7224  	if err := p.VerboseEqual(msg); err != nil {
  7225  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7226  	}
  7227  	if !p.Equal(msg) {
  7228  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7229  	}
  7230  }
  7231  
  7232  func TestNinNestedStructUnionProtoText(t *testing.T) {
  7233  	seed := time.Now().UnixNano()
  7234  	popr := math_rand.New(math_rand.NewSource(seed))
  7235  	p := NewPopulatedNinNestedStructUnion(popr, true)
  7236  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7237  	msg := &NinNestedStructUnion{}
  7238  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7239  		t.Fatalf("seed = %d, err = %v", seed, err)
  7240  	}
  7241  	if err := p.VerboseEqual(msg); err != nil {
  7242  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7243  	}
  7244  	if !p.Equal(msg) {
  7245  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7246  	}
  7247  }
  7248  
  7249  func TestNinNestedStructUnionProtoCompactText(t *testing.T) {
  7250  	seed := time.Now().UnixNano()
  7251  	popr := math_rand.New(math_rand.NewSource(seed))
  7252  	p := NewPopulatedNinNestedStructUnion(popr, true)
  7253  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7254  	msg := &NinNestedStructUnion{}
  7255  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7256  		t.Fatalf("seed = %d, err = %v", seed, err)
  7257  	}
  7258  	if err := p.VerboseEqual(msg); err != nil {
  7259  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7260  	}
  7261  	if !p.Equal(msg) {
  7262  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7263  	}
  7264  }
  7265  
  7266  func TestTreeProtoText(t *testing.T) {
  7267  	seed := time.Now().UnixNano()
  7268  	popr := math_rand.New(math_rand.NewSource(seed))
  7269  	p := NewPopulatedTree(popr, true)
  7270  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7271  	msg := &Tree{}
  7272  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7273  		t.Fatalf("seed = %d, err = %v", seed, err)
  7274  	}
  7275  	if err := p.VerboseEqual(msg); err != nil {
  7276  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7277  	}
  7278  	if !p.Equal(msg) {
  7279  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7280  	}
  7281  }
  7282  
  7283  func TestTreeProtoCompactText(t *testing.T) {
  7284  	seed := time.Now().UnixNano()
  7285  	popr := math_rand.New(math_rand.NewSource(seed))
  7286  	p := NewPopulatedTree(popr, true)
  7287  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7288  	msg := &Tree{}
  7289  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7290  		t.Fatalf("seed = %d, err = %v", seed, err)
  7291  	}
  7292  	if err := p.VerboseEqual(msg); err != nil {
  7293  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7294  	}
  7295  	if !p.Equal(msg) {
  7296  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7297  	}
  7298  }
  7299  
  7300  func TestOrBranchProtoText(t *testing.T) {
  7301  	seed := time.Now().UnixNano()
  7302  	popr := math_rand.New(math_rand.NewSource(seed))
  7303  	p := NewPopulatedOrBranch(popr, true)
  7304  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7305  	msg := &OrBranch{}
  7306  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7307  		t.Fatalf("seed = %d, err = %v", seed, err)
  7308  	}
  7309  	if err := p.VerboseEqual(msg); err != nil {
  7310  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7311  	}
  7312  	if !p.Equal(msg) {
  7313  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7314  	}
  7315  }
  7316  
  7317  func TestOrBranchProtoCompactText(t *testing.T) {
  7318  	seed := time.Now().UnixNano()
  7319  	popr := math_rand.New(math_rand.NewSource(seed))
  7320  	p := NewPopulatedOrBranch(popr, true)
  7321  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7322  	msg := &OrBranch{}
  7323  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7324  		t.Fatalf("seed = %d, err = %v", seed, err)
  7325  	}
  7326  	if err := p.VerboseEqual(msg); err != nil {
  7327  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7328  	}
  7329  	if !p.Equal(msg) {
  7330  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7331  	}
  7332  }
  7333  
  7334  func TestAndBranchProtoText(t *testing.T) {
  7335  	seed := time.Now().UnixNano()
  7336  	popr := math_rand.New(math_rand.NewSource(seed))
  7337  	p := NewPopulatedAndBranch(popr, true)
  7338  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7339  	msg := &AndBranch{}
  7340  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7341  		t.Fatalf("seed = %d, err = %v", seed, err)
  7342  	}
  7343  	if err := p.VerboseEqual(msg); err != nil {
  7344  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7345  	}
  7346  	if !p.Equal(msg) {
  7347  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7348  	}
  7349  }
  7350  
  7351  func TestAndBranchProtoCompactText(t *testing.T) {
  7352  	seed := time.Now().UnixNano()
  7353  	popr := math_rand.New(math_rand.NewSource(seed))
  7354  	p := NewPopulatedAndBranch(popr, true)
  7355  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7356  	msg := &AndBranch{}
  7357  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7358  		t.Fatalf("seed = %d, err = %v", seed, err)
  7359  	}
  7360  	if err := p.VerboseEqual(msg); err != nil {
  7361  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7362  	}
  7363  	if !p.Equal(msg) {
  7364  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7365  	}
  7366  }
  7367  
  7368  func TestLeafProtoText(t *testing.T) {
  7369  	seed := time.Now().UnixNano()
  7370  	popr := math_rand.New(math_rand.NewSource(seed))
  7371  	p := NewPopulatedLeaf(popr, true)
  7372  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7373  	msg := &Leaf{}
  7374  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7375  		t.Fatalf("seed = %d, err = %v", seed, err)
  7376  	}
  7377  	if err := p.VerboseEqual(msg); err != nil {
  7378  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7379  	}
  7380  	if !p.Equal(msg) {
  7381  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7382  	}
  7383  }
  7384  
  7385  func TestLeafProtoCompactText(t *testing.T) {
  7386  	seed := time.Now().UnixNano()
  7387  	popr := math_rand.New(math_rand.NewSource(seed))
  7388  	p := NewPopulatedLeaf(popr, true)
  7389  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7390  	msg := &Leaf{}
  7391  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); 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 !Proto %#v", seed, msg, p)
  7399  	}
  7400  }
  7401  
  7402  func TestDeepTreeProtoText(t *testing.T) {
  7403  	seed := time.Now().UnixNano()
  7404  	popr := math_rand.New(math_rand.NewSource(seed))
  7405  	p := NewPopulatedDeepTree(popr, true)
  7406  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7407  	msg := &DeepTree{}
  7408  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7409  		t.Fatalf("seed = %d, err = %v", seed, err)
  7410  	}
  7411  	if err := p.VerboseEqual(msg); err != nil {
  7412  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7413  	}
  7414  	if !p.Equal(msg) {
  7415  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7416  	}
  7417  }
  7418  
  7419  func TestDeepTreeProtoCompactText(t *testing.T) {
  7420  	seed := time.Now().UnixNano()
  7421  	popr := math_rand.New(math_rand.NewSource(seed))
  7422  	p := NewPopulatedDeepTree(popr, true)
  7423  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7424  	msg := &DeepTree{}
  7425  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7426  		t.Fatalf("seed = %d, err = %v", seed, err)
  7427  	}
  7428  	if err := p.VerboseEqual(msg); err != nil {
  7429  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7430  	}
  7431  	if !p.Equal(msg) {
  7432  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7433  	}
  7434  }
  7435  
  7436  func TestADeepBranchProtoText(t *testing.T) {
  7437  	seed := time.Now().UnixNano()
  7438  	popr := math_rand.New(math_rand.NewSource(seed))
  7439  	p := NewPopulatedADeepBranch(popr, true)
  7440  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7441  	msg := &ADeepBranch{}
  7442  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7443  		t.Fatalf("seed = %d, err = %v", seed, err)
  7444  	}
  7445  	if err := p.VerboseEqual(msg); err != nil {
  7446  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7447  	}
  7448  	if !p.Equal(msg) {
  7449  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7450  	}
  7451  }
  7452  
  7453  func TestADeepBranchProtoCompactText(t *testing.T) {
  7454  	seed := time.Now().UnixNano()
  7455  	popr := math_rand.New(math_rand.NewSource(seed))
  7456  	p := NewPopulatedADeepBranch(popr, true)
  7457  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7458  	msg := &ADeepBranch{}
  7459  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7460  		t.Fatalf("seed = %d, err = %v", seed, err)
  7461  	}
  7462  	if err := p.VerboseEqual(msg); err != nil {
  7463  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7464  	}
  7465  	if !p.Equal(msg) {
  7466  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7467  	}
  7468  }
  7469  
  7470  func TestAndDeepBranchProtoText(t *testing.T) {
  7471  	seed := time.Now().UnixNano()
  7472  	popr := math_rand.New(math_rand.NewSource(seed))
  7473  	p := NewPopulatedAndDeepBranch(popr, true)
  7474  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7475  	msg := &AndDeepBranch{}
  7476  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7477  		t.Fatalf("seed = %d, err = %v", seed, err)
  7478  	}
  7479  	if err := p.VerboseEqual(msg); err != nil {
  7480  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7481  	}
  7482  	if !p.Equal(msg) {
  7483  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7484  	}
  7485  }
  7486  
  7487  func TestAndDeepBranchProtoCompactText(t *testing.T) {
  7488  	seed := time.Now().UnixNano()
  7489  	popr := math_rand.New(math_rand.NewSource(seed))
  7490  	p := NewPopulatedAndDeepBranch(popr, true)
  7491  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7492  	msg := &AndDeepBranch{}
  7493  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7494  		t.Fatalf("seed = %d, err = %v", seed, err)
  7495  	}
  7496  	if err := p.VerboseEqual(msg); err != nil {
  7497  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7498  	}
  7499  	if !p.Equal(msg) {
  7500  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7501  	}
  7502  }
  7503  
  7504  func TestDeepLeafProtoText(t *testing.T) {
  7505  	seed := time.Now().UnixNano()
  7506  	popr := math_rand.New(math_rand.NewSource(seed))
  7507  	p := NewPopulatedDeepLeaf(popr, true)
  7508  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7509  	msg := &DeepLeaf{}
  7510  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7511  		t.Fatalf("seed = %d, err = %v", seed, err)
  7512  	}
  7513  	if err := p.VerboseEqual(msg); err != nil {
  7514  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7515  	}
  7516  	if !p.Equal(msg) {
  7517  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7518  	}
  7519  }
  7520  
  7521  func TestDeepLeafProtoCompactText(t *testing.T) {
  7522  	seed := time.Now().UnixNano()
  7523  	popr := math_rand.New(math_rand.NewSource(seed))
  7524  	p := NewPopulatedDeepLeaf(popr, true)
  7525  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7526  	msg := &DeepLeaf{}
  7527  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7528  		t.Fatalf("seed = %d, err = %v", seed, err)
  7529  	}
  7530  	if err := p.VerboseEqual(msg); err != nil {
  7531  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7532  	}
  7533  	if !p.Equal(msg) {
  7534  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7535  	}
  7536  }
  7537  
  7538  func TestNilProtoText(t *testing.T) {
  7539  	seed := time.Now().UnixNano()
  7540  	popr := math_rand.New(math_rand.NewSource(seed))
  7541  	p := NewPopulatedNil(popr, true)
  7542  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7543  	msg := &Nil{}
  7544  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7545  		t.Fatalf("seed = %d, err = %v", seed, err)
  7546  	}
  7547  	if err := p.VerboseEqual(msg); err != nil {
  7548  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7549  	}
  7550  	if !p.Equal(msg) {
  7551  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7552  	}
  7553  }
  7554  
  7555  func TestNilProtoCompactText(t *testing.T) {
  7556  	seed := time.Now().UnixNano()
  7557  	popr := math_rand.New(math_rand.NewSource(seed))
  7558  	p := NewPopulatedNil(popr, true)
  7559  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7560  	msg := &Nil{}
  7561  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7562  		t.Fatalf("seed = %d, err = %v", seed, err)
  7563  	}
  7564  	if err := p.VerboseEqual(msg); err != nil {
  7565  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7566  	}
  7567  	if !p.Equal(msg) {
  7568  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7569  	}
  7570  }
  7571  
  7572  func TestNidOptEnumProtoText(t *testing.T) {
  7573  	seed := time.Now().UnixNano()
  7574  	popr := math_rand.New(math_rand.NewSource(seed))
  7575  	p := NewPopulatedNidOptEnum(popr, true)
  7576  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7577  	msg := &NidOptEnum{}
  7578  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7579  		t.Fatalf("seed = %d, err = %v", seed, err)
  7580  	}
  7581  	if err := p.VerboseEqual(msg); err != nil {
  7582  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7583  	}
  7584  	if !p.Equal(msg) {
  7585  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7586  	}
  7587  }
  7588  
  7589  func TestNidOptEnumProtoCompactText(t *testing.T) {
  7590  	seed := time.Now().UnixNano()
  7591  	popr := math_rand.New(math_rand.NewSource(seed))
  7592  	p := NewPopulatedNidOptEnum(popr, true)
  7593  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7594  	msg := &NidOptEnum{}
  7595  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7596  		t.Fatalf("seed = %d, err = %v", seed, err)
  7597  	}
  7598  	if err := p.VerboseEqual(msg); err != nil {
  7599  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7600  	}
  7601  	if !p.Equal(msg) {
  7602  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7603  	}
  7604  }
  7605  
  7606  func TestNinOptEnumProtoText(t *testing.T) {
  7607  	seed := time.Now().UnixNano()
  7608  	popr := math_rand.New(math_rand.NewSource(seed))
  7609  	p := NewPopulatedNinOptEnum(popr, true)
  7610  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7611  	msg := &NinOptEnum{}
  7612  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7613  		t.Fatalf("seed = %d, err = %v", seed, err)
  7614  	}
  7615  	if err := p.VerboseEqual(msg); err != nil {
  7616  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7617  	}
  7618  	if !p.Equal(msg) {
  7619  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7620  	}
  7621  }
  7622  
  7623  func TestNinOptEnumProtoCompactText(t *testing.T) {
  7624  	seed := time.Now().UnixNano()
  7625  	popr := math_rand.New(math_rand.NewSource(seed))
  7626  	p := NewPopulatedNinOptEnum(popr, true)
  7627  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7628  	msg := &NinOptEnum{}
  7629  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7630  		t.Fatalf("seed = %d, err = %v", seed, err)
  7631  	}
  7632  	if err := p.VerboseEqual(msg); err != nil {
  7633  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7634  	}
  7635  	if !p.Equal(msg) {
  7636  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7637  	}
  7638  }
  7639  
  7640  func TestNidRepEnumProtoText(t *testing.T) {
  7641  	seed := time.Now().UnixNano()
  7642  	popr := math_rand.New(math_rand.NewSource(seed))
  7643  	p := NewPopulatedNidRepEnum(popr, true)
  7644  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7645  	msg := &NidRepEnum{}
  7646  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7647  		t.Fatalf("seed = %d, err = %v", seed, err)
  7648  	}
  7649  	if err := p.VerboseEqual(msg); err != nil {
  7650  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7651  	}
  7652  	if !p.Equal(msg) {
  7653  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7654  	}
  7655  }
  7656  
  7657  func TestNidRepEnumProtoCompactText(t *testing.T) {
  7658  	seed := time.Now().UnixNano()
  7659  	popr := math_rand.New(math_rand.NewSource(seed))
  7660  	p := NewPopulatedNidRepEnum(popr, true)
  7661  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7662  	msg := &NidRepEnum{}
  7663  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7664  		t.Fatalf("seed = %d, err = %v", seed, err)
  7665  	}
  7666  	if err := p.VerboseEqual(msg); err != nil {
  7667  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7668  	}
  7669  	if !p.Equal(msg) {
  7670  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7671  	}
  7672  }
  7673  
  7674  func TestNinRepEnumProtoText(t *testing.T) {
  7675  	seed := time.Now().UnixNano()
  7676  	popr := math_rand.New(math_rand.NewSource(seed))
  7677  	p := NewPopulatedNinRepEnum(popr, true)
  7678  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7679  	msg := &NinRepEnum{}
  7680  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7681  		t.Fatalf("seed = %d, err = %v", seed, err)
  7682  	}
  7683  	if err := p.VerboseEqual(msg); err != nil {
  7684  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7685  	}
  7686  	if !p.Equal(msg) {
  7687  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7688  	}
  7689  }
  7690  
  7691  func TestNinRepEnumProtoCompactText(t *testing.T) {
  7692  	seed := time.Now().UnixNano()
  7693  	popr := math_rand.New(math_rand.NewSource(seed))
  7694  	p := NewPopulatedNinRepEnum(popr, true)
  7695  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7696  	msg := &NinRepEnum{}
  7697  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7698  		t.Fatalf("seed = %d, err = %v", seed, err)
  7699  	}
  7700  	if err := p.VerboseEqual(msg); err != nil {
  7701  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7702  	}
  7703  	if !p.Equal(msg) {
  7704  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7705  	}
  7706  }
  7707  
  7708  func TestNinOptEnumDefaultProtoText(t *testing.T) {
  7709  	seed := time.Now().UnixNano()
  7710  	popr := math_rand.New(math_rand.NewSource(seed))
  7711  	p := NewPopulatedNinOptEnumDefault(popr, true)
  7712  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7713  	msg := &NinOptEnumDefault{}
  7714  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7715  		t.Fatalf("seed = %d, err = %v", seed, err)
  7716  	}
  7717  	if err := p.VerboseEqual(msg); err != nil {
  7718  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7719  	}
  7720  	if !p.Equal(msg) {
  7721  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7722  	}
  7723  }
  7724  
  7725  func TestNinOptEnumDefaultProtoCompactText(t *testing.T) {
  7726  	seed := time.Now().UnixNano()
  7727  	popr := math_rand.New(math_rand.NewSource(seed))
  7728  	p := NewPopulatedNinOptEnumDefault(popr, true)
  7729  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7730  	msg := &NinOptEnumDefault{}
  7731  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7732  		t.Fatalf("seed = %d, err = %v", seed, err)
  7733  	}
  7734  	if err := p.VerboseEqual(msg); err != nil {
  7735  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7736  	}
  7737  	if !p.Equal(msg) {
  7738  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7739  	}
  7740  }
  7741  
  7742  func TestAnotherNinOptEnumProtoText(t *testing.T) {
  7743  	seed := time.Now().UnixNano()
  7744  	popr := math_rand.New(math_rand.NewSource(seed))
  7745  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  7746  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7747  	msg := &AnotherNinOptEnum{}
  7748  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); 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 !Proto %#v", seed, msg, p)
  7756  	}
  7757  }
  7758  
  7759  func TestAnotherNinOptEnumProtoCompactText(t *testing.T) {
  7760  	seed := time.Now().UnixNano()
  7761  	popr := math_rand.New(math_rand.NewSource(seed))
  7762  	p := NewPopulatedAnotherNinOptEnum(popr, true)
  7763  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7764  	msg := &AnotherNinOptEnum{}
  7765  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7766  		t.Fatalf("seed = %d, err = %v", seed, err)
  7767  	}
  7768  	if err := p.VerboseEqual(msg); err != nil {
  7769  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7770  	}
  7771  	if !p.Equal(msg) {
  7772  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7773  	}
  7774  }
  7775  
  7776  func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) {
  7777  	seed := time.Now().UnixNano()
  7778  	popr := math_rand.New(math_rand.NewSource(seed))
  7779  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  7780  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7781  	msg := &AnotherNinOptEnumDefault{}
  7782  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7783  		t.Fatalf("seed = %d, err = %v", seed, err)
  7784  	}
  7785  	if err := p.VerboseEqual(msg); err != nil {
  7786  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7787  	}
  7788  	if !p.Equal(msg) {
  7789  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7790  	}
  7791  }
  7792  
  7793  func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) {
  7794  	seed := time.Now().UnixNano()
  7795  	popr := math_rand.New(math_rand.NewSource(seed))
  7796  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
  7797  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7798  	msg := &AnotherNinOptEnumDefault{}
  7799  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7800  		t.Fatalf("seed = %d, err = %v", seed, err)
  7801  	}
  7802  	if err := p.VerboseEqual(msg); err != nil {
  7803  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7804  	}
  7805  	if !p.Equal(msg) {
  7806  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7807  	}
  7808  }
  7809  
  7810  func TestTimerProtoText(t *testing.T) {
  7811  	seed := time.Now().UnixNano()
  7812  	popr := math_rand.New(math_rand.NewSource(seed))
  7813  	p := NewPopulatedTimer(popr, true)
  7814  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7815  	msg := &Timer{}
  7816  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7817  		t.Fatalf("seed = %d, err = %v", seed, err)
  7818  	}
  7819  	if err := p.VerboseEqual(msg); err != nil {
  7820  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7821  	}
  7822  	if !p.Equal(msg) {
  7823  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7824  	}
  7825  }
  7826  
  7827  func TestTimerProtoCompactText(t *testing.T) {
  7828  	seed := time.Now().UnixNano()
  7829  	popr := math_rand.New(math_rand.NewSource(seed))
  7830  	p := NewPopulatedTimer(popr, true)
  7831  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7832  	msg := &Timer{}
  7833  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7834  		t.Fatalf("seed = %d, err = %v", seed, err)
  7835  	}
  7836  	if err := p.VerboseEqual(msg); err != nil {
  7837  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7838  	}
  7839  	if !p.Equal(msg) {
  7840  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7841  	}
  7842  }
  7843  
  7844  func TestMyExtendableProtoText(t *testing.T) {
  7845  	seed := time.Now().UnixNano()
  7846  	popr := math_rand.New(math_rand.NewSource(seed))
  7847  	p := NewPopulatedMyExtendable(popr, true)
  7848  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7849  	msg := &MyExtendable{}
  7850  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7851  		t.Fatalf("seed = %d, err = %v", seed, err)
  7852  	}
  7853  	if err := p.VerboseEqual(msg); err != nil {
  7854  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7855  	}
  7856  	if !p.Equal(msg) {
  7857  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7858  	}
  7859  }
  7860  
  7861  func TestMyExtendableProtoCompactText(t *testing.T) {
  7862  	seed := time.Now().UnixNano()
  7863  	popr := math_rand.New(math_rand.NewSource(seed))
  7864  	p := NewPopulatedMyExtendable(popr, true)
  7865  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7866  	msg := &MyExtendable{}
  7867  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7868  		t.Fatalf("seed = %d, err = %v", seed, err)
  7869  	}
  7870  	if err := p.VerboseEqual(msg); err != nil {
  7871  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7872  	}
  7873  	if !p.Equal(msg) {
  7874  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7875  	}
  7876  }
  7877  
  7878  func TestOtherExtenableProtoText(t *testing.T) {
  7879  	seed := time.Now().UnixNano()
  7880  	popr := math_rand.New(math_rand.NewSource(seed))
  7881  	p := NewPopulatedOtherExtenable(popr, true)
  7882  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7883  	msg := &OtherExtenable{}
  7884  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7885  		t.Fatalf("seed = %d, err = %v", seed, err)
  7886  	}
  7887  	if err := p.VerboseEqual(msg); err != nil {
  7888  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7889  	}
  7890  	if !p.Equal(msg) {
  7891  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7892  	}
  7893  }
  7894  
  7895  func TestOtherExtenableProtoCompactText(t *testing.T) {
  7896  	seed := time.Now().UnixNano()
  7897  	popr := math_rand.New(math_rand.NewSource(seed))
  7898  	p := NewPopulatedOtherExtenable(popr, true)
  7899  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7900  	msg := &OtherExtenable{}
  7901  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7902  		t.Fatalf("seed = %d, err = %v", seed, err)
  7903  	}
  7904  	if err := p.VerboseEqual(msg); err != nil {
  7905  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7906  	}
  7907  	if !p.Equal(msg) {
  7908  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7909  	}
  7910  }
  7911  
  7912  func TestNestedDefinitionProtoText(t *testing.T) {
  7913  	seed := time.Now().UnixNano()
  7914  	popr := math_rand.New(math_rand.NewSource(seed))
  7915  	p := NewPopulatedNestedDefinition(popr, true)
  7916  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7917  	msg := &NestedDefinition{}
  7918  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7919  		t.Fatalf("seed = %d, err = %v", seed, err)
  7920  	}
  7921  	if err := p.VerboseEqual(msg); err != nil {
  7922  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7923  	}
  7924  	if !p.Equal(msg) {
  7925  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7926  	}
  7927  }
  7928  
  7929  func TestNestedDefinitionProtoCompactText(t *testing.T) {
  7930  	seed := time.Now().UnixNano()
  7931  	popr := math_rand.New(math_rand.NewSource(seed))
  7932  	p := NewPopulatedNestedDefinition(popr, true)
  7933  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7934  	msg := &NestedDefinition{}
  7935  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7936  		t.Fatalf("seed = %d, err = %v", seed, err)
  7937  	}
  7938  	if err := p.VerboseEqual(msg); err != nil {
  7939  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7940  	}
  7941  	if !p.Equal(msg) {
  7942  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7943  	}
  7944  }
  7945  
  7946  func TestNestedDefinition_NestedMessageProtoText(t *testing.T) {
  7947  	seed := time.Now().UnixNano()
  7948  	popr := math_rand.New(math_rand.NewSource(seed))
  7949  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  7950  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7951  	msg := &NestedDefinition_NestedMessage{}
  7952  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7953  		t.Fatalf("seed = %d, err = %v", seed, err)
  7954  	}
  7955  	if err := p.VerboseEqual(msg); err != nil {
  7956  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7957  	}
  7958  	if !p.Equal(msg) {
  7959  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7960  	}
  7961  }
  7962  
  7963  func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) {
  7964  	seed := time.Now().UnixNano()
  7965  	popr := math_rand.New(math_rand.NewSource(seed))
  7966  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
  7967  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  7968  	msg := &NestedDefinition_NestedMessage{}
  7969  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7970  		t.Fatalf("seed = %d, err = %v", seed, err)
  7971  	}
  7972  	if err := p.VerboseEqual(msg); err != nil {
  7973  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7974  	}
  7975  	if !p.Equal(msg) {
  7976  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7977  	}
  7978  }
  7979  
  7980  func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) {
  7981  	seed := time.Now().UnixNano()
  7982  	popr := math_rand.New(math_rand.NewSource(seed))
  7983  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  7984  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  7985  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  7986  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  7987  		t.Fatalf("seed = %d, err = %v", seed, err)
  7988  	}
  7989  	if err := p.VerboseEqual(msg); err != nil {
  7990  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  7991  	}
  7992  	if !p.Equal(msg) {
  7993  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  7994  	}
  7995  }
  7996  
  7997  func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) {
  7998  	seed := time.Now().UnixNano()
  7999  	popr := math_rand.New(math_rand.NewSource(seed))
  8000  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
  8001  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8002  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  8003  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8004  		t.Fatalf("seed = %d, err = %v", seed, err)
  8005  	}
  8006  	if err := p.VerboseEqual(msg); err != nil {
  8007  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8008  	}
  8009  	if !p.Equal(msg) {
  8010  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8011  	}
  8012  }
  8013  
  8014  func TestNestedScopeProtoText(t *testing.T) {
  8015  	seed := time.Now().UnixNano()
  8016  	popr := math_rand.New(math_rand.NewSource(seed))
  8017  	p := NewPopulatedNestedScope(popr, true)
  8018  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8019  	msg := &NestedScope{}
  8020  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8021  		t.Fatalf("seed = %d, err = %v", seed, err)
  8022  	}
  8023  	if err := p.VerboseEqual(msg); err != nil {
  8024  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8025  	}
  8026  	if !p.Equal(msg) {
  8027  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8028  	}
  8029  }
  8030  
  8031  func TestNestedScopeProtoCompactText(t *testing.T) {
  8032  	seed := time.Now().UnixNano()
  8033  	popr := math_rand.New(math_rand.NewSource(seed))
  8034  	p := NewPopulatedNestedScope(popr, true)
  8035  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8036  	msg := &NestedScope{}
  8037  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8038  		t.Fatalf("seed = %d, err = %v", seed, err)
  8039  	}
  8040  	if err := p.VerboseEqual(msg); err != nil {
  8041  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8042  	}
  8043  	if !p.Equal(msg) {
  8044  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8045  	}
  8046  }
  8047  
  8048  func TestNinOptNativeDefaultProtoText(t *testing.T) {
  8049  	seed := time.Now().UnixNano()
  8050  	popr := math_rand.New(math_rand.NewSource(seed))
  8051  	p := NewPopulatedNinOptNativeDefault(popr, true)
  8052  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8053  	msg := &NinOptNativeDefault{}
  8054  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8055  		t.Fatalf("seed = %d, err = %v", seed, err)
  8056  	}
  8057  	if err := p.VerboseEqual(msg); err != nil {
  8058  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8059  	}
  8060  	if !p.Equal(msg) {
  8061  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8062  	}
  8063  }
  8064  
  8065  func TestNinOptNativeDefaultProtoCompactText(t *testing.T) {
  8066  	seed := time.Now().UnixNano()
  8067  	popr := math_rand.New(math_rand.NewSource(seed))
  8068  	p := NewPopulatedNinOptNativeDefault(popr, true)
  8069  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8070  	msg := &NinOptNativeDefault{}
  8071  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8072  		t.Fatalf("seed = %d, err = %v", seed, err)
  8073  	}
  8074  	if err := p.VerboseEqual(msg); err != nil {
  8075  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8076  	}
  8077  	if !p.Equal(msg) {
  8078  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8079  	}
  8080  }
  8081  
  8082  func TestCustomContainerProtoText(t *testing.T) {
  8083  	seed := time.Now().UnixNano()
  8084  	popr := math_rand.New(math_rand.NewSource(seed))
  8085  	p := NewPopulatedCustomContainer(popr, true)
  8086  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8087  	msg := &CustomContainer{}
  8088  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8089  		t.Fatalf("seed = %d, err = %v", seed, err)
  8090  	}
  8091  	if err := p.VerboseEqual(msg); err != nil {
  8092  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8093  	}
  8094  	if !p.Equal(msg) {
  8095  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8096  	}
  8097  }
  8098  
  8099  func TestCustomContainerProtoCompactText(t *testing.T) {
  8100  	seed := time.Now().UnixNano()
  8101  	popr := math_rand.New(math_rand.NewSource(seed))
  8102  	p := NewPopulatedCustomContainer(popr, true)
  8103  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8104  	msg := &CustomContainer{}
  8105  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); 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 !Proto %#v", seed, msg, p)
  8113  	}
  8114  }
  8115  
  8116  func TestCustomNameNidOptNativeProtoText(t *testing.T) {
  8117  	seed := time.Now().UnixNano()
  8118  	popr := math_rand.New(math_rand.NewSource(seed))
  8119  	p := NewPopulatedCustomNameNidOptNative(popr, true)
  8120  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8121  	msg := &CustomNameNidOptNative{}
  8122  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8123  		t.Fatalf("seed = %d, err = %v", seed, err)
  8124  	}
  8125  	if err := p.VerboseEqual(msg); err != nil {
  8126  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8127  	}
  8128  	if !p.Equal(msg) {
  8129  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8130  	}
  8131  }
  8132  
  8133  func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) {
  8134  	seed := time.Now().UnixNano()
  8135  	popr := math_rand.New(math_rand.NewSource(seed))
  8136  	p := NewPopulatedCustomNameNidOptNative(popr, true)
  8137  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8138  	msg := &CustomNameNidOptNative{}
  8139  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8140  		t.Fatalf("seed = %d, err = %v", seed, err)
  8141  	}
  8142  	if err := p.VerboseEqual(msg); err != nil {
  8143  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8144  	}
  8145  	if !p.Equal(msg) {
  8146  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8147  	}
  8148  }
  8149  
  8150  func TestCustomNameNinOptNativeProtoText(t *testing.T) {
  8151  	seed := time.Now().UnixNano()
  8152  	popr := math_rand.New(math_rand.NewSource(seed))
  8153  	p := NewPopulatedCustomNameNinOptNative(popr, true)
  8154  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8155  	msg := &CustomNameNinOptNative{}
  8156  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8157  		t.Fatalf("seed = %d, err = %v", seed, err)
  8158  	}
  8159  	if err := p.VerboseEqual(msg); err != nil {
  8160  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8161  	}
  8162  	if !p.Equal(msg) {
  8163  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8164  	}
  8165  }
  8166  
  8167  func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) {
  8168  	seed := time.Now().UnixNano()
  8169  	popr := math_rand.New(math_rand.NewSource(seed))
  8170  	p := NewPopulatedCustomNameNinOptNative(popr, true)
  8171  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8172  	msg := &CustomNameNinOptNative{}
  8173  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8174  		t.Fatalf("seed = %d, err = %v", seed, err)
  8175  	}
  8176  	if err := p.VerboseEqual(msg); err != nil {
  8177  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8178  	}
  8179  	if !p.Equal(msg) {
  8180  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8181  	}
  8182  }
  8183  
  8184  func TestCustomNameNinRepNativeProtoText(t *testing.T) {
  8185  	seed := time.Now().UnixNano()
  8186  	popr := math_rand.New(math_rand.NewSource(seed))
  8187  	p := NewPopulatedCustomNameNinRepNative(popr, true)
  8188  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8189  	msg := &CustomNameNinRepNative{}
  8190  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8191  		t.Fatalf("seed = %d, err = %v", seed, err)
  8192  	}
  8193  	if err := p.VerboseEqual(msg); err != nil {
  8194  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8195  	}
  8196  	if !p.Equal(msg) {
  8197  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8198  	}
  8199  }
  8200  
  8201  func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) {
  8202  	seed := time.Now().UnixNano()
  8203  	popr := math_rand.New(math_rand.NewSource(seed))
  8204  	p := NewPopulatedCustomNameNinRepNative(popr, true)
  8205  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8206  	msg := &CustomNameNinRepNative{}
  8207  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8208  		t.Fatalf("seed = %d, err = %v", seed, err)
  8209  	}
  8210  	if err := p.VerboseEqual(msg); err != nil {
  8211  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8212  	}
  8213  	if !p.Equal(msg) {
  8214  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8215  	}
  8216  }
  8217  
  8218  func TestCustomNameNinStructProtoText(t *testing.T) {
  8219  	seed := time.Now().UnixNano()
  8220  	popr := math_rand.New(math_rand.NewSource(seed))
  8221  	p := NewPopulatedCustomNameNinStruct(popr, true)
  8222  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8223  	msg := &CustomNameNinStruct{}
  8224  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8225  		t.Fatalf("seed = %d, err = %v", seed, err)
  8226  	}
  8227  	if err := p.VerboseEqual(msg); err != nil {
  8228  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8229  	}
  8230  	if !p.Equal(msg) {
  8231  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8232  	}
  8233  }
  8234  
  8235  func TestCustomNameNinStructProtoCompactText(t *testing.T) {
  8236  	seed := time.Now().UnixNano()
  8237  	popr := math_rand.New(math_rand.NewSource(seed))
  8238  	p := NewPopulatedCustomNameNinStruct(popr, true)
  8239  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8240  	msg := &CustomNameNinStruct{}
  8241  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8242  		t.Fatalf("seed = %d, err = %v", seed, err)
  8243  	}
  8244  	if err := p.VerboseEqual(msg); err != nil {
  8245  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8246  	}
  8247  	if !p.Equal(msg) {
  8248  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8249  	}
  8250  }
  8251  
  8252  func TestCustomNameCustomTypeProtoText(t *testing.T) {
  8253  	seed := time.Now().UnixNano()
  8254  	popr := math_rand.New(math_rand.NewSource(seed))
  8255  	p := NewPopulatedCustomNameCustomType(popr, true)
  8256  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8257  	msg := &CustomNameCustomType{}
  8258  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8259  		t.Fatalf("seed = %d, err = %v", seed, err)
  8260  	}
  8261  	if err := p.VerboseEqual(msg); err != nil {
  8262  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8263  	}
  8264  	if !p.Equal(msg) {
  8265  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8266  	}
  8267  }
  8268  
  8269  func TestCustomNameCustomTypeProtoCompactText(t *testing.T) {
  8270  	seed := time.Now().UnixNano()
  8271  	popr := math_rand.New(math_rand.NewSource(seed))
  8272  	p := NewPopulatedCustomNameCustomType(popr, true)
  8273  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8274  	msg := &CustomNameCustomType{}
  8275  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8276  		t.Fatalf("seed = %d, err = %v", seed, err)
  8277  	}
  8278  	if err := p.VerboseEqual(msg); err != nil {
  8279  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8280  	}
  8281  	if !p.Equal(msg) {
  8282  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8283  	}
  8284  }
  8285  
  8286  func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) {
  8287  	seed := time.Now().UnixNano()
  8288  	popr := math_rand.New(math_rand.NewSource(seed))
  8289  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
  8290  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8291  	msg := &CustomNameNinEmbeddedStructUnion{}
  8292  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8293  		t.Fatalf("seed = %d, err = %v", seed, err)
  8294  	}
  8295  	if err := p.VerboseEqual(msg); err != nil {
  8296  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8297  	}
  8298  	if !p.Equal(msg) {
  8299  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8300  	}
  8301  }
  8302  
  8303  func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) {
  8304  	seed := time.Now().UnixNano()
  8305  	popr := math_rand.New(math_rand.NewSource(seed))
  8306  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
  8307  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8308  	msg := &CustomNameNinEmbeddedStructUnion{}
  8309  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8310  		t.Fatalf("seed = %d, err = %v", seed, err)
  8311  	}
  8312  	if err := p.VerboseEqual(msg); err != nil {
  8313  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8314  	}
  8315  	if !p.Equal(msg) {
  8316  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8317  	}
  8318  }
  8319  
  8320  func TestCustomNameEnumProtoText(t *testing.T) {
  8321  	seed := time.Now().UnixNano()
  8322  	popr := math_rand.New(math_rand.NewSource(seed))
  8323  	p := NewPopulatedCustomNameEnum(popr, true)
  8324  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8325  	msg := &CustomNameEnum{}
  8326  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8327  		t.Fatalf("seed = %d, err = %v", seed, err)
  8328  	}
  8329  	if err := p.VerboseEqual(msg); err != nil {
  8330  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8331  	}
  8332  	if !p.Equal(msg) {
  8333  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8334  	}
  8335  }
  8336  
  8337  func TestCustomNameEnumProtoCompactText(t *testing.T) {
  8338  	seed := time.Now().UnixNano()
  8339  	popr := math_rand.New(math_rand.NewSource(seed))
  8340  	p := NewPopulatedCustomNameEnum(popr, true)
  8341  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8342  	msg := &CustomNameEnum{}
  8343  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8344  		t.Fatalf("seed = %d, err = %v", seed, err)
  8345  	}
  8346  	if err := p.VerboseEqual(msg); err != nil {
  8347  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8348  	}
  8349  	if !p.Equal(msg) {
  8350  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8351  	}
  8352  }
  8353  
  8354  func TestNoExtensionsMapProtoText(t *testing.T) {
  8355  	seed := time.Now().UnixNano()
  8356  	popr := math_rand.New(math_rand.NewSource(seed))
  8357  	p := NewPopulatedNoExtensionsMap(popr, true)
  8358  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8359  	msg := &NoExtensionsMap{}
  8360  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8361  		t.Fatalf("seed = %d, err = %v", seed, err)
  8362  	}
  8363  	if err := p.VerboseEqual(msg); err != nil {
  8364  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8365  	}
  8366  	if !p.Equal(msg) {
  8367  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8368  	}
  8369  }
  8370  
  8371  func TestNoExtensionsMapProtoCompactText(t *testing.T) {
  8372  	seed := time.Now().UnixNano()
  8373  	popr := math_rand.New(math_rand.NewSource(seed))
  8374  	p := NewPopulatedNoExtensionsMap(popr, true)
  8375  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8376  	msg := &NoExtensionsMap{}
  8377  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  8378  		t.Fatalf("seed = %d, err = %v", seed, err)
  8379  	}
  8380  	if err := p.VerboseEqual(msg); err != nil {
  8381  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  8382  	}
  8383  	if !p.Equal(msg) {
  8384  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  8385  	}
  8386  }
  8387  
  8388  func TestUnrecognizedProtoText(t *testing.T) {
  8389  	seed := time.Now().UnixNano()
  8390  	popr := math_rand.New(math_rand.NewSource(seed))
  8391  	p := NewPopulatedUnrecognized(popr, true)
  8392  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8393  	msg := &Unrecognized{}
  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 TestUnrecognizedProtoCompactText(t *testing.T) {
  8406  	seed := time.Now().UnixNano()
  8407  	popr := math_rand.New(math_rand.NewSource(seed))
  8408  	p := NewPopulatedUnrecognized(popr, true)
  8409  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8410  	msg := &Unrecognized{}
  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 TestUnrecognizedWithInnerProtoText(t *testing.T) {
  8423  	seed := time.Now().UnixNano()
  8424  	popr := math_rand.New(math_rand.NewSource(seed))
  8425  	p := NewPopulatedUnrecognizedWithInner(popr, true)
  8426  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8427  	msg := &UnrecognizedWithInner{}
  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 TestUnrecognizedWithInnerProtoCompactText(t *testing.T) {
  8440  	seed := time.Now().UnixNano()
  8441  	popr := math_rand.New(math_rand.NewSource(seed))
  8442  	p := NewPopulatedUnrecognizedWithInner(popr, true)
  8443  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8444  	msg := &UnrecognizedWithInner{}
  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 TestUnrecognizedWithInner_InnerProtoText(t *testing.T) {
  8457  	seed := time.Now().UnixNano()
  8458  	popr := math_rand.New(math_rand.NewSource(seed))
  8459  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
  8460  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8461  	msg := &UnrecognizedWithInner_Inner{}
  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 TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) {
  8474  	seed := time.Now().UnixNano()
  8475  	popr := math_rand.New(math_rand.NewSource(seed))
  8476  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
  8477  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8478  	msg := &UnrecognizedWithInner_Inner{}
  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 TestUnrecognizedWithEmbedProtoText(t *testing.T) {
  8491  	seed := time.Now().UnixNano()
  8492  	popr := math_rand.New(math_rand.NewSource(seed))
  8493  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
  8494  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8495  	msg := &UnrecognizedWithEmbed{}
  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 TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) {
  8508  	seed := time.Now().UnixNano()
  8509  	popr := math_rand.New(math_rand.NewSource(seed))
  8510  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
  8511  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8512  	msg := &UnrecognizedWithEmbed{}
  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 TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) {
  8525  	seed := time.Now().UnixNano()
  8526  	popr := math_rand.New(math_rand.NewSource(seed))
  8527  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
  8528  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8529  	msg := &UnrecognizedWithEmbed_Embedded{}
  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 TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) {
  8542  	seed := time.Now().UnixNano()
  8543  	popr := math_rand.New(math_rand.NewSource(seed))
  8544  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
  8545  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8546  	msg := &UnrecognizedWithEmbed_Embedded{}
  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 TestNodeProtoText(t *testing.T) {
  8559  	seed := time.Now().UnixNano()
  8560  	popr := math_rand.New(math_rand.NewSource(seed))
  8561  	p := NewPopulatedNode(popr, true)
  8562  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8563  	msg := &Node{}
  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 TestNodeProtoCompactText(t *testing.T) {
  8576  	seed := time.Now().UnixNano()
  8577  	popr := math_rand.New(math_rand.NewSource(seed))
  8578  	p := NewPopulatedNode(popr, true)
  8579  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8580  	msg := &Node{}
  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 TestNonByteCustomTypeProtoText(t *testing.T) {
  8593  	seed := time.Now().UnixNano()
  8594  	popr := math_rand.New(math_rand.NewSource(seed))
  8595  	p := NewPopulatedNonByteCustomType(popr, true)
  8596  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8597  	msg := &NonByteCustomType{}
  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 TestNonByteCustomTypeProtoCompactText(t *testing.T) {
  8610  	seed := time.Now().UnixNano()
  8611  	popr := math_rand.New(math_rand.NewSource(seed))
  8612  	p := NewPopulatedNonByteCustomType(popr, true)
  8613  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8614  	msg := &NonByteCustomType{}
  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 TestNidOptNonByteCustomTypeProtoText(t *testing.T) {
  8627  	seed := time.Now().UnixNano()
  8628  	popr := math_rand.New(math_rand.NewSource(seed))
  8629  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
  8630  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8631  	msg := &NidOptNonByteCustomType{}
  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 TestNidOptNonByteCustomTypeProtoCompactText(t *testing.T) {
  8644  	seed := time.Now().UnixNano()
  8645  	popr := math_rand.New(math_rand.NewSource(seed))
  8646  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
  8647  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8648  	msg := &NidOptNonByteCustomType{}
  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 TestNinOptNonByteCustomTypeProtoText(t *testing.T) {
  8661  	seed := time.Now().UnixNano()
  8662  	popr := math_rand.New(math_rand.NewSource(seed))
  8663  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
  8664  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8665  	msg := &NinOptNonByteCustomType{}
  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 TestNinOptNonByteCustomTypeProtoCompactText(t *testing.T) {
  8678  	seed := time.Now().UnixNano()
  8679  	popr := math_rand.New(math_rand.NewSource(seed))
  8680  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
  8681  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8682  	msg := &NinOptNonByteCustomType{}
  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 TestNidRepNonByteCustomTypeProtoText(t *testing.T) {
  8695  	seed := time.Now().UnixNano()
  8696  	popr := math_rand.New(math_rand.NewSource(seed))
  8697  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
  8698  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8699  	msg := &NidRepNonByteCustomType{}
  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 TestNidRepNonByteCustomTypeProtoCompactText(t *testing.T) {
  8712  	seed := time.Now().UnixNano()
  8713  	popr := math_rand.New(math_rand.NewSource(seed))
  8714  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
  8715  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8716  	msg := &NidRepNonByteCustomType{}
  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 TestNinRepNonByteCustomTypeProtoText(t *testing.T) {
  8729  	seed := time.Now().UnixNano()
  8730  	popr := math_rand.New(math_rand.NewSource(seed))
  8731  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
  8732  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8733  	msg := &NinRepNonByteCustomType{}
  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 TestNinRepNonByteCustomTypeProtoCompactText(t *testing.T) {
  8746  	seed := time.Now().UnixNano()
  8747  	popr := math_rand.New(math_rand.NewSource(seed))
  8748  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
  8749  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8750  	msg := &NinRepNonByteCustomType{}
  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 TestProtoTypeProtoText(t *testing.T) {
  8763  	seed := time.Now().UnixNano()
  8764  	popr := math_rand.New(math_rand.NewSource(seed))
  8765  	p := NewPopulatedProtoType(popr, true)
  8766  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  8767  	msg := &ProtoType{}
  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 TestProtoTypeProtoCompactText(t *testing.T) {
  8780  	seed := time.Now().UnixNano()
  8781  	popr := math_rand.New(math_rand.NewSource(seed))
  8782  	p := NewPopulatedProtoType(popr, true)
  8783  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  8784  	msg := &ProtoType{}
  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 TestNidOptNativeCompare(t *testing.T) {
  8797  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8798  	p := NewPopulatedNidOptNative(popr, false)
  8799  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8800  	if err != nil {
  8801  		panic(err)
  8802  	}
  8803  	msg := &NidOptNative{}
  8804  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8805  		panic(err)
  8806  	}
  8807  	if c := p.Compare(msg); c != 0 {
  8808  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8809  	}
  8810  	p2 := NewPopulatedNidOptNative(popr, false)
  8811  	c := p.Compare(p2)
  8812  	c2 := p2.Compare(p)
  8813  	if c != (-1 * c2) {
  8814  		t.Errorf("p.Compare(p2) = %d", c)
  8815  		t.Errorf("p2.Compare(p) = %d", c2)
  8816  		t.Errorf("p = %#v", p)
  8817  		t.Errorf("p2 = %#v", p2)
  8818  	}
  8819  }
  8820  func TestNinOptNativeCompare(t *testing.T) {
  8821  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8822  	p := NewPopulatedNinOptNative(popr, false)
  8823  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8824  	if err != nil {
  8825  		panic(err)
  8826  	}
  8827  	msg := &NinOptNative{}
  8828  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8829  		panic(err)
  8830  	}
  8831  	if c := p.Compare(msg); c != 0 {
  8832  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8833  	}
  8834  	p2 := NewPopulatedNinOptNative(popr, false)
  8835  	c := p.Compare(p2)
  8836  	c2 := p2.Compare(p)
  8837  	if c != (-1 * c2) {
  8838  		t.Errorf("p.Compare(p2) = %d", c)
  8839  		t.Errorf("p2.Compare(p) = %d", c2)
  8840  		t.Errorf("p = %#v", p)
  8841  		t.Errorf("p2 = %#v", p2)
  8842  	}
  8843  }
  8844  func TestNidRepNativeCompare(t *testing.T) {
  8845  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8846  	p := NewPopulatedNidRepNative(popr, false)
  8847  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8848  	if err != nil {
  8849  		panic(err)
  8850  	}
  8851  	msg := &NidRepNative{}
  8852  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8853  		panic(err)
  8854  	}
  8855  	if c := p.Compare(msg); c != 0 {
  8856  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8857  	}
  8858  	p2 := NewPopulatedNidRepNative(popr, false)
  8859  	c := p.Compare(p2)
  8860  	c2 := p2.Compare(p)
  8861  	if c != (-1 * c2) {
  8862  		t.Errorf("p.Compare(p2) = %d", c)
  8863  		t.Errorf("p2.Compare(p) = %d", c2)
  8864  		t.Errorf("p = %#v", p)
  8865  		t.Errorf("p2 = %#v", p2)
  8866  	}
  8867  }
  8868  func TestNinRepNativeCompare(t *testing.T) {
  8869  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8870  	p := NewPopulatedNinRepNative(popr, false)
  8871  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8872  	if err != nil {
  8873  		panic(err)
  8874  	}
  8875  	msg := &NinRepNative{}
  8876  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8877  		panic(err)
  8878  	}
  8879  	if c := p.Compare(msg); c != 0 {
  8880  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8881  	}
  8882  	p2 := NewPopulatedNinRepNative(popr, false)
  8883  	c := p.Compare(p2)
  8884  	c2 := p2.Compare(p)
  8885  	if c != (-1 * c2) {
  8886  		t.Errorf("p.Compare(p2) = %d", c)
  8887  		t.Errorf("p2.Compare(p) = %d", c2)
  8888  		t.Errorf("p = %#v", p)
  8889  		t.Errorf("p2 = %#v", p2)
  8890  	}
  8891  }
  8892  func TestNidRepPackedNativeCompare(t *testing.T) {
  8893  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8894  	p := NewPopulatedNidRepPackedNative(popr, false)
  8895  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8896  	if err != nil {
  8897  		panic(err)
  8898  	}
  8899  	msg := &NidRepPackedNative{}
  8900  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8901  		panic(err)
  8902  	}
  8903  	if c := p.Compare(msg); c != 0 {
  8904  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8905  	}
  8906  	p2 := NewPopulatedNidRepPackedNative(popr, false)
  8907  	c := p.Compare(p2)
  8908  	c2 := p2.Compare(p)
  8909  	if c != (-1 * c2) {
  8910  		t.Errorf("p.Compare(p2) = %d", c)
  8911  		t.Errorf("p2.Compare(p) = %d", c2)
  8912  		t.Errorf("p = %#v", p)
  8913  		t.Errorf("p2 = %#v", p2)
  8914  	}
  8915  }
  8916  func TestNinRepPackedNativeCompare(t *testing.T) {
  8917  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8918  	p := NewPopulatedNinRepPackedNative(popr, false)
  8919  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8920  	if err != nil {
  8921  		panic(err)
  8922  	}
  8923  	msg := &NinRepPackedNative{}
  8924  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8925  		panic(err)
  8926  	}
  8927  	if c := p.Compare(msg); c != 0 {
  8928  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8929  	}
  8930  	p2 := NewPopulatedNinRepPackedNative(popr, false)
  8931  	c := p.Compare(p2)
  8932  	c2 := p2.Compare(p)
  8933  	if c != (-1 * c2) {
  8934  		t.Errorf("p.Compare(p2) = %d", c)
  8935  		t.Errorf("p2.Compare(p) = %d", c2)
  8936  		t.Errorf("p = %#v", p)
  8937  		t.Errorf("p2 = %#v", p2)
  8938  	}
  8939  }
  8940  func TestNidOptStructCompare(t *testing.T) {
  8941  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8942  	p := NewPopulatedNidOptStruct(popr, false)
  8943  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8944  	if err != nil {
  8945  		panic(err)
  8946  	}
  8947  	msg := &NidOptStruct{}
  8948  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8949  		panic(err)
  8950  	}
  8951  	if c := p.Compare(msg); c != 0 {
  8952  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8953  	}
  8954  	p2 := NewPopulatedNidOptStruct(popr, false)
  8955  	c := p.Compare(p2)
  8956  	c2 := p2.Compare(p)
  8957  	if c != (-1 * c2) {
  8958  		t.Errorf("p.Compare(p2) = %d", c)
  8959  		t.Errorf("p2.Compare(p) = %d", c2)
  8960  		t.Errorf("p = %#v", p)
  8961  		t.Errorf("p2 = %#v", p2)
  8962  	}
  8963  }
  8964  func TestNinOptStructCompare(t *testing.T) {
  8965  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8966  	p := NewPopulatedNinOptStruct(popr, false)
  8967  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8968  	if err != nil {
  8969  		panic(err)
  8970  	}
  8971  	msg := &NinOptStruct{}
  8972  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8973  		panic(err)
  8974  	}
  8975  	if c := p.Compare(msg); c != 0 {
  8976  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  8977  	}
  8978  	p2 := NewPopulatedNinOptStruct(popr, false)
  8979  	c := p.Compare(p2)
  8980  	c2 := p2.Compare(p)
  8981  	if c != (-1 * c2) {
  8982  		t.Errorf("p.Compare(p2) = %d", c)
  8983  		t.Errorf("p2.Compare(p) = %d", c2)
  8984  		t.Errorf("p = %#v", p)
  8985  		t.Errorf("p2 = %#v", p2)
  8986  	}
  8987  }
  8988  func TestNidRepStructCompare(t *testing.T) {
  8989  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  8990  	p := NewPopulatedNidRepStruct(popr, false)
  8991  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  8992  	if err != nil {
  8993  		panic(err)
  8994  	}
  8995  	msg := &NidRepStruct{}
  8996  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  8997  		panic(err)
  8998  	}
  8999  	if c := p.Compare(msg); c != 0 {
  9000  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9001  	}
  9002  	p2 := NewPopulatedNidRepStruct(popr, false)
  9003  	c := p.Compare(p2)
  9004  	c2 := p2.Compare(p)
  9005  	if c != (-1 * c2) {
  9006  		t.Errorf("p.Compare(p2) = %d", c)
  9007  		t.Errorf("p2.Compare(p) = %d", c2)
  9008  		t.Errorf("p = %#v", p)
  9009  		t.Errorf("p2 = %#v", p2)
  9010  	}
  9011  }
  9012  func TestNinRepStructCompare(t *testing.T) {
  9013  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9014  	p := NewPopulatedNinRepStruct(popr, false)
  9015  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9016  	if err != nil {
  9017  		panic(err)
  9018  	}
  9019  	msg := &NinRepStruct{}
  9020  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9021  		panic(err)
  9022  	}
  9023  	if c := p.Compare(msg); c != 0 {
  9024  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9025  	}
  9026  	p2 := NewPopulatedNinRepStruct(popr, false)
  9027  	c := p.Compare(p2)
  9028  	c2 := p2.Compare(p)
  9029  	if c != (-1 * c2) {
  9030  		t.Errorf("p.Compare(p2) = %d", c)
  9031  		t.Errorf("p2.Compare(p) = %d", c2)
  9032  		t.Errorf("p = %#v", p)
  9033  		t.Errorf("p2 = %#v", p2)
  9034  	}
  9035  }
  9036  func TestNidEmbeddedStructCompare(t *testing.T) {
  9037  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9038  	p := NewPopulatedNidEmbeddedStruct(popr, false)
  9039  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9040  	if err != nil {
  9041  		panic(err)
  9042  	}
  9043  	msg := &NidEmbeddedStruct{}
  9044  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9045  		panic(err)
  9046  	}
  9047  	if c := p.Compare(msg); c != 0 {
  9048  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9049  	}
  9050  	p2 := NewPopulatedNidEmbeddedStruct(popr, false)
  9051  	c := p.Compare(p2)
  9052  	c2 := p2.Compare(p)
  9053  	if c != (-1 * c2) {
  9054  		t.Errorf("p.Compare(p2) = %d", c)
  9055  		t.Errorf("p2.Compare(p) = %d", c2)
  9056  		t.Errorf("p = %#v", p)
  9057  		t.Errorf("p2 = %#v", p2)
  9058  	}
  9059  }
  9060  func TestNinEmbeddedStructCompare(t *testing.T) {
  9061  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9062  	p := NewPopulatedNinEmbeddedStruct(popr, false)
  9063  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9064  	if err != nil {
  9065  		panic(err)
  9066  	}
  9067  	msg := &NinEmbeddedStruct{}
  9068  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9069  		panic(err)
  9070  	}
  9071  	if c := p.Compare(msg); c != 0 {
  9072  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9073  	}
  9074  	p2 := NewPopulatedNinEmbeddedStruct(popr, false)
  9075  	c := p.Compare(p2)
  9076  	c2 := p2.Compare(p)
  9077  	if c != (-1 * c2) {
  9078  		t.Errorf("p.Compare(p2) = %d", c)
  9079  		t.Errorf("p2.Compare(p) = %d", c2)
  9080  		t.Errorf("p = %#v", p)
  9081  		t.Errorf("p2 = %#v", p2)
  9082  	}
  9083  }
  9084  func TestNidNestedStructCompare(t *testing.T) {
  9085  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9086  	p := NewPopulatedNidNestedStruct(popr, false)
  9087  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9088  	if err != nil {
  9089  		panic(err)
  9090  	}
  9091  	msg := &NidNestedStruct{}
  9092  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9093  		panic(err)
  9094  	}
  9095  	if c := p.Compare(msg); c != 0 {
  9096  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9097  	}
  9098  	p2 := NewPopulatedNidNestedStruct(popr, false)
  9099  	c := p.Compare(p2)
  9100  	c2 := p2.Compare(p)
  9101  	if c != (-1 * c2) {
  9102  		t.Errorf("p.Compare(p2) = %d", c)
  9103  		t.Errorf("p2.Compare(p) = %d", c2)
  9104  		t.Errorf("p = %#v", p)
  9105  		t.Errorf("p2 = %#v", p2)
  9106  	}
  9107  }
  9108  func TestNinNestedStructCompare(t *testing.T) {
  9109  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9110  	p := NewPopulatedNinNestedStruct(popr, false)
  9111  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9112  	if err != nil {
  9113  		panic(err)
  9114  	}
  9115  	msg := &NinNestedStruct{}
  9116  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9117  		panic(err)
  9118  	}
  9119  	if c := p.Compare(msg); c != 0 {
  9120  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9121  	}
  9122  	p2 := NewPopulatedNinNestedStruct(popr, false)
  9123  	c := p.Compare(p2)
  9124  	c2 := p2.Compare(p)
  9125  	if c != (-1 * c2) {
  9126  		t.Errorf("p.Compare(p2) = %d", c)
  9127  		t.Errorf("p2.Compare(p) = %d", c2)
  9128  		t.Errorf("p = %#v", p)
  9129  		t.Errorf("p2 = %#v", p2)
  9130  	}
  9131  }
  9132  func TestNidOptCustomCompare(t *testing.T) {
  9133  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9134  	p := NewPopulatedNidOptCustom(popr, false)
  9135  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9136  	if err != nil {
  9137  		panic(err)
  9138  	}
  9139  	msg := &NidOptCustom{}
  9140  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9141  		panic(err)
  9142  	}
  9143  	if c := p.Compare(msg); c != 0 {
  9144  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9145  	}
  9146  	p2 := NewPopulatedNidOptCustom(popr, false)
  9147  	c := p.Compare(p2)
  9148  	c2 := p2.Compare(p)
  9149  	if c != (-1 * c2) {
  9150  		t.Errorf("p.Compare(p2) = %d", c)
  9151  		t.Errorf("p2.Compare(p) = %d", c2)
  9152  		t.Errorf("p = %#v", p)
  9153  		t.Errorf("p2 = %#v", p2)
  9154  	}
  9155  }
  9156  func TestCustomDashCompare(t *testing.T) {
  9157  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9158  	p := NewPopulatedCustomDash(popr, false)
  9159  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9160  	if err != nil {
  9161  		panic(err)
  9162  	}
  9163  	msg := &CustomDash{}
  9164  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9165  		panic(err)
  9166  	}
  9167  	if c := p.Compare(msg); c != 0 {
  9168  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9169  	}
  9170  	p2 := NewPopulatedCustomDash(popr, false)
  9171  	c := p.Compare(p2)
  9172  	c2 := p2.Compare(p)
  9173  	if c != (-1 * c2) {
  9174  		t.Errorf("p.Compare(p2) = %d", c)
  9175  		t.Errorf("p2.Compare(p) = %d", c2)
  9176  		t.Errorf("p = %#v", p)
  9177  		t.Errorf("p2 = %#v", p2)
  9178  	}
  9179  }
  9180  func TestNinOptCustomCompare(t *testing.T) {
  9181  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9182  	p := NewPopulatedNinOptCustom(popr, false)
  9183  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9184  	if err != nil {
  9185  		panic(err)
  9186  	}
  9187  	msg := &NinOptCustom{}
  9188  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9189  		panic(err)
  9190  	}
  9191  	if c := p.Compare(msg); c != 0 {
  9192  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9193  	}
  9194  	p2 := NewPopulatedNinOptCustom(popr, false)
  9195  	c := p.Compare(p2)
  9196  	c2 := p2.Compare(p)
  9197  	if c != (-1 * c2) {
  9198  		t.Errorf("p.Compare(p2) = %d", c)
  9199  		t.Errorf("p2.Compare(p) = %d", c2)
  9200  		t.Errorf("p = %#v", p)
  9201  		t.Errorf("p2 = %#v", p2)
  9202  	}
  9203  }
  9204  func TestNidRepCustomCompare(t *testing.T) {
  9205  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9206  	p := NewPopulatedNidRepCustom(popr, false)
  9207  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9208  	if err != nil {
  9209  		panic(err)
  9210  	}
  9211  	msg := &NidRepCustom{}
  9212  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9213  		panic(err)
  9214  	}
  9215  	if c := p.Compare(msg); c != 0 {
  9216  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9217  	}
  9218  	p2 := NewPopulatedNidRepCustom(popr, false)
  9219  	c := p.Compare(p2)
  9220  	c2 := p2.Compare(p)
  9221  	if c != (-1 * c2) {
  9222  		t.Errorf("p.Compare(p2) = %d", c)
  9223  		t.Errorf("p2.Compare(p) = %d", c2)
  9224  		t.Errorf("p = %#v", p)
  9225  		t.Errorf("p2 = %#v", p2)
  9226  	}
  9227  }
  9228  func TestNinRepCustomCompare(t *testing.T) {
  9229  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9230  	p := NewPopulatedNinRepCustom(popr, false)
  9231  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9232  	if err != nil {
  9233  		panic(err)
  9234  	}
  9235  	msg := &NinRepCustom{}
  9236  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9237  		panic(err)
  9238  	}
  9239  	if c := p.Compare(msg); c != 0 {
  9240  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9241  	}
  9242  	p2 := NewPopulatedNinRepCustom(popr, false)
  9243  	c := p.Compare(p2)
  9244  	c2 := p2.Compare(p)
  9245  	if c != (-1 * c2) {
  9246  		t.Errorf("p.Compare(p2) = %d", c)
  9247  		t.Errorf("p2.Compare(p) = %d", c2)
  9248  		t.Errorf("p = %#v", p)
  9249  		t.Errorf("p2 = %#v", p2)
  9250  	}
  9251  }
  9252  func TestNinOptNativeUnionCompare(t *testing.T) {
  9253  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9254  	p := NewPopulatedNinOptNativeUnion(popr, false)
  9255  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9256  	if err != nil {
  9257  		panic(err)
  9258  	}
  9259  	msg := &NinOptNativeUnion{}
  9260  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9261  		panic(err)
  9262  	}
  9263  	if c := p.Compare(msg); c != 0 {
  9264  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9265  	}
  9266  	p2 := NewPopulatedNinOptNativeUnion(popr, false)
  9267  	c := p.Compare(p2)
  9268  	c2 := p2.Compare(p)
  9269  	if c != (-1 * c2) {
  9270  		t.Errorf("p.Compare(p2) = %d", c)
  9271  		t.Errorf("p2.Compare(p) = %d", c2)
  9272  		t.Errorf("p = %#v", p)
  9273  		t.Errorf("p2 = %#v", p2)
  9274  	}
  9275  }
  9276  func TestNinOptStructUnionCompare(t *testing.T) {
  9277  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9278  	p := NewPopulatedNinOptStructUnion(popr, false)
  9279  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9280  	if err != nil {
  9281  		panic(err)
  9282  	}
  9283  	msg := &NinOptStructUnion{}
  9284  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9285  		panic(err)
  9286  	}
  9287  	if c := p.Compare(msg); c != 0 {
  9288  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9289  	}
  9290  	p2 := NewPopulatedNinOptStructUnion(popr, false)
  9291  	c := p.Compare(p2)
  9292  	c2 := p2.Compare(p)
  9293  	if c != (-1 * c2) {
  9294  		t.Errorf("p.Compare(p2) = %d", c)
  9295  		t.Errorf("p2.Compare(p) = %d", c2)
  9296  		t.Errorf("p = %#v", p)
  9297  		t.Errorf("p2 = %#v", p2)
  9298  	}
  9299  }
  9300  func TestNinEmbeddedStructUnionCompare(t *testing.T) {
  9301  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9302  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
  9303  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9304  	if err != nil {
  9305  		panic(err)
  9306  	}
  9307  	msg := &NinEmbeddedStructUnion{}
  9308  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9309  		panic(err)
  9310  	}
  9311  	if c := p.Compare(msg); c != 0 {
  9312  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9313  	}
  9314  	p2 := NewPopulatedNinEmbeddedStructUnion(popr, false)
  9315  	c := p.Compare(p2)
  9316  	c2 := p2.Compare(p)
  9317  	if c != (-1 * c2) {
  9318  		t.Errorf("p.Compare(p2) = %d", c)
  9319  		t.Errorf("p2.Compare(p) = %d", c2)
  9320  		t.Errorf("p = %#v", p)
  9321  		t.Errorf("p2 = %#v", p2)
  9322  	}
  9323  }
  9324  func TestNinNestedStructUnionCompare(t *testing.T) {
  9325  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9326  	p := NewPopulatedNinNestedStructUnion(popr, false)
  9327  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9328  	if err != nil {
  9329  		panic(err)
  9330  	}
  9331  	msg := &NinNestedStructUnion{}
  9332  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9333  		panic(err)
  9334  	}
  9335  	if c := p.Compare(msg); c != 0 {
  9336  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9337  	}
  9338  	p2 := NewPopulatedNinNestedStructUnion(popr, false)
  9339  	c := p.Compare(p2)
  9340  	c2 := p2.Compare(p)
  9341  	if c != (-1 * c2) {
  9342  		t.Errorf("p.Compare(p2) = %d", c)
  9343  		t.Errorf("p2.Compare(p) = %d", c2)
  9344  		t.Errorf("p = %#v", p)
  9345  		t.Errorf("p2 = %#v", p2)
  9346  	}
  9347  }
  9348  func TestTreeCompare(t *testing.T) {
  9349  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9350  	p := NewPopulatedTree(popr, false)
  9351  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9352  	if err != nil {
  9353  		panic(err)
  9354  	}
  9355  	msg := &Tree{}
  9356  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9357  		panic(err)
  9358  	}
  9359  	if c := p.Compare(msg); c != 0 {
  9360  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9361  	}
  9362  	p2 := NewPopulatedTree(popr, false)
  9363  	c := p.Compare(p2)
  9364  	c2 := p2.Compare(p)
  9365  	if c != (-1 * c2) {
  9366  		t.Errorf("p.Compare(p2) = %d", c)
  9367  		t.Errorf("p2.Compare(p) = %d", c2)
  9368  		t.Errorf("p = %#v", p)
  9369  		t.Errorf("p2 = %#v", p2)
  9370  	}
  9371  }
  9372  func TestOrBranchCompare(t *testing.T) {
  9373  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9374  	p := NewPopulatedOrBranch(popr, false)
  9375  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9376  	if err != nil {
  9377  		panic(err)
  9378  	}
  9379  	msg := &OrBranch{}
  9380  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9381  		panic(err)
  9382  	}
  9383  	if c := p.Compare(msg); c != 0 {
  9384  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9385  	}
  9386  	p2 := NewPopulatedOrBranch(popr, false)
  9387  	c := p.Compare(p2)
  9388  	c2 := p2.Compare(p)
  9389  	if c != (-1 * c2) {
  9390  		t.Errorf("p.Compare(p2) = %d", c)
  9391  		t.Errorf("p2.Compare(p) = %d", c2)
  9392  		t.Errorf("p = %#v", p)
  9393  		t.Errorf("p2 = %#v", p2)
  9394  	}
  9395  }
  9396  func TestAndBranchCompare(t *testing.T) {
  9397  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9398  	p := NewPopulatedAndBranch(popr, false)
  9399  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9400  	if err != nil {
  9401  		panic(err)
  9402  	}
  9403  	msg := &AndBranch{}
  9404  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9405  		panic(err)
  9406  	}
  9407  	if c := p.Compare(msg); c != 0 {
  9408  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9409  	}
  9410  	p2 := NewPopulatedAndBranch(popr, false)
  9411  	c := p.Compare(p2)
  9412  	c2 := p2.Compare(p)
  9413  	if c != (-1 * c2) {
  9414  		t.Errorf("p.Compare(p2) = %d", c)
  9415  		t.Errorf("p2.Compare(p) = %d", c2)
  9416  		t.Errorf("p = %#v", p)
  9417  		t.Errorf("p2 = %#v", p2)
  9418  	}
  9419  }
  9420  func TestLeafCompare(t *testing.T) {
  9421  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9422  	p := NewPopulatedLeaf(popr, false)
  9423  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9424  	if err != nil {
  9425  		panic(err)
  9426  	}
  9427  	msg := &Leaf{}
  9428  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9429  		panic(err)
  9430  	}
  9431  	if c := p.Compare(msg); c != 0 {
  9432  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9433  	}
  9434  	p2 := NewPopulatedLeaf(popr, false)
  9435  	c := p.Compare(p2)
  9436  	c2 := p2.Compare(p)
  9437  	if c != (-1 * c2) {
  9438  		t.Errorf("p.Compare(p2) = %d", c)
  9439  		t.Errorf("p2.Compare(p) = %d", c2)
  9440  		t.Errorf("p = %#v", p)
  9441  		t.Errorf("p2 = %#v", p2)
  9442  	}
  9443  }
  9444  func TestDeepTreeCompare(t *testing.T) {
  9445  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9446  	p := NewPopulatedDeepTree(popr, false)
  9447  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9448  	if err != nil {
  9449  		panic(err)
  9450  	}
  9451  	msg := &DeepTree{}
  9452  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9453  		panic(err)
  9454  	}
  9455  	if c := p.Compare(msg); c != 0 {
  9456  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9457  	}
  9458  	p2 := NewPopulatedDeepTree(popr, false)
  9459  	c := p.Compare(p2)
  9460  	c2 := p2.Compare(p)
  9461  	if c != (-1 * c2) {
  9462  		t.Errorf("p.Compare(p2) = %d", c)
  9463  		t.Errorf("p2.Compare(p) = %d", c2)
  9464  		t.Errorf("p = %#v", p)
  9465  		t.Errorf("p2 = %#v", p2)
  9466  	}
  9467  }
  9468  func TestADeepBranchCompare(t *testing.T) {
  9469  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9470  	p := NewPopulatedADeepBranch(popr, false)
  9471  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9472  	if err != nil {
  9473  		panic(err)
  9474  	}
  9475  	msg := &ADeepBranch{}
  9476  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9477  		panic(err)
  9478  	}
  9479  	if c := p.Compare(msg); c != 0 {
  9480  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9481  	}
  9482  	p2 := NewPopulatedADeepBranch(popr, false)
  9483  	c := p.Compare(p2)
  9484  	c2 := p2.Compare(p)
  9485  	if c != (-1 * c2) {
  9486  		t.Errorf("p.Compare(p2) = %d", c)
  9487  		t.Errorf("p2.Compare(p) = %d", c2)
  9488  		t.Errorf("p = %#v", p)
  9489  		t.Errorf("p2 = %#v", p2)
  9490  	}
  9491  }
  9492  func TestAndDeepBranchCompare(t *testing.T) {
  9493  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9494  	p := NewPopulatedAndDeepBranch(popr, false)
  9495  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9496  	if err != nil {
  9497  		panic(err)
  9498  	}
  9499  	msg := &AndDeepBranch{}
  9500  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9501  		panic(err)
  9502  	}
  9503  	if c := p.Compare(msg); c != 0 {
  9504  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9505  	}
  9506  	p2 := NewPopulatedAndDeepBranch(popr, false)
  9507  	c := p.Compare(p2)
  9508  	c2 := p2.Compare(p)
  9509  	if c != (-1 * c2) {
  9510  		t.Errorf("p.Compare(p2) = %d", c)
  9511  		t.Errorf("p2.Compare(p) = %d", c2)
  9512  		t.Errorf("p = %#v", p)
  9513  		t.Errorf("p2 = %#v", p2)
  9514  	}
  9515  }
  9516  func TestDeepLeafCompare(t *testing.T) {
  9517  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9518  	p := NewPopulatedDeepLeaf(popr, false)
  9519  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9520  	if err != nil {
  9521  		panic(err)
  9522  	}
  9523  	msg := &DeepLeaf{}
  9524  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9525  		panic(err)
  9526  	}
  9527  	if c := p.Compare(msg); c != 0 {
  9528  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9529  	}
  9530  	p2 := NewPopulatedDeepLeaf(popr, false)
  9531  	c := p.Compare(p2)
  9532  	c2 := p2.Compare(p)
  9533  	if c != (-1 * c2) {
  9534  		t.Errorf("p.Compare(p2) = %d", c)
  9535  		t.Errorf("p2.Compare(p) = %d", c2)
  9536  		t.Errorf("p = %#v", p)
  9537  		t.Errorf("p2 = %#v", p2)
  9538  	}
  9539  }
  9540  func TestNilCompare(t *testing.T) {
  9541  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9542  	p := NewPopulatedNil(popr, false)
  9543  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9544  	if err != nil {
  9545  		panic(err)
  9546  	}
  9547  	msg := &Nil{}
  9548  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9549  		panic(err)
  9550  	}
  9551  	if c := p.Compare(msg); c != 0 {
  9552  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9553  	}
  9554  	p2 := NewPopulatedNil(popr, false)
  9555  	c := p.Compare(p2)
  9556  	c2 := p2.Compare(p)
  9557  	if c != (-1 * c2) {
  9558  		t.Errorf("p.Compare(p2) = %d", c)
  9559  		t.Errorf("p2.Compare(p) = %d", c2)
  9560  		t.Errorf("p = %#v", p)
  9561  		t.Errorf("p2 = %#v", p2)
  9562  	}
  9563  }
  9564  func TestNidOptEnumCompare(t *testing.T) {
  9565  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9566  	p := NewPopulatedNidOptEnum(popr, false)
  9567  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9568  	if err != nil {
  9569  		panic(err)
  9570  	}
  9571  	msg := &NidOptEnum{}
  9572  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9573  		panic(err)
  9574  	}
  9575  	if c := p.Compare(msg); c != 0 {
  9576  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9577  	}
  9578  	p2 := NewPopulatedNidOptEnum(popr, false)
  9579  	c := p.Compare(p2)
  9580  	c2 := p2.Compare(p)
  9581  	if c != (-1 * c2) {
  9582  		t.Errorf("p.Compare(p2) = %d", c)
  9583  		t.Errorf("p2.Compare(p) = %d", c2)
  9584  		t.Errorf("p = %#v", p)
  9585  		t.Errorf("p2 = %#v", p2)
  9586  	}
  9587  }
  9588  func TestNinOptEnumCompare(t *testing.T) {
  9589  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9590  	p := NewPopulatedNinOptEnum(popr, false)
  9591  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9592  	if err != nil {
  9593  		panic(err)
  9594  	}
  9595  	msg := &NinOptEnum{}
  9596  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9597  		panic(err)
  9598  	}
  9599  	if c := p.Compare(msg); c != 0 {
  9600  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9601  	}
  9602  	p2 := NewPopulatedNinOptEnum(popr, false)
  9603  	c := p.Compare(p2)
  9604  	c2 := p2.Compare(p)
  9605  	if c != (-1 * c2) {
  9606  		t.Errorf("p.Compare(p2) = %d", c)
  9607  		t.Errorf("p2.Compare(p) = %d", c2)
  9608  		t.Errorf("p = %#v", p)
  9609  		t.Errorf("p2 = %#v", p2)
  9610  	}
  9611  }
  9612  func TestNidRepEnumCompare(t *testing.T) {
  9613  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9614  	p := NewPopulatedNidRepEnum(popr, false)
  9615  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9616  	if err != nil {
  9617  		panic(err)
  9618  	}
  9619  	msg := &NidRepEnum{}
  9620  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9621  		panic(err)
  9622  	}
  9623  	if c := p.Compare(msg); c != 0 {
  9624  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9625  	}
  9626  	p2 := NewPopulatedNidRepEnum(popr, false)
  9627  	c := p.Compare(p2)
  9628  	c2 := p2.Compare(p)
  9629  	if c != (-1 * c2) {
  9630  		t.Errorf("p.Compare(p2) = %d", c)
  9631  		t.Errorf("p2.Compare(p) = %d", c2)
  9632  		t.Errorf("p = %#v", p)
  9633  		t.Errorf("p2 = %#v", p2)
  9634  	}
  9635  }
  9636  func TestNinRepEnumCompare(t *testing.T) {
  9637  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9638  	p := NewPopulatedNinRepEnum(popr, false)
  9639  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9640  	if err != nil {
  9641  		panic(err)
  9642  	}
  9643  	msg := &NinRepEnum{}
  9644  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9645  		panic(err)
  9646  	}
  9647  	if c := p.Compare(msg); c != 0 {
  9648  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9649  	}
  9650  	p2 := NewPopulatedNinRepEnum(popr, false)
  9651  	c := p.Compare(p2)
  9652  	c2 := p2.Compare(p)
  9653  	if c != (-1 * c2) {
  9654  		t.Errorf("p.Compare(p2) = %d", c)
  9655  		t.Errorf("p2.Compare(p) = %d", c2)
  9656  		t.Errorf("p = %#v", p)
  9657  		t.Errorf("p2 = %#v", p2)
  9658  	}
  9659  }
  9660  func TestNinOptEnumDefaultCompare(t *testing.T) {
  9661  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9662  	p := NewPopulatedNinOptEnumDefault(popr, false)
  9663  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9664  	if err != nil {
  9665  		panic(err)
  9666  	}
  9667  	msg := &NinOptEnumDefault{}
  9668  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9669  		panic(err)
  9670  	}
  9671  	if c := p.Compare(msg); c != 0 {
  9672  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9673  	}
  9674  	p2 := NewPopulatedNinOptEnumDefault(popr, false)
  9675  	c := p.Compare(p2)
  9676  	c2 := p2.Compare(p)
  9677  	if c != (-1 * c2) {
  9678  		t.Errorf("p.Compare(p2) = %d", c)
  9679  		t.Errorf("p2.Compare(p) = %d", c2)
  9680  		t.Errorf("p = %#v", p)
  9681  		t.Errorf("p2 = %#v", p2)
  9682  	}
  9683  }
  9684  func TestAnotherNinOptEnumCompare(t *testing.T) {
  9685  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9686  	p := NewPopulatedAnotherNinOptEnum(popr, false)
  9687  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9688  	if err != nil {
  9689  		panic(err)
  9690  	}
  9691  	msg := &AnotherNinOptEnum{}
  9692  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9693  		panic(err)
  9694  	}
  9695  	if c := p.Compare(msg); c != 0 {
  9696  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9697  	}
  9698  	p2 := NewPopulatedAnotherNinOptEnum(popr, false)
  9699  	c := p.Compare(p2)
  9700  	c2 := p2.Compare(p)
  9701  	if c != (-1 * c2) {
  9702  		t.Errorf("p.Compare(p2) = %d", c)
  9703  		t.Errorf("p2.Compare(p) = %d", c2)
  9704  		t.Errorf("p = %#v", p)
  9705  		t.Errorf("p2 = %#v", p2)
  9706  	}
  9707  }
  9708  func TestAnotherNinOptEnumDefaultCompare(t *testing.T) {
  9709  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9710  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
  9711  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9712  	if err != nil {
  9713  		panic(err)
  9714  	}
  9715  	msg := &AnotherNinOptEnumDefault{}
  9716  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9717  		panic(err)
  9718  	}
  9719  	if c := p.Compare(msg); c != 0 {
  9720  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9721  	}
  9722  	p2 := NewPopulatedAnotherNinOptEnumDefault(popr, false)
  9723  	c := p.Compare(p2)
  9724  	c2 := p2.Compare(p)
  9725  	if c != (-1 * c2) {
  9726  		t.Errorf("p.Compare(p2) = %d", c)
  9727  		t.Errorf("p2.Compare(p) = %d", c2)
  9728  		t.Errorf("p = %#v", p)
  9729  		t.Errorf("p2 = %#v", p2)
  9730  	}
  9731  }
  9732  func TestTimerCompare(t *testing.T) {
  9733  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9734  	p := NewPopulatedTimer(popr, false)
  9735  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9736  	if err != nil {
  9737  		panic(err)
  9738  	}
  9739  	msg := &Timer{}
  9740  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9741  		panic(err)
  9742  	}
  9743  	if c := p.Compare(msg); c != 0 {
  9744  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9745  	}
  9746  	p2 := NewPopulatedTimer(popr, false)
  9747  	c := p.Compare(p2)
  9748  	c2 := p2.Compare(p)
  9749  	if c != (-1 * c2) {
  9750  		t.Errorf("p.Compare(p2) = %d", c)
  9751  		t.Errorf("p2.Compare(p) = %d", c2)
  9752  		t.Errorf("p = %#v", p)
  9753  		t.Errorf("p2 = %#v", p2)
  9754  	}
  9755  }
  9756  func TestMyExtendableCompare(t *testing.T) {
  9757  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9758  	p := NewPopulatedMyExtendable(popr, false)
  9759  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9760  	if err != nil {
  9761  		panic(err)
  9762  	}
  9763  	msg := &MyExtendable{}
  9764  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9765  		panic(err)
  9766  	}
  9767  	if c := p.Compare(msg); c != 0 {
  9768  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9769  	}
  9770  	p2 := NewPopulatedMyExtendable(popr, false)
  9771  	c := p.Compare(p2)
  9772  	c2 := p2.Compare(p)
  9773  	if c != (-1 * c2) {
  9774  		t.Errorf("p.Compare(p2) = %d", c)
  9775  		t.Errorf("p2.Compare(p) = %d", c2)
  9776  		t.Errorf("p = %#v", p)
  9777  		t.Errorf("p2 = %#v", p2)
  9778  	}
  9779  }
  9780  func TestOtherExtenableCompare(t *testing.T) {
  9781  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9782  	p := NewPopulatedOtherExtenable(popr, false)
  9783  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9784  	if err != nil {
  9785  		panic(err)
  9786  	}
  9787  	msg := &OtherExtenable{}
  9788  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9789  		panic(err)
  9790  	}
  9791  	if c := p.Compare(msg); c != 0 {
  9792  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9793  	}
  9794  	p2 := NewPopulatedOtherExtenable(popr, false)
  9795  	c := p.Compare(p2)
  9796  	c2 := p2.Compare(p)
  9797  	if c != (-1 * c2) {
  9798  		t.Errorf("p.Compare(p2) = %d", c)
  9799  		t.Errorf("p2.Compare(p) = %d", c2)
  9800  		t.Errorf("p = %#v", p)
  9801  		t.Errorf("p2 = %#v", p2)
  9802  	}
  9803  }
  9804  func TestNestedDefinitionCompare(t *testing.T) {
  9805  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9806  	p := NewPopulatedNestedDefinition(popr, false)
  9807  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9808  	if err != nil {
  9809  		panic(err)
  9810  	}
  9811  	msg := &NestedDefinition{}
  9812  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9813  		panic(err)
  9814  	}
  9815  	if c := p.Compare(msg); c != 0 {
  9816  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9817  	}
  9818  	p2 := NewPopulatedNestedDefinition(popr, false)
  9819  	c := p.Compare(p2)
  9820  	c2 := p2.Compare(p)
  9821  	if c != (-1 * c2) {
  9822  		t.Errorf("p.Compare(p2) = %d", c)
  9823  		t.Errorf("p2.Compare(p) = %d", c2)
  9824  		t.Errorf("p = %#v", p)
  9825  		t.Errorf("p2 = %#v", p2)
  9826  	}
  9827  }
  9828  func TestNestedDefinition_NestedMessageCompare(t *testing.T) {
  9829  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9830  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
  9831  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9832  	if err != nil {
  9833  		panic(err)
  9834  	}
  9835  	msg := &NestedDefinition_NestedMessage{}
  9836  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9837  		panic(err)
  9838  	}
  9839  	if c := p.Compare(msg); c != 0 {
  9840  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9841  	}
  9842  	p2 := NewPopulatedNestedDefinition_NestedMessage(popr, false)
  9843  	c := p.Compare(p2)
  9844  	c2 := p2.Compare(p)
  9845  	if c != (-1 * c2) {
  9846  		t.Errorf("p.Compare(p2) = %d", c)
  9847  		t.Errorf("p2.Compare(p) = %d", c2)
  9848  		t.Errorf("p = %#v", p)
  9849  		t.Errorf("p2 = %#v", p2)
  9850  	}
  9851  }
  9852  func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) {
  9853  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9854  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  9855  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9856  	if err != nil {
  9857  		panic(err)
  9858  	}
  9859  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
  9860  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9861  		panic(err)
  9862  	}
  9863  	if c := p.Compare(msg); c != 0 {
  9864  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9865  	}
  9866  	p2 := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
  9867  	c := p.Compare(p2)
  9868  	c2 := p2.Compare(p)
  9869  	if c != (-1 * c2) {
  9870  		t.Errorf("p.Compare(p2) = %d", c)
  9871  		t.Errorf("p2.Compare(p) = %d", c2)
  9872  		t.Errorf("p = %#v", p)
  9873  		t.Errorf("p2 = %#v", p2)
  9874  	}
  9875  }
  9876  func TestNestedScopeCompare(t *testing.T) {
  9877  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9878  	p := NewPopulatedNestedScope(popr, false)
  9879  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9880  	if err != nil {
  9881  		panic(err)
  9882  	}
  9883  	msg := &NestedScope{}
  9884  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9885  		panic(err)
  9886  	}
  9887  	if c := p.Compare(msg); c != 0 {
  9888  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9889  	}
  9890  	p2 := NewPopulatedNestedScope(popr, false)
  9891  	c := p.Compare(p2)
  9892  	c2 := p2.Compare(p)
  9893  	if c != (-1 * c2) {
  9894  		t.Errorf("p.Compare(p2) = %d", c)
  9895  		t.Errorf("p2.Compare(p) = %d", c2)
  9896  		t.Errorf("p = %#v", p)
  9897  		t.Errorf("p2 = %#v", p2)
  9898  	}
  9899  }
  9900  func TestNinOptNativeDefaultCompare(t *testing.T) {
  9901  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9902  	p := NewPopulatedNinOptNativeDefault(popr, false)
  9903  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9904  	if err != nil {
  9905  		panic(err)
  9906  	}
  9907  	msg := &NinOptNativeDefault{}
  9908  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9909  		panic(err)
  9910  	}
  9911  	if c := p.Compare(msg); c != 0 {
  9912  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9913  	}
  9914  	p2 := NewPopulatedNinOptNativeDefault(popr, false)
  9915  	c := p.Compare(p2)
  9916  	c2 := p2.Compare(p)
  9917  	if c != (-1 * c2) {
  9918  		t.Errorf("p.Compare(p2) = %d", c)
  9919  		t.Errorf("p2.Compare(p) = %d", c2)
  9920  		t.Errorf("p = %#v", p)
  9921  		t.Errorf("p2 = %#v", p2)
  9922  	}
  9923  }
  9924  func TestCustomContainerCompare(t *testing.T) {
  9925  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9926  	p := NewPopulatedCustomContainer(popr, false)
  9927  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9928  	if err != nil {
  9929  		panic(err)
  9930  	}
  9931  	msg := &CustomContainer{}
  9932  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9933  		panic(err)
  9934  	}
  9935  	if c := p.Compare(msg); c != 0 {
  9936  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9937  	}
  9938  	p2 := NewPopulatedCustomContainer(popr, false)
  9939  	c := p.Compare(p2)
  9940  	c2 := p2.Compare(p)
  9941  	if c != (-1 * c2) {
  9942  		t.Errorf("p.Compare(p2) = %d", c)
  9943  		t.Errorf("p2.Compare(p) = %d", c2)
  9944  		t.Errorf("p = %#v", p)
  9945  		t.Errorf("p2 = %#v", p2)
  9946  	}
  9947  }
  9948  func TestCustomNameNidOptNativeCompare(t *testing.T) {
  9949  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9950  	p := NewPopulatedCustomNameNidOptNative(popr, false)
  9951  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9952  	if err != nil {
  9953  		panic(err)
  9954  	}
  9955  	msg := &CustomNameNidOptNative{}
  9956  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9957  		panic(err)
  9958  	}
  9959  	if c := p.Compare(msg); c != 0 {
  9960  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9961  	}
  9962  	p2 := NewPopulatedCustomNameNidOptNative(popr, false)
  9963  	c := p.Compare(p2)
  9964  	c2 := p2.Compare(p)
  9965  	if c != (-1 * c2) {
  9966  		t.Errorf("p.Compare(p2) = %d", c)
  9967  		t.Errorf("p2.Compare(p) = %d", c2)
  9968  		t.Errorf("p = %#v", p)
  9969  		t.Errorf("p2 = %#v", p2)
  9970  	}
  9971  }
  9972  func TestCustomNameNinOptNativeCompare(t *testing.T) {
  9973  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9974  	p := NewPopulatedCustomNameNinOptNative(popr, false)
  9975  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  9976  	if err != nil {
  9977  		panic(err)
  9978  	}
  9979  	msg := &CustomNameNinOptNative{}
  9980  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  9981  		panic(err)
  9982  	}
  9983  	if c := p.Compare(msg); c != 0 {
  9984  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
  9985  	}
  9986  	p2 := NewPopulatedCustomNameNinOptNative(popr, false)
  9987  	c := p.Compare(p2)
  9988  	c2 := p2.Compare(p)
  9989  	if c != (-1 * c2) {
  9990  		t.Errorf("p.Compare(p2) = %d", c)
  9991  		t.Errorf("p2.Compare(p) = %d", c2)
  9992  		t.Errorf("p = %#v", p)
  9993  		t.Errorf("p2 = %#v", p2)
  9994  	}
  9995  }
  9996  func TestCustomNameNinRepNativeCompare(t *testing.T) {
  9997  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  9998  	p := NewPopulatedCustomNameNinRepNative(popr, false)
  9999  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10000  	if err != nil {
 10001  		panic(err)
 10002  	}
 10003  	msg := &CustomNameNinRepNative{}
 10004  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10005  		panic(err)
 10006  	}
 10007  	if c := p.Compare(msg); c != 0 {
 10008  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10009  	}
 10010  	p2 := NewPopulatedCustomNameNinRepNative(popr, false)
 10011  	c := p.Compare(p2)
 10012  	c2 := p2.Compare(p)
 10013  	if c != (-1 * c2) {
 10014  		t.Errorf("p.Compare(p2) = %d", c)
 10015  		t.Errorf("p2.Compare(p) = %d", c2)
 10016  		t.Errorf("p = %#v", p)
 10017  		t.Errorf("p2 = %#v", p2)
 10018  	}
 10019  }
 10020  func TestCustomNameNinStructCompare(t *testing.T) {
 10021  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10022  	p := NewPopulatedCustomNameNinStruct(popr, false)
 10023  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10024  	if err != nil {
 10025  		panic(err)
 10026  	}
 10027  	msg := &CustomNameNinStruct{}
 10028  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10029  		panic(err)
 10030  	}
 10031  	if c := p.Compare(msg); c != 0 {
 10032  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10033  	}
 10034  	p2 := NewPopulatedCustomNameNinStruct(popr, false)
 10035  	c := p.Compare(p2)
 10036  	c2 := p2.Compare(p)
 10037  	if c != (-1 * c2) {
 10038  		t.Errorf("p.Compare(p2) = %d", c)
 10039  		t.Errorf("p2.Compare(p) = %d", c2)
 10040  		t.Errorf("p = %#v", p)
 10041  		t.Errorf("p2 = %#v", p2)
 10042  	}
 10043  }
 10044  func TestCustomNameCustomTypeCompare(t *testing.T) {
 10045  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10046  	p := NewPopulatedCustomNameCustomType(popr, false)
 10047  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10048  	if err != nil {
 10049  		panic(err)
 10050  	}
 10051  	msg := &CustomNameCustomType{}
 10052  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10053  		panic(err)
 10054  	}
 10055  	if c := p.Compare(msg); c != 0 {
 10056  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10057  	}
 10058  	p2 := NewPopulatedCustomNameCustomType(popr, false)
 10059  	c := p.Compare(p2)
 10060  	c2 := p2.Compare(p)
 10061  	if c != (-1 * c2) {
 10062  		t.Errorf("p.Compare(p2) = %d", c)
 10063  		t.Errorf("p2.Compare(p) = %d", c2)
 10064  		t.Errorf("p = %#v", p)
 10065  		t.Errorf("p2 = %#v", p2)
 10066  	}
 10067  }
 10068  func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) {
 10069  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10070  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 10071  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10072  	if err != nil {
 10073  		panic(err)
 10074  	}
 10075  	msg := &CustomNameNinEmbeddedStructUnion{}
 10076  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10077  		panic(err)
 10078  	}
 10079  	if c := p.Compare(msg); c != 0 {
 10080  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10081  	}
 10082  	p2 := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 10083  	c := p.Compare(p2)
 10084  	c2 := p2.Compare(p)
 10085  	if c != (-1 * c2) {
 10086  		t.Errorf("p.Compare(p2) = %d", c)
 10087  		t.Errorf("p2.Compare(p) = %d", c2)
 10088  		t.Errorf("p = %#v", p)
 10089  		t.Errorf("p2 = %#v", p2)
 10090  	}
 10091  }
 10092  func TestCustomNameEnumCompare(t *testing.T) {
 10093  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10094  	p := NewPopulatedCustomNameEnum(popr, false)
 10095  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10096  	if err != nil {
 10097  		panic(err)
 10098  	}
 10099  	msg := &CustomNameEnum{}
 10100  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10101  		panic(err)
 10102  	}
 10103  	if c := p.Compare(msg); c != 0 {
 10104  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10105  	}
 10106  	p2 := NewPopulatedCustomNameEnum(popr, false)
 10107  	c := p.Compare(p2)
 10108  	c2 := p2.Compare(p)
 10109  	if c != (-1 * c2) {
 10110  		t.Errorf("p.Compare(p2) = %d", c)
 10111  		t.Errorf("p2.Compare(p) = %d", c2)
 10112  		t.Errorf("p = %#v", p)
 10113  		t.Errorf("p2 = %#v", p2)
 10114  	}
 10115  }
 10116  func TestNoExtensionsMapCompare(t *testing.T) {
 10117  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10118  	p := NewPopulatedNoExtensionsMap(popr, false)
 10119  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10120  	if err != nil {
 10121  		panic(err)
 10122  	}
 10123  	msg := &NoExtensionsMap{}
 10124  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10125  		panic(err)
 10126  	}
 10127  	if c := p.Compare(msg); c != 0 {
 10128  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10129  	}
 10130  	p2 := NewPopulatedNoExtensionsMap(popr, false)
 10131  	c := p.Compare(p2)
 10132  	c2 := p2.Compare(p)
 10133  	if c != (-1 * c2) {
 10134  		t.Errorf("p.Compare(p2) = %d", c)
 10135  		t.Errorf("p2.Compare(p) = %d", c2)
 10136  		t.Errorf("p = %#v", p)
 10137  		t.Errorf("p2 = %#v", p2)
 10138  	}
 10139  }
 10140  func TestUnrecognizedCompare(t *testing.T) {
 10141  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10142  	p := NewPopulatedUnrecognized(popr, false)
 10143  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10144  	if err != nil {
 10145  		panic(err)
 10146  	}
 10147  	msg := &Unrecognized{}
 10148  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10149  		panic(err)
 10150  	}
 10151  	if c := p.Compare(msg); c != 0 {
 10152  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10153  	}
 10154  	p2 := NewPopulatedUnrecognized(popr, false)
 10155  	c := p.Compare(p2)
 10156  	c2 := p2.Compare(p)
 10157  	if c != (-1 * c2) {
 10158  		t.Errorf("p.Compare(p2) = %d", c)
 10159  		t.Errorf("p2.Compare(p) = %d", c2)
 10160  		t.Errorf("p = %#v", p)
 10161  		t.Errorf("p2 = %#v", p2)
 10162  	}
 10163  }
 10164  func TestUnrecognizedWithInnerCompare(t *testing.T) {
 10165  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10166  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 10167  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10168  	if err != nil {
 10169  		panic(err)
 10170  	}
 10171  	msg := &UnrecognizedWithInner{}
 10172  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10173  		panic(err)
 10174  	}
 10175  	if c := p.Compare(msg); c != 0 {
 10176  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10177  	}
 10178  	p2 := NewPopulatedUnrecognizedWithInner(popr, false)
 10179  	c := p.Compare(p2)
 10180  	c2 := p2.Compare(p)
 10181  	if c != (-1 * c2) {
 10182  		t.Errorf("p.Compare(p2) = %d", c)
 10183  		t.Errorf("p2.Compare(p) = %d", c2)
 10184  		t.Errorf("p = %#v", p)
 10185  		t.Errorf("p2 = %#v", p2)
 10186  	}
 10187  }
 10188  func TestUnrecognizedWithInner_InnerCompare(t *testing.T) {
 10189  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10190  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 10191  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10192  	if err != nil {
 10193  		panic(err)
 10194  	}
 10195  	msg := &UnrecognizedWithInner_Inner{}
 10196  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10197  		panic(err)
 10198  	}
 10199  	if c := p.Compare(msg); c != 0 {
 10200  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10201  	}
 10202  	p2 := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 10203  	c := p.Compare(p2)
 10204  	c2 := p2.Compare(p)
 10205  	if c != (-1 * c2) {
 10206  		t.Errorf("p.Compare(p2) = %d", c)
 10207  		t.Errorf("p2.Compare(p) = %d", c2)
 10208  		t.Errorf("p = %#v", p)
 10209  		t.Errorf("p2 = %#v", p2)
 10210  	}
 10211  }
 10212  func TestUnrecognizedWithEmbedCompare(t *testing.T) {
 10213  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10214  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 10215  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10216  	if err != nil {
 10217  		panic(err)
 10218  	}
 10219  	msg := &UnrecognizedWithEmbed{}
 10220  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10221  		panic(err)
 10222  	}
 10223  	if c := p.Compare(msg); c != 0 {
 10224  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10225  	}
 10226  	p2 := NewPopulatedUnrecognizedWithEmbed(popr, false)
 10227  	c := p.Compare(p2)
 10228  	c2 := p2.Compare(p)
 10229  	if c != (-1 * c2) {
 10230  		t.Errorf("p.Compare(p2) = %d", c)
 10231  		t.Errorf("p2.Compare(p) = %d", c2)
 10232  		t.Errorf("p = %#v", p)
 10233  		t.Errorf("p2 = %#v", p2)
 10234  	}
 10235  }
 10236  func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) {
 10237  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10238  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 10239  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10240  	if err != nil {
 10241  		panic(err)
 10242  	}
 10243  	msg := &UnrecognizedWithEmbed_Embedded{}
 10244  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10245  		panic(err)
 10246  	}
 10247  	if c := p.Compare(msg); c != 0 {
 10248  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10249  	}
 10250  	p2 := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 10251  	c := p.Compare(p2)
 10252  	c2 := p2.Compare(p)
 10253  	if c != (-1 * c2) {
 10254  		t.Errorf("p.Compare(p2) = %d", c)
 10255  		t.Errorf("p2.Compare(p) = %d", c2)
 10256  		t.Errorf("p = %#v", p)
 10257  		t.Errorf("p2 = %#v", p2)
 10258  	}
 10259  }
 10260  func TestNodeCompare(t *testing.T) {
 10261  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10262  	p := NewPopulatedNode(popr, false)
 10263  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10264  	if err != nil {
 10265  		panic(err)
 10266  	}
 10267  	msg := &Node{}
 10268  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10269  		panic(err)
 10270  	}
 10271  	if c := p.Compare(msg); c != 0 {
 10272  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10273  	}
 10274  	p2 := NewPopulatedNode(popr, false)
 10275  	c := p.Compare(p2)
 10276  	c2 := p2.Compare(p)
 10277  	if c != (-1 * c2) {
 10278  		t.Errorf("p.Compare(p2) = %d", c)
 10279  		t.Errorf("p2.Compare(p) = %d", c2)
 10280  		t.Errorf("p = %#v", p)
 10281  		t.Errorf("p2 = %#v", p2)
 10282  	}
 10283  }
 10284  func TestNonByteCustomTypeCompare(t *testing.T) {
 10285  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10286  	p := NewPopulatedNonByteCustomType(popr, false)
 10287  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10288  	if err != nil {
 10289  		panic(err)
 10290  	}
 10291  	msg := &NonByteCustomType{}
 10292  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10293  		panic(err)
 10294  	}
 10295  	if c := p.Compare(msg); c != 0 {
 10296  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10297  	}
 10298  	p2 := NewPopulatedNonByteCustomType(popr, false)
 10299  	c := p.Compare(p2)
 10300  	c2 := p2.Compare(p)
 10301  	if c != (-1 * c2) {
 10302  		t.Errorf("p.Compare(p2) = %d", c)
 10303  		t.Errorf("p2.Compare(p) = %d", c2)
 10304  		t.Errorf("p = %#v", p)
 10305  		t.Errorf("p2 = %#v", p2)
 10306  	}
 10307  }
 10308  func TestNidOptNonByteCustomTypeCompare(t *testing.T) {
 10309  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10310  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 10311  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10312  	if err != nil {
 10313  		panic(err)
 10314  	}
 10315  	msg := &NidOptNonByteCustomType{}
 10316  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10317  		panic(err)
 10318  	}
 10319  	if c := p.Compare(msg); c != 0 {
 10320  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10321  	}
 10322  	p2 := NewPopulatedNidOptNonByteCustomType(popr, false)
 10323  	c := p.Compare(p2)
 10324  	c2 := p2.Compare(p)
 10325  	if c != (-1 * c2) {
 10326  		t.Errorf("p.Compare(p2) = %d", c)
 10327  		t.Errorf("p2.Compare(p) = %d", c2)
 10328  		t.Errorf("p = %#v", p)
 10329  		t.Errorf("p2 = %#v", p2)
 10330  	}
 10331  }
 10332  func TestNinOptNonByteCustomTypeCompare(t *testing.T) {
 10333  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10334  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 10335  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10336  	if err != nil {
 10337  		panic(err)
 10338  	}
 10339  	msg := &NinOptNonByteCustomType{}
 10340  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10341  		panic(err)
 10342  	}
 10343  	if c := p.Compare(msg); c != 0 {
 10344  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10345  	}
 10346  	p2 := NewPopulatedNinOptNonByteCustomType(popr, false)
 10347  	c := p.Compare(p2)
 10348  	c2 := p2.Compare(p)
 10349  	if c != (-1 * c2) {
 10350  		t.Errorf("p.Compare(p2) = %d", c)
 10351  		t.Errorf("p2.Compare(p) = %d", c2)
 10352  		t.Errorf("p = %#v", p)
 10353  		t.Errorf("p2 = %#v", p2)
 10354  	}
 10355  }
 10356  func TestNidRepNonByteCustomTypeCompare(t *testing.T) {
 10357  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10358  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 10359  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10360  	if err != nil {
 10361  		panic(err)
 10362  	}
 10363  	msg := &NidRepNonByteCustomType{}
 10364  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10365  		panic(err)
 10366  	}
 10367  	if c := p.Compare(msg); c != 0 {
 10368  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10369  	}
 10370  	p2 := NewPopulatedNidRepNonByteCustomType(popr, false)
 10371  	c := p.Compare(p2)
 10372  	c2 := p2.Compare(p)
 10373  	if c != (-1 * c2) {
 10374  		t.Errorf("p.Compare(p2) = %d", c)
 10375  		t.Errorf("p2.Compare(p) = %d", c2)
 10376  		t.Errorf("p = %#v", p)
 10377  		t.Errorf("p2 = %#v", p2)
 10378  	}
 10379  }
 10380  func TestNinRepNonByteCustomTypeCompare(t *testing.T) {
 10381  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10382  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 10383  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10384  	if err != nil {
 10385  		panic(err)
 10386  	}
 10387  	msg := &NinRepNonByteCustomType{}
 10388  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10389  		panic(err)
 10390  	}
 10391  	if c := p.Compare(msg); c != 0 {
 10392  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10393  	}
 10394  	p2 := NewPopulatedNinRepNonByteCustomType(popr, false)
 10395  	c := p.Compare(p2)
 10396  	c2 := p2.Compare(p)
 10397  	if c != (-1 * c2) {
 10398  		t.Errorf("p.Compare(p2) = %d", c)
 10399  		t.Errorf("p2.Compare(p) = %d", c2)
 10400  		t.Errorf("p = %#v", p)
 10401  		t.Errorf("p2 = %#v", p2)
 10402  	}
 10403  }
 10404  func TestProtoTypeCompare(t *testing.T) {
 10405  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10406  	p := NewPopulatedProtoType(popr, false)
 10407  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10408  	if err != nil {
 10409  		panic(err)
 10410  	}
 10411  	msg := &ProtoType{}
 10412  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10413  		panic(err)
 10414  	}
 10415  	if c := p.Compare(msg); c != 0 {
 10416  		t.Fatalf("%#v !Compare %#v, since %d", msg, p, c)
 10417  	}
 10418  	p2 := NewPopulatedProtoType(popr, false)
 10419  	c := p.Compare(p2)
 10420  	c2 := p2.Compare(p)
 10421  	if c != (-1 * c2) {
 10422  		t.Errorf("p.Compare(p2) = %d", c)
 10423  		t.Errorf("p2.Compare(p) = %d", c2)
 10424  		t.Errorf("p = %#v", p)
 10425  		t.Errorf("p2 = %#v", p2)
 10426  	}
 10427  }
 10428  func TestThetestDescription(t *testing.T) {
 10429  	ThetestDescription()
 10430  }
 10431  func TestNidOptNativeVerboseEqual(t *testing.T) {
 10432  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10433  	p := NewPopulatedNidOptNative(popr, false)
 10434  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10435  	if err != nil {
 10436  		panic(err)
 10437  	}
 10438  	msg := &NidOptNative{}
 10439  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10440  		panic(err)
 10441  	}
 10442  	if err := p.VerboseEqual(msg); err != nil {
 10443  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10444  	}
 10445  }
 10446  func TestNinOptNativeVerboseEqual(t *testing.T) {
 10447  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10448  	p := NewPopulatedNinOptNative(popr, false)
 10449  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10450  	if err != nil {
 10451  		panic(err)
 10452  	}
 10453  	msg := &NinOptNative{}
 10454  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10455  		panic(err)
 10456  	}
 10457  	if err := p.VerboseEqual(msg); err != nil {
 10458  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10459  	}
 10460  }
 10461  func TestNidRepNativeVerboseEqual(t *testing.T) {
 10462  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10463  	p := NewPopulatedNidRepNative(popr, false)
 10464  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10465  	if err != nil {
 10466  		panic(err)
 10467  	}
 10468  	msg := &NidRepNative{}
 10469  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10470  		panic(err)
 10471  	}
 10472  	if err := p.VerboseEqual(msg); err != nil {
 10473  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10474  	}
 10475  }
 10476  func TestNinRepNativeVerboseEqual(t *testing.T) {
 10477  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10478  	p := NewPopulatedNinRepNative(popr, false)
 10479  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10480  	if err != nil {
 10481  		panic(err)
 10482  	}
 10483  	msg := &NinRepNative{}
 10484  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10485  		panic(err)
 10486  	}
 10487  	if err := p.VerboseEqual(msg); err != nil {
 10488  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10489  	}
 10490  }
 10491  func TestNidRepPackedNativeVerboseEqual(t *testing.T) {
 10492  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10493  	p := NewPopulatedNidRepPackedNative(popr, false)
 10494  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10495  	if err != nil {
 10496  		panic(err)
 10497  	}
 10498  	msg := &NidRepPackedNative{}
 10499  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10500  		panic(err)
 10501  	}
 10502  	if err := p.VerboseEqual(msg); err != nil {
 10503  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10504  	}
 10505  }
 10506  func TestNinRepPackedNativeVerboseEqual(t *testing.T) {
 10507  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10508  	p := NewPopulatedNinRepPackedNative(popr, false)
 10509  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10510  	if err != nil {
 10511  		panic(err)
 10512  	}
 10513  	msg := &NinRepPackedNative{}
 10514  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10515  		panic(err)
 10516  	}
 10517  	if err := p.VerboseEqual(msg); err != nil {
 10518  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10519  	}
 10520  }
 10521  func TestNidOptStructVerboseEqual(t *testing.T) {
 10522  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10523  	p := NewPopulatedNidOptStruct(popr, false)
 10524  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10525  	if err != nil {
 10526  		panic(err)
 10527  	}
 10528  	msg := &NidOptStruct{}
 10529  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10530  		panic(err)
 10531  	}
 10532  	if err := p.VerboseEqual(msg); err != nil {
 10533  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10534  	}
 10535  }
 10536  func TestNinOptStructVerboseEqual(t *testing.T) {
 10537  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10538  	p := NewPopulatedNinOptStruct(popr, false)
 10539  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10540  	if err != nil {
 10541  		panic(err)
 10542  	}
 10543  	msg := &NinOptStruct{}
 10544  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10545  		panic(err)
 10546  	}
 10547  	if err := p.VerboseEqual(msg); err != nil {
 10548  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10549  	}
 10550  }
 10551  func TestNidRepStructVerboseEqual(t *testing.T) {
 10552  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10553  	p := NewPopulatedNidRepStruct(popr, false)
 10554  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10555  	if err != nil {
 10556  		panic(err)
 10557  	}
 10558  	msg := &NidRepStruct{}
 10559  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10560  		panic(err)
 10561  	}
 10562  	if err := p.VerboseEqual(msg); err != nil {
 10563  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10564  	}
 10565  }
 10566  func TestNinRepStructVerboseEqual(t *testing.T) {
 10567  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10568  	p := NewPopulatedNinRepStruct(popr, false)
 10569  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10570  	if err != nil {
 10571  		panic(err)
 10572  	}
 10573  	msg := &NinRepStruct{}
 10574  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10575  		panic(err)
 10576  	}
 10577  	if err := p.VerboseEqual(msg); err != nil {
 10578  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10579  	}
 10580  }
 10581  func TestNidEmbeddedStructVerboseEqual(t *testing.T) {
 10582  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10583  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 10584  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10585  	if err != nil {
 10586  		panic(err)
 10587  	}
 10588  	msg := &NidEmbeddedStruct{}
 10589  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10590  		panic(err)
 10591  	}
 10592  	if err := p.VerboseEqual(msg); err != nil {
 10593  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10594  	}
 10595  }
 10596  func TestNinEmbeddedStructVerboseEqual(t *testing.T) {
 10597  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10598  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 10599  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10600  	if err != nil {
 10601  		panic(err)
 10602  	}
 10603  	msg := &NinEmbeddedStruct{}
 10604  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10605  		panic(err)
 10606  	}
 10607  	if err := p.VerboseEqual(msg); err != nil {
 10608  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10609  	}
 10610  }
 10611  func TestNidNestedStructVerboseEqual(t *testing.T) {
 10612  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10613  	p := NewPopulatedNidNestedStruct(popr, false)
 10614  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10615  	if err != nil {
 10616  		panic(err)
 10617  	}
 10618  	msg := &NidNestedStruct{}
 10619  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10620  		panic(err)
 10621  	}
 10622  	if err := p.VerboseEqual(msg); err != nil {
 10623  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10624  	}
 10625  }
 10626  func TestNinNestedStructVerboseEqual(t *testing.T) {
 10627  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10628  	p := NewPopulatedNinNestedStruct(popr, false)
 10629  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10630  	if err != nil {
 10631  		panic(err)
 10632  	}
 10633  	msg := &NinNestedStruct{}
 10634  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10635  		panic(err)
 10636  	}
 10637  	if err := p.VerboseEqual(msg); err != nil {
 10638  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10639  	}
 10640  }
 10641  func TestNidOptCustomVerboseEqual(t *testing.T) {
 10642  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10643  	p := NewPopulatedNidOptCustom(popr, false)
 10644  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10645  	if err != nil {
 10646  		panic(err)
 10647  	}
 10648  	msg := &NidOptCustom{}
 10649  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10650  		panic(err)
 10651  	}
 10652  	if err := p.VerboseEqual(msg); err != nil {
 10653  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10654  	}
 10655  }
 10656  func TestCustomDashVerboseEqual(t *testing.T) {
 10657  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10658  	p := NewPopulatedCustomDash(popr, false)
 10659  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10660  	if err != nil {
 10661  		panic(err)
 10662  	}
 10663  	msg := &CustomDash{}
 10664  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10665  		panic(err)
 10666  	}
 10667  	if err := p.VerboseEqual(msg); err != nil {
 10668  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10669  	}
 10670  }
 10671  func TestNinOptCustomVerboseEqual(t *testing.T) {
 10672  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10673  	p := NewPopulatedNinOptCustom(popr, false)
 10674  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10675  	if err != nil {
 10676  		panic(err)
 10677  	}
 10678  	msg := &NinOptCustom{}
 10679  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10680  		panic(err)
 10681  	}
 10682  	if err := p.VerboseEqual(msg); err != nil {
 10683  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10684  	}
 10685  }
 10686  func TestNidRepCustomVerboseEqual(t *testing.T) {
 10687  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10688  	p := NewPopulatedNidRepCustom(popr, false)
 10689  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10690  	if err != nil {
 10691  		panic(err)
 10692  	}
 10693  	msg := &NidRepCustom{}
 10694  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10695  		panic(err)
 10696  	}
 10697  	if err := p.VerboseEqual(msg); err != nil {
 10698  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10699  	}
 10700  }
 10701  func TestNinRepCustomVerboseEqual(t *testing.T) {
 10702  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10703  	p := NewPopulatedNinRepCustom(popr, false)
 10704  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10705  	if err != nil {
 10706  		panic(err)
 10707  	}
 10708  	msg := &NinRepCustom{}
 10709  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10710  		panic(err)
 10711  	}
 10712  	if err := p.VerboseEqual(msg); err != nil {
 10713  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10714  	}
 10715  }
 10716  func TestNinOptNativeUnionVerboseEqual(t *testing.T) {
 10717  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10718  	p := NewPopulatedNinOptNativeUnion(popr, false)
 10719  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10720  	if err != nil {
 10721  		panic(err)
 10722  	}
 10723  	msg := &NinOptNativeUnion{}
 10724  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10725  		panic(err)
 10726  	}
 10727  	if err := p.VerboseEqual(msg); err != nil {
 10728  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10729  	}
 10730  }
 10731  func TestNinOptStructUnionVerboseEqual(t *testing.T) {
 10732  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10733  	p := NewPopulatedNinOptStructUnion(popr, false)
 10734  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10735  	if err != nil {
 10736  		panic(err)
 10737  	}
 10738  	msg := &NinOptStructUnion{}
 10739  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10740  		panic(err)
 10741  	}
 10742  	if err := p.VerboseEqual(msg); err != nil {
 10743  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10744  	}
 10745  }
 10746  func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
 10747  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10748  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 10749  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10750  	if err != nil {
 10751  		panic(err)
 10752  	}
 10753  	msg := &NinEmbeddedStructUnion{}
 10754  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10755  		panic(err)
 10756  	}
 10757  	if err := p.VerboseEqual(msg); err != nil {
 10758  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10759  	}
 10760  }
 10761  func TestNinNestedStructUnionVerboseEqual(t *testing.T) {
 10762  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10763  	p := NewPopulatedNinNestedStructUnion(popr, false)
 10764  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10765  	if err != nil {
 10766  		panic(err)
 10767  	}
 10768  	msg := &NinNestedStructUnion{}
 10769  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10770  		panic(err)
 10771  	}
 10772  	if err := p.VerboseEqual(msg); err != nil {
 10773  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10774  	}
 10775  }
 10776  func TestTreeVerboseEqual(t *testing.T) {
 10777  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10778  	p := NewPopulatedTree(popr, false)
 10779  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10780  	if err != nil {
 10781  		panic(err)
 10782  	}
 10783  	msg := &Tree{}
 10784  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10785  		panic(err)
 10786  	}
 10787  	if err := p.VerboseEqual(msg); err != nil {
 10788  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10789  	}
 10790  }
 10791  func TestOrBranchVerboseEqual(t *testing.T) {
 10792  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10793  	p := NewPopulatedOrBranch(popr, false)
 10794  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10795  	if err != nil {
 10796  		panic(err)
 10797  	}
 10798  	msg := &OrBranch{}
 10799  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10800  		panic(err)
 10801  	}
 10802  	if err := p.VerboseEqual(msg); err != nil {
 10803  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10804  	}
 10805  }
 10806  func TestAndBranchVerboseEqual(t *testing.T) {
 10807  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10808  	p := NewPopulatedAndBranch(popr, false)
 10809  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10810  	if err != nil {
 10811  		panic(err)
 10812  	}
 10813  	msg := &AndBranch{}
 10814  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10815  		panic(err)
 10816  	}
 10817  	if err := p.VerboseEqual(msg); err != nil {
 10818  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10819  	}
 10820  }
 10821  func TestLeafVerboseEqual(t *testing.T) {
 10822  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10823  	p := NewPopulatedLeaf(popr, false)
 10824  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10825  	if err != nil {
 10826  		panic(err)
 10827  	}
 10828  	msg := &Leaf{}
 10829  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10830  		panic(err)
 10831  	}
 10832  	if err := p.VerboseEqual(msg); err != nil {
 10833  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10834  	}
 10835  }
 10836  func TestDeepTreeVerboseEqual(t *testing.T) {
 10837  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10838  	p := NewPopulatedDeepTree(popr, false)
 10839  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10840  	if err != nil {
 10841  		panic(err)
 10842  	}
 10843  	msg := &DeepTree{}
 10844  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10845  		panic(err)
 10846  	}
 10847  	if err := p.VerboseEqual(msg); err != nil {
 10848  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10849  	}
 10850  }
 10851  func TestADeepBranchVerboseEqual(t *testing.T) {
 10852  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10853  	p := NewPopulatedADeepBranch(popr, false)
 10854  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10855  	if err != nil {
 10856  		panic(err)
 10857  	}
 10858  	msg := &ADeepBranch{}
 10859  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10860  		panic(err)
 10861  	}
 10862  	if err := p.VerboseEqual(msg); err != nil {
 10863  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10864  	}
 10865  }
 10866  func TestAndDeepBranchVerboseEqual(t *testing.T) {
 10867  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10868  	p := NewPopulatedAndDeepBranch(popr, false)
 10869  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10870  	if err != nil {
 10871  		panic(err)
 10872  	}
 10873  	msg := &AndDeepBranch{}
 10874  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10875  		panic(err)
 10876  	}
 10877  	if err := p.VerboseEqual(msg); err != nil {
 10878  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10879  	}
 10880  }
 10881  func TestDeepLeafVerboseEqual(t *testing.T) {
 10882  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10883  	p := NewPopulatedDeepLeaf(popr, false)
 10884  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10885  	if err != nil {
 10886  		panic(err)
 10887  	}
 10888  	msg := &DeepLeaf{}
 10889  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10890  		panic(err)
 10891  	}
 10892  	if err := p.VerboseEqual(msg); err != nil {
 10893  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10894  	}
 10895  }
 10896  func TestNilVerboseEqual(t *testing.T) {
 10897  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10898  	p := NewPopulatedNil(popr, false)
 10899  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10900  	if err != nil {
 10901  		panic(err)
 10902  	}
 10903  	msg := &Nil{}
 10904  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10905  		panic(err)
 10906  	}
 10907  	if err := p.VerboseEqual(msg); err != nil {
 10908  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10909  	}
 10910  }
 10911  func TestNidOptEnumVerboseEqual(t *testing.T) {
 10912  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10913  	p := NewPopulatedNidOptEnum(popr, false)
 10914  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10915  	if err != nil {
 10916  		panic(err)
 10917  	}
 10918  	msg := &NidOptEnum{}
 10919  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10920  		panic(err)
 10921  	}
 10922  	if err := p.VerboseEqual(msg); err != nil {
 10923  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10924  	}
 10925  }
 10926  func TestNinOptEnumVerboseEqual(t *testing.T) {
 10927  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10928  	p := NewPopulatedNinOptEnum(popr, false)
 10929  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10930  	if err != nil {
 10931  		panic(err)
 10932  	}
 10933  	msg := &NinOptEnum{}
 10934  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10935  		panic(err)
 10936  	}
 10937  	if err := p.VerboseEqual(msg); err != nil {
 10938  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10939  	}
 10940  }
 10941  func TestNidRepEnumVerboseEqual(t *testing.T) {
 10942  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10943  	p := NewPopulatedNidRepEnum(popr, false)
 10944  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10945  	if err != nil {
 10946  		panic(err)
 10947  	}
 10948  	msg := &NidRepEnum{}
 10949  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10950  		panic(err)
 10951  	}
 10952  	if err := p.VerboseEqual(msg); err != nil {
 10953  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10954  	}
 10955  }
 10956  func TestNinRepEnumVerboseEqual(t *testing.T) {
 10957  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10958  	p := NewPopulatedNinRepEnum(popr, false)
 10959  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10960  	if err != nil {
 10961  		panic(err)
 10962  	}
 10963  	msg := &NinRepEnum{}
 10964  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10965  		panic(err)
 10966  	}
 10967  	if err := p.VerboseEqual(msg); err != nil {
 10968  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10969  	}
 10970  }
 10971  func TestNinOptEnumDefaultVerboseEqual(t *testing.T) {
 10972  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10973  	p := NewPopulatedNinOptEnumDefault(popr, false)
 10974  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10975  	if err != nil {
 10976  		panic(err)
 10977  	}
 10978  	msg := &NinOptEnumDefault{}
 10979  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10980  		panic(err)
 10981  	}
 10982  	if err := p.VerboseEqual(msg); err != nil {
 10983  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10984  	}
 10985  }
 10986  func TestAnotherNinOptEnumVerboseEqual(t *testing.T) {
 10987  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 10988  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 10989  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 10990  	if err != nil {
 10991  		panic(err)
 10992  	}
 10993  	msg := &AnotherNinOptEnum{}
 10994  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 10995  		panic(err)
 10996  	}
 10997  	if err := p.VerboseEqual(msg); err != nil {
 10998  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 10999  	}
 11000  }
 11001  func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) {
 11002  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11003  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 11004  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11005  	if err != nil {
 11006  		panic(err)
 11007  	}
 11008  	msg := &AnotherNinOptEnumDefault{}
 11009  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11010  		panic(err)
 11011  	}
 11012  	if err := p.VerboseEqual(msg); err != nil {
 11013  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11014  	}
 11015  }
 11016  func TestTimerVerboseEqual(t *testing.T) {
 11017  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11018  	p := NewPopulatedTimer(popr, false)
 11019  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11020  	if err != nil {
 11021  		panic(err)
 11022  	}
 11023  	msg := &Timer{}
 11024  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11025  		panic(err)
 11026  	}
 11027  	if err := p.VerboseEqual(msg); err != nil {
 11028  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11029  	}
 11030  }
 11031  func TestMyExtendableVerboseEqual(t *testing.T) {
 11032  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11033  	p := NewPopulatedMyExtendable(popr, false)
 11034  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11035  	if err != nil {
 11036  		panic(err)
 11037  	}
 11038  	msg := &MyExtendable{}
 11039  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11040  		panic(err)
 11041  	}
 11042  	if err := p.VerboseEqual(msg); err != nil {
 11043  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11044  	}
 11045  }
 11046  func TestOtherExtenableVerboseEqual(t *testing.T) {
 11047  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11048  	p := NewPopulatedOtherExtenable(popr, false)
 11049  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11050  	if err != nil {
 11051  		panic(err)
 11052  	}
 11053  	msg := &OtherExtenable{}
 11054  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11055  		panic(err)
 11056  	}
 11057  	if err := p.VerboseEqual(msg); err != nil {
 11058  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11059  	}
 11060  }
 11061  func TestNestedDefinitionVerboseEqual(t *testing.T) {
 11062  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11063  	p := NewPopulatedNestedDefinition(popr, false)
 11064  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11065  	if err != nil {
 11066  		panic(err)
 11067  	}
 11068  	msg := &NestedDefinition{}
 11069  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11070  		panic(err)
 11071  	}
 11072  	if err := p.VerboseEqual(msg); err != nil {
 11073  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11074  	}
 11075  }
 11076  func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) {
 11077  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11078  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 11079  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11080  	if err != nil {
 11081  		panic(err)
 11082  	}
 11083  	msg := &NestedDefinition_NestedMessage{}
 11084  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11085  		panic(err)
 11086  	}
 11087  	if err := p.VerboseEqual(msg); err != nil {
 11088  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11089  	}
 11090  }
 11091  func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) {
 11092  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11093  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 11094  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11095  	if err != nil {
 11096  		panic(err)
 11097  	}
 11098  	msg := &NestedDefinition_NestedMessage_NestedNestedMsg{}
 11099  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11100  		panic(err)
 11101  	}
 11102  	if err := p.VerboseEqual(msg); err != nil {
 11103  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11104  	}
 11105  }
 11106  func TestNestedScopeVerboseEqual(t *testing.T) {
 11107  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11108  	p := NewPopulatedNestedScope(popr, false)
 11109  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11110  	if err != nil {
 11111  		panic(err)
 11112  	}
 11113  	msg := &NestedScope{}
 11114  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11115  		panic(err)
 11116  	}
 11117  	if err := p.VerboseEqual(msg); err != nil {
 11118  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11119  	}
 11120  }
 11121  func TestNinOptNativeDefaultVerboseEqual(t *testing.T) {
 11122  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11123  	p := NewPopulatedNinOptNativeDefault(popr, false)
 11124  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11125  	if err != nil {
 11126  		panic(err)
 11127  	}
 11128  	msg := &NinOptNativeDefault{}
 11129  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11130  		panic(err)
 11131  	}
 11132  	if err := p.VerboseEqual(msg); err != nil {
 11133  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11134  	}
 11135  }
 11136  func TestCustomContainerVerboseEqual(t *testing.T) {
 11137  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11138  	p := NewPopulatedCustomContainer(popr, false)
 11139  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11140  	if err != nil {
 11141  		panic(err)
 11142  	}
 11143  	msg := &CustomContainer{}
 11144  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11145  		panic(err)
 11146  	}
 11147  	if err := p.VerboseEqual(msg); err != nil {
 11148  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11149  	}
 11150  }
 11151  func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) {
 11152  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11153  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 11154  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11155  	if err != nil {
 11156  		panic(err)
 11157  	}
 11158  	msg := &CustomNameNidOptNative{}
 11159  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11160  		panic(err)
 11161  	}
 11162  	if err := p.VerboseEqual(msg); err != nil {
 11163  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11164  	}
 11165  }
 11166  func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) {
 11167  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11168  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 11169  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11170  	if err != nil {
 11171  		panic(err)
 11172  	}
 11173  	msg := &CustomNameNinOptNative{}
 11174  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11175  		panic(err)
 11176  	}
 11177  	if err := p.VerboseEqual(msg); err != nil {
 11178  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11179  	}
 11180  }
 11181  func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) {
 11182  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11183  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 11184  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11185  	if err != nil {
 11186  		panic(err)
 11187  	}
 11188  	msg := &CustomNameNinRepNative{}
 11189  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11190  		panic(err)
 11191  	}
 11192  	if err := p.VerboseEqual(msg); err != nil {
 11193  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11194  	}
 11195  }
 11196  func TestCustomNameNinStructVerboseEqual(t *testing.T) {
 11197  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11198  	p := NewPopulatedCustomNameNinStruct(popr, false)
 11199  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11200  	if err != nil {
 11201  		panic(err)
 11202  	}
 11203  	msg := &CustomNameNinStruct{}
 11204  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11205  		panic(err)
 11206  	}
 11207  	if err := p.VerboseEqual(msg); err != nil {
 11208  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11209  	}
 11210  }
 11211  func TestCustomNameCustomTypeVerboseEqual(t *testing.T) {
 11212  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11213  	p := NewPopulatedCustomNameCustomType(popr, false)
 11214  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11215  	if err != nil {
 11216  		panic(err)
 11217  	}
 11218  	msg := &CustomNameCustomType{}
 11219  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11220  		panic(err)
 11221  	}
 11222  	if err := p.VerboseEqual(msg); err != nil {
 11223  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11224  	}
 11225  }
 11226  func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) {
 11227  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11228  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 11229  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11230  	if err != nil {
 11231  		panic(err)
 11232  	}
 11233  	msg := &CustomNameNinEmbeddedStructUnion{}
 11234  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11235  		panic(err)
 11236  	}
 11237  	if err := p.VerboseEqual(msg); err != nil {
 11238  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11239  	}
 11240  }
 11241  func TestCustomNameEnumVerboseEqual(t *testing.T) {
 11242  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11243  	p := NewPopulatedCustomNameEnum(popr, false)
 11244  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11245  	if err != nil {
 11246  		panic(err)
 11247  	}
 11248  	msg := &CustomNameEnum{}
 11249  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11250  		panic(err)
 11251  	}
 11252  	if err := p.VerboseEqual(msg); err != nil {
 11253  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11254  	}
 11255  }
 11256  func TestNoExtensionsMapVerboseEqual(t *testing.T) {
 11257  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11258  	p := NewPopulatedNoExtensionsMap(popr, false)
 11259  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11260  	if err != nil {
 11261  		panic(err)
 11262  	}
 11263  	msg := &NoExtensionsMap{}
 11264  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11265  		panic(err)
 11266  	}
 11267  	if err := p.VerboseEqual(msg); err != nil {
 11268  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11269  	}
 11270  }
 11271  func TestUnrecognizedVerboseEqual(t *testing.T) {
 11272  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11273  	p := NewPopulatedUnrecognized(popr, false)
 11274  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11275  	if err != nil {
 11276  		panic(err)
 11277  	}
 11278  	msg := &Unrecognized{}
 11279  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11280  		panic(err)
 11281  	}
 11282  	if err := p.VerboseEqual(msg); err != nil {
 11283  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11284  	}
 11285  }
 11286  func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) {
 11287  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11288  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 11289  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11290  	if err != nil {
 11291  		panic(err)
 11292  	}
 11293  	msg := &UnrecognizedWithInner{}
 11294  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11295  		panic(err)
 11296  	}
 11297  	if err := p.VerboseEqual(msg); err != nil {
 11298  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11299  	}
 11300  }
 11301  func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) {
 11302  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11303  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 11304  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11305  	if err != nil {
 11306  		panic(err)
 11307  	}
 11308  	msg := &UnrecognizedWithInner_Inner{}
 11309  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11310  		panic(err)
 11311  	}
 11312  	if err := p.VerboseEqual(msg); err != nil {
 11313  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11314  	}
 11315  }
 11316  func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) {
 11317  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11318  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 11319  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11320  	if err != nil {
 11321  		panic(err)
 11322  	}
 11323  	msg := &UnrecognizedWithEmbed{}
 11324  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11325  		panic(err)
 11326  	}
 11327  	if err := p.VerboseEqual(msg); err != nil {
 11328  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11329  	}
 11330  }
 11331  func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) {
 11332  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11333  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 11334  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11335  	if err != nil {
 11336  		panic(err)
 11337  	}
 11338  	msg := &UnrecognizedWithEmbed_Embedded{}
 11339  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11340  		panic(err)
 11341  	}
 11342  	if err := p.VerboseEqual(msg); err != nil {
 11343  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11344  	}
 11345  }
 11346  func TestNodeVerboseEqual(t *testing.T) {
 11347  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11348  	p := NewPopulatedNode(popr, false)
 11349  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11350  	if err != nil {
 11351  		panic(err)
 11352  	}
 11353  	msg := &Node{}
 11354  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11355  		panic(err)
 11356  	}
 11357  	if err := p.VerboseEqual(msg); err != nil {
 11358  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11359  	}
 11360  }
 11361  func TestNonByteCustomTypeVerboseEqual(t *testing.T) {
 11362  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11363  	p := NewPopulatedNonByteCustomType(popr, false)
 11364  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11365  	if err != nil {
 11366  		panic(err)
 11367  	}
 11368  	msg := &NonByteCustomType{}
 11369  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11370  		panic(err)
 11371  	}
 11372  	if err := p.VerboseEqual(msg); err != nil {
 11373  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11374  	}
 11375  }
 11376  func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) {
 11377  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11378  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 11379  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11380  	if err != nil {
 11381  		panic(err)
 11382  	}
 11383  	msg := &NidOptNonByteCustomType{}
 11384  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11385  		panic(err)
 11386  	}
 11387  	if err := p.VerboseEqual(msg); err != nil {
 11388  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11389  	}
 11390  }
 11391  func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) {
 11392  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11393  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 11394  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11395  	if err != nil {
 11396  		panic(err)
 11397  	}
 11398  	msg := &NinOptNonByteCustomType{}
 11399  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11400  		panic(err)
 11401  	}
 11402  	if err := p.VerboseEqual(msg); err != nil {
 11403  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11404  	}
 11405  }
 11406  func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) {
 11407  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11408  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 11409  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11410  	if err != nil {
 11411  		panic(err)
 11412  	}
 11413  	msg := &NidRepNonByteCustomType{}
 11414  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11415  		panic(err)
 11416  	}
 11417  	if err := p.VerboseEqual(msg); err != nil {
 11418  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11419  	}
 11420  }
 11421  func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) {
 11422  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11423  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 11424  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11425  	if err != nil {
 11426  		panic(err)
 11427  	}
 11428  	msg := &NinRepNonByteCustomType{}
 11429  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11430  		panic(err)
 11431  	}
 11432  	if err := p.VerboseEqual(msg); err != nil {
 11433  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11434  	}
 11435  }
 11436  func TestProtoTypeVerboseEqual(t *testing.T) {
 11437  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11438  	p := NewPopulatedProtoType(popr, false)
 11439  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 11440  	if err != nil {
 11441  		panic(err)
 11442  	}
 11443  	msg := &ProtoType{}
 11444  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 11445  		panic(err)
 11446  	}
 11447  	if err := p.VerboseEqual(msg); err != nil {
 11448  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
 11449  	}
 11450  }
 11451  func TestNidOptNativeFace(t *testing.T) {
 11452  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11453  	p := NewPopulatedNidOptNative(popr, true)
 11454  	msg := p.TestProto()
 11455  	if !p.Equal(msg) {
 11456  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11457  	}
 11458  }
 11459  func TestNinOptNativeFace(t *testing.T) {
 11460  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11461  	p := NewPopulatedNinOptNative(popr, true)
 11462  	msg := p.TestProto()
 11463  	if !p.Equal(msg) {
 11464  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11465  	}
 11466  }
 11467  func TestNidRepNativeFace(t *testing.T) {
 11468  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11469  	p := NewPopulatedNidRepNative(popr, true)
 11470  	msg := p.TestProto()
 11471  	if !p.Equal(msg) {
 11472  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11473  	}
 11474  }
 11475  func TestNinRepNativeFace(t *testing.T) {
 11476  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11477  	p := NewPopulatedNinRepNative(popr, true)
 11478  	msg := p.TestProto()
 11479  	if !p.Equal(msg) {
 11480  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11481  	}
 11482  }
 11483  func TestNidRepPackedNativeFace(t *testing.T) {
 11484  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11485  	p := NewPopulatedNidRepPackedNative(popr, true)
 11486  	msg := p.TestProto()
 11487  	if !p.Equal(msg) {
 11488  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11489  	}
 11490  }
 11491  func TestNinRepPackedNativeFace(t *testing.T) {
 11492  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11493  	p := NewPopulatedNinRepPackedNative(popr, true)
 11494  	msg := p.TestProto()
 11495  	if !p.Equal(msg) {
 11496  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11497  	}
 11498  }
 11499  func TestNidOptStructFace(t *testing.T) {
 11500  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11501  	p := NewPopulatedNidOptStruct(popr, true)
 11502  	msg := p.TestProto()
 11503  	if !p.Equal(msg) {
 11504  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11505  	}
 11506  }
 11507  func TestNinOptStructFace(t *testing.T) {
 11508  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11509  	p := NewPopulatedNinOptStruct(popr, true)
 11510  	msg := p.TestProto()
 11511  	if !p.Equal(msg) {
 11512  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11513  	}
 11514  }
 11515  func TestNidRepStructFace(t *testing.T) {
 11516  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11517  	p := NewPopulatedNidRepStruct(popr, true)
 11518  	msg := p.TestProto()
 11519  	if !p.Equal(msg) {
 11520  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11521  	}
 11522  }
 11523  func TestNinRepStructFace(t *testing.T) {
 11524  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11525  	p := NewPopulatedNinRepStruct(popr, true)
 11526  	msg := p.TestProto()
 11527  	if !p.Equal(msg) {
 11528  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11529  	}
 11530  }
 11531  func TestNidEmbeddedStructFace(t *testing.T) {
 11532  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11533  	p := NewPopulatedNidEmbeddedStruct(popr, true)
 11534  	msg := p.TestProto()
 11535  	if !p.Equal(msg) {
 11536  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11537  	}
 11538  }
 11539  func TestNinEmbeddedStructFace(t *testing.T) {
 11540  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11541  	p := NewPopulatedNinEmbeddedStruct(popr, true)
 11542  	msg := p.TestProto()
 11543  	if !p.Equal(msg) {
 11544  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11545  	}
 11546  }
 11547  func TestNidNestedStructFace(t *testing.T) {
 11548  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11549  	p := NewPopulatedNidNestedStruct(popr, true)
 11550  	msg := p.TestProto()
 11551  	if !p.Equal(msg) {
 11552  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11553  	}
 11554  }
 11555  func TestNinNestedStructFace(t *testing.T) {
 11556  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11557  	p := NewPopulatedNinNestedStruct(popr, true)
 11558  	msg := p.TestProto()
 11559  	if !p.Equal(msg) {
 11560  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11561  	}
 11562  }
 11563  func TestNidOptCustomFace(t *testing.T) {
 11564  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11565  	p := NewPopulatedNidOptCustom(popr, true)
 11566  	msg := p.TestProto()
 11567  	if !p.Equal(msg) {
 11568  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11569  	}
 11570  }
 11571  func TestCustomDashFace(t *testing.T) {
 11572  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11573  	p := NewPopulatedCustomDash(popr, true)
 11574  	msg := p.TestProto()
 11575  	if !p.Equal(msg) {
 11576  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11577  	}
 11578  }
 11579  func TestNinOptCustomFace(t *testing.T) {
 11580  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11581  	p := NewPopulatedNinOptCustom(popr, true)
 11582  	msg := p.TestProto()
 11583  	if !p.Equal(msg) {
 11584  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11585  	}
 11586  }
 11587  func TestNidRepCustomFace(t *testing.T) {
 11588  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11589  	p := NewPopulatedNidRepCustom(popr, true)
 11590  	msg := p.TestProto()
 11591  	if !p.Equal(msg) {
 11592  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11593  	}
 11594  }
 11595  func TestNinRepCustomFace(t *testing.T) {
 11596  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11597  	p := NewPopulatedNinRepCustom(popr, true)
 11598  	msg := p.TestProto()
 11599  	if !p.Equal(msg) {
 11600  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11601  	}
 11602  }
 11603  func TestNinOptNativeUnionFace(t *testing.T) {
 11604  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11605  	p := NewPopulatedNinOptNativeUnion(popr, true)
 11606  	msg := p.TestProto()
 11607  	if !p.Equal(msg) {
 11608  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11609  	}
 11610  }
 11611  func TestNinOptStructUnionFace(t *testing.T) {
 11612  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11613  	p := NewPopulatedNinOptStructUnion(popr, true)
 11614  	msg := p.TestProto()
 11615  	if !p.Equal(msg) {
 11616  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11617  	}
 11618  }
 11619  func TestNinEmbeddedStructUnionFace(t *testing.T) {
 11620  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11621  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 11622  	msg := p.TestProto()
 11623  	if !p.Equal(msg) {
 11624  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11625  	}
 11626  }
 11627  func TestNinNestedStructUnionFace(t *testing.T) {
 11628  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11629  	p := NewPopulatedNinNestedStructUnion(popr, true)
 11630  	msg := p.TestProto()
 11631  	if !p.Equal(msg) {
 11632  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11633  	}
 11634  }
 11635  func TestTreeFace(t *testing.T) {
 11636  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11637  	p := NewPopulatedTree(popr, true)
 11638  	msg := p.TestProto()
 11639  	if !p.Equal(msg) {
 11640  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11641  	}
 11642  }
 11643  func TestOrBranchFace(t *testing.T) {
 11644  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11645  	p := NewPopulatedOrBranch(popr, true)
 11646  	msg := p.TestProto()
 11647  	if !p.Equal(msg) {
 11648  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11649  	}
 11650  }
 11651  func TestAndBranchFace(t *testing.T) {
 11652  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11653  	p := NewPopulatedAndBranch(popr, true)
 11654  	msg := p.TestProto()
 11655  	if !p.Equal(msg) {
 11656  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11657  	}
 11658  }
 11659  func TestLeafFace(t *testing.T) {
 11660  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11661  	p := NewPopulatedLeaf(popr, true)
 11662  	msg := p.TestProto()
 11663  	if !p.Equal(msg) {
 11664  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11665  	}
 11666  }
 11667  func TestDeepTreeFace(t *testing.T) {
 11668  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11669  	p := NewPopulatedDeepTree(popr, true)
 11670  	msg := p.TestProto()
 11671  	if !p.Equal(msg) {
 11672  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11673  	}
 11674  }
 11675  func TestADeepBranchFace(t *testing.T) {
 11676  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11677  	p := NewPopulatedADeepBranch(popr, true)
 11678  	msg := p.TestProto()
 11679  	if !p.Equal(msg) {
 11680  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11681  	}
 11682  }
 11683  func TestAndDeepBranchFace(t *testing.T) {
 11684  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11685  	p := NewPopulatedAndDeepBranch(popr, true)
 11686  	msg := p.TestProto()
 11687  	if !p.Equal(msg) {
 11688  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11689  	}
 11690  }
 11691  func TestDeepLeafFace(t *testing.T) {
 11692  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11693  	p := NewPopulatedDeepLeaf(popr, true)
 11694  	msg := p.TestProto()
 11695  	if !p.Equal(msg) {
 11696  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11697  	}
 11698  }
 11699  func TestNilFace(t *testing.T) {
 11700  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11701  	p := NewPopulatedNil(popr, true)
 11702  	msg := p.TestProto()
 11703  	if !p.Equal(msg) {
 11704  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11705  	}
 11706  }
 11707  func TestNidOptEnumFace(t *testing.T) {
 11708  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11709  	p := NewPopulatedNidOptEnum(popr, true)
 11710  	msg := p.TestProto()
 11711  	if !p.Equal(msg) {
 11712  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11713  	}
 11714  }
 11715  func TestNinOptEnumFace(t *testing.T) {
 11716  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11717  	p := NewPopulatedNinOptEnum(popr, true)
 11718  	msg := p.TestProto()
 11719  	if !p.Equal(msg) {
 11720  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11721  	}
 11722  }
 11723  func TestNidRepEnumFace(t *testing.T) {
 11724  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11725  	p := NewPopulatedNidRepEnum(popr, true)
 11726  	msg := p.TestProto()
 11727  	if !p.Equal(msg) {
 11728  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11729  	}
 11730  }
 11731  func TestNinRepEnumFace(t *testing.T) {
 11732  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11733  	p := NewPopulatedNinRepEnum(popr, true)
 11734  	msg := p.TestProto()
 11735  	if !p.Equal(msg) {
 11736  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11737  	}
 11738  }
 11739  func TestAnotherNinOptEnumFace(t *testing.T) {
 11740  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11741  	p := NewPopulatedAnotherNinOptEnum(popr, true)
 11742  	msg := p.TestProto()
 11743  	if !p.Equal(msg) {
 11744  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11745  	}
 11746  }
 11747  func TestTimerFace(t *testing.T) {
 11748  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11749  	p := NewPopulatedTimer(popr, true)
 11750  	msg := p.TestProto()
 11751  	if !p.Equal(msg) {
 11752  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11753  	}
 11754  }
 11755  func TestNestedDefinitionFace(t *testing.T) {
 11756  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11757  	p := NewPopulatedNestedDefinition(popr, true)
 11758  	msg := p.TestProto()
 11759  	if !p.Equal(msg) {
 11760  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11761  	}
 11762  }
 11763  func TestNestedDefinition_NestedMessageFace(t *testing.T) {
 11764  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11765  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
 11766  	msg := p.TestProto()
 11767  	if !p.Equal(msg) {
 11768  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11769  	}
 11770  }
 11771  func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) {
 11772  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11773  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
 11774  	msg := p.TestProto()
 11775  	if !p.Equal(msg) {
 11776  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11777  	}
 11778  }
 11779  func TestNestedScopeFace(t *testing.T) {
 11780  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11781  	p := NewPopulatedNestedScope(popr, true)
 11782  	msg := p.TestProto()
 11783  	if !p.Equal(msg) {
 11784  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11785  	}
 11786  }
 11787  func TestCustomContainerFace(t *testing.T) {
 11788  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11789  	p := NewPopulatedCustomContainer(popr, true)
 11790  	msg := p.TestProto()
 11791  	if !p.Equal(msg) {
 11792  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11793  	}
 11794  }
 11795  func TestCustomNameNidOptNativeFace(t *testing.T) {
 11796  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11797  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 11798  	msg := p.TestProto()
 11799  	if !p.Equal(msg) {
 11800  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11801  	}
 11802  }
 11803  func TestCustomNameNinOptNativeFace(t *testing.T) {
 11804  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11805  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 11806  	msg := p.TestProto()
 11807  	if !p.Equal(msg) {
 11808  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11809  	}
 11810  }
 11811  func TestCustomNameNinRepNativeFace(t *testing.T) {
 11812  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11813  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 11814  	msg := p.TestProto()
 11815  	if !p.Equal(msg) {
 11816  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11817  	}
 11818  }
 11819  func TestCustomNameNinStructFace(t *testing.T) {
 11820  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11821  	p := NewPopulatedCustomNameNinStruct(popr, true)
 11822  	msg := p.TestProto()
 11823  	if !p.Equal(msg) {
 11824  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11825  	}
 11826  }
 11827  func TestCustomNameCustomTypeFace(t *testing.T) {
 11828  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11829  	p := NewPopulatedCustomNameCustomType(popr, true)
 11830  	msg := p.TestProto()
 11831  	if !p.Equal(msg) {
 11832  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11833  	}
 11834  }
 11835  func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) {
 11836  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11837  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 11838  	msg := p.TestProto()
 11839  	if !p.Equal(msg) {
 11840  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11841  	}
 11842  }
 11843  func TestCustomNameEnumFace(t *testing.T) {
 11844  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11845  	p := NewPopulatedCustomNameEnum(popr, true)
 11846  	msg := p.TestProto()
 11847  	if !p.Equal(msg) {
 11848  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11849  	}
 11850  }
 11851  func TestUnrecognizedFace(t *testing.T) {
 11852  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11853  	p := NewPopulatedUnrecognized(popr, true)
 11854  	msg := p.TestProto()
 11855  	if !p.Equal(msg) {
 11856  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11857  	}
 11858  }
 11859  func TestUnrecognizedWithInnerFace(t *testing.T) {
 11860  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11861  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 11862  	msg := p.TestProto()
 11863  	if !p.Equal(msg) {
 11864  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11865  	}
 11866  }
 11867  func TestUnrecognizedWithInner_InnerFace(t *testing.T) {
 11868  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11869  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 11870  	msg := p.TestProto()
 11871  	if !p.Equal(msg) {
 11872  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11873  	}
 11874  }
 11875  func TestUnrecognizedWithEmbedFace(t *testing.T) {
 11876  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11877  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 11878  	msg := p.TestProto()
 11879  	if !p.Equal(msg) {
 11880  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11881  	}
 11882  }
 11883  func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) {
 11884  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11885  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 11886  	msg := p.TestProto()
 11887  	if !p.Equal(msg) {
 11888  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11889  	}
 11890  }
 11891  func TestNodeFace(t *testing.T) {
 11892  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11893  	p := NewPopulatedNode(popr, true)
 11894  	msg := p.TestProto()
 11895  	if !p.Equal(msg) {
 11896  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11897  	}
 11898  }
 11899  func TestNonByteCustomTypeFace(t *testing.T) {
 11900  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11901  	p := NewPopulatedNonByteCustomType(popr, true)
 11902  	msg := p.TestProto()
 11903  	if !p.Equal(msg) {
 11904  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11905  	}
 11906  }
 11907  func TestNidOptNonByteCustomTypeFace(t *testing.T) {
 11908  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11909  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 11910  	msg := p.TestProto()
 11911  	if !p.Equal(msg) {
 11912  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11913  	}
 11914  }
 11915  func TestNinOptNonByteCustomTypeFace(t *testing.T) {
 11916  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11917  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 11918  	msg := p.TestProto()
 11919  	if !p.Equal(msg) {
 11920  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11921  	}
 11922  }
 11923  func TestNidRepNonByteCustomTypeFace(t *testing.T) {
 11924  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11925  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 11926  	msg := p.TestProto()
 11927  	if !p.Equal(msg) {
 11928  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11929  	}
 11930  }
 11931  func TestNinRepNonByteCustomTypeFace(t *testing.T) {
 11932  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11933  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 11934  	msg := p.TestProto()
 11935  	if !p.Equal(msg) {
 11936  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11937  	}
 11938  }
 11939  func TestProtoTypeFace(t *testing.T) {
 11940  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11941  	p := NewPopulatedProtoType(popr, true)
 11942  	msg := p.TestProto()
 11943  	if !p.Equal(msg) {
 11944  		t.Fatalf("%#v !Face Equal %#v", msg, p)
 11945  	}
 11946  }
 11947  func TestNidOptNativeGoString(t *testing.T) {
 11948  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11949  	p := NewPopulatedNidOptNative(popr, false)
 11950  	s1 := p.GoString()
 11951  	s2 := fmt.Sprintf("%#v", p)
 11952  	if s1 != s2 {
 11953  		t.Fatalf("GoString want %v got %v", s1, s2)
 11954  	}
 11955  	_, err := go_parser.ParseExpr(s1)
 11956  	if err != nil {
 11957  		t.Fatal(err)
 11958  	}
 11959  }
 11960  func TestNinOptNativeGoString(t *testing.T) {
 11961  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11962  	p := NewPopulatedNinOptNative(popr, false)
 11963  	s1 := p.GoString()
 11964  	s2 := fmt.Sprintf("%#v", p)
 11965  	if s1 != s2 {
 11966  		t.Fatalf("GoString want %v got %v", s1, s2)
 11967  	}
 11968  	_, err := go_parser.ParseExpr(s1)
 11969  	if err != nil {
 11970  		t.Fatal(err)
 11971  	}
 11972  }
 11973  func TestNidRepNativeGoString(t *testing.T) {
 11974  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11975  	p := NewPopulatedNidRepNative(popr, false)
 11976  	s1 := p.GoString()
 11977  	s2 := fmt.Sprintf("%#v", p)
 11978  	if s1 != s2 {
 11979  		t.Fatalf("GoString want %v got %v", s1, s2)
 11980  	}
 11981  	_, err := go_parser.ParseExpr(s1)
 11982  	if err != nil {
 11983  		t.Fatal(err)
 11984  	}
 11985  }
 11986  func TestNinRepNativeGoString(t *testing.T) {
 11987  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 11988  	p := NewPopulatedNinRepNative(popr, false)
 11989  	s1 := p.GoString()
 11990  	s2 := fmt.Sprintf("%#v", p)
 11991  	if s1 != s2 {
 11992  		t.Fatalf("GoString want %v got %v", s1, s2)
 11993  	}
 11994  	_, err := go_parser.ParseExpr(s1)
 11995  	if err != nil {
 11996  		t.Fatal(err)
 11997  	}
 11998  }
 11999  func TestNidRepPackedNativeGoString(t *testing.T) {
 12000  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12001  	p := NewPopulatedNidRepPackedNative(popr, false)
 12002  	s1 := p.GoString()
 12003  	s2 := fmt.Sprintf("%#v", p)
 12004  	if s1 != s2 {
 12005  		t.Fatalf("GoString want %v got %v", s1, s2)
 12006  	}
 12007  	_, err := go_parser.ParseExpr(s1)
 12008  	if err != nil {
 12009  		t.Fatal(err)
 12010  	}
 12011  }
 12012  func TestNinRepPackedNativeGoString(t *testing.T) {
 12013  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12014  	p := NewPopulatedNinRepPackedNative(popr, false)
 12015  	s1 := p.GoString()
 12016  	s2 := fmt.Sprintf("%#v", p)
 12017  	if s1 != s2 {
 12018  		t.Fatalf("GoString want %v got %v", s1, s2)
 12019  	}
 12020  	_, err := go_parser.ParseExpr(s1)
 12021  	if err != nil {
 12022  		t.Fatal(err)
 12023  	}
 12024  }
 12025  func TestNidOptStructGoString(t *testing.T) {
 12026  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12027  	p := NewPopulatedNidOptStruct(popr, false)
 12028  	s1 := p.GoString()
 12029  	s2 := fmt.Sprintf("%#v", p)
 12030  	if s1 != s2 {
 12031  		t.Fatalf("GoString want %v got %v", s1, s2)
 12032  	}
 12033  	_, err := go_parser.ParseExpr(s1)
 12034  	if err != nil {
 12035  		t.Fatal(err)
 12036  	}
 12037  }
 12038  func TestNinOptStructGoString(t *testing.T) {
 12039  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12040  	p := NewPopulatedNinOptStruct(popr, false)
 12041  	s1 := p.GoString()
 12042  	s2 := fmt.Sprintf("%#v", p)
 12043  	if s1 != s2 {
 12044  		t.Fatalf("GoString want %v got %v", s1, s2)
 12045  	}
 12046  	_, err := go_parser.ParseExpr(s1)
 12047  	if err != nil {
 12048  		t.Fatal(err)
 12049  	}
 12050  }
 12051  func TestNidRepStructGoString(t *testing.T) {
 12052  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12053  	p := NewPopulatedNidRepStruct(popr, false)
 12054  	s1 := p.GoString()
 12055  	s2 := fmt.Sprintf("%#v", p)
 12056  	if s1 != s2 {
 12057  		t.Fatalf("GoString want %v got %v", s1, s2)
 12058  	}
 12059  	_, err := go_parser.ParseExpr(s1)
 12060  	if err != nil {
 12061  		t.Fatal(err)
 12062  	}
 12063  }
 12064  func TestNinRepStructGoString(t *testing.T) {
 12065  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12066  	p := NewPopulatedNinRepStruct(popr, false)
 12067  	s1 := p.GoString()
 12068  	s2 := fmt.Sprintf("%#v", p)
 12069  	if s1 != s2 {
 12070  		t.Fatalf("GoString want %v got %v", s1, s2)
 12071  	}
 12072  	_, err := go_parser.ParseExpr(s1)
 12073  	if err != nil {
 12074  		t.Fatal(err)
 12075  	}
 12076  }
 12077  func TestNidEmbeddedStructGoString(t *testing.T) {
 12078  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12079  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 12080  	s1 := p.GoString()
 12081  	s2 := fmt.Sprintf("%#v", p)
 12082  	if s1 != s2 {
 12083  		t.Fatalf("GoString want %v got %v", s1, s2)
 12084  	}
 12085  	_, err := go_parser.ParseExpr(s1)
 12086  	if err != nil {
 12087  		t.Fatal(err)
 12088  	}
 12089  }
 12090  func TestNinEmbeddedStructGoString(t *testing.T) {
 12091  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12092  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 12093  	s1 := p.GoString()
 12094  	s2 := fmt.Sprintf("%#v", p)
 12095  	if s1 != s2 {
 12096  		t.Fatalf("GoString want %v got %v", s1, s2)
 12097  	}
 12098  	_, err := go_parser.ParseExpr(s1)
 12099  	if err != nil {
 12100  		t.Fatal(err)
 12101  	}
 12102  }
 12103  func TestNidNestedStructGoString(t *testing.T) {
 12104  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12105  	p := NewPopulatedNidNestedStruct(popr, false)
 12106  	s1 := p.GoString()
 12107  	s2 := fmt.Sprintf("%#v", p)
 12108  	if s1 != s2 {
 12109  		t.Fatalf("GoString want %v got %v", s1, s2)
 12110  	}
 12111  	_, err := go_parser.ParseExpr(s1)
 12112  	if err != nil {
 12113  		t.Fatal(err)
 12114  	}
 12115  }
 12116  func TestNinNestedStructGoString(t *testing.T) {
 12117  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12118  	p := NewPopulatedNinNestedStruct(popr, false)
 12119  	s1 := p.GoString()
 12120  	s2 := fmt.Sprintf("%#v", p)
 12121  	if s1 != s2 {
 12122  		t.Fatalf("GoString want %v got %v", s1, s2)
 12123  	}
 12124  	_, err := go_parser.ParseExpr(s1)
 12125  	if err != nil {
 12126  		t.Fatal(err)
 12127  	}
 12128  }
 12129  func TestNidOptCustomGoString(t *testing.T) {
 12130  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12131  	p := NewPopulatedNidOptCustom(popr, false)
 12132  	s1 := p.GoString()
 12133  	s2 := fmt.Sprintf("%#v", p)
 12134  	if s1 != s2 {
 12135  		t.Fatalf("GoString want %v got %v", s1, s2)
 12136  	}
 12137  	_, err := go_parser.ParseExpr(s1)
 12138  	if err != nil {
 12139  		t.Fatal(err)
 12140  	}
 12141  }
 12142  func TestCustomDashGoString(t *testing.T) {
 12143  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12144  	p := NewPopulatedCustomDash(popr, false)
 12145  	s1 := p.GoString()
 12146  	s2 := fmt.Sprintf("%#v", p)
 12147  	if s1 != s2 {
 12148  		t.Fatalf("GoString want %v got %v", s1, s2)
 12149  	}
 12150  	_, err := go_parser.ParseExpr(s1)
 12151  	if err != nil {
 12152  		t.Fatal(err)
 12153  	}
 12154  }
 12155  func TestNinOptCustomGoString(t *testing.T) {
 12156  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12157  	p := NewPopulatedNinOptCustom(popr, false)
 12158  	s1 := p.GoString()
 12159  	s2 := fmt.Sprintf("%#v", p)
 12160  	if s1 != s2 {
 12161  		t.Fatalf("GoString want %v got %v", s1, s2)
 12162  	}
 12163  	_, err := go_parser.ParseExpr(s1)
 12164  	if err != nil {
 12165  		t.Fatal(err)
 12166  	}
 12167  }
 12168  func TestNidRepCustomGoString(t *testing.T) {
 12169  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12170  	p := NewPopulatedNidRepCustom(popr, false)
 12171  	s1 := p.GoString()
 12172  	s2 := fmt.Sprintf("%#v", p)
 12173  	if s1 != s2 {
 12174  		t.Fatalf("GoString want %v got %v", s1, s2)
 12175  	}
 12176  	_, err := go_parser.ParseExpr(s1)
 12177  	if err != nil {
 12178  		t.Fatal(err)
 12179  	}
 12180  }
 12181  func TestNinRepCustomGoString(t *testing.T) {
 12182  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12183  	p := NewPopulatedNinRepCustom(popr, false)
 12184  	s1 := p.GoString()
 12185  	s2 := fmt.Sprintf("%#v", p)
 12186  	if s1 != s2 {
 12187  		t.Fatalf("GoString want %v got %v", s1, s2)
 12188  	}
 12189  	_, err := go_parser.ParseExpr(s1)
 12190  	if err != nil {
 12191  		t.Fatal(err)
 12192  	}
 12193  }
 12194  func TestNinOptNativeUnionGoString(t *testing.T) {
 12195  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12196  	p := NewPopulatedNinOptNativeUnion(popr, false)
 12197  	s1 := p.GoString()
 12198  	s2 := fmt.Sprintf("%#v", p)
 12199  	if s1 != s2 {
 12200  		t.Fatalf("GoString want %v got %v", s1, s2)
 12201  	}
 12202  	_, err := go_parser.ParseExpr(s1)
 12203  	if err != nil {
 12204  		t.Fatal(err)
 12205  	}
 12206  }
 12207  func TestNinOptStructUnionGoString(t *testing.T) {
 12208  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12209  	p := NewPopulatedNinOptStructUnion(popr, false)
 12210  	s1 := p.GoString()
 12211  	s2 := fmt.Sprintf("%#v", p)
 12212  	if s1 != s2 {
 12213  		t.Fatalf("GoString want %v got %v", s1, s2)
 12214  	}
 12215  	_, err := go_parser.ParseExpr(s1)
 12216  	if err != nil {
 12217  		t.Fatal(err)
 12218  	}
 12219  }
 12220  func TestNinEmbeddedStructUnionGoString(t *testing.T) {
 12221  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12222  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 12223  	s1 := p.GoString()
 12224  	s2 := fmt.Sprintf("%#v", p)
 12225  	if s1 != s2 {
 12226  		t.Fatalf("GoString want %v got %v", s1, s2)
 12227  	}
 12228  	_, err := go_parser.ParseExpr(s1)
 12229  	if err != nil {
 12230  		t.Fatal(err)
 12231  	}
 12232  }
 12233  func TestNinNestedStructUnionGoString(t *testing.T) {
 12234  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12235  	p := NewPopulatedNinNestedStructUnion(popr, false)
 12236  	s1 := p.GoString()
 12237  	s2 := fmt.Sprintf("%#v", p)
 12238  	if s1 != s2 {
 12239  		t.Fatalf("GoString want %v got %v", s1, s2)
 12240  	}
 12241  	_, err := go_parser.ParseExpr(s1)
 12242  	if err != nil {
 12243  		t.Fatal(err)
 12244  	}
 12245  }
 12246  func TestTreeGoString(t *testing.T) {
 12247  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12248  	p := NewPopulatedTree(popr, false)
 12249  	s1 := p.GoString()
 12250  	s2 := fmt.Sprintf("%#v", p)
 12251  	if s1 != s2 {
 12252  		t.Fatalf("GoString want %v got %v", s1, s2)
 12253  	}
 12254  	_, err := go_parser.ParseExpr(s1)
 12255  	if err != nil {
 12256  		t.Fatal(err)
 12257  	}
 12258  }
 12259  func TestOrBranchGoString(t *testing.T) {
 12260  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12261  	p := NewPopulatedOrBranch(popr, false)
 12262  	s1 := p.GoString()
 12263  	s2 := fmt.Sprintf("%#v", p)
 12264  	if s1 != s2 {
 12265  		t.Fatalf("GoString want %v got %v", s1, s2)
 12266  	}
 12267  	_, err := go_parser.ParseExpr(s1)
 12268  	if err != nil {
 12269  		t.Fatal(err)
 12270  	}
 12271  }
 12272  func TestAndBranchGoString(t *testing.T) {
 12273  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12274  	p := NewPopulatedAndBranch(popr, false)
 12275  	s1 := p.GoString()
 12276  	s2 := fmt.Sprintf("%#v", p)
 12277  	if s1 != s2 {
 12278  		t.Fatalf("GoString want %v got %v", s1, s2)
 12279  	}
 12280  	_, err := go_parser.ParseExpr(s1)
 12281  	if err != nil {
 12282  		t.Fatal(err)
 12283  	}
 12284  }
 12285  func TestLeafGoString(t *testing.T) {
 12286  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12287  	p := NewPopulatedLeaf(popr, false)
 12288  	s1 := p.GoString()
 12289  	s2 := fmt.Sprintf("%#v", p)
 12290  	if s1 != s2 {
 12291  		t.Fatalf("GoString want %v got %v", s1, s2)
 12292  	}
 12293  	_, err := go_parser.ParseExpr(s1)
 12294  	if err != nil {
 12295  		t.Fatal(err)
 12296  	}
 12297  }
 12298  func TestDeepTreeGoString(t *testing.T) {
 12299  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12300  	p := NewPopulatedDeepTree(popr, false)
 12301  	s1 := p.GoString()
 12302  	s2 := fmt.Sprintf("%#v", p)
 12303  	if s1 != s2 {
 12304  		t.Fatalf("GoString want %v got %v", s1, s2)
 12305  	}
 12306  	_, err := go_parser.ParseExpr(s1)
 12307  	if err != nil {
 12308  		t.Fatal(err)
 12309  	}
 12310  }
 12311  func TestADeepBranchGoString(t *testing.T) {
 12312  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12313  	p := NewPopulatedADeepBranch(popr, false)
 12314  	s1 := p.GoString()
 12315  	s2 := fmt.Sprintf("%#v", p)
 12316  	if s1 != s2 {
 12317  		t.Fatalf("GoString want %v got %v", s1, s2)
 12318  	}
 12319  	_, err := go_parser.ParseExpr(s1)
 12320  	if err != nil {
 12321  		t.Fatal(err)
 12322  	}
 12323  }
 12324  func TestAndDeepBranchGoString(t *testing.T) {
 12325  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12326  	p := NewPopulatedAndDeepBranch(popr, false)
 12327  	s1 := p.GoString()
 12328  	s2 := fmt.Sprintf("%#v", p)
 12329  	if s1 != s2 {
 12330  		t.Fatalf("GoString want %v got %v", s1, s2)
 12331  	}
 12332  	_, err := go_parser.ParseExpr(s1)
 12333  	if err != nil {
 12334  		t.Fatal(err)
 12335  	}
 12336  }
 12337  func TestDeepLeafGoString(t *testing.T) {
 12338  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12339  	p := NewPopulatedDeepLeaf(popr, false)
 12340  	s1 := p.GoString()
 12341  	s2 := fmt.Sprintf("%#v", p)
 12342  	if s1 != s2 {
 12343  		t.Fatalf("GoString want %v got %v", s1, s2)
 12344  	}
 12345  	_, err := go_parser.ParseExpr(s1)
 12346  	if err != nil {
 12347  		t.Fatal(err)
 12348  	}
 12349  }
 12350  func TestNilGoString(t *testing.T) {
 12351  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12352  	p := NewPopulatedNil(popr, false)
 12353  	s1 := p.GoString()
 12354  	s2 := fmt.Sprintf("%#v", p)
 12355  	if s1 != s2 {
 12356  		t.Fatalf("GoString want %v got %v", s1, s2)
 12357  	}
 12358  	_, err := go_parser.ParseExpr(s1)
 12359  	if err != nil {
 12360  		t.Fatal(err)
 12361  	}
 12362  }
 12363  func TestNidOptEnumGoString(t *testing.T) {
 12364  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12365  	p := NewPopulatedNidOptEnum(popr, false)
 12366  	s1 := p.GoString()
 12367  	s2 := fmt.Sprintf("%#v", p)
 12368  	if s1 != s2 {
 12369  		t.Fatalf("GoString want %v got %v", s1, s2)
 12370  	}
 12371  	_, err := go_parser.ParseExpr(s1)
 12372  	if err != nil {
 12373  		t.Fatal(err)
 12374  	}
 12375  }
 12376  func TestNinOptEnumGoString(t *testing.T) {
 12377  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12378  	p := NewPopulatedNinOptEnum(popr, false)
 12379  	s1 := p.GoString()
 12380  	s2 := fmt.Sprintf("%#v", p)
 12381  	if s1 != s2 {
 12382  		t.Fatalf("GoString want %v got %v", s1, s2)
 12383  	}
 12384  	_, err := go_parser.ParseExpr(s1)
 12385  	if err != nil {
 12386  		t.Fatal(err)
 12387  	}
 12388  }
 12389  func TestNidRepEnumGoString(t *testing.T) {
 12390  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12391  	p := NewPopulatedNidRepEnum(popr, false)
 12392  	s1 := p.GoString()
 12393  	s2 := fmt.Sprintf("%#v", p)
 12394  	if s1 != s2 {
 12395  		t.Fatalf("GoString want %v got %v", s1, s2)
 12396  	}
 12397  	_, err := go_parser.ParseExpr(s1)
 12398  	if err != nil {
 12399  		t.Fatal(err)
 12400  	}
 12401  }
 12402  func TestNinRepEnumGoString(t *testing.T) {
 12403  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12404  	p := NewPopulatedNinRepEnum(popr, false)
 12405  	s1 := p.GoString()
 12406  	s2 := fmt.Sprintf("%#v", p)
 12407  	if s1 != s2 {
 12408  		t.Fatalf("GoString want %v got %v", s1, s2)
 12409  	}
 12410  	_, err := go_parser.ParseExpr(s1)
 12411  	if err != nil {
 12412  		t.Fatal(err)
 12413  	}
 12414  }
 12415  func TestNinOptEnumDefaultGoString(t *testing.T) {
 12416  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12417  	p := NewPopulatedNinOptEnumDefault(popr, false)
 12418  	s1 := p.GoString()
 12419  	s2 := fmt.Sprintf("%#v", p)
 12420  	if s1 != s2 {
 12421  		t.Fatalf("GoString want %v got %v", s1, s2)
 12422  	}
 12423  	_, err := go_parser.ParseExpr(s1)
 12424  	if err != nil {
 12425  		t.Fatal(err)
 12426  	}
 12427  }
 12428  func TestAnotherNinOptEnumGoString(t *testing.T) {
 12429  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12430  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 12431  	s1 := p.GoString()
 12432  	s2 := fmt.Sprintf("%#v", p)
 12433  	if s1 != s2 {
 12434  		t.Fatalf("GoString want %v got %v", s1, s2)
 12435  	}
 12436  	_, err := go_parser.ParseExpr(s1)
 12437  	if err != nil {
 12438  		t.Fatal(err)
 12439  	}
 12440  }
 12441  func TestAnotherNinOptEnumDefaultGoString(t *testing.T) {
 12442  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12443  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 12444  	s1 := p.GoString()
 12445  	s2 := fmt.Sprintf("%#v", p)
 12446  	if s1 != s2 {
 12447  		t.Fatalf("GoString want %v got %v", s1, s2)
 12448  	}
 12449  	_, err := go_parser.ParseExpr(s1)
 12450  	if err != nil {
 12451  		t.Fatal(err)
 12452  	}
 12453  }
 12454  func TestTimerGoString(t *testing.T) {
 12455  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12456  	p := NewPopulatedTimer(popr, false)
 12457  	s1 := p.GoString()
 12458  	s2 := fmt.Sprintf("%#v", p)
 12459  	if s1 != s2 {
 12460  		t.Fatalf("GoString want %v got %v", s1, s2)
 12461  	}
 12462  	_, err := go_parser.ParseExpr(s1)
 12463  	if err != nil {
 12464  		t.Fatal(err)
 12465  	}
 12466  }
 12467  func TestMyExtendableGoString(t *testing.T) {
 12468  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12469  	p := NewPopulatedMyExtendable(popr, false)
 12470  	s1 := p.GoString()
 12471  	s2 := fmt.Sprintf("%#v", p)
 12472  	if s1 != s2 {
 12473  		t.Fatalf("GoString want %v got %v", s1, s2)
 12474  	}
 12475  	_, err := go_parser.ParseExpr(s1)
 12476  	if err != nil {
 12477  		t.Fatal(err)
 12478  	}
 12479  }
 12480  func TestOtherExtenableGoString(t *testing.T) {
 12481  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12482  	p := NewPopulatedOtherExtenable(popr, false)
 12483  	s1 := p.GoString()
 12484  	s2 := fmt.Sprintf("%#v", p)
 12485  	if s1 != s2 {
 12486  		t.Fatalf("GoString want %v got %v", s1, s2)
 12487  	}
 12488  	_, err := go_parser.ParseExpr(s1)
 12489  	if err != nil {
 12490  		t.Fatal(err)
 12491  	}
 12492  }
 12493  func TestNestedDefinitionGoString(t *testing.T) {
 12494  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12495  	p := NewPopulatedNestedDefinition(popr, false)
 12496  	s1 := p.GoString()
 12497  	s2 := fmt.Sprintf("%#v", p)
 12498  	if s1 != s2 {
 12499  		t.Fatalf("GoString want %v got %v", s1, s2)
 12500  	}
 12501  	_, err := go_parser.ParseExpr(s1)
 12502  	if err != nil {
 12503  		t.Fatal(err)
 12504  	}
 12505  }
 12506  func TestNestedDefinition_NestedMessageGoString(t *testing.T) {
 12507  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12508  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 12509  	s1 := p.GoString()
 12510  	s2 := fmt.Sprintf("%#v", p)
 12511  	if s1 != s2 {
 12512  		t.Fatalf("GoString want %v got %v", s1, s2)
 12513  	}
 12514  	_, err := go_parser.ParseExpr(s1)
 12515  	if err != nil {
 12516  		t.Fatal(err)
 12517  	}
 12518  }
 12519  func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) {
 12520  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12521  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 12522  	s1 := p.GoString()
 12523  	s2 := fmt.Sprintf("%#v", p)
 12524  	if s1 != s2 {
 12525  		t.Fatalf("GoString want %v got %v", s1, s2)
 12526  	}
 12527  	_, err := go_parser.ParseExpr(s1)
 12528  	if err != nil {
 12529  		t.Fatal(err)
 12530  	}
 12531  }
 12532  func TestNestedScopeGoString(t *testing.T) {
 12533  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12534  	p := NewPopulatedNestedScope(popr, false)
 12535  	s1 := p.GoString()
 12536  	s2 := fmt.Sprintf("%#v", p)
 12537  	if s1 != s2 {
 12538  		t.Fatalf("GoString want %v got %v", s1, s2)
 12539  	}
 12540  	_, err := go_parser.ParseExpr(s1)
 12541  	if err != nil {
 12542  		t.Fatal(err)
 12543  	}
 12544  }
 12545  func TestNinOptNativeDefaultGoString(t *testing.T) {
 12546  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12547  	p := NewPopulatedNinOptNativeDefault(popr, false)
 12548  	s1 := p.GoString()
 12549  	s2 := fmt.Sprintf("%#v", p)
 12550  	if s1 != s2 {
 12551  		t.Fatalf("GoString want %v got %v", s1, s2)
 12552  	}
 12553  	_, err := go_parser.ParseExpr(s1)
 12554  	if err != nil {
 12555  		t.Fatal(err)
 12556  	}
 12557  }
 12558  func TestCustomContainerGoString(t *testing.T) {
 12559  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12560  	p := NewPopulatedCustomContainer(popr, false)
 12561  	s1 := p.GoString()
 12562  	s2 := fmt.Sprintf("%#v", p)
 12563  	if s1 != s2 {
 12564  		t.Fatalf("GoString want %v got %v", s1, s2)
 12565  	}
 12566  	_, err := go_parser.ParseExpr(s1)
 12567  	if err != nil {
 12568  		t.Fatal(err)
 12569  	}
 12570  }
 12571  func TestCustomNameNidOptNativeGoString(t *testing.T) {
 12572  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12573  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 12574  	s1 := p.GoString()
 12575  	s2 := fmt.Sprintf("%#v", p)
 12576  	if s1 != s2 {
 12577  		t.Fatalf("GoString want %v got %v", s1, s2)
 12578  	}
 12579  	_, err := go_parser.ParseExpr(s1)
 12580  	if err != nil {
 12581  		t.Fatal(err)
 12582  	}
 12583  }
 12584  func TestCustomNameNinOptNativeGoString(t *testing.T) {
 12585  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12586  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 12587  	s1 := p.GoString()
 12588  	s2 := fmt.Sprintf("%#v", p)
 12589  	if s1 != s2 {
 12590  		t.Fatalf("GoString want %v got %v", s1, s2)
 12591  	}
 12592  	_, err := go_parser.ParseExpr(s1)
 12593  	if err != nil {
 12594  		t.Fatal(err)
 12595  	}
 12596  }
 12597  func TestCustomNameNinRepNativeGoString(t *testing.T) {
 12598  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12599  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 12600  	s1 := p.GoString()
 12601  	s2 := fmt.Sprintf("%#v", p)
 12602  	if s1 != s2 {
 12603  		t.Fatalf("GoString want %v got %v", s1, s2)
 12604  	}
 12605  	_, err := go_parser.ParseExpr(s1)
 12606  	if err != nil {
 12607  		t.Fatal(err)
 12608  	}
 12609  }
 12610  func TestCustomNameNinStructGoString(t *testing.T) {
 12611  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12612  	p := NewPopulatedCustomNameNinStruct(popr, false)
 12613  	s1 := p.GoString()
 12614  	s2 := fmt.Sprintf("%#v", p)
 12615  	if s1 != s2 {
 12616  		t.Fatalf("GoString want %v got %v", s1, s2)
 12617  	}
 12618  	_, err := go_parser.ParseExpr(s1)
 12619  	if err != nil {
 12620  		t.Fatal(err)
 12621  	}
 12622  }
 12623  func TestCustomNameCustomTypeGoString(t *testing.T) {
 12624  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12625  	p := NewPopulatedCustomNameCustomType(popr, false)
 12626  	s1 := p.GoString()
 12627  	s2 := fmt.Sprintf("%#v", p)
 12628  	if s1 != s2 {
 12629  		t.Fatalf("GoString want %v got %v", s1, s2)
 12630  	}
 12631  	_, err := go_parser.ParseExpr(s1)
 12632  	if err != nil {
 12633  		t.Fatal(err)
 12634  	}
 12635  }
 12636  func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) {
 12637  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12638  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 12639  	s1 := p.GoString()
 12640  	s2 := fmt.Sprintf("%#v", p)
 12641  	if s1 != s2 {
 12642  		t.Fatalf("GoString want %v got %v", s1, s2)
 12643  	}
 12644  	_, err := go_parser.ParseExpr(s1)
 12645  	if err != nil {
 12646  		t.Fatal(err)
 12647  	}
 12648  }
 12649  func TestCustomNameEnumGoString(t *testing.T) {
 12650  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12651  	p := NewPopulatedCustomNameEnum(popr, false)
 12652  	s1 := p.GoString()
 12653  	s2 := fmt.Sprintf("%#v", p)
 12654  	if s1 != s2 {
 12655  		t.Fatalf("GoString want %v got %v", s1, s2)
 12656  	}
 12657  	_, err := go_parser.ParseExpr(s1)
 12658  	if err != nil {
 12659  		t.Fatal(err)
 12660  	}
 12661  }
 12662  func TestNoExtensionsMapGoString(t *testing.T) {
 12663  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12664  	p := NewPopulatedNoExtensionsMap(popr, false)
 12665  	s1 := p.GoString()
 12666  	s2 := fmt.Sprintf("%#v", p)
 12667  	if s1 != s2 {
 12668  		t.Fatalf("GoString want %v got %v", s1, s2)
 12669  	}
 12670  	_, err := go_parser.ParseExpr(s1)
 12671  	if err != nil {
 12672  		t.Fatal(err)
 12673  	}
 12674  }
 12675  func TestUnrecognizedGoString(t *testing.T) {
 12676  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12677  	p := NewPopulatedUnrecognized(popr, false)
 12678  	s1 := p.GoString()
 12679  	s2 := fmt.Sprintf("%#v", p)
 12680  	if s1 != s2 {
 12681  		t.Fatalf("GoString want %v got %v", s1, s2)
 12682  	}
 12683  	_, err := go_parser.ParseExpr(s1)
 12684  	if err != nil {
 12685  		t.Fatal(err)
 12686  	}
 12687  }
 12688  func TestUnrecognizedWithInnerGoString(t *testing.T) {
 12689  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12690  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 12691  	s1 := p.GoString()
 12692  	s2 := fmt.Sprintf("%#v", p)
 12693  	if s1 != s2 {
 12694  		t.Fatalf("GoString want %v got %v", s1, s2)
 12695  	}
 12696  	_, err := go_parser.ParseExpr(s1)
 12697  	if err != nil {
 12698  		t.Fatal(err)
 12699  	}
 12700  }
 12701  func TestUnrecognizedWithInner_InnerGoString(t *testing.T) {
 12702  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12703  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 12704  	s1 := p.GoString()
 12705  	s2 := fmt.Sprintf("%#v", p)
 12706  	if s1 != s2 {
 12707  		t.Fatalf("GoString want %v got %v", s1, s2)
 12708  	}
 12709  	_, err := go_parser.ParseExpr(s1)
 12710  	if err != nil {
 12711  		t.Fatal(err)
 12712  	}
 12713  }
 12714  func TestUnrecognizedWithEmbedGoString(t *testing.T) {
 12715  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12716  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 12717  	s1 := p.GoString()
 12718  	s2 := fmt.Sprintf("%#v", p)
 12719  	if s1 != s2 {
 12720  		t.Fatalf("GoString want %v got %v", s1, s2)
 12721  	}
 12722  	_, err := go_parser.ParseExpr(s1)
 12723  	if err != nil {
 12724  		t.Fatal(err)
 12725  	}
 12726  }
 12727  func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) {
 12728  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12729  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 12730  	s1 := p.GoString()
 12731  	s2 := fmt.Sprintf("%#v", p)
 12732  	if s1 != s2 {
 12733  		t.Fatalf("GoString want %v got %v", s1, s2)
 12734  	}
 12735  	_, err := go_parser.ParseExpr(s1)
 12736  	if err != nil {
 12737  		t.Fatal(err)
 12738  	}
 12739  }
 12740  func TestNodeGoString(t *testing.T) {
 12741  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12742  	p := NewPopulatedNode(popr, false)
 12743  	s1 := p.GoString()
 12744  	s2 := fmt.Sprintf("%#v", p)
 12745  	if s1 != s2 {
 12746  		t.Fatalf("GoString want %v got %v", s1, s2)
 12747  	}
 12748  	_, err := go_parser.ParseExpr(s1)
 12749  	if err != nil {
 12750  		t.Fatal(err)
 12751  	}
 12752  }
 12753  func TestNonByteCustomTypeGoString(t *testing.T) {
 12754  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12755  	p := NewPopulatedNonByteCustomType(popr, false)
 12756  	s1 := p.GoString()
 12757  	s2 := fmt.Sprintf("%#v", p)
 12758  	if s1 != s2 {
 12759  		t.Fatalf("GoString want %v got %v", s1, s2)
 12760  	}
 12761  	_, err := go_parser.ParseExpr(s1)
 12762  	if err != nil {
 12763  		t.Fatal(err)
 12764  	}
 12765  }
 12766  func TestNidOptNonByteCustomTypeGoString(t *testing.T) {
 12767  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12768  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 12769  	s1 := p.GoString()
 12770  	s2 := fmt.Sprintf("%#v", p)
 12771  	if s1 != s2 {
 12772  		t.Fatalf("GoString want %v got %v", s1, s2)
 12773  	}
 12774  	_, err := go_parser.ParseExpr(s1)
 12775  	if err != nil {
 12776  		t.Fatal(err)
 12777  	}
 12778  }
 12779  func TestNinOptNonByteCustomTypeGoString(t *testing.T) {
 12780  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12781  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 12782  	s1 := p.GoString()
 12783  	s2 := fmt.Sprintf("%#v", p)
 12784  	if s1 != s2 {
 12785  		t.Fatalf("GoString want %v got %v", s1, s2)
 12786  	}
 12787  	_, err := go_parser.ParseExpr(s1)
 12788  	if err != nil {
 12789  		t.Fatal(err)
 12790  	}
 12791  }
 12792  func TestNidRepNonByteCustomTypeGoString(t *testing.T) {
 12793  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12794  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 12795  	s1 := p.GoString()
 12796  	s2 := fmt.Sprintf("%#v", p)
 12797  	if s1 != s2 {
 12798  		t.Fatalf("GoString want %v got %v", s1, s2)
 12799  	}
 12800  	_, err := go_parser.ParseExpr(s1)
 12801  	if err != nil {
 12802  		t.Fatal(err)
 12803  	}
 12804  }
 12805  func TestNinRepNonByteCustomTypeGoString(t *testing.T) {
 12806  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12807  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 12808  	s1 := p.GoString()
 12809  	s2 := fmt.Sprintf("%#v", p)
 12810  	if s1 != s2 {
 12811  		t.Fatalf("GoString want %v got %v", s1, s2)
 12812  	}
 12813  	_, err := go_parser.ParseExpr(s1)
 12814  	if err != nil {
 12815  		t.Fatal(err)
 12816  	}
 12817  }
 12818  func TestProtoTypeGoString(t *testing.T) {
 12819  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 12820  	p := NewPopulatedProtoType(popr, false)
 12821  	s1 := p.GoString()
 12822  	s2 := fmt.Sprintf("%#v", p)
 12823  	if s1 != s2 {
 12824  		t.Fatalf("GoString want %v got %v", s1, s2)
 12825  	}
 12826  	_, err := go_parser.ParseExpr(s1)
 12827  	if err != nil {
 12828  		t.Fatal(err)
 12829  	}
 12830  }
 12831  func TestNidOptNativeSize(t *testing.T) {
 12832  	seed := time.Now().UnixNano()
 12833  	popr := math_rand.New(math_rand.NewSource(seed))
 12834  	p := NewPopulatedNidOptNative(popr, true)
 12835  	size2 := github_com_gogo_protobuf_proto.Size(p)
 12836  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12837  	if err != nil {
 12838  		t.Fatalf("seed = %d, err = %v", seed, err)
 12839  	}
 12840  	size := p.Size()
 12841  	if len(dAtA) != size {
 12842  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 12843  	}
 12844  	if size2 != size {
 12845  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 12846  	}
 12847  	size3 := github_com_gogo_protobuf_proto.Size(p)
 12848  	if size3 != size {
 12849  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 12850  	}
 12851  }
 12852  
 12853  func BenchmarkNidOptNativeSize(b *testing.B) {
 12854  	popr := math_rand.New(math_rand.NewSource(616))
 12855  	total := 0
 12856  	pops := make([]*NidOptNative, 1000)
 12857  	for i := 0; i < 1000; i++ {
 12858  		pops[i] = NewPopulatedNidOptNative(popr, false)
 12859  	}
 12860  	b.ResetTimer()
 12861  	for i := 0; i < b.N; i++ {
 12862  		total += pops[i%1000].Size()
 12863  	}
 12864  	b.SetBytes(int64(total / b.N))
 12865  }
 12866  
 12867  func TestNinOptNativeSize(t *testing.T) {
 12868  	seed := time.Now().UnixNano()
 12869  	popr := math_rand.New(math_rand.NewSource(seed))
 12870  	p := NewPopulatedNinOptNative(popr, true)
 12871  	size2 := github_com_gogo_protobuf_proto.Size(p)
 12872  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12873  	if err != nil {
 12874  		t.Fatalf("seed = %d, err = %v", seed, err)
 12875  	}
 12876  	size := p.Size()
 12877  	if len(dAtA) != size {
 12878  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 12879  	}
 12880  	if size2 != size {
 12881  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 12882  	}
 12883  	size3 := github_com_gogo_protobuf_proto.Size(p)
 12884  	if size3 != size {
 12885  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 12886  	}
 12887  }
 12888  
 12889  func BenchmarkNinOptNativeSize(b *testing.B) {
 12890  	popr := math_rand.New(math_rand.NewSource(616))
 12891  	total := 0
 12892  	pops := make([]*NinOptNative, 1000)
 12893  	for i := 0; i < 1000; i++ {
 12894  		pops[i] = NewPopulatedNinOptNative(popr, false)
 12895  	}
 12896  	b.ResetTimer()
 12897  	for i := 0; i < b.N; i++ {
 12898  		total += pops[i%1000].Size()
 12899  	}
 12900  	b.SetBytes(int64(total / b.N))
 12901  }
 12902  
 12903  func TestNidRepNativeSize(t *testing.T) {
 12904  	seed := time.Now().UnixNano()
 12905  	popr := math_rand.New(math_rand.NewSource(seed))
 12906  	p := NewPopulatedNidRepNative(popr, true)
 12907  	size2 := github_com_gogo_protobuf_proto.Size(p)
 12908  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12909  	if err != nil {
 12910  		t.Fatalf("seed = %d, err = %v", seed, err)
 12911  	}
 12912  	size := p.Size()
 12913  	if len(dAtA) != size {
 12914  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 12915  	}
 12916  	if size2 != size {
 12917  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 12918  	}
 12919  	size3 := github_com_gogo_protobuf_proto.Size(p)
 12920  	if size3 != size {
 12921  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 12922  	}
 12923  }
 12924  
 12925  func BenchmarkNidRepNativeSize(b *testing.B) {
 12926  	popr := math_rand.New(math_rand.NewSource(616))
 12927  	total := 0
 12928  	pops := make([]*NidRepNative, 1000)
 12929  	for i := 0; i < 1000; i++ {
 12930  		pops[i] = NewPopulatedNidRepNative(popr, false)
 12931  	}
 12932  	b.ResetTimer()
 12933  	for i := 0; i < b.N; i++ {
 12934  		total += pops[i%1000].Size()
 12935  	}
 12936  	b.SetBytes(int64(total / b.N))
 12937  }
 12938  
 12939  func TestNinRepNativeSize(t *testing.T) {
 12940  	seed := time.Now().UnixNano()
 12941  	popr := math_rand.New(math_rand.NewSource(seed))
 12942  	p := NewPopulatedNinRepNative(popr, true)
 12943  	size2 := github_com_gogo_protobuf_proto.Size(p)
 12944  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12945  	if err != nil {
 12946  		t.Fatalf("seed = %d, err = %v", seed, err)
 12947  	}
 12948  	size := p.Size()
 12949  	if len(dAtA) != size {
 12950  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 12951  	}
 12952  	if size2 != size {
 12953  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 12954  	}
 12955  	size3 := github_com_gogo_protobuf_proto.Size(p)
 12956  	if size3 != size {
 12957  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 12958  	}
 12959  }
 12960  
 12961  func BenchmarkNinRepNativeSize(b *testing.B) {
 12962  	popr := math_rand.New(math_rand.NewSource(616))
 12963  	total := 0
 12964  	pops := make([]*NinRepNative, 1000)
 12965  	for i := 0; i < 1000; i++ {
 12966  		pops[i] = NewPopulatedNinRepNative(popr, false)
 12967  	}
 12968  	b.ResetTimer()
 12969  	for i := 0; i < b.N; i++ {
 12970  		total += pops[i%1000].Size()
 12971  	}
 12972  	b.SetBytes(int64(total / b.N))
 12973  }
 12974  
 12975  func TestNidRepPackedNativeSize(t *testing.T) {
 12976  	seed := time.Now().UnixNano()
 12977  	popr := math_rand.New(math_rand.NewSource(seed))
 12978  	p := NewPopulatedNidRepPackedNative(popr, true)
 12979  	size2 := github_com_gogo_protobuf_proto.Size(p)
 12980  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 12981  	if err != nil {
 12982  		t.Fatalf("seed = %d, err = %v", seed, err)
 12983  	}
 12984  	size := p.Size()
 12985  	if len(dAtA) != size {
 12986  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 12987  	}
 12988  	if size2 != size {
 12989  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 12990  	}
 12991  	size3 := github_com_gogo_protobuf_proto.Size(p)
 12992  	if size3 != size {
 12993  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 12994  	}
 12995  }
 12996  
 12997  func BenchmarkNidRepPackedNativeSize(b *testing.B) {
 12998  	popr := math_rand.New(math_rand.NewSource(616))
 12999  	total := 0
 13000  	pops := make([]*NidRepPackedNative, 1000)
 13001  	for i := 0; i < 1000; i++ {
 13002  		pops[i] = NewPopulatedNidRepPackedNative(popr, false)
 13003  	}
 13004  	b.ResetTimer()
 13005  	for i := 0; i < b.N; i++ {
 13006  		total += pops[i%1000].Size()
 13007  	}
 13008  	b.SetBytes(int64(total / b.N))
 13009  }
 13010  
 13011  func TestNinRepPackedNativeSize(t *testing.T) {
 13012  	seed := time.Now().UnixNano()
 13013  	popr := math_rand.New(math_rand.NewSource(seed))
 13014  	p := NewPopulatedNinRepPackedNative(popr, true)
 13015  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13016  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13017  	if err != nil {
 13018  		t.Fatalf("seed = %d, err = %v", seed, err)
 13019  	}
 13020  	size := p.Size()
 13021  	if len(dAtA) != size {
 13022  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13023  	}
 13024  	if size2 != size {
 13025  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13026  	}
 13027  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13028  	if size3 != size {
 13029  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13030  	}
 13031  }
 13032  
 13033  func BenchmarkNinRepPackedNativeSize(b *testing.B) {
 13034  	popr := math_rand.New(math_rand.NewSource(616))
 13035  	total := 0
 13036  	pops := make([]*NinRepPackedNative, 1000)
 13037  	for i := 0; i < 1000; i++ {
 13038  		pops[i] = NewPopulatedNinRepPackedNative(popr, false)
 13039  	}
 13040  	b.ResetTimer()
 13041  	for i := 0; i < b.N; i++ {
 13042  		total += pops[i%1000].Size()
 13043  	}
 13044  	b.SetBytes(int64(total / b.N))
 13045  }
 13046  
 13047  func TestNidOptStructSize(t *testing.T) {
 13048  	seed := time.Now().UnixNano()
 13049  	popr := math_rand.New(math_rand.NewSource(seed))
 13050  	p := NewPopulatedNidOptStruct(popr, true)
 13051  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13052  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13053  	if err != nil {
 13054  		t.Fatalf("seed = %d, err = %v", seed, err)
 13055  	}
 13056  	size := p.Size()
 13057  	if len(dAtA) != size {
 13058  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13059  	}
 13060  	if size2 != size {
 13061  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13062  	}
 13063  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13064  	if size3 != size {
 13065  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13066  	}
 13067  }
 13068  
 13069  func BenchmarkNidOptStructSize(b *testing.B) {
 13070  	popr := math_rand.New(math_rand.NewSource(616))
 13071  	total := 0
 13072  	pops := make([]*NidOptStruct, 1000)
 13073  	for i := 0; i < 1000; i++ {
 13074  		pops[i] = NewPopulatedNidOptStruct(popr, false)
 13075  	}
 13076  	b.ResetTimer()
 13077  	for i := 0; i < b.N; i++ {
 13078  		total += pops[i%1000].Size()
 13079  	}
 13080  	b.SetBytes(int64(total / b.N))
 13081  }
 13082  
 13083  func TestNinOptStructSize(t *testing.T) {
 13084  	seed := time.Now().UnixNano()
 13085  	popr := math_rand.New(math_rand.NewSource(seed))
 13086  	p := NewPopulatedNinOptStruct(popr, true)
 13087  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13088  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13089  	if err != nil {
 13090  		t.Fatalf("seed = %d, err = %v", seed, err)
 13091  	}
 13092  	size := p.Size()
 13093  	if len(dAtA) != size {
 13094  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13095  	}
 13096  	if size2 != size {
 13097  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13098  	}
 13099  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13100  	if size3 != size {
 13101  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13102  	}
 13103  }
 13104  
 13105  func BenchmarkNinOptStructSize(b *testing.B) {
 13106  	popr := math_rand.New(math_rand.NewSource(616))
 13107  	total := 0
 13108  	pops := make([]*NinOptStruct, 1000)
 13109  	for i := 0; i < 1000; i++ {
 13110  		pops[i] = NewPopulatedNinOptStruct(popr, false)
 13111  	}
 13112  	b.ResetTimer()
 13113  	for i := 0; i < b.N; i++ {
 13114  		total += pops[i%1000].Size()
 13115  	}
 13116  	b.SetBytes(int64(total / b.N))
 13117  }
 13118  
 13119  func TestNidRepStructSize(t *testing.T) {
 13120  	seed := time.Now().UnixNano()
 13121  	popr := math_rand.New(math_rand.NewSource(seed))
 13122  	p := NewPopulatedNidRepStruct(popr, true)
 13123  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13124  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13125  	if err != nil {
 13126  		t.Fatalf("seed = %d, err = %v", seed, err)
 13127  	}
 13128  	size := p.Size()
 13129  	if len(dAtA) != size {
 13130  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13131  	}
 13132  	if size2 != size {
 13133  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13134  	}
 13135  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13136  	if size3 != size {
 13137  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13138  	}
 13139  }
 13140  
 13141  func BenchmarkNidRepStructSize(b *testing.B) {
 13142  	popr := math_rand.New(math_rand.NewSource(616))
 13143  	total := 0
 13144  	pops := make([]*NidRepStruct, 1000)
 13145  	for i := 0; i < 1000; i++ {
 13146  		pops[i] = NewPopulatedNidRepStruct(popr, false)
 13147  	}
 13148  	b.ResetTimer()
 13149  	for i := 0; i < b.N; i++ {
 13150  		total += pops[i%1000].Size()
 13151  	}
 13152  	b.SetBytes(int64(total / b.N))
 13153  }
 13154  
 13155  func TestNinRepStructSize(t *testing.T) {
 13156  	seed := time.Now().UnixNano()
 13157  	popr := math_rand.New(math_rand.NewSource(seed))
 13158  	p := NewPopulatedNinRepStruct(popr, true)
 13159  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13160  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13161  	if err != nil {
 13162  		t.Fatalf("seed = %d, err = %v", seed, err)
 13163  	}
 13164  	size := p.Size()
 13165  	if len(dAtA) != size {
 13166  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13167  	}
 13168  	if size2 != size {
 13169  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13170  	}
 13171  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13172  	if size3 != size {
 13173  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13174  	}
 13175  }
 13176  
 13177  func BenchmarkNinRepStructSize(b *testing.B) {
 13178  	popr := math_rand.New(math_rand.NewSource(616))
 13179  	total := 0
 13180  	pops := make([]*NinRepStruct, 1000)
 13181  	for i := 0; i < 1000; i++ {
 13182  		pops[i] = NewPopulatedNinRepStruct(popr, false)
 13183  	}
 13184  	b.ResetTimer()
 13185  	for i := 0; i < b.N; i++ {
 13186  		total += pops[i%1000].Size()
 13187  	}
 13188  	b.SetBytes(int64(total / b.N))
 13189  }
 13190  
 13191  func TestNidEmbeddedStructSize(t *testing.T) {
 13192  	seed := time.Now().UnixNano()
 13193  	popr := math_rand.New(math_rand.NewSource(seed))
 13194  	p := NewPopulatedNidEmbeddedStruct(popr, true)
 13195  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13196  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13197  	if err != nil {
 13198  		t.Fatalf("seed = %d, err = %v", seed, err)
 13199  	}
 13200  	size := p.Size()
 13201  	if len(dAtA) != size {
 13202  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13203  	}
 13204  	if size2 != size {
 13205  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13206  	}
 13207  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13208  	if size3 != size {
 13209  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13210  	}
 13211  }
 13212  
 13213  func BenchmarkNidEmbeddedStructSize(b *testing.B) {
 13214  	popr := math_rand.New(math_rand.NewSource(616))
 13215  	total := 0
 13216  	pops := make([]*NidEmbeddedStruct, 1000)
 13217  	for i := 0; i < 1000; i++ {
 13218  		pops[i] = NewPopulatedNidEmbeddedStruct(popr, false)
 13219  	}
 13220  	b.ResetTimer()
 13221  	for i := 0; i < b.N; i++ {
 13222  		total += pops[i%1000].Size()
 13223  	}
 13224  	b.SetBytes(int64(total / b.N))
 13225  }
 13226  
 13227  func TestNinEmbeddedStructSize(t *testing.T) {
 13228  	seed := time.Now().UnixNano()
 13229  	popr := math_rand.New(math_rand.NewSource(seed))
 13230  	p := NewPopulatedNinEmbeddedStruct(popr, true)
 13231  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13232  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13233  	if err != nil {
 13234  		t.Fatalf("seed = %d, err = %v", seed, err)
 13235  	}
 13236  	size := p.Size()
 13237  	if len(dAtA) != size {
 13238  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13239  	}
 13240  	if size2 != size {
 13241  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13242  	}
 13243  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13244  	if size3 != size {
 13245  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13246  	}
 13247  }
 13248  
 13249  func BenchmarkNinEmbeddedStructSize(b *testing.B) {
 13250  	popr := math_rand.New(math_rand.NewSource(616))
 13251  	total := 0
 13252  	pops := make([]*NinEmbeddedStruct, 1000)
 13253  	for i := 0; i < 1000; i++ {
 13254  		pops[i] = NewPopulatedNinEmbeddedStruct(popr, false)
 13255  	}
 13256  	b.ResetTimer()
 13257  	for i := 0; i < b.N; i++ {
 13258  		total += pops[i%1000].Size()
 13259  	}
 13260  	b.SetBytes(int64(total / b.N))
 13261  }
 13262  
 13263  func TestNidNestedStructSize(t *testing.T) {
 13264  	seed := time.Now().UnixNano()
 13265  	popr := math_rand.New(math_rand.NewSource(seed))
 13266  	p := NewPopulatedNidNestedStruct(popr, true)
 13267  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13268  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13269  	if err != nil {
 13270  		t.Fatalf("seed = %d, err = %v", seed, err)
 13271  	}
 13272  	size := p.Size()
 13273  	if len(dAtA) != size {
 13274  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13275  	}
 13276  	if size2 != size {
 13277  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13278  	}
 13279  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13280  	if size3 != size {
 13281  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13282  	}
 13283  }
 13284  
 13285  func BenchmarkNidNestedStructSize(b *testing.B) {
 13286  	popr := math_rand.New(math_rand.NewSource(616))
 13287  	total := 0
 13288  	pops := make([]*NidNestedStruct, 1000)
 13289  	for i := 0; i < 1000; i++ {
 13290  		pops[i] = NewPopulatedNidNestedStruct(popr, false)
 13291  	}
 13292  	b.ResetTimer()
 13293  	for i := 0; i < b.N; i++ {
 13294  		total += pops[i%1000].Size()
 13295  	}
 13296  	b.SetBytes(int64(total / b.N))
 13297  }
 13298  
 13299  func TestNinNestedStructSize(t *testing.T) {
 13300  	seed := time.Now().UnixNano()
 13301  	popr := math_rand.New(math_rand.NewSource(seed))
 13302  	p := NewPopulatedNinNestedStruct(popr, true)
 13303  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13304  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13305  	if err != nil {
 13306  		t.Fatalf("seed = %d, err = %v", seed, err)
 13307  	}
 13308  	size := p.Size()
 13309  	if len(dAtA) != size {
 13310  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13311  	}
 13312  	if size2 != size {
 13313  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13314  	}
 13315  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13316  	if size3 != size {
 13317  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13318  	}
 13319  }
 13320  
 13321  func BenchmarkNinNestedStructSize(b *testing.B) {
 13322  	popr := math_rand.New(math_rand.NewSource(616))
 13323  	total := 0
 13324  	pops := make([]*NinNestedStruct, 1000)
 13325  	for i := 0; i < 1000; i++ {
 13326  		pops[i] = NewPopulatedNinNestedStruct(popr, false)
 13327  	}
 13328  	b.ResetTimer()
 13329  	for i := 0; i < b.N; i++ {
 13330  		total += pops[i%1000].Size()
 13331  	}
 13332  	b.SetBytes(int64(total / b.N))
 13333  }
 13334  
 13335  func TestNidOptCustomSize(t *testing.T) {
 13336  	seed := time.Now().UnixNano()
 13337  	popr := math_rand.New(math_rand.NewSource(seed))
 13338  	p := NewPopulatedNidOptCustom(popr, true)
 13339  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13340  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13341  	if err != nil {
 13342  		t.Fatalf("seed = %d, err = %v", seed, err)
 13343  	}
 13344  	size := p.Size()
 13345  	if len(dAtA) != size {
 13346  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13347  	}
 13348  	if size2 != size {
 13349  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13350  	}
 13351  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13352  	if size3 != size {
 13353  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13354  	}
 13355  }
 13356  
 13357  func BenchmarkNidOptCustomSize(b *testing.B) {
 13358  	popr := math_rand.New(math_rand.NewSource(616))
 13359  	total := 0
 13360  	pops := make([]*NidOptCustom, 1000)
 13361  	for i := 0; i < 1000; i++ {
 13362  		pops[i] = NewPopulatedNidOptCustom(popr, false)
 13363  	}
 13364  	b.ResetTimer()
 13365  	for i := 0; i < b.N; i++ {
 13366  		total += pops[i%1000].Size()
 13367  	}
 13368  	b.SetBytes(int64(total / b.N))
 13369  }
 13370  
 13371  func TestCustomDashSize(t *testing.T) {
 13372  	seed := time.Now().UnixNano()
 13373  	popr := math_rand.New(math_rand.NewSource(seed))
 13374  	p := NewPopulatedCustomDash(popr, true)
 13375  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13376  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13377  	if err != nil {
 13378  		t.Fatalf("seed = %d, err = %v", seed, err)
 13379  	}
 13380  	size := p.Size()
 13381  	if len(dAtA) != size {
 13382  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13383  	}
 13384  	if size2 != size {
 13385  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13386  	}
 13387  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13388  	if size3 != size {
 13389  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13390  	}
 13391  }
 13392  
 13393  func BenchmarkCustomDashSize(b *testing.B) {
 13394  	popr := math_rand.New(math_rand.NewSource(616))
 13395  	total := 0
 13396  	pops := make([]*CustomDash, 1000)
 13397  	for i := 0; i < 1000; i++ {
 13398  		pops[i] = NewPopulatedCustomDash(popr, false)
 13399  	}
 13400  	b.ResetTimer()
 13401  	for i := 0; i < b.N; i++ {
 13402  		total += pops[i%1000].Size()
 13403  	}
 13404  	b.SetBytes(int64(total / b.N))
 13405  }
 13406  
 13407  func TestNinOptCustomSize(t *testing.T) {
 13408  	seed := time.Now().UnixNano()
 13409  	popr := math_rand.New(math_rand.NewSource(seed))
 13410  	p := NewPopulatedNinOptCustom(popr, true)
 13411  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13412  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13413  	if err != nil {
 13414  		t.Fatalf("seed = %d, err = %v", seed, err)
 13415  	}
 13416  	size := p.Size()
 13417  	if len(dAtA) != size {
 13418  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13419  	}
 13420  	if size2 != size {
 13421  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13422  	}
 13423  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13424  	if size3 != size {
 13425  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13426  	}
 13427  }
 13428  
 13429  func BenchmarkNinOptCustomSize(b *testing.B) {
 13430  	popr := math_rand.New(math_rand.NewSource(616))
 13431  	total := 0
 13432  	pops := make([]*NinOptCustom, 1000)
 13433  	for i := 0; i < 1000; i++ {
 13434  		pops[i] = NewPopulatedNinOptCustom(popr, false)
 13435  	}
 13436  	b.ResetTimer()
 13437  	for i := 0; i < b.N; i++ {
 13438  		total += pops[i%1000].Size()
 13439  	}
 13440  	b.SetBytes(int64(total / b.N))
 13441  }
 13442  
 13443  func TestNidRepCustomSize(t *testing.T) {
 13444  	seed := time.Now().UnixNano()
 13445  	popr := math_rand.New(math_rand.NewSource(seed))
 13446  	p := NewPopulatedNidRepCustom(popr, true)
 13447  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13448  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13449  	if err != nil {
 13450  		t.Fatalf("seed = %d, err = %v", seed, err)
 13451  	}
 13452  	size := p.Size()
 13453  	if len(dAtA) != size {
 13454  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13455  	}
 13456  	if size2 != size {
 13457  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13458  	}
 13459  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13460  	if size3 != size {
 13461  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13462  	}
 13463  }
 13464  
 13465  func BenchmarkNidRepCustomSize(b *testing.B) {
 13466  	popr := math_rand.New(math_rand.NewSource(616))
 13467  	total := 0
 13468  	pops := make([]*NidRepCustom, 1000)
 13469  	for i := 0; i < 1000; i++ {
 13470  		pops[i] = NewPopulatedNidRepCustom(popr, false)
 13471  	}
 13472  	b.ResetTimer()
 13473  	for i := 0; i < b.N; i++ {
 13474  		total += pops[i%1000].Size()
 13475  	}
 13476  	b.SetBytes(int64(total / b.N))
 13477  }
 13478  
 13479  func TestNinRepCustomSize(t *testing.T) {
 13480  	seed := time.Now().UnixNano()
 13481  	popr := math_rand.New(math_rand.NewSource(seed))
 13482  	p := NewPopulatedNinRepCustom(popr, true)
 13483  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13484  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13485  	if err != nil {
 13486  		t.Fatalf("seed = %d, err = %v", seed, err)
 13487  	}
 13488  	size := p.Size()
 13489  	if len(dAtA) != size {
 13490  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13491  	}
 13492  	if size2 != size {
 13493  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13494  	}
 13495  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13496  	if size3 != size {
 13497  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13498  	}
 13499  }
 13500  
 13501  func BenchmarkNinRepCustomSize(b *testing.B) {
 13502  	popr := math_rand.New(math_rand.NewSource(616))
 13503  	total := 0
 13504  	pops := make([]*NinRepCustom, 1000)
 13505  	for i := 0; i < 1000; i++ {
 13506  		pops[i] = NewPopulatedNinRepCustom(popr, false)
 13507  	}
 13508  	b.ResetTimer()
 13509  	for i := 0; i < b.N; i++ {
 13510  		total += pops[i%1000].Size()
 13511  	}
 13512  	b.SetBytes(int64(total / b.N))
 13513  }
 13514  
 13515  func TestNinOptNativeUnionSize(t *testing.T) {
 13516  	seed := time.Now().UnixNano()
 13517  	popr := math_rand.New(math_rand.NewSource(seed))
 13518  	p := NewPopulatedNinOptNativeUnion(popr, true)
 13519  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13520  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13521  	if err != nil {
 13522  		t.Fatalf("seed = %d, err = %v", seed, err)
 13523  	}
 13524  	size := p.Size()
 13525  	if len(dAtA) != size {
 13526  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13527  	}
 13528  	if size2 != size {
 13529  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13530  	}
 13531  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13532  	if size3 != size {
 13533  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13534  	}
 13535  }
 13536  
 13537  func BenchmarkNinOptNativeUnionSize(b *testing.B) {
 13538  	popr := math_rand.New(math_rand.NewSource(616))
 13539  	total := 0
 13540  	pops := make([]*NinOptNativeUnion, 1000)
 13541  	for i := 0; i < 1000; i++ {
 13542  		pops[i] = NewPopulatedNinOptNativeUnion(popr, false)
 13543  	}
 13544  	b.ResetTimer()
 13545  	for i := 0; i < b.N; i++ {
 13546  		total += pops[i%1000].Size()
 13547  	}
 13548  	b.SetBytes(int64(total / b.N))
 13549  }
 13550  
 13551  func TestNinOptStructUnionSize(t *testing.T) {
 13552  	seed := time.Now().UnixNano()
 13553  	popr := math_rand.New(math_rand.NewSource(seed))
 13554  	p := NewPopulatedNinOptStructUnion(popr, true)
 13555  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13556  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13557  	if err != nil {
 13558  		t.Fatalf("seed = %d, err = %v", seed, err)
 13559  	}
 13560  	size := p.Size()
 13561  	if len(dAtA) != size {
 13562  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13563  	}
 13564  	if size2 != size {
 13565  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13566  	}
 13567  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13568  	if size3 != size {
 13569  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13570  	}
 13571  }
 13572  
 13573  func BenchmarkNinOptStructUnionSize(b *testing.B) {
 13574  	popr := math_rand.New(math_rand.NewSource(616))
 13575  	total := 0
 13576  	pops := make([]*NinOptStructUnion, 1000)
 13577  	for i := 0; i < 1000; i++ {
 13578  		pops[i] = NewPopulatedNinOptStructUnion(popr, false)
 13579  	}
 13580  	b.ResetTimer()
 13581  	for i := 0; i < b.N; i++ {
 13582  		total += pops[i%1000].Size()
 13583  	}
 13584  	b.SetBytes(int64(total / b.N))
 13585  }
 13586  
 13587  func TestNinEmbeddedStructUnionSize(t *testing.T) {
 13588  	seed := time.Now().UnixNano()
 13589  	popr := math_rand.New(math_rand.NewSource(seed))
 13590  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 13591  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13592  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13593  	if err != nil {
 13594  		t.Fatalf("seed = %d, err = %v", seed, err)
 13595  	}
 13596  	size := p.Size()
 13597  	if len(dAtA) != size {
 13598  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13599  	}
 13600  	if size2 != size {
 13601  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13602  	}
 13603  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13604  	if size3 != size {
 13605  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13606  	}
 13607  }
 13608  
 13609  func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) {
 13610  	popr := math_rand.New(math_rand.NewSource(616))
 13611  	total := 0
 13612  	pops := make([]*NinEmbeddedStructUnion, 1000)
 13613  	for i := 0; i < 1000; i++ {
 13614  		pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false)
 13615  	}
 13616  	b.ResetTimer()
 13617  	for i := 0; i < b.N; i++ {
 13618  		total += pops[i%1000].Size()
 13619  	}
 13620  	b.SetBytes(int64(total / b.N))
 13621  }
 13622  
 13623  func TestNinNestedStructUnionSize(t *testing.T) {
 13624  	seed := time.Now().UnixNano()
 13625  	popr := math_rand.New(math_rand.NewSource(seed))
 13626  	p := NewPopulatedNinNestedStructUnion(popr, true)
 13627  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13628  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13629  	if err != nil {
 13630  		t.Fatalf("seed = %d, err = %v", seed, err)
 13631  	}
 13632  	size := p.Size()
 13633  	if len(dAtA) != size {
 13634  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13635  	}
 13636  	if size2 != size {
 13637  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13638  	}
 13639  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13640  	if size3 != size {
 13641  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13642  	}
 13643  }
 13644  
 13645  func BenchmarkNinNestedStructUnionSize(b *testing.B) {
 13646  	popr := math_rand.New(math_rand.NewSource(616))
 13647  	total := 0
 13648  	pops := make([]*NinNestedStructUnion, 1000)
 13649  	for i := 0; i < 1000; i++ {
 13650  		pops[i] = NewPopulatedNinNestedStructUnion(popr, false)
 13651  	}
 13652  	b.ResetTimer()
 13653  	for i := 0; i < b.N; i++ {
 13654  		total += pops[i%1000].Size()
 13655  	}
 13656  	b.SetBytes(int64(total / b.N))
 13657  }
 13658  
 13659  func TestTreeSize(t *testing.T) {
 13660  	seed := time.Now().UnixNano()
 13661  	popr := math_rand.New(math_rand.NewSource(seed))
 13662  	p := NewPopulatedTree(popr, true)
 13663  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13664  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13665  	if err != nil {
 13666  		t.Fatalf("seed = %d, err = %v", seed, err)
 13667  	}
 13668  	size := p.Size()
 13669  	if len(dAtA) != size {
 13670  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13671  	}
 13672  	if size2 != size {
 13673  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13674  	}
 13675  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13676  	if size3 != size {
 13677  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13678  	}
 13679  }
 13680  
 13681  func BenchmarkTreeSize(b *testing.B) {
 13682  	popr := math_rand.New(math_rand.NewSource(616))
 13683  	total := 0
 13684  	pops := make([]*Tree, 1000)
 13685  	for i := 0; i < 1000; i++ {
 13686  		pops[i] = NewPopulatedTree(popr, false)
 13687  	}
 13688  	b.ResetTimer()
 13689  	for i := 0; i < b.N; i++ {
 13690  		total += pops[i%1000].Size()
 13691  	}
 13692  	b.SetBytes(int64(total / b.N))
 13693  }
 13694  
 13695  func TestOrBranchSize(t *testing.T) {
 13696  	seed := time.Now().UnixNano()
 13697  	popr := math_rand.New(math_rand.NewSource(seed))
 13698  	p := NewPopulatedOrBranch(popr, true)
 13699  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13700  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13701  	if err != nil {
 13702  		t.Fatalf("seed = %d, err = %v", seed, err)
 13703  	}
 13704  	size := p.Size()
 13705  	if len(dAtA) != size {
 13706  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13707  	}
 13708  	if size2 != size {
 13709  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13710  	}
 13711  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13712  	if size3 != size {
 13713  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13714  	}
 13715  }
 13716  
 13717  func BenchmarkOrBranchSize(b *testing.B) {
 13718  	popr := math_rand.New(math_rand.NewSource(616))
 13719  	total := 0
 13720  	pops := make([]*OrBranch, 1000)
 13721  	for i := 0; i < 1000; i++ {
 13722  		pops[i] = NewPopulatedOrBranch(popr, false)
 13723  	}
 13724  	b.ResetTimer()
 13725  	for i := 0; i < b.N; i++ {
 13726  		total += pops[i%1000].Size()
 13727  	}
 13728  	b.SetBytes(int64(total / b.N))
 13729  }
 13730  
 13731  func TestAndBranchSize(t *testing.T) {
 13732  	seed := time.Now().UnixNano()
 13733  	popr := math_rand.New(math_rand.NewSource(seed))
 13734  	p := NewPopulatedAndBranch(popr, true)
 13735  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13736  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13737  	if err != nil {
 13738  		t.Fatalf("seed = %d, err = %v", seed, err)
 13739  	}
 13740  	size := p.Size()
 13741  	if len(dAtA) != size {
 13742  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13743  	}
 13744  	if size2 != size {
 13745  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13746  	}
 13747  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13748  	if size3 != size {
 13749  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13750  	}
 13751  }
 13752  
 13753  func BenchmarkAndBranchSize(b *testing.B) {
 13754  	popr := math_rand.New(math_rand.NewSource(616))
 13755  	total := 0
 13756  	pops := make([]*AndBranch, 1000)
 13757  	for i := 0; i < 1000; i++ {
 13758  		pops[i] = NewPopulatedAndBranch(popr, false)
 13759  	}
 13760  	b.ResetTimer()
 13761  	for i := 0; i < b.N; i++ {
 13762  		total += pops[i%1000].Size()
 13763  	}
 13764  	b.SetBytes(int64(total / b.N))
 13765  }
 13766  
 13767  func TestLeafSize(t *testing.T) {
 13768  	seed := time.Now().UnixNano()
 13769  	popr := math_rand.New(math_rand.NewSource(seed))
 13770  	p := NewPopulatedLeaf(popr, true)
 13771  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13772  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13773  	if err != nil {
 13774  		t.Fatalf("seed = %d, err = %v", seed, err)
 13775  	}
 13776  	size := p.Size()
 13777  	if len(dAtA) != size {
 13778  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13779  	}
 13780  	if size2 != size {
 13781  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13782  	}
 13783  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13784  	if size3 != size {
 13785  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13786  	}
 13787  }
 13788  
 13789  func BenchmarkLeafSize(b *testing.B) {
 13790  	popr := math_rand.New(math_rand.NewSource(616))
 13791  	total := 0
 13792  	pops := make([]*Leaf, 1000)
 13793  	for i := 0; i < 1000; i++ {
 13794  		pops[i] = NewPopulatedLeaf(popr, false)
 13795  	}
 13796  	b.ResetTimer()
 13797  	for i := 0; i < b.N; i++ {
 13798  		total += pops[i%1000].Size()
 13799  	}
 13800  	b.SetBytes(int64(total / b.N))
 13801  }
 13802  
 13803  func TestDeepTreeSize(t *testing.T) {
 13804  	seed := time.Now().UnixNano()
 13805  	popr := math_rand.New(math_rand.NewSource(seed))
 13806  	p := NewPopulatedDeepTree(popr, true)
 13807  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13808  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13809  	if err != nil {
 13810  		t.Fatalf("seed = %d, err = %v", seed, err)
 13811  	}
 13812  	size := p.Size()
 13813  	if len(dAtA) != size {
 13814  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13815  	}
 13816  	if size2 != size {
 13817  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13818  	}
 13819  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13820  	if size3 != size {
 13821  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13822  	}
 13823  }
 13824  
 13825  func BenchmarkDeepTreeSize(b *testing.B) {
 13826  	popr := math_rand.New(math_rand.NewSource(616))
 13827  	total := 0
 13828  	pops := make([]*DeepTree, 1000)
 13829  	for i := 0; i < 1000; i++ {
 13830  		pops[i] = NewPopulatedDeepTree(popr, false)
 13831  	}
 13832  	b.ResetTimer()
 13833  	for i := 0; i < b.N; i++ {
 13834  		total += pops[i%1000].Size()
 13835  	}
 13836  	b.SetBytes(int64(total / b.N))
 13837  }
 13838  
 13839  func TestADeepBranchSize(t *testing.T) {
 13840  	seed := time.Now().UnixNano()
 13841  	popr := math_rand.New(math_rand.NewSource(seed))
 13842  	p := NewPopulatedADeepBranch(popr, true)
 13843  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13844  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13845  	if err != nil {
 13846  		t.Fatalf("seed = %d, err = %v", seed, err)
 13847  	}
 13848  	size := p.Size()
 13849  	if len(dAtA) != size {
 13850  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13851  	}
 13852  	if size2 != size {
 13853  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13854  	}
 13855  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13856  	if size3 != size {
 13857  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13858  	}
 13859  }
 13860  
 13861  func BenchmarkADeepBranchSize(b *testing.B) {
 13862  	popr := math_rand.New(math_rand.NewSource(616))
 13863  	total := 0
 13864  	pops := make([]*ADeepBranch, 1000)
 13865  	for i := 0; i < 1000; i++ {
 13866  		pops[i] = NewPopulatedADeepBranch(popr, false)
 13867  	}
 13868  	b.ResetTimer()
 13869  	for i := 0; i < b.N; i++ {
 13870  		total += pops[i%1000].Size()
 13871  	}
 13872  	b.SetBytes(int64(total / b.N))
 13873  }
 13874  
 13875  func TestAndDeepBranchSize(t *testing.T) {
 13876  	seed := time.Now().UnixNano()
 13877  	popr := math_rand.New(math_rand.NewSource(seed))
 13878  	p := NewPopulatedAndDeepBranch(popr, true)
 13879  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13880  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13881  	if err != nil {
 13882  		t.Fatalf("seed = %d, err = %v", seed, err)
 13883  	}
 13884  	size := p.Size()
 13885  	if len(dAtA) != size {
 13886  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13887  	}
 13888  	if size2 != size {
 13889  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13890  	}
 13891  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13892  	if size3 != size {
 13893  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13894  	}
 13895  }
 13896  
 13897  func BenchmarkAndDeepBranchSize(b *testing.B) {
 13898  	popr := math_rand.New(math_rand.NewSource(616))
 13899  	total := 0
 13900  	pops := make([]*AndDeepBranch, 1000)
 13901  	for i := 0; i < 1000; i++ {
 13902  		pops[i] = NewPopulatedAndDeepBranch(popr, false)
 13903  	}
 13904  	b.ResetTimer()
 13905  	for i := 0; i < b.N; i++ {
 13906  		total += pops[i%1000].Size()
 13907  	}
 13908  	b.SetBytes(int64(total / b.N))
 13909  }
 13910  
 13911  func TestDeepLeafSize(t *testing.T) {
 13912  	seed := time.Now().UnixNano()
 13913  	popr := math_rand.New(math_rand.NewSource(seed))
 13914  	p := NewPopulatedDeepLeaf(popr, true)
 13915  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13916  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13917  	if err != nil {
 13918  		t.Fatalf("seed = %d, err = %v", seed, err)
 13919  	}
 13920  	size := p.Size()
 13921  	if len(dAtA) != size {
 13922  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13923  	}
 13924  	if size2 != size {
 13925  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13926  	}
 13927  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13928  	if size3 != size {
 13929  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13930  	}
 13931  }
 13932  
 13933  func BenchmarkDeepLeafSize(b *testing.B) {
 13934  	popr := math_rand.New(math_rand.NewSource(616))
 13935  	total := 0
 13936  	pops := make([]*DeepLeaf, 1000)
 13937  	for i := 0; i < 1000; i++ {
 13938  		pops[i] = NewPopulatedDeepLeaf(popr, false)
 13939  	}
 13940  	b.ResetTimer()
 13941  	for i := 0; i < b.N; i++ {
 13942  		total += pops[i%1000].Size()
 13943  	}
 13944  	b.SetBytes(int64(total / b.N))
 13945  }
 13946  
 13947  func TestNilSize(t *testing.T) {
 13948  	seed := time.Now().UnixNano()
 13949  	popr := math_rand.New(math_rand.NewSource(seed))
 13950  	p := NewPopulatedNil(popr, true)
 13951  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13952  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13953  	if err != nil {
 13954  		t.Fatalf("seed = %d, err = %v", seed, err)
 13955  	}
 13956  	size := p.Size()
 13957  	if len(dAtA) != size {
 13958  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13959  	}
 13960  	if size2 != size {
 13961  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13962  	}
 13963  	size3 := github_com_gogo_protobuf_proto.Size(p)
 13964  	if size3 != size {
 13965  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 13966  	}
 13967  }
 13968  
 13969  func BenchmarkNilSize(b *testing.B) {
 13970  	popr := math_rand.New(math_rand.NewSource(616))
 13971  	total := 0
 13972  	pops := make([]*Nil, 1000)
 13973  	for i := 0; i < 1000; i++ {
 13974  		pops[i] = NewPopulatedNil(popr, false)
 13975  	}
 13976  	b.ResetTimer()
 13977  	for i := 0; i < b.N; i++ {
 13978  		total += pops[i%1000].Size()
 13979  	}
 13980  	b.SetBytes(int64(total / b.N))
 13981  }
 13982  
 13983  func TestNidOptEnumSize(t *testing.T) {
 13984  	seed := time.Now().UnixNano()
 13985  	popr := math_rand.New(math_rand.NewSource(seed))
 13986  	p := NewPopulatedNidOptEnum(popr, true)
 13987  	size2 := github_com_gogo_protobuf_proto.Size(p)
 13988  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 13989  	if err != nil {
 13990  		t.Fatalf("seed = %d, err = %v", seed, err)
 13991  	}
 13992  	size := p.Size()
 13993  	if len(dAtA) != size {
 13994  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 13995  	}
 13996  	if size2 != size {
 13997  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 13998  	}
 13999  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14000  	if size3 != size {
 14001  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14002  	}
 14003  }
 14004  
 14005  func BenchmarkNidOptEnumSize(b *testing.B) {
 14006  	popr := math_rand.New(math_rand.NewSource(616))
 14007  	total := 0
 14008  	pops := make([]*NidOptEnum, 1000)
 14009  	for i := 0; i < 1000; i++ {
 14010  		pops[i] = NewPopulatedNidOptEnum(popr, false)
 14011  	}
 14012  	b.ResetTimer()
 14013  	for i := 0; i < b.N; i++ {
 14014  		total += pops[i%1000].Size()
 14015  	}
 14016  	b.SetBytes(int64(total / b.N))
 14017  }
 14018  
 14019  func TestNinOptEnumSize(t *testing.T) {
 14020  	seed := time.Now().UnixNano()
 14021  	popr := math_rand.New(math_rand.NewSource(seed))
 14022  	p := NewPopulatedNinOptEnum(popr, true)
 14023  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14024  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14025  	if err != nil {
 14026  		t.Fatalf("seed = %d, err = %v", seed, err)
 14027  	}
 14028  	size := p.Size()
 14029  	if len(dAtA) != size {
 14030  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14031  	}
 14032  	if size2 != size {
 14033  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14034  	}
 14035  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14036  	if size3 != size {
 14037  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14038  	}
 14039  }
 14040  
 14041  func BenchmarkNinOptEnumSize(b *testing.B) {
 14042  	popr := math_rand.New(math_rand.NewSource(616))
 14043  	total := 0
 14044  	pops := make([]*NinOptEnum, 1000)
 14045  	for i := 0; i < 1000; i++ {
 14046  		pops[i] = NewPopulatedNinOptEnum(popr, false)
 14047  	}
 14048  	b.ResetTimer()
 14049  	for i := 0; i < b.N; i++ {
 14050  		total += pops[i%1000].Size()
 14051  	}
 14052  	b.SetBytes(int64(total / b.N))
 14053  }
 14054  
 14055  func TestNidRepEnumSize(t *testing.T) {
 14056  	seed := time.Now().UnixNano()
 14057  	popr := math_rand.New(math_rand.NewSource(seed))
 14058  	p := NewPopulatedNidRepEnum(popr, true)
 14059  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14060  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14061  	if err != nil {
 14062  		t.Fatalf("seed = %d, err = %v", seed, err)
 14063  	}
 14064  	size := p.Size()
 14065  	if len(dAtA) != size {
 14066  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14067  	}
 14068  	if size2 != size {
 14069  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14070  	}
 14071  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14072  	if size3 != size {
 14073  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14074  	}
 14075  }
 14076  
 14077  func BenchmarkNidRepEnumSize(b *testing.B) {
 14078  	popr := math_rand.New(math_rand.NewSource(616))
 14079  	total := 0
 14080  	pops := make([]*NidRepEnum, 1000)
 14081  	for i := 0; i < 1000; i++ {
 14082  		pops[i] = NewPopulatedNidRepEnum(popr, false)
 14083  	}
 14084  	b.ResetTimer()
 14085  	for i := 0; i < b.N; i++ {
 14086  		total += pops[i%1000].Size()
 14087  	}
 14088  	b.SetBytes(int64(total / b.N))
 14089  }
 14090  
 14091  func TestNinRepEnumSize(t *testing.T) {
 14092  	seed := time.Now().UnixNano()
 14093  	popr := math_rand.New(math_rand.NewSource(seed))
 14094  	p := NewPopulatedNinRepEnum(popr, true)
 14095  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14096  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14097  	if err != nil {
 14098  		t.Fatalf("seed = %d, err = %v", seed, err)
 14099  	}
 14100  	size := p.Size()
 14101  	if len(dAtA) != size {
 14102  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14103  	}
 14104  	if size2 != size {
 14105  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14106  	}
 14107  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14108  	if size3 != size {
 14109  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14110  	}
 14111  }
 14112  
 14113  func BenchmarkNinRepEnumSize(b *testing.B) {
 14114  	popr := math_rand.New(math_rand.NewSource(616))
 14115  	total := 0
 14116  	pops := make([]*NinRepEnum, 1000)
 14117  	for i := 0; i < 1000; i++ {
 14118  		pops[i] = NewPopulatedNinRepEnum(popr, false)
 14119  	}
 14120  	b.ResetTimer()
 14121  	for i := 0; i < b.N; i++ {
 14122  		total += pops[i%1000].Size()
 14123  	}
 14124  	b.SetBytes(int64(total / b.N))
 14125  }
 14126  
 14127  func TestNinOptEnumDefaultSize(t *testing.T) {
 14128  	seed := time.Now().UnixNano()
 14129  	popr := math_rand.New(math_rand.NewSource(seed))
 14130  	p := NewPopulatedNinOptEnumDefault(popr, true)
 14131  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14132  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14133  	if err != nil {
 14134  		t.Fatalf("seed = %d, err = %v", seed, err)
 14135  	}
 14136  	size := p.Size()
 14137  	if len(dAtA) != size {
 14138  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14139  	}
 14140  	if size2 != size {
 14141  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14142  	}
 14143  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14144  	if size3 != size {
 14145  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14146  	}
 14147  }
 14148  
 14149  func BenchmarkNinOptEnumDefaultSize(b *testing.B) {
 14150  	popr := math_rand.New(math_rand.NewSource(616))
 14151  	total := 0
 14152  	pops := make([]*NinOptEnumDefault, 1000)
 14153  	for i := 0; i < 1000; i++ {
 14154  		pops[i] = NewPopulatedNinOptEnumDefault(popr, false)
 14155  	}
 14156  	b.ResetTimer()
 14157  	for i := 0; i < b.N; i++ {
 14158  		total += pops[i%1000].Size()
 14159  	}
 14160  	b.SetBytes(int64(total / b.N))
 14161  }
 14162  
 14163  func TestAnotherNinOptEnumSize(t *testing.T) {
 14164  	seed := time.Now().UnixNano()
 14165  	popr := math_rand.New(math_rand.NewSource(seed))
 14166  	p := NewPopulatedAnotherNinOptEnum(popr, true)
 14167  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14168  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14169  	if err != nil {
 14170  		t.Fatalf("seed = %d, err = %v", seed, err)
 14171  	}
 14172  	size := p.Size()
 14173  	if len(dAtA) != size {
 14174  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14175  	}
 14176  	if size2 != size {
 14177  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14178  	}
 14179  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14180  	if size3 != size {
 14181  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14182  	}
 14183  }
 14184  
 14185  func BenchmarkAnotherNinOptEnumSize(b *testing.B) {
 14186  	popr := math_rand.New(math_rand.NewSource(616))
 14187  	total := 0
 14188  	pops := make([]*AnotherNinOptEnum, 1000)
 14189  	for i := 0; i < 1000; i++ {
 14190  		pops[i] = NewPopulatedAnotherNinOptEnum(popr, false)
 14191  	}
 14192  	b.ResetTimer()
 14193  	for i := 0; i < b.N; i++ {
 14194  		total += pops[i%1000].Size()
 14195  	}
 14196  	b.SetBytes(int64(total / b.N))
 14197  }
 14198  
 14199  func TestAnotherNinOptEnumDefaultSize(t *testing.T) {
 14200  	seed := time.Now().UnixNano()
 14201  	popr := math_rand.New(math_rand.NewSource(seed))
 14202  	p := NewPopulatedAnotherNinOptEnumDefault(popr, true)
 14203  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14204  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14205  	if err != nil {
 14206  		t.Fatalf("seed = %d, err = %v", seed, err)
 14207  	}
 14208  	size := p.Size()
 14209  	if len(dAtA) != size {
 14210  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14211  	}
 14212  	if size2 != size {
 14213  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14214  	}
 14215  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14216  	if size3 != size {
 14217  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14218  	}
 14219  }
 14220  
 14221  func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) {
 14222  	popr := math_rand.New(math_rand.NewSource(616))
 14223  	total := 0
 14224  	pops := make([]*AnotherNinOptEnumDefault, 1000)
 14225  	for i := 0; i < 1000; i++ {
 14226  		pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false)
 14227  	}
 14228  	b.ResetTimer()
 14229  	for i := 0; i < b.N; i++ {
 14230  		total += pops[i%1000].Size()
 14231  	}
 14232  	b.SetBytes(int64(total / b.N))
 14233  }
 14234  
 14235  func TestTimerSize(t *testing.T) {
 14236  	seed := time.Now().UnixNano()
 14237  	popr := math_rand.New(math_rand.NewSource(seed))
 14238  	p := NewPopulatedTimer(popr, true)
 14239  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14240  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14241  	if err != nil {
 14242  		t.Fatalf("seed = %d, err = %v", seed, err)
 14243  	}
 14244  	size := p.Size()
 14245  	if len(dAtA) != size {
 14246  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14247  	}
 14248  	if size2 != size {
 14249  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14250  	}
 14251  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14252  	if size3 != size {
 14253  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14254  	}
 14255  }
 14256  
 14257  func BenchmarkTimerSize(b *testing.B) {
 14258  	popr := math_rand.New(math_rand.NewSource(616))
 14259  	total := 0
 14260  	pops := make([]*Timer, 1000)
 14261  	for i := 0; i < 1000; i++ {
 14262  		pops[i] = NewPopulatedTimer(popr, false)
 14263  	}
 14264  	b.ResetTimer()
 14265  	for i := 0; i < b.N; i++ {
 14266  		total += pops[i%1000].Size()
 14267  	}
 14268  	b.SetBytes(int64(total / b.N))
 14269  }
 14270  
 14271  func TestMyExtendableSize(t *testing.T) {
 14272  	seed := time.Now().UnixNano()
 14273  	popr := math_rand.New(math_rand.NewSource(seed))
 14274  	p := NewPopulatedMyExtendable(popr, true)
 14275  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14276  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14277  	if err != nil {
 14278  		t.Fatalf("seed = %d, err = %v", seed, err)
 14279  	}
 14280  	size := p.Size()
 14281  	if len(dAtA) != size {
 14282  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14283  	}
 14284  	if size2 != size {
 14285  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14286  	}
 14287  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14288  	if size3 != size {
 14289  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14290  	}
 14291  }
 14292  
 14293  func BenchmarkMyExtendableSize(b *testing.B) {
 14294  	popr := math_rand.New(math_rand.NewSource(616))
 14295  	total := 0
 14296  	pops := make([]*MyExtendable, 1000)
 14297  	for i := 0; i < 1000; i++ {
 14298  		pops[i] = NewPopulatedMyExtendable(popr, false)
 14299  	}
 14300  	b.ResetTimer()
 14301  	for i := 0; i < b.N; i++ {
 14302  		total += pops[i%1000].Size()
 14303  	}
 14304  	b.SetBytes(int64(total / b.N))
 14305  }
 14306  
 14307  func TestOtherExtenableSize(t *testing.T) {
 14308  	seed := time.Now().UnixNano()
 14309  	popr := math_rand.New(math_rand.NewSource(seed))
 14310  	p := NewPopulatedOtherExtenable(popr, true)
 14311  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14312  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14313  	if err != nil {
 14314  		t.Fatalf("seed = %d, err = %v", seed, err)
 14315  	}
 14316  	size := p.Size()
 14317  	if len(dAtA) != size {
 14318  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14319  	}
 14320  	if size2 != size {
 14321  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14322  	}
 14323  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14324  	if size3 != size {
 14325  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14326  	}
 14327  }
 14328  
 14329  func BenchmarkOtherExtenableSize(b *testing.B) {
 14330  	popr := math_rand.New(math_rand.NewSource(616))
 14331  	total := 0
 14332  	pops := make([]*OtherExtenable, 1000)
 14333  	for i := 0; i < 1000; i++ {
 14334  		pops[i] = NewPopulatedOtherExtenable(popr, false)
 14335  	}
 14336  	b.ResetTimer()
 14337  	for i := 0; i < b.N; i++ {
 14338  		total += pops[i%1000].Size()
 14339  	}
 14340  	b.SetBytes(int64(total / b.N))
 14341  }
 14342  
 14343  func TestNestedDefinitionSize(t *testing.T) {
 14344  	seed := time.Now().UnixNano()
 14345  	popr := math_rand.New(math_rand.NewSource(seed))
 14346  	p := NewPopulatedNestedDefinition(popr, true)
 14347  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14348  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14349  	if err != nil {
 14350  		t.Fatalf("seed = %d, err = %v", seed, err)
 14351  	}
 14352  	size := p.Size()
 14353  	if len(dAtA) != size {
 14354  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14355  	}
 14356  	if size2 != size {
 14357  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14358  	}
 14359  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14360  	if size3 != size {
 14361  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14362  	}
 14363  }
 14364  
 14365  func BenchmarkNestedDefinitionSize(b *testing.B) {
 14366  	popr := math_rand.New(math_rand.NewSource(616))
 14367  	total := 0
 14368  	pops := make([]*NestedDefinition, 1000)
 14369  	for i := 0; i < 1000; i++ {
 14370  		pops[i] = NewPopulatedNestedDefinition(popr, false)
 14371  	}
 14372  	b.ResetTimer()
 14373  	for i := 0; i < b.N; i++ {
 14374  		total += pops[i%1000].Size()
 14375  	}
 14376  	b.SetBytes(int64(total / b.N))
 14377  }
 14378  
 14379  func TestNestedDefinition_NestedMessageSize(t *testing.T) {
 14380  	seed := time.Now().UnixNano()
 14381  	popr := math_rand.New(math_rand.NewSource(seed))
 14382  	p := NewPopulatedNestedDefinition_NestedMessage(popr, true)
 14383  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14384  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14385  	if err != nil {
 14386  		t.Fatalf("seed = %d, err = %v", seed, err)
 14387  	}
 14388  	size := p.Size()
 14389  	if len(dAtA) != size {
 14390  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14391  	}
 14392  	if size2 != size {
 14393  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14394  	}
 14395  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14396  	if size3 != size {
 14397  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14398  	}
 14399  }
 14400  
 14401  func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) {
 14402  	popr := math_rand.New(math_rand.NewSource(616))
 14403  	total := 0
 14404  	pops := make([]*NestedDefinition_NestedMessage, 1000)
 14405  	for i := 0; i < 1000; i++ {
 14406  		pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false)
 14407  	}
 14408  	b.ResetTimer()
 14409  	for i := 0; i < b.N; i++ {
 14410  		total += pops[i%1000].Size()
 14411  	}
 14412  	b.SetBytes(int64(total / b.N))
 14413  }
 14414  
 14415  func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) {
 14416  	seed := time.Now().UnixNano()
 14417  	popr := math_rand.New(math_rand.NewSource(seed))
 14418  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true)
 14419  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14420  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14421  	if err != nil {
 14422  		t.Fatalf("seed = %d, err = %v", seed, err)
 14423  	}
 14424  	size := p.Size()
 14425  	if len(dAtA) != size {
 14426  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14427  	}
 14428  	if size2 != size {
 14429  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14430  	}
 14431  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14432  	if size3 != size {
 14433  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14434  	}
 14435  }
 14436  
 14437  func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) {
 14438  	popr := math_rand.New(math_rand.NewSource(616))
 14439  	total := 0
 14440  	pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000)
 14441  	for i := 0; i < 1000; i++ {
 14442  		pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 14443  	}
 14444  	b.ResetTimer()
 14445  	for i := 0; i < b.N; i++ {
 14446  		total += pops[i%1000].Size()
 14447  	}
 14448  	b.SetBytes(int64(total / b.N))
 14449  }
 14450  
 14451  func TestNestedScopeSize(t *testing.T) {
 14452  	seed := time.Now().UnixNano()
 14453  	popr := math_rand.New(math_rand.NewSource(seed))
 14454  	p := NewPopulatedNestedScope(popr, true)
 14455  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14456  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14457  	if err != nil {
 14458  		t.Fatalf("seed = %d, err = %v", seed, err)
 14459  	}
 14460  	size := p.Size()
 14461  	if len(dAtA) != size {
 14462  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14463  	}
 14464  	if size2 != size {
 14465  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14466  	}
 14467  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14468  	if size3 != size {
 14469  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14470  	}
 14471  }
 14472  
 14473  func BenchmarkNestedScopeSize(b *testing.B) {
 14474  	popr := math_rand.New(math_rand.NewSource(616))
 14475  	total := 0
 14476  	pops := make([]*NestedScope, 1000)
 14477  	for i := 0; i < 1000; i++ {
 14478  		pops[i] = NewPopulatedNestedScope(popr, false)
 14479  	}
 14480  	b.ResetTimer()
 14481  	for i := 0; i < b.N; i++ {
 14482  		total += pops[i%1000].Size()
 14483  	}
 14484  	b.SetBytes(int64(total / b.N))
 14485  }
 14486  
 14487  func TestNinOptNativeDefaultSize(t *testing.T) {
 14488  	seed := time.Now().UnixNano()
 14489  	popr := math_rand.New(math_rand.NewSource(seed))
 14490  	p := NewPopulatedNinOptNativeDefault(popr, true)
 14491  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14492  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14493  	if err != nil {
 14494  		t.Fatalf("seed = %d, err = %v", seed, err)
 14495  	}
 14496  	size := p.Size()
 14497  	if len(dAtA) != size {
 14498  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14499  	}
 14500  	if size2 != size {
 14501  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14502  	}
 14503  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14504  	if size3 != size {
 14505  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14506  	}
 14507  }
 14508  
 14509  func BenchmarkNinOptNativeDefaultSize(b *testing.B) {
 14510  	popr := math_rand.New(math_rand.NewSource(616))
 14511  	total := 0
 14512  	pops := make([]*NinOptNativeDefault, 1000)
 14513  	for i := 0; i < 1000; i++ {
 14514  		pops[i] = NewPopulatedNinOptNativeDefault(popr, false)
 14515  	}
 14516  	b.ResetTimer()
 14517  	for i := 0; i < b.N; i++ {
 14518  		total += pops[i%1000].Size()
 14519  	}
 14520  	b.SetBytes(int64(total / b.N))
 14521  }
 14522  
 14523  func TestCustomContainerSize(t *testing.T) {
 14524  	seed := time.Now().UnixNano()
 14525  	popr := math_rand.New(math_rand.NewSource(seed))
 14526  	p := NewPopulatedCustomContainer(popr, true)
 14527  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14528  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14529  	if err != nil {
 14530  		t.Fatalf("seed = %d, err = %v", seed, err)
 14531  	}
 14532  	size := p.Size()
 14533  	if len(dAtA) != size {
 14534  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14535  	}
 14536  	if size2 != size {
 14537  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14538  	}
 14539  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14540  	if size3 != size {
 14541  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14542  	}
 14543  }
 14544  
 14545  func BenchmarkCustomContainerSize(b *testing.B) {
 14546  	popr := math_rand.New(math_rand.NewSource(616))
 14547  	total := 0
 14548  	pops := make([]*CustomContainer, 1000)
 14549  	for i := 0; i < 1000; i++ {
 14550  		pops[i] = NewPopulatedCustomContainer(popr, false)
 14551  	}
 14552  	b.ResetTimer()
 14553  	for i := 0; i < b.N; i++ {
 14554  		total += pops[i%1000].Size()
 14555  	}
 14556  	b.SetBytes(int64(total / b.N))
 14557  }
 14558  
 14559  func TestCustomNameNidOptNativeSize(t *testing.T) {
 14560  	seed := time.Now().UnixNano()
 14561  	popr := math_rand.New(math_rand.NewSource(seed))
 14562  	p := NewPopulatedCustomNameNidOptNative(popr, true)
 14563  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14564  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14565  	if err != nil {
 14566  		t.Fatalf("seed = %d, err = %v", seed, err)
 14567  	}
 14568  	size := p.Size()
 14569  	if len(dAtA) != size {
 14570  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14571  	}
 14572  	if size2 != size {
 14573  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14574  	}
 14575  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14576  	if size3 != size {
 14577  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14578  	}
 14579  }
 14580  
 14581  func BenchmarkCustomNameNidOptNativeSize(b *testing.B) {
 14582  	popr := math_rand.New(math_rand.NewSource(616))
 14583  	total := 0
 14584  	pops := make([]*CustomNameNidOptNative, 1000)
 14585  	for i := 0; i < 1000; i++ {
 14586  		pops[i] = NewPopulatedCustomNameNidOptNative(popr, false)
 14587  	}
 14588  	b.ResetTimer()
 14589  	for i := 0; i < b.N; i++ {
 14590  		total += pops[i%1000].Size()
 14591  	}
 14592  	b.SetBytes(int64(total / b.N))
 14593  }
 14594  
 14595  func TestCustomNameNinOptNativeSize(t *testing.T) {
 14596  	seed := time.Now().UnixNano()
 14597  	popr := math_rand.New(math_rand.NewSource(seed))
 14598  	p := NewPopulatedCustomNameNinOptNative(popr, true)
 14599  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14600  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14601  	if err != nil {
 14602  		t.Fatalf("seed = %d, err = %v", seed, err)
 14603  	}
 14604  	size := p.Size()
 14605  	if len(dAtA) != size {
 14606  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14607  	}
 14608  	if size2 != size {
 14609  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14610  	}
 14611  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14612  	if size3 != size {
 14613  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14614  	}
 14615  }
 14616  
 14617  func BenchmarkCustomNameNinOptNativeSize(b *testing.B) {
 14618  	popr := math_rand.New(math_rand.NewSource(616))
 14619  	total := 0
 14620  	pops := make([]*CustomNameNinOptNative, 1000)
 14621  	for i := 0; i < 1000; i++ {
 14622  		pops[i] = NewPopulatedCustomNameNinOptNative(popr, false)
 14623  	}
 14624  	b.ResetTimer()
 14625  	for i := 0; i < b.N; i++ {
 14626  		total += pops[i%1000].Size()
 14627  	}
 14628  	b.SetBytes(int64(total / b.N))
 14629  }
 14630  
 14631  func TestCustomNameNinRepNativeSize(t *testing.T) {
 14632  	seed := time.Now().UnixNano()
 14633  	popr := math_rand.New(math_rand.NewSource(seed))
 14634  	p := NewPopulatedCustomNameNinRepNative(popr, true)
 14635  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14636  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14637  	if err != nil {
 14638  		t.Fatalf("seed = %d, err = %v", seed, err)
 14639  	}
 14640  	size := p.Size()
 14641  	if len(dAtA) != size {
 14642  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14643  	}
 14644  	if size2 != size {
 14645  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14646  	}
 14647  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14648  	if size3 != size {
 14649  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14650  	}
 14651  }
 14652  
 14653  func BenchmarkCustomNameNinRepNativeSize(b *testing.B) {
 14654  	popr := math_rand.New(math_rand.NewSource(616))
 14655  	total := 0
 14656  	pops := make([]*CustomNameNinRepNative, 1000)
 14657  	for i := 0; i < 1000; i++ {
 14658  		pops[i] = NewPopulatedCustomNameNinRepNative(popr, false)
 14659  	}
 14660  	b.ResetTimer()
 14661  	for i := 0; i < b.N; i++ {
 14662  		total += pops[i%1000].Size()
 14663  	}
 14664  	b.SetBytes(int64(total / b.N))
 14665  }
 14666  
 14667  func TestCustomNameNinStructSize(t *testing.T) {
 14668  	seed := time.Now().UnixNano()
 14669  	popr := math_rand.New(math_rand.NewSource(seed))
 14670  	p := NewPopulatedCustomNameNinStruct(popr, true)
 14671  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14672  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14673  	if err != nil {
 14674  		t.Fatalf("seed = %d, err = %v", seed, err)
 14675  	}
 14676  	size := p.Size()
 14677  	if len(dAtA) != size {
 14678  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14679  	}
 14680  	if size2 != size {
 14681  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14682  	}
 14683  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14684  	if size3 != size {
 14685  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14686  	}
 14687  }
 14688  
 14689  func BenchmarkCustomNameNinStructSize(b *testing.B) {
 14690  	popr := math_rand.New(math_rand.NewSource(616))
 14691  	total := 0
 14692  	pops := make([]*CustomNameNinStruct, 1000)
 14693  	for i := 0; i < 1000; i++ {
 14694  		pops[i] = NewPopulatedCustomNameNinStruct(popr, false)
 14695  	}
 14696  	b.ResetTimer()
 14697  	for i := 0; i < b.N; i++ {
 14698  		total += pops[i%1000].Size()
 14699  	}
 14700  	b.SetBytes(int64(total / b.N))
 14701  }
 14702  
 14703  func TestCustomNameCustomTypeSize(t *testing.T) {
 14704  	seed := time.Now().UnixNano()
 14705  	popr := math_rand.New(math_rand.NewSource(seed))
 14706  	p := NewPopulatedCustomNameCustomType(popr, true)
 14707  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14708  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14709  	if err != nil {
 14710  		t.Fatalf("seed = %d, err = %v", seed, err)
 14711  	}
 14712  	size := p.Size()
 14713  	if len(dAtA) != size {
 14714  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14715  	}
 14716  	if size2 != size {
 14717  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14718  	}
 14719  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14720  	if size3 != size {
 14721  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14722  	}
 14723  }
 14724  
 14725  func BenchmarkCustomNameCustomTypeSize(b *testing.B) {
 14726  	popr := math_rand.New(math_rand.NewSource(616))
 14727  	total := 0
 14728  	pops := make([]*CustomNameCustomType, 1000)
 14729  	for i := 0; i < 1000; i++ {
 14730  		pops[i] = NewPopulatedCustomNameCustomType(popr, false)
 14731  	}
 14732  	b.ResetTimer()
 14733  	for i := 0; i < b.N; i++ {
 14734  		total += pops[i%1000].Size()
 14735  	}
 14736  	b.SetBytes(int64(total / b.N))
 14737  }
 14738  
 14739  func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) {
 14740  	seed := time.Now().UnixNano()
 14741  	popr := math_rand.New(math_rand.NewSource(seed))
 14742  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 14743  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14744  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14745  	if err != nil {
 14746  		t.Fatalf("seed = %d, err = %v", seed, err)
 14747  	}
 14748  	size := p.Size()
 14749  	if len(dAtA) != size {
 14750  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14751  	}
 14752  	if size2 != size {
 14753  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14754  	}
 14755  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14756  	if size3 != size {
 14757  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14758  	}
 14759  }
 14760  
 14761  func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) {
 14762  	popr := math_rand.New(math_rand.NewSource(616))
 14763  	total := 0
 14764  	pops := make([]*CustomNameNinEmbeddedStructUnion, 1000)
 14765  	for i := 0; i < 1000; i++ {
 14766  		pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 14767  	}
 14768  	b.ResetTimer()
 14769  	for i := 0; i < b.N; i++ {
 14770  		total += pops[i%1000].Size()
 14771  	}
 14772  	b.SetBytes(int64(total / b.N))
 14773  }
 14774  
 14775  func TestCustomNameEnumSize(t *testing.T) {
 14776  	seed := time.Now().UnixNano()
 14777  	popr := math_rand.New(math_rand.NewSource(seed))
 14778  	p := NewPopulatedCustomNameEnum(popr, true)
 14779  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14780  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14781  	if err != nil {
 14782  		t.Fatalf("seed = %d, err = %v", seed, err)
 14783  	}
 14784  	size := p.Size()
 14785  	if len(dAtA) != size {
 14786  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14787  	}
 14788  	if size2 != size {
 14789  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14790  	}
 14791  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14792  	if size3 != size {
 14793  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14794  	}
 14795  }
 14796  
 14797  func BenchmarkCustomNameEnumSize(b *testing.B) {
 14798  	popr := math_rand.New(math_rand.NewSource(616))
 14799  	total := 0
 14800  	pops := make([]*CustomNameEnum, 1000)
 14801  	for i := 0; i < 1000; i++ {
 14802  		pops[i] = NewPopulatedCustomNameEnum(popr, false)
 14803  	}
 14804  	b.ResetTimer()
 14805  	for i := 0; i < b.N; i++ {
 14806  		total += pops[i%1000].Size()
 14807  	}
 14808  	b.SetBytes(int64(total / b.N))
 14809  }
 14810  
 14811  func TestNoExtensionsMapSize(t *testing.T) {
 14812  	seed := time.Now().UnixNano()
 14813  	popr := math_rand.New(math_rand.NewSource(seed))
 14814  	p := NewPopulatedNoExtensionsMap(popr, true)
 14815  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14816  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14817  	if err != nil {
 14818  		t.Fatalf("seed = %d, err = %v", seed, err)
 14819  	}
 14820  	size := p.Size()
 14821  	if len(dAtA) != size {
 14822  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14823  	}
 14824  	if size2 != size {
 14825  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14826  	}
 14827  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14828  	if size3 != size {
 14829  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14830  	}
 14831  }
 14832  
 14833  func BenchmarkNoExtensionsMapSize(b *testing.B) {
 14834  	popr := math_rand.New(math_rand.NewSource(616))
 14835  	total := 0
 14836  	pops := make([]*NoExtensionsMap, 1000)
 14837  	for i := 0; i < 1000; i++ {
 14838  		pops[i] = NewPopulatedNoExtensionsMap(popr, false)
 14839  	}
 14840  	b.ResetTimer()
 14841  	for i := 0; i < b.N; i++ {
 14842  		total += pops[i%1000].Size()
 14843  	}
 14844  	b.SetBytes(int64(total / b.N))
 14845  }
 14846  
 14847  func TestUnrecognizedSize(t *testing.T) {
 14848  	seed := time.Now().UnixNano()
 14849  	popr := math_rand.New(math_rand.NewSource(seed))
 14850  	p := NewPopulatedUnrecognized(popr, true)
 14851  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14852  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14853  	if err != nil {
 14854  		t.Fatalf("seed = %d, err = %v", seed, err)
 14855  	}
 14856  	size := p.Size()
 14857  	if len(dAtA) != size {
 14858  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14859  	}
 14860  	if size2 != size {
 14861  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14862  	}
 14863  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14864  	if size3 != size {
 14865  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14866  	}
 14867  }
 14868  
 14869  func BenchmarkUnrecognizedSize(b *testing.B) {
 14870  	popr := math_rand.New(math_rand.NewSource(616))
 14871  	total := 0
 14872  	pops := make([]*Unrecognized, 1000)
 14873  	for i := 0; i < 1000; i++ {
 14874  		pops[i] = NewPopulatedUnrecognized(popr, false)
 14875  	}
 14876  	b.ResetTimer()
 14877  	for i := 0; i < b.N; i++ {
 14878  		total += pops[i%1000].Size()
 14879  	}
 14880  	b.SetBytes(int64(total / b.N))
 14881  }
 14882  
 14883  func TestUnrecognizedWithInnerSize(t *testing.T) {
 14884  	seed := time.Now().UnixNano()
 14885  	popr := math_rand.New(math_rand.NewSource(seed))
 14886  	p := NewPopulatedUnrecognizedWithInner(popr, true)
 14887  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14888  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14889  	if err != nil {
 14890  		t.Fatalf("seed = %d, err = %v", seed, err)
 14891  	}
 14892  	size := p.Size()
 14893  	if len(dAtA) != size {
 14894  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14895  	}
 14896  	if size2 != size {
 14897  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14898  	}
 14899  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14900  	if size3 != size {
 14901  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14902  	}
 14903  }
 14904  
 14905  func BenchmarkUnrecognizedWithInnerSize(b *testing.B) {
 14906  	popr := math_rand.New(math_rand.NewSource(616))
 14907  	total := 0
 14908  	pops := make([]*UnrecognizedWithInner, 1000)
 14909  	for i := 0; i < 1000; i++ {
 14910  		pops[i] = NewPopulatedUnrecognizedWithInner(popr, false)
 14911  	}
 14912  	b.ResetTimer()
 14913  	for i := 0; i < b.N; i++ {
 14914  		total += pops[i%1000].Size()
 14915  	}
 14916  	b.SetBytes(int64(total / b.N))
 14917  }
 14918  
 14919  func TestUnrecognizedWithInner_InnerSize(t *testing.T) {
 14920  	seed := time.Now().UnixNano()
 14921  	popr := math_rand.New(math_rand.NewSource(seed))
 14922  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, true)
 14923  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14924  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14925  	if err != nil {
 14926  		t.Fatalf("seed = %d, err = %v", seed, err)
 14927  	}
 14928  	size := p.Size()
 14929  	if len(dAtA) != size {
 14930  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14931  	}
 14932  	if size2 != size {
 14933  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14934  	}
 14935  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14936  	if size3 != size {
 14937  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14938  	}
 14939  }
 14940  
 14941  func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) {
 14942  	popr := math_rand.New(math_rand.NewSource(616))
 14943  	total := 0
 14944  	pops := make([]*UnrecognizedWithInner_Inner, 1000)
 14945  	for i := 0; i < 1000; i++ {
 14946  		pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 14947  	}
 14948  	b.ResetTimer()
 14949  	for i := 0; i < b.N; i++ {
 14950  		total += pops[i%1000].Size()
 14951  	}
 14952  	b.SetBytes(int64(total / b.N))
 14953  }
 14954  
 14955  func TestUnrecognizedWithEmbedSize(t *testing.T) {
 14956  	seed := time.Now().UnixNano()
 14957  	popr := math_rand.New(math_rand.NewSource(seed))
 14958  	p := NewPopulatedUnrecognizedWithEmbed(popr, true)
 14959  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14960  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14961  	if err != nil {
 14962  		t.Fatalf("seed = %d, err = %v", seed, err)
 14963  	}
 14964  	size := p.Size()
 14965  	if len(dAtA) != size {
 14966  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 14967  	}
 14968  	if size2 != size {
 14969  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 14970  	}
 14971  	size3 := github_com_gogo_protobuf_proto.Size(p)
 14972  	if size3 != size {
 14973  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 14974  	}
 14975  }
 14976  
 14977  func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) {
 14978  	popr := math_rand.New(math_rand.NewSource(616))
 14979  	total := 0
 14980  	pops := make([]*UnrecognizedWithEmbed, 1000)
 14981  	for i := 0; i < 1000; i++ {
 14982  		pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false)
 14983  	}
 14984  	b.ResetTimer()
 14985  	for i := 0; i < b.N; i++ {
 14986  		total += pops[i%1000].Size()
 14987  	}
 14988  	b.SetBytes(int64(total / b.N))
 14989  }
 14990  
 14991  func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) {
 14992  	seed := time.Now().UnixNano()
 14993  	popr := math_rand.New(math_rand.NewSource(seed))
 14994  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true)
 14995  	size2 := github_com_gogo_protobuf_proto.Size(p)
 14996  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 14997  	if err != nil {
 14998  		t.Fatalf("seed = %d, err = %v", seed, err)
 14999  	}
 15000  	size := p.Size()
 15001  	if len(dAtA) != size {
 15002  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15003  	}
 15004  	if size2 != size {
 15005  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15006  	}
 15007  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15008  	if size3 != size {
 15009  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15010  	}
 15011  }
 15012  
 15013  func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) {
 15014  	popr := math_rand.New(math_rand.NewSource(616))
 15015  	total := 0
 15016  	pops := make([]*UnrecognizedWithEmbed_Embedded, 1000)
 15017  	for i := 0; i < 1000; i++ {
 15018  		pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 15019  	}
 15020  	b.ResetTimer()
 15021  	for i := 0; i < b.N; i++ {
 15022  		total += pops[i%1000].Size()
 15023  	}
 15024  	b.SetBytes(int64(total / b.N))
 15025  }
 15026  
 15027  func TestNodeSize(t *testing.T) {
 15028  	seed := time.Now().UnixNano()
 15029  	popr := math_rand.New(math_rand.NewSource(seed))
 15030  	p := NewPopulatedNode(popr, true)
 15031  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15032  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15033  	if err != nil {
 15034  		t.Fatalf("seed = %d, err = %v", seed, err)
 15035  	}
 15036  	size := p.Size()
 15037  	if len(dAtA) != size {
 15038  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15039  	}
 15040  	if size2 != size {
 15041  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15042  	}
 15043  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15044  	if size3 != size {
 15045  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15046  	}
 15047  }
 15048  
 15049  func BenchmarkNodeSize(b *testing.B) {
 15050  	popr := math_rand.New(math_rand.NewSource(616))
 15051  	total := 0
 15052  	pops := make([]*Node, 1000)
 15053  	for i := 0; i < 1000; i++ {
 15054  		pops[i] = NewPopulatedNode(popr, false)
 15055  	}
 15056  	b.ResetTimer()
 15057  	for i := 0; i < b.N; i++ {
 15058  		total += pops[i%1000].Size()
 15059  	}
 15060  	b.SetBytes(int64(total / b.N))
 15061  }
 15062  
 15063  func TestNonByteCustomTypeSize(t *testing.T) {
 15064  	seed := time.Now().UnixNano()
 15065  	popr := math_rand.New(math_rand.NewSource(seed))
 15066  	p := NewPopulatedNonByteCustomType(popr, true)
 15067  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15068  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15069  	if err != nil {
 15070  		t.Fatalf("seed = %d, err = %v", seed, err)
 15071  	}
 15072  	size := p.Size()
 15073  	if len(dAtA) != size {
 15074  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15075  	}
 15076  	if size2 != size {
 15077  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15078  	}
 15079  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15080  	if size3 != size {
 15081  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15082  	}
 15083  }
 15084  
 15085  func BenchmarkNonByteCustomTypeSize(b *testing.B) {
 15086  	popr := math_rand.New(math_rand.NewSource(616))
 15087  	total := 0
 15088  	pops := make([]*NonByteCustomType, 1000)
 15089  	for i := 0; i < 1000; i++ {
 15090  		pops[i] = NewPopulatedNonByteCustomType(popr, false)
 15091  	}
 15092  	b.ResetTimer()
 15093  	for i := 0; i < b.N; i++ {
 15094  		total += pops[i%1000].Size()
 15095  	}
 15096  	b.SetBytes(int64(total / b.N))
 15097  }
 15098  
 15099  func TestNidOptNonByteCustomTypeSize(t *testing.T) {
 15100  	seed := time.Now().UnixNano()
 15101  	popr := math_rand.New(math_rand.NewSource(seed))
 15102  	p := NewPopulatedNidOptNonByteCustomType(popr, true)
 15103  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15104  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15105  	if err != nil {
 15106  		t.Fatalf("seed = %d, err = %v", seed, err)
 15107  	}
 15108  	size := p.Size()
 15109  	if len(dAtA) != size {
 15110  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15111  	}
 15112  	if size2 != size {
 15113  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15114  	}
 15115  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15116  	if size3 != size {
 15117  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15118  	}
 15119  }
 15120  
 15121  func BenchmarkNidOptNonByteCustomTypeSize(b *testing.B) {
 15122  	popr := math_rand.New(math_rand.NewSource(616))
 15123  	total := 0
 15124  	pops := make([]*NidOptNonByteCustomType, 1000)
 15125  	for i := 0; i < 1000; i++ {
 15126  		pops[i] = NewPopulatedNidOptNonByteCustomType(popr, false)
 15127  	}
 15128  	b.ResetTimer()
 15129  	for i := 0; i < b.N; i++ {
 15130  		total += pops[i%1000].Size()
 15131  	}
 15132  	b.SetBytes(int64(total / b.N))
 15133  }
 15134  
 15135  func TestNinOptNonByteCustomTypeSize(t *testing.T) {
 15136  	seed := time.Now().UnixNano()
 15137  	popr := math_rand.New(math_rand.NewSource(seed))
 15138  	p := NewPopulatedNinOptNonByteCustomType(popr, true)
 15139  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15140  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15141  	if err != nil {
 15142  		t.Fatalf("seed = %d, err = %v", seed, err)
 15143  	}
 15144  	size := p.Size()
 15145  	if len(dAtA) != size {
 15146  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15147  	}
 15148  	if size2 != size {
 15149  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15150  	}
 15151  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15152  	if size3 != size {
 15153  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15154  	}
 15155  }
 15156  
 15157  func BenchmarkNinOptNonByteCustomTypeSize(b *testing.B) {
 15158  	popr := math_rand.New(math_rand.NewSource(616))
 15159  	total := 0
 15160  	pops := make([]*NinOptNonByteCustomType, 1000)
 15161  	for i := 0; i < 1000; i++ {
 15162  		pops[i] = NewPopulatedNinOptNonByteCustomType(popr, false)
 15163  	}
 15164  	b.ResetTimer()
 15165  	for i := 0; i < b.N; i++ {
 15166  		total += pops[i%1000].Size()
 15167  	}
 15168  	b.SetBytes(int64(total / b.N))
 15169  }
 15170  
 15171  func TestNidRepNonByteCustomTypeSize(t *testing.T) {
 15172  	seed := time.Now().UnixNano()
 15173  	popr := math_rand.New(math_rand.NewSource(seed))
 15174  	p := NewPopulatedNidRepNonByteCustomType(popr, true)
 15175  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15176  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15177  	if err != nil {
 15178  		t.Fatalf("seed = %d, err = %v", seed, err)
 15179  	}
 15180  	size := p.Size()
 15181  	if len(dAtA) != size {
 15182  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15183  	}
 15184  	if size2 != size {
 15185  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15186  	}
 15187  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15188  	if size3 != size {
 15189  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15190  	}
 15191  }
 15192  
 15193  func BenchmarkNidRepNonByteCustomTypeSize(b *testing.B) {
 15194  	popr := math_rand.New(math_rand.NewSource(616))
 15195  	total := 0
 15196  	pops := make([]*NidRepNonByteCustomType, 1000)
 15197  	for i := 0; i < 1000; i++ {
 15198  		pops[i] = NewPopulatedNidRepNonByteCustomType(popr, false)
 15199  	}
 15200  	b.ResetTimer()
 15201  	for i := 0; i < b.N; i++ {
 15202  		total += pops[i%1000].Size()
 15203  	}
 15204  	b.SetBytes(int64(total / b.N))
 15205  }
 15206  
 15207  func TestNinRepNonByteCustomTypeSize(t *testing.T) {
 15208  	seed := time.Now().UnixNano()
 15209  	popr := math_rand.New(math_rand.NewSource(seed))
 15210  	p := NewPopulatedNinRepNonByteCustomType(popr, true)
 15211  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15212  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15213  	if err != nil {
 15214  		t.Fatalf("seed = %d, err = %v", seed, err)
 15215  	}
 15216  	size := p.Size()
 15217  	if len(dAtA) != size {
 15218  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15219  	}
 15220  	if size2 != size {
 15221  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15222  	}
 15223  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15224  	if size3 != size {
 15225  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15226  	}
 15227  }
 15228  
 15229  func BenchmarkNinRepNonByteCustomTypeSize(b *testing.B) {
 15230  	popr := math_rand.New(math_rand.NewSource(616))
 15231  	total := 0
 15232  	pops := make([]*NinRepNonByteCustomType, 1000)
 15233  	for i := 0; i < 1000; i++ {
 15234  		pops[i] = NewPopulatedNinRepNonByteCustomType(popr, false)
 15235  	}
 15236  	b.ResetTimer()
 15237  	for i := 0; i < b.N; i++ {
 15238  		total += pops[i%1000].Size()
 15239  	}
 15240  	b.SetBytes(int64(total / b.N))
 15241  }
 15242  
 15243  func TestProtoTypeSize(t *testing.T) {
 15244  	seed := time.Now().UnixNano()
 15245  	popr := math_rand.New(math_rand.NewSource(seed))
 15246  	p := NewPopulatedProtoType(popr, true)
 15247  	size2 := github_com_gogo_protobuf_proto.Size(p)
 15248  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 15249  	if err != nil {
 15250  		t.Fatalf("seed = %d, err = %v", seed, err)
 15251  	}
 15252  	size := p.Size()
 15253  	if len(dAtA) != size {
 15254  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
 15255  	}
 15256  	if size2 != size {
 15257  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
 15258  	}
 15259  	size3 := github_com_gogo_protobuf_proto.Size(p)
 15260  	if size3 != size {
 15261  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
 15262  	}
 15263  }
 15264  
 15265  func BenchmarkProtoTypeSize(b *testing.B) {
 15266  	popr := math_rand.New(math_rand.NewSource(616))
 15267  	total := 0
 15268  	pops := make([]*ProtoType, 1000)
 15269  	for i := 0; i < 1000; i++ {
 15270  		pops[i] = NewPopulatedProtoType(popr, false)
 15271  	}
 15272  	b.ResetTimer()
 15273  	for i := 0; i < b.N; i++ {
 15274  		total += pops[i%1000].Size()
 15275  	}
 15276  	b.SetBytes(int64(total / b.N))
 15277  }
 15278  
 15279  func TestNidOptNativeStringer(t *testing.T) {
 15280  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15281  	p := NewPopulatedNidOptNative(popr, false)
 15282  	s1 := p.String()
 15283  	s2 := fmt.Sprintf("%v", p)
 15284  	if s1 != s2 {
 15285  		t.Fatalf("String want %v got %v", s1, s2)
 15286  	}
 15287  }
 15288  func TestNinOptNativeStringer(t *testing.T) {
 15289  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15290  	p := NewPopulatedNinOptNative(popr, false)
 15291  	s1 := p.String()
 15292  	s2 := fmt.Sprintf("%v", p)
 15293  	if s1 != s2 {
 15294  		t.Fatalf("String want %v got %v", s1, s2)
 15295  	}
 15296  }
 15297  func TestNidRepNativeStringer(t *testing.T) {
 15298  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15299  	p := NewPopulatedNidRepNative(popr, false)
 15300  	s1 := p.String()
 15301  	s2 := fmt.Sprintf("%v", p)
 15302  	if s1 != s2 {
 15303  		t.Fatalf("String want %v got %v", s1, s2)
 15304  	}
 15305  }
 15306  func TestNinRepNativeStringer(t *testing.T) {
 15307  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15308  	p := NewPopulatedNinRepNative(popr, false)
 15309  	s1 := p.String()
 15310  	s2 := fmt.Sprintf("%v", p)
 15311  	if s1 != s2 {
 15312  		t.Fatalf("String want %v got %v", s1, s2)
 15313  	}
 15314  }
 15315  func TestNidRepPackedNativeStringer(t *testing.T) {
 15316  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15317  	p := NewPopulatedNidRepPackedNative(popr, false)
 15318  	s1 := p.String()
 15319  	s2 := fmt.Sprintf("%v", p)
 15320  	if s1 != s2 {
 15321  		t.Fatalf("String want %v got %v", s1, s2)
 15322  	}
 15323  }
 15324  func TestNinRepPackedNativeStringer(t *testing.T) {
 15325  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15326  	p := NewPopulatedNinRepPackedNative(popr, false)
 15327  	s1 := p.String()
 15328  	s2 := fmt.Sprintf("%v", p)
 15329  	if s1 != s2 {
 15330  		t.Fatalf("String want %v got %v", s1, s2)
 15331  	}
 15332  }
 15333  func TestNidOptStructStringer(t *testing.T) {
 15334  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15335  	p := NewPopulatedNidOptStruct(popr, false)
 15336  	s1 := p.String()
 15337  	s2 := fmt.Sprintf("%v", p)
 15338  	if s1 != s2 {
 15339  		t.Fatalf("String want %v got %v", s1, s2)
 15340  	}
 15341  }
 15342  func TestNinOptStructStringer(t *testing.T) {
 15343  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15344  	p := NewPopulatedNinOptStruct(popr, false)
 15345  	s1 := p.String()
 15346  	s2 := fmt.Sprintf("%v", p)
 15347  	if s1 != s2 {
 15348  		t.Fatalf("String want %v got %v", s1, s2)
 15349  	}
 15350  }
 15351  func TestNidRepStructStringer(t *testing.T) {
 15352  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15353  	p := NewPopulatedNidRepStruct(popr, false)
 15354  	s1 := p.String()
 15355  	s2 := fmt.Sprintf("%v", p)
 15356  	if s1 != s2 {
 15357  		t.Fatalf("String want %v got %v", s1, s2)
 15358  	}
 15359  }
 15360  func TestNinRepStructStringer(t *testing.T) {
 15361  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15362  	p := NewPopulatedNinRepStruct(popr, false)
 15363  	s1 := p.String()
 15364  	s2 := fmt.Sprintf("%v", p)
 15365  	if s1 != s2 {
 15366  		t.Fatalf("String want %v got %v", s1, s2)
 15367  	}
 15368  }
 15369  func TestNidEmbeddedStructStringer(t *testing.T) {
 15370  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15371  	p := NewPopulatedNidEmbeddedStruct(popr, false)
 15372  	s1 := p.String()
 15373  	s2 := fmt.Sprintf("%v", p)
 15374  	if s1 != s2 {
 15375  		t.Fatalf("String want %v got %v", s1, s2)
 15376  	}
 15377  }
 15378  func TestNinEmbeddedStructStringer(t *testing.T) {
 15379  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15380  	p := NewPopulatedNinEmbeddedStruct(popr, false)
 15381  	s1 := p.String()
 15382  	s2 := fmt.Sprintf("%v", p)
 15383  	if s1 != s2 {
 15384  		t.Fatalf("String want %v got %v", s1, s2)
 15385  	}
 15386  }
 15387  func TestNidNestedStructStringer(t *testing.T) {
 15388  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15389  	p := NewPopulatedNidNestedStruct(popr, false)
 15390  	s1 := p.String()
 15391  	s2 := fmt.Sprintf("%v", p)
 15392  	if s1 != s2 {
 15393  		t.Fatalf("String want %v got %v", s1, s2)
 15394  	}
 15395  }
 15396  func TestNinNestedStructStringer(t *testing.T) {
 15397  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15398  	p := NewPopulatedNinNestedStruct(popr, false)
 15399  	s1 := p.String()
 15400  	s2 := fmt.Sprintf("%v", p)
 15401  	if s1 != s2 {
 15402  		t.Fatalf("String want %v got %v", s1, s2)
 15403  	}
 15404  }
 15405  func TestNidOptCustomStringer(t *testing.T) {
 15406  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15407  	p := NewPopulatedNidOptCustom(popr, false)
 15408  	s1 := p.String()
 15409  	s2 := fmt.Sprintf("%v", p)
 15410  	if s1 != s2 {
 15411  		t.Fatalf("String want %v got %v", s1, s2)
 15412  	}
 15413  }
 15414  func TestCustomDashStringer(t *testing.T) {
 15415  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15416  	p := NewPopulatedCustomDash(popr, false)
 15417  	s1 := p.String()
 15418  	s2 := fmt.Sprintf("%v", p)
 15419  	if s1 != s2 {
 15420  		t.Fatalf("String want %v got %v", s1, s2)
 15421  	}
 15422  }
 15423  func TestNinOptCustomStringer(t *testing.T) {
 15424  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15425  	p := NewPopulatedNinOptCustom(popr, false)
 15426  	s1 := p.String()
 15427  	s2 := fmt.Sprintf("%v", p)
 15428  	if s1 != s2 {
 15429  		t.Fatalf("String want %v got %v", s1, s2)
 15430  	}
 15431  }
 15432  func TestNidRepCustomStringer(t *testing.T) {
 15433  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15434  	p := NewPopulatedNidRepCustom(popr, false)
 15435  	s1 := p.String()
 15436  	s2 := fmt.Sprintf("%v", p)
 15437  	if s1 != s2 {
 15438  		t.Fatalf("String want %v got %v", s1, s2)
 15439  	}
 15440  }
 15441  func TestNinRepCustomStringer(t *testing.T) {
 15442  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15443  	p := NewPopulatedNinRepCustom(popr, false)
 15444  	s1 := p.String()
 15445  	s2 := fmt.Sprintf("%v", p)
 15446  	if s1 != s2 {
 15447  		t.Fatalf("String want %v got %v", s1, s2)
 15448  	}
 15449  }
 15450  func TestNinOptNativeUnionStringer(t *testing.T) {
 15451  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15452  	p := NewPopulatedNinOptNativeUnion(popr, false)
 15453  	s1 := p.String()
 15454  	s2 := fmt.Sprintf("%v", p)
 15455  	if s1 != s2 {
 15456  		t.Fatalf("String want %v got %v", s1, s2)
 15457  	}
 15458  }
 15459  func TestNinOptStructUnionStringer(t *testing.T) {
 15460  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15461  	p := NewPopulatedNinOptStructUnion(popr, false)
 15462  	s1 := p.String()
 15463  	s2 := fmt.Sprintf("%v", p)
 15464  	if s1 != s2 {
 15465  		t.Fatalf("String want %v got %v", s1, s2)
 15466  	}
 15467  }
 15468  func TestNinEmbeddedStructUnionStringer(t *testing.T) {
 15469  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15470  	p := NewPopulatedNinEmbeddedStructUnion(popr, false)
 15471  	s1 := p.String()
 15472  	s2 := fmt.Sprintf("%v", p)
 15473  	if s1 != s2 {
 15474  		t.Fatalf("String want %v got %v", s1, s2)
 15475  	}
 15476  }
 15477  func TestNinNestedStructUnionStringer(t *testing.T) {
 15478  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15479  	p := NewPopulatedNinNestedStructUnion(popr, false)
 15480  	s1 := p.String()
 15481  	s2 := fmt.Sprintf("%v", p)
 15482  	if s1 != s2 {
 15483  		t.Fatalf("String want %v got %v", s1, s2)
 15484  	}
 15485  }
 15486  func TestTreeStringer(t *testing.T) {
 15487  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15488  	p := NewPopulatedTree(popr, false)
 15489  	s1 := p.String()
 15490  	s2 := fmt.Sprintf("%v", p)
 15491  	if s1 != s2 {
 15492  		t.Fatalf("String want %v got %v", s1, s2)
 15493  	}
 15494  }
 15495  func TestOrBranchStringer(t *testing.T) {
 15496  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15497  	p := NewPopulatedOrBranch(popr, false)
 15498  	s1 := p.String()
 15499  	s2 := fmt.Sprintf("%v", p)
 15500  	if s1 != s2 {
 15501  		t.Fatalf("String want %v got %v", s1, s2)
 15502  	}
 15503  }
 15504  func TestAndBranchStringer(t *testing.T) {
 15505  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15506  	p := NewPopulatedAndBranch(popr, false)
 15507  	s1 := p.String()
 15508  	s2 := fmt.Sprintf("%v", p)
 15509  	if s1 != s2 {
 15510  		t.Fatalf("String want %v got %v", s1, s2)
 15511  	}
 15512  }
 15513  func TestLeafStringer(t *testing.T) {
 15514  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15515  	p := NewPopulatedLeaf(popr, false)
 15516  	s1 := p.String()
 15517  	s2 := fmt.Sprintf("%v", p)
 15518  	if s1 != s2 {
 15519  		t.Fatalf("String want %v got %v", s1, s2)
 15520  	}
 15521  }
 15522  func TestDeepTreeStringer(t *testing.T) {
 15523  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15524  	p := NewPopulatedDeepTree(popr, false)
 15525  	s1 := p.String()
 15526  	s2 := fmt.Sprintf("%v", p)
 15527  	if s1 != s2 {
 15528  		t.Fatalf("String want %v got %v", s1, s2)
 15529  	}
 15530  }
 15531  func TestADeepBranchStringer(t *testing.T) {
 15532  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15533  	p := NewPopulatedADeepBranch(popr, false)
 15534  	s1 := p.String()
 15535  	s2 := fmt.Sprintf("%v", p)
 15536  	if s1 != s2 {
 15537  		t.Fatalf("String want %v got %v", s1, s2)
 15538  	}
 15539  }
 15540  func TestAndDeepBranchStringer(t *testing.T) {
 15541  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15542  	p := NewPopulatedAndDeepBranch(popr, false)
 15543  	s1 := p.String()
 15544  	s2 := fmt.Sprintf("%v", p)
 15545  	if s1 != s2 {
 15546  		t.Fatalf("String want %v got %v", s1, s2)
 15547  	}
 15548  }
 15549  func TestDeepLeafStringer(t *testing.T) {
 15550  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15551  	p := NewPopulatedDeepLeaf(popr, false)
 15552  	s1 := p.String()
 15553  	s2 := fmt.Sprintf("%v", p)
 15554  	if s1 != s2 {
 15555  		t.Fatalf("String want %v got %v", s1, s2)
 15556  	}
 15557  }
 15558  func TestNilStringer(t *testing.T) {
 15559  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15560  	p := NewPopulatedNil(popr, false)
 15561  	s1 := p.String()
 15562  	s2 := fmt.Sprintf("%v", p)
 15563  	if s1 != s2 {
 15564  		t.Fatalf("String want %v got %v", s1, s2)
 15565  	}
 15566  }
 15567  func TestNidOptEnumStringer(t *testing.T) {
 15568  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15569  	p := NewPopulatedNidOptEnum(popr, false)
 15570  	s1 := p.String()
 15571  	s2 := fmt.Sprintf("%v", p)
 15572  	if s1 != s2 {
 15573  		t.Fatalf("String want %v got %v", s1, s2)
 15574  	}
 15575  }
 15576  func TestNinOptEnumStringer(t *testing.T) {
 15577  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15578  	p := NewPopulatedNinOptEnum(popr, false)
 15579  	s1 := p.String()
 15580  	s2 := fmt.Sprintf("%v", p)
 15581  	if s1 != s2 {
 15582  		t.Fatalf("String want %v got %v", s1, s2)
 15583  	}
 15584  }
 15585  func TestNidRepEnumStringer(t *testing.T) {
 15586  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15587  	p := NewPopulatedNidRepEnum(popr, false)
 15588  	s1 := p.String()
 15589  	s2 := fmt.Sprintf("%v", p)
 15590  	if s1 != s2 {
 15591  		t.Fatalf("String want %v got %v", s1, s2)
 15592  	}
 15593  }
 15594  func TestNinRepEnumStringer(t *testing.T) {
 15595  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15596  	p := NewPopulatedNinRepEnum(popr, false)
 15597  	s1 := p.String()
 15598  	s2 := fmt.Sprintf("%v", p)
 15599  	if s1 != s2 {
 15600  		t.Fatalf("String want %v got %v", s1, s2)
 15601  	}
 15602  }
 15603  func TestNinOptEnumDefaultStringer(t *testing.T) {
 15604  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15605  	p := NewPopulatedNinOptEnumDefault(popr, false)
 15606  	s1 := p.String()
 15607  	s2 := fmt.Sprintf("%v", p)
 15608  	if s1 != s2 {
 15609  		t.Fatalf("String want %v got %v", s1, s2)
 15610  	}
 15611  }
 15612  func TestAnotherNinOptEnumStringer(t *testing.T) {
 15613  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15614  	p := NewPopulatedAnotherNinOptEnum(popr, false)
 15615  	s1 := p.String()
 15616  	s2 := fmt.Sprintf("%v", p)
 15617  	if s1 != s2 {
 15618  		t.Fatalf("String want %v got %v", s1, s2)
 15619  	}
 15620  }
 15621  func TestAnotherNinOptEnumDefaultStringer(t *testing.T) {
 15622  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15623  	p := NewPopulatedAnotherNinOptEnumDefault(popr, false)
 15624  	s1 := p.String()
 15625  	s2 := fmt.Sprintf("%v", p)
 15626  	if s1 != s2 {
 15627  		t.Fatalf("String want %v got %v", s1, s2)
 15628  	}
 15629  }
 15630  func TestTimerStringer(t *testing.T) {
 15631  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15632  	p := NewPopulatedTimer(popr, false)
 15633  	s1 := p.String()
 15634  	s2 := fmt.Sprintf("%v", p)
 15635  	if s1 != s2 {
 15636  		t.Fatalf("String want %v got %v", s1, s2)
 15637  	}
 15638  }
 15639  func TestMyExtendableStringer(t *testing.T) {
 15640  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15641  	p := NewPopulatedMyExtendable(popr, false)
 15642  	s1 := p.String()
 15643  	s2 := fmt.Sprintf("%v", p)
 15644  	if s1 != s2 {
 15645  		t.Fatalf("String want %v got %v", s1, s2)
 15646  	}
 15647  }
 15648  func TestOtherExtenableStringer(t *testing.T) {
 15649  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15650  	p := NewPopulatedOtherExtenable(popr, false)
 15651  	s1 := p.String()
 15652  	s2 := fmt.Sprintf("%v", p)
 15653  	if s1 != s2 {
 15654  		t.Fatalf("String want %v got %v", s1, s2)
 15655  	}
 15656  }
 15657  func TestNestedDefinitionStringer(t *testing.T) {
 15658  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15659  	p := NewPopulatedNestedDefinition(popr, false)
 15660  	s1 := p.String()
 15661  	s2 := fmt.Sprintf("%v", p)
 15662  	if s1 != s2 {
 15663  		t.Fatalf("String want %v got %v", s1, s2)
 15664  	}
 15665  }
 15666  func TestNestedDefinition_NestedMessageStringer(t *testing.T) {
 15667  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15668  	p := NewPopulatedNestedDefinition_NestedMessage(popr, false)
 15669  	s1 := p.String()
 15670  	s2 := fmt.Sprintf("%v", p)
 15671  	if s1 != s2 {
 15672  		t.Fatalf("String want %v got %v", s1, s2)
 15673  	}
 15674  }
 15675  func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) {
 15676  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15677  	p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)
 15678  	s1 := p.String()
 15679  	s2 := fmt.Sprintf("%v", p)
 15680  	if s1 != s2 {
 15681  		t.Fatalf("String want %v got %v", s1, s2)
 15682  	}
 15683  }
 15684  func TestNestedScopeStringer(t *testing.T) {
 15685  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15686  	p := NewPopulatedNestedScope(popr, false)
 15687  	s1 := p.String()
 15688  	s2 := fmt.Sprintf("%v", p)
 15689  	if s1 != s2 {
 15690  		t.Fatalf("String want %v got %v", s1, s2)
 15691  	}
 15692  }
 15693  func TestNinOptNativeDefaultStringer(t *testing.T) {
 15694  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15695  	p := NewPopulatedNinOptNativeDefault(popr, false)
 15696  	s1 := p.String()
 15697  	s2 := fmt.Sprintf("%v", p)
 15698  	if s1 != s2 {
 15699  		t.Fatalf("String want %v got %v", s1, s2)
 15700  	}
 15701  }
 15702  func TestCustomContainerStringer(t *testing.T) {
 15703  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15704  	p := NewPopulatedCustomContainer(popr, false)
 15705  	s1 := p.String()
 15706  	s2 := fmt.Sprintf("%v", p)
 15707  	if s1 != s2 {
 15708  		t.Fatalf("String want %v got %v", s1, s2)
 15709  	}
 15710  }
 15711  func TestCustomNameNidOptNativeStringer(t *testing.T) {
 15712  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15713  	p := NewPopulatedCustomNameNidOptNative(popr, false)
 15714  	s1 := p.String()
 15715  	s2 := fmt.Sprintf("%v", p)
 15716  	if s1 != s2 {
 15717  		t.Fatalf("String want %v got %v", s1, s2)
 15718  	}
 15719  }
 15720  func TestCustomNameNinOptNativeStringer(t *testing.T) {
 15721  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15722  	p := NewPopulatedCustomNameNinOptNative(popr, false)
 15723  	s1 := p.String()
 15724  	s2 := fmt.Sprintf("%v", p)
 15725  	if s1 != s2 {
 15726  		t.Fatalf("String want %v got %v", s1, s2)
 15727  	}
 15728  }
 15729  func TestCustomNameNinRepNativeStringer(t *testing.T) {
 15730  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15731  	p := NewPopulatedCustomNameNinRepNative(popr, false)
 15732  	s1 := p.String()
 15733  	s2 := fmt.Sprintf("%v", p)
 15734  	if s1 != s2 {
 15735  		t.Fatalf("String want %v got %v", s1, s2)
 15736  	}
 15737  }
 15738  func TestCustomNameNinStructStringer(t *testing.T) {
 15739  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15740  	p := NewPopulatedCustomNameNinStruct(popr, false)
 15741  	s1 := p.String()
 15742  	s2 := fmt.Sprintf("%v", p)
 15743  	if s1 != s2 {
 15744  		t.Fatalf("String want %v got %v", s1, s2)
 15745  	}
 15746  }
 15747  func TestCustomNameCustomTypeStringer(t *testing.T) {
 15748  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15749  	p := NewPopulatedCustomNameCustomType(popr, false)
 15750  	s1 := p.String()
 15751  	s2 := fmt.Sprintf("%v", p)
 15752  	if s1 != s2 {
 15753  		t.Fatalf("String want %v got %v", s1, s2)
 15754  	}
 15755  }
 15756  func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) {
 15757  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15758  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)
 15759  	s1 := p.String()
 15760  	s2 := fmt.Sprintf("%v", p)
 15761  	if s1 != s2 {
 15762  		t.Fatalf("String want %v got %v", s1, s2)
 15763  	}
 15764  }
 15765  func TestCustomNameEnumStringer(t *testing.T) {
 15766  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15767  	p := NewPopulatedCustomNameEnum(popr, false)
 15768  	s1 := p.String()
 15769  	s2 := fmt.Sprintf("%v", p)
 15770  	if s1 != s2 {
 15771  		t.Fatalf("String want %v got %v", s1, s2)
 15772  	}
 15773  }
 15774  func TestNoExtensionsMapStringer(t *testing.T) {
 15775  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15776  	p := NewPopulatedNoExtensionsMap(popr, false)
 15777  	s1 := p.String()
 15778  	s2 := fmt.Sprintf("%v", p)
 15779  	if s1 != s2 {
 15780  		t.Fatalf("String want %v got %v", s1, s2)
 15781  	}
 15782  }
 15783  func TestUnrecognizedStringer(t *testing.T) {
 15784  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15785  	p := NewPopulatedUnrecognized(popr, false)
 15786  	s1 := p.String()
 15787  	s2 := fmt.Sprintf("%v", p)
 15788  	if s1 != s2 {
 15789  		t.Fatalf("String want %v got %v", s1, s2)
 15790  	}
 15791  }
 15792  func TestUnrecognizedWithInnerStringer(t *testing.T) {
 15793  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15794  	p := NewPopulatedUnrecognizedWithInner(popr, false)
 15795  	s1 := p.String()
 15796  	s2 := fmt.Sprintf("%v", p)
 15797  	if s1 != s2 {
 15798  		t.Fatalf("String want %v got %v", s1, s2)
 15799  	}
 15800  }
 15801  func TestUnrecognizedWithInner_InnerStringer(t *testing.T) {
 15802  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15803  	p := NewPopulatedUnrecognizedWithInner_Inner(popr, false)
 15804  	s1 := p.String()
 15805  	s2 := fmt.Sprintf("%v", p)
 15806  	if s1 != s2 {
 15807  		t.Fatalf("String want %v got %v", s1, s2)
 15808  	}
 15809  }
 15810  func TestUnrecognizedWithEmbedStringer(t *testing.T) {
 15811  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15812  	p := NewPopulatedUnrecognizedWithEmbed(popr, false)
 15813  	s1 := p.String()
 15814  	s2 := fmt.Sprintf("%v", p)
 15815  	if s1 != s2 {
 15816  		t.Fatalf("String want %v got %v", s1, s2)
 15817  	}
 15818  }
 15819  func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) {
 15820  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15821  	p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)
 15822  	s1 := p.String()
 15823  	s2 := fmt.Sprintf("%v", p)
 15824  	if s1 != s2 {
 15825  		t.Fatalf("String want %v got %v", s1, s2)
 15826  	}
 15827  }
 15828  func TestNodeStringer(t *testing.T) {
 15829  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15830  	p := NewPopulatedNode(popr, false)
 15831  	s1 := p.String()
 15832  	s2 := fmt.Sprintf("%v", p)
 15833  	if s1 != s2 {
 15834  		t.Fatalf("String want %v got %v", s1, s2)
 15835  	}
 15836  }
 15837  func TestNonByteCustomTypeStringer(t *testing.T) {
 15838  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15839  	p := NewPopulatedNonByteCustomType(popr, false)
 15840  	s1 := p.String()
 15841  	s2 := fmt.Sprintf("%v", p)
 15842  	if s1 != s2 {
 15843  		t.Fatalf("String want %v got %v", s1, s2)
 15844  	}
 15845  }
 15846  func TestNidOptNonByteCustomTypeStringer(t *testing.T) {
 15847  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15848  	p := NewPopulatedNidOptNonByteCustomType(popr, false)
 15849  	s1 := p.String()
 15850  	s2 := fmt.Sprintf("%v", p)
 15851  	if s1 != s2 {
 15852  		t.Fatalf("String want %v got %v", s1, s2)
 15853  	}
 15854  }
 15855  func TestNinOptNonByteCustomTypeStringer(t *testing.T) {
 15856  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15857  	p := NewPopulatedNinOptNonByteCustomType(popr, false)
 15858  	s1 := p.String()
 15859  	s2 := fmt.Sprintf("%v", p)
 15860  	if s1 != s2 {
 15861  		t.Fatalf("String want %v got %v", s1, s2)
 15862  	}
 15863  }
 15864  func TestNidRepNonByteCustomTypeStringer(t *testing.T) {
 15865  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15866  	p := NewPopulatedNidRepNonByteCustomType(popr, false)
 15867  	s1 := p.String()
 15868  	s2 := fmt.Sprintf("%v", p)
 15869  	if s1 != s2 {
 15870  		t.Fatalf("String want %v got %v", s1, s2)
 15871  	}
 15872  }
 15873  func TestNinRepNonByteCustomTypeStringer(t *testing.T) {
 15874  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15875  	p := NewPopulatedNinRepNonByteCustomType(popr, false)
 15876  	s1 := p.String()
 15877  	s2 := fmt.Sprintf("%v", p)
 15878  	if s1 != s2 {
 15879  		t.Fatalf("String want %v got %v", s1, s2)
 15880  	}
 15881  }
 15882  func TestProtoTypeStringer(t *testing.T) {
 15883  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15884  	p := NewPopulatedProtoType(popr, false)
 15885  	s1 := p.String()
 15886  	s2 := fmt.Sprintf("%v", p)
 15887  	if s1 != s2 {
 15888  		t.Fatalf("String want %v got %v", s1, s2)
 15889  	}
 15890  }
 15891  func TestNinOptNativeUnionOnlyOne(t *testing.T) {
 15892  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15893  	p := NewPopulatedNinOptNativeUnion(popr, true)
 15894  	v := p.GetValue()
 15895  	msg := &NinOptNativeUnion{}
 15896  	if !msg.SetValue(v) {
 15897  		t.Fatalf("OnlyOne: Could not set Value")
 15898  	}
 15899  	if !p.Equal(msg) {
 15900  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15901  	}
 15902  }
 15903  func TestNinOptStructUnionOnlyOne(t *testing.T) {
 15904  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15905  	p := NewPopulatedNinOptStructUnion(popr, true)
 15906  	v := p.GetValue()
 15907  	msg := &NinOptStructUnion{}
 15908  	if !msg.SetValue(v) {
 15909  		t.Fatalf("OnlyOne: Could not set Value")
 15910  	}
 15911  	if !p.Equal(msg) {
 15912  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15913  	}
 15914  }
 15915  func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) {
 15916  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15917  	p := NewPopulatedNinEmbeddedStructUnion(popr, true)
 15918  	v := p.GetValue()
 15919  	msg := &NinEmbeddedStructUnion{}
 15920  	if !msg.SetValue(v) {
 15921  		t.Fatalf("OnlyOne: Could not set Value")
 15922  	}
 15923  	if !p.Equal(msg) {
 15924  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15925  	}
 15926  }
 15927  func TestNinNestedStructUnionOnlyOne(t *testing.T) {
 15928  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15929  	p := NewPopulatedNinNestedStructUnion(popr, true)
 15930  	v := p.GetValue()
 15931  	msg := &NinNestedStructUnion{}
 15932  	if !msg.SetValue(v) {
 15933  		t.Fatalf("OnlyOne: Could not set Value")
 15934  	}
 15935  	if !p.Equal(msg) {
 15936  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15937  	}
 15938  }
 15939  func TestTreeOnlyOne(t *testing.T) {
 15940  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15941  	p := NewPopulatedTree(popr, true)
 15942  	v := p.GetValue()
 15943  	msg := &Tree{}
 15944  	if !msg.SetValue(v) {
 15945  		t.Fatalf("OnlyOne: Could not set Value")
 15946  	}
 15947  	if !p.Equal(msg) {
 15948  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15949  	}
 15950  }
 15951  func TestDeepTreeOnlyOne(t *testing.T) {
 15952  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15953  	p := NewPopulatedDeepTree(popr, true)
 15954  	v := p.GetValue()
 15955  	msg := &DeepTree{}
 15956  	if !msg.SetValue(v) {
 15957  		t.Fatalf("OnlyOne: Could not set Value")
 15958  	}
 15959  	if !p.Equal(msg) {
 15960  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15961  	}
 15962  }
 15963  func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) {
 15964  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
 15965  	p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true)
 15966  	v := p.GetValue()
 15967  	msg := &CustomNameNinEmbeddedStructUnion{}
 15968  	if !msg.SetValue(v) {
 15969  		t.Fatalf("OnlyOne: Could not set Value")
 15970  	}
 15971  	if !p.Equal(msg) {
 15972  		t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)
 15973  	}
 15974  }
 15975  
 15976  //These tests are generated by github.com/gogo/protobuf/plugin/testgen
 15977  

View as plain text