From 100ba4e885062801d56799d78530b73b178a78f3 Mon Sep 17 00:00:00 2001 From: Walter Schulze Date: Tue, 7 Mar 2017 19:04:53 +0100 Subject: [PATCH] skip unsafe tests for bigendian architectures. (#272) * skip marshal and unmarshal tests on big endian architectures if message has generated unsafe methods * equal and compare tests now also check for bigendian architectures when the message uses the unsafe marshaler or unmarshaler * skip packed unsafe issue21 if cpu is not little endian --- extensions.md | 4 +- plugin/compare/comparetest.go | 11 + plugin/equal/equaltest.go | 13 + plugin/testgen/testgen.go | 19 + .../combos/unsafeboth/casttypepb_test.go | 25 + .../combos/unsafemarshaler/casttypepb_test.go | 25 + .../unsafeunmarshaler/casttypepb_test.go | 17 + .../combos/unsafeboth/castvaluepb_test.go | 25 + .../unsafemarshaler/castvaluepb_test.go | 25 + .../unsafeunmarshaler/castvaluepb_test.go | 17 + test/combos/unsafeboth/thetestpb_test.go | 1089 +++++++++++++++++ test/combos/unsafemarshaler/thetestpb_test.go | 1089 +++++++++++++++++ .../unsafeunmarshaler/thetestpb_test.go | 817 +++++++++++++ .../combos/unsafeboth/mapsproto2pb_test.go | 49 + .../unsafemarshaler/mapsproto2pb_test.go | 49 + .../unsafeunmarshaler/mapsproto2pb_test.go | 33 + test/oneof/combos/unsafeboth/onepb_test.go | 49 + .../combos/unsafemarshaler/onepb_test.go | 49 + .../combos/unsafeunmarshaler/onepb_test.go | 33 + test/oneof3/combos/unsafeboth/onepb_test.go | 25 + .../combos/unsafemarshaler/onepb_test.go | 25 + .../combos/unsafeunmarshaler/onepb_test.go | 17 + test/packed/packed_test.go | 13 +- .../combos/unsafeboth/theproto3pb_test.go | 121 ++ .../unsafemarshaler/theproto3pb_test.go | 121 ++ .../unsafeunmarshaler/theproto3pb_test.go | 81 ++ test/types/combos/unsafeboth/typespb_test.go | 121 ++ .../combos/unsafemarshaler/typespb_test.go | 121 ++ .../combos/unsafeunmarshaler/typespb_test.go | 85 ++ test/unmarshalmerge/unmarshalmergepb_test.go | 9 + 30 files changed, 4171 insertions(+), 6 deletions(-) diff --git a/extensions.md b/extensions.md index fb9a3ff46c..891359ac72 100644 --- a/extensions.md +++ b/extensions.md @@ -20,8 +20,8 @@ See [BenchComparison](https://github.com/gogo/protobuf/blob/master/bench.md) for sizerMessageboolif true, a Size method is generated for the specific messagefalse unmarshaler Message bool if true, an Unmarshal method is generated for the specific message false protosizerMessageboolif true, a ProtoSize method is generated for the specific messagefalse - unsafe_marshaler Message bool if true, a Marshal and MarshalTo method is generated for the specific message. The generated code uses the unsafe package. false -unsafe_unmarshaler Message bool if true, an Unmarshal method is generated for the specific message. The generated code uses the unsafe package. false + unsafe_marshaler Message bool if true, a Marshal and MarshalTo method is generated for the specific message. The generated code uses the unsafe package and is not compatible with big endian CPUs. false +unsafe_unmarshaler Message bool if true, an Unmarshal method is generated for the specific message. The generated code uses the unsafe package and is not compatible with big endian CPUs. false stable_marshaler Message bool if true, a Marshal and MarshalTo method is generated for the specific message, but unlike marshaler the output is guaranteed to be deterministic, at the sacrifice of some speed false typedecl (beta) Message bool if false, type declaration of the message is excluded from the generated output. Requires the marshaler and unmarshaler to be generated. true diff --git a/plugin/compare/comparetest.go b/plugin/compare/comparetest.go index 4db0d6acc5..4fbdbc633c 100644 --- a/plugin/compare/comparetest.go +++ b/plugin/compare/comparetest.go @@ -48,6 +48,7 @@ func (p *test) Generate(imports generator.PluginImports, file *generator.FileDes timePkg := imports.NewImport("time") testingPkg := imports.NewImport("testing") protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + unsafePkg := imports.NewImport("unsafe") if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { protoPkg = imports.NewImport("github.com/golang/protobuf/proto") } @@ -62,8 +63,18 @@ func (p *test) Generate(imports generator.PluginImports, file *generator.FileDes if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { used = true + hasUnsafe := gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) || + gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) p.P(`func Test`, ccTypeName, `Compare(t *`, testingPkg.Use(), `.T) {`) p.In() + if hasUnsafe { + p.P(`var bigendian uint32 = 0x01020304`) + p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`) + p.In() + p.P(`t.Skip("unsafe does not work on big endian architectures")`) + p.Out() + p.P(`}`) + } p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) p.P(`dAtA, err := `, protoPkg.Use(), `.Marshal(p)`) diff --git a/plugin/equal/equaltest.go b/plugin/equal/equaltest.go index 8a47a0c9be..1233647a56 100644 --- a/plugin/equal/equaltest.go +++ b/plugin/equal/equaltest.go @@ -48,6 +48,7 @@ func (p *test) Generate(imports generator.PluginImports, file *generator.FileDes timePkg := imports.NewImport("time") testingPkg := imports.NewImport("testing") protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + unsafePkg := imports.NewImport("unsafe") if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { protoPkg = imports.NewImport("github.com/golang/protobuf/proto") } @@ -62,8 +63,20 @@ func (p *test) Generate(imports generator.PluginImports, file *generator.FileDes if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { used = true + hasUnsafe := gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) || + gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) p.P(`func Test`, ccTypeName, `VerboseEqual(t *`, testingPkg.Use(), `.T) {`) p.In() + if hasUnsafe { + if hasUnsafe { + p.P(`var bigendian uint32 = 0x01020304`) + p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`) + p.In() + p.P(`t.Skip("unsafe does not work on big endian architectures")`) + p.Out() + p.P(`}`) + } + } p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) p.P(`dAtA, err := `, protoPkg.Use(), `.Marshal(p)`) diff --git a/plugin/testgen/testgen.go b/plugin/testgen/testgen.go index e0a9287e56..a9364f99ad 100644 --- a/plugin/testgen/testgen.go +++ b/plugin/testgen/testgen.go @@ -270,6 +270,7 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi testingPkg := imports.NewImport("testing") randPkg := imports.NewImport("math/rand") timePkg := imports.NewImport("time") + unsafePkg := imports.NewImport("unsafe") protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { protoPkg = imports.NewImport("github.com/golang/protobuf/proto") @@ -279,11 +280,21 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi if message.DescriptorProto.GetOptions().GetMapEntry() { continue } + hasUnsafe := gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) || + gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { used = true p.P(`func Test`, ccTypeName, `Proto(t *`, testingPkg.Use(), `.T) {`) p.In() + if hasUnsafe { + p.P(`var bigendian uint32 = 0x01020304`) + p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`) + p.In() + p.P(`t.Skip("unsafe does not work on big endian architectures")`) + p.Out() + p.P(`}`) + } p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) @@ -340,6 +351,14 @@ func (p *testProto) Generate(imports generator.PluginImports, file *generator.Fi if gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) || gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) { p.P(`func Test`, ccTypeName, `MarshalTo(t *`, testingPkg.Use(), `.T) {`) p.In() + if hasUnsafe { + p.P(`var bigendian uint32 = 0x01020304`) + p.P(`if *(*byte)(`, unsafePkg.Use(), `.Pointer(&bigendian)) == 1 {`) + p.In() + p.P(`t.Skip("unsafe does not work on big endian architectures")`) + p.Out() + p.P(`}`) + } p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) diff --git a/test/casttype/combos/unsafeboth/casttypepb_test.go b/test/casttype/combos/unsafeboth/casttypepb_test.go index e0aa1ab658..1518a9c481 100644 --- a/test/casttype/combos/unsafeboth/casttypepb_test.go +++ b/test/casttype/combos/unsafeboth/casttypepb_test.go @@ -17,6 +17,7 @@ package casttype import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -65,6 +70,10 @@ func TestCastawayProto(t *testing.T) { } func TestCastawayMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -133,6 +142,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -167,6 +180,10 @@ func TestWilsonProto(t *testing.T) { } func TestWilsonMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -348,6 +365,10 @@ func TestCasttypeDescription(t *testing.T) { CasttypeDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -363,6 +384,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/casttype/combos/unsafemarshaler/casttypepb_test.go b/test/casttype/combos/unsafemarshaler/casttypepb_test.go index fa1609f81a..240e96a894 100644 --- a/test/casttype/combos/unsafemarshaler/casttypepb_test.go +++ b/test/casttype/combos/unsafemarshaler/casttypepb_test.go @@ -17,6 +17,7 @@ package casttype import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -65,6 +70,10 @@ func TestCastawayProto(t *testing.T) { } func TestCastawayMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -133,6 +142,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -167,6 +180,10 @@ func TestWilsonProto(t *testing.T) { } func TestWilsonMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -348,6 +365,10 @@ func TestCasttypeDescription(t *testing.T) { CasttypeDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -363,6 +384,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go b/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go index e0a046ab93..82c06cb575 100644 --- a/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go +++ b/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go @@ -17,6 +17,7 @@ package casttype import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -105,6 +110,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -292,6 +301,10 @@ func TestCasttypeDescription(t *testing.T) { CasttypeDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -307,6 +320,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/castvalue/combos/unsafeboth/castvaluepb_test.go b/test/castvalue/combos/unsafeboth/castvaluepb_test.go index 06887a0410..371d619b1e 100644 --- a/test/castvalue/combos/unsafeboth/castvaluepb_test.go +++ b/test/castvalue/combos/unsafeboth/castvaluepb_test.go @@ -17,6 +17,7 @@ package castvalue import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -65,6 +70,10 @@ func TestCastawayProto(t *testing.T) { } func TestCastawayMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -133,6 +142,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -167,6 +180,10 @@ func TestWilsonProto(t *testing.T) { } func TestWilsonMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -348,6 +365,10 @@ func TestCastvalueDescription(t *testing.T) { CastvalueDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -363,6 +384,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/castvalue/combos/unsafemarshaler/castvaluepb_test.go b/test/castvalue/combos/unsafemarshaler/castvaluepb_test.go index e0a8bc5b78..dcbaa06759 100644 --- a/test/castvalue/combos/unsafemarshaler/castvaluepb_test.go +++ b/test/castvalue/combos/unsafemarshaler/castvaluepb_test.go @@ -17,6 +17,7 @@ package castvalue import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -65,6 +70,10 @@ func TestCastawayProto(t *testing.T) { } func TestCastawayMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -133,6 +142,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -167,6 +180,10 @@ func TestWilsonProto(t *testing.T) { } func TestWilsonMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -348,6 +365,10 @@ func TestCastvalueDescription(t *testing.T) { CastvalueDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -363,6 +384,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/castvalue/combos/unsafeunmarshaler/castvaluepb_test.go b/test/castvalue/combos/unsafeunmarshaler/castvaluepb_test.go index 12bda3af0a..6b7dbc19fd 100644 --- a/test/castvalue/combos/unsafeunmarshaler/castvaluepb_test.go +++ b/test/castvalue/combos/unsafeunmarshaler/castvaluepb_test.go @@ -17,6 +17,7 @@ package castvalue import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestCastawayProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) @@ -105,6 +110,10 @@ func BenchmarkCastawayProtoUnmarshal(b *testing.B) { } func TestWilsonProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedWilson(popr, false) @@ -292,6 +301,10 @@ func TestCastvalueDescription(t *testing.T) { CastvalueDescription() } func TestCastawayVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCastaway(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -307,6 +320,10 @@ func TestCastawayVerboseEqual(t *testing.T) { } } func TestWilsonVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/combos/unsafeboth/thetestpb_test.go b/test/combos/unsafeboth/thetestpb_test.go index 7b897ee64b..d2f7a8e893 100644 --- a/test/combos/unsafeboth/thetestpb_test.go +++ b/test/combos/unsafeboth/thetestpb_test.go @@ -79,6 +79,7 @@ package test import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -93,6 +94,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNative(popr, false) @@ -127,6 +132,10 @@ func TestNidOptNativeProto(t *testing.T) { } func TestNidOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNative(popr, false) @@ -195,6 +204,10 @@ func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNative(popr, false) @@ -229,6 +242,10 @@ func TestNinOptNativeProto(t *testing.T) { } func TestNinOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNative(popr, false) @@ -297,6 +314,10 @@ func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { } func TestNidRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNative(popr, false) @@ -331,6 +352,10 @@ func TestNidRepNativeProto(t *testing.T) { } func TestNidRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNative(popr, false) @@ -399,6 +424,10 @@ func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { } func TestNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNative(popr, false) @@ -433,6 +462,10 @@ func TestNinRepNativeProto(t *testing.T) { } func TestNinRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNative(popr, false) @@ -501,6 +534,10 @@ func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { } func TestNidRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepPackedNative(popr, false) @@ -535,6 +572,10 @@ func TestNidRepPackedNativeProto(t *testing.T) { } func TestNidRepPackedNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepPackedNative(popr, false) @@ -603,6 +644,10 @@ func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNinRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepPackedNative(popr, false) @@ -637,6 +682,10 @@ func TestNinRepPackedNativeProto(t *testing.T) { } func TestNinRepPackedNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepPackedNative(popr, false) @@ -705,6 +754,10 @@ func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNidOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptStruct(popr, false) @@ -739,6 +792,10 @@ func TestNidOptStructProto(t *testing.T) { } func TestNidOptStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptStruct(popr, false) @@ -807,6 +864,10 @@ func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { } func TestNinOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStruct(popr, false) @@ -841,6 +902,10 @@ func TestNinOptStructProto(t *testing.T) { } func TestNinOptStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStruct(popr, false) @@ -909,6 +974,10 @@ func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { } func TestNidRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepStruct(popr, false) @@ -943,6 +1012,10 @@ func TestNidRepStructProto(t *testing.T) { } func TestNidRepStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepStruct(popr, false) @@ -1011,6 +1084,10 @@ func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { } func TestNinRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepStruct(popr, false) @@ -1045,6 +1122,10 @@ func TestNinRepStructProto(t *testing.T) { } func TestNinRepStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepStruct(popr, false) @@ -1113,6 +1194,10 @@ func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { } func TestNidEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidEmbeddedStruct(popr, false) @@ -1147,6 +1232,10 @@ func TestNidEmbeddedStructProto(t *testing.T) { } func TestNidEmbeddedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidEmbeddedStruct(popr, false) @@ -1215,6 +1304,10 @@ func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStruct(popr, false) @@ -1249,6 +1342,10 @@ func TestNinEmbeddedStructProto(t *testing.T) { } func TestNinEmbeddedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStruct(popr, false) @@ -1317,6 +1414,10 @@ func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNidNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidNestedStruct(popr, false) @@ -1351,6 +1452,10 @@ func TestNidNestedStructProto(t *testing.T) { } func TestNidNestedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidNestedStruct(popr, false) @@ -1419,6 +1524,10 @@ func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { } func TestNinNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStruct(popr, false) @@ -1453,6 +1562,10 @@ func TestNinNestedStructProto(t *testing.T) { } func TestNinNestedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStruct(popr, false) @@ -1521,6 +1634,10 @@ func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { } func TestNidOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptCustom(popr, false) @@ -1555,6 +1672,10 @@ func TestNidOptCustomProto(t *testing.T) { } func TestNidOptCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptCustom(popr, false) @@ -1623,6 +1744,10 @@ func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { } func TestCustomDashProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomDash(popr, false) @@ -1657,6 +1782,10 @@ func TestCustomDashProto(t *testing.T) { } func TestCustomDashMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomDash(popr, false) @@ -1725,6 +1854,10 @@ func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { } func TestNinOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptCustom(popr, false) @@ -1759,6 +1892,10 @@ func TestNinOptCustomProto(t *testing.T) { } func TestNinOptCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptCustom(popr, false) @@ -1827,6 +1964,10 @@ func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { } func TestNidRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepCustom(popr, false) @@ -1861,6 +2002,10 @@ func TestNidRepCustomProto(t *testing.T) { } func TestNidRepCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepCustom(popr, false) @@ -1929,6 +2074,10 @@ func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { } func TestNinRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepCustom(popr, false) @@ -1963,6 +2112,10 @@ func TestNinRepCustomProto(t *testing.T) { } func TestNinRepCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepCustom(popr, false) @@ -2031,6 +2184,10 @@ func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { } func TestNinOptNativeUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeUnion(popr, false) @@ -2065,6 +2222,10 @@ func TestNinOptNativeUnionProto(t *testing.T) { } func TestNinOptNativeUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeUnion(popr, false) @@ -2133,6 +2294,10 @@ func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { } func TestNinOptStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStructUnion(popr, false) @@ -2167,6 +2332,10 @@ func TestNinOptStructUnionProto(t *testing.T) { } func TestNinOptStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStructUnion(popr, false) @@ -2235,6 +2404,10 @@ func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStructUnion(popr, false) @@ -2269,6 +2442,10 @@ func TestNinEmbeddedStructUnionProto(t *testing.T) { } func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStructUnion(popr, false) @@ -2337,6 +2514,10 @@ func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestNinNestedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStructUnion(popr, false) @@ -2371,6 +2552,10 @@ func TestNinNestedStructUnionProto(t *testing.T) { } func TestNinNestedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStructUnion(popr, false) @@ -2439,6 +2624,10 @@ func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { } func TestTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTree(popr, false) @@ -2473,6 +2662,10 @@ func TestTreeProto(t *testing.T) { } func TestTreeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTree(popr, false) @@ -2541,6 +2734,10 @@ func BenchmarkTreeProtoUnmarshal(b *testing.B) { } func TestOrBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOrBranch(popr, false) @@ -2575,6 +2772,10 @@ func TestOrBranchProto(t *testing.T) { } func TestOrBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOrBranch(popr, false) @@ -2643,6 +2844,10 @@ func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { } func TestAndBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndBranch(popr, false) @@ -2677,6 +2882,10 @@ func TestAndBranchProto(t *testing.T) { } func TestAndBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndBranch(popr, false) @@ -2745,6 +2954,10 @@ func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { } func TestLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedLeaf(popr, false) @@ -2779,6 +2992,10 @@ func TestLeafProto(t *testing.T) { } func TestLeafMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedLeaf(popr, false) @@ -2847,6 +3064,10 @@ func BenchmarkLeafProtoUnmarshal(b *testing.B) { } func TestDeepTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepTree(popr, false) @@ -2881,6 +3102,10 @@ func TestDeepTreeProto(t *testing.T) { } func TestDeepTreeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepTree(popr, false) @@ -2949,6 +3174,10 @@ func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { } func TestADeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedADeepBranch(popr, false) @@ -2983,6 +3212,10 @@ func TestADeepBranchProto(t *testing.T) { } func TestADeepBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedADeepBranch(popr, false) @@ -3051,6 +3284,10 @@ func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { } func TestAndDeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndDeepBranch(popr, false) @@ -3085,6 +3322,10 @@ func TestAndDeepBranchProto(t *testing.T) { } func TestAndDeepBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndDeepBranch(popr, false) @@ -3153,6 +3394,10 @@ func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { } func TestDeepLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepLeaf(popr, false) @@ -3187,6 +3432,10 @@ func TestDeepLeafProto(t *testing.T) { } func TestDeepLeafMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepLeaf(popr, false) @@ -3255,6 +3504,10 @@ func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { } func TestNilProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNil(popr, false) @@ -3289,6 +3542,10 @@ func TestNilProto(t *testing.T) { } func TestNilMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNil(popr, false) @@ -3357,6 +3614,10 @@ func BenchmarkNilProtoUnmarshal(b *testing.B) { } func TestNidOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptEnum(popr, false) @@ -3391,6 +3652,10 @@ func TestNidOptEnumProto(t *testing.T) { } func TestNidOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptEnum(popr, false) @@ -3459,6 +3724,10 @@ func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnum(popr, false) @@ -3493,6 +3762,10 @@ func TestNinOptEnumProto(t *testing.T) { } func TestNinOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnum(popr, false) @@ -3561,6 +3834,10 @@ func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { } func TestNidRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepEnum(popr, false) @@ -3595,6 +3872,10 @@ func TestNidRepEnumProto(t *testing.T) { } func TestNidRepEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepEnum(popr, false) @@ -3663,6 +3944,10 @@ func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { } func TestNinRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepEnum(popr, false) @@ -3697,6 +3982,10 @@ func TestNinRepEnumProto(t *testing.T) { } func TestNinRepEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepEnum(popr, false) @@ -3765,6 +4054,10 @@ func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnumDefault(popr, false) @@ -3799,6 +4092,10 @@ func TestNinOptEnumDefaultProto(t *testing.T) { } func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnumDefault(popr, false) @@ -3867,6 +4164,10 @@ func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnum(popr, false) @@ -3901,6 +4202,10 @@ func TestAnotherNinOptEnumProto(t *testing.T) { } func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnum(popr, false) @@ -3969,6 +4274,10 @@ func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) @@ -4003,6 +4312,10 @@ func TestAnotherNinOptEnumDefaultProto(t *testing.T) { } func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) @@ -4071,6 +4384,10 @@ func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestTimerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTimer(popr, false) @@ -4105,6 +4422,10 @@ func TestTimerProto(t *testing.T) { } func TestTimerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTimer(popr, false) @@ -4173,6 +4494,10 @@ func BenchmarkTimerProtoUnmarshal(b *testing.B) { } func TestMyExtendableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMyExtendable(popr, false) @@ -4207,6 +4532,10 @@ func TestMyExtendableProto(t *testing.T) { } func TestMyExtendableMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMyExtendable(popr, false) @@ -4275,6 +4604,10 @@ func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { } func TestOtherExtenableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOtherExtenable(popr, false) @@ -4309,6 +4642,10 @@ func TestOtherExtenableProto(t *testing.T) { } func TestOtherExtenableMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOtherExtenable(popr, false) @@ -4377,6 +4714,10 @@ func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { } func TestNestedDefinitionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition(popr, false) @@ -4411,6 +4752,10 @@ func TestNestedDefinitionProto(t *testing.T) { } func TestNestedDefinitionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition(popr, false) @@ -4479,6 +4824,10 @@ func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) @@ -4513,6 +4862,10 @@ func TestNestedDefinition_NestedMessageProto(t *testing.T) { } func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) @@ -4581,6 +4934,10 @@ func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) @@ -4615,6 +4972,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { } func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) @@ -4683,6 +5044,10 @@ func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *te } func TestNestedScopeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedScope(popr, false) @@ -4717,6 +5082,10 @@ func TestNestedScopeProto(t *testing.T) { } func TestNestedScopeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedScope(popr, false) @@ -4785,6 +5154,10 @@ func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeDefault(popr, false) @@ -4819,6 +5192,10 @@ func TestNinOptNativeDefaultProto(t *testing.T) { } func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeDefault(popr, false) @@ -4887,6 +5264,10 @@ func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { } func TestCustomContainerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomContainer(popr, false) @@ -4921,6 +5302,10 @@ func TestCustomContainerProto(t *testing.T) { } func TestCustomContainerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomContainer(popr, false) @@ -4989,6 +5374,10 @@ func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { } func TestCustomNameNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNidOptNative(popr, false) @@ -5023,6 +5412,10 @@ func TestCustomNameNidOptNativeProto(t *testing.T) { } func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNidOptNative(popr, false) @@ -5091,6 +5484,10 @@ func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinOptNative(popr, false) @@ -5125,6 +5522,10 @@ func TestCustomNameNinOptNativeProto(t *testing.T) { } func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinOptNative(popr, false) @@ -5193,6 +5594,10 @@ func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinRepNative(popr, false) @@ -5227,6 +5632,10 @@ func TestCustomNameNinRepNativeProto(t *testing.T) { } func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinRepNative(popr, false) @@ -5295,6 +5704,10 @@ func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinStruct(popr, false) @@ -5329,6 +5742,10 @@ func TestCustomNameNinStructProto(t *testing.T) { } func TestCustomNameNinStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinStruct(popr, false) @@ -5397,6 +5814,10 @@ func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { } func TestCustomNameCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameCustomType(popr, false) @@ -5431,6 +5852,10 @@ func TestCustomNameCustomTypeProto(t *testing.T) { } func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameCustomType(popr, false) @@ -5499,6 +5924,10 @@ func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) @@ -5533,6 +5962,10 @@ func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { } func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) @@ -5601,6 +6034,10 @@ func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestCustomNameEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameEnum(popr, false) @@ -5635,6 +6072,10 @@ func TestCustomNameEnumProto(t *testing.T) { } func TestCustomNameEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameEnum(popr, false) @@ -5703,6 +6144,10 @@ func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { } func TestNoExtensionsMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNoExtensionsMap(popr, false) @@ -5737,6 +6182,10 @@ func TestNoExtensionsMapProto(t *testing.T) { } func TestNoExtensionsMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNoExtensionsMap(popr, false) @@ -5805,6 +6254,10 @@ func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { } func TestUnrecognizedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognized(popr, false) @@ -5839,6 +6292,10 @@ func TestUnrecognizedProto(t *testing.T) { } func TestUnrecognizedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognized(popr, false) @@ -5907,6 +6364,10 @@ func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner(popr, false) @@ -5941,6 +6402,10 @@ func TestUnrecognizedWithInnerProto(t *testing.T) { } func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner(popr, false) @@ -6009,6 +6474,10 @@ func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) @@ -6043,6 +6512,10 @@ func TestUnrecognizedWithInner_InnerProto(t *testing.T) { } func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) @@ -6111,6 +6584,10 @@ func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed(popr, false) @@ -6145,6 +6622,10 @@ func TestUnrecognizedWithEmbedProto(t *testing.T) { } func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed(popr, false) @@ -6213,6 +6694,10 @@ func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) @@ -6247,6 +6732,10 @@ func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { } func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) @@ -6315,6 +6804,10 @@ func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { } func TestNodeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNode(popr, false) @@ -6349,6 +6842,10 @@ func TestNodeProto(t *testing.T) { } func TestNodeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNode(popr, false) @@ -6417,6 +6914,10 @@ func BenchmarkNodeProtoUnmarshal(b *testing.B) { } func TestNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNonByteCustomType(popr, false) @@ -6451,6 +6952,10 @@ func TestNonByteCustomTypeProto(t *testing.T) { } func TestNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNonByteCustomType(popr, false) @@ -6519,6 +7024,10 @@ func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNonByteCustomType(popr, false) @@ -6553,6 +7062,10 @@ func TestNidOptNonByteCustomTypeProto(t *testing.T) { } func TestNidOptNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNonByteCustomType(popr, false) @@ -6621,6 +7134,10 @@ func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNonByteCustomType(popr, false) @@ -6655,6 +7172,10 @@ func TestNinOptNonByteCustomTypeProto(t *testing.T) { } func TestNinOptNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNonByteCustomType(popr, false) @@ -6723,6 +7244,10 @@ func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNonByteCustomType(popr, false) @@ -6757,6 +7282,10 @@ func TestNidRepNonByteCustomTypeProto(t *testing.T) { } func TestNidRepNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNonByteCustomType(popr, false) @@ -6825,6 +7354,10 @@ func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNonByteCustomType(popr, false) @@ -6859,6 +7392,10 @@ func TestNinRepNonByteCustomTypeProto(t *testing.T) { } func TestNinRepNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNonByteCustomType(popr, false) @@ -6927,6 +7464,10 @@ func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestProtoTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoType(popr, false) @@ -6961,6 +7502,10 @@ func TestProtoTypeProto(t *testing.T) { } func TestProtoTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoType(popr, false) @@ -10769,6 +11314,10 @@ func TestProtoTypeProtoCompactText(t *testing.T) { } func TestNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10793,6 +11342,10 @@ func TestNidOptNativeCompare(t *testing.T) { } } func TestNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10817,6 +11370,10 @@ func TestNinOptNativeCompare(t *testing.T) { } } func TestNidRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10841,6 +11398,10 @@ func TestNidRepNativeCompare(t *testing.T) { } } func TestNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10865,6 +11426,10 @@ func TestNinRepNativeCompare(t *testing.T) { } } func TestNidRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10889,6 +11454,10 @@ func TestNidRepPackedNativeCompare(t *testing.T) { } } func TestNinRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10913,6 +11482,10 @@ func TestNinRepPackedNativeCompare(t *testing.T) { } } func TestNidOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10937,6 +11510,10 @@ func TestNidOptStructCompare(t *testing.T) { } } func TestNinOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10961,6 +11538,10 @@ func TestNinOptStructCompare(t *testing.T) { } } func TestNidRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10985,6 +11566,10 @@ func TestNidRepStructCompare(t *testing.T) { } } func TestNinRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11009,6 +11594,10 @@ func TestNinRepStructCompare(t *testing.T) { } } func TestNidEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11033,6 +11622,10 @@ func TestNidEmbeddedStructCompare(t *testing.T) { } } func TestNinEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11057,6 +11650,10 @@ func TestNinEmbeddedStructCompare(t *testing.T) { } } func TestNidNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11081,6 +11678,10 @@ func TestNidNestedStructCompare(t *testing.T) { } } func TestNinNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11105,6 +11706,10 @@ func TestNinNestedStructCompare(t *testing.T) { } } func TestNidOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11129,6 +11734,10 @@ func TestNidOptCustomCompare(t *testing.T) { } } func TestCustomDashCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11153,6 +11762,10 @@ func TestCustomDashCompare(t *testing.T) { } } func TestNinOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11177,6 +11790,10 @@ func TestNinOptCustomCompare(t *testing.T) { } } func TestNidRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11201,6 +11818,10 @@ func TestNidRepCustomCompare(t *testing.T) { } } func TestNinRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11225,6 +11846,10 @@ func TestNinRepCustomCompare(t *testing.T) { } } func TestNinOptNativeUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11249,6 +11874,10 @@ func TestNinOptNativeUnionCompare(t *testing.T) { } } func TestNinOptStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11273,6 +11902,10 @@ func TestNinOptStructUnionCompare(t *testing.T) { } } func TestNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11297,6 +11930,10 @@ func TestNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestNinNestedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11321,6 +11958,10 @@ func TestNinNestedStructUnionCompare(t *testing.T) { } } func TestTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11345,6 +11986,10 @@ func TestTreeCompare(t *testing.T) { } } func TestOrBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11369,6 +12014,10 @@ func TestOrBranchCompare(t *testing.T) { } } func TestAndBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11393,6 +12042,10 @@ func TestAndBranchCompare(t *testing.T) { } } func TestLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11417,6 +12070,10 @@ func TestLeafCompare(t *testing.T) { } } func TestDeepTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11441,6 +12098,10 @@ func TestDeepTreeCompare(t *testing.T) { } } func TestADeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11465,6 +12126,10 @@ func TestADeepBranchCompare(t *testing.T) { } } func TestAndDeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11489,6 +12154,10 @@ func TestAndDeepBranchCompare(t *testing.T) { } } func TestDeepLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11513,6 +12182,10 @@ func TestDeepLeafCompare(t *testing.T) { } } func TestNilCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11537,6 +12210,10 @@ func TestNilCompare(t *testing.T) { } } func TestNidOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11561,6 +12238,10 @@ func TestNidOptEnumCompare(t *testing.T) { } } func TestNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11585,6 +12266,10 @@ func TestNinOptEnumCompare(t *testing.T) { } } func TestNidRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11609,6 +12294,10 @@ func TestNidRepEnumCompare(t *testing.T) { } } func TestNinRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11633,6 +12322,10 @@ func TestNinRepEnumCompare(t *testing.T) { } } func TestNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11657,6 +12350,10 @@ func TestNinOptEnumDefaultCompare(t *testing.T) { } } func TestAnotherNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11681,6 +12378,10 @@ func TestAnotherNinOptEnumCompare(t *testing.T) { } } func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11705,6 +12406,10 @@ func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { } } func TestTimerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11729,6 +12434,10 @@ func TestTimerCompare(t *testing.T) { } } func TestMyExtendableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11753,6 +12462,10 @@ func TestMyExtendableCompare(t *testing.T) { } } func TestOtherExtenableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11777,6 +12490,10 @@ func TestOtherExtenableCompare(t *testing.T) { } } func TestNestedDefinitionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11801,6 +12518,10 @@ func TestNestedDefinitionCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessageCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11825,6 +12546,10 @@ func TestNestedDefinition_NestedMessageCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11849,6 +12574,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { } } func TestNestedScopeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11873,6 +12602,10 @@ func TestNestedScopeCompare(t *testing.T) { } } func TestNinOptNativeDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11897,6 +12630,10 @@ func TestNinOptNativeDefaultCompare(t *testing.T) { } } func TestCustomContainerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11921,6 +12658,10 @@ func TestCustomContainerCompare(t *testing.T) { } } func TestCustomNameNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11945,6 +12686,10 @@ func TestCustomNameNidOptNativeCompare(t *testing.T) { } } func TestCustomNameNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11969,6 +12714,10 @@ func TestCustomNameNinOptNativeCompare(t *testing.T) { } } func TestCustomNameNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11993,6 +12742,10 @@ func TestCustomNameNinRepNativeCompare(t *testing.T) { } } func TestCustomNameNinStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12017,6 +12770,10 @@ func TestCustomNameNinStructCompare(t *testing.T) { } } func TestCustomNameCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12041,6 +12798,10 @@ func TestCustomNameCustomTypeCompare(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12065,6 +12826,10 @@ func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestCustomNameEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12089,6 +12854,10 @@ func TestCustomNameEnumCompare(t *testing.T) { } } func TestNoExtensionsMapCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12113,6 +12882,10 @@ func TestNoExtensionsMapCompare(t *testing.T) { } } func TestUnrecognizedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12137,6 +12910,10 @@ func TestUnrecognizedCompare(t *testing.T) { } } func TestUnrecognizedWithInnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12161,6 +12938,10 @@ func TestUnrecognizedWithInnerCompare(t *testing.T) { } } func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12185,6 +12966,10 @@ func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { } } func TestUnrecognizedWithEmbedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12209,6 +12994,10 @@ func TestUnrecognizedWithEmbedCompare(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12233,6 +13022,10 @@ func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { } } func TestNodeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12257,6 +13050,10 @@ func TestNodeCompare(t *testing.T) { } } func TestNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12281,6 +13078,10 @@ func TestNonByteCustomTypeCompare(t *testing.T) { } } func TestNidOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12305,6 +13106,10 @@ func TestNidOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNinOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12329,6 +13134,10 @@ func TestNinOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNidRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12353,6 +13162,10 @@ func TestNidRepNonByteCustomTypeCompare(t *testing.T) { } } func TestNinRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12377,6 +13190,10 @@ func TestNinRepNonByteCustomTypeCompare(t *testing.T) { } } func TestProtoTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12404,6 +13221,10 @@ func TestThetestDescription(t *testing.T) { ThetestDescription() } func TestNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12419,6 +13240,10 @@ func TestNidOptNativeVerboseEqual(t *testing.T) { } } func TestNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12434,6 +13259,10 @@ func TestNinOptNativeVerboseEqual(t *testing.T) { } } func TestNidRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12449,6 +13278,10 @@ func TestNidRepNativeVerboseEqual(t *testing.T) { } } func TestNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12464,6 +13297,10 @@ func TestNinRepNativeVerboseEqual(t *testing.T) { } } func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12479,6 +13316,10 @@ func TestNidRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12494,6 +13335,10 @@ func TestNinRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNidOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12509,6 +13354,10 @@ func TestNidOptStructVerboseEqual(t *testing.T) { } } func TestNinOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12524,6 +13373,10 @@ func TestNinOptStructVerboseEqual(t *testing.T) { } } func TestNidRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12539,6 +13392,10 @@ func TestNidRepStructVerboseEqual(t *testing.T) { } } func TestNinRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12554,6 +13411,10 @@ func TestNinRepStructVerboseEqual(t *testing.T) { } } func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12569,6 +13430,10 @@ func TestNidEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12584,6 +13449,10 @@ func TestNinEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNidNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12599,6 +13468,10 @@ func TestNidNestedStructVerboseEqual(t *testing.T) { } } func TestNinNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12614,6 +13487,10 @@ func TestNinNestedStructVerboseEqual(t *testing.T) { } } func TestNidOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12629,6 +13506,10 @@ func TestNidOptCustomVerboseEqual(t *testing.T) { } } func TestCustomDashVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12644,6 +13525,10 @@ func TestCustomDashVerboseEqual(t *testing.T) { } } func TestNinOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12659,6 +13544,10 @@ func TestNinOptCustomVerboseEqual(t *testing.T) { } } func TestNidRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12674,6 +13563,10 @@ func TestNidRepCustomVerboseEqual(t *testing.T) { } } func TestNinRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12689,6 +13582,10 @@ func TestNinRepCustomVerboseEqual(t *testing.T) { } } func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12704,6 +13601,10 @@ func TestNinOptNativeUnionVerboseEqual(t *testing.T) { } } func TestNinOptStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12719,6 +13620,10 @@ func TestNinOptStructUnionVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12734,6 +13639,10 @@ func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12749,6 +13658,10 @@ func TestNinNestedStructUnionVerboseEqual(t *testing.T) { } } func TestTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12764,6 +13677,10 @@ func TestTreeVerboseEqual(t *testing.T) { } } func TestOrBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12779,6 +13696,10 @@ func TestOrBranchVerboseEqual(t *testing.T) { } } func TestAndBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12794,6 +13715,10 @@ func TestAndBranchVerboseEqual(t *testing.T) { } } func TestLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12809,6 +13734,10 @@ func TestLeafVerboseEqual(t *testing.T) { } } func TestDeepTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12824,6 +13753,10 @@ func TestDeepTreeVerboseEqual(t *testing.T) { } } func TestADeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12839,6 +13772,10 @@ func TestADeepBranchVerboseEqual(t *testing.T) { } } func TestAndDeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12854,6 +13791,10 @@ func TestAndDeepBranchVerboseEqual(t *testing.T) { } } func TestDeepLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12869,6 +13810,10 @@ func TestDeepLeafVerboseEqual(t *testing.T) { } } func TestNilVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12884,6 +13829,10 @@ func TestNilVerboseEqual(t *testing.T) { } } func TestNidOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12899,6 +13848,10 @@ func TestNidOptEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12914,6 +13867,10 @@ func TestNinOptEnumVerboseEqual(t *testing.T) { } } func TestNidRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12929,6 +13886,10 @@ func TestNidRepEnumVerboseEqual(t *testing.T) { } } func TestNinRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12944,6 +13905,10 @@ func TestNinRepEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12959,6 +13924,10 @@ func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12974,6 +13943,10 @@ func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12989,6 +13962,10 @@ func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestTimerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13004,6 +13981,10 @@ func TestTimerVerboseEqual(t *testing.T) { } } func TestMyExtendableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13019,6 +14000,10 @@ func TestMyExtendableVerboseEqual(t *testing.T) { } } func TestOtherExtenableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13034,6 +14019,10 @@ func TestOtherExtenableVerboseEqual(t *testing.T) { } } func TestNestedDefinitionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13049,6 +14038,10 @@ func TestNestedDefinitionVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13064,6 +14057,10 @@ func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13079,6 +14076,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T } } func TestNestedScopeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13094,6 +14095,10 @@ func TestNestedScopeVerboseEqual(t *testing.T) { } } func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13109,6 +14114,10 @@ func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { } } func TestCustomContainerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13124,6 +14133,10 @@ func TestCustomContainerVerboseEqual(t *testing.T) { } } func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13139,6 +14152,10 @@ func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13154,6 +14171,10 @@ func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13169,6 +14190,10 @@ func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13184,6 +14209,10 @@ func TestCustomNameNinStructVerboseEqual(t *testing.T) { } } func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13199,6 +14228,10 @@ func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13214,6 +14247,10 @@ func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestCustomNameEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13229,6 +14266,10 @@ func TestCustomNameEnumVerboseEqual(t *testing.T) { } } func TestNoExtensionsMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13244,6 +14285,10 @@ func TestNoExtensionsMapVerboseEqual(t *testing.T) { } } func TestUnrecognizedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13259,6 +14304,10 @@ func TestUnrecognizedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13274,6 +14323,10 @@ func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13289,6 +14342,10 @@ func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13304,6 +14361,10 @@ func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13319,6 +14380,10 @@ func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { } } func TestNodeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13334,6 +14399,10 @@ func TestNodeVerboseEqual(t *testing.T) { } } func TestNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13349,6 +14418,10 @@ func TestNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13364,6 +14437,10 @@ func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13379,6 +14456,10 @@ func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13394,6 +14475,10 @@ func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13409,6 +14494,10 @@ func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestProtoTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/combos/unsafemarshaler/thetestpb_test.go b/test/combos/unsafemarshaler/thetestpb_test.go index 6a98daa33d..8ddbe3809f 100644 --- a/test/combos/unsafemarshaler/thetestpb_test.go +++ b/test/combos/unsafemarshaler/thetestpb_test.go @@ -79,6 +79,7 @@ package test import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -93,6 +94,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNative(popr, false) @@ -127,6 +132,10 @@ func TestNidOptNativeProto(t *testing.T) { } func TestNidOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNative(popr, false) @@ -195,6 +204,10 @@ func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNative(popr, false) @@ -229,6 +242,10 @@ func TestNinOptNativeProto(t *testing.T) { } func TestNinOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNative(popr, false) @@ -297,6 +314,10 @@ func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { } func TestNidRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNative(popr, false) @@ -331,6 +352,10 @@ func TestNidRepNativeProto(t *testing.T) { } func TestNidRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNative(popr, false) @@ -399,6 +424,10 @@ func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { } func TestNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNative(popr, false) @@ -433,6 +462,10 @@ func TestNinRepNativeProto(t *testing.T) { } func TestNinRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNative(popr, false) @@ -501,6 +534,10 @@ func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { } func TestNidRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepPackedNative(popr, false) @@ -535,6 +572,10 @@ func TestNidRepPackedNativeProto(t *testing.T) { } func TestNidRepPackedNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepPackedNative(popr, false) @@ -603,6 +644,10 @@ func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNinRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepPackedNative(popr, false) @@ -637,6 +682,10 @@ func TestNinRepPackedNativeProto(t *testing.T) { } func TestNinRepPackedNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepPackedNative(popr, false) @@ -705,6 +754,10 @@ func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNidOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptStruct(popr, false) @@ -739,6 +792,10 @@ func TestNidOptStructProto(t *testing.T) { } func TestNidOptStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptStruct(popr, false) @@ -807,6 +864,10 @@ func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { } func TestNinOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStruct(popr, false) @@ -841,6 +902,10 @@ func TestNinOptStructProto(t *testing.T) { } func TestNinOptStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStruct(popr, false) @@ -909,6 +974,10 @@ func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { } func TestNidRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepStruct(popr, false) @@ -943,6 +1012,10 @@ func TestNidRepStructProto(t *testing.T) { } func TestNidRepStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepStruct(popr, false) @@ -1011,6 +1084,10 @@ func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { } func TestNinRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepStruct(popr, false) @@ -1045,6 +1122,10 @@ func TestNinRepStructProto(t *testing.T) { } func TestNinRepStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepStruct(popr, false) @@ -1113,6 +1194,10 @@ func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { } func TestNidEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidEmbeddedStruct(popr, false) @@ -1147,6 +1232,10 @@ func TestNidEmbeddedStructProto(t *testing.T) { } func TestNidEmbeddedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidEmbeddedStruct(popr, false) @@ -1215,6 +1304,10 @@ func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStruct(popr, false) @@ -1249,6 +1342,10 @@ func TestNinEmbeddedStructProto(t *testing.T) { } func TestNinEmbeddedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStruct(popr, false) @@ -1317,6 +1414,10 @@ func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNidNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidNestedStruct(popr, false) @@ -1351,6 +1452,10 @@ func TestNidNestedStructProto(t *testing.T) { } func TestNidNestedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidNestedStruct(popr, false) @@ -1419,6 +1524,10 @@ func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { } func TestNinNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStruct(popr, false) @@ -1453,6 +1562,10 @@ func TestNinNestedStructProto(t *testing.T) { } func TestNinNestedStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStruct(popr, false) @@ -1521,6 +1634,10 @@ func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { } func TestNidOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptCustom(popr, false) @@ -1555,6 +1672,10 @@ func TestNidOptCustomProto(t *testing.T) { } func TestNidOptCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptCustom(popr, false) @@ -1623,6 +1744,10 @@ func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { } func TestCustomDashProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomDash(popr, false) @@ -1657,6 +1782,10 @@ func TestCustomDashProto(t *testing.T) { } func TestCustomDashMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomDash(popr, false) @@ -1725,6 +1854,10 @@ func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { } func TestNinOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptCustom(popr, false) @@ -1759,6 +1892,10 @@ func TestNinOptCustomProto(t *testing.T) { } func TestNinOptCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptCustom(popr, false) @@ -1827,6 +1964,10 @@ func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { } func TestNidRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepCustom(popr, false) @@ -1861,6 +2002,10 @@ func TestNidRepCustomProto(t *testing.T) { } func TestNidRepCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepCustom(popr, false) @@ -1929,6 +2074,10 @@ func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { } func TestNinRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepCustom(popr, false) @@ -1963,6 +2112,10 @@ func TestNinRepCustomProto(t *testing.T) { } func TestNinRepCustomMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepCustom(popr, false) @@ -2031,6 +2184,10 @@ func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { } func TestNinOptNativeUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeUnion(popr, false) @@ -2065,6 +2222,10 @@ func TestNinOptNativeUnionProto(t *testing.T) { } func TestNinOptNativeUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeUnion(popr, false) @@ -2133,6 +2294,10 @@ func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { } func TestNinOptStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStructUnion(popr, false) @@ -2167,6 +2332,10 @@ func TestNinOptStructUnionProto(t *testing.T) { } func TestNinOptStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStructUnion(popr, false) @@ -2235,6 +2404,10 @@ func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStructUnion(popr, false) @@ -2269,6 +2442,10 @@ func TestNinEmbeddedStructUnionProto(t *testing.T) { } func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStructUnion(popr, false) @@ -2337,6 +2514,10 @@ func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestNinNestedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStructUnion(popr, false) @@ -2371,6 +2552,10 @@ func TestNinNestedStructUnionProto(t *testing.T) { } func TestNinNestedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStructUnion(popr, false) @@ -2439,6 +2624,10 @@ func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { } func TestTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTree(popr, false) @@ -2473,6 +2662,10 @@ func TestTreeProto(t *testing.T) { } func TestTreeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTree(popr, false) @@ -2541,6 +2734,10 @@ func BenchmarkTreeProtoUnmarshal(b *testing.B) { } func TestOrBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOrBranch(popr, false) @@ -2575,6 +2772,10 @@ func TestOrBranchProto(t *testing.T) { } func TestOrBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOrBranch(popr, false) @@ -2643,6 +2844,10 @@ func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { } func TestAndBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndBranch(popr, false) @@ -2677,6 +2882,10 @@ func TestAndBranchProto(t *testing.T) { } func TestAndBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndBranch(popr, false) @@ -2745,6 +2954,10 @@ func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { } func TestLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedLeaf(popr, false) @@ -2779,6 +2992,10 @@ func TestLeafProto(t *testing.T) { } func TestLeafMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedLeaf(popr, false) @@ -2847,6 +3064,10 @@ func BenchmarkLeafProtoUnmarshal(b *testing.B) { } func TestDeepTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepTree(popr, false) @@ -2881,6 +3102,10 @@ func TestDeepTreeProto(t *testing.T) { } func TestDeepTreeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepTree(popr, false) @@ -2949,6 +3174,10 @@ func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { } func TestADeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedADeepBranch(popr, false) @@ -2983,6 +3212,10 @@ func TestADeepBranchProto(t *testing.T) { } func TestADeepBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedADeepBranch(popr, false) @@ -3051,6 +3284,10 @@ func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { } func TestAndDeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndDeepBranch(popr, false) @@ -3085,6 +3322,10 @@ func TestAndDeepBranchProto(t *testing.T) { } func TestAndDeepBranchMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndDeepBranch(popr, false) @@ -3153,6 +3394,10 @@ func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { } func TestDeepLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepLeaf(popr, false) @@ -3187,6 +3432,10 @@ func TestDeepLeafProto(t *testing.T) { } func TestDeepLeafMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepLeaf(popr, false) @@ -3255,6 +3504,10 @@ func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { } func TestNilProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNil(popr, false) @@ -3289,6 +3542,10 @@ func TestNilProto(t *testing.T) { } func TestNilMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNil(popr, false) @@ -3357,6 +3614,10 @@ func BenchmarkNilProtoUnmarshal(b *testing.B) { } func TestNidOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptEnum(popr, false) @@ -3391,6 +3652,10 @@ func TestNidOptEnumProto(t *testing.T) { } func TestNidOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptEnum(popr, false) @@ -3459,6 +3724,10 @@ func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnum(popr, false) @@ -3493,6 +3762,10 @@ func TestNinOptEnumProto(t *testing.T) { } func TestNinOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnum(popr, false) @@ -3561,6 +3834,10 @@ func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { } func TestNidRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepEnum(popr, false) @@ -3595,6 +3872,10 @@ func TestNidRepEnumProto(t *testing.T) { } func TestNidRepEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepEnum(popr, false) @@ -3663,6 +3944,10 @@ func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { } func TestNinRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepEnum(popr, false) @@ -3697,6 +3982,10 @@ func TestNinRepEnumProto(t *testing.T) { } func TestNinRepEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepEnum(popr, false) @@ -3765,6 +4054,10 @@ func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnumDefault(popr, false) @@ -3799,6 +4092,10 @@ func TestNinOptEnumDefaultProto(t *testing.T) { } func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnumDefault(popr, false) @@ -3867,6 +4164,10 @@ func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnum(popr, false) @@ -3901,6 +4202,10 @@ func TestAnotherNinOptEnumProto(t *testing.T) { } func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnum(popr, false) @@ -3969,6 +4274,10 @@ func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) @@ -4003,6 +4312,10 @@ func TestAnotherNinOptEnumDefaultProto(t *testing.T) { } func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) @@ -4071,6 +4384,10 @@ func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestTimerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTimer(popr, false) @@ -4105,6 +4422,10 @@ func TestTimerProto(t *testing.T) { } func TestTimerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTimer(popr, false) @@ -4173,6 +4494,10 @@ func BenchmarkTimerProtoUnmarshal(b *testing.B) { } func TestMyExtendableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMyExtendable(popr, false) @@ -4207,6 +4532,10 @@ func TestMyExtendableProto(t *testing.T) { } func TestMyExtendableMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMyExtendable(popr, false) @@ -4275,6 +4604,10 @@ func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { } func TestOtherExtenableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOtherExtenable(popr, false) @@ -4309,6 +4642,10 @@ func TestOtherExtenableProto(t *testing.T) { } func TestOtherExtenableMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOtherExtenable(popr, false) @@ -4377,6 +4714,10 @@ func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { } func TestNestedDefinitionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition(popr, false) @@ -4411,6 +4752,10 @@ func TestNestedDefinitionProto(t *testing.T) { } func TestNestedDefinitionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition(popr, false) @@ -4479,6 +4824,10 @@ func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) @@ -4513,6 +4862,10 @@ func TestNestedDefinition_NestedMessageProto(t *testing.T) { } func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) @@ -4581,6 +4934,10 @@ func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) @@ -4615,6 +4972,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { } func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) @@ -4683,6 +5044,10 @@ func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *te } func TestNestedScopeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedScope(popr, false) @@ -4717,6 +5082,10 @@ func TestNestedScopeProto(t *testing.T) { } func TestNestedScopeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedScope(popr, false) @@ -4785,6 +5154,10 @@ func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeDefault(popr, false) @@ -4819,6 +5192,10 @@ func TestNinOptNativeDefaultProto(t *testing.T) { } func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeDefault(popr, false) @@ -4887,6 +5264,10 @@ func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { } func TestCustomContainerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomContainer(popr, false) @@ -4921,6 +5302,10 @@ func TestCustomContainerProto(t *testing.T) { } func TestCustomContainerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomContainer(popr, false) @@ -4989,6 +5374,10 @@ func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { } func TestCustomNameNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNidOptNative(popr, false) @@ -5023,6 +5412,10 @@ func TestCustomNameNidOptNativeProto(t *testing.T) { } func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNidOptNative(popr, false) @@ -5091,6 +5484,10 @@ func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinOptNative(popr, false) @@ -5125,6 +5522,10 @@ func TestCustomNameNinOptNativeProto(t *testing.T) { } func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinOptNative(popr, false) @@ -5193,6 +5594,10 @@ func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinRepNative(popr, false) @@ -5227,6 +5632,10 @@ func TestCustomNameNinRepNativeProto(t *testing.T) { } func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinRepNative(popr, false) @@ -5295,6 +5704,10 @@ func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinStruct(popr, false) @@ -5329,6 +5742,10 @@ func TestCustomNameNinStructProto(t *testing.T) { } func TestCustomNameNinStructMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinStruct(popr, false) @@ -5397,6 +5814,10 @@ func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { } func TestCustomNameCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameCustomType(popr, false) @@ -5431,6 +5852,10 @@ func TestCustomNameCustomTypeProto(t *testing.T) { } func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameCustomType(popr, false) @@ -5499,6 +5924,10 @@ func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) @@ -5533,6 +5962,10 @@ func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { } func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) @@ -5601,6 +6034,10 @@ func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestCustomNameEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameEnum(popr, false) @@ -5635,6 +6072,10 @@ func TestCustomNameEnumProto(t *testing.T) { } func TestCustomNameEnumMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameEnum(popr, false) @@ -5703,6 +6144,10 @@ func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { } func TestNoExtensionsMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNoExtensionsMap(popr, false) @@ -5737,6 +6182,10 @@ func TestNoExtensionsMapProto(t *testing.T) { } func TestNoExtensionsMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNoExtensionsMap(popr, false) @@ -5805,6 +6254,10 @@ func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { } func TestUnrecognizedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognized(popr, false) @@ -5839,6 +6292,10 @@ func TestUnrecognizedProto(t *testing.T) { } func TestUnrecognizedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognized(popr, false) @@ -5907,6 +6364,10 @@ func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner(popr, false) @@ -5941,6 +6402,10 @@ func TestUnrecognizedWithInnerProto(t *testing.T) { } func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner(popr, false) @@ -6009,6 +6474,10 @@ func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) @@ -6043,6 +6512,10 @@ func TestUnrecognizedWithInner_InnerProto(t *testing.T) { } func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) @@ -6111,6 +6584,10 @@ func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed(popr, false) @@ -6145,6 +6622,10 @@ func TestUnrecognizedWithEmbedProto(t *testing.T) { } func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed(popr, false) @@ -6213,6 +6694,10 @@ func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) @@ -6247,6 +6732,10 @@ func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { } func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) @@ -6315,6 +6804,10 @@ func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { } func TestNodeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNode(popr, false) @@ -6349,6 +6842,10 @@ func TestNodeProto(t *testing.T) { } func TestNodeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNode(popr, false) @@ -6417,6 +6914,10 @@ func BenchmarkNodeProtoUnmarshal(b *testing.B) { } func TestNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNonByteCustomType(popr, false) @@ -6451,6 +6952,10 @@ func TestNonByteCustomTypeProto(t *testing.T) { } func TestNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNonByteCustomType(popr, false) @@ -6519,6 +7024,10 @@ func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNonByteCustomType(popr, false) @@ -6553,6 +7062,10 @@ func TestNidOptNonByteCustomTypeProto(t *testing.T) { } func TestNidOptNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNonByteCustomType(popr, false) @@ -6621,6 +7134,10 @@ func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNonByteCustomType(popr, false) @@ -6655,6 +7172,10 @@ func TestNinOptNonByteCustomTypeProto(t *testing.T) { } func TestNinOptNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNonByteCustomType(popr, false) @@ -6723,6 +7244,10 @@ func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNonByteCustomType(popr, false) @@ -6757,6 +7282,10 @@ func TestNidRepNonByteCustomTypeProto(t *testing.T) { } func TestNidRepNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNonByteCustomType(popr, false) @@ -6825,6 +7354,10 @@ func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNonByteCustomType(popr, false) @@ -6859,6 +7392,10 @@ func TestNinRepNonByteCustomTypeProto(t *testing.T) { } func TestNinRepNonByteCustomTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNonByteCustomType(popr, false) @@ -6927,6 +7464,10 @@ func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestProtoTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoType(popr, false) @@ -6961,6 +7502,10 @@ func TestProtoTypeProto(t *testing.T) { } func TestProtoTypeMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoType(popr, false) @@ -10769,6 +11314,10 @@ func TestProtoTypeProtoCompactText(t *testing.T) { } func TestNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10793,6 +11342,10 @@ func TestNidOptNativeCompare(t *testing.T) { } } func TestNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10817,6 +11370,10 @@ func TestNinOptNativeCompare(t *testing.T) { } } func TestNidRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10841,6 +11398,10 @@ func TestNidRepNativeCompare(t *testing.T) { } } func TestNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10865,6 +11426,10 @@ func TestNinRepNativeCompare(t *testing.T) { } } func TestNidRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10889,6 +11454,10 @@ func TestNidRepPackedNativeCompare(t *testing.T) { } } func TestNinRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10913,6 +11482,10 @@ func TestNinRepPackedNativeCompare(t *testing.T) { } } func TestNidOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10937,6 +11510,10 @@ func TestNidOptStructCompare(t *testing.T) { } } func TestNinOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10961,6 +11538,10 @@ func TestNinOptStructCompare(t *testing.T) { } } func TestNidRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10985,6 +11566,10 @@ func TestNidRepStructCompare(t *testing.T) { } } func TestNinRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11009,6 +11594,10 @@ func TestNinRepStructCompare(t *testing.T) { } } func TestNidEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11033,6 +11622,10 @@ func TestNidEmbeddedStructCompare(t *testing.T) { } } func TestNinEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11057,6 +11650,10 @@ func TestNinEmbeddedStructCompare(t *testing.T) { } } func TestNidNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11081,6 +11678,10 @@ func TestNidNestedStructCompare(t *testing.T) { } } func TestNinNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11105,6 +11706,10 @@ func TestNinNestedStructCompare(t *testing.T) { } } func TestNidOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11129,6 +11734,10 @@ func TestNidOptCustomCompare(t *testing.T) { } } func TestCustomDashCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11153,6 +11762,10 @@ func TestCustomDashCompare(t *testing.T) { } } func TestNinOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11177,6 +11790,10 @@ func TestNinOptCustomCompare(t *testing.T) { } } func TestNidRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11201,6 +11818,10 @@ func TestNidRepCustomCompare(t *testing.T) { } } func TestNinRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11225,6 +11846,10 @@ func TestNinRepCustomCompare(t *testing.T) { } } func TestNinOptNativeUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11249,6 +11874,10 @@ func TestNinOptNativeUnionCompare(t *testing.T) { } } func TestNinOptStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11273,6 +11902,10 @@ func TestNinOptStructUnionCompare(t *testing.T) { } } func TestNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11297,6 +11930,10 @@ func TestNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestNinNestedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11321,6 +11958,10 @@ func TestNinNestedStructUnionCompare(t *testing.T) { } } func TestTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11345,6 +11986,10 @@ func TestTreeCompare(t *testing.T) { } } func TestOrBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11369,6 +12014,10 @@ func TestOrBranchCompare(t *testing.T) { } } func TestAndBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11393,6 +12042,10 @@ func TestAndBranchCompare(t *testing.T) { } } func TestLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11417,6 +12070,10 @@ func TestLeafCompare(t *testing.T) { } } func TestDeepTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11441,6 +12098,10 @@ func TestDeepTreeCompare(t *testing.T) { } } func TestADeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11465,6 +12126,10 @@ func TestADeepBranchCompare(t *testing.T) { } } func TestAndDeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11489,6 +12154,10 @@ func TestAndDeepBranchCompare(t *testing.T) { } } func TestDeepLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11513,6 +12182,10 @@ func TestDeepLeafCompare(t *testing.T) { } } func TestNilCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11537,6 +12210,10 @@ func TestNilCompare(t *testing.T) { } } func TestNidOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11561,6 +12238,10 @@ func TestNidOptEnumCompare(t *testing.T) { } } func TestNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11585,6 +12266,10 @@ func TestNinOptEnumCompare(t *testing.T) { } } func TestNidRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11609,6 +12294,10 @@ func TestNidRepEnumCompare(t *testing.T) { } } func TestNinRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11633,6 +12322,10 @@ func TestNinRepEnumCompare(t *testing.T) { } } func TestNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11657,6 +12350,10 @@ func TestNinOptEnumDefaultCompare(t *testing.T) { } } func TestAnotherNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11681,6 +12378,10 @@ func TestAnotherNinOptEnumCompare(t *testing.T) { } } func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11705,6 +12406,10 @@ func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { } } func TestTimerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11729,6 +12434,10 @@ func TestTimerCompare(t *testing.T) { } } func TestMyExtendableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11753,6 +12462,10 @@ func TestMyExtendableCompare(t *testing.T) { } } func TestOtherExtenableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11777,6 +12490,10 @@ func TestOtherExtenableCompare(t *testing.T) { } } func TestNestedDefinitionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11801,6 +12518,10 @@ func TestNestedDefinitionCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessageCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11825,6 +12546,10 @@ func TestNestedDefinition_NestedMessageCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11849,6 +12574,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { } } func TestNestedScopeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11873,6 +12602,10 @@ func TestNestedScopeCompare(t *testing.T) { } } func TestNinOptNativeDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11897,6 +12630,10 @@ func TestNinOptNativeDefaultCompare(t *testing.T) { } } func TestCustomContainerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11921,6 +12658,10 @@ func TestCustomContainerCompare(t *testing.T) { } } func TestCustomNameNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11945,6 +12686,10 @@ func TestCustomNameNidOptNativeCompare(t *testing.T) { } } func TestCustomNameNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11969,6 +12714,10 @@ func TestCustomNameNinOptNativeCompare(t *testing.T) { } } func TestCustomNameNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11993,6 +12742,10 @@ func TestCustomNameNinRepNativeCompare(t *testing.T) { } } func TestCustomNameNinStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12017,6 +12770,10 @@ func TestCustomNameNinStructCompare(t *testing.T) { } } func TestCustomNameCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12041,6 +12798,10 @@ func TestCustomNameCustomTypeCompare(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12065,6 +12826,10 @@ func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestCustomNameEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12089,6 +12854,10 @@ func TestCustomNameEnumCompare(t *testing.T) { } } func TestNoExtensionsMapCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12113,6 +12882,10 @@ func TestNoExtensionsMapCompare(t *testing.T) { } } func TestUnrecognizedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12137,6 +12910,10 @@ func TestUnrecognizedCompare(t *testing.T) { } } func TestUnrecognizedWithInnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12161,6 +12938,10 @@ func TestUnrecognizedWithInnerCompare(t *testing.T) { } } func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12185,6 +12966,10 @@ func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { } } func TestUnrecognizedWithEmbedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12209,6 +12994,10 @@ func TestUnrecognizedWithEmbedCompare(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12233,6 +13022,10 @@ func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { } } func TestNodeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12257,6 +13050,10 @@ func TestNodeCompare(t *testing.T) { } } func TestNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12281,6 +13078,10 @@ func TestNonByteCustomTypeCompare(t *testing.T) { } } func TestNidOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12305,6 +13106,10 @@ func TestNidOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNinOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12329,6 +13134,10 @@ func TestNinOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNidRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12353,6 +13162,10 @@ func TestNidRepNonByteCustomTypeCompare(t *testing.T) { } } func TestNinRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12377,6 +13190,10 @@ func TestNinRepNonByteCustomTypeCompare(t *testing.T) { } } func TestProtoTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12404,6 +13221,10 @@ func TestThetestDescription(t *testing.T) { ThetestDescription() } func TestNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12419,6 +13240,10 @@ func TestNidOptNativeVerboseEqual(t *testing.T) { } } func TestNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12434,6 +13259,10 @@ func TestNinOptNativeVerboseEqual(t *testing.T) { } } func TestNidRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12449,6 +13278,10 @@ func TestNidRepNativeVerboseEqual(t *testing.T) { } } func TestNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12464,6 +13297,10 @@ func TestNinRepNativeVerboseEqual(t *testing.T) { } } func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12479,6 +13316,10 @@ func TestNidRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12494,6 +13335,10 @@ func TestNinRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNidOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12509,6 +13354,10 @@ func TestNidOptStructVerboseEqual(t *testing.T) { } } func TestNinOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12524,6 +13373,10 @@ func TestNinOptStructVerboseEqual(t *testing.T) { } } func TestNidRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12539,6 +13392,10 @@ func TestNidRepStructVerboseEqual(t *testing.T) { } } func TestNinRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12554,6 +13411,10 @@ func TestNinRepStructVerboseEqual(t *testing.T) { } } func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12569,6 +13430,10 @@ func TestNidEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12584,6 +13449,10 @@ func TestNinEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNidNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12599,6 +13468,10 @@ func TestNidNestedStructVerboseEqual(t *testing.T) { } } func TestNinNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12614,6 +13487,10 @@ func TestNinNestedStructVerboseEqual(t *testing.T) { } } func TestNidOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12629,6 +13506,10 @@ func TestNidOptCustomVerboseEqual(t *testing.T) { } } func TestCustomDashVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12644,6 +13525,10 @@ func TestCustomDashVerboseEqual(t *testing.T) { } } func TestNinOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12659,6 +13544,10 @@ func TestNinOptCustomVerboseEqual(t *testing.T) { } } func TestNidRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12674,6 +13563,10 @@ func TestNidRepCustomVerboseEqual(t *testing.T) { } } func TestNinRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12689,6 +13582,10 @@ func TestNinRepCustomVerboseEqual(t *testing.T) { } } func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12704,6 +13601,10 @@ func TestNinOptNativeUnionVerboseEqual(t *testing.T) { } } func TestNinOptStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12719,6 +13620,10 @@ func TestNinOptStructUnionVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12734,6 +13639,10 @@ func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12749,6 +13658,10 @@ func TestNinNestedStructUnionVerboseEqual(t *testing.T) { } } func TestTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12764,6 +13677,10 @@ func TestTreeVerboseEqual(t *testing.T) { } } func TestOrBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12779,6 +13696,10 @@ func TestOrBranchVerboseEqual(t *testing.T) { } } func TestAndBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12794,6 +13715,10 @@ func TestAndBranchVerboseEqual(t *testing.T) { } } func TestLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12809,6 +13734,10 @@ func TestLeafVerboseEqual(t *testing.T) { } } func TestDeepTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12824,6 +13753,10 @@ func TestDeepTreeVerboseEqual(t *testing.T) { } } func TestADeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12839,6 +13772,10 @@ func TestADeepBranchVerboseEqual(t *testing.T) { } } func TestAndDeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12854,6 +13791,10 @@ func TestAndDeepBranchVerboseEqual(t *testing.T) { } } func TestDeepLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12869,6 +13810,10 @@ func TestDeepLeafVerboseEqual(t *testing.T) { } } func TestNilVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12884,6 +13829,10 @@ func TestNilVerboseEqual(t *testing.T) { } } func TestNidOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12899,6 +13848,10 @@ func TestNidOptEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12914,6 +13867,10 @@ func TestNinOptEnumVerboseEqual(t *testing.T) { } } func TestNidRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12929,6 +13886,10 @@ func TestNidRepEnumVerboseEqual(t *testing.T) { } } func TestNinRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12944,6 +13905,10 @@ func TestNinRepEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12959,6 +13924,10 @@ func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12974,6 +13943,10 @@ func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -12989,6 +13962,10 @@ func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestTimerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13004,6 +13981,10 @@ func TestTimerVerboseEqual(t *testing.T) { } } func TestMyExtendableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13019,6 +14000,10 @@ func TestMyExtendableVerboseEqual(t *testing.T) { } } func TestOtherExtenableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13034,6 +14019,10 @@ func TestOtherExtenableVerboseEqual(t *testing.T) { } } func TestNestedDefinitionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13049,6 +14038,10 @@ func TestNestedDefinitionVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13064,6 +14057,10 @@ func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13079,6 +14076,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T } } func TestNestedScopeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13094,6 +14095,10 @@ func TestNestedScopeVerboseEqual(t *testing.T) { } } func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13109,6 +14114,10 @@ func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { } } func TestCustomContainerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13124,6 +14133,10 @@ func TestCustomContainerVerboseEqual(t *testing.T) { } } func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13139,6 +14152,10 @@ func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13154,6 +14171,10 @@ func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13169,6 +14190,10 @@ func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13184,6 +14209,10 @@ func TestCustomNameNinStructVerboseEqual(t *testing.T) { } } func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13199,6 +14228,10 @@ func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13214,6 +14247,10 @@ func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestCustomNameEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13229,6 +14266,10 @@ func TestCustomNameEnumVerboseEqual(t *testing.T) { } } func TestNoExtensionsMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13244,6 +14285,10 @@ func TestNoExtensionsMapVerboseEqual(t *testing.T) { } } func TestUnrecognizedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13259,6 +14304,10 @@ func TestUnrecognizedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13274,6 +14323,10 @@ func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13289,6 +14342,10 @@ func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13304,6 +14361,10 @@ func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13319,6 +14380,10 @@ func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { } } func TestNodeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13334,6 +14399,10 @@ func TestNodeVerboseEqual(t *testing.T) { } } func TestNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13349,6 +14418,10 @@ func TestNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13364,6 +14437,10 @@ func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13379,6 +14456,10 @@ func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13394,6 +14475,10 @@ func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -13409,6 +14494,10 @@ func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestProtoTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/combos/unsafeunmarshaler/thetestpb_test.go b/test/combos/unsafeunmarshaler/thetestpb_test.go index def87ed9ef..453ee602c7 100644 --- a/test/combos/unsafeunmarshaler/thetestpb_test.go +++ b/test/combos/unsafeunmarshaler/thetestpb_test.go @@ -79,6 +79,7 @@ package test import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -93,6 +94,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNative(popr, false) @@ -167,6 +172,10 @@ func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNative(popr, false) @@ -241,6 +250,10 @@ func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { } func TestNidRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNative(popr, false) @@ -315,6 +328,10 @@ func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { } func TestNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNative(popr, false) @@ -389,6 +406,10 @@ func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { } func TestNidRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepPackedNative(popr, false) @@ -463,6 +484,10 @@ func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNinRepPackedNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepPackedNative(popr, false) @@ -537,6 +562,10 @@ func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { } func TestNidOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptStruct(popr, false) @@ -611,6 +640,10 @@ func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { } func TestNinOptStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStruct(popr, false) @@ -685,6 +718,10 @@ func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { } func TestNidRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepStruct(popr, false) @@ -759,6 +796,10 @@ func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { } func TestNinRepStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepStruct(popr, false) @@ -833,6 +874,10 @@ func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { } func TestNidEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidEmbeddedStruct(popr, false) @@ -907,6 +952,10 @@ func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStruct(popr, false) @@ -981,6 +1030,10 @@ func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { } func TestNidNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidNestedStruct(popr, false) @@ -1055,6 +1108,10 @@ func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { } func TestNinNestedStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStruct(popr, false) @@ -1129,6 +1186,10 @@ func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { } func TestNidOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptCustom(popr, false) @@ -1203,6 +1264,10 @@ func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { } func TestCustomDashProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomDash(popr, false) @@ -1277,6 +1342,10 @@ func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { } func TestNinOptCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptCustom(popr, false) @@ -1351,6 +1420,10 @@ func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { } func TestNidRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepCustom(popr, false) @@ -1425,6 +1498,10 @@ func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { } func TestNinRepCustomProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepCustom(popr, false) @@ -1499,6 +1576,10 @@ func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { } func TestNinOptNativeUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeUnion(popr, false) @@ -1573,6 +1654,10 @@ func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { } func TestNinOptStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptStructUnion(popr, false) @@ -1647,6 +1732,10 @@ func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { } func TestNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinEmbeddedStructUnion(popr, false) @@ -1721,6 +1810,10 @@ func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestNinNestedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinNestedStructUnion(popr, false) @@ -1795,6 +1888,10 @@ func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { } func TestTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTree(popr, false) @@ -1869,6 +1966,10 @@ func BenchmarkTreeProtoUnmarshal(b *testing.B) { } func TestOrBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOrBranch(popr, false) @@ -1943,6 +2044,10 @@ func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { } func TestAndBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndBranch(popr, false) @@ -2017,6 +2122,10 @@ func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { } func TestLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedLeaf(popr, false) @@ -2091,6 +2200,10 @@ func BenchmarkLeafProtoUnmarshal(b *testing.B) { } func TestDeepTreeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepTree(popr, false) @@ -2165,6 +2278,10 @@ func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { } func TestADeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedADeepBranch(popr, false) @@ -2239,6 +2356,10 @@ func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { } func TestAndDeepBranchProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAndDeepBranch(popr, false) @@ -2313,6 +2434,10 @@ func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { } func TestDeepLeafProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedDeepLeaf(popr, false) @@ -2387,6 +2512,10 @@ func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { } func TestNilProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNil(popr, false) @@ -2461,6 +2590,10 @@ func BenchmarkNilProtoUnmarshal(b *testing.B) { } func TestNidOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptEnum(popr, false) @@ -2535,6 +2668,10 @@ func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnum(popr, false) @@ -2609,6 +2746,10 @@ func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { } func TestNidRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepEnum(popr, false) @@ -2683,6 +2824,10 @@ func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { } func TestNinRepEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepEnum(popr, false) @@ -2757,6 +2902,10 @@ func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { } func TestNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptEnumDefault(popr, false) @@ -2831,6 +2980,10 @@ func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnum(popr, false) @@ -2905,6 +3058,10 @@ func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { } func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) @@ -2979,6 +3136,10 @@ func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { } func TestTimerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTimer(popr, false) @@ -3053,6 +3214,10 @@ func BenchmarkTimerProtoUnmarshal(b *testing.B) { } func TestMyExtendableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMyExtendable(popr, false) @@ -3127,6 +3292,10 @@ func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { } func TestOtherExtenableProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOtherExtenable(popr, false) @@ -3201,6 +3370,10 @@ func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { } func TestNestedDefinitionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition(popr, false) @@ -3275,6 +3448,10 @@ func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) @@ -3349,6 +3526,10 @@ func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { } func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) @@ -3423,6 +3604,10 @@ func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *te } func TestNestedScopeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNestedScope(popr, false) @@ -3497,6 +3682,10 @@ func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { } func TestNinOptNativeDefaultProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNativeDefault(popr, false) @@ -3571,6 +3760,10 @@ func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { } func TestCustomContainerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomContainer(popr, false) @@ -3645,6 +3838,10 @@ func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { } func TestCustomNameNidOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNidOptNative(popr, false) @@ -3719,6 +3916,10 @@ func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinOptNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinOptNative(popr, false) @@ -3793,6 +3994,10 @@ func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinRepNativeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinRepNative(popr, false) @@ -3867,6 +4072,10 @@ func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinStructProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinStruct(popr, false) @@ -3941,6 +4150,10 @@ func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { } func TestCustomNameCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameCustomType(popr, false) @@ -4015,6 +4228,10 @@ func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { } func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) @@ -4089,6 +4306,10 @@ func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { } func TestCustomNameEnumProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomNameEnum(popr, false) @@ -4163,6 +4384,10 @@ func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { } func TestNoExtensionsMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNoExtensionsMap(popr, false) @@ -4237,6 +4462,10 @@ func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { } func TestUnrecognizedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognized(popr, false) @@ -4311,6 +4540,10 @@ func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner(popr, false) @@ -4385,6 +4618,10 @@ func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) @@ -4459,6 +4696,10 @@ func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed(popr, false) @@ -4533,6 +4774,10 @@ func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { } func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) @@ -4607,6 +4852,10 @@ func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { } func TestNodeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNode(popr, false) @@ -4681,6 +4930,10 @@ func BenchmarkNodeProtoUnmarshal(b *testing.B) { } func TestNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNonByteCustomType(popr, false) @@ -4755,6 +5008,10 @@ func BenchmarkNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidOptNonByteCustomType(popr, false) @@ -4829,6 +5086,10 @@ func BenchmarkNidOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinOptNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinOptNonByteCustomType(popr, false) @@ -4903,6 +5164,10 @@ func BenchmarkNinOptNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNidRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNidRepNonByteCustomType(popr, false) @@ -4977,6 +5242,10 @@ func BenchmarkNidRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestNinRepNonByteCustomTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNinRepNonByteCustomType(popr, false) @@ -5051,6 +5320,10 @@ func BenchmarkNinRepNonByteCustomTypeProtoUnmarshal(b *testing.B) { } func TestProtoTypeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoType(popr, false) @@ -8865,6 +9138,10 @@ func TestProtoTypeProtoCompactText(t *testing.T) { } func TestNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -8889,6 +9166,10 @@ func TestNidOptNativeCompare(t *testing.T) { } } func TestNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -8913,6 +9194,10 @@ func TestNinOptNativeCompare(t *testing.T) { } } func TestNidRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -8937,6 +9222,10 @@ func TestNidRepNativeCompare(t *testing.T) { } } func TestNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -8961,6 +9250,10 @@ func TestNinRepNativeCompare(t *testing.T) { } } func TestNidRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -8985,6 +9278,10 @@ func TestNidRepPackedNativeCompare(t *testing.T) { } } func TestNinRepPackedNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9009,6 +9306,10 @@ func TestNinRepPackedNativeCompare(t *testing.T) { } } func TestNidOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9033,6 +9334,10 @@ func TestNidOptStructCompare(t *testing.T) { } } func TestNinOptStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9057,6 +9362,10 @@ func TestNinOptStructCompare(t *testing.T) { } } func TestNidRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9081,6 +9390,10 @@ func TestNidRepStructCompare(t *testing.T) { } } func TestNinRepStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9105,6 +9418,10 @@ func TestNinRepStructCompare(t *testing.T) { } } func TestNidEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9129,6 +9446,10 @@ func TestNidEmbeddedStructCompare(t *testing.T) { } } func TestNinEmbeddedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9153,6 +9474,10 @@ func TestNinEmbeddedStructCompare(t *testing.T) { } } func TestNidNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9177,6 +9502,10 @@ func TestNidNestedStructCompare(t *testing.T) { } } func TestNinNestedStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9201,6 +9530,10 @@ func TestNinNestedStructCompare(t *testing.T) { } } func TestNidOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9225,6 +9558,10 @@ func TestNidOptCustomCompare(t *testing.T) { } } func TestCustomDashCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9249,6 +9586,10 @@ func TestCustomDashCompare(t *testing.T) { } } func TestNinOptCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9273,6 +9614,10 @@ func TestNinOptCustomCompare(t *testing.T) { } } func TestNidRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9297,6 +9642,10 @@ func TestNidRepCustomCompare(t *testing.T) { } } func TestNinRepCustomCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9321,6 +9670,10 @@ func TestNinRepCustomCompare(t *testing.T) { } } func TestNinOptNativeUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9345,6 +9698,10 @@ func TestNinOptNativeUnionCompare(t *testing.T) { } } func TestNinOptStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9369,6 +9726,10 @@ func TestNinOptStructUnionCompare(t *testing.T) { } } func TestNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9393,6 +9754,10 @@ func TestNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestNinNestedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9417,6 +9782,10 @@ func TestNinNestedStructUnionCompare(t *testing.T) { } } func TestTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9441,6 +9810,10 @@ func TestTreeCompare(t *testing.T) { } } func TestOrBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9465,6 +9838,10 @@ func TestOrBranchCompare(t *testing.T) { } } func TestAndBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9489,6 +9866,10 @@ func TestAndBranchCompare(t *testing.T) { } } func TestLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9513,6 +9894,10 @@ func TestLeafCompare(t *testing.T) { } } func TestDeepTreeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9537,6 +9922,10 @@ func TestDeepTreeCompare(t *testing.T) { } } func TestADeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9561,6 +9950,10 @@ func TestADeepBranchCompare(t *testing.T) { } } func TestAndDeepBranchCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9585,6 +9978,10 @@ func TestAndDeepBranchCompare(t *testing.T) { } } func TestDeepLeafCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9609,6 +10006,10 @@ func TestDeepLeafCompare(t *testing.T) { } } func TestNilCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9633,6 +10034,10 @@ func TestNilCompare(t *testing.T) { } } func TestNidOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9657,6 +10062,10 @@ func TestNidOptEnumCompare(t *testing.T) { } } func TestNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9681,6 +10090,10 @@ func TestNinOptEnumCompare(t *testing.T) { } } func TestNidRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9705,6 +10118,10 @@ func TestNidRepEnumCompare(t *testing.T) { } } func TestNinRepEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9729,6 +10146,10 @@ func TestNinRepEnumCompare(t *testing.T) { } } func TestNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9753,6 +10174,10 @@ func TestNinOptEnumDefaultCompare(t *testing.T) { } } func TestAnotherNinOptEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9777,6 +10202,10 @@ func TestAnotherNinOptEnumCompare(t *testing.T) { } } func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9801,6 +10230,10 @@ func TestAnotherNinOptEnumDefaultCompare(t *testing.T) { } } func TestTimerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9825,6 +10258,10 @@ func TestTimerCompare(t *testing.T) { } } func TestMyExtendableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9849,6 +10286,10 @@ func TestMyExtendableCompare(t *testing.T) { } } func TestOtherExtenableCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9873,6 +10314,10 @@ func TestOtherExtenableCompare(t *testing.T) { } } func TestNestedDefinitionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9897,6 +10342,10 @@ func TestNestedDefinitionCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessageCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9921,6 +10370,10 @@ func TestNestedDefinition_NestedMessageCompare(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9945,6 +10398,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgCompare(t *testing.T) { } } func TestNestedScopeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9969,6 +10426,10 @@ func TestNestedScopeCompare(t *testing.T) { } } func TestNinOptNativeDefaultCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -9993,6 +10454,10 @@ func TestNinOptNativeDefaultCompare(t *testing.T) { } } func TestCustomContainerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10017,6 +10482,10 @@ func TestCustomContainerCompare(t *testing.T) { } } func TestCustomNameNidOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10041,6 +10510,10 @@ func TestCustomNameNidOptNativeCompare(t *testing.T) { } } func TestCustomNameNinOptNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10065,6 +10538,10 @@ func TestCustomNameNinOptNativeCompare(t *testing.T) { } } func TestCustomNameNinRepNativeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10089,6 +10566,10 @@ func TestCustomNameNinRepNativeCompare(t *testing.T) { } } func TestCustomNameNinStructCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10113,6 +10594,10 @@ func TestCustomNameNinStructCompare(t *testing.T) { } } func TestCustomNameCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10137,6 +10622,10 @@ func TestCustomNameCustomTypeCompare(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10161,6 +10650,10 @@ func TestCustomNameNinEmbeddedStructUnionCompare(t *testing.T) { } } func TestCustomNameEnumCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10185,6 +10678,10 @@ func TestCustomNameEnumCompare(t *testing.T) { } } func TestNoExtensionsMapCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10209,6 +10706,10 @@ func TestNoExtensionsMapCompare(t *testing.T) { } } func TestUnrecognizedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10233,6 +10734,10 @@ func TestUnrecognizedCompare(t *testing.T) { } } func TestUnrecognizedWithInnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10257,6 +10762,10 @@ func TestUnrecognizedWithInnerCompare(t *testing.T) { } } func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10281,6 +10790,10 @@ func TestUnrecognizedWithInner_InnerCompare(t *testing.T) { } } func TestUnrecognizedWithEmbedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10305,6 +10818,10 @@ func TestUnrecognizedWithEmbedCompare(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10329,6 +10846,10 @@ func TestUnrecognizedWithEmbed_EmbeddedCompare(t *testing.T) { } } func TestNodeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10353,6 +10874,10 @@ func TestNodeCompare(t *testing.T) { } } func TestNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10377,6 +10902,10 @@ func TestNonByteCustomTypeCompare(t *testing.T) { } } func TestNidOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10401,6 +10930,10 @@ func TestNidOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNinOptNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10425,6 +10958,10 @@ func TestNinOptNonByteCustomTypeCompare(t *testing.T) { } } func TestNidRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10449,6 +10986,10 @@ func TestNidRepNonByteCustomTypeCompare(t *testing.T) { } } func TestNinRepNonByteCustomTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10473,6 +11014,10 @@ func TestNinRepNonByteCustomTypeCompare(t *testing.T) { } } func TestProtoTypeCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10500,6 +11045,10 @@ func TestThetestDescription(t *testing.T) { ThetestDescription() } func TestNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10515,6 +11064,10 @@ func TestNidOptNativeVerboseEqual(t *testing.T) { } } func TestNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10530,6 +11083,10 @@ func TestNinOptNativeVerboseEqual(t *testing.T) { } } func TestNidRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10545,6 +11102,10 @@ func TestNidRepNativeVerboseEqual(t *testing.T) { } } func TestNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10560,6 +11121,10 @@ func TestNinRepNativeVerboseEqual(t *testing.T) { } } func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10575,6 +11140,10 @@ func TestNidRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepPackedNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10590,6 +11159,10 @@ func TestNinRepPackedNativeVerboseEqual(t *testing.T) { } } func TestNidOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10605,6 +11178,10 @@ func TestNidOptStructVerboseEqual(t *testing.T) { } } func TestNinOptStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10620,6 +11197,10 @@ func TestNinOptStructVerboseEqual(t *testing.T) { } } func TestNidRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10635,6 +11216,10 @@ func TestNidRepStructVerboseEqual(t *testing.T) { } } func TestNinRepStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10650,6 +11235,10 @@ func TestNinRepStructVerboseEqual(t *testing.T) { } } func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10665,6 +11254,10 @@ func TestNidEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10680,6 +11273,10 @@ func TestNinEmbeddedStructVerboseEqual(t *testing.T) { } } func TestNidNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10695,6 +11292,10 @@ func TestNidNestedStructVerboseEqual(t *testing.T) { } } func TestNinNestedStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10710,6 +11311,10 @@ func TestNinNestedStructVerboseEqual(t *testing.T) { } } func TestNidOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10725,6 +11330,10 @@ func TestNidOptCustomVerboseEqual(t *testing.T) { } } func TestCustomDashVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomDash(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10740,6 +11349,10 @@ func TestCustomDashVerboseEqual(t *testing.T) { } } func TestNinOptCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10755,6 +11368,10 @@ func TestNinOptCustomVerboseEqual(t *testing.T) { } } func TestNidRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10770,6 +11387,10 @@ func TestNidRepCustomVerboseEqual(t *testing.T) { } } func TestNinRepCustomVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepCustom(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10785,6 +11406,10 @@ func TestNinRepCustomVerboseEqual(t *testing.T) { } } func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10800,6 +11425,10 @@ func TestNinOptNativeUnionVerboseEqual(t *testing.T) { } } func TestNinOptStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10815,6 +11444,10 @@ func TestNinOptStructUnionVerboseEqual(t *testing.T) { } } func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10830,6 +11463,10 @@ func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinNestedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10845,6 +11482,10 @@ func TestNinNestedStructUnionVerboseEqual(t *testing.T) { } } func TestTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10860,6 +11501,10 @@ func TestTreeVerboseEqual(t *testing.T) { } } func TestOrBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOrBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10875,6 +11520,10 @@ func TestOrBranchVerboseEqual(t *testing.T) { } } func TestAndBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10890,6 +11539,10 @@ func TestAndBranchVerboseEqual(t *testing.T) { } } func TestLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10905,6 +11558,10 @@ func TestLeafVerboseEqual(t *testing.T) { } } func TestDeepTreeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepTree(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10920,6 +11577,10 @@ func TestDeepTreeVerboseEqual(t *testing.T) { } } func TestADeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedADeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10935,6 +11596,10 @@ func TestADeepBranchVerboseEqual(t *testing.T) { } } func TestAndDeepBranchVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAndDeepBranch(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10950,6 +11615,10 @@ func TestAndDeepBranchVerboseEqual(t *testing.T) { } } func TestDeepLeafVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedDeepLeaf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10965,6 +11634,10 @@ func TestDeepLeafVerboseEqual(t *testing.T) { } } func TestNilVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNil(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10980,6 +11653,10 @@ func TestNilVerboseEqual(t *testing.T) { } } func TestNidOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -10995,6 +11672,10 @@ func TestNidOptEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11010,6 +11691,10 @@ func TestNinOptEnumVerboseEqual(t *testing.T) { } } func TestNidRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11025,6 +11710,10 @@ func TestNidRepEnumVerboseEqual(t *testing.T) { } } func TestNinRepEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11040,6 +11729,10 @@ func TestNinRepEnumVerboseEqual(t *testing.T) { } } func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11055,6 +11748,10 @@ func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11070,6 +11767,10 @@ func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { } } func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAnotherNinOptEnumDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11085,6 +11786,10 @@ func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { } } func TestTimerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTimer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11100,6 +11805,10 @@ func TestTimerVerboseEqual(t *testing.T) { } } func TestMyExtendableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMyExtendable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11115,6 +11824,10 @@ func TestMyExtendableVerboseEqual(t *testing.T) { } } func TestOtherExtenableVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOtherExtenable(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11130,6 +11843,10 @@ func TestOtherExtenableVerboseEqual(t *testing.T) { } } func TestNestedDefinitionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11145,6 +11862,10 @@ func TestNestedDefinitionVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11160,6 +11881,10 @@ func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { } } func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11175,6 +11900,10 @@ func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T } } func TestNestedScopeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNestedScope(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11190,6 +11919,10 @@ func TestNestedScopeVerboseEqual(t *testing.T) { } } func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNativeDefault(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11205,6 +11938,10 @@ func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { } } func TestCustomContainerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomContainer(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11220,6 +11957,10 @@ func TestCustomContainerVerboseEqual(t *testing.T) { } } func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNidOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11235,6 +11976,10 @@ func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinOptNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11250,6 +11995,10 @@ func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinRepNative(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11265,6 +12014,10 @@ func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { } } func TestCustomNameNinStructVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinStruct(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11280,6 +12033,10 @@ func TestCustomNameNinStructVerboseEqual(t *testing.T) { } } func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11295,6 +12052,10 @@ func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { } } func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11310,6 +12071,10 @@ func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { } } func TestCustomNameEnumVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomNameEnum(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11325,6 +12090,10 @@ func TestCustomNameEnumVerboseEqual(t *testing.T) { } } func TestNoExtensionsMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNoExtensionsMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11340,6 +12109,10 @@ func TestNoExtensionsMapVerboseEqual(t *testing.T) { } } func TestUnrecognizedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognized(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11355,6 +12128,10 @@ func TestUnrecognizedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11370,6 +12147,10 @@ func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11385,6 +12166,10 @@ func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11400,6 +12185,10 @@ func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { } } func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11415,6 +12204,10 @@ func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { } } func TestNodeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNode(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11430,6 +12223,10 @@ func TestNodeVerboseEqual(t *testing.T) { } } func TestNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11445,6 +12242,10 @@ func TestNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11460,6 +12261,10 @@ func TestNidOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinOptNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11475,6 +12280,10 @@ func TestNinOptNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNidRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11490,6 +12299,10 @@ func TestNidRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNinRepNonByteCustomType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -11505,6 +12318,10 @@ func TestNinRepNonByteCustomTypeVerboseEqual(t *testing.T) { } } func TestProtoTypeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoType(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go b/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go index 1c0d7b4fbe..ba3a6a0dd2 100644 --- a/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go +++ b/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go @@ -19,6 +19,7 @@ package proto2_maps import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -67,6 +72,10 @@ func TestFloatingPointProto(t *testing.T) { } func TestFloatingPointMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -135,6 +144,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestCustomMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomMap(popr, false) @@ -169,6 +182,10 @@ func TestCustomMapProto(t *testing.T) { } func TestCustomMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomMap(popr, false) @@ -237,6 +254,10 @@ func BenchmarkCustomMapProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -271,6 +292,10 @@ func TestAllMapsProto(t *testing.T) { } func TestAllMapsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -339,6 +364,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -373,6 +402,10 @@ func TestAllMapsOrderedProto(t *testing.T) { } func TestAllMapsOrderedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -664,6 +697,10 @@ func TestMapsproto2Description(t *testing.T) { Mapsproto2Description() } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -679,6 +716,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestCustomMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -694,6 +735,10 @@ func TestCustomMapVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -709,6 +754,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go b/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go index d1f2c5f0b1..b59669eb14 100644 --- a/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go +++ b/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go @@ -19,6 +19,7 @@ package proto2_maps import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -67,6 +72,10 @@ func TestFloatingPointProto(t *testing.T) { } func TestFloatingPointMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -135,6 +144,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestCustomMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomMap(popr, false) @@ -169,6 +182,10 @@ func TestCustomMapProto(t *testing.T) { } func TestCustomMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomMap(popr, false) @@ -237,6 +254,10 @@ func BenchmarkCustomMapProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -271,6 +292,10 @@ func TestAllMapsProto(t *testing.T) { } func TestAllMapsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -339,6 +364,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -373,6 +402,10 @@ func TestAllMapsOrderedProto(t *testing.T) { } func TestAllMapsOrderedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -664,6 +697,10 @@ func TestMapsproto2Description(t *testing.T) { Mapsproto2Description() } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -679,6 +716,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestCustomMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -694,6 +735,10 @@ func TestCustomMapVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -709,6 +754,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go b/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go index 4965a3d4ba..181f75d514 100644 --- a/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go +++ b/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go @@ -19,6 +19,7 @@ package proto2_maps import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -107,6 +112,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestCustomMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomMap(popr, false) @@ -181,6 +190,10 @@ func BenchmarkCustomMapProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -255,6 +268,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -552,6 +569,10 @@ func TestMapsproto2Description(t *testing.T) { Mapsproto2Description() } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -567,6 +588,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestCustomMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -582,6 +607,10 @@ func TestCustomMapVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -597,6 +626,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof/combos/unsafeboth/onepb_test.go b/test/oneof/combos/unsafeboth/onepb_test.go index cebe3916cb..09f0c6976a 100644 --- a/test/oneof/combos/unsafeboth/onepb_test.go +++ b/test/oneof/combos/unsafeboth/onepb_test.go @@ -19,6 +19,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -67,6 +72,10 @@ func TestSubbyProto(t *testing.T) { } func TestSubbyMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -95,6 +104,10 @@ func TestSubbyMarshalTo(t *testing.T) { } func TestAllTypesOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllTypesOneOf(popr, false) @@ -129,6 +142,10 @@ func TestAllTypesOneOfProto(t *testing.T) { } func TestAllTypesOneOfMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllTypesOneOf(popr, false) @@ -157,6 +174,10 @@ func TestAllTypesOneOfMarshalTo(t *testing.T) { } func TestTwoOneofsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTwoOneofs(popr, false) @@ -191,6 +212,10 @@ func TestTwoOneofsProto(t *testing.T) { } func TestTwoOneofsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTwoOneofs(popr, false) @@ -219,6 +244,10 @@ func TestTwoOneofsMarshalTo(t *testing.T) { } func TestCustomOneofProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomOneof(popr, false) @@ -253,6 +282,10 @@ func TestCustomOneofProto(t *testing.T) { } func TestCustomOneofMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomOneof(popr, false) @@ -504,6 +537,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -519,6 +556,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestAllTypesOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllTypesOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -534,6 +575,10 @@ func TestAllTypesOneOfVerboseEqual(t *testing.T) { } } func TestTwoOneofsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTwoOneofs(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -549,6 +594,10 @@ func TestTwoOneofsVerboseEqual(t *testing.T) { } } func TestCustomOneofVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomOneof(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof/combos/unsafemarshaler/onepb_test.go b/test/oneof/combos/unsafemarshaler/onepb_test.go index eaad4ebf33..becfa0ddcd 100644 --- a/test/oneof/combos/unsafemarshaler/onepb_test.go +++ b/test/oneof/combos/unsafemarshaler/onepb_test.go @@ -19,6 +19,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -67,6 +72,10 @@ func TestSubbyProto(t *testing.T) { } func TestSubbyMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -95,6 +104,10 @@ func TestSubbyMarshalTo(t *testing.T) { } func TestAllTypesOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllTypesOneOf(popr, false) @@ -129,6 +142,10 @@ func TestAllTypesOneOfProto(t *testing.T) { } func TestAllTypesOneOfMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllTypesOneOf(popr, false) @@ -157,6 +174,10 @@ func TestAllTypesOneOfMarshalTo(t *testing.T) { } func TestTwoOneofsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTwoOneofs(popr, false) @@ -191,6 +212,10 @@ func TestTwoOneofsProto(t *testing.T) { } func TestTwoOneofsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTwoOneofs(popr, false) @@ -219,6 +244,10 @@ func TestTwoOneofsMarshalTo(t *testing.T) { } func TestCustomOneofProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomOneof(popr, false) @@ -253,6 +282,10 @@ func TestCustomOneofProto(t *testing.T) { } func TestCustomOneofMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomOneof(popr, false) @@ -504,6 +537,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -519,6 +556,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestAllTypesOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllTypesOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -534,6 +575,10 @@ func TestAllTypesOneOfVerboseEqual(t *testing.T) { } } func TestTwoOneofsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTwoOneofs(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -549,6 +594,10 @@ func TestTwoOneofsVerboseEqual(t *testing.T) { } } func TestCustomOneofVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomOneof(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof/combos/unsafeunmarshaler/onepb_test.go b/test/oneof/combos/unsafeunmarshaler/onepb_test.go index 7169f26e2b..18110e3320 100644 --- a/test/oneof/combos/unsafeunmarshaler/onepb_test.go +++ b/test/oneof/combos/unsafeunmarshaler/onepb_test.go @@ -19,6 +19,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -33,6 +34,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -67,6 +72,10 @@ func TestSubbyProto(t *testing.T) { } func TestAllTypesOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllTypesOneOf(popr, false) @@ -101,6 +110,10 @@ func TestAllTypesOneOfProto(t *testing.T) { } func TestTwoOneofsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedTwoOneofs(popr, false) @@ -135,6 +148,10 @@ func TestTwoOneofsProto(t *testing.T) { } func TestCustomOneofProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCustomOneof(popr, false) @@ -392,6 +409,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -407,6 +428,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestAllTypesOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllTypesOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -422,6 +447,10 @@ func TestAllTypesOneOfVerboseEqual(t *testing.T) { } } func TestTwoOneofsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedTwoOneofs(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -437,6 +466,10 @@ func TestTwoOneofsVerboseEqual(t *testing.T) { } } func TestCustomOneofVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedCustomOneof(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof3/combos/unsafeboth/onepb_test.go b/test/oneof3/combos/unsafeboth/onepb_test.go index 639f5b3528..1951ceae5c 100644 --- a/test/oneof3/combos/unsafeboth/onepb_test.go +++ b/test/oneof3/combos/unsafeboth/onepb_test.go @@ -17,6 +17,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -65,6 +70,10 @@ func TestSubbyProto(t *testing.T) { } func TestSubbyMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -93,6 +102,10 @@ func TestSubbyMarshalTo(t *testing.T) { } func TestSampleOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSampleOneOf(popr, false) @@ -127,6 +140,10 @@ func TestSampleOneOfProto(t *testing.T) { } func TestSampleOneOfMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSampleOneOf(popr, false) @@ -268,6 +285,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -283,6 +304,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestSampleOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSampleOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof3/combos/unsafemarshaler/onepb_test.go b/test/oneof3/combos/unsafemarshaler/onepb_test.go index 0f3765eee4..f705abc4e3 100644 --- a/test/oneof3/combos/unsafemarshaler/onepb_test.go +++ b/test/oneof3/combos/unsafemarshaler/onepb_test.go @@ -17,6 +17,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -65,6 +70,10 @@ func TestSubbyProto(t *testing.T) { } func TestSubbyMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -93,6 +102,10 @@ func TestSubbyMarshalTo(t *testing.T) { } func TestSampleOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSampleOneOf(popr, false) @@ -127,6 +140,10 @@ func TestSampleOneOfProto(t *testing.T) { } func TestSampleOneOfMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSampleOneOf(popr, false) @@ -268,6 +285,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -283,6 +304,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestSampleOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSampleOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/oneof3/combos/unsafeunmarshaler/onepb_test.go b/test/oneof3/combos/unsafeunmarshaler/onepb_test.go index 18a0634f55..eb664495bf 100644 --- a/test/oneof3/combos/unsafeunmarshaler/onepb_test.go +++ b/test/oneof3/combos/unsafeunmarshaler/onepb_test.go @@ -17,6 +17,7 @@ package one import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -31,6 +32,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestSubbyProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSubby(popr, false) @@ -65,6 +70,10 @@ func TestSubbyProto(t *testing.T) { } func TestSampleOneOfProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedSampleOneOf(popr, false) @@ -212,6 +221,10 @@ func TestOneDescription(t *testing.T) { OneDescription() } func TestSubbyVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSubby(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -227,6 +240,10 @@ func TestSubbyVerboseEqual(t *testing.T) { } } func TestSampleOneOfVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedSampleOneOf(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/packed/packed_test.go b/test/packed/packed_test.go index 01ed36b2b8..ea66292c6c 100644 --- a/test/packed/packed_test.go +++ b/test/packed/packed_test.go @@ -35,6 +35,7 @@ import ( math_rand "math/rand" "testing" "time" + "unsafe" ) /* @@ -47,12 +48,12 @@ func TestSafeIssue21(t *testing.T) { msg1 := NewPopulatedNinRepNative(popr, true) data1, err := proto.Marshal(msg1) if err != nil { - panic(err) + t.Fatal(err) } packedmsg := &NinRepPackedNative{} err = proto.Unmarshal(data1, packedmsg) if err != nil { - panic(err) + t.Fatal(err) } if len(packedmsg.XXX_unrecognized) != 0 { t.Fatalf("packed msg unmarshaled unrecognized fields, even though there aren't any") @@ -63,16 +64,20 @@ func TestSafeIssue21(t *testing.T) { } func TestUnsafeIssue21(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) msg1 := NewPopulatedNinRepNativeUnsafe(popr, true) data1, err := proto.Marshal(msg1) if err != nil { - panic(err) + t.Fatal(err) } packedmsg := &NinRepPackedNativeUnsafe{} err = proto.Unmarshal(data1, packedmsg) if err != nil { - panic(err) + t.Fatal(err) } if len(packedmsg.XXX_unrecognized) != 0 { t.Fatalf("packed msg unmarshaled unrecognized fields, even though there aren't any") diff --git a/test/theproto3/combos/unsafeboth/theproto3pb_test.go b/test/theproto3/combos/unsafeboth/theproto3pb_test.go index 47efaac0e6..9d00bb39fd 100644 --- a/test/theproto3/combos/unsafeboth/theproto3pb_test.go +++ b/test/theproto3/combos/unsafeboth/theproto3pb_test.go @@ -24,6 +24,7 @@ package theproto3 import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -39,6 +40,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessage(popr, false) @@ -73,6 +78,10 @@ func TestMessageProto(t *testing.T) { } func TestMessageMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessage(popr, false) @@ -141,6 +150,10 @@ func BenchmarkMessageProtoUnmarshal(b *testing.B) { } func TestNestedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNested(popr, false) @@ -175,6 +188,10 @@ func TestNestedProto(t *testing.T) { } func TestNestedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNested(popr, false) @@ -243,6 +260,10 @@ func BenchmarkNestedProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -277,6 +298,10 @@ func TestAllMapsProto(t *testing.T) { } func TestAllMapsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -345,6 +370,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -379,6 +408,10 @@ func TestAllMapsOrderedProto(t *testing.T) { } func TestAllMapsOrderedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -447,6 +480,10 @@ func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) { } func TestMessageWithMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessageWithMap(popr, false) @@ -481,6 +518,10 @@ func TestMessageWithMapProto(t *testing.T) { } func TestMessageWithMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessageWithMap(popr, false) @@ -549,6 +590,10 @@ func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { } func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -583,6 +628,10 @@ func TestFloatingPointProto(t *testing.T) { } func TestFloatingPointMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -651,6 +700,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestUint128PairProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUint128Pair(popr, false) @@ -685,6 +738,10 @@ func TestUint128PairProto(t *testing.T) { } func TestUint128PairMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUint128Pair(popr, false) @@ -753,6 +810,10 @@ func BenchmarkUint128PairProtoUnmarshal(b *testing.B) { } func TestContainsNestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap(popr, false) @@ -787,6 +848,10 @@ func TestContainsNestedMapProto(t *testing.T) { } func TestContainsNestedMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap(popr, false) @@ -855,6 +920,10 @@ func BenchmarkContainsNestedMapProtoUnmarshal(b *testing.B) { } func TestContainsNestedMap_NestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) @@ -889,6 +958,10 @@ func TestContainsNestedMap_NestedMapProto(t *testing.T) { } func TestContainsNestedMap_NestedMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) @@ -957,6 +1030,10 @@ func BenchmarkContainsNestedMap_NestedMapProtoUnmarshal(b *testing.B) { } func TestNotPackedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNotPacked(popr, false) @@ -991,6 +1068,10 @@ func TestNotPackedProto(t *testing.T) { } func TestNotPackedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNotPacked(popr, false) @@ -1612,6 +1693,10 @@ func TestTheproto3Description(t *testing.T) { Theproto3Description() } func TestMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1627,6 +1712,10 @@ func TestMessageVerboseEqual(t *testing.T) { } } func TestNestedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNested(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1642,6 +1731,10 @@ func TestNestedVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1657,6 +1750,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1672,6 +1769,10 @@ func TestAllMapsOrderedVerboseEqual(t *testing.T) { } } func TestMessageWithMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessageWithMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1687,6 +1788,10 @@ func TestMessageWithMapVerboseEqual(t *testing.T) { } } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1702,6 +1807,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestUint128PairVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUint128Pair(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1717,6 +1826,10 @@ func TestUint128PairVerboseEqual(t *testing.T) { } } func TestContainsNestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1732,6 +1845,10 @@ func TestContainsNestedMapVerboseEqual(t *testing.T) { } } func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1747,6 +1864,10 @@ func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { } } func TestNotPackedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNotPacked(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go b/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go index 30b9283bce..cfed275322 100644 --- a/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go +++ b/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go @@ -24,6 +24,7 @@ package theproto3 import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -39,6 +40,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessage(popr, false) @@ -73,6 +78,10 @@ func TestMessageProto(t *testing.T) { } func TestMessageMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessage(popr, false) @@ -141,6 +150,10 @@ func BenchmarkMessageProtoUnmarshal(b *testing.B) { } func TestNestedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNested(popr, false) @@ -175,6 +188,10 @@ func TestNestedProto(t *testing.T) { } func TestNestedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNested(popr, false) @@ -243,6 +260,10 @@ func BenchmarkNestedProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -277,6 +298,10 @@ func TestAllMapsProto(t *testing.T) { } func TestAllMapsMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -345,6 +370,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -379,6 +408,10 @@ func TestAllMapsOrderedProto(t *testing.T) { } func TestAllMapsOrderedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -447,6 +480,10 @@ func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) { } func TestMessageWithMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessageWithMap(popr, false) @@ -481,6 +518,10 @@ func TestMessageWithMapProto(t *testing.T) { } func TestMessageWithMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessageWithMap(popr, false) @@ -549,6 +590,10 @@ func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { } func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -583,6 +628,10 @@ func TestFloatingPointProto(t *testing.T) { } func TestFloatingPointMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -651,6 +700,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestUint128PairProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUint128Pair(popr, false) @@ -685,6 +738,10 @@ func TestUint128PairProto(t *testing.T) { } func TestUint128PairMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUint128Pair(popr, false) @@ -753,6 +810,10 @@ func BenchmarkUint128PairProtoUnmarshal(b *testing.B) { } func TestContainsNestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap(popr, false) @@ -787,6 +848,10 @@ func TestContainsNestedMapProto(t *testing.T) { } func TestContainsNestedMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap(popr, false) @@ -855,6 +920,10 @@ func BenchmarkContainsNestedMapProtoUnmarshal(b *testing.B) { } func TestContainsNestedMap_NestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) @@ -889,6 +958,10 @@ func TestContainsNestedMap_NestedMapProto(t *testing.T) { } func TestContainsNestedMap_NestedMapMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) @@ -957,6 +1030,10 @@ func BenchmarkContainsNestedMap_NestedMapProtoUnmarshal(b *testing.B) { } func TestNotPackedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNotPacked(popr, false) @@ -991,6 +1068,10 @@ func TestNotPackedProto(t *testing.T) { } func TestNotPackedMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNotPacked(popr, false) @@ -1612,6 +1693,10 @@ func TestTheproto3Description(t *testing.T) { Theproto3Description() } func TestMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1627,6 +1712,10 @@ func TestMessageVerboseEqual(t *testing.T) { } } func TestNestedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNested(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1642,6 +1731,10 @@ func TestNestedVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1657,6 +1750,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1672,6 +1769,10 @@ func TestAllMapsOrderedVerboseEqual(t *testing.T) { } } func TestMessageWithMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessageWithMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1687,6 +1788,10 @@ func TestMessageWithMapVerboseEqual(t *testing.T) { } } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1702,6 +1807,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestUint128PairVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUint128Pair(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1717,6 +1826,10 @@ func TestUint128PairVerboseEqual(t *testing.T) { } } func TestContainsNestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1732,6 +1845,10 @@ func TestContainsNestedMapVerboseEqual(t *testing.T) { } } func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1747,6 +1864,10 @@ func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { } } func TestNotPackedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNotPacked(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go b/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go index 4f22ab4da9..ff954ac53a 100644 --- a/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go +++ b/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go @@ -24,6 +24,7 @@ package theproto3 import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -39,6 +40,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestMessageProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessage(popr, false) @@ -113,6 +118,10 @@ func BenchmarkMessageProtoUnmarshal(b *testing.B) { } func TestNestedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNested(popr, false) @@ -187,6 +196,10 @@ func BenchmarkNestedProtoUnmarshal(b *testing.B) { } func TestAllMapsProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMaps(popr, false) @@ -261,6 +274,10 @@ func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { } func TestAllMapsOrderedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedAllMapsOrdered(popr, false) @@ -335,6 +352,10 @@ func BenchmarkAllMapsOrderedProtoUnmarshal(b *testing.B) { } func TestMessageWithMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMessageWithMap(popr, false) @@ -409,6 +430,10 @@ func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { } func TestFloatingPointProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedFloatingPoint(popr, false) @@ -483,6 +508,10 @@ func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { } func TestUint128PairProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedUint128Pair(popr, false) @@ -557,6 +586,10 @@ func BenchmarkUint128PairProtoUnmarshal(b *testing.B) { } func TestContainsNestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap(popr, false) @@ -631,6 +664,10 @@ func BenchmarkContainsNestedMapProtoUnmarshal(b *testing.B) { } func TestContainsNestedMap_NestedMapProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) @@ -705,6 +742,10 @@ func BenchmarkContainsNestedMap_NestedMapProtoUnmarshal(b *testing.B) { } func TestNotPackedProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedNotPacked(popr, false) @@ -1332,6 +1373,10 @@ func TestTheproto3Description(t *testing.T) { Theproto3Description() } func TestMessageVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessage(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1347,6 +1392,10 @@ func TestMessageVerboseEqual(t *testing.T) { } } func TestNestedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNested(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1362,6 +1411,10 @@ func TestNestedVerboseEqual(t *testing.T) { } } func TestAllMapsVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMaps(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1377,6 +1430,10 @@ func TestAllMapsVerboseEqual(t *testing.T) { } } func TestAllMapsOrderedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedAllMapsOrdered(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1392,6 +1449,10 @@ func TestAllMapsOrderedVerboseEqual(t *testing.T) { } } func TestMessageWithMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMessageWithMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1407,6 +1468,10 @@ func TestMessageWithMapVerboseEqual(t *testing.T) { } } func TestFloatingPointVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedFloatingPoint(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1422,6 +1487,10 @@ func TestFloatingPointVerboseEqual(t *testing.T) { } } func TestUint128PairVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedUint128Pair(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1437,6 +1506,10 @@ func TestUint128PairVerboseEqual(t *testing.T) { } } func TestContainsNestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1452,6 +1525,10 @@ func TestContainsNestedMapVerboseEqual(t *testing.T) { } } func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedContainsNestedMap_NestedMap(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1467,6 +1544,10 @@ func TestContainsNestedMap_NestedMapVerboseEqual(t *testing.T) { } } func TestNotPackedVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedNotPacked(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/types/combos/unsafeboth/typespb_test.go b/test/types/combos/unsafeboth/typespb_test.go index 5e16d5402a..26c3faa8f3 100644 --- a/test/types/combos/unsafeboth/typespb_test.go +++ b/test/types/combos/unsafeboth/typespb_test.go @@ -24,6 +24,7 @@ package types import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import proto "github.com/gogo/protobuf/proto" @@ -40,6 +41,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestKnownTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedKnownTypes(popr, false) @@ -74,6 +79,10 @@ func TestKnownTypesProto(t *testing.T) { } func TestKnownTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedKnownTypes(popr, false) @@ -142,6 +151,10 @@ func BenchmarkKnownTypesProtoUnmarshal(b *testing.B) { } func TestProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoTypes(popr, false) @@ -176,6 +189,10 @@ func TestProtoTypesProto(t *testing.T) { } func TestProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoTypes(popr, false) @@ -244,6 +261,10 @@ func BenchmarkProtoTypesProtoUnmarshal(b *testing.B) { } func TestStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedStdTypes(popr, false) @@ -278,6 +299,10 @@ func TestStdTypesProto(t *testing.T) { } func TestStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedStdTypes(popr, false) @@ -346,6 +371,10 @@ func BenchmarkStdTypesProtoUnmarshal(b *testing.B) { } func TestRepProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepProtoTypes(popr, false) @@ -380,6 +409,10 @@ func TestRepProtoTypesProto(t *testing.T) { } func TestRepProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepProtoTypes(popr, false) @@ -448,6 +481,10 @@ func BenchmarkRepProtoTypesProtoUnmarshal(b *testing.B) { } func TestRepStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepStdTypes(popr, false) @@ -482,6 +519,10 @@ func TestRepStdTypesProto(t *testing.T) { } func TestRepStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepStdTypes(popr, false) @@ -550,6 +591,10 @@ func BenchmarkRepStdTypesProtoUnmarshal(b *testing.B) { } func TestMapProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapProtoTypes(popr, false) @@ -584,6 +629,10 @@ func TestMapProtoTypesProto(t *testing.T) { } func TestMapProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapProtoTypes(popr, false) @@ -652,6 +701,10 @@ func BenchmarkMapProtoTypesProtoUnmarshal(b *testing.B) { } func TestMapStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapStdTypes(popr, false) @@ -686,6 +739,10 @@ func TestMapStdTypesProto(t *testing.T) { } func TestMapStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapStdTypes(popr, false) @@ -754,6 +811,10 @@ func BenchmarkMapStdTypesProtoUnmarshal(b *testing.B) { } func TestOneofProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofProtoTypes(popr, false) @@ -788,6 +849,10 @@ func TestOneofProtoTypesProto(t *testing.T) { } func TestOneofProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofProtoTypes(popr, false) @@ -856,6 +921,10 @@ func BenchmarkOneofProtoTypesProtoUnmarshal(b *testing.B) { } func TestOneofStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofStdTypes(popr, false) @@ -890,6 +959,10 @@ func TestOneofStdTypesProto(t *testing.T) { } func TestOneofStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofStdTypes(popr, false) @@ -1453,6 +1526,10 @@ func TestOneofStdTypesProtoCompactText(t *testing.T) { } func TestKnownTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1477,6 +1554,10 @@ func TestKnownTypesCompare(t *testing.T) { } } func TestProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1501,6 +1582,10 @@ func TestProtoTypesCompare(t *testing.T) { } } func TestRepProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1525,6 +1610,10 @@ func TestRepProtoTypesCompare(t *testing.T) { } } func TestKnownTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1540,6 +1629,10 @@ func TestKnownTypesVerboseEqual(t *testing.T) { } } func TestProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1555,6 +1648,10 @@ func TestProtoTypesVerboseEqual(t *testing.T) { } } func TestStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1570,6 +1667,10 @@ func TestStdTypesVerboseEqual(t *testing.T) { } } func TestRepProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1585,6 +1686,10 @@ func TestRepProtoTypesVerboseEqual(t *testing.T) { } } func TestRepStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1600,6 +1705,10 @@ func TestRepStdTypesVerboseEqual(t *testing.T) { } } func TestMapProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1615,6 +1724,10 @@ func TestMapProtoTypesVerboseEqual(t *testing.T) { } } func TestMapStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1630,6 +1743,10 @@ func TestMapStdTypesVerboseEqual(t *testing.T) { } } func TestOneofProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1645,6 +1762,10 @@ func TestOneofProtoTypesVerboseEqual(t *testing.T) { } } func TestOneofStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/types/combos/unsafemarshaler/typespb_test.go b/test/types/combos/unsafemarshaler/typespb_test.go index 195edc464f..00858d00c5 100644 --- a/test/types/combos/unsafemarshaler/typespb_test.go +++ b/test/types/combos/unsafemarshaler/typespb_test.go @@ -24,6 +24,7 @@ package types import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import proto "github.com/gogo/protobuf/proto" @@ -40,6 +41,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestKnownTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedKnownTypes(popr, false) @@ -74,6 +79,10 @@ func TestKnownTypesProto(t *testing.T) { } func TestKnownTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedKnownTypes(popr, false) @@ -142,6 +151,10 @@ func BenchmarkKnownTypesProtoUnmarshal(b *testing.B) { } func TestProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoTypes(popr, false) @@ -176,6 +189,10 @@ func TestProtoTypesProto(t *testing.T) { } func TestProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoTypes(popr, false) @@ -244,6 +261,10 @@ func BenchmarkProtoTypesProtoUnmarshal(b *testing.B) { } func TestStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedStdTypes(popr, false) @@ -278,6 +299,10 @@ func TestStdTypesProto(t *testing.T) { } func TestStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedStdTypes(popr, false) @@ -346,6 +371,10 @@ func BenchmarkStdTypesProtoUnmarshal(b *testing.B) { } func TestRepProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepProtoTypes(popr, false) @@ -380,6 +409,10 @@ func TestRepProtoTypesProto(t *testing.T) { } func TestRepProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepProtoTypes(popr, false) @@ -448,6 +481,10 @@ func BenchmarkRepProtoTypesProtoUnmarshal(b *testing.B) { } func TestRepStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepStdTypes(popr, false) @@ -482,6 +519,10 @@ func TestRepStdTypesProto(t *testing.T) { } func TestRepStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepStdTypes(popr, false) @@ -550,6 +591,10 @@ func BenchmarkRepStdTypesProtoUnmarshal(b *testing.B) { } func TestMapProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapProtoTypes(popr, false) @@ -584,6 +629,10 @@ func TestMapProtoTypesProto(t *testing.T) { } func TestMapProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapProtoTypes(popr, false) @@ -652,6 +701,10 @@ func BenchmarkMapProtoTypesProtoUnmarshal(b *testing.B) { } func TestMapStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapStdTypes(popr, false) @@ -686,6 +739,10 @@ func TestMapStdTypesProto(t *testing.T) { } func TestMapStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapStdTypes(popr, false) @@ -754,6 +811,10 @@ func BenchmarkMapStdTypesProtoUnmarshal(b *testing.B) { } func TestOneofProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofProtoTypes(popr, false) @@ -788,6 +849,10 @@ func TestOneofProtoTypesProto(t *testing.T) { } func TestOneofProtoTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofProtoTypes(popr, false) @@ -856,6 +921,10 @@ func BenchmarkOneofProtoTypesProtoUnmarshal(b *testing.B) { } func TestOneofStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofStdTypes(popr, false) @@ -890,6 +959,10 @@ func TestOneofStdTypesProto(t *testing.T) { } func TestOneofStdTypesMarshalTo(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofStdTypes(popr, false) @@ -1453,6 +1526,10 @@ func TestOneofStdTypesProtoCompactText(t *testing.T) { } func TestKnownTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1477,6 +1554,10 @@ func TestKnownTypesCompare(t *testing.T) { } } func TestProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1501,6 +1582,10 @@ func TestProtoTypesCompare(t *testing.T) { } } func TestRepProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1525,6 +1610,10 @@ func TestRepProtoTypesCompare(t *testing.T) { } } func TestKnownTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1540,6 +1629,10 @@ func TestKnownTypesVerboseEqual(t *testing.T) { } } func TestProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1555,6 +1648,10 @@ func TestProtoTypesVerboseEqual(t *testing.T) { } } func TestStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1570,6 +1667,10 @@ func TestStdTypesVerboseEqual(t *testing.T) { } } func TestRepProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1585,6 +1686,10 @@ func TestRepProtoTypesVerboseEqual(t *testing.T) { } } func TestRepStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1600,6 +1705,10 @@ func TestRepStdTypesVerboseEqual(t *testing.T) { } } func TestMapProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1615,6 +1724,10 @@ func TestMapProtoTypesVerboseEqual(t *testing.T) { } } func TestMapStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1630,6 +1743,10 @@ func TestMapStdTypesVerboseEqual(t *testing.T) { } } func TestOneofProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1645,6 +1762,10 @@ func TestOneofProtoTypesVerboseEqual(t *testing.T) { } } func TestOneofStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/types/combos/unsafeunmarshaler/typespb_test.go b/test/types/combos/unsafeunmarshaler/typespb_test.go index 41f858f1b7..8da815c7ba 100644 --- a/test/types/combos/unsafeunmarshaler/typespb_test.go +++ b/test/types/combos/unsafeunmarshaler/typespb_test.go @@ -24,6 +24,7 @@ package types import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import proto "github.com/gogo/protobuf/proto" @@ -40,6 +41,10 @@ var _ = fmt.Errorf var _ = math.Inf func TestKnownTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedKnownTypes(popr, false) @@ -114,6 +119,10 @@ func BenchmarkKnownTypesProtoUnmarshal(b *testing.B) { } func TestProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedProtoTypes(popr, false) @@ -188,6 +197,10 @@ func BenchmarkProtoTypesProtoUnmarshal(b *testing.B) { } func TestStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedStdTypes(popr, false) @@ -262,6 +275,10 @@ func BenchmarkStdTypesProtoUnmarshal(b *testing.B) { } func TestRepProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepProtoTypes(popr, false) @@ -336,6 +353,10 @@ func BenchmarkRepProtoTypesProtoUnmarshal(b *testing.B) { } func TestRepStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedRepStdTypes(popr, false) @@ -410,6 +431,10 @@ func BenchmarkRepStdTypesProtoUnmarshal(b *testing.B) { } func TestMapProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapProtoTypes(popr, false) @@ -484,6 +509,10 @@ func BenchmarkMapProtoTypesProtoUnmarshal(b *testing.B) { } func TestMapStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedMapStdTypes(popr, false) @@ -558,6 +587,10 @@ func BenchmarkMapStdTypesProtoUnmarshal(b *testing.B) { } func TestOneofProtoTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofProtoTypes(popr, false) @@ -632,6 +665,10 @@ func BenchmarkOneofProtoTypesProtoUnmarshal(b *testing.B) { } func TestOneofStdTypesProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedOneofStdTypes(popr, false) @@ -1201,6 +1238,10 @@ func TestOneofStdTypesProtoCompactText(t *testing.T) { } func TestKnownTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1225,6 +1266,10 @@ func TestKnownTypesCompare(t *testing.T) { } } func TestProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1249,6 +1294,10 @@ func TestProtoTypesCompare(t *testing.T) { } } func TestRepProtoTypesCompare(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1273,6 +1322,10 @@ func TestRepProtoTypesCompare(t *testing.T) { } } func TestKnownTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedKnownTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1288,6 +1341,10 @@ func TestKnownTypesVerboseEqual(t *testing.T) { } } func TestProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1303,6 +1360,10 @@ func TestProtoTypesVerboseEqual(t *testing.T) { } } func TestStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1318,6 +1379,10 @@ func TestStdTypesVerboseEqual(t *testing.T) { } } func TestRepProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1333,6 +1398,10 @@ func TestRepProtoTypesVerboseEqual(t *testing.T) { } } func TestRepStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedRepStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1348,6 +1417,10 @@ func TestRepStdTypesVerboseEqual(t *testing.T) { } } func TestMapProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1363,6 +1436,10 @@ func TestMapProtoTypesVerboseEqual(t *testing.T) { } } func TestMapStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedMapStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1378,6 +1455,10 @@ func TestMapStdTypesVerboseEqual(t *testing.T) { } } func TestOneofProtoTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofProtoTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) @@ -1393,6 +1474,10 @@ func TestOneofProtoTypesVerboseEqual(t *testing.T) { } } func TestOneofStdTypesVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedOneofStdTypes(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) diff --git a/test/unmarshalmerge/unmarshalmergepb_test.go b/test/unmarshalmerge/unmarshalmergepb_test.go index bdb0582d47..9d5ee29c4c 100644 --- a/test/unmarshalmerge/unmarshalmergepb_test.go +++ b/test/unmarshalmerge/unmarshalmergepb_test.go @@ -19,6 +19,7 @@ package unmarshalmerge import testing "testing" import math_rand "math/rand" import time "time" +import unsafe "unsafe" import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" import github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" import fmt "fmt" @@ -107,6 +108,10 @@ func BenchmarkBigProtoUnmarshal(b *testing.B) { } func TestBigUnsafeProto(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedBigUnsafe(popr, false) @@ -564,6 +569,10 @@ func TestBigVerboseEqual(t *testing.T) { } } func TestBigUnsafeVerboseEqual(t *testing.T) { + var bigendian uint32 = 0x01020304 + if *(*byte)(unsafe.Pointer(&bigendian)) == 1 { + t.Skip("unsafe does not work on big endian architectures") + } popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedBigUnsafe(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)