Source file src/github.com/gogo/protobuf/test/theproto3/combos/neither/theproto3pb_test.go

Documentation: github.com/gogo/protobuf/test/theproto3/combos/neither

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: combos/neither/theproto3.proto
     3  
     4  package theproto3
     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  	_ "github.com/gogo/protobuf/test/combos/both"
    13  	go_parser "go/parser"
    14  	math "math"
    15  	math_rand "math/rand"
    16  	testing "testing"
    17  	time "time"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var _ = proto.Marshal
    22  var _ = fmt.Errorf
    23  var _ = math.Inf
    24  
    25  func TestMessageProto(t *testing.T) {
    26  	seed := time.Now().UnixNano()
    27  	popr := math_rand.New(math_rand.NewSource(seed))
    28  	p := NewPopulatedMessage(popr, false)
    29  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
    30  	if err != nil {
    31  		t.Fatalf("seed = %d, err = %v", seed, err)
    32  	}
    33  	msg := &Message{}
    34  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
    35  		t.Fatalf("seed = %d, err = %v", seed, err)
    36  	}
    37  	littlefuzz := make([]byte, len(dAtA))
    38  	copy(littlefuzz, dAtA)
    39  	for i := range dAtA {
    40  		dAtA[i] = byte(popr.Intn(256))
    41  	}
    42  	if err := p.VerboseEqual(msg); err != nil {
    43  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
    44  	}
    45  	if !p.Equal(msg) {
    46  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
    47  	}
    48  	if len(littlefuzz) > 0 {
    49  		fuzzamount := 100
    50  		for i := 0; i < fuzzamount; i++ {
    51  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
    52  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
    53  		}
    54  		// shouldn't panic
    55  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
    56  	}
    57  }
    58  
    59  func BenchmarkMessageProtoMarshal(b *testing.B) {
    60  	popr := math_rand.New(math_rand.NewSource(616))
    61  	total := 0
    62  	pops := make([]*Message, 10000)
    63  	for i := 0; i < 10000; i++ {
    64  		pops[i] = NewPopulatedMessage(popr, false)
    65  	}
    66  	b.ResetTimer()
    67  	for i := 0; i < b.N; i++ {
    68  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
    69  		if err != nil {
    70  			panic(err)
    71  		}
    72  		total += len(dAtA)
    73  	}
    74  	b.SetBytes(int64(total / b.N))
    75  }
    76  
    77  func BenchmarkMessageProtoUnmarshal(b *testing.B) {
    78  	popr := math_rand.New(math_rand.NewSource(616))
    79  	total := 0
    80  	datas := make([][]byte, 10000)
    81  	for i := 0; i < 10000; i++ {
    82  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false))
    83  		if err != nil {
    84  			panic(err)
    85  		}
    86  		datas[i] = dAtA
    87  	}
    88  	msg := &Message{}
    89  	b.ResetTimer()
    90  	for i := 0; i < b.N; i++ {
    91  		total += len(datas[i%10000])
    92  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
    93  			panic(err)
    94  		}
    95  	}
    96  	b.SetBytes(int64(total / b.N))
    97  }
    98  
    99  func TestNestedProto(t *testing.T) {
   100  	seed := time.Now().UnixNano()
   101  	popr := math_rand.New(math_rand.NewSource(seed))
   102  	p := NewPopulatedNested(popr, false)
   103  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   104  	if err != nil {
   105  		t.Fatalf("seed = %d, err = %v", seed, err)
   106  	}
   107  	msg := &Nested{}
   108  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   109  		t.Fatalf("seed = %d, err = %v", seed, err)
   110  	}
   111  	littlefuzz := make([]byte, len(dAtA))
   112  	copy(littlefuzz, dAtA)
   113  	for i := range dAtA {
   114  		dAtA[i] = byte(popr.Intn(256))
   115  	}
   116  	if err := p.VerboseEqual(msg); err != nil {
   117  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   118  	}
   119  	if !p.Equal(msg) {
   120  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   121  	}
   122  	if len(littlefuzz) > 0 {
   123  		fuzzamount := 100
   124  		for i := 0; i < fuzzamount; i++ {
   125  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   126  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   127  		}
   128  		// shouldn't panic
   129  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   130  	}
   131  }
   132  
   133  func BenchmarkNestedProtoMarshal(b *testing.B) {
   134  	popr := math_rand.New(math_rand.NewSource(616))
   135  	total := 0
   136  	pops := make([]*Nested, 10000)
   137  	for i := 0; i < 10000; i++ {
   138  		pops[i] = NewPopulatedNested(popr, false)
   139  	}
   140  	b.ResetTimer()
   141  	for i := 0; i < b.N; i++ {
   142  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   143  		if err != nil {
   144  			panic(err)
   145  		}
   146  		total += len(dAtA)
   147  	}
   148  	b.SetBytes(int64(total / b.N))
   149  }
   150  
   151  func BenchmarkNestedProtoUnmarshal(b *testing.B) {
   152  	popr := math_rand.New(math_rand.NewSource(616))
   153  	total := 0
   154  	datas := make([][]byte, 10000)
   155  	for i := 0; i < 10000; i++ {
   156  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false))
   157  		if err != nil {
   158  			panic(err)
   159  		}
   160  		datas[i] = dAtA
   161  	}
   162  	msg := &Nested{}
   163  	b.ResetTimer()
   164  	for i := 0; i < b.N; i++ {
   165  		total += len(datas[i%10000])
   166  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   167  			panic(err)
   168  		}
   169  	}
   170  	b.SetBytes(int64(total / b.N))
   171  }
   172  
   173  func TestAllMapsProto(t *testing.T) {
   174  	seed := time.Now().UnixNano()
   175  	popr := math_rand.New(math_rand.NewSource(seed))
   176  	p := NewPopulatedAllMaps(popr, false)
   177  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   178  	if err != nil {
   179  		t.Fatalf("seed = %d, err = %v", seed, err)
   180  	}
   181  	msg := &AllMaps{}
   182  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   183  		t.Fatalf("seed = %d, err = %v", seed, err)
   184  	}
   185  	littlefuzz := make([]byte, len(dAtA))
   186  	copy(littlefuzz, dAtA)
   187  	for i := range dAtA {
   188  		dAtA[i] = byte(popr.Intn(256))
   189  	}
   190  	if err := p.VerboseEqual(msg); err != nil {
   191  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   192  	}
   193  	if !p.Equal(msg) {
   194  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   195  	}
   196  	if len(littlefuzz) > 0 {
   197  		fuzzamount := 100
   198  		for i := 0; i < fuzzamount; i++ {
   199  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   200  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   201  		}
   202  		// shouldn't panic
   203  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   204  	}
   205  }
   206  
   207  func BenchmarkAllMapsProtoMarshal(b *testing.B) {
   208  	popr := math_rand.New(math_rand.NewSource(616))
   209  	total := 0
   210  	pops := make([]*AllMaps, 10000)
   211  	for i := 0; i < 10000; i++ {
   212  		pops[i] = NewPopulatedAllMaps(popr, false)
   213  	}
   214  	b.ResetTimer()
   215  	for i := 0; i < b.N; i++ {
   216  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   217  		if err != nil {
   218  			panic(err)
   219  		}
   220  		total += len(dAtA)
   221  	}
   222  	b.SetBytes(int64(total / b.N))
   223  }
   224  
   225  func BenchmarkAllMapsProtoUnmarshal(b *testing.B) {
   226  	popr := math_rand.New(math_rand.NewSource(616))
   227  	total := 0
   228  	datas := make([][]byte, 10000)
   229  	for i := 0; i < 10000; i++ {
   230  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false))
   231  		if err != nil {
   232  			panic(err)
   233  		}
   234  		datas[i] = dAtA
   235  	}
   236  	msg := &AllMaps{}
   237  	b.ResetTimer()
   238  	for i := 0; i < b.N; i++ {
   239  		total += len(datas[i%10000])
   240  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   241  			panic(err)
   242  		}
   243  	}
   244  	b.SetBytes(int64(total / b.N))
   245  }
   246  
   247  func TestAllMapsOrderedProto(t *testing.T) {
   248  	seed := time.Now().UnixNano()
   249  	popr := math_rand.New(math_rand.NewSource(seed))
   250  	p := NewPopulatedAllMapsOrdered(popr, false)
   251  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   252  	if err != nil {
   253  		t.Fatalf("seed = %d, err = %v", seed, err)
   254  	}
   255  	msg := &AllMapsOrdered{}
   256  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   257  		t.Fatalf("seed = %d, err = %v", seed, err)
   258  	}
   259  	littlefuzz := make([]byte, len(dAtA))
   260  	copy(littlefuzz, dAtA)
   261  	for i := range dAtA {
   262  		dAtA[i] = byte(popr.Intn(256))
   263  	}
   264  	if err := p.VerboseEqual(msg); err != nil {
   265  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   266  	}
   267  	if !p.Equal(msg) {
   268  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   269  	}
   270  	if len(littlefuzz) > 0 {
   271  		fuzzamount := 100
   272  		for i := 0; i < fuzzamount; i++ {
   273  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   274  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   275  		}
   276  		// shouldn't panic
   277  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   278  	}
   279  }
   280  
   281  func BenchmarkAllMapsOrderedProtoMarshal(b *testing.B) {
   282  	popr := math_rand.New(math_rand.NewSource(616))
   283  	total := 0
   284  	pops := make([]*AllMapsOrdered, 10000)
   285  	for i := 0; i < 10000; i++ {
   286  		pops[i] = NewPopulatedAllMapsOrdered(popr, false)
   287  	}
   288  	b.ResetTimer()
   289  	for i := 0; i < b.N; i++ {
   290  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   291  		if err != nil {
   292  			panic(err)
   293  		}
   294  		total += len(dAtA)
   295  	}
   296  	b.SetBytes(int64(total / b.N))
   297  }
   298  
   299  func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) {
   300  	popr := math_rand.New(math_rand.NewSource(616))
   301  	total := 0
   302  	datas := make([][]byte, 10000)
   303  	for i := 0; i < 10000; i++ {
   304  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMapsOrdered(popr, false))
   305  		if err != nil {
   306  			panic(err)
   307  		}
   308  		datas[i] = dAtA
   309  	}
   310  	msg := &AllMapsOrdered{}
   311  	b.ResetTimer()
   312  	for i := 0; i < b.N; i++ {
   313  		total += len(datas[i%10000])
   314  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   315  			panic(err)
   316  		}
   317  	}
   318  	b.SetBytes(int64(total / b.N))
   319  }
   320  
   321  func TestMessageWithMapProto(t *testing.T) {
   322  	seed := time.Now().UnixNano()
   323  	popr := math_rand.New(math_rand.NewSource(seed))
   324  	p := NewPopulatedMessageWithMap(popr, false)
   325  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   326  	if err != nil {
   327  		t.Fatalf("seed = %d, err = %v", seed, err)
   328  	}
   329  	msg := &MessageWithMap{}
   330  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   331  		t.Fatalf("seed = %d, err = %v", seed, err)
   332  	}
   333  	littlefuzz := make([]byte, len(dAtA))
   334  	copy(littlefuzz, dAtA)
   335  	for i := range dAtA {
   336  		dAtA[i] = byte(popr.Intn(256))
   337  	}
   338  	if err := p.VerboseEqual(msg); err != nil {
   339  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   340  	}
   341  	if !p.Equal(msg) {
   342  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   343  	}
   344  	if len(littlefuzz) > 0 {
   345  		fuzzamount := 100
   346  		for i := 0; i < fuzzamount; i++ {
   347  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   348  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   349  		}
   350  		// shouldn't panic
   351  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   352  	}
   353  }
   354  
   355  func BenchmarkMessageWithMapProtoMarshal(b *testing.B) {
   356  	popr := math_rand.New(math_rand.NewSource(616))
   357  	total := 0
   358  	pops := make([]*MessageWithMap, 10000)
   359  	for i := 0; i < 10000; i++ {
   360  		pops[i] = NewPopulatedMessageWithMap(popr, false)
   361  	}
   362  	b.ResetTimer()
   363  	for i := 0; i < b.N; i++ {
   364  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   365  		if err != nil {
   366  			panic(err)
   367  		}
   368  		total += len(dAtA)
   369  	}
   370  	b.SetBytes(int64(total / b.N))
   371  }
   372  
   373  func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) {
   374  	popr := math_rand.New(math_rand.NewSource(616))
   375  	total := 0
   376  	datas := make([][]byte, 10000)
   377  	for i := 0; i < 10000; i++ {
   378  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false))
   379  		if err != nil {
   380  			panic(err)
   381  		}
   382  		datas[i] = dAtA
   383  	}
   384  	msg := &MessageWithMap{}
   385  	b.ResetTimer()
   386  	for i := 0; i < b.N; i++ {
   387  		total += len(datas[i%10000])
   388  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   389  			panic(err)
   390  		}
   391  	}
   392  	b.SetBytes(int64(total / b.N))
   393  }
   394  
   395  func TestFloatingPointProto(t *testing.T) {
   396  	seed := time.Now().UnixNano()
   397  	popr := math_rand.New(math_rand.NewSource(seed))
   398  	p := NewPopulatedFloatingPoint(popr, false)
   399  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   400  	if err != nil {
   401  		t.Fatalf("seed = %d, err = %v", seed, err)
   402  	}
   403  	msg := &FloatingPoint{}
   404  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   405  		t.Fatalf("seed = %d, err = %v", seed, err)
   406  	}
   407  	littlefuzz := make([]byte, len(dAtA))
   408  	copy(littlefuzz, dAtA)
   409  	for i := range dAtA {
   410  		dAtA[i] = byte(popr.Intn(256))
   411  	}
   412  	if err := p.VerboseEqual(msg); err != nil {
   413  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   414  	}
   415  	if !p.Equal(msg) {
   416  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   417  	}
   418  	if len(littlefuzz) > 0 {
   419  		fuzzamount := 100
   420  		for i := 0; i < fuzzamount; i++ {
   421  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   422  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   423  		}
   424  		// shouldn't panic
   425  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   426  	}
   427  }
   428  
   429  func BenchmarkFloatingPointProtoMarshal(b *testing.B) {
   430  	popr := math_rand.New(math_rand.NewSource(616))
   431  	total := 0
   432  	pops := make([]*FloatingPoint, 10000)
   433  	for i := 0; i < 10000; i++ {
   434  		pops[i] = NewPopulatedFloatingPoint(popr, false)
   435  	}
   436  	b.ResetTimer()
   437  	for i := 0; i < b.N; i++ {
   438  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   439  		if err != nil {
   440  			panic(err)
   441  		}
   442  		total += len(dAtA)
   443  	}
   444  	b.SetBytes(int64(total / b.N))
   445  }
   446  
   447  func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) {
   448  	popr := math_rand.New(math_rand.NewSource(616))
   449  	total := 0
   450  	datas := make([][]byte, 10000)
   451  	for i := 0; i < 10000; i++ {
   452  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false))
   453  		if err != nil {
   454  			panic(err)
   455  		}
   456  		datas[i] = dAtA
   457  	}
   458  	msg := &FloatingPoint{}
   459  	b.ResetTimer()
   460  	for i := 0; i < b.N; i++ {
   461  		total += len(datas[i%10000])
   462  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   463  			panic(err)
   464  		}
   465  	}
   466  	b.SetBytes(int64(total / b.N))
   467  }
   468  
   469  func TestUint128PairProto(t *testing.T) {
   470  	seed := time.Now().UnixNano()
   471  	popr := math_rand.New(math_rand.NewSource(seed))
   472  	p := NewPopulatedUint128Pair(popr, false)
   473  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   474  	if err != nil {
   475  		t.Fatalf("seed = %d, err = %v", seed, err)
   476  	}
   477  	msg := &Uint128Pair{}
   478  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   479  		t.Fatalf("seed = %d, err = %v", seed, err)
   480  	}
   481  	littlefuzz := make([]byte, len(dAtA))
   482  	copy(littlefuzz, dAtA)
   483  	for i := range dAtA {
   484  		dAtA[i] = byte(popr.Intn(256))
   485  	}
   486  	if err := p.VerboseEqual(msg); err != nil {
   487  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   488  	}
   489  	if !p.Equal(msg) {
   490  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   491  	}
   492  	if len(littlefuzz) > 0 {
   493  		fuzzamount := 100
   494  		for i := 0; i < fuzzamount; i++ {
   495  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   496  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   497  		}
   498  		// shouldn't panic
   499  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   500  	}
   501  }
   502  
   503  func BenchmarkUint128PairProtoMarshal(b *testing.B) {
   504  	popr := math_rand.New(math_rand.NewSource(616))
   505  	total := 0
   506  	pops := make([]*Uint128Pair, 10000)
   507  	for i := 0; i < 10000; i++ {
   508  		pops[i] = NewPopulatedUint128Pair(popr, false)
   509  	}
   510  	b.ResetTimer()
   511  	for i := 0; i < b.N; i++ {
   512  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   513  		if err != nil {
   514  			panic(err)
   515  		}
   516  		total += len(dAtA)
   517  	}
   518  	b.SetBytes(int64(total / b.N))
   519  }
   520  
   521  func BenchmarkUint128PairProtoUnmarshal(b *testing.B) {
   522  	popr := math_rand.New(math_rand.NewSource(616))
   523  	total := 0
   524  	datas := make([][]byte, 10000)
   525  	for i := 0; i < 10000; i++ {
   526  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUint128Pair(popr, false))
   527  		if err != nil {
   528  			panic(err)
   529  		}
   530  		datas[i] = dAtA
   531  	}
   532  	msg := &Uint128Pair{}
   533  	b.ResetTimer()
   534  	for i := 0; i < b.N; i++ {
   535  		total += len(datas[i%10000])
   536  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   537  			panic(err)
   538  		}
   539  	}
   540  	b.SetBytes(int64(total / b.N))
   541  }
   542  
   543  func TestContainsNestedMapProto(t *testing.T) {
   544  	seed := time.Now().UnixNano()
   545  	popr := math_rand.New(math_rand.NewSource(seed))
   546  	p := NewPopulatedContainsNestedMap(popr, false)
   547  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   548  	if err != nil {
   549  		t.Fatalf("seed = %d, err = %v", seed, err)
   550  	}
   551  	msg := &ContainsNestedMap{}
   552  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   553  		t.Fatalf("seed = %d, err = %v", seed, err)
   554  	}
   555  	littlefuzz := make([]byte, len(dAtA))
   556  	copy(littlefuzz, dAtA)
   557  	for i := range dAtA {
   558  		dAtA[i] = byte(popr.Intn(256))
   559  	}
   560  	if err := p.VerboseEqual(msg); err != nil {
   561  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   562  	}
   563  	if !p.Equal(msg) {
   564  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   565  	}
   566  	if len(littlefuzz) > 0 {
   567  		fuzzamount := 100
   568  		for i := 0; i < fuzzamount; i++ {
   569  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   570  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   571  		}
   572  		// shouldn't panic
   573  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   574  	}
   575  }
   576  
   577  func BenchmarkContainsNestedMapProtoMarshal(b *testing.B) {
   578  	popr := math_rand.New(math_rand.NewSource(616))
   579  	total := 0
   580  	pops := make([]*ContainsNestedMap, 10000)
   581  	for i := 0; i < 10000; i++ {
   582  		pops[i] = NewPopulatedContainsNestedMap(popr, false)
   583  	}
   584  	b.ResetTimer()
   585  	for i := 0; i < b.N; i++ {
   586  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   587  		if err != nil {
   588  			panic(err)
   589  		}
   590  		total += len(dAtA)
   591  	}
   592  	b.SetBytes(int64(total / b.N))
   593  }
   594  
   595  func BenchmarkContainsNestedMapProtoUnmarshal(b *testing.B) {
   596  	popr := math_rand.New(math_rand.NewSource(616))
   597  	total := 0
   598  	datas := make([][]byte, 10000)
   599  	for i := 0; i < 10000; i++ {
   600  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedContainsNestedMap(popr, false))
   601  		if err != nil {
   602  			panic(err)
   603  		}
   604  		datas[i] = dAtA
   605  	}
   606  	msg := &ContainsNestedMap{}
   607  	b.ResetTimer()
   608  	for i := 0; i < b.N; i++ {
   609  		total += len(datas[i%10000])
   610  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   611  			panic(err)
   612  		}
   613  	}
   614  	b.SetBytes(int64(total / b.N))
   615  }
   616  
   617  func TestContainsNestedMap_NestedMapProto(t *testing.T) {
   618  	seed := time.Now().UnixNano()
   619  	popr := math_rand.New(math_rand.NewSource(seed))
   620  	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
   621  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   622  	if err != nil {
   623  		t.Fatalf("seed = %d, err = %v", seed, err)
   624  	}
   625  	msg := &ContainsNestedMap_NestedMap{}
   626  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   627  		t.Fatalf("seed = %d, err = %v", seed, err)
   628  	}
   629  	littlefuzz := make([]byte, len(dAtA))
   630  	copy(littlefuzz, dAtA)
   631  	for i := range dAtA {
   632  		dAtA[i] = byte(popr.Intn(256))
   633  	}
   634  	if err := p.VerboseEqual(msg); err != nil {
   635  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   636  	}
   637  	if !p.Equal(msg) {
   638  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   639  	}
   640  	if len(littlefuzz) > 0 {
   641  		fuzzamount := 100
   642  		for i := 0; i < fuzzamount; i++ {
   643  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   644  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   645  		}
   646  		// shouldn't panic
   647  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   648  	}
   649  }
   650  
   651  func BenchmarkContainsNestedMap_NestedMapProtoMarshal(b *testing.B) {
   652  	popr := math_rand.New(math_rand.NewSource(616))
   653  	total := 0
   654  	pops := make([]*ContainsNestedMap_NestedMap, 10000)
   655  	for i := 0; i < 10000; i++ {
   656  		pops[i] = NewPopulatedContainsNestedMap_NestedMap(popr, false)
   657  	}
   658  	b.ResetTimer()
   659  	for i := 0; i < b.N; i++ {
   660  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   661  		if err != nil {
   662  			panic(err)
   663  		}
   664  		total += len(dAtA)
   665  	}
   666  	b.SetBytes(int64(total / b.N))
   667  }
   668  
   669  func BenchmarkContainsNestedMap_NestedMapProtoUnmarshal(b *testing.B) {
   670  	popr := math_rand.New(math_rand.NewSource(616))
   671  	total := 0
   672  	datas := make([][]byte, 10000)
   673  	for i := 0; i < 10000; i++ {
   674  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedContainsNestedMap_NestedMap(popr, false))
   675  		if err != nil {
   676  			panic(err)
   677  		}
   678  		datas[i] = dAtA
   679  	}
   680  	msg := &ContainsNestedMap_NestedMap{}
   681  	b.ResetTimer()
   682  	for i := 0; i < b.N; i++ {
   683  		total += len(datas[i%10000])
   684  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   685  			panic(err)
   686  		}
   687  	}
   688  	b.SetBytes(int64(total / b.N))
   689  }
   690  
   691  func TestNotPackedProto(t *testing.T) {
   692  	seed := time.Now().UnixNano()
   693  	popr := math_rand.New(math_rand.NewSource(seed))
   694  	p := NewPopulatedNotPacked(popr, false)
   695  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
   696  	if err != nil {
   697  		t.Fatalf("seed = %d, err = %v", seed, err)
   698  	}
   699  	msg := &NotPacked{}
   700  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
   701  		t.Fatalf("seed = %d, err = %v", seed, err)
   702  	}
   703  	littlefuzz := make([]byte, len(dAtA))
   704  	copy(littlefuzz, dAtA)
   705  	for i := range dAtA {
   706  		dAtA[i] = byte(popr.Intn(256))
   707  	}
   708  	if err := p.VerboseEqual(msg); err != nil {
   709  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   710  	}
   711  	if !p.Equal(msg) {
   712  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   713  	}
   714  	if len(littlefuzz) > 0 {
   715  		fuzzamount := 100
   716  		for i := 0; i < fuzzamount; i++ {
   717  			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
   718  			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
   719  		}
   720  		// shouldn't panic
   721  		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
   722  	}
   723  }
   724  
   725  func BenchmarkNotPackedProtoMarshal(b *testing.B) {
   726  	popr := math_rand.New(math_rand.NewSource(616))
   727  	total := 0
   728  	pops := make([]*NotPacked, 10000)
   729  	for i := 0; i < 10000; i++ {
   730  		pops[i] = NewPopulatedNotPacked(popr, false)
   731  	}
   732  	b.ResetTimer()
   733  	for i := 0; i < b.N; i++ {
   734  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000])
   735  		if err != nil {
   736  			panic(err)
   737  		}
   738  		total += len(dAtA)
   739  	}
   740  	b.SetBytes(int64(total / b.N))
   741  }
   742  
   743  func BenchmarkNotPackedProtoUnmarshal(b *testing.B) {
   744  	popr := math_rand.New(math_rand.NewSource(616))
   745  	total := 0
   746  	datas := make([][]byte, 10000)
   747  	for i := 0; i < 10000; i++ {
   748  		dAtA, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNotPacked(popr, false))
   749  		if err != nil {
   750  			panic(err)
   751  		}
   752  		datas[i] = dAtA
   753  	}
   754  	msg := &NotPacked{}
   755  	b.ResetTimer()
   756  	for i := 0; i < b.N; i++ {
   757  		total += len(datas[i%10000])
   758  		if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil {
   759  			panic(err)
   760  		}
   761  	}
   762  	b.SetBytes(int64(total / b.N))
   763  }
   764  
   765  func TestMessageJSON(t *testing.T) {
   766  	seed := time.Now().UnixNano()
   767  	popr := math_rand.New(math_rand.NewSource(seed))
   768  	p := NewPopulatedMessage(popr, true)
   769  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   770  	jsondata, err := marshaler.MarshalToString(p)
   771  	if err != nil {
   772  		t.Fatalf("seed = %d, err = %v", seed, err)
   773  	}
   774  	msg := &Message{}
   775  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   776  	if err != nil {
   777  		t.Fatalf("seed = %d, err = %v", seed, err)
   778  	}
   779  	if err := p.VerboseEqual(msg); err != nil {
   780  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   781  	}
   782  	if !p.Equal(msg) {
   783  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   784  	}
   785  }
   786  func TestNestedJSON(t *testing.T) {
   787  	seed := time.Now().UnixNano()
   788  	popr := math_rand.New(math_rand.NewSource(seed))
   789  	p := NewPopulatedNested(popr, true)
   790  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   791  	jsondata, err := marshaler.MarshalToString(p)
   792  	if err != nil {
   793  		t.Fatalf("seed = %d, err = %v", seed, err)
   794  	}
   795  	msg := &Nested{}
   796  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   797  	if err != nil {
   798  		t.Fatalf("seed = %d, err = %v", seed, err)
   799  	}
   800  	if err := p.VerboseEqual(msg); err != nil {
   801  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   802  	}
   803  	if !p.Equal(msg) {
   804  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   805  	}
   806  }
   807  func TestAllMapsJSON(t *testing.T) {
   808  	seed := time.Now().UnixNano()
   809  	popr := math_rand.New(math_rand.NewSource(seed))
   810  	p := NewPopulatedAllMaps(popr, true)
   811  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   812  	jsondata, err := marshaler.MarshalToString(p)
   813  	if err != nil {
   814  		t.Fatalf("seed = %d, err = %v", seed, err)
   815  	}
   816  	msg := &AllMaps{}
   817  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   818  	if err != nil {
   819  		t.Fatalf("seed = %d, err = %v", seed, err)
   820  	}
   821  	if err := p.VerboseEqual(msg); err != nil {
   822  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   823  	}
   824  	if !p.Equal(msg) {
   825  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   826  	}
   827  }
   828  func TestAllMapsOrderedJSON(t *testing.T) {
   829  	seed := time.Now().UnixNano()
   830  	popr := math_rand.New(math_rand.NewSource(seed))
   831  	p := NewPopulatedAllMapsOrdered(popr, true)
   832  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   833  	jsondata, err := marshaler.MarshalToString(p)
   834  	if err != nil {
   835  		t.Fatalf("seed = %d, err = %v", seed, err)
   836  	}
   837  	msg := &AllMapsOrdered{}
   838  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   839  	if err != nil {
   840  		t.Fatalf("seed = %d, err = %v", seed, err)
   841  	}
   842  	if err := p.VerboseEqual(msg); err != nil {
   843  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   844  	}
   845  	if !p.Equal(msg) {
   846  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   847  	}
   848  }
   849  func TestMessageWithMapJSON(t *testing.T) {
   850  	seed := time.Now().UnixNano()
   851  	popr := math_rand.New(math_rand.NewSource(seed))
   852  	p := NewPopulatedMessageWithMap(popr, true)
   853  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   854  	jsondata, err := marshaler.MarshalToString(p)
   855  	if err != nil {
   856  		t.Fatalf("seed = %d, err = %v", seed, err)
   857  	}
   858  	msg := &MessageWithMap{}
   859  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   860  	if err != nil {
   861  		t.Fatalf("seed = %d, err = %v", seed, err)
   862  	}
   863  	if err := p.VerboseEqual(msg); err != nil {
   864  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   865  	}
   866  	if !p.Equal(msg) {
   867  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   868  	}
   869  }
   870  func TestFloatingPointJSON(t *testing.T) {
   871  	seed := time.Now().UnixNano()
   872  	popr := math_rand.New(math_rand.NewSource(seed))
   873  	p := NewPopulatedFloatingPoint(popr, true)
   874  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   875  	jsondata, err := marshaler.MarshalToString(p)
   876  	if err != nil {
   877  		t.Fatalf("seed = %d, err = %v", seed, err)
   878  	}
   879  	msg := &FloatingPoint{}
   880  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   881  	if err != nil {
   882  		t.Fatalf("seed = %d, err = %v", seed, err)
   883  	}
   884  	if err := p.VerboseEqual(msg); err != nil {
   885  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   886  	}
   887  	if !p.Equal(msg) {
   888  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   889  	}
   890  }
   891  func TestUint128PairJSON(t *testing.T) {
   892  	seed := time.Now().UnixNano()
   893  	popr := math_rand.New(math_rand.NewSource(seed))
   894  	p := NewPopulatedUint128Pair(popr, true)
   895  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   896  	jsondata, err := marshaler.MarshalToString(p)
   897  	if err != nil {
   898  		t.Fatalf("seed = %d, err = %v", seed, err)
   899  	}
   900  	msg := &Uint128Pair{}
   901  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   902  	if err != nil {
   903  		t.Fatalf("seed = %d, err = %v", seed, err)
   904  	}
   905  	if err := p.VerboseEqual(msg); err != nil {
   906  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   907  	}
   908  	if !p.Equal(msg) {
   909  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   910  	}
   911  }
   912  func TestContainsNestedMapJSON(t *testing.T) {
   913  	seed := time.Now().UnixNano()
   914  	popr := math_rand.New(math_rand.NewSource(seed))
   915  	p := NewPopulatedContainsNestedMap(popr, true)
   916  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   917  	jsondata, err := marshaler.MarshalToString(p)
   918  	if err != nil {
   919  		t.Fatalf("seed = %d, err = %v", seed, err)
   920  	}
   921  	msg := &ContainsNestedMap{}
   922  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   923  	if err != nil {
   924  		t.Fatalf("seed = %d, err = %v", seed, err)
   925  	}
   926  	if err := p.VerboseEqual(msg); err != nil {
   927  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   928  	}
   929  	if !p.Equal(msg) {
   930  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   931  	}
   932  }
   933  func TestContainsNestedMap_NestedMapJSON(t *testing.T) {
   934  	seed := time.Now().UnixNano()
   935  	popr := math_rand.New(math_rand.NewSource(seed))
   936  	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
   937  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   938  	jsondata, err := marshaler.MarshalToString(p)
   939  	if err != nil {
   940  		t.Fatalf("seed = %d, err = %v", seed, err)
   941  	}
   942  	msg := &ContainsNestedMap_NestedMap{}
   943  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   944  	if err != nil {
   945  		t.Fatalf("seed = %d, err = %v", seed, err)
   946  	}
   947  	if err := p.VerboseEqual(msg); err != nil {
   948  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   949  	}
   950  	if !p.Equal(msg) {
   951  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   952  	}
   953  }
   954  func TestNotPackedJSON(t *testing.T) {
   955  	seed := time.Now().UnixNano()
   956  	popr := math_rand.New(math_rand.NewSource(seed))
   957  	p := NewPopulatedNotPacked(popr, true)
   958  	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
   959  	jsondata, err := marshaler.MarshalToString(p)
   960  	if err != nil {
   961  		t.Fatalf("seed = %d, err = %v", seed, err)
   962  	}
   963  	msg := &NotPacked{}
   964  	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
   965  	if err != nil {
   966  		t.Fatalf("seed = %d, err = %v", seed, err)
   967  	}
   968  	if err := p.VerboseEqual(msg); err != nil {
   969  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   970  	}
   971  	if !p.Equal(msg) {
   972  		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
   973  	}
   974  }
   975  func TestMessageProtoText(t *testing.T) {
   976  	seed := time.Now().UnixNano()
   977  	popr := math_rand.New(math_rand.NewSource(seed))
   978  	p := NewPopulatedMessage(popr, true)
   979  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
   980  	msg := &Message{}
   981  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
   982  		t.Fatalf("seed = %d, err = %v", seed, err)
   983  	}
   984  	if err := p.VerboseEqual(msg); err != nil {
   985  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
   986  	}
   987  	if !p.Equal(msg) {
   988  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
   989  	}
   990  }
   991  
   992  func TestMessageProtoCompactText(t *testing.T) {
   993  	seed := time.Now().UnixNano()
   994  	popr := math_rand.New(math_rand.NewSource(seed))
   995  	p := NewPopulatedMessage(popr, true)
   996  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
   997  	msg := &Message{}
   998  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
   999  		t.Fatalf("seed = %d, err = %v", seed, err)
  1000  	}
  1001  	if err := p.VerboseEqual(msg); err != nil {
  1002  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1003  	}
  1004  	if !p.Equal(msg) {
  1005  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1006  	}
  1007  }
  1008  
  1009  func TestNestedProtoText(t *testing.T) {
  1010  	seed := time.Now().UnixNano()
  1011  	popr := math_rand.New(math_rand.NewSource(seed))
  1012  	p := NewPopulatedNested(popr, true)
  1013  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1014  	msg := &Nested{}
  1015  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1016  		t.Fatalf("seed = %d, err = %v", seed, err)
  1017  	}
  1018  	if err := p.VerboseEqual(msg); err != nil {
  1019  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1020  	}
  1021  	if !p.Equal(msg) {
  1022  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1023  	}
  1024  }
  1025  
  1026  func TestNestedProtoCompactText(t *testing.T) {
  1027  	seed := time.Now().UnixNano()
  1028  	popr := math_rand.New(math_rand.NewSource(seed))
  1029  	p := NewPopulatedNested(popr, true)
  1030  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1031  	msg := &Nested{}
  1032  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1033  		t.Fatalf("seed = %d, err = %v", seed, err)
  1034  	}
  1035  	if err := p.VerboseEqual(msg); err != nil {
  1036  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1037  	}
  1038  	if !p.Equal(msg) {
  1039  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1040  	}
  1041  }
  1042  
  1043  func TestAllMapsProtoText(t *testing.T) {
  1044  	seed := time.Now().UnixNano()
  1045  	popr := math_rand.New(math_rand.NewSource(seed))
  1046  	p := NewPopulatedAllMaps(popr, true)
  1047  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1048  	msg := &AllMaps{}
  1049  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1050  		t.Fatalf("seed = %d, err = %v", seed, err)
  1051  	}
  1052  	if err := p.VerboseEqual(msg); err != nil {
  1053  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1054  	}
  1055  	if !p.Equal(msg) {
  1056  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1057  	}
  1058  }
  1059  
  1060  func TestAllMapsProtoCompactText(t *testing.T) {
  1061  	seed := time.Now().UnixNano()
  1062  	popr := math_rand.New(math_rand.NewSource(seed))
  1063  	p := NewPopulatedAllMaps(popr, true)
  1064  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1065  	msg := &AllMaps{}
  1066  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1067  		t.Fatalf("seed = %d, err = %v", seed, err)
  1068  	}
  1069  	if err := p.VerboseEqual(msg); err != nil {
  1070  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1071  	}
  1072  	if !p.Equal(msg) {
  1073  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1074  	}
  1075  }
  1076  
  1077  func TestAllMapsOrderedProtoText(t *testing.T) {
  1078  	seed := time.Now().UnixNano()
  1079  	popr := math_rand.New(math_rand.NewSource(seed))
  1080  	p := NewPopulatedAllMapsOrdered(popr, true)
  1081  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1082  	msg := &AllMapsOrdered{}
  1083  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1084  		t.Fatalf("seed = %d, err = %v", seed, err)
  1085  	}
  1086  	if err := p.VerboseEqual(msg); err != nil {
  1087  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1088  	}
  1089  	if !p.Equal(msg) {
  1090  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1091  	}
  1092  }
  1093  
  1094  func TestAllMapsOrderedProtoCompactText(t *testing.T) {
  1095  	seed := time.Now().UnixNano()
  1096  	popr := math_rand.New(math_rand.NewSource(seed))
  1097  	p := NewPopulatedAllMapsOrdered(popr, true)
  1098  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1099  	msg := &AllMapsOrdered{}
  1100  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1101  		t.Fatalf("seed = %d, err = %v", seed, err)
  1102  	}
  1103  	if err := p.VerboseEqual(msg); err != nil {
  1104  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1105  	}
  1106  	if !p.Equal(msg) {
  1107  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1108  	}
  1109  }
  1110  
  1111  func TestMessageWithMapProtoText(t *testing.T) {
  1112  	seed := time.Now().UnixNano()
  1113  	popr := math_rand.New(math_rand.NewSource(seed))
  1114  	p := NewPopulatedMessageWithMap(popr, true)
  1115  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1116  	msg := &MessageWithMap{}
  1117  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1118  		t.Fatalf("seed = %d, err = %v", seed, err)
  1119  	}
  1120  	if err := p.VerboseEqual(msg); err != nil {
  1121  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1122  	}
  1123  	if !p.Equal(msg) {
  1124  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1125  	}
  1126  }
  1127  
  1128  func TestMessageWithMapProtoCompactText(t *testing.T) {
  1129  	seed := time.Now().UnixNano()
  1130  	popr := math_rand.New(math_rand.NewSource(seed))
  1131  	p := NewPopulatedMessageWithMap(popr, true)
  1132  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1133  	msg := &MessageWithMap{}
  1134  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1135  		t.Fatalf("seed = %d, err = %v", seed, err)
  1136  	}
  1137  	if err := p.VerboseEqual(msg); err != nil {
  1138  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1139  	}
  1140  	if !p.Equal(msg) {
  1141  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1142  	}
  1143  }
  1144  
  1145  func TestFloatingPointProtoText(t *testing.T) {
  1146  	seed := time.Now().UnixNano()
  1147  	popr := math_rand.New(math_rand.NewSource(seed))
  1148  	p := NewPopulatedFloatingPoint(popr, true)
  1149  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1150  	msg := &FloatingPoint{}
  1151  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1152  		t.Fatalf("seed = %d, err = %v", seed, err)
  1153  	}
  1154  	if err := p.VerboseEqual(msg); err != nil {
  1155  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1156  	}
  1157  	if !p.Equal(msg) {
  1158  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1159  	}
  1160  }
  1161  
  1162  func TestFloatingPointProtoCompactText(t *testing.T) {
  1163  	seed := time.Now().UnixNano()
  1164  	popr := math_rand.New(math_rand.NewSource(seed))
  1165  	p := NewPopulatedFloatingPoint(popr, true)
  1166  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1167  	msg := &FloatingPoint{}
  1168  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1169  		t.Fatalf("seed = %d, err = %v", seed, err)
  1170  	}
  1171  	if err := p.VerboseEqual(msg); err != nil {
  1172  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1173  	}
  1174  	if !p.Equal(msg) {
  1175  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1176  	}
  1177  }
  1178  
  1179  func TestUint128PairProtoText(t *testing.T) {
  1180  	seed := time.Now().UnixNano()
  1181  	popr := math_rand.New(math_rand.NewSource(seed))
  1182  	p := NewPopulatedUint128Pair(popr, true)
  1183  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1184  	msg := &Uint128Pair{}
  1185  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1186  		t.Fatalf("seed = %d, err = %v", seed, err)
  1187  	}
  1188  	if err := p.VerboseEqual(msg); err != nil {
  1189  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1190  	}
  1191  	if !p.Equal(msg) {
  1192  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1193  	}
  1194  }
  1195  
  1196  func TestUint128PairProtoCompactText(t *testing.T) {
  1197  	seed := time.Now().UnixNano()
  1198  	popr := math_rand.New(math_rand.NewSource(seed))
  1199  	p := NewPopulatedUint128Pair(popr, true)
  1200  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1201  	msg := &Uint128Pair{}
  1202  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1203  		t.Fatalf("seed = %d, err = %v", seed, err)
  1204  	}
  1205  	if err := p.VerboseEqual(msg); err != nil {
  1206  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1207  	}
  1208  	if !p.Equal(msg) {
  1209  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1210  	}
  1211  }
  1212  
  1213  func TestContainsNestedMapProtoText(t *testing.T) {
  1214  	seed := time.Now().UnixNano()
  1215  	popr := math_rand.New(math_rand.NewSource(seed))
  1216  	p := NewPopulatedContainsNestedMap(popr, true)
  1217  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1218  	msg := &ContainsNestedMap{}
  1219  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1220  		t.Fatalf("seed = %d, err = %v", seed, err)
  1221  	}
  1222  	if err := p.VerboseEqual(msg); err != nil {
  1223  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1224  	}
  1225  	if !p.Equal(msg) {
  1226  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1227  	}
  1228  }
  1229  
  1230  func TestContainsNestedMapProtoCompactText(t *testing.T) {
  1231  	seed := time.Now().UnixNano()
  1232  	popr := math_rand.New(math_rand.NewSource(seed))
  1233  	p := NewPopulatedContainsNestedMap(popr, true)
  1234  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1235  	msg := &ContainsNestedMap{}
  1236  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1237  		t.Fatalf("seed = %d, err = %v", seed, err)
  1238  	}
  1239  	if err := p.VerboseEqual(msg); err != nil {
  1240  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1241  	}
  1242  	if !p.Equal(msg) {
  1243  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1244  	}
  1245  }
  1246  
  1247  func TestContainsNestedMap_NestedMapProtoText(t *testing.T) {
  1248  	seed := time.Now().UnixNano()
  1249  	popr := math_rand.New(math_rand.NewSource(seed))
  1250  	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
  1251  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1252  	msg := &ContainsNestedMap_NestedMap{}
  1253  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1254  		t.Fatalf("seed = %d, err = %v", seed, err)
  1255  	}
  1256  	if err := p.VerboseEqual(msg); err != nil {
  1257  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1258  	}
  1259  	if !p.Equal(msg) {
  1260  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1261  	}
  1262  }
  1263  
  1264  func TestContainsNestedMap_NestedMapProtoCompactText(t *testing.T) {
  1265  	seed := time.Now().UnixNano()
  1266  	popr := math_rand.New(math_rand.NewSource(seed))
  1267  	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
  1268  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1269  	msg := &ContainsNestedMap_NestedMap{}
  1270  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1271  		t.Fatalf("seed = %d, err = %v", seed, err)
  1272  	}
  1273  	if err := p.VerboseEqual(msg); err != nil {
  1274  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1275  	}
  1276  	if !p.Equal(msg) {
  1277  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1278  	}
  1279  }
  1280  
  1281  func TestNotPackedProtoText(t *testing.T) {
  1282  	seed := time.Now().UnixNano()
  1283  	popr := math_rand.New(math_rand.NewSource(seed))
  1284  	p := NewPopulatedNotPacked(popr, true)
  1285  	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
  1286  	msg := &NotPacked{}
  1287  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1288  		t.Fatalf("seed = %d, err = %v", seed, err)
  1289  	}
  1290  	if err := p.VerboseEqual(msg); err != nil {
  1291  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1292  	}
  1293  	if !p.Equal(msg) {
  1294  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1295  	}
  1296  }
  1297  
  1298  func TestNotPackedProtoCompactText(t *testing.T) {
  1299  	seed := time.Now().UnixNano()
  1300  	popr := math_rand.New(math_rand.NewSource(seed))
  1301  	p := NewPopulatedNotPacked(popr, true)
  1302  	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
  1303  	msg := &NotPacked{}
  1304  	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
  1305  		t.Fatalf("seed = %d, err = %v", seed, err)
  1306  	}
  1307  	if err := p.VerboseEqual(msg); err != nil {
  1308  		t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)
  1309  	}
  1310  	if !p.Equal(msg) {
  1311  		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
  1312  	}
  1313  }
  1314  
  1315  func TestTheproto3Description(t *testing.T) {
  1316  	Theproto3Description()
  1317  }
  1318  func TestMessageVerboseEqual(t *testing.T) {
  1319  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1320  	p := NewPopulatedMessage(popr, false)
  1321  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1322  	if err != nil {
  1323  		panic(err)
  1324  	}
  1325  	msg := &Message{}
  1326  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1327  		panic(err)
  1328  	}
  1329  	if err := p.VerboseEqual(msg); err != nil {
  1330  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1331  	}
  1332  }
  1333  func TestNestedVerboseEqual(t *testing.T) {
  1334  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1335  	p := NewPopulatedNested(popr, false)
  1336  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1337  	if err != nil {
  1338  		panic(err)
  1339  	}
  1340  	msg := &Nested{}
  1341  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1342  		panic(err)
  1343  	}
  1344  	if err := p.VerboseEqual(msg); err != nil {
  1345  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1346  	}
  1347  }
  1348  func TestAllMapsVerboseEqual(t *testing.T) {
  1349  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1350  	p := NewPopulatedAllMaps(popr, false)
  1351  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1352  	if err != nil {
  1353  		panic(err)
  1354  	}
  1355  	msg := &AllMaps{}
  1356  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1357  		panic(err)
  1358  	}
  1359  	if err := p.VerboseEqual(msg); err != nil {
  1360  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1361  	}
  1362  }
  1363  func TestAllMapsOrderedVerboseEqual(t *testing.T) {
  1364  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1365  	p := NewPopulatedAllMapsOrdered(popr, false)
  1366  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1367  	if err != nil {
  1368  		panic(err)
  1369  	}
  1370  	msg := &AllMapsOrdered{}
  1371  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1372  		panic(err)
  1373  	}
  1374  	if err := p.VerboseEqual(msg); err != nil {
  1375  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1376  	}
  1377  }
  1378  func TestMessageWithMapVerboseEqual(t *testing.T) {
  1379  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1380  	p := NewPopulatedMessageWithMap(popr, false)
  1381  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1382  	if err != nil {
  1383  		panic(err)
  1384  	}
  1385  	msg := &MessageWithMap{}
  1386  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1387  		panic(err)
  1388  	}
  1389  	if err := p.VerboseEqual(msg); err != nil {
  1390  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1391  	}
  1392  }
  1393  func TestFloatingPointVerboseEqual(t *testing.T) {
  1394  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1395  	p := NewPopulatedFloatingPoint(popr, false)
  1396  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1397  	if err != nil {
  1398  		panic(err)
  1399  	}
  1400  	msg := &FloatingPoint{}
  1401  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1402  		panic(err)
  1403  	}
  1404  	if err := p.VerboseEqual(msg); err != nil {
  1405  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1406  	}
  1407  }
  1408  func TestUint128PairVerboseEqual(t *testing.T) {
  1409  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1410  	p := NewPopulatedUint128Pair(popr, false)
  1411  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1412  	if err != nil {
  1413  		panic(err)
  1414  	}
  1415  	msg := &Uint128Pair{}
  1416  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1417  		panic(err)
  1418  	}
  1419  	if err := p.VerboseEqual(msg); err != nil {
  1420  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1421  	}
  1422  }
  1423  func TestContainsNestedMapVerboseEqual(t *testing.T) {
  1424  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1425  	p := NewPopulatedContainsNestedMap(popr, false)
  1426  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1427  	if err != nil {
  1428  		panic(err)
  1429  	}
  1430  	msg := &ContainsNestedMap{}
  1431  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1432  		panic(err)
  1433  	}
  1434  	if err := p.VerboseEqual(msg); err != nil {
  1435  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1436  	}
  1437  }
  1438  func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) {
  1439  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1440  	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
  1441  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1442  	if err != nil {
  1443  		panic(err)
  1444  	}
  1445  	msg := &ContainsNestedMap_NestedMap{}
  1446  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1447  		panic(err)
  1448  	}
  1449  	if err := p.VerboseEqual(msg); err != nil {
  1450  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1451  	}
  1452  }
  1453  func TestNotPackedVerboseEqual(t *testing.T) {
  1454  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1455  	p := NewPopulatedNotPacked(popr, false)
  1456  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1457  	if err != nil {
  1458  		panic(err)
  1459  	}
  1460  	msg := &NotPacked{}
  1461  	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
  1462  		panic(err)
  1463  	}
  1464  	if err := p.VerboseEqual(msg); err != nil {
  1465  		t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)
  1466  	}
  1467  }
  1468  func TestMessageFace(t *testing.T) {
  1469  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1470  	p := NewPopulatedMessage(popr, true)
  1471  	msg := p.TestProto()
  1472  	if !p.Equal(msg) {
  1473  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1474  	}
  1475  }
  1476  func TestNestedFace(t *testing.T) {
  1477  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1478  	p := NewPopulatedNested(popr, true)
  1479  	msg := p.TestProto()
  1480  	if !p.Equal(msg) {
  1481  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1482  	}
  1483  }
  1484  func TestAllMapsFace(t *testing.T) {
  1485  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1486  	p := NewPopulatedAllMaps(popr, true)
  1487  	msg := p.TestProto()
  1488  	if !p.Equal(msg) {
  1489  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1490  	}
  1491  }
  1492  func TestAllMapsOrderedFace(t *testing.T) {
  1493  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1494  	p := NewPopulatedAllMapsOrdered(popr, true)
  1495  	msg := p.TestProto()
  1496  	if !p.Equal(msg) {
  1497  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1498  	}
  1499  }
  1500  func TestMessageWithMapFace(t *testing.T) {
  1501  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1502  	p := NewPopulatedMessageWithMap(popr, true)
  1503  	msg := p.TestProto()
  1504  	if !p.Equal(msg) {
  1505  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1506  	}
  1507  }
  1508  func TestFloatingPointFace(t *testing.T) {
  1509  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1510  	p := NewPopulatedFloatingPoint(popr, true)
  1511  	msg := p.TestProto()
  1512  	if !p.Equal(msg) {
  1513  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1514  	}
  1515  }
  1516  func TestUint128PairFace(t *testing.T) {
  1517  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1518  	p := NewPopulatedUint128Pair(popr, true)
  1519  	msg := p.TestProto()
  1520  	if !p.Equal(msg) {
  1521  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1522  	}
  1523  }
  1524  func TestContainsNestedMapFace(t *testing.T) {
  1525  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1526  	p := NewPopulatedContainsNestedMap(popr, true)
  1527  	msg := p.TestProto()
  1528  	if !p.Equal(msg) {
  1529  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1530  	}
  1531  }
  1532  func TestContainsNestedMap_NestedMapFace(t *testing.T) {
  1533  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1534  	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
  1535  	msg := p.TestProto()
  1536  	if !p.Equal(msg) {
  1537  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1538  	}
  1539  }
  1540  func TestNotPackedFace(t *testing.T) {
  1541  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1542  	p := NewPopulatedNotPacked(popr, true)
  1543  	msg := p.TestProto()
  1544  	if !p.Equal(msg) {
  1545  		t.Fatalf("%#v !Face Equal %#v", msg, p)
  1546  	}
  1547  }
  1548  func TestMessageGoString(t *testing.T) {
  1549  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1550  	p := NewPopulatedMessage(popr, false)
  1551  	s1 := p.GoString()
  1552  	s2 := fmt.Sprintf("%#v", p)
  1553  	if s1 != s2 {
  1554  		t.Fatalf("GoString want %v got %v", s1, s2)
  1555  	}
  1556  	_, err := go_parser.ParseExpr(s1)
  1557  	if err != nil {
  1558  		t.Fatal(err)
  1559  	}
  1560  }
  1561  func TestNestedGoString(t *testing.T) {
  1562  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1563  	p := NewPopulatedNested(popr, false)
  1564  	s1 := p.GoString()
  1565  	s2 := fmt.Sprintf("%#v", p)
  1566  	if s1 != s2 {
  1567  		t.Fatalf("GoString want %v got %v", s1, s2)
  1568  	}
  1569  	_, err := go_parser.ParseExpr(s1)
  1570  	if err != nil {
  1571  		t.Fatal(err)
  1572  	}
  1573  }
  1574  func TestAllMapsGoString(t *testing.T) {
  1575  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1576  	p := NewPopulatedAllMaps(popr, false)
  1577  	s1 := p.GoString()
  1578  	s2 := fmt.Sprintf("%#v", p)
  1579  	if s1 != s2 {
  1580  		t.Fatalf("GoString want %v got %v", s1, s2)
  1581  	}
  1582  	_, err := go_parser.ParseExpr(s1)
  1583  	if err != nil {
  1584  		t.Fatal(err)
  1585  	}
  1586  }
  1587  func TestAllMapsOrderedGoString(t *testing.T) {
  1588  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1589  	p := NewPopulatedAllMapsOrdered(popr, false)
  1590  	s1 := p.GoString()
  1591  	s2 := fmt.Sprintf("%#v", p)
  1592  	if s1 != s2 {
  1593  		t.Fatalf("GoString want %v got %v", s1, s2)
  1594  	}
  1595  	_, err := go_parser.ParseExpr(s1)
  1596  	if err != nil {
  1597  		t.Fatal(err)
  1598  	}
  1599  }
  1600  func TestMessageWithMapGoString(t *testing.T) {
  1601  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1602  	p := NewPopulatedMessageWithMap(popr, false)
  1603  	s1 := p.GoString()
  1604  	s2 := fmt.Sprintf("%#v", p)
  1605  	if s1 != s2 {
  1606  		t.Fatalf("GoString want %v got %v", s1, s2)
  1607  	}
  1608  	_, err := go_parser.ParseExpr(s1)
  1609  	if err != nil {
  1610  		t.Fatal(err)
  1611  	}
  1612  }
  1613  func TestFloatingPointGoString(t *testing.T) {
  1614  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1615  	p := NewPopulatedFloatingPoint(popr, false)
  1616  	s1 := p.GoString()
  1617  	s2 := fmt.Sprintf("%#v", p)
  1618  	if s1 != s2 {
  1619  		t.Fatalf("GoString want %v got %v", s1, s2)
  1620  	}
  1621  	_, err := go_parser.ParseExpr(s1)
  1622  	if err != nil {
  1623  		t.Fatal(err)
  1624  	}
  1625  }
  1626  func TestUint128PairGoString(t *testing.T) {
  1627  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1628  	p := NewPopulatedUint128Pair(popr, false)
  1629  	s1 := p.GoString()
  1630  	s2 := fmt.Sprintf("%#v", p)
  1631  	if s1 != s2 {
  1632  		t.Fatalf("GoString want %v got %v", s1, s2)
  1633  	}
  1634  	_, err := go_parser.ParseExpr(s1)
  1635  	if err != nil {
  1636  		t.Fatal(err)
  1637  	}
  1638  }
  1639  func TestContainsNestedMapGoString(t *testing.T) {
  1640  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1641  	p := NewPopulatedContainsNestedMap(popr, false)
  1642  	s1 := p.GoString()
  1643  	s2 := fmt.Sprintf("%#v", p)
  1644  	if s1 != s2 {
  1645  		t.Fatalf("GoString want %v got %v", s1, s2)
  1646  	}
  1647  	_, err := go_parser.ParseExpr(s1)
  1648  	if err != nil {
  1649  		t.Fatal(err)
  1650  	}
  1651  }
  1652  func TestContainsNestedMap_NestedMapGoString(t *testing.T) {
  1653  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1654  	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
  1655  	s1 := p.GoString()
  1656  	s2 := fmt.Sprintf("%#v", p)
  1657  	if s1 != s2 {
  1658  		t.Fatalf("GoString want %v got %v", s1, s2)
  1659  	}
  1660  	_, err := go_parser.ParseExpr(s1)
  1661  	if err != nil {
  1662  		t.Fatal(err)
  1663  	}
  1664  }
  1665  func TestNotPackedGoString(t *testing.T) {
  1666  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  1667  	p := NewPopulatedNotPacked(popr, false)
  1668  	s1 := p.GoString()
  1669  	s2 := fmt.Sprintf("%#v", p)
  1670  	if s1 != s2 {
  1671  		t.Fatalf("GoString want %v got %v", s1, s2)
  1672  	}
  1673  	_, err := go_parser.ParseExpr(s1)
  1674  	if err != nil {
  1675  		t.Fatal(err)
  1676  	}
  1677  }
  1678  func TestMessageSize(t *testing.T) {
  1679  	seed := time.Now().UnixNano()
  1680  	popr := math_rand.New(math_rand.NewSource(seed))
  1681  	p := NewPopulatedMessage(popr, true)
  1682  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1683  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1684  	if err != nil {
  1685  		t.Fatalf("seed = %d, err = %v", seed, err)
  1686  	}
  1687  	size := p.Size()
  1688  	if len(dAtA) != size {
  1689  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1690  	}
  1691  	if size2 != size {
  1692  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1693  	}
  1694  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1695  	if size3 != size {
  1696  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1697  	}
  1698  }
  1699  
  1700  func BenchmarkMessageSize(b *testing.B) {
  1701  	popr := math_rand.New(math_rand.NewSource(616))
  1702  	total := 0
  1703  	pops := make([]*Message, 1000)
  1704  	for i := 0; i < 1000; i++ {
  1705  		pops[i] = NewPopulatedMessage(popr, false)
  1706  	}
  1707  	b.ResetTimer()
  1708  	for i := 0; i < b.N; i++ {
  1709  		total += pops[i%1000].Size()
  1710  	}
  1711  	b.SetBytes(int64(total / b.N))
  1712  }
  1713  
  1714  func TestNestedSize(t *testing.T) {
  1715  	seed := time.Now().UnixNano()
  1716  	popr := math_rand.New(math_rand.NewSource(seed))
  1717  	p := NewPopulatedNested(popr, true)
  1718  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1719  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1720  	if err != nil {
  1721  		t.Fatalf("seed = %d, err = %v", seed, err)
  1722  	}
  1723  	size := p.Size()
  1724  	if len(dAtA) != size {
  1725  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1726  	}
  1727  	if size2 != size {
  1728  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1729  	}
  1730  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1731  	if size3 != size {
  1732  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1733  	}
  1734  }
  1735  
  1736  func BenchmarkNestedSize(b *testing.B) {
  1737  	popr := math_rand.New(math_rand.NewSource(616))
  1738  	total := 0
  1739  	pops := make([]*Nested, 1000)
  1740  	for i := 0; i < 1000; i++ {
  1741  		pops[i] = NewPopulatedNested(popr, false)
  1742  	}
  1743  	b.ResetTimer()
  1744  	for i := 0; i < b.N; i++ {
  1745  		total += pops[i%1000].Size()
  1746  	}
  1747  	b.SetBytes(int64(total / b.N))
  1748  }
  1749  
  1750  func TestAllMapsSize(t *testing.T) {
  1751  	seed := time.Now().UnixNano()
  1752  	popr := math_rand.New(math_rand.NewSource(seed))
  1753  	p := NewPopulatedAllMaps(popr, true)
  1754  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1755  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1756  	if err != nil {
  1757  		t.Fatalf("seed = %d, err = %v", seed, err)
  1758  	}
  1759  	size := p.Size()
  1760  	if len(dAtA) != size {
  1761  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1762  	}
  1763  	if size2 != size {
  1764  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1765  	}
  1766  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1767  	if size3 != size {
  1768  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1769  	}
  1770  }
  1771  
  1772  func BenchmarkAllMapsSize(b *testing.B) {
  1773  	popr := math_rand.New(math_rand.NewSource(616))
  1774  	total := 0
  1775  	pops := make([]*AllMaps, 1000)
  1776  	for i := 0; i < 1000; i++ {
  1777  		pops[i] = NewPopulatedAllMaps(popr, false)
  1778  	}
  1779  	b.ResetTimer()
  1780  	for i := 0; i < b.N; i++ {
  1781  		total += pops[i%1000].Size()
  1782  	}
  1783  	b.SetBytes(int64(total / b.N))
  1784  }
  1785  
  1786  func TestAllMapsOrderedSize(t *testing.T) {
  1787  	seed := time.Now().UnixNano()
  1788  	popr := math_rand.New(math_rand.NewSource(seed))
  1789  	p := NewPopulatedAllMapsOrdered(popr, true)
  1790  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1791  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1792  	if err != nil {
  1793  		t.Fatalf("seed = %d, err = %v", seed, err)
  1794  	}
  1795  	size := p.Size()
  1796  	if len(dAtA) != size {
  1797  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1798  	}
  1799  	if size2 != size {
  1800  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1801  	}
  1802  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1803  	if size3 != size {
  1804  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1805  	}
  1806  }
  1807  
  1808  func BenchmarkAllMapsOrderedSize(b *testing.B) {
  1809  	popr := math_rand.New(math_rand.NewSource(616))
  1810  	total := 0
  1811  	pops := make([]*AllMapsOrdered, 1000)
  1812  	for i := 0; i < 1000; i++ {
  1813  		pops[i] = NewPopulatedAllMapsOrdered(popr, false)
  1814  	}
  1815  	b.ResetTimer()
  1816  	for i := 0; i < b.N; i++ {
  1817  		total += pops[i%1000].Size()
  1818  	}
  1819  	b.SetBytes(int64(total / b.N))
  1820  }
  1821  
  1822  func TestMessageWithMapSize(t *testing.T) {
  1823  	seed := time.Now().UnixNano()
  1824  	popr := math_rand.New(math_rand.NewSource(seed))
  1825  	p := NewPopulatedMessageWithMap(popr, true)
  1826  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1827  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1828  	if err != nil {
  1829  		t.Fatalf("seed = %d, err = %v", seed, err)
  1830  	}
  1831  	size := p.Size()
  1832  	if len(dAtA) != size {
  1833  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1834  	}
  1835  	if size2 != size {
  1836  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1837  	}
  1838  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1839  	if size3 != size {
  1840  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1841  	}
  1842  }
  1843  
  1844  func BenchmarkMessageWithMapSize(b *testing.B) {
  1845  	popr := math_rand.New(math_rand.NewSource(616))
  1846  	total := 0
  1847  	pops := make([]*MessageWithMap, 1000)
  1848  	for i := 0; i < 1000; i++ {
  1849  		pops[i] = NewPopulatedMessageWithMap(popr, false)
  1850  	}
  1851  	b.ResetTimer()
  1852  	for i := 0; i < b.N; i++ {
  1853  		total += pops[i%1000].Size()
  1854  	}
  1855  	b.SetBytes(int64(total / b.N))
  1856  }
  1857  
  1858  func TestFloatingPointSize(t *testing.T) {
  1859  	seed := time.Now().UnixNano()
  1860  	popr := math_rand.New(math_rand.NewSource(seed))
  1861  	p := NewPopulatedFloatingPoint(popr, true)
  1862  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1863  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1864  	if err != nil {
  1865  		t.Fatalf("seed = %d, err = %v", seed, err)
  1866  	}
  1867  	size := p.Size()
  1868  	if len(dAtA) != size {
  1869  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1870  	}
  1871  	if size2 != size {
  1872  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1873  	}
  1874  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1875  	if size3 != size {
  1876  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1877  	}
  1878  }
  1879  
  1880  func BenchmarkFloatingPointSize(b *testing.B) {
  1881  	popr := math_rand.New(math_rand.NewSource(616))
  1882  	total := 0
  1883  	pops := make([]*FloatingPoint, 1000)
  1884  	for i := 0; i < 1000; i++ {
  1885  		pops[i] = NewPopulatedFloatingPoint(popr, false)
  1886  	}
  1887  	b.ResetTimer()
  1888  	for i := 0; i < b.N; i++ {
  1889  		total += pops[i%1000].Size()
  1890  	}
  1891  	b.SetBytes(int64(total / b.N))
  1892  }
  1893  
  1894  func TestUint128PairSize(t *testing.T) {
  1895  	seed := time.Now().UnixNano()
  1896  	popr := math_rand.New(math_rand.NewSource(seed))
  1897  	p := NewPopulatedUint128Pair(popr, true)
  1898  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1899  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1900  	if err != nil {
  1901  		t.Fatalf("seed = %d, err = %v", seed, err)
  1902  	}
  1903  	size := p.Size()
  1904  	if len(dAtA) != size {
  1905  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1906  	}
  1907  	if size2 != size {
  1908  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1909  	}
  1910  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1911  	if size3 != size {
  1912  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1913  	}
  1914  }
  1915  
  1916  func BenchmarkUint128PairSize(b *testing.B) {
  1917  	popr := math_rand.New(math_rand.NewSource(616))
  1918  	total := 0
  1919  	pops := make([]*Uint128Pair, 1000)
  1920  	for i := 0; i < 1000; i++ {
  1921  		pops[i] = NewPopulatedUint128Pair(popr, false)
  1922  	}
  1923  	b.ResetTimer()
  1924  	for i := 0; i < b.N; i++ {
  1925  		total += pops[i%1000].Size()
  1926  	}
  1927  	b.SetBytes(int64(total / b.N))
  1928  }
  1929  
  1930  func TestContainsNestedMapSize(t *testing.T) {
  1931  	seed := time.Now().UnixNano()
  1932  	popr := math_rand.New(math_rand.NewSource(seed))
  1933  	p := NewPopulatedContainsNestedMap(popr, true)
  1934  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1935  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1936  	if err != nil {
  1937  		t.Fatalf("seed = %d, err = %v", seed, err)
  1938  	}
  1939  	size := p.Size()
  1940  	if len(dAtA) != size {
  1941  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1942  	}
  1943  	if size2 != size {
  1944  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1945  	}
  1946  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1947  	if size3 != size {
  1948  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1949  	}
  1950  }
  1951  
  1952  func BenchmarkContainsNestedMapSize(b *testing.B) {
  1953  	popr := math_rand.New(math_rand.NewSource(616))
  1954  	total := 0
  1955  	pops := make([]*ContainsNestedMap, 1000)
  1956  	for i := 0; i < 1000; i++ {
  1957  		pops[i] = NewPopulatedContainsNestedMap(popr, false)
  1958  	}
  1959  	b.ResetTimer()
  1960  	for i := 0; i < b.N; i++ {
  1961  		total += pops[i%1000].Size()
  1962  	}
  1963  	b.SetBytes(int64(total / b.N))
  1964  }
  1965  
  1966  func TestContainsNestedMap_NestedMapSize(t *testing.T) {
  1967  	seed := time.Now().UnixNano()
  1968  	popr := math_rand.New(math_rand.NewSource(seed))
  1969  	p := NewPopulatedContainsNestedMap_NestedMap(popr, true)
  1970  	size2 := github_com_gogo_protobuf_proto.Size(p)
  1971  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  1972  	if err != nil {
  1973  		t.Fatalf("seed = %d, err = %v", seed, err)
  1974  	}
  1975  	size := p.Size()
  1976  	if len(dAtA) != size {
  1977  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  1978  	}
  1979  	if size2 != size {
  1980  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  1981  	}
  1982  	size3 := github_com_gogo_protobuf_proto.Size(p)
  1983  	if size3 != size {
  1984  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  1985  	}
  1986  }
  1987  
  1988  func BenchmarkContainsNestedMap_NestedMapSize(b *testing.B) {
  1989  	popr := math_rand.New(math_rand.NewSource(616))
  1990  	total := 0
  1991  	pops := make([]*ContainsNestedMap_NestedMap, 1000)
  1992  	for i := 0; i < 1000; i++ {
  1993  		pops[i] = NewPopulatedContainsNestedMap_NestedMap(popr, false)
  1994  	}
  1995  	b.ResetTimer()
  1996  	for i := 0; i < b.N; i++ {
  1997  		total += pops[i%1000].Size()
  1998  	}
  1999  	b.SetBytes(int64(total / b.N))
  2000  }
  2001  
  2002  func TestNotPackedSize(t *testing.T) {
  2003  	seed := time.Now().UnixNano()
  2004  	popr := math_rand.New(math_rand.NewSource(seed))
  2005  	p := NewPopulatedNotPacked(popr, true)
  2006  	size2 := github_com_gogo_protobuf_proto.Size(p)
  2007  	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
  2008  	if err != nil {
  2009  		t.Fatalf("seed = %d, err = %v", seed, err)
  2010  	}
  2011  	size := p.Size()
  2012  	if len(dAtA) != size {
  2013  		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
  2014  	}
  2015  	if size2 != size {
  2016  		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
  2017  	}
  2018  	size3 := github_com_gogo_protobuf_proto.Size(p)
  2019  	if size3 != size {
  2020  		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
  2021  	}
  2022  }
  2023  
  2024  func BenchmarkNotPackedSize(b *testing.B) {
  2025  	popr := math_rand.New(math_rand.NewSource(616))
  2026  	total := 0
  2027  	pops := make([]*NotPacked, 1000)
  2028  	for i := 0; i < 1000; i++ {
  2029  		pops[i] = NewPopulatedNotPacked(popr, false)
  2030  	}
  2031  	b.ResetTimer()
  2032  	for i := 0; i < b.N; i++ {
  2033  		total += pops[i%1000].Size()
  2034  	}
  2035  	b.SetBytes(int64(total / b.N))
  2036  }
  2037  
  2038  func TestMessageStringer(t *testing.T) {
  2039  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2040  	p := NewPopulatedMessage(popr, false)
  2041  	s1 := p.String()
  2042  	s2 := fmt.Sprintf("%v", p)
  2043  	if s1 != s2 {
  2044  		t.Fatalf("String want %v got %v", s1, s2)
  2045  	}
  2046  }
  2047  func TestNestedStringer(t *testing.T) {
  2048  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2049  	p := NewPopulatedNested(popr, false)
  2050  	s1 := p.String()
  2051  	s2 := fmt.Sprintf("%v", p)
  2052  	if s1 != s2 {
  2053  		t.Fatalf("String want %v got %v", s1, s2)
  2054  	}
  2055  }
  2056  func TestAllMapsStringer(t *testing.T) {
  2057  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2058  	p := NewPopulatedAllMaps(popr, false)
  2059  	s1 := p.String()
  2060  	s2 := fmt.Sprintf("%v", p)
  2061  	if s1 != s2 {
  2062  		t.Fatalf("String want %v got %v", s1, s2)
  2063  	}
  2064  }
  2065  func TestAllMapsOrderedStringer(t *testing.T) {
  2066  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2067  	p := NewPopulatedAllMapsOrdered(popr, false)
  2068  	s1 := p.String()
  2069  	s2 := fmt.Sprintf("%v", p)
  2070  	if s1 != s2 {
  2071  		t.Fatalf("String want %v got %v", s1, s2)
  2072  	}
  2073  }
  2074  func TestMessageWithMapStringer(t *testing.T) {
  2075  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2076  	p := NewPopulatedMessageWithMap(popr, false)
  2077  	s1 := p.String()
  2078  	s2 := fmt.Sprintf("%v", p)
  2079  	if s1 != s2 {
  2080  		t.Fatalf("String want %v got %v", s1, s2)
  2081  	}
  2082  }
  2083  func TestFloatingPointStringer(t *testing.T) {
  2084  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2085  	p := NewPopulatedFloatingPoint(popr, false)
  2086  	s1 := p.String()
  2087  	s2 := fmt.Sprintf("%v", p)
  2088  	if s1 != s2 {
  2089  		t.Fatalf("String want %v got %v", s1, s2)
  2090  	}
  2091  }
  2092  func TestUint128PairStringer(t *testing.T) {
  2093  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2094  	p := NewPopulatedUint128Pair(popr, false)
  2095  	s1 := p.String()
  2096  	s2 := fmt.Sprintf("%v", p)
  2097  	if s1 != s2 {
  2098  		t.Fatalf("String want %v got %v", s1, s2)
  2099  	}
  2100  }
  2101  func TestContainsNestedMapStringer(t *testing.T) {
  2102  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2103  	p := NewPopulatedContainsNestedMap(popr, false)
  2104  	s1 := p.String()
  2105  	s2 := fmt.Sprintf("%v", p)
  2106  	if s1 != s2 {
  2107  		t.Fatalf("String want %v got %v", s1, s2)
  2108  	}
  2109  }
  2110  func TestContainsNestedMap_NestedMapStringer(t *testing.T) {
  2111  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2112  	p := NewPopulatedContainsNestedMap_NestedMap(popr, false)
  2113  	s1 := p.String()
  2114  	s2 := fmt.Sprintf("%v", p)
  2115  	if s1 != s2 {
  2116  		t.Fatalf("String want %v got %v", s1, s2)
  2117  	}
  2118  }
  2119  func TestNotPackedStringer(t *testing.T) {
  2120  	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
  2121  	p := NewPopulatedNotPacked(popr, false)
  2122  	s1 := p.String()
  2123  	s2 := fmt.Sprintf("%v", p)
  2124  	if s1 != s2 {
  2125  		t.Fatalf("String want %v got %v", s1, s2)
  2126  	}
  2127  }
  2128  
  2129  //These tests are generated by github.com/gogo/protobuf/plugin/testgen
  2130  

View as plain text