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

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

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

View as plain text