[chore] Call NewOrig* func instead of manually create new objects (#13646)

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

internal/cmd/pdatagen/internal/templates/message.go.tmpl

@@ -41,7 +41,7 @@ func new{{ .structName }}(orig *{{ .originFullName }}, state *internal.State) {{
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func New{{ .structName }}() {{ .structName }} {
-	return new{{ .structName }}(&{{ .originFullName }}{}, internal.NewState())
+	return new{{ .structName }}(internal.NewOrigPtr{{ .originName }}(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

internal/cmd/pdatagen/internal/templates/message_internal.go.tmpl

@@ -31,9 +31,9 @@ func New{{ .structName }}(orig *{{ .originFullName }}, state *State) {{ .structN
 }
 
 func GenerateTest{{ .structName }}() {{ .structName }} {
-	orig := {{ .originFullName }}{}
-	FillOrigTest{{ .originName }}(&orig)
-	return New{{ .structName }}(&orig, NewState())
+	orig := NewOrigPtr{{ .originName }}()
+	FillOrigTest{{ .originName }}(orig)
+	return New{{ .structName }}(orig, NewState())
 }
 
 {{ end }}

internal/cmd/pdatagen/internal/templates/message_internal_test.go.tmpl

@@ -13,10 +13,10 @@ import (
 )
 
 func TestCopyOrig{{ .originName }}(t *testing.T) {
-	src := &{{ .originFullName }}{}
-	dest := &{{ .originFullName }}{}
+	src := NewOrigPtr{{ .originName }}()
+	dest := NewOrigPtr{{ .originName }}()
 	CopyOrig{{ .originName }}(dest, src)
-	assert.Equal(t, &{{ .originFullName }}{}, dest)
+	assert.Equal(t, NewOrigPtr{{ .originName }}(), dest)
 	FillOrigTest{{ .originName }}(src)
 	CopyOrig{{ .originName }}(dest, src)
 	assert.Equal(t, src, dest)
@@ -25,10 +25,10 @@ func TestCopyOrig{{ .originName }}(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrig{{ .originName }}Unknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &{{ .originFullName }}{}
+	dest := NewOrigPtr{{ .originName }}()
 	UnmarshalJSONOrig{{ .originName }}(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &{{ .originFullName }}{}, dest)
+	assert.Equal(t, NewOrigPtr{{ .originName }}(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrig{{ .originName }}(t *testing.T) {
@@ -41,7 +41,7 @@ func TestMarshalAndUnmarshalJSONOrig{{ .originName }}(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &{{ .originFullName }}{}
+			dest := NewOrigPtr{{ .originName }}()
 			UnmarshalJSONOrig{{ .originName }}(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -51,10 +51,10 @@ func TestMarshalAndUnmarshalJSONOrig{{ .originName }}(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrig{{ .originName }}Unknown(t *testing.T) {
-	dest := &{{ .originFullName }}{}
+	dest := NewOrigPtr{{ .originName }}()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrig{{ .originName }}(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &{{ .originFullName }}{}, dest)
+	assert.Equal(t, NewOrigPtr{{ .originName }}(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrig{{ .originName }}(t *testing.T) {
@@ -64,7 +64,7 @@ func TestMarshalAndUnmarshalProtoOrig{{ .originName }}(t *testing.T) {
 			gotSize := MarshalProtoOrig{{ .originName }}(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &{{ .originFullName }}{}
+			dest := NewOrigPtr{{ .originName }}()
 			require.NoError(t, UnmarshalProtoOrig{{ .originName }}(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -84,7 +84,7 @@ func TestMarshalAndUnmarshalProtoViaProtobuf{{ .originName }}(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &{{ .originFullName }}{}
+			dest := NewOrigPtr{{ .originName }}()
 			require.NoError(t, UnmarshalProtoOrig{{ .originName }}(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -93,9 +93,9 @@ func TestMarshalAndUnmarshalProtoViaProtobuf{{ .originName }}(t *testing.T) {
 
 func getEncodingTestValues{{ .originName }}() map[string]*{{ .originFullName }} {
 	return map[string]*{{ .originFullName }}{
-		"empty": &{{ .originFullName }}{},
+		"empty": NewOrigPtr{{ .originName }}(),
 		"fill_test": func() *{{ .originFullName }} {
-			src := &{{ .originFullName }}{}
+			src := NewOrigPtr{{ .originName }}()
 			FillOrigTest{{ .originName }}(src)
 			return src
 		}(), {{ range .fields -}}{{ .GenerateTestValue $.messageStruct }}{{ end }}

internal/cmd/pdatagen/internal/templates/message_test.go.tmpl

@@ -22,8 +22,8 @@ func Test{{ .structName }}_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTest{{ .structName }}(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(new{{ .structName }}(&{{ .originFullName }}{}, sharedState)) })
-	assert.Panics(t, func() { new{{ .structName }}(&{{ .originFullName }}{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(new{{ .structName }}(internal.NewOrigPtr{{ .originName }}(), sharedState)) })
+	assert.Panics(t, func() { new{{ .structName }}(internal.NewOrigPtr{{ .originName }}(), sharedState).MoveTo(dest) })
 }
 
 func Test{{ .structName }}_CopyTo(t *testing.T) {
@@ -36,7 +36,7 @@ func Test{{ .structName }}_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(new{{ .structName }}(&{{ .originFullName }}{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(new{{ .structName }}(internal.NewOrigPtr{{ .originName }}(), sharedState)) })
 }
 
 {{ range .fields }}

pdata/internal/generated_wrapper_attributeunit_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigAttributeUnit(t *testing.T) {
-	src := &otlpprofiles.AttributeUnit{}
-	dest := &otlpprofiles.AttributeUnit{}
+	src := NewOrigPtrAttributeUnit()
+	dest := NewOrigPtrAttributeUnit()
 	CopyOrigAttributeUnit(dest, src)
-	assert.Equal(t, &otlpprofiles.AttributeUnit{}, dest)
+	assert.Equal(t, NewOrigPtrAttributeUnit(), dest)
 	FillOrigTestAttributeUnit(src)
 	CopyOrigAttributeUnit(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigAttributeUnit(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigAttributeUnitUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.AttributeUnit{}
+	dest := NewOrigPtrAttributeUnit()
 	UnmarshalJSONOrigAttributeUnit(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.AttributeUnit{}, dest)
+	assert.Equal(t, NewOrigPtrAttributeUnit(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigAttributeUnit(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigAttributeUnit(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.AttributeUnit{}
+			dest := NewOrigPtrAttributeUnit()
 			UnmarshalJSONOrigAttributeUnit(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigAttributeUnit(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigAttributeUnitUnknown(t *testing.T) {
-	dest := &otlpprofiles.AttributeUnit{}
+	dest := NewOrigPtrAttributeUnit()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigAttributeUnit(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.AttributeUnit{}, dest)
+	assert.Equal(t, NewOrigPtrAttributeUnit(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigAttributeUnit(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigAttributeUnit(t *testing.T) {
 			gotSize := MarshalProtoOrigAttributeUnit(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.AttributeUnit{}
+			dest := NewOrigPtrAttributeUnit()
 			require.NoError(t, UnmarshalProtoOrigAttributeUnit(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufAttributeUnit(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.AttributeUnit{}
+			dest := NewOrigPtrAttributeUnit()
 			require.NoError(t, UnmarshalProtoOrigAttributeUnit(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufAttributeUnit(t *testing.T) {
 
 func getEncodingTestValuesAttributeUnit() map[string]*otlpprofiles.AttributeUnit {
 	return map[string]*otlpprofiles.AttributeUnit{
-		"empty": {},
+		"empty": NewOrigPtrAttributeUnit(),
 		"fill_test": func() *otlpprofiles.AttributeUnit {
-			src := &otlpprofiles.AttributeUnit{}
+			src := NewOrigPtrAttributeUnit()
 			FillOrigTestAttributeUnit(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_entityref.go

@@ -32,9 +32,9 @@ func NewEntityRef(orig *otlpcommon.EntityRef, state *State) EntityRef {
 }
 
 func GenerateTestEntityRef() EntityRef {
-	orig := otlpcommon.EntityRef{}
-	FillOrigTestEntityRef(&orig)
-	return NewEntityRef(&orig, NewState())
+	orig := NewOrigPtrEntityRef()
+	FillOrigTestEntityRef(orig)
+	return NewEntityRef(orig, NewState())
 }
 
 func NewOrigEntityRef() otlpcommon.EntityRef {

pdata/internal/generated_wrapper_entityref_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigEntityRef(t *testing.T) {
-	src := &otlpcommon.EntityRef{}
-	dest := &otlpcommon.EntityRef{}
+	src := NewOrigPtrEntityRef()
+	dest := NewOrigPtrEntityRef()
 	CopyOrigEntityRef(dest, src)
-	assert.Equal(t, &otlpcommon.EntityRef{}, dest)
+	assert.Equal(t, NewOrigPtrEntityRef(), dest)
 	FillOrigTestEntityRef(src)
 	CopyOrigEntityRef(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigEntityRef(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigEntityRefUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcommon.EntityRef{}
+	dest := NewOrigPtrEntityRef()
 	UnmarshalJSONOrigEntityRef(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcommon.EntityRef{}, dest)
+	assert.Equal(t, NewOrigPtrEntityRef(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigEntityRef(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigEntityRef(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcommon.EntityRef{}
+			dest := NewOrigPtrEntityRef()
 			UnmarshalJSONOrigEntityRef(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigEntityRef(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigEntityRefUnknown(t *testing.T) {
-	dest := &otlpcommon.EntityRef{}
+	dest := NewOrigPtrEntityRef()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigEntityRef(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcommon.EntityRef{}, dest)
+	assert.Equal(t, NewOrigPtrEntityRef(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigEntityRef(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigEntityRef(t *testing.T) {
 			gotSize := MarshalProtoOrigEntityRef(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcommon.EntityRef{}
+			dest := NewOrigPtrEntityRef()
 			require.NoError(t, UnmarshalProtoOrigEntityRef(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufEntityRef(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcommon.EntityRef{}
+			dest := NewOrigPtrEntityRef()
 			require.NoError(t, UnmarshalProtoOrigEntityRef(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufEntityRef(t *testing.T) {
 
 func getEncodingTestValuesEntityRef() map[string]*otlpcommon.EntityRef {
 	return map[string]*otlpcommon.EntityRef{
-		"empty": {},
+		"empty": NewOrigPtrEntityRef(),
 		"fill_test": func() *otlpcommon.EntityRef {
-			src := &otlpcommon.EntityRef{}
+			src := NewOrigPtrEntityRef()
 			FillOrigTestEntityRef(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exemplar_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExemplar(t *testing.T) {
-	src := &otlpmetrics.Exemplar{}
-	dest := &otlpmetrics.Exemplar{}
+	src := NewOrigPtrExemplar()
+	dest := NewOrigPtrExemplar()
 	CopyOrigExemplar(dest, src)
-	assert.Equal(t, &otlpmetrics.Exemplar{}, dest)
+	assert.Equal(t, NewOrigPtrExemplar(), dest)
 	FillOrigTestExemplar(src)
 	CopyOrigExemplar(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExemplar(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExemplarUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Exemplar{}
+	dest := NewOrigPtrExemplar()
 	UnmarshalJSONOrigExemplar(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Exemplar{}, dest)
+	assert.Equal(t, NewOrigPtrExemplar(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExemplar(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExemplar(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Exemplar{}
+			dest := NewOrigPtrExemplar()
 			UnmarshalJSONOrigExemplar(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExemplar(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExemplarUnknown(t *testing.T) {
-	dest := &otlpmetrics.Exemplar{}
+	dest := NewOrigPtrExemplar()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExemplar(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Exemplar{}, dest)
+	assert.Equal(t, NewOrigPtrExemplar(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExemplar(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExemplar(t *testing.T) {
 			gotSize := MarshalProtoOrigExemplar(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Exemplar{}
+			dest := NewOrigPtrExemplar()
 			require.NoError(t, UnmarshalProtoOrigExemplar(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExemplar(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Exemplar{}
+			dest := NewOrigPtrExemplar()
 			require.NoError(t, UnmarshalProtoOrigExemplar(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExemplar(t *testing.T) {
 
 func getEncodingTestValuesExemplar() map[string]*otlpmetrics.Exemplar {
 	return map[string]*otlpmetrics.Exemplar{
-		"empty": {},
+		"empty": NewOrigPtrExemplar(),
 		"fill_test": func() *otlpmetrics.Exemplar {
-			src := &otlpmetrics.Exemplar{}
+			src := NewOrigPtrExemplar()
 			FillOrigTestExemplar(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exponentialhistogram_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExponentialHistogram(t *testing.T) {
-	src := &otlpmetrics.ExponentialHistogram{}
-	dest := &otlpmetrics.ExponentialHistogram{}
+	src := NewOrigPtrExponentialHistogram()
+	dest := NewOrigPtrExponentialHistogram()
 	CopyOrigExponentialHistogram(dest, src)
-	assert.Equal(t, &otlpmetrics.ExponentialHistogram{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogram(), dest)
 	FillOrigTestExponentialHistogram(src)
 	CopyOrigExponentialHistogram(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExponentialHistogram(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogramUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.ExponentialHistogram{}
+	dest := NewOrigPtrExponentialHistogram()
 	UnmarshalJSONOrigExponentialHistogram(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.ExponentialHistogram{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogram(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogram(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogram(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.ExponentialHistogram{}
+			dest := NewOrigPtrExponentialHistogram()
 			UnmarshalJSONOrigExponentialHistogram(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogram(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogramUnknown(t *testing.T) {
-	dest := &otlpmetrics.ExponentialHistogram{}
+	dest := NewOrigPtrExponentialHistogram()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExponentialHistogram(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.ExponentialHistogram{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogram(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogram(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExponentialHistogram(t *testing.T) {
 			gotSize := MarshalProtoOrigExponentialHistogram(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.ExponentialHistogram{}
+			dest := NewOrigPtrExponentialHistogram()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogram(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogram(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.ExponentialHistogram{}
+			dest := NewOrigPtrExponentialHistogram()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogram(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogram(t *testing.T) {
 
 func getEncodingTestValuesExponentialHistogram() map[string]*otlpmetrics.ExponentialHistogram {
 	return map[string]*otlpmetrics.ExponentialHistogram{
-		"empty": {},
+		"empty": NewOrigPtrExponentialHistogram(),
 		"fill_test": func() *otlpmetrics.ExponentialHistogram {
-			src := &otlpmetrics.ExponentialHistogram{}
+			src := NewOrigPtrExponentialHistogram()
 			FillOrigTestExponentialHistogram(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exponentialhistogramdatapoint_buckets_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExponentialHistogramDataPoint_Buckets(t *testing.T) {
-	src := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
-	dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+	src := NewOrigPtrExponentialHistogramDataPoint_Buckets()
+	dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 	CopyOrigExponentialHistogramDataPoint_Buckets(dest, src)
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint_Buckets(), dest)
 	FillOrigTestExponentialHistogramDataPoint_Buckets(src)
 	CopyOrigExponentialHistogramDataPoint_Buckets(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExponentialHistogramDataPoint_Buckets(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint_BucketsUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+	dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 	UnmarshalJSONOrigExponentialHistogramDataPoint_Buckets(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint_Buckets(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint_Buckets(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint_Buckets(t *tes
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+			dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 			UnmarshalJSONOrigExponentialHistogramDataPoint_Buckets(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint_Buckets(t *tes
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPoint_BucketsUnknown(t *testing.T) {
-	dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+	dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint_Buckets(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint_Buckets(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPoint_Buckets(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPoint_Buckets(t *te
 			gotSize := MarshalProtoOrigExponentialHistogramDataPoint_Buckets(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+			dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint_Buckets(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogramDataPoint_Bucket
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+			dest := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint_Buckets(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogramDataPoint_Bucket
 
 func getEncodingTestValuesExponentialHistogramDataPoint_Buckets() map[string]*otlpmetrics.ExponentialHistogramDataPoint_Buckets {
 	return map[string]*otlpmetrics.ExponentialHistogramDataPoint_Buckets{
-		"empty": {},
+		"empty": NewOrigPtrExponentialHistogramDataPoint_Buckets(),
 		"fill_test": func() *otlpmetrics.ExponentialHistogramDataPoint_Buckets {
-			src := &otlpmetrics.ExponentialHistogramDataPoint_Buckets{}
+			src := NewOrigPtrExponentialHistogramDataPoint_Buckets()
 			FillOrigTestExponentialHistogramDataPoint_Buckets(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exponentialhistogramdatapoint_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExponentialHistogramDataPoint(t *testing.T) {
-	src := &otlpmetrics.ExponentialHistogramDataPoint{}
-	dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+	src := NewOrigPtrExponentialHistogramDataPoint()
+	dest := NewOrigPtrExponentialHistogramDataPoint()
 	CopyOrigExponentialHistogramDataPoint(dest, src)
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint(), dest)
 	FillOrigTestExponentialHistogramDataPoint(src)
 	CopyOrigExponentialHistogramDataPoint(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExponentialHistogramDataPoint(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPointUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+	dest := NewOrigPtrExponentialHistogramDataPoint()
 	UnmarshalJSONOrigExponentialHistogramDataPoint(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint(t *testing.T)
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+			dest := NewOrigPtrExponentialHistogramDataPoint()
 			UnmarshalJSONOrigExponentialHistogramDataPoint(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExponentialHistogramDataPoint(t *testing.T)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPointUnknown(t *testing.T) {
-	dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+	dest := NewOrigPtrExponentialHistogramDataPoint()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.ExponentialHistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrExponentialHistogramDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPoint(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExponentialHistogramDataPoint(t *testing.T)
 			gotSize := MarshalProtoOrigExponentialHistogramDataPoint(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+			dest := NewOrigPtrExponentialHistogramDataPoint()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogramDataPoint(t *tes
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.ExponentialHistogramDataPoint{}
+			dest := NewOrigPtrExponentialHistogramDataPoint()
 			require.NoError(t, UnmarshalProtoOrigExponentialHistogramDataPoint(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExponentialHistogramDataPoint(t *tes
 
 func getEncodingTestValuesExponentialHistogramDataPoint() map[string]*otlpmetrics.ExponentialHistogramDataPoint {
 	return map[string]*otlpmetrics.ExponentialHistogramDataPoint{
-		"empty": {},
+		"empty": NewOrigPtrExponentialHistogramDataPoint(),
 		"fill_test": func() *otlpmetrics.ExponentialHistogramDataPoint {
-			src := &otlpmetrics.ExponentialHistogramDataPoint{}
+			src := NewOrigPtrExponentialHistogramDataPoint()
 			FillOrigTestExponentialHistogramDataPoint(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportlogspartialsuccess_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportLogsPartialSuccess(t *testing.T) {
-	src := &otlpcollectorlogs.ExportLogsPartialSuccess{}
-	dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+	src := NewOrigPtrExportLogsPartialSuccess()
+	dest := NewOrigPtrExportLogsPartialSuccess()
 	CopyOrigExportLogsPartialSuccess(dest, src)
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsPartialSuccess(), dest)
 	FillOrigTestExportLogsPartialSuccess(src)
 	CopyOrigExportLogsPartialSuccess(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportLogsPartialSuccess(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportLogsPartialSuccessUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+	dest := NewOrigPtrExportLogsPartialSuccess()
 	UnmarshalJSONOrigExportLogsPartialSuccess(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportLogsPartialSuccess(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsPartialSuccess(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+			dest := NewOrigPtrExportLogsPartialSuccess()
 			UnmarshalJSONOrigExportLogsPartialSuccess(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsPartialSuccess(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsPartialSuccessUnknown(t *testing.T) {
-	dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+	dest := NewOrigPtrExportLogsPartialSuccess()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportLogsPartialSuccess(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsPartialSuccess(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportLogsPartialSuccess(t *testing.T) {
 			gotSize := MarshalProtoOrigExportLogsPartialSuccess(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+			dest := NewOrigPtrExportLogsPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportLogsPartialSuccess(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsPartialSuccess(t *testing.
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+			dest := NewOrigPtrExportLogsPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportLogsPartialSuccess(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsPartialSuccess(t *testing.
 
 func getEncodingTestValuesExportLogsPartialSuccess() map[string]*otlpcollectorlogs.ExportLogsPartialSuccess {
 	return map[string]*otlpcollectorlogs.ExportLogsPartialSuccess{
-		"empty": {},
+		"empty": NewOrigPtrExportLogsPartialSuccess(),
 		"fill_test": func() *otlpcollectorlogs.ExportLogsPartialSuccess {
-			src := &otlpcollectorlogs.ExportLogsPartialSuccess{}
+			src := NewOrigPtrExportLogsPartialSuccess()
 			FillOrigTestExportLogsPartialSuccess(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportlogsservicerequest.go

@@ -32,9 +32,9 @@ func NewLogs(orig *otlpcollectorlogs.ExportLogsServiceRequest, state *State) Log
 }
 
 func GenerateTestLogs() Logs {
-	orig := otlpcollectorlogs.ExportLogsServiceRequest{}
-	FillOrigTestExportLogsServiceRequest(&orig)
-	return NewLogs(&orig, NewState())
+	orig := NewOrigPtrExportLogsServiceRequest()
+	FillOrigTestExportLogsServiceRequest(orig)
+	return NewLogs(orig, NewState())
 }
 
 func NewOrigExportLogsServiceRequest() otlpcollectorlogs.ExportLogsServiceRequest {

pdata/internal/generated_wrapper_exportlogsservicerequest_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportLogsServiceRequest(t *testing.T) {
-	src := &otlpcollectorlogs.ExportLogsServiceRequest{}
-	dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+	src := NewOrigPtrExportLogsServiceRequest()
+	dest := NewOrigPtrExportLogsServiceRequest()
 	CopyOrigExportLogsServiceRequest(dest, src)
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceRequest(), dest)
 	FillOrigTestExportLogsServiceRequest(src)
 	CopyOrigExportLogsServiceRequest(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportLogsServiceRequest(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportLogsServiceRequestUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+	dest := NewOrigPtrExportLogsServiceRequest()
 	UnmarshalJSONOrigExportLogsServiceRequest(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportLogsServiceRequest(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsServiceRequest(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+			dest := NewOrigPtrExportLogsServiceRequest()
 			UnmarshalJSONOrigExportLogsServiceRequest(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsServiceRequest(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsServiceRequestUnknown(t *testing.T) {
-	dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+	dest := NewOrigPtrExportLogsServiceRequest()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportLogsServiceRequest(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsServiceRequest(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportLogsServiceRequest(t *testing.T) {
 			gotSize := MarshalProtoOrigExportLogsServiceRequest(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+			dest := NewOrigPtrExportLogsServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportLogsServiceRequest(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsServiceRequest(t *testing.
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorlogs.ExportLogsServiceRequest{}
+			dest := NewOrigPtrExportLogsServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportLogsServiceRequest(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsServiceRequest(t *testing.
 
 func getEncodingTestValuesExportLogsServiceRequest() map[string]*otlpcollectorlogs.ExportLogsServiceRequest {
 	return map[string]*otlpcollectorlogs.ExportLogsServiceRequest{
-		"empty": {},
+		"empty": NewOrigPtrExportLogsServiceRequest(),
 		"fill_test": func() *otlpcollectorlogs.ExportLogsServiceRequest {
-			src := &otlpcollectorlogs.ExportLogsServiceRequest{}
+			src := NewOrigPtrExportLogsServiceRequest()
 			FillOrigTestExportLogsServiceRequest(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportlogsserviceresponse_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportLogsServiceResponse(t *testing.T) {
-	src := &otlpcollectorlogs.ExportLogsServiceResponse{}
-	dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+	src := NewOrigPtrExportLogsServiceResponse()
+	dest := NewOrigPtrExportLogsServiceResponse()
 	CopyOrigExportLogsServiceResponse(dest, src)
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceResponse(), dest)
 	FillOrigTestExportLogsServiceResponse(src)
 	CopyOrigExportLogsServiceResponse(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportLogsServiceResponse(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportLogsServiceResponseUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+	dest := NewOrigPtrExportLogsServiceResponse()
 	UnmarshalJSONOrigExportLogsServiceResponse(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportLogsServiceResponse(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsServiceResponse(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+			dest := NewOrigPtrExportLogsServiceResponse()
 			UnmarshalJSONOrigExportLogsServiceResponse(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportLogsServiceResponse(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsServiceResponseUnknown(t *testing.T) {
-	dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+	dest := NewOrigPtrExportLogsServiceResponse()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportLogsServiceResponse(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorlogs.ExportLogsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportLogsServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportLogsServiceResponse(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportLogsServiceResponse(t *testing.T) {
 			gotSize := MarshalProtoOrigExportLogsServiceResponse(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+			dest := NewOrigPtrExportLogsServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportLogsServiceResponse(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsServiceResponse(t *testing
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorlogs.ExportLogsServiceResponse{}
+			dest := NewOrigPtrExportLogsServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportLogsServiceResponse(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportLogsServiceResponse(t *testing
 
 func getEncodingTestValuesExportLogsServiceResponse() map[string]*otlpcollectorlogs.ExportLogsServiceResponse {
 	return map[string]*otlpcollectorlogs.ExportLogsServiceResponse{
-		"empty": {},
+		"empty": NewOrigPtrExportLogsServiceResponse(),
 		"fill_test": func() *otlpcollectorlogs.ExportLogsServiceResponse {
-			src := &otlpcollectorlogs.ExportLogsServiceResponse{}
+			src := NewOrigPtrExportLogsServiceResponse()
 			FillOrigTestExportLogsServiceResponse(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportmetricspartialsuccess_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportMetricsPartialSuccess(t *testing.T) {
-	src := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
-	dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+	src := NewOrigPtrExportMetricsPartialSuccess()
+	dest := NewOrigPtrExportMetricsPartialSuccess()
 	CopyOrigExportMetricsPartialSuccess(dest, src)
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsPartialSuccess(), dest)
 	FillOrigTestExportMetricsPartialSuccess(src)
 	CopyOrigExportMetricsPartialSuccess(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportMetricsPartialSuccess(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportMetricsPartialSuccessUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+	dest := NewOrigPtrExportMetricsPartialSuccess()
 	UnmarshalJSONOrigExportMetricsPartialSuccess(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportMetricsPartialSuccess(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsPartialSuccess(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+			dest := NewOrigPtrExportMetricsPartialSuccess()
 			UnmarshalJSONOrigExportMetricsPartialSuccess(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsPartialSuccess(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsPartialSuccessUnknown(t *testing.T) {
-	dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+	dest := NewOrigPtrExportMetricsPartialSuccess()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportMetricsPartialSuccess(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsPartialSuccess(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportMetricsPartialSuccess(t *testing.T) {
 			gotSize := MarshalProtoOrigExportMetricsPartialSuccess(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+			dest := NewOrigPtrExportMetricsPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsPartialSuccess(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsPartialSuccess(t *testi
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+			dest := NewOrigPtrExportMetricsPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsPartialSuccess(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsPartialSuccess(t *testi
 
 func getEncodingTestValuesExportMetricsPartialSuccess() map[string]*otlpcollectormetrics.ExportMetricsPartialSuccess {
 	return map[string]*otlpcollectormetrics.ExportMetricsPartialSuccess{
-		"empty": {},
+		"empty": NewOrigPtrExportMetricsPartialSuccess(),
 		"fill_test": func() *otlpcollectormetrics.ExportMetricsPartialSuccess {
-			src := &otlpcollectormetrics.ExportMetricsPartialSuccess{}
+			src := NewOrigPtrExportMetricsPartialSuccess()
 			FillOrigTestExportMetricsPartialSuccess(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportmetricsservicerequest.go

@@ -32,9 +32,9 @@ func NewMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest, state *S
 }
 
 func GenerateTestMetrics() Metrics {
-	orig := otlpcollectormetrics.ExportMetricsServiceRequest{}
-	FillOrigTestExportMetricsServiceRequest(&orig)
-	return NewMetrics(&orig, NewState())
+	orig := NewOrigPtrExportMetricsServiceRequest()
+	FillOrigTestExportMetricsServiceRequest(orig)
+	return NewMetrics(orig, NewState())
 }
 
 func NewOrigExportMetricsServiceRequest() otlpcollectormetrics.ExportMetricsServiceRequest {

pdata/internal/generated_wrapper_exportmetricsservicerequest_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportMetricsServiceRequest(t *testing.T) {
-	src := &otlpcollectormetrics.ExportMetricsServiceRequest{}
-	dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+	src := NewOrigPtrExportMetricsServiceRequest()
+	dest := NewOrigPtrExportMetricsServiceRequest()
 	CopyOrigExportMetricsServiceRequest(dest, src)
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceRequest(), dest)
 	FillOrigTestExportMetricsServiceRequest(src)
 	CopyOrigExportMetricsServiceRequest(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportMetricsServiceRequest(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceRequestUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+	dest := NewOrigPtrExportMetricsServiceRequest()
 	UnmarshalJSONOrigExportMetricsServiceRequest(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceRequest(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceRequest(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+			dest := NewOrigPtrExportMetricsServiceRequest()
 			UnmarshalJSONOrigExportMetricsServiceRequest(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceRequest(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceRequestUnknown(t *testing.T) {
-	dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+	dest := NewOrigPtrExportMetricsServiceRequest()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportMetricsServiceRequest(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceRequest(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceRequest(t *testing.T) {
 			gotSize := MarshalProtoOrigExportMetricsServiceRequest(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+			dest := NewOrigPtrExportMetricsServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsServiceRequest(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsServiceRequest(t *testi
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+			dest := NewOrigPtrExportMetricsServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsServiceRequest(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsServiceRequest(t *testi
 
 func getEncodingTestValuesExportMetricsServiceRequest() map[string]*otlpcollectormetrics.ExportMetricsServiceRequest {
 	return map[string]*otlpcollectormetrics.ExportMetricsServiceRequest{
-		"empty": {},
+		"empty": NewOrigPtrExportMetricsServiceRequest(),
 		"fill_test": func() *otlpcollectormetrics.ExportMetricsServiceRequest {
-			src := &otlpcollectormetrics.ExportMetricsServiceRequest{}
+			src := NewOrigPtrExportMetricsServiceRequest()
 			FillOrigTestExportMetricsServiceRequest(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportmetricsserviceresponse_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportMetricsServiceResponse(t *testing.T) {
-	src := &otlpcollectormetrics.ExportMetricsServiceResponse{}
-	dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+	src := NewOrigPtrExportMetricsServiceResponse()
+	dest := NewOrigPtrExportMetricsServiceResponse()
 	CopyOrigExportMetricsServiceResponse(dest, src)
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceResponse(), dest)
 	FillOrigTestExportMetricsServiceResponse(src)
 	CopyOrigExportMetricsServiceResponse(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportMetricsServiceResponse(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceResponseUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+	dest := NewOrigPtrExportMetricsServiceResponse()
 	UnmarshalJSONOrigExportMetricsServiceResponse(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceResponse(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceResponse(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+			dest := NewOrigPtrExportMetricsServiceResponse()
 			UnmarshalJSONOrigExportMetricsServiceResponse(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportMetricsServiceResponse(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceResponseUnknown(t *testing.T) {
-	dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+	dest := NewOrigPtrExportMetricsServiceResponse()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportMetricsServiceResponse(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectormetrics.ExportMetricsServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportMetricsServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceResponse(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportMetricsServiceResponse(t *testing.T)
 			gotSize := MarshalProtoOrigExportMetricsServiceResponse(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+			dest := NewOrigPtrExportMetricsServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsServiceResponse(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsServiceResponse(t *test
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+			dest := NewOrigPtrExportMetricsServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportMetricsServiceResponse(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportMetricsServiceResponse(t *test
 
 func getEncodingTestValuesExportMetricsServiceResponse() map[string]*otlpcollectormetrics.ExportMetricsServiceResponse {
 	return map[string]*otlpcollectormetrics.ExportMetricsServiceResponse{
-		"empty": {},
+		"empty": NewOrigPtrExportMetricsServiceResponse(),
 		"fill_test": func() *otlpcollectormetrics.ExportMetricsServiceResponse {
-			src := &otlpcollectormetrics.ExportMetricsServiceResponse{}
+			src := NewOrigPtrExportMetricsServiceResponse()
 			FillOrigTestExportMetricsServiceResponse(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportprofilespartialsuccess_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportProfilesPartialSuccess(t *testing.T) {
-	src := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
-	dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+	src := NewOrigPtrExportProfilesPartialSuccess()
+	dest := NewOrigPtrExportProfilesPartialSuccess()
 	CopyOrigExportProfilesPartialSuccess(dest, src)
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesPartialSuccess(), dest)
 	FillOrigTestExportProfilesPartialSuccess(src)
 	CopyOrigExportProfilesPartialSuccess(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportProfilesPartialSuccess(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportProfilesPartialSuccessUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+	dest := NewOrigPtrExportProfilesPartialSuccess()
 	UnmarshalJSONOrigExportProfilesPartialSuccess(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportProfilesPartialSuccess(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesPartialSuccess(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+			dest := NewOrigPtrExportProfilesPartialSuccess()
 			UnmarshalJSONOrigExportProfilesPartialSuccess(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesPartialSuccess(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesPartialSuccessUnknown(t *testing.T) {
-	dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+	dest := NewOrigPtrExportProfilesPartialSuccess()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportProfilesPartialSuccess(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesPartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesPartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesPartialSuccess(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportProfilesPartialSuccess(t *testing.T)
 			gotSize := MarshalProtoOrigExportProfilesPartialSuccess(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+			dest := NewOrigPtrExportProfilesPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesPartialSuccess(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesPartialSuccess(t *test
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+			dest := NewOrigPtrExportProfilesPartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesPartialSuccess(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesPartialSuccess(t *test
 
 func getEncodingTestValuesExportProfilesPartialSuccess() map[string]*otlpcollectorprofiles.ExportProfilesPartialSuccess {
 	return map[string]*otlpcollectorprofiles.ExportProfilesPartialSuccess{
-		"empty": {},
+		"empty": NewOrigPtrExportProfilesPartialSuccess(),
 		"fill_test": func() *otlpcollectorprofiles.ExportProfilesPartialSuccess {
-			src := &otlpcollectorprofiles.ExportProfilesPartialSuccess{}
+			src := NewOrigPtrExportProfilesPartialSuccess()
 			FillOrigTestExportProfilesPartialSuccess(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportprofilesservicerequest.go

@@ -32,9 +32,9 @@ func NewProfiles(orig *otlpcollectorprofiles.ExportProfilesServiceRequest, state
 }
 
 func GenerateTestProfiles() Profiles {
-	orig := otlpcollectorprofiles.ExportProfilesServiceRequest{}
-	FillOrigTestExportProfilesServiceRequest(&orig)
-	return NewProfiles(&orig, NewState())
+	orig := NewOrigPtrExportProfilesServiceRequest()
+	FillOrigTestExportProfilesServiceRequest(orig)
+	return NewProfiles(orig, NewState())
 }
 
 func NewOrigExportProfilesServiceRequest() otlpcollectorprofiles.ExportProfilesServiceRequest {

pdata/internal/generated_wrapper_exportprofilesservicerequest_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportProfilesServiceRequest(t *testing.T) {
-	src := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
-	dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+	src := NewOrigPtrExportProfilesServiceRequest()
+	dest := NewOrigPtrExportProfilesServiceRequest()
 	CopyOrigExportProfilesServiceRequest(dest, src)
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceRequest(), dest)
 	FillOrigTestExportProfilesServiceRequest(src)
 	CopyOrigExportProfilesServiceRequest(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportProfilesServiceRequest(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceRequestUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+	dest := NewOrigPtrExportProfilesServiceRequest()
 	UnmarshalJSONOrigExportProfilesServiceRequest(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceRequest(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceRequest(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+			dest := NewOrigPtrExportProfilesServiceRequest()
 			UnmarshalJSONOrigExportProfilesServiceRequest(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceRequest(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceRequestUnknown(t *testing.T) {
-	dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+	dest := NewOrigPtrExportProfilesServiceRequest()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportProfilesServiceRequest(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceRequest(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceRequest(t *testing.T)
 			gotSize := MarshalProtoOrigExportProfilesServiceRequest(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+			dest := NewOrigPtrExportProfilesServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesServiceRequest(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesServiceRequest(t *test
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+			dest := NewOrigPtrExportProfilesServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesServiceRequest(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesServiceRequest(t *test
 
 func getEncodingTestValuesExportProfilesServiceRequest() map[string]*otlpcollectorprofiles.ExportProfilesServiceRequest {
 	return map[string]*otlpcollectorprofiles.ExportProfilesServiceRequest{
-		"empty": {},
+		"empty": NewOrigPtrExportProfilesServiceRequest(),
 		"fill_test": func() *otlpcollectorprofiles.ExportProfilesServiceRequest {
-			src := &otlpcollectorprofiles.ExportProfilesServiceRequest{}
+			src := NewOrigPtrExportProfilesServiceRequest()
 			FillOrigTestExportProfilesServiceRequest(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exportprofilesserviceresponse_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportProfilesServiceResponse(t *testing.T) {
-	src := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
-	dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+	src := NewOrigPtrExportProfilesServiceResponse()
+	dest := NewOrigPtrExportProfilesServiceResponse()
 	CopyOrigExportProfilesServiceResponse(dest, src)
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceResponse(), dest)
 	FillOrigTestExportProfilesServiceResponse(src)
 	CopyOrigExportProfilesServiceResponse(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportProfilesServiceResponse(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceResponseUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+	dest := NewOrigPtrExportProfilesServiceResponse()
 	UnmarshalJSONOrigExportProfilesServiceResponse(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceResponse(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceResponse(t *testing.T)
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+			dest := NewOrigPtrExportProfilesServiceResponse()
 			UnmarshalJSONOrigExportProfilesServiceResponse(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportProfilesServiceResponse(t *testing.T)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceResponseUnknown(t *testing.T) {
-	dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+	dest := NewOrigPtrExportProfilesServiceResponse()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportProfilesServiceResponse(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectorprofiles.ExportProfilesServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportProfilesServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceResponse(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportProfilesServiceResponse(t *testing.T)
 			gotSize := MarshalProtoOrigExportProfilesServiceResponse(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+			dest := NewOrigPtrExportProfilesServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesServiceResponse(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesServiceResponse(t *tes
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+			dest := NewOrigPtrExportProfilesServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportProfilesServiceResponse(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportProfilesServiceResponse(t *tes
 
 func getEncodingTestValuesExportProfilesServiceResponse() map[string]*otlpcollectorprofiles.ExportProfilesServiceResponse {
 	return map[string]*otlpcollectorprofiles.ExportProfilesServiceResponse{
-		"empty": {},
+		"empty": NewOrigPtrExportProfilesServiceResponse(),
 		"fill_test": func() *otlpcollectorprofiles.ExportProfilesServiceResponse {
-			src := &otlpcollectorprofiles.ExportProfilesServiceResponse{}
+			src := NewOrigPtrExportProfilesServiceResponse()
 			FillOrigTestExportProfilesServiceResponse(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exporttracepartialsuccess_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportTracePartialSuccess(t *testing.T) {
-	src := &otlpcollectortrace.ExportTracePartialSuccess{}
-	dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+	src := NewOrigPtrExportTracePartialSuccess()
+	dest := NewOrigPtrExportTracePartialSuccess()
 	CopyOrigExportTracePartialSuccess(dest, src)
-	assert.Equal(t, &otlpcollectortrace.ExportTracePartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportTracePartialSuccess(), dest)
 	FillOrigTestExportTracePartialSuccess(src)
 	CopyOrigExportTracePartialSuccess(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportTracePartialSuccess(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportTracePartialSuccessUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+	dest := NewOrigPtrExportTracePartialSuccess()
 	UnmarshalJSONOrigExportTracePartialSuccess(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectortrace.ExportTracePartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportTracePartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportTracePartialSuccess(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportTracePartialSuccess(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+			dest := NewOrigPtrExportTracePartialSuccess()
 			UnmarshalJSONOrigExportTracePartialSuccess(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportTracePartialSuccess(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTracePartialSuccessUnknown(t *testing.T) {
-	dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+	dest := NewOrigPtrExportTracePartialSuccess()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportTracePartialSuccess(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectortrace.ExportTracePartialSuccess{}, dest)
+	assert.Equal(t, NewOrigPtrExportTracePartialSuccess(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTracePartialSuccess(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportTracePartialSuccess(t *testing.T) {
 			gotSize := MarshalProtoOrigExportTracePartialSuccess(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+			dest := NewOrigPtrExportTracePartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportTracePartialSuccess(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTracePartialSuccess(t *testing
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectortrace.ExportTracePartialSuccess{}
+			dest := NewOrigPtrExportTracePartialSuccess()
 			require.NoError(t, UnmarshalProtoOrigExportTracePartialSuccess(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTracePartialSuccess(t *testing
 
 func getEncodingTestValuesExportTracePartialSuccess() map[string]*otlpcollectortrace.ExportTracePartialSuccess {
 	return map[string]*otlpcollectortrace.ExportTracePartialSuccess{
-		"empty": {},
+		"empty": NewOrigPtrExportTracePartialSuccess(),
 		"fill_test": func() *otlpcollectortrace.ExportTracePartialSuccess {
-			src := &otlpcollectortrace.ExportTracePartialSuccess{}
+			src := NewOrigPtrExportTracePartialSuccess()
 			FillOrigTestExportTracePartialSuccess(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exporttraceservicerequest.go

@@ -32,9 +32,9 @@ func NewTraces(orig *otlpcollectortrace.ExportTraceServiceRequest, state *State)
 }
 
 func GenerateTestTraces() Traces {
-	orig := otlpcollectortrace.ExportTraceServiceRequest{}
-	FillOrigTestExportTraceServiceRequest(&orig)
-	return NewTraces(&orig, NewState())
+	orig := NewOrigPtrExportTraceServiceRequest()
+	FillOrigTestExportTraceServiceRequest(orig)
+	return NewTraces(orig, NewState())
 }
 
 func NewOrigExportTraceServiceRequest() otlpcollectortrace.ExportTraceServiceRequest {

pdata/internal/generated_wrapper_exporttraceservicerequest_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportTraceServiceRequest(t *testing.T) {
-	src := &otlpcollectortrace.ExportTraceServiceRequest{}
-	dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+	src := NewOrigPtrExportTraceServiceRequest()
+	dest := NewOrigPtrExportTraceServiceRequest()
 	CopyOrigExportTraceServiceRequest(dest, src)
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceRequest(), dest)
 	FillOrigTestExportTraceServiceRequest(src)
 	CopyOrigExportTraceServiceRequest(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportTraceServiceRequest(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportTraceServiceRequestUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+	dest := NewOrigPtrExportTraceServiceRequest()
 	UnmarshalJSONOrigExportTraceServiceRequest(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportTraceServiceRequest(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportTraceServiceRequest(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+			dest := NewOrigPtrExportTraceServiceRequest()
 			UnmarshalJSONOrigExportTraceServiceRequest(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportTraceServiceRequest(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTraceServiceRequestUnknown(t *testing.T) {
-	dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+	dest := NewOrigPtrExportTraceServiceRequest()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportTraceServiceRequest(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceRequest{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceRequest(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTraceServiceRequest(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportTraceServiceRequest(t *testing.T) {
 			gotSize := MarshalProtoOrigExportTraceServiceRequest(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+			dest := NewOrigPtrExportTraceServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportTraceServiceRequest(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTraceServiceRequest(t *testing
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectortrace.ExportTraceServiceRequest{}
+			dest := NewOrigPtrExportTraceServiceRequest()
 			require.NoError(t, UnmarshalProtoOrigExportTraceServiceRequest(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTraceServiceRequest(t *testing
 
 func getEncodingTestValuesExportTraceServiceRequest() map[string]*otlpcollectortrace.ExportTraceServiceRequest {
 	return map[string]*otlpcollectortrace.ExportTraceServiceRequest{
-		"empty": {},
+		"empty": NewOrigPtrExportTraceServiceRequest(),
 		"fill_test": func() *otlpcollectortrace.ExportTraceServiceRequest {
-			src := &otlpcollectortrace.ExportTraceServiceRequest{}
+			src := NewOrigPtrExportTraceServiceRequest()
 			FillOrigTestExportTraceServiceRequest(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_exporttraceserviceresponse_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigExportTraceServiceResponse(t *testing.T) {
-	src := &otlpcollectortrace.ExportTraceServiceResponse{}
-	dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+	src := NewOrigPtrExportTraceServiceResponse()
+	dest := NewOrigPtrExportTraceServiceResponse()
 	CopyOrigExportTraceServiceResponse(dest, src)
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceResponse(), dest)
 	FillOrigTestExportTraceServiceResponse(src)
 	CopyOrigExportTraceServiceResponse(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigExportTraceServiceResponse(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigExportTraceServiceResponseUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+	dest := NewOrigPtrExportTraceServiceResponse()
 	UnmarshalJSONOrigExportTraceServiceResponse(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigExportTraceServiceResponse(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigExportTraceServiceResponse(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+			dest := NewOrigPtrExportTraceServiceResponse()
 			UnmarshalJSONOrigExportTraceServiceResponse(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigExportTraceServiceResponse(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTraceServiceResponseUnknown(t *testing.T) {
-	dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+	dest := NewOrigPtrExportTraceServiceResponse()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigExportTraceServiceResponse(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcollectortrace.ExportTraceServiceResponse{}, dest)
+	assert.Equal(t, NewOrigPtrExportTraceServiceResponse(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigExportTraceServiceResponse(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigExportTraceServiceResponse(t *testing.T) {
 			gotSize := MarshalProtoOrigExportTraceServiceResponse(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+			dest := NewOrigPtrExportTraceServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportTraceServiceResponse(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTraceServiceResponse(t *testin
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcollectortrace.ExportTraceServiceResponse{}
+			dest := NewOrigPtrExportTraceServiceResponse()
 			require.NoError(t, UnmarshalProtoOrigExportTraceServiceResponse(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufExportTraceServiceResponse(t *testin
 
 func getEncodingTestValuesExportTraceServiceResponse() map[string]*otlpcollectortrace.ExportTraceServiceResponse {
 	return map[string]*otlpcollectortrace.ExportTraceServiceResponse{
-		"empty": {},
+		"empty": NewOrigPtrExportTraceServiceResponse(),
 		"fill_test": func() *otlpcollectortrace.ExportTraceServiceResponse {
-			src := &otlpcollectortrace.ExportTraceServiceResponse{}
+			src := NewOrigPtrExportTraceServiceResponse()
 			FillOrigTestExportTraceServiceResponse(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_function_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigFunction(t *testing.T) {
-	src := &otlpprofiles.Function{}
-	dest := &otlpprofiles.Function{}
+	src := NewOrigPtrFunction()
+	dest := NewOrigPtrFunction()
 	CopyOrigFunction(dest, src)
-	assert.Equal(t, &otlpprofiles.Function{}, dest)
+	assert.Equal(t, NewOrigPtrFunction(), dest)
 	FillOrigTestFunction(src)
 	CopyOrigFunction(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigFunction(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigFunctionUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Function{}
+	dest := NewOrigPtrFunction()
 	UnmarshalJSONOrigFunction(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Function{}, dest)
+	assert.Equal(t, NewOrigPtrFunction(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigFunction(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigFunction(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Function{}
+			dest := NewOrigPtrFunction()
 			UnmarshalJSONOrigFunction(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigFunction(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigFunctionUnknown(t *testing.T) {
-	dest := &otlpprofiles.Function{}
+	dest := NewOrigPtrFunction()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigFunction(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Function{}, dest)
+	assert.Equal(t, NewOrigPtrFunction(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigFunction(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigFunction(t *testing.T) {
 			gotSize := MarshalProtoOrigFunction(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Function{}
+			dest := NewOrigPtrFunction()
 			require.NoError(t, UnmarshalProtoOrigFunction(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufFunction(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Function{}
+			dest := NewOrigPtrFunction()
 			require.NoError(t, UnmarshalProtoOrigFunction(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufFunction(t *testing.T) {
 
 func getEncodingTestValuesFunction() map[string]*otlpprofiles.Function {
 	return map[string]*otlpprofiles.Function{
-		"empty": {},
+		"empty": NewOrigPtrFunction(),
 		"fill_test": func() *otlpprofiles.Function {
-			src := &otlpprofiles.Function{}
+			src := NewOrigPtrFunction()
 			FillOrigTestFunction(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_gauge_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigGauge(t *testing.T) {
-	src := &otlpmetrics.Gauge{}
-	dest := &otlpmetrics.Gauge{}
+	src := NewOrigPtrGauge()
+	dest := NewOrigPtrGauge()
 	CopyOrigGauge(dest, src)
-	assert.Equal(t, &otlpmetrics.Gauge{}, dest)
+	assert.Equal(t, NewOrigPtrGauge(), dest)
 	FillOrigTestGauge(src)
 	CopyOrigGauge(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigGauge(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigGaugeUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Gauge{}
+	dest := NewOrigPtrGauge()
 	UnmarshalJSONOrigGauge(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Gauge{}, dest)
+	assert.Equal(t, NewOrigPtrGauge(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigGauge(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigGauge(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Gauge{}
+			dest := NewOrigPtrGauge()
 			UnmarshalJSONOrigGauge(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigGauge(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigGaugeUnknown(t *testing.T) {
-	dest := &otlpmetrics.Gauge{}
+	dest := NewOrigPtrGauge()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigGauge(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Gauge{}, dest)
+	assert.Equal(t, NewOrigPtrGauge(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigGauge(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigGauge(t *testing.T) {
 			gotSize := MarshalProtoOrigGauge(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Gauge{}
+			dest := NewOrigPtrGauge()
 			require.NoError(t, UnmarshalProtoOrigGauge(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufGauge(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Gauge{}
+			dest := NewOrigPtrGauge()
 			require.NoError(t, UnmarshalProtoOrigGauge(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufGauge(t *testing.T) {
 
 func getEncodingTestValuesGauge() map[string]*otlpmetrics.Gauge {
 	return map[string]*otlpmetrics.Gauge{
-		"empty": {},
+		"empty": NewOrigPtrGauge(),
 		"fill_test": func() *otlpmetrics.Gauge {
-			src := &otlpmetrics.Gauge{}
+			src := NewOrigPtrGauge()
 			FillOrigTestGauge(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_histogram_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigHistogram(t *testing.T) {
-	src := &otlpmetrics.Histogram{}
-	dest := &otlpmetrics.Histogram{}
+	src := NewOrigPtrHistogram()
+	dest := NewOrigPtrHistogram()
 	CopyOrigHistogram(dest, src)
-	assert.Equal(t, &otlpmetrics.Histogram{}, dest)
+	assert.Equal(t, NewOrigPtrHistogram(), dest)
 	FillOrigTestHistogram(src)
 	CopyOrigHistogram(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigHistogram(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigHistogramUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Histogram{}
+	dest := NewOrigPtrHistogram()
 	UnmarshalJSONOrigHistogram(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Histogram{}, dest)
+	assert.Equal(t, NewOrigPtrHistogram(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigHistogram(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigHistogram(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Histogram{}
+			dest := NewOrigPtrHistogram()
 			UnmarshalJSONOrigHistogram(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigHistogram(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigHistogramUnknown(t *testing.T) {
-	dest := &otlpmetrics.Histogram{}
+	dest := NewOrigPtrHistogram()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigHistogram(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Histogram{}, dest)
+	assert.Equal(t, NewOrigPtrHistogram(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigHistogram(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigHistogram(t *testing.T) {
 			gotSize := MarshalProtoOrigHistogram(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Histogram{}
+			dest := NewOrigPtrHistogram()
 			require.NoError(t, UnmarshalProtoOrigHistogram(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufHistogram(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Histogram{}
+			dest := NewOrigPtrHistogram()
 			require.NoError(t, UnmarshalProtoOrigHistogram(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufHistogram(t *testing.T) {
 
 func getEncodingTestValuesHistogram() map[string]*otlpmetrics.Histogram {
 	return map[string]*otlpmetrics.Histogram{
-		"empty": {},
+		"empty": NewOrigPtrHistogram(),
 		"fill_test": func() *otlpmetrics.Histogram {
-			src := &otlpmetrics.Histogram{}
+			src := NewOrigPtrHistogram()
 			FillOrigTestHistogram(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_histogramdatapoint_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigHistogramDataPoint(t *testing.T) {
-	src := &otlpmetrics.HistogramDataPoint{}
-	dest := &otlpmetrics.HistogramDataPoint{}
+	src := NewOrigPtrHistogramDataPoint()
+	dest := NewOrigPtrHistogramDataPoint()
 	CopyOrigHistogramDataPoint(dest, src)
-	assert.Equal(t, &otlpmetrics.HistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrHistogramDataPoint(), dest)
 	FillOrigTestHistogramDataPoint(src)
 	CopyOrigHistogramDataPoint(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigHistogramDataPoint(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigHistogramDataPointUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.HistogramDataPoint{}
+	dest := NewOrigPtrHistogramDataPoint()
 	UnmarshalJSONOrigHistogramDataPoint(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.HistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrHistogramDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigHistogramDataPoint(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigHistogramDataPoint(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.HistogramDataPoint{}
+			dest := NewOrigPtrHistogramDataPoint()
 			UnmarshalJSONOrigHistogramDataPoint(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigHistogramDataPoint(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigHistogramDataPointUnknown(t *testing.T) {
-	dest := &otlpmetrics.HistogramDataPoint{}
+	dest := NewOrigPtrHistogramDataPoint()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigHistogramDataPoint(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.HistogramDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrHistogramDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigHistogramDataPoint(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigHistogramDataPoint(t *testing.T) {
 			gotSize := MarshalProtoOrigHistogramDataPoint(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.HistogramDataPoint{}
+			dest := NewOrigPtrHistogramDataPoint()
 			require.NoError(t, UnmarshalProtoOrigHistogramDataPoint(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufHistogramDataPoint(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.HistogramDataPoint{}
+			dest := NewOrigPtrHistogramDataPoint()
 			require.NoError(t, UnmarshalProtoOrigHistogramDataPoint(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufHistogramDataPoint(t *testing.T) {
 
 func getEncodingTestValuesHistogramDataPoint() map[string]*otlpmetrics.HistogramDataPoint {
 	return map[string]*otlpmetrics.HistogramDataPoint{
-		"empty": {},
+		"empty": NewOrigPtrHistogramDataPoint(),
 		"fill_test": func() *otlpmetrics.HistogramDataPoint {
-			src := &otlpmetrics.HistogramDataPoint{}
+			src := NewOrigPtrHistogramDataPoint()
 			FillOrigTestHistogramDataPoint(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_instrumentationscope.go

@@ -32,9 +32,9 @@ func NewInstrumentationScope(orig *otlpcommon.InstrumentationScope, state *State
 }
 
 func GenerateTestInstrumentationScope() InstrumentationScope {
-	orig := otlpcommon.InstrumentationScope{}
-	FillOrigTestInstrumentationScope(&orig)
-	return NewInstrumentationScope(&orig, NewState())
+	orig := NewOrigPtrInstrumentationScope()
+	FillOrigTestInstrumentationScope(orig)
+	return NewInstrumentationScope(orig, NewState())
 }
 
 func NewOrigInstrumentationScope() otlpcommon.InstrumentationScope {

pdata/internal/generated_wrapper_instrumentationscope_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigInstrumentationScope(t *testing.T) {
-	src := &otlpcommon.InstrumentationScope{}
-	dest := &otlpcommon.InstrumentationScope{}
+	src := NewOrigPtrInstrumentationScope()
+	dest := NewOrigPtrInstrumentationScope()
 	CopyOrigInstrumentationScope(dest, src)
-	assert.Equal(t, &otlpcommon.InstrumentationScope{}, dest)
+	assert.Equal(t, NewOrigPtrInstrumentationScope(), dest)
 	FillOrigTestInstrumentationScope(src)
 	CopyOrigInstrumentationScope(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigInstrumentationScope(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigInstrumentationScopeUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcommon.InstrumentationScope{}
+	dest := NewOrigPtrInstrumentationScope()
 	UnmarshalJSONOrigInstrumentationScope(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcommon.InstrumentationScope{}, dest)
+	assert.Equal(t, NewOrigPtrInstrumentationScope(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigInstrumentationScope(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigInstrumentationScope(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcommon.InstrumentationScope{}
+			dest := NewOrigPtrInstrumentationScope()
 			UnmarshalJSONOrigInstrumentationScope(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigInstrumentationScope(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigInstrumentationScopeUnknown(t *testing.T) {
-	dest := &otlpcommon.InstrumentationScope{}
+	dest := NewOrigPtrInstrumentationScope()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigInstrumentationScope(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcommon.InstrumentationScope{}, dest)
+	assert.Equal(t, NewOrigPtrInstrumentationScope(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigInstrumentationScope(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigInstrumentationScope(t *testing.T) {
 			gotSize := MarshalProtoOrigInstrumentationScope(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcommon.InstrumentationScope{}
+			dest := NewOrigPtrInstrumentationScope()
 			require.NoError(t, UnmarshalProtoOrigInstrumentationScope(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufInstrumentationScope(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcommon.InstrumentationScope{}
+			dest := NewOrigPtrInstrumentationScope()
 			require.NoError(t, UnmarshalProtoOrigInstrumentationScope(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufInstrumentationScope(t *testing.T) {
 
 func getEncodingTestValuesInstrumentationScope() map[string]*otlpcommon.InstrumentationScope {
 	return map[string]*otlpcommon.InstrumentationScope{
-		"empty": {},
+		"empty": NewOrigPtrInstrumentationScope(),
 		"fill_test": func() *otlpcommon.InstrumentationScope {
-			src := &otlpcommon.InstrumentationScope{}
+			src := NewOrigPtrInstrumentationScope()
 			FillOrigTestInstrumentationScope(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_keyvalue_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigKeyValue(t *testing.T) {
-	src := &otlpcommon.KeyValue{}
-	dest := &otlpcommon.KeyValue{}
+	src := NewOrigPtrKeyValue()
+	dest := NewOrigPtrKeyValue()
 	CopyOrigKeyValue(dest, src)
-	assert.Equal(t, &otlpcommon.KeyValue{}, dest)
+	assert.Equal(t, NewOrigPtrKeyValue(), dest)
 	FillOrigTestKeyValue(src)
 	CopyOrigKeyValue(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigKeyValue(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigKeyValueUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpcommon.KeyValue{}
+	dest := NewOrigPtrKeyValue()
 	UnmarshalJSONOrigKeyValue(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpcommon.KeyValue{}, dest)
+	assert.Equal(t, NewOrigPtrKeyValue(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigKeyValue(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigKeyValue(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpcommon.KeyValue{}
+			dest := NewOrigPtrKeyValue()
 			UnmarshalJSONOrigKeyValue(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigKeyValue(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigKeyValueUnknown(t *testing.T) {
-	dest := &otlpcommon.KeyValue{}
+	dest := NewOrigPtrKeyValue()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigKeyValue(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpcommon.KeyValue{}, dest)
+	assert.Equal(t, NewOrigPtrKeyValue(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigKeyValue(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigKeyValue(t *testing.T) {
 			gotSize := MarshalProtoOrigKeyValue(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpcommon.KeyValue{}
+			dest := NewOrigPtrKeyValue()
 			require.NoError(t, UnmarshalProtoOrigKeyValue(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufKeyValue(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpcommon.KeyValue{}
+			dest := NewOrigPtrKeyValue()
 			require.NoError(t, UnmarshalProtoOrigKeyValue(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufKeyValue(t *testing.T) {
 
 func getEncodingTestValuesKeyValue() map[string]*otlpcommon.KeyValue {
 	return map[string]*otlpcommon.KeyValue{
-		"empty": {},
+		"empty": NewOrigPtrKeyValue(),
 		"fill_test": func() *otlpcommon.KeyValue {
-			src := &otlpcommon.KeyValue{}
+			src := NewOrigPtrKeyValue()
 			FillOrigTestKeyValue(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_line_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigLine(t *testing.T) {
-	src := &otlpprofiles.Line{}
-	dest := &otlpprofiles.Line{}
+	src := NewOrigPtrLine()
+	dest := NewOrigPtrLine()
 	CopyOrigLine(dest, src)
-	assert.Equal(t, &otlpprofiles.Line{}, dest)
+	assert.Equal(t, NewOrigPtrLine(), dest)
 	FillOrigTestLine(src)
 	CopyOrigLine(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigLine(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigLineUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Line{}
+	dest := NewOrigPtrLine()
 	UnmarshalJSONOrigLine(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Line{}, dest)
+	assert.Equal(t, NewOrigPtrLine(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigLine(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigLine(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Line{}
+			dest := NewOrigPtrLine()
 			UnmarshalJSONOrigLine(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigLine(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigLineUnknown(t *testing.T) {
-	dest := &otlpprofiles.Line{}
+	dest := NewOrigPtrLine()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigLine(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Line{}, dest)
+	assert.Equal(t, NewOrigPtrLine(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigLine(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigLine(t *testing.T) {
 			gotSize := MarshalProtoOrigLine(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Line{}
+			dest := NewOrigPtrLine()
 			require.NoError(t, UnmarshalProtoOrigLine(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufLine(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Line{}
+			dest := NewOrigPtrLine()
 			require.NoError(t, UnmarshalProtoOrigLine(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufLine(t *testing.T) {
 
 func getEncodingTestValuesLine() map[string]*otlpprofiles.Line {
 	return map[string]*otlpprofiles.Line{
-		"empty": {},
+		"empty": NewOrigPtrLine(),
 		"fill_test": func() *otlpprofiles.Line {
-			src := &otlpprofiles.Line{}
+			src := NewOrigPtrLine()
 			FillOrigTestLine(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_link_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigLink(t *testing.T) {
-	src := &otlpprofiles.Link{}
-	dest := &otlpprofiles.Link{}
+	src := NewOrigPtrLink()
+	dest := NewOrigPtrLink()
 	CopyOrigLink(dest, src)
-	assert.Equal(t, &otlpprofiles.Link{}, dest)
+	assert.Equal(t, NewOrigPtrLink(), dest)
 	FillOrigTestLink(src)
 	CopyOrigLink(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigLink(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigLinkUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Link{}
+	dest := NewOrigPtrLink()
 	UnmarshalJSONOrigLink(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Link{}, dest)
+	assert.Equal(t, NewOrigPtrLink(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigLink(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigLink(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Link{}
+			dest := NewOrigPtrLink()
 			UnmarshalJSONOrigLink(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigLink(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigLinkUnknown(t *testing.T) {
-	dest := &otlpprofiles.Link{}
+	dest := NewOrigPtrLink()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigLink(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Link{}, dest)
+	assert.Equal(t, NewOrigPtrLink(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigLink(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigLink(t *testing.T) {
 			gotSize := MarshalProtoOrigLink(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Link{}
+			dest := NewOrigPtrLink()
 			require.NoError(t, UnmarshalProtoOrigLink(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufLink(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Link{}
+			dest := NewOrigPtrLink()
 			require.NoError(t, UnmarshalProtoOrigLink(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufLink(t *testing.T) {
 
 func getEncodingTestValuesLink() map[string]*otlpprofiles.Link {
 	return map[string]*otlpprofiles.Link{
-		"empty": {},
+		"empty": NewOrigPtrLink(),
 		"fill_test": func() *otlpprofiles.Link {
-			src := &otlpprofiles.Link{}
+			src := NewOrigPtrLink()
 			FillOrigTestLink(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_location_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigLocation(t *testing.T) {
-	src := &otlpprofiles.Location{}
-	dest := &otlpprofiles.Location{}
+	src := NewOrigPtrLocation()
+	dest := NewOrigPtrLocation()
 	CopyOrigLocation(dest, src)
-	assert.Equal(t, &otlpprofiles.Location{}, dest)
+	assert.Equal(t, NewOrigPtrLocation(), dest)
 	FillOrigTestLocation(src)
 	CopyOrigLocation(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigLocation(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigLocationUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Location{}
+	dest := NewOrigPtrLocation()
 	UnmarshalJSONOrigLocation(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Location{}, dest)
+	assert.Equal(t, NewOrigPtrLocation(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigLocation(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigLocation(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Location{}
+			dest := NewOrigPtrLocation()
 			UnmarshalJSONOrigLocation(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigLocation(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigLocationUnknown(t *testing.T) {
-	dest := &otlpprofiles.Location{}
+	dest := NewOrigPtrLocation()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigLocation(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Location{}, dest)
+	assert.Equal(t, NewOrigPtrLocation(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigLocation(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigLocation(t *testing.T) {
 			gotSize := MarshalProtoOrigLocation(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Location{}
+			dest := NewOrigPtrLocation()
 			require.NoError(t, UnmarshalProtoOrigLocation(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufLocation(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Location{}
+			dest := NewOrigPtrLocation()
 			require.NoError(t, UnmarshalProtoOrigLocation(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufLocation(t *testing.T) {
 
 func getEncodingTestValuesLocation() map[string]*otlpprofiles.Location {
 	return map[string]*otlpprofiles.Location{
-		"empty": {},
+		"empty": NewOrigPtrLocation(),
 		"fill_test": func() *otlpprofiles.Location {
-			src := &otlpprofiles.Location{}
+			src := NewOrigPtrLocation()
 			FillOrigTestLocation(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_logrecord_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigLogRecord(t *testing.T) {
-	src := &otlplogs.LogRecord{}
-	dest := &otlplogs.LogRecord{}
+	src := NewOrigPtrLogRecord()
+	dest := NewOrigPtrLogRecord()
 	CopyOrigLogRecord(dest, src)
-	assert.Equal(t, &otlplogs.LogRecord{}, dest)
+	assert.Equal(t, NewOrigPtrLogRecord(), dest)
 	FillOrigTestLogRecord(src)
 	CopyOrigLogRecord(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigLogRecord(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigLogRecordUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlplogs.LogRecord{}
+	dest := NewOrigPtrLogRecord()
 	UnmarshalJSONOrigLogRecord(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlplogs.LogRecord{}, dest)
+	assert.Equal(t, NewOrigPtrLogRecord(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigLogRecord(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigLogRecord(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlplogs.LogRecord{}
+			dest := NewOrigPtrLogRecord()
 			UnmarshalJSONOrigLogRecord(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigLogRecord(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigLogRecordUnknown(t *testing.T) {
-	dest := &otlplogs.LogRecord{}
+	dest := NewOrigPtrLogRecord()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigLogRecord(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlplogs.LogRecord{}, dest)
+	assert.Equal(t, NewOrigPtrLogRecord(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigLogRecord(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigLogRecord(t *testing.T) {
 			gotSize := MarshalProtoOrigLogRecord(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlplogs.LogRecord{}
+			dest := NewOrigPtrLogRecord()
 			require.NoError(t, UnmarshalProtoOrigLogRecord(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufLogRecord(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlplogs.LogRecord{}
+			dest := NewOrigPtrLogRecord()
 			require.NoError(t, UnmarshalProtoOrigLogRecord(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufLogRecord(t *testing.T) {
 
 func getEncodingTestValuesLogRecord() map[string]*otlplogs.LogRecord {
 	return map[string]*otlplogs.LogRecord{
-		"empty": {},
+		"empty": NewOrigPtrLogRecord(),
 		"fill_test": func() *otlplogs.LogRecord {
-			src := &otlplogs.LogRecord{}
+			src := NewOrigPtrLogRecord()
 			FillOrigTestLogRecord(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_mapping_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigMapping(t *testing.T) {
-	src := &otlpprofiles.Mapping{}
-	dest := &otlpprofiles.Mapping{}
+	src := NewOrigPtrMapping()
+	dest := NewOrigPtrMapping()
 	CopyOrigMapping(dest, src)
-	assert.Equal(t, &otlpprofiles.Mapping{}, dest)
+	assert.Equal(t, NewOrigPtrMapping(), dest)
 	FillOrigTestMapping(src)
 	CopyOrigMapping(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigMapping(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigMappingUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Mapping{}
+	dest := NewOrigPtrMapping()
 	UnmarshalJSONOrigMapping(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Mapping{}, dest)
+	assert.Equal(t, NewOrigPtrMapping(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigMapping(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigMapping(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Mapping{}
+			dest := NewOrigPtrMapping()
 			UnmarshalJSONOrigMapping(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigMapping(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigMappingUnknown(t *testing.T) {
-	dest := &otlpprofiles.Mapping{}
+	dest := NewOrigPtrMapping()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigMapping(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Mapping{}, dest)
+	assert.Equal(t, NewOrigPtrMapping(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigMapping(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigMapping(t *testing.T) {
 			gotSize := MarshalProtoOrigMapping(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Mapping{}
+			dest := NewOrigPtrMapping()
 			require.NoError(t, UnmarshalProtoOrigMapping(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufMapping(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Mapping{}
+			dest := NewOrigPtrMapping()
 			require.NoError(t, UnmarshalProtoOrigMapping(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufMapping(t *testing.T) {
 
 func getEncodingTestValuesMapping() map[string]*otlpprofiles.Mapping {
 	return map[string]*otlpprofiles.Mapping{
-		"empty": {},
+		"empty": NewOrigPtrMapping(),
 		"fill_test": func() *otlpprofiles.Mapping {
-			src := &otlpprofiles.Mapping{}
+			src := NewOrigPtrMapping()
 			FillOrigTestMapping(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_metric_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigMetric(t *testing.T) {
-	src := &otlpmetrics.Metric{}
-	dest := &otlpmetrics.Metric{}
+	src := NewOrigPtrMetric()
+	dest := NewOrigPtrMetric()
 	CopyOrigMetric(dest, src)
-	assert.Equal(t, &otlpmetrics.Metric{}, dest)
+	assert.Equal(t, NewOrigPtrMetric(), dest)
 	FillOrigTestMetric(src)
 	CopyOrigMetric(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigMetric(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigMetricUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Metric{}
+	dest := NewOrigPtrMetric()
 	UnmarshalJSONOrigMetric(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Metric{}, dest)
+	assert.Equal(t, NewOrigPtrMetric(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigMetric(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigMetric(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Metric{}
+			dest := NewOrigPtrMetric()
 			UnmarshalJSONOrigMetric(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigMetric(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigMetricUnknown(t *testing.T) {
-	dest := &otlpmetrics.Metric{}
+	dest := NewOrigPtrMetric()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigMetric(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Metric{}, dest)
+	assert.Equal(t, NewOrigPtrMetric(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigMetric(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigMetric(t *testing.T) {
 			gotSize := MarshalProtoOrigMetric(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Metric{}
+			dest := NewOrigPtrMetric()
 			require.NoError(t, UnmarshalProtoOrigMetric(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufMetric(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Metric{}
+			dest := NewOrigPtrMetric()
 			require.NoError(t, UnmarshalProtoOrigMetric(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufMetric(t *testing.T) {
 
 func getEncodingTestValuesMetric() map[string]*otlpmetrics.Metric {
 	return map[string]*otlpmetrics.Metric{
-		"empty": {},
+		"empty": NewOrigPtrMetric(),
 		"fill_test": func() *otlpmetrics.Metric {
-			src := &otlpmetrics.Metric{}
+			src := NewOrigPtrMetric()
 			FillOrigTestMetric(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_numberdatapoint_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigNumberDataPoint(t *testing.T) {
-	src := &otlpmetrics.NumberDataPoint{}
-	dest := &otlpmetrics.NumberDataPoint{}
+	src := NewOrigPtrNumberDataPoint()
+	dest := NewOrigPtrNumberDataPoint()
 	CopyOrigNumberDataPoint(dest, src)
-	assert.Equal(t, &otlpmetrics.NumberDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrNumberDataPoint(), dest)
 	FillOrigTestNumberDataPoint(src)
 	CopyOrigNumberDataPoint(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigNumberDataPoint(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigNumberDataPointUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.NumberDataPoint{}
+	dest := NewOrigPtrNumberDataPoint()
 	UnmarshalJSONOrigNumberDataPoint(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.NumberDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrNumberDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigNumberDataPoint(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigNumberDataPoint(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.NumberDataPoint{}
+			dest := NewOrigPtrNumberDataPoint()
 			UnmarshalJSONOrigNumberDataPoint(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigNumberDataPoint(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigNumberDataPointUnknown(t *testing.T) {
-	dest := &otlpmetrics.NumberDataPoint{}
+	dest := NewOrigPtrNumberDataPoint()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigNumberDataPoint(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.NumberDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrNumberDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigNumberDataPoint(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigNumberDataPoint(t *testing.T) {
 			gotSize := MarshalProtoOrigNumberDataPoint(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.NumberDataPoint{}
+			dest := NewOrigPtrNumberDataPoint()
 			require.NoError(t, UnmarshalProtoOrigNumberDataPoint(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufNumberDataPoint(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.NumberDataPoint{}
+			dest := NewOrigPtrNumberDataPoint()
 			require.NoError(t, UnmarshalProtoOrigNumberDataPoint(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufNumberDataPoint(t *testing.T) {
 
 func getEncodingTestValuesNumberDataPoint() map[string]*otlpmetrics.NumberDataPoint {
 	return map[string]*otlpmetrics.NumberDataPoint{
-		"empty": {},
+		"empty": NewOrigPtrNumberDataPoint(),
 		"fill_test": func() *otlpmetrics.NumberDataPoint {
-			src := &otlpmetrics.NumberDataPoint{}
+			src := NewOrigPtrNumberDataPoint()
 			FillOrigTestNumberDataPoint(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_profile_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigProfile(t *testing.T) {
-	src := &otlpprofiles.Profile{}
-	dest := &otlpprofiles.Profile{}
+	src := NewOrigPtrProfile()
+	dest := NewOrigPtrProfile()
 	CopyOrigProfile(dest, src)
-	assert.Equal(t, &otlpprofiles.Profile{}, dest)
+	assert.Equal(t, NewOrigPtrProfile(), dest)
 	FillOrigTestProfile(src)
 	CopyOrigProfile(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigProfile(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigProfileUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Profile{}
+	dest := NewOrigPtrProfile()
 	UnmarshalJSONOrigProfile(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Profile{}, dest)
+	assert.Equal(t, NewOrigPtrProfile(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigProfile(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigProfile(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Profile{}
+			dest := NewOrigPtrProfile()
 			UnmarshalJSONOrigProfile(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigProfile(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigProfileUnknown(t *testing.T) {
-	dest := &otlpprofiles.Profile{}
+	dest := NewOrigPtrProfile()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigProfile(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Profile{}, dest)
+	assert.Equal(t, NewOrigPtrProfile(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigProfile(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigProfile(t *testing.T) {
 			gotSize := MarshalProtoOrigProfile(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Profile{}
+			dest := NewOrigPtrProfile()
 			require.NoError(t, UnmarshalProtoOrigProfile(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufProfile(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Profile{}
+			dest := NewOrigPtrProfile()
 			require.NoError(t, UnmarshalProtoOrigProfile(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufProfile(t *testing.T) {
 
 func getEncodingTestValuesProfile() map[string]*otlpprofiles.Profile {
 	return map[string]*otlpprofiles.Profile{
-		"empty": {},
+		"empty": NewOrigPtrProfile(),
 		"fill_test": func() *otlpprofiles.Profile {
-			src := &otlpprofiles.Profile{}
+			src := NewOrigPtrProfile()
 			FillOrigTestProfile(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_profilesdictionary_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigProfilesDictionary(t *testing.T) {
-	src := &otlpprofiles.ProfilesDictionary{}
-	dest := &otlpprofiles.ProfilesDictionary{}
+	src := NewOrigPtrProfilesDictionary()
+	dest := NewOrigPtrProfilesDictionary()
 	CopyOrigProfilesDictionary(dest, src)
-	assert.Equal(t, &otlpprofiles.ProfilesDictionary{}, dest)
+	assert.Equal(t, NewOrigPtrProfilesDictionary(), dest)
 	FillOrigTestProfilesDictionary(src)
 	CopyOrigProfilesDictionary(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigProfilesDictionary(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigProfilesDictionaryUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.ProfilesDictionary{}
+	dest := NewOrigPtrProfilesDictionary()
 	UnmarshalJSONOrigProfilesDictionary(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.ProfilesDictionary{}, dest)
+	assert.Equal(t, NewOrigPtrProfilesDictionary(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigProfilesDictionary(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigProfilesDictionary(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.ProfilesDictionary{}
+			dest := NewOrigPtrProfilesDictionary()
 			UnmarshalJSONOrigProfilesDictionary(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigProfilesDictionary(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigProfilesDictionaryUnknown(t *testing.T) {
-	dest := &otlpprofiles.ProfilesDictionary{}
+	dest := NewOrigPtrProfilesDictionary()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigProfilesDictionary(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.ProfilesDictionary{}, dest)
+	assert.Equal(t, NewOrigPtrProfilesDictionary(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigProfilesDictionary(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigProfilesDictionary(t *testing.T) {
 			gotSize := MarshalProtoOrigProfilesDictionary(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.ProfilesDictionary{}
+			dest := NewOrigPtrProfilesDictionary()
 			require.NoError(t, UnmarshalProtoOrigProfilesDictionary(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufProfilesDictionary(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.ProfilesDictionary{}
+			dest := NewOrigPtrProfilesDictionary()
 			require.NoError(t, UnmarshalProtoOrigProfilesDictionary(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufProfilesDictionary(t *testing.T) {
 
 func getEncodingTestValuesProfilesDictionary() map[string]*otlpprofiles.ProfilesDictionary {
 	return map[string]*otlpprofiles.ProfilesDictionary{
-		"empty": {},
+		"empty": NewOrigPtrProfilesDictionary(),
 		"fill_test": func() *otlpprofiles.ProfilesDictionary {
-			src := &otlpprofiles.ProfilesDictionary{}
+			src := NewOrigPtrProfilesDictionary()
 			FillOrigTestProfilesDictionary(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_resource.go

@@ -32,9 +32,9 @@ func NewResource(orig *otlpresource.Resource, state *State) Resource {
 }
 
 func GenerateTestResource() Resource {
-	orig := otlpresource.Resource{}
-	FillOrigTestResource(&orig)
-	return NewResource(&orig, NewState())
+	orig := NewOrigPtrResource()
+	FillOrigTestResource(orig)
+	return NewResource(orig, NewState())
 }
 
 func NewOrigResource() otlpresource.Resource {

pdata/internal/generated_wrapper_resource_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigResource(t *testing.T) {
-	src := &otlpresource.Resource{}
-	dest := &otlpresource.Resource{}
+	src := NewOrigPtrResource()
+	dest := NewOrigPtrResource()
 	CopyOrigResource(dest, src)
-	assert.Equal(t, &otlpresource.Resource{}, dest)
+	assert.Equal(t, NewOrigPtrResource(), dest)
 	FillOrigTestResource(src)
 	CopyOrigResource(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigResource(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigResourceUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpresource.Resource{}
+	dest := NewOrigPtrResource()
 	UnmarshalJSONOrigResource(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpresource.Resource{}, dest)
+	assert.Equal(t, NewOrigPtrResource(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigResource(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigResource(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpresource.Resource{}
+			dest := NewOrigPtrResource()
 			UnmarshalJSONOrigResource(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigResource(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceUnknown(t *testing.T) {
-	dest := &otlpresource.Resource{}
+	dest := NewOrigPtrResource()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigResource(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpresource.Resource{}, dest)
+	assert.Equal(t, NewOrigPtrResource(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigResource(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigResource(t *testing.T) {
 			gotSize := MarshalProtoOrigResource(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpresource.Resource{}
+			dest := NewOrigPtrResource()
 			require.NoError(t, UnmarshalProtoOrigResource(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufResource(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpresource.Resource{}
+			dest := NewOrigPtrResource()
 			require.NoError(t, UnmarshalProtoOrigResource(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufResource(t *testing.T) {
 
 func getEncodingTestValuesResource() map[string]*otlpresource.Resource {
 	return map[string]*otlpresource.Resource{
-		"empty": {},
+		"empty": NewOrigPtrResource(),
 		"fill_test": func() *otlpresource.Resource {
-			src := &otlpresource.Resource{}
+			src := NewOrigPtrResource()
 			FillOrigTestResource(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_resourcelogs_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigResourceLogs(t *testing.T) {
-	src := &otlplogs.ResourceLogs{}
-	dest := &otlplogs.ResourceLogs{}
+	src := NewOrigPtrResourceLogs()
+	dest := NewOrigPtrResourceLogs()
 	CopyOrigResourceLogs(dest, src)
-	assert.Equal(t, &otlplogs.ResourceLogs{}, dest)
+	assert.Equal(t, NewOrigPtrResourceLogs(), dest)
 	FillOrigTestResourceLogs(src)
 	CopyOrigResourceLogs(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigResourceLogs(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigResourceLogsUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlplogs.ResourceLogs{}
+	dest := NewOrigPtrResourceLogs()
 	UnmarshalJSONOrigResourceLogs(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlplogs.ResourceLogs{}, dest)
+	assert.Equal(t, NewOrigPtrResourceLogs(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigResourceLogs(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigResourceLogs(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlplogs.ResourceLogs{}
+			dest := NewOrigPtrResourceLogs()
 			UnmarshalJSONOrigResourceLogs(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigResourceLogs(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceLogsUnknown(t *testing.T) {
-	dest := &otlplogs.ResourceLogs{}
+	dest := NewOrigPtrResourceLogs()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigResourceLogs(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlplogs.ResourceLogs{}, dest)
+	assert.Equal(t, NewOrigPtrResourceLogs(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceLogs(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigResourceLogs(t *testing.T) {
 			gotSize := MarshalProtoOrigResourceLogs(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlplogs.ResourceLogs{}
+			dest := NewOrigPtrResourceLogs()
 			require.NoError(t, UnmarshalProtoOrigResourceLogs(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceLogs(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlplogs.ResourceLogs{}
+			dest := NewOrigPtrResourceLogs()
 			require.NoError(t, UnmarshalProtoOrigResourceLogs(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceLogs(t *testing.T) {
 
 func getEncodingTestValuesResourceLogs() map[string]*otlplogs.ResourceLogs {
 	return map[string]*otlplogs.ResourceLogs{
-		"empty": {},
+		"empty": NewOrigPtrResourceLogs(),
 		"fill_test": func() *otlplogs.ResourceLogs {
-			src := &otlplogs.ResourceLogs{}
+			src := NewOrigPtrResourceLogs()
 			FillOrigTestResourceLogs(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_resourcemetrics_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigResourceMetrics(t *testing.T) {
-	src := &otlpmetrics.ResourceMetrics{}
-	dest := &otlpmetrics.ResourceMetrics{}
+	src := NewOrigPtrResourceMetrics()
+	dest := NewOrigPtrResourceMetrics()
 	CopyOrigResourceMetrics(dest, src)
-	assert.Equal(t, &otlpmetrics.ResourceMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrResourceMetrics(), dest)
 	FillOrigTestResourceMetrics(src)
 	CopyOrigResourceMetrics(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigResourceMetrics(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigResourceMetricsUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.ResourceMetrics{}
+	dest := NewOrigPtrResourceMetrics()
 	UnmarshalJSONOrigResourceMetrics(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.ResourceMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrResourceMetrics(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigResourceMetrics(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigResourceMetrics(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.ResourceMetrics{}
+			dest := NewOrigPtrResourceMetrics()
 			UnmarshalJSONOrigResourceMetrics(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigResourceMetrics(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceMetricsUnknown(t *testing.T) {
-	dest := &otlpmetrics.ResourceMetrics{}
+	dest := NewOrigPtrResourceMetrics()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigResourceMetrics(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.ResourceMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrResourceMetrics(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceMetrics(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigResourceMetrics(t *testing.T) {
 			gotSize := MarshalProtoOrigResourceMetrics(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.ResourceMetrics{}
+			dest := NewOrigPtrResourceMetrics()
 			require.NoError(t, UnmarshalProtoOrigResourceMetrics(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceMetrics(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.ResourceMetrics{}
+			dest := NewOrigPtrResourceMetrics()
 			require.NoError(t, UnmarshalProtoOrigResourceMetrics(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceMetrics(t *testing.T) {
 
 func getEncodingTestValuesResourceMetrics() map[string]*otlpmetrics.ResourceMetrics {
 	return map[string]*otlpmetrics.ResourceMetrics{
-		"empty": {},
+		"empty": NewOrigPtrResourceMetrics(),
 		"fill_test": func() *otlpmetrics.ResourceMetrics {
-			src := &otlpmetrics.ResourceMetrics{}
+			src := NewOrigPtrResourceMetrics()
 			FillOrigTestResourceMetrics(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_resourceprofiles_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigResourceProfiles(t *testing.T) {
-	src := &otlpprofiles.ResourceProfiles{}
-	dest := &otlpprofiles.ResourceProfiles{}
+	src := NewOrigPtrResourceProfiles()
+	dest := NewOrigPtrResourceProfiles()
 	CopyOrigResourceProfiles(dest, src)
-	assert.Equal(t, &otlpprofiles.ResourceProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrResourceProfiles(), dest)
 	FillOrigTestResourceProfiles(src)
 	CopyOrigResourceProfiles(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigResourceProfiles(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigResourceProfilesUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.ResourceProfiles{}
+	dest := NewOrigPtrResourceProfiles()
 	UnmarshalJSONOrigResourceProfiles(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.ResourceProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrResourceProfiles(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigResourceProfiles(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigResourceProfiles(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.ResourceProfiles{}
+			dest := NewOrigPtrResourceProfiles()
 			UnmarshalJSONOrigResourceProfiles(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigResourceProfiles(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceProfilesUnknown(t *testing.T) {
-	dest := &otlpprofiles.ResourceProfiles{}
+	dest := NewOrigPtrResourceProfiles()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigResourceProfiles(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.ResourceProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrResourceProfiles(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceProfiles(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigResourceProfiles(t *testing.T) {
 			gotSize := MarshalProtoOrigResourceProfiles(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.ResourceProfiles{}
+			dest := NewOrigPtrResourceProfiles()
 			require.NoError(t, UnmarshalProtoOrigResourceProfiles(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceProfiles(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.ResourceProfiles{}
+			dest := NewOrigPtrResourceProfiles()
 			require.NoError(t, UnmarshalProtoOrigResourceProfiles(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceProfiles(t *testing.T) {
 
 func getEncodingTestValuesResourceProfiles() map[string]*otlpprofiles.ResourceProfiles {
 	return map[string]*otlpprofiles.ResourceProfiles{
-		"empty": {},
+		"empty": NewOrigPtrResourceProfiles(),
 		"fill_test": func() *otlpprofiles.ResourceProfiles {
-			src := &otlpprofiles.ResourceProfiles{}
+			src := NewOrigPtrResourceProfiles()
 			FillOrigTestResourceProfiles(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_resourcespans_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigResourceSpans(t *testing.T) {
-	src := &otlptrace.ResourceSpans{}
-	dest := &otlptrace.ResourceSpans{}
+	src := NewOrigPtrResourceSpans()
+	dest := NewOrigPtrResourceSpans()
 	CopyOrigResourceSpans(dest, src)
-	assert.Equal(t, &otlptrace.ResourceSpans{}, dest)
+	assert.Equal(t, NewOrigPtrResourceSpans(), dest)
 	FillOrigTestResourceSpans(src)
 	CopyOrigResourceSpans(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigResourceSpans(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigResourceSpansUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.ResourceSpans{}
+	dest := NewOrigPtrResourceSpans()
 	UnmarshalJSONOrigResourceSpans(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.ResourceSpans{}, dest)
+	assert.Equal(t, NewOrigPtrResourceSpans(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigResourceSpans(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigResourceSpans(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.ResourceSpans{}
+			dest := NewOrigPtrResourceSpans()
 			UnmarshalJSONOrigResourceSpans(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigResourceSpans(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceSpansUnknown(t *testing.T) {
-	dest := &otlptrace.ResourceSpans{}
+	dest := NewOrigPtrResourceSpans()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigResourceSpans(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.ResourceSpans{}, dest)
+	assert.Equal(t, NewOrigPtrResourceSpans(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigResourceSpans(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigResourceSpans(t *testing.T) {
 			gotSize := MarshalProtoOrigResourceSpans(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.ResourceSpans{}
+			dest := NewOrigPtrResourceSpans()
 			require.NoError(t, UnmarshalProtoOrigResourceSpans(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceSpans(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.ResourceSpans{}
+			dest := NewOrigPtrResourceSpans()
 			require.NoError(t, UnmarshalProtoOrigResourceSpans(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufResourceSpans(t *testing.T) {
 
 func getEncodingTestValuesResourceSpans() map[string]*otlptrace.ResourceSpans {
 	return map[string]*otlptrace.ResourceSpans{
-		"empty": {},
+		"empty": NewOrigPtrResourceSpans(),
 		"fill_test": func() *otlptrace.ResourceSpans {
-			src := &otlptrace.ResourceSpans{}
+			src := NewOrigPtrResourceSpans()
 			FillOrigTestResourceSpans(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_sample_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSample(t *testing.T) {
-	src := &otlpprofiles.Sample{}
-	dest := &otlpprofiles.Sample{}
+	src := NewOrigPtrSample()
+	dest := NewOrigPtrSample()
 	CopyOrigSample(dest, src)
-	assert.Equal(t, &otlpprofiles.Sample{}, dest)
+	assert.Equal(t, NewOrigPtrSample(), dest)
 	FillOrigTestSample(src)
 	CopyOrigSample(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSample(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSampleUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.Sample{}
+	dest := NewOrigPtrSample()
 	UnmarshalJSONOrigSample(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.Sample{}, dest)
+	assert.Equal(t, NewOrigPtrSample(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSample(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSample(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.Sample{}
+			dest := NewOrigPtrSample()
 			UnmarshalJSONOrigSample(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSample(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSampleUnknown(t *testing.T) {
-	dest := &otlpprofiles.Sample{}
+	dest := NewOrigPtrSample()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSample(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.Sample{}, dest)
+	assert.Equal(t, NewOrigPtrSample(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSample(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSample(t *testing.T) {
 			gotSize := MarshalProtoOrigSample(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.Sample{}
+			dest := NewOrigPtrSample()
 			require.NoError(t, UnmarshalProtoOrigSample(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSample(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.Sample{}
+			dest := NewOrigPtrSample()
 			require.NoError(t, UnmarshalProtoOrigSample(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSample(t *testing.T) {
 
 func getEncodingTestValuesSample() map[string]*otlpprofiles.Sample {
 	return map[string]*otlpprofiles.Sample{
-		"empty": {},
+		"empty": NewOrigPtrSample(),
 		"fill_test": func() *otlpprofiles.Sample {
-			src := &otlpprofiles.Sample{}
+			src := NewOrigPtrSample()
 			FillOrigTestSample(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_scopelogs_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigScopeLogs(t *testing.T) {
-	src := &otlplogs.ScopeLogs{}
-	dest := &otlplogs.ScopeLogs{}
+	src := NewOrigPtrScopeLogs()
+	dest := NewOrigPtrScopeLogs()
 	CopyOrigScopeLogs(dest, src)
-	assert.Equal(t, &otlplogs.ScopeLogs{}, dest)
+	assert.Equal(t, NewOrigPtrScopeLogs(), dest)
 	FillOrigTestScopeLogs(src)
 	CopyOrigScopeLogs(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigScopeLogs(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigScopeLogsUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlplogs.ScopeLogs{}
+	dest := NewOrigPtrScopeLogs()
 	UnmarshalJSONOrigScopeLogs(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlplogs.ScopeLogs{}, dest)
+	assert.Equal(t, NewOrigPtrScopeLogs(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigScopeLogs(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigScopeLogs(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlplogs.ScopeLogs{}
+			dest := NewOrigPtrScopeLogs()
 			UnmarshalJSONOrigScopeLogs(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigScopeLogs(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeLogsUnknown(t *testing.T) {
-	dest := &otlplogs.ScopeLogs{}
+	dest := NewOrigPtrScopeLogs()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigScopeLogs(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlplogs.ScopeLogs{}, dest)
+	assert.Equal(t, NewOrigPtrScopeLogs(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeLogs(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigScopeLogs(t *testing.T) {
 			gotSize := MarshalProtoOrigScopeLogs(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlplogs.ScopeLogs{}
+			dest := NewOrigPtrScopeLogs()
 			require.NoError(t, UnmarshalProtoOrigScopeLogs(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeLogs(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlplogs.ScopeLogs{}
+			dest := NewOrigPtrScopeLogs()
 			require.NoError(t, UnmarshalProtoOrigScopeLogs(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeLogs(t *testing.T) {
 
 func getEncodingTestValuesScopeLogs() map[string]*otlplogs.ScopeLogs {
 	return map[string]*otlplogs.ScopeLogs{
-		"empty": {},
+		"empty": NewOrigPtrScopeLogs(),
 		"fill_test": func() *otlplogs.ScopeLogs {
-			src := &otlplogs.ScopeLogs{}
+			src := NewOrigPtrScopeLogs()
 			FillOrigTestScopeLogs(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_scopemetrics_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigScopeMetrics(t *testing.T) {
-	src := &otlpmetrics.ScopeMetrics{}
-	dest := &otlpmetrics.ScopeMetrics{}
+	src := NewOrigPtrScopeMetrics()
+	dest := NewOrigPtrScopeMetrics()
 	CopyOrigScopeMetrics(dest, src)
-	assert.Equal(t, &otlpmetrics.ScopeMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrScopeMetrics(), dest)
 	FillOrigTestScopeMetrics(src)
 	CopyOrigScopeMetrics(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigScopeMetrics(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigScopeMetricsUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.ScopeMetrics{}
+	dest := NewOrigPtrScopeMetrics()
 	UnmarshalJSONOrigScopeMetrics(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.ScopeMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrScopeMetrics(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigScopeMetrics(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigScopeMetrics(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.ScopeMetrics{}
+			dest := NewOrigPtrScopeMetrics()
 			UnmarshalJSONOrigScopeMetrics(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigScopeMetrics(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeMetricsUnknown(t *testing.T) {
-	dest := &otlpmetrics.ScopeMetrics{}
+	dest := NewOrigPtrScopeMetrics()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigScopeMetrics(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.ScopeMetrics{}, dest)
+	assert.Equal(t, NewOrigPtrScopeMetrics(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeMetrics(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigScopeMetrics(t *testing.T) {
 			gotSize := MarshalProtoOrigScopeMetrics(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.ScopeMetrics{}
+			dest := NewOrigPtrScopeMetrics()
 			require.NoError(t, UnmarshalProtoOrigScopeMetrics(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeMetrics(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.ScopeMetrics{}
+			dest := NewOrigPtrScopeMetrics()
 			require.NoError(t, UnmarshalProtoOrigScopeMetrics(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeMetrics(t *testing.T) {
 
 func getEncodingTestValuesScopeMetrics() map[string]*otlpmetrics.ScopeMetrics {
 	return map[string]*otlpmetrics.ScopeMetrics{
-		"empty": {},
+		"empty": NewOrigPtrScopeMetrics(),
 		"fill_test": func() *otlpmetrics.ScopeMetrics {
-			src := &otlpmetrics.ScopeMetrics{}
+			src := NewOrigPtrScopeMetrics()
 			FillOrigTestScopeMetrics(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_scopeprofiles_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigScopeProfiles(t *testing.T) {
-	src := &otlpprofiles.ScopeProfiles{}
-	dest := &otlpprofiles.ScopeProfiles{}
+	src := NewOrigPtrScopeProfiles()
+	dest := NewOrigPtrScopeProfiles()
 	CopyOrigScopeProfiles(dest, src)
-	assert.Equal(t, &otlpprofiles.ScopeProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrScopeProfiles(), dest)
 	FillOrigTestScopeProfiles(src)
 	CopyOrigScopeProfiles(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigScopeProfiles(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigScopeProfilesUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.ScopeProfiles{}
+	dest := NewOrigPtrScopeProfiles()
 	UnmarshalJSONOrigScopeProfiles(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.ScopeProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrScopeProfiles(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigScopeProfiles(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigScopeProfiles(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.ScopeProfiles{}
+			dest := NewOrigPtrScopeProfiles()
 			UnmarshalJSONOrigScopeProfiles(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigScopeProfiles(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeProfilesUnknown(t *testing.T) {
-	dest := &otlpprofiles.ScopeProfiles{}
+	dest := NewOrigPtrScopeProfiles()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigScopeProfiles(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.ScopeProfiles{}, dest)
+	assert.Equal(t, NewOrigPtrScopeProfiles(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeProfiles(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigScopeProfiles(t *testing.T) {
 			gotSize := MarshalProtoOrigScopeProfiles(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.ScopeProfiles{}
+			dest := NewOrigPtrScopeProfiles()
 			require.NoError(t, UnmarshalProtoOrigScopeProfiles(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeProfiles(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.ScopeProfiles{}
+			dest := NewOrigPtrScopeProfiles()
 			require.NoError(t, UnmarshalProtoOrigScopeProfiles(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeProfiles(t *testing.T) {
 
 func getEncodingTestValuesScopeProfiles() map[string]*otlpprofiles.ScopeProfiles {
 	return map[string]*otlpprofiles.ScopeProfiles{
-		"empty": {},
+		"empty": NewOrigPtrScopeProfiles(),
 		"fill_test": func() *otlpprofiles.ScopeProfiles {
-			src := &otlpprofiles.ScopeProfiles{}
+			src := NewOrigPtrScopeProfiles()
 			FillOrigTestScopeProfiles(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_scopespans_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigScopeSpans(t *testing.T) {
-	src := &otlptrace.ScopeSpans{}
-	dest := &otlptrace.ScopeSpans{}
+	src := NewOrigPtrScopeSpans()
+	dest := NewOrigPtrScopeSpans()
 	CopyOrigScopeSpans(dest, src)
-	assert.Equal(t, &otlptrace.ScopeSpans{}, dest)
+	assert.Equal(t, NewOrigPtrScopeSpans(), dest)
 	FillOrigTestScopeSpans(src)
 	CopyOrigScopeSpans(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigScopeSpans(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigScopeSpansUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.ScopeSpans{}
+	dest := NewOrigPtrScopeSpans()
 	UnmarshalJSONOrigScopeSpans(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.ScopeSpans{}, dest)
+	assert.Equal(t, NewOrigPtrScopeSpans(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigScopeSpans(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigScopeSpans(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.ScopeSpans{}
+			dest := NewOrigPtrScopeSpans()
 			UnmarshalJSONOrigScopeSpans(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigScopeSpans(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeSpansUnknown(t *testing.T) {
-	dest := &otlptrace.ScopeSpans{}
+	dest := NewOrigPtrScopeSpans()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigScopeSpans(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.ScopeSpans{}, dest)
+	assert.Equal(t, NewOrigPtrScopeSpans(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigScopeSpans(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigScopeSpans(t *testing.T) {
 			gotSize := MarshalProtoOrigScopeSpans(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.ScopeSpans{}
+			dest := NewOrigPtrScopeSpans()
 			require.NoError(t, UnmarshalProtoOrigScopeSpans(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeSpans(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.ScopeSpans{}
+			dest := NewOrigPtrScopeSpans()
 			require.NoError(t, UnmarshalProtoOrigScopeSpans(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufScopeSpans(t *testing.T) {
 
 func getEncodingTestValuesScopeSpans() map[string]*otlptrace.ScopeSpans {
 	return map[string]*otlptrace.ScopeSpans{
-		"empty": {},
+		"empty": NewOrigPtrScopeSpans(),
 		"fill_test": func() *otlptrace.ScopeSpans {
-			src := &otlptrace.ScopeSpans{}
+			src := NewOrigPtrScopeSpans()
 			FillOrigTestScopeSpans(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_span_event_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSpan_Event(t *testing.T) {
-	src := &otlptrace.Span_Event{}
-	dest := &otlptrace.Span_Event{}
+	src := NewOrigPtrSpan_Event()
+	dest := NewOrigPtrSpan_Event()
 	CopyOrigSpan_Event(dest, src)
-	assert.Equal(t, &otlptrace.Span_Event{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Event(), dest)
 	FillOrigTestSpan_Event(src)
 	CopyOrigSpan_Event(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSpan_Event(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSpan_EventUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.Span_Event{}
+	dest := NewOrigPtrSpan_Event()
 	UnmarshalJSONOrigSpan_Event(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.Span_Event{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Event(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSpan_Event(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSpan_Event(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.Span_Event{}
+			dest := NewOrigPtrSpan_Event()
 			UnmarshalJSONOrigSpan_Event(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSpan_Event(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpan_EventUnknown(t *testing.T) {
-	dest := &otlptrace.Span_Event{}
+	dest := NewOrigPtrSpan_Event()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSpan_Event(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.Span_Event{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Event(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpan_Event(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSpan_Event(t *testing.T) {
 			gotSize := MarshalProtoOrigSpan_Event(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.Span_Event{}
+			dest := NewOrigPtrSpan_Event()
 			require.NoError(t, UnmarshalProtoOrigSpan_Event(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan_Event(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.Span_Event{}
+			dest := NewOrigPtrSpan_Event()
 			require.NoError(t, UnmarshalProtoOrigSpan_Event(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan_Event(t *testing.T) {
 
 func getEncodingTestValuesSpan_Event() map[string]*otlptrace.Span_Event {
 	return map[string]*otlptrace.Span_Event{
-		"empty": {},
+		"empty": NewOrigPtrSpan_Event(),
 		"fill_test": func() *otlptrace.Span_Event {
-			src := &otlptrace.Span_Event{}
+			src := NewOrigPtrSpan_Event()
 			FillOrigTestSpan_Event(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_span_link_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSpan_Link(t *testing.T) {
-	src := &otlptrace.Span_Link{}
-	dest := &otlptrace.Span_Link{}
+	src := NewOrigPtrSpan_Link()
+	dest := NewOrigPtrSpan_Link()
 	CopyOrigSpan_Link(dest, src)
-	assert.Equal(t, &otlptrace.Span_Link{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Link(), dest)
 	FillOrigTestSpan_Link(src)
 	CopyOrigSpan_Link(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSpan_Link(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSpan_LinkUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.Span_Link{}
+	dest := NewOrigPtrSpan_Link()
 	UnmarshalJSONOrigSpan_Link(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.Span_Link{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Link(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSpan_Link(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSpan_Link(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.Span_Link{}
+			dest := NewOrigPtrSpan_Link()
 			UnmarshalJSONOrigSpan_Link(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSpan_Link(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpan_LinkUnknown(t *testing.T) {
-	dest := &otlptrace.Span_Link{}
+	dest := NewOrigPtrSpan_Link()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSpan_Link(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.Span_Link{}, dest)
+	assert.Equal(t, NewOrigPtrSpan_Link(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpan_Link(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSpan_Link(t *testing.T) {
 			gotSize := MarshalProtoOrigSpan_Link(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.Span_Link{}
+			dest := NewOrigPtrSpan_Link()
 			require.NoError(t, UnmarshalProtoOrigSpan_Link(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan_Link(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.Span_Link{}
+			dest := NewOrigPtrSpan_Link()
 			require.NoError(t, UnmarshalProtoOrigSpan_Link(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan_Link(t *testing.T) {
 
 func getEncodingTestValuesSpan_Link() map[string]*otlptrace.Span_Link {
 	return map[string]*otlptrace.Span_Link{
-		"empty": {},
+		"empty": NewOrigPtrSpan_Link(),
 		"fill_test": func() *otlptrace.Span_Link {
-			src := &otlptrace.Span_Link{}
+			src := NewOrigPtrSpan_Link()
 			FillOrigTestSpan_Link(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_span_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSpan(t *testing.T) {
-	src := &otlptrace.Span{}
-	dest := &otlptrace.Span{}
+	src := NewOrigPtrSpan()
+	dest := NewOrigPtrSpan()
 	CopyOrigSpan(dest, src)
-	assert.Equal(t, &otlptrace.Span{}, dest)
+	assert.Equal(t, NewOrigPtrSpan(), dest)
 	FillOrigTestSpan(src)
 	CopyOrigSpan(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSpan(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSpanUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.Span{}
+	dest := NewOrigPtrSpan()
 	UnmarshalJSONOrigSpan(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.Span{}, dest)
+	assert.Equal(t, NewOrigPtrSpan(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSpan(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSpan(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.Span{}
+			dest := NewOrigPtrSpan()
 			UnmarshalJSONOrigSpan(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSpan(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpanUnknown(t *testing.T) {
-	dest := &otlptrace.Span{}
+	dest := NewOrigPtrSpan()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSpan(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.Span{}, dest)
+	assert.Equal(t, NewOrigPtrSpan(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSpan(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSpan(t *testing.T) {
 			gotSize := MarshalProtoOrigSpan(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.Span{}
+			dest := NewOrigPtrSpan()
 			require.NoError(t, UnmarshalProtoOrigSpan(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.Span{}
+			dest := NewOrigPtrSpan()
 			require.NoError(t, UnmarshalProtoOrigSpan(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSpan(t *testing.T) {
 
 func getEncodingTestValuesSpan() map[string]*otlptrace.Span {
 	return map[string]*otlptrace.Span{
-		"empty": {},
+		"empty": NewOrigPtrSpan(),
 		"fill_test": func() *otlptrace.Span {
-			src := &otlptrace.Span{}
+			src := NewOrigPtrSpan()
 			FillOrigTestSpan(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_status_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigStatus(t *testing.T) {
-	src := &otlptrace.Status{}
-	dest := &otlptrace.Status{}
+	src := NewOrigPtrStatus()
+	dest := NewOrigPtrStatus()
 	CopyOrigStatus(dest, src)
-	assert.Equal(t, &otlptrace.Status{}, dest)
+	assert.Equal(t, NewOrigPtrStatus(), dest)
 	FillOrigTestStatus(src)
 	CopyOrigStatus(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigStatus(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigStatusUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlptrace.Status{}
+	dest := NewOrigPtrStatus()
 	UnmarshalJSONOrigStatus(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlptrace.Status{}, dest)
+	assert.Equal(t, NewOrigPtrStatus(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigStatus(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigStatus(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlptrace.Status{}
+			dest := NewOrigPtrStatus()
 			UnmarshalJSONOrigStatus(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigStatus(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigStatusUnknown(t *testing.T) {
-	dest := &otlptrace.Status{}
+	dest := NewOrigPtrStatus()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigStatus(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlptrace.Status{}, dest)
+	assert.Equal(t, NewOrigPtrStatus(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigStatus(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigStatus(t *testing.T) {
 			gotSize := MarshalProtoOrigStatus(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlptrace.Status{}
+			dest := NewOrigPtrStatus()
 			require.NoError(t, UnmarshalProtoOrigStatus(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufStatus(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlptrace.Status{}
+			dest := NewOrigPtrStatus()
 			require.NoError(t, UnmarshalProtoOrigStatus(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufStatus(t *testing.T) {
 
 func getEncodingTestValuesStatus() map[string]*otlptrace.Status {
 	return map[string]*otlptrace.Status{
-		"empty": {},
+		"empty": NewOrigPtrStatus(),
 		"fill_test": func() *otlptrace.Status {
-			src := &otlptrace.Status{}
+			src := NewOrigPtrStatus()
 			FillOrigTestStatus(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_sum_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSum(t *testing.T) {
-	src := &otlpmetrics.Sum{}
-	dest := &otlpmetrics.Sum{}
+	src := NewOrigPtrSum()
+	dest := NewOrigPtrSum()
 	CopyOrigSum(dest, src)
-	assert.Equal(t, &otlpmetrics.Sum{}, dest)
+	assert.Equal(t, NewOrigPtrSum(), dest)
 	FillOrigTestSum(src)
 	CopyOrigSum(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSum(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSumUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Sum{}
+	dest := NewOrigPtrSum()
 	UnmarshalJSONOrigSum(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Sum{}, dest)
+	assert.Equal(t, NewOrigPtrSum(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSum(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSum(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Sum{}
+			dest := NewOrigPtrSum()
 			UnmarshalJSONOrigSum(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSum(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSumUnknown(t *testing.T) {
-	dest := &otlpmetrics.Sum{}
+	dest := NewOrigPtrSum()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSum(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Sum{}, dest)
+	assert.Equal(t, NewOrigPtrSum(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSum(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSum(t *testing.T) {
 			gotSize := MarshalProtoOrigSum(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Sum{}
+			dest := NewOrigPtrSum()
 			require.NoError(t, UnmarshalProtoOrigSum(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSum(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Sum{}
+			dest := NewOrigPtrSum()
 			require.NoError(t, UnmarshalProtoOrigSum(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSum(t *testing.T) {
 
 func getEncodingTestValuesSum() map[string]*otlpmetrics.Sum {
 	return map[string]*otlpmetrics.Sum{
-		"empty": {},
+		"empty": NewOrigPtrSum(),
 		"fill_test": func() *otlpmetrics.Sum {
-			src := &otlpmetrics.Sum{}
+			src := NewOrigPtrSum()
 			FillOrigTestSum(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_summary_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSummary(t *testing.T) {
-	src := &otlpmetrics.Summary{}
-	dest := &otlpmetrics.Summary{}
+	src := NewOrigPtrSummary()
+	dest := NewOrigPtrSummary()
 	CopyOrigSummary(dest, src)
-	assert.Equal(t, &otlpmetrics.Summary{}, dest)
+	assert.Equal(t, NewOrigPtrSummary(), dest)
 	FillOrigTestSummary(src)
 	CopyOrigSummary(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSummary(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSummaryUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.Summary{}
+	dest := NewOrigPtrSummary()
 	UnmarshalJSONOrigSummary(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.Summary{}, dest)
+	assert.Equal(t, NewOrigPtrSummary(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSummary(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSummary(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.Summary{}
+			dest := NewOrigPtrSummary()
 			UnmarshalJSONOrigSummary(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSummary(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummaryUnknown(t *testing.T) {
-	dest := &otlpmetrics.Summary{}
+	dest := NewOrigPtrSummary()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSummary(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.Summary{}, dest)
+	assert.Equal(t, NewOrigPtrSummary(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummary(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSummary(t *testing.T) {
 			gotSize := MarshalProtoOrigSummary(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.Summary{}
+			dest := NewOrigPtrSummary()
 			require.NoError(t, UnmarshalProtoOrigSummary(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummary(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.Summary{}
+			dest := NewOrigPtrSummary()
 			require.NoError(t, UnmarshalProtoOrigSummary(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummary(t *testing.T) {
 
 func getEncodingTestValuesSummary() map[string]*otlpmetrics.Summary {
 	return map[string]*otlpmetrics.Summary{
-		"empty": {},
+		"empty": NewOrigPtrSummary(),
 		"fill_test": func() *otlpmetrics.Summary {
-			src := &otlpmetrics.Summary{}
+			src := NewOrigPtrSummary()
 			FillOrigTestSummary(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_summarydatapoint_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSummaryDataPoint(t *testing.T) {
-	src := &otlpmetrics.SummaryDataPoint{}
-	dest := &otlpmetrics.SummaryDataPoint{}
+	src := NewOrigPtrSummaryDataPoint()
+	dest := NewOrigPtrSummaryDataPoint()
 	CopyOrigSummaryDataPoint(dest, src)
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint(), dest)
 	FillOrigTestSummaryDataPoint(src)
 	CopyOrigSummaryDataPoint(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSummaryDataPoint(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSummaryDataPointUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.SummaryDataPoint{}
+	dest := NewOrigPtrSummaryDataPoint()
 	UnmarshalJSONOrigSummaryDataPoint(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.SummaryDataPoint{}
+			dest := NewOrigPtrSummaryDataPoint()
 			UnmarshalJSONOrigSummaryDataPoint(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummaryDataPointUnknown(t *testing.T) {
-	dest := &otlpmetrics.SummaryDataPoint{}
+	dest := NewOrigPtrSummaryDataPoint()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSummaryDataPoint(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummaryDataPoint(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSummaryDataPoint(t *testing.T) {
 			gotSize := MarshalProtoOrigSummaryDataPoint(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.SummaryDataPoint{}
+			dest := NewOrigPtrSummaryDataPoint()
 			require.NoError(t, UnmarshalProtoOrigSummaryDataPoint(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummaryDataPoint(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.SummaryDataPoint{}
+			dest := NewOrigPtrSummaryDataPoint()
 			require.NoError(t, UnmarshalProtoOrigSummaryDataPoint(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummaryDataPoint(t *testing.T) {
 
 func getEncodingTestValuesSummaryDataPoint() map[string]*otlpmetrics.SummaryDataPoint {
 	return map[string]*otlpmetrics.SummaryDataPoint{
-		"empty": {},
+		"empty": NewOrigPtrSummaryDataPoint(),
 		"fill_test": func() *otlpmetrics.SummaryDataPoint {
-			src := &otlpmetrics.SummaryDataPoint{}
+			src := NewOrigPtrSummaryDataPoint()
 			FillOrigTestSummaryDataPoint(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_summarydatapoint_valueatquantile_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigSummaryDataPoint_ValueAtQuantile(t *testing.T) {
-	src := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
-	dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+	src := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
+	dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 	CopyOrigSummaryDataPoint_ValueAtQuantile(dest, src)
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint_ValueAtQuantile(), dest)
 	FillOrigTestSummaryDataPoint_ValueAtQuantile(src)
 	CopyOrigSummaryDataPoint_ValueAtQuantile(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigSummaryDataPoint_ValueAtQuantile(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint_ValueAtQuantileUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+	dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 	UnmarshalJSONOrigSummaryDataPoint_ValueAtQuantile(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint_ValueAtQuantile(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint_ValueAtQuantile(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint_ValueAtQuantile(t *testing.
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+			dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 			UnmarshalJSONOrigSummaryDataPoint_ValueAtQuantile(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigSummaryDataPoint_ValueAtQuantile(t *testing.
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummaryDataPoint_ValueAtQuantileUnknown(t *testing.T) {
-	dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+	dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigSummaryDataPoint_ValueAtQuantile(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}, dest)
+	assert.Equal(t, NewOrigPtrSummaryDataPoint_ValueAtQuantile(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigSummaryDataPoint_ValueAtQuantile(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigSummaryDataPoint_ValueAtQuantile(t *testing
 			gotSize := MarshalProtoOrigSummaryDataPoint_ValueAtQuantile(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+			dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 			require.NoError(t, UnmarshalProtoOrigSummaryDataPoint_ValueAtQuantile(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummaryDataPoint_ValueAtQuantile(t *
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+			dest := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 			require.NoError(t, UnmarshalProtoOrigSummaryDataPoint_ValueAtQuantile(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufSummaryDataPoint_ValueAtQuantile(t *
 
 func getEncodingTestValuesSummaryDataPoint_ValueAtQuantile() map[string]*otlpmetrics.SummaryDataPoint_ValueAtQuantile {
 	return map[string]*otlpmetrics.SummaryDataPoint_ValueAtQuantile{
-		"empty": {},
+		"empty": NewOrigPtrSummaryDataPoint_ValueAtQuantile(),
 		"fill_test": func() *otlpmetrics.SummaryDataPoint_ValueAtQuantile {
-			src := &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+			src := NewOrigPtrSummaryDataPoint_ValueAtQuantile()
 			FillOrigTestSummaryDataPoint_ValueAtQuantile(src)
 			return src
 		}(),

pdata/internal/generated_wrapper_valuetype_test.go

@@ -19,10 +19,10 @@ import (
 )
 
 func TestCopyOrigValueType(t *testing.T) {
-	src := &otlpprofiles.ValueType{}
-	dest := &otlpprofiles.ValueType{}
+	src := NewOrigPtrValueType()
+	dest := NewOrigPtrValueType()
 	CopyOrigValueType(dest, src)
-	assert.Equal(t, &otlpprofiles.ValueType{}, dest)
+	assert.Equal(t, NewOrigPtrValueType(), dest)
 	FillOrigTestValueType(src)
 	CopyOrigValueType(dest, src)
 	assert.Equal(t, src, dest)
@@ -31,10 +31,10 @@ func TestCopyOrigValueType(t *testing.T) {
 func TestMarshalAndUnmarshalJSONOrigValueTypeUnknown(t *testing.T) {
 	iter := json.BorrowIterator([]byte(`{"unknown": "string"}`))
 	defer json.ReturnIterator(iter)
-	dest := &otlpprofiles.ValueType{}
+	dest := NewOrigPtrValueType()
 	UnmarshalJSONOrigValueType(dest, iter)
 	require.NoError(t, iter.Error())
-	assert.Equal(t, &otlpprofiles.ValueType{}, dest)
+	assert.Equal(t, NewOrigPtrValueType(), dest)
 }
 
 func TestMarshalAndUnmarshalJSONOrigValueType(t *testing.T) {
@@ -47,7 +47,7 @@ func TestMarshalAndUnmarshalJSONOrigValueType(t *testing.T) {
 
 			iter := json.BorrowIterator(stream.Buffer())
 			defer json.ReturnIterator(iter)
-			dest := &otlpprofiles.ValueType{}
+			dest := NewOrigPtrValueType()
 			UnmarshalJSONOrigValueType(dest, iter)
 			require.NoError(t, iter.Error())
 
@@ -57,10 +57,10 @@ func TestMarshalAndUnmarshalJSONOrigValueType(t *testing.T) {
 }
 
 func TestMarshalAndUnmarshalProtoOrigValueTypeUnknown(t *testing.T) {
-	dest := &otlpprofiles.ValueType{}
+	dest := NewOrigPtrValueType()
 	// message Test { required int64 field = 1313; } encoding { "field": "1234" }
 	require.NoError(t, UnmarshalProtoOrigValueType(dest, []byte{0x88, 0x52, 0xD2, 0x09}))
-	assert.Equal(t, &otlpprofiles.ValueType{}, dest)
+	assert.Equal(t, NewOrigPtrValueType(), dest)
 }
 
 func TestMarshalAndUnmarshalProtoOrigValueType(t *testing.T) {
@@ -70,7 +70,7 @@ func TestMarshalAndUnmarshalProtoOrigValueType(t *testing.T) {
 			gotSize := MarshalProtoOrigValueType(src, buf)
 			assert.Equal(t, len(buf), gotSize)
 
-			dest := &otlpprofiles.ValueType{}
+			dest := NewOrigPtrValueType()
 			require.NoError(t, UnmarshalProtoOrigValueType(dest, buf))
 			assert.Equal(t, src, dest)
 		})
@@ -90,7 +90,7 @@ func TestMarshalAndUnmarshalProtoViaProtobufValueType(t *testing.T) {
 			goBuf, err := proto.Marshal(goDest)
 			require.NoError(t, err)
 
-			dest := &otlpprofiles.ValueType{}
+			dest := NewOrigPtrValueType()
 			require.NoError(t, UnmarshalProtoOrigValueType(dest, goBuf))
 			assert.Equal(t, src, dest)
 		})
@@ -99,9 +99,9 @@ func TestMarshalAndUnmarshalProtoViaProtobufValueType(t *testing.T) {
 
 func getEncodingTestValuesValueType() map[string]*otlpprofiles.ValueType {
 	return map[string]*otlpprofiles.ValueType{
-		"empty": {},
+		"empty": NewOrigPtrValueType(),
 		"fill_test": func() *otlpprofiles.ValueType {
-			src := &otlpprofiles.ValueType{}
+			src := NewOrigPtrValueType()
 			FillOrigTestValueType(src)
 			return src
 		}(),

pdata/pcommon/generated_instrumentationscope.go

@@ -29,7 +29,7 @@ func newInstrumentationScope(orig *otlpcommon.InstrumentationScope, state *inter
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewInstrumentationScope() InstrumentationScope {
-	return newInstrumentationScope(&otlpcommon.InstrumentationScope{}, internal.NewState())
+	return newInstrumentationScope(internal.NewOrigPtrInstrumentationScope(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pcommon/generated_instrumentationscope_test.go

@@ -25,8 +25,8 @@ func TestInstrumentationScope_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestInstrumentationScope(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newInstrumentationScope(&otlpcommon.InstrumentationScope{}, sharedState)) })
-	assert.Panics(t, func() { newInstrumentationScope(&otlpcommon.InstrumentationScope{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newInstrumentationScope(internal.NewOrigPtrInstrumentationScope(), sharedState)) })
+	assert.Panics(t, func() { newInstrumentationScope(internal.NewOrigPtrInstrumentationScope(), sharedState).MoveTo(dest) })
 }
 
 func TestInstrumentationScope_CopyTo(t *testing.T) {
@@ -39,7 +39,7 @@ func TestInstrumentationScope_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newInstrumentationScope(&otlpcommon.InstrumentationScope{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newInstrumentationScope(internal.NewOrigPtrInstrumentationScope(), sharedState)) })
 }
 
 func TestInstrumentationScope_Name(t *testing.T) {

pdata/pcommon/generated_resource.go

@@ -29,7 +29,7 @@ func newResource(orig *otlpresource.Resource, state *internal.State) Resource {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewResource() Resource {
-	return newResource(&otlpresource.Resource{}, internal.NewState())
+	return newResource(internal.NewOrigPtrResource(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pcommon/generated_resource_test.go

@@ -25,8 +25,8 @@ func TestResource_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestResource(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newResource(&otlpresource.Resource{}, sharedState)) })
-	assert.Panics(t, func() { newResource(&otlpresource.Resource{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newResource(internal.NewOrigPtrResource(), sharedState)) })
+	assert.Panics(t, func() { newResource(internal.NewOrigPtrResource(), sharedState).MoveTo(dest) })
 }
 
 func TestResource_CopyTo(t *testing.T) {
@@ -39,7 +39,7 @@ func TestResource_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newResource(&otlpresource.Resource{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newResource(internal.NewOrigPtrResource(), sharedState)) })
 }
 
 func TestResource_Attributes(t *testing.T) {

pdata/plog/generated_logrecord.go

@@ -34,7 +34,7 @@ func newLogRecord(orig *otlplogs.LogRecord, state *internal.State) LogRecord {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewLogRecord() LogRecord {
-	return newLogRecord(&otlplogs.LogRecord{}, internal.NewState())
+	return newLogRecord(internal.NewOrigPtrLogRecord(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/generated_logrecord_test.go

@@ -27,8 +27,8 @@ func TestLogRecord_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestLogRecord(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newLogRecord(&otlplogs.LogRecord{}, sharedState)) })
-	assert.Panics(t, func() { newLogRecord(&otlplogs.LogRecord{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newLogRecord(internal.NewOrigPtrLogRecord(), sharedState)) })
+	assert.Panics(t, func() { newLogRecord(internal.NewOrigPtrLogRecord(), sharedState).MoveTo(dest) })
 }
 
 func TestLogRecord_CopyTo(t *testing.T) {
@@ -41,7 +41,7 @@ func TestLogRecord_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newLogRecord(&otlplogs.LogRecord{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newLogRecord(internal.NewOrigPtrLogRecord(), sharedState)) })
 }
 
 func TestLogRecord_Timestamp(t *testing.T) {

pdata/plog/generated_logs.go

@@ -30,7 +30,7 @@ func newLogs(orig *otlpcollectorlogs.ExportLogsServiceRequest, state *internal.S
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewLogs() Logs {
-	return newLogs(&otlpcollectorlogs.ExportLogsServiceRequest{}, internal.NewState())
+	return newLogs(internal.NewOrigPtrExportLogsServiceRequest(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/generated_logs_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"go.opentelemetry.io/collector/pdata/internal"
-	otlpcollectorlogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1"
 )
 
 func TestLogs_MoveTo(t *testing.T) {
@@ -25,8 +24,8 @@ func TestLogs_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestLogs(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newLogs(&otlpcollectorlogs.ExportLogsServiceRequest{}, sharedState)) })
-	assert.Panics(t, func() { newLogs(&otlpcollectorlogs.ExportLogsServiceRequest{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newLogs(internal.NewOrigPtrExportLogsServiceRequest(), sharedState)) })
+	assert.Panics(t, func() { newLogs(internal.NewOrigPtrExportLogsServiceRequest(), sharedState).MoveTo(dest) })
 }
 
 func TestLogs_CopyTo(t *testing.T) {
@@ -39,7 +38,7 @@ func TestLogs_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newLogs(&otlpcollectorlogs.ExportLogsServiceRequest{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newLogs(internal.NewOrigPtrExportLogsServiceRequest(), sharedState)) })
 }
 
 func TestLogs_ResourceLogs(t *testing.T) {

pdata/plog/generated_resourcelogs.go

@@ -33,7 +33,7 @@ func newResourceLogs(orig *otlplogs.ResourceLogs, state *internal.State) Resourc
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewResourceLogs() ResourceLogs {
-	return newResourceLogs(&otlplogs.ResourceLogs{}, internal.NewState())
+	return newResourceLogs(internal.NewOrigPtrResourceLogs(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/generated_resourcelogs_test.go

@@ -26,8 +26,8 @@ func TestResourceLogs_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestResourceLogs(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newResourceLogs(&otlplogs.ResourceLogs{}, sharedState)) })
-	assert.Panics(t, func() { newResourceLogs(&otlplogs.ResourceLogs{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newResourceLogs(internal.NewOrigPtrResourceLogs(), sharedState)) })
+	assert.Panics(t, func() { newResourceLogs(internal.NewOrigPtrResourceLogs(), sharedState).MoveTo(dest) })
 }
 
 func TestResourceLogs_CopyTo(t *testing.T) {
@@ -40,7 +40,7 @@ func TestResourceLogs_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newResourceLogs(&otlplogs.ResourceLogs{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newResourceLogs(internal.NewOrigPtrResourceLogs(), sharedState)) })
 }
 
 func TestResourceLogs_Resource(t *testing.T) {

pdata/plog/generated_scopelogs.go

@@ -33,7 +33,7 @@ func newScopeLogs(orig *otlplogs.ScopeLogs, state *internal.State) ScopeLogs {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewScopeLogs() ScopeLogs {
-	return newScopeLogs(&otlplogs.ScopeLogs{}, internal.NewState())
+	return newScopeLogs(internal.NewOrigPtrScopeLogs(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/generated_scopelogs_test.go

@@ -26,8 +26,8 @@ func TestScopeLogs_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestScopeLogs(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newScopeLogs(&otlplogs.ScopeLogs{}, sharedState)) })
-	assert.Panics(t, func() { newScopeLogs(&otlplogs.ScopeLogs{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newScopeLogs(internal.NewOrigPtrScopeLogs(), sharedState)) })
+	assert.Panics(t, func() { newScopeLogs(internal.NewOrigPtrScopeLogs(), sharedState).MoveTo(dest) })
 }
 
 func TestScopeLogs_CopyTo(t *testing.T) {
@@ -40,7 +40,7 @@ func TestScopeLogs_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newScopeLogs(&otlplogs.ScopeLogs{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newScopeLogs(internal.NewOrigPtrScopeLogs(), sharedState)) })
 }
 
 func TestScopeLogs_Scope(t *testing.T) {

pdata/plog/plogotlp/generated_exportpartialsuccess.go

@@ -32,7 +32,7 @@ func newExportPartialSuccess(orig *otlpcollectorlogs.ExportLogsPartialSuccess, s
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExportPartialSuccess() ExportPartialSuccess {
-	return newExportPartialSuccess(&otlpcollectorlogs.ExportLogsPartialSuccess{}, internal.NewState())
+	return newExportPartialSuccess(internal.NewOrigPtrExportLogsPartialSuccess(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/plogotlp/generated_exportpartialsuccess_test.go

@@ -25,9 +25,9 @@ func TestExportPartialSuccess_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestExportPartialSuccess(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newExportPartialSuccess(&otlpcollectorlogs.ExportLogsPartialSuccess{}, sharedState)) })
+	assert.Panics(t, func() { ms.MoveTo(newExportPartialSuccess(internal.NewOrigPtrExportLogsPartialSuccess(), sharedState)) })
 	assert.Panics(t, func() {
-		newExportPartialSuccess(&otlpcollectorlogs.ExportLogsPartialSuccess{}, sharedState).MoveTo(dest)
+		newExportPartialSuccess(internal.NewOrigPtrExportLogsPartialSuccess(), sharedState).MoveTo(dest)
 	})
 }
 
@@ -41,7 +41,7 @@ func TestExportPartialSuccess_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newExportPartialSuccess(&otlpcollectorlogs.ExportLogsPartialSuccess{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newExportPartialSuccess(internal.NewOrigPtrExportLogsPartialSuccess(), sharedState)) })
 }
 
 func TestExportPartialSuccess_RejectedLogRecords(t *testing.T) {

pdata/plog/plogotlp/generated_exportresponse.go

@@ -32,7 +32,7 @@ func newExportResponse(orig *otlpcollectorlogs.ExportLogsServiceResponse, state
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExportResponse() ExportResponse {
-	return newExportResponse(&otlpcollectorlogs.ExportLogsServiceResponse{}, internal.NewState())
+	return newExportResponse(internal.NewOrigPtrExportLogsServiceResponse(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/plog/plogotlp/generated_exportresponse_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"go.opentelemetry.io/collector/pdata/internal"
-	otlpcollectorlogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/logs/v1"
 )
 
 func TestExportResponse_MoveTo(t *testing.T) {
@@ -25,8 +24,8 @@ func TestExportResponse_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestExportResponse(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newExportResponse(&otlpcollectorlogs.ExportLogsServiceResponse{}, sharedState)) })
-	assert.Panics(t, func() { newExportResponse(&otlpcollectorlogs.ExportLogsServiceResponse{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newExportResponse(internal.NewOrigPtrExportLogsServiceResponse(), sharedState)) })
+	assert.Panics(t, func() { newExportResponse(internal.NewOrigPtrExportLogsServiceResponse(), sharedState).MoveTo(dest) })
 }
 
 func TestExportResponse_CopyTo(t *testing.T) {
@@ -39,7 +38,7 @@ func TestExportResponse_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newExportResponse(&otlpcollectorlogs.ExportLogsServiceResponse{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newExportResponse(internal.NewOrigPtrExportLogsServiceResponse(), sharedState)) })
 }
 
 func TestExportResponse_PartialSuccess(t *testing.T) {

pdata/pmetric/generated_exemplar.go

@@ -37,7 +37,7 @@ func newExemplar(orig *otlpmetrics.Exemplar, state *internal.State) Exemplar {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExemplar() Exemplar {
-	return newExemplar(&otlpmetrics.Exemplar{}, internal.NewState())
+	return newExemplar(internal.NewOrigPtrExemplar(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_exemplar_test.go

@@ -27,8 +27,8 @@ func TestExemplar_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestExemplar(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newExemplar(&otlpmetrics.Exemplar{}, sharedState)) })
-	assert.Panics(t, func() { newExemplar(&otlpmetrics.Exemplar{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newExemplar(internal.NewOrigPtrExemplar(), sharedState)) })
+	assert.Panics(t, func() { newExemplar(internal.NewOrigPtrExemplar(), sharedState).MoveTo(dest) })
 }
 
 func TestExemplar_CopyTo(t *testing.T) {
@@ -41,7 +41,7 @@ func TestExemplar_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newExemplar(&otlpmetrics.Exemplar{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newExemplar(internal.NewOrigPtrExemplar(), sharedState)) })
 }
 
 func TestExemplar_FilteredAttributes(t *testing.T) {

pdata/pmetric/generated_exponentialhistogram.go

@@ -33,7 +33,7 @@ func newExponentialHistogram(orig *otlpmetrics.ExponentialHistogram, state *inte
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExponentialHistogram() ExponentialHistogram {
-	return newExponentialHistogram(&otlpmetrics.ExponentialHistogram{}, internal.NewState())
+	return newExponentialHistogram(internal.NewOrigPtrExponentialHistogram(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_exponentialhistogram_test.go

@@ -25,8 +25,8 @@ func TestExponentialHistogram_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestExponentialHistogram(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newExponentialHistogram(&otlpmetrics.ExponentialHistogram{}, sharedState)) })
-	assert.Panics(t, func() { newExponentialHistogram(&otlpmetrics.ExponentialHistogram{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newExponentialHistogram(internal.NewOrigPtrExponentialHistogram(), sharedState)) })
+	assert.Panics(t, func() { newExponentialHistogram(internal.NewOrigPtrExponentialHistogram(), sharedState).MoveTo(dest) })
 }
 
 func TestExponentialHistogram_CopyTo(t *testing.T) {
@@ -39,7 +39,7 @@ func TestExponentialHistogram_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newExponentialHistogram(&otlpmetrics.ExponentialHistogram{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newExponentialHistogram(internal.NewOrigPtrExponentialHistogram(), sharedState)) })
 }
 
 func TestExponentialHistogram_DataPoints(t *testing.T) {

pdata/pmetric/generated_exponentialhistogramdatapoint.go

@@ -36,7 +36,7 @@ func newExponentialHistogramDataPoint(orig *otlpmetrics.ExponentialHistogramData
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExponentialHistogramDataPoint() ExponentialHistogramDataPoint {
-	return newExponentialHistogramDataPoint(&otlpmetrics.ExponentialHistogramDataPoint{}, internal.NewState())
+	return newExponentialHistogramDataPoint(internal.NewOrigPtrExponentialHistogramDataPoint(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_exponentialhistogramdatapoint_test.go

@@ -27,10 +27,10 @@ func TestExponentialHistogramDataPoint_MoveTo(t *testing.T) {
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
 	assert.Panics(t, func() {
-		ms.MoveTo(newExponentialHistogramDataPoint(&otlpmetrics.ExponentialHistogramDataPoint{}, sharedState))
+		ms.MoveTo(newExponentialHistogramDataPoint(internal.NewOrigPtrExponentialHistogramDataPoint(), sharedState))
 	})
 	assert.Panics(t, func() {
-		newExponentialHistogramDataPoint(&otlpmetrics.ExponentialHistogramDataPoint{}, sharedState).MoveTo(dest)
+		newExponentialHistogramDataPoint(internal.NewOrigPtrExponentialHistogramDataPoint(), sharedState).MoveTo(dest)
 	})
 }
 
@@ -45,7 +45,7 @@ func TestExponentialHistogramDataPoint_CopyTo(t *testing.T) {
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
 	assert.Panics(t, func() {
-		ms.CopyTo(newExponentialHistogramDataPoint(&otlpmetrics.ExponentialHistogramDataPoint{}, sharedState))
+		ms.CopyTo(newExponentialHistogramDataPoint(internal.NewOrigPtrExponentialHistogramDataPoint(), sharedState))
 	})
 }
 

pdata/pmetric/generated_exponentialhistogramdatapointbuckets.go

@@ -33,7 +33,7 @@ func newExponentialHistogramDataPointBuckets(orig *otlpmetrics.ExponentialHistog
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewExponentialHistogramDataPointBuckets() ExponentialHistogramDataPointBuckets {
-	return newExponentialHistogramDataPointBuckets(&otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, internal.NewState())
+	return newExponentialHistogramDataPointBuckets(internal.NewOrigPtrExponentialHistogramDataPoint_Buckets(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_exponentialhistogramdatapointbuckets_test.go

@@ -27,10 +27,10 @@ func TestExponentialHistogramDataPointBuckets_MoveTo(t *testing.T) {
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
 	assert.Panics(t, func() {
-		ms.MoveTo(newExponentialHistogramDataPointBuckets(&otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, sharedState))
+		ms.MoveTo(newExponentialHistogramDataPointBuckets(internal.NewOrigPtrExponentialHistogramDataPoint_Buckets(), sharedState))
 	})
 	assert.Panics(t, func() {
-		newExponentialHistogramDataPointBuckets(&otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, sharedState).MoveTo(dest)
+		newExponentialHistogramDataPointBuckets(internal.NewOrigPtrExponentialHistogramDataPoint_Buckets(), sharedState).MoveTo(dest)
 	})
 }
 
@@ -45,7 +45,7 @@ func TestExponentialHistogramDataPointBuckets_CopyTo(t *testing.T) {
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
 	assert.Panics(t, func() {
-		ms.CopyTo(newExponentialHistogramDataPointBuckets(&otlpmetrics.ExponentialHistogramDataPoint_Buckets{}, sharedState))
+		ms.CopyTo(newExponentialHistogramDataPointBuckets(internal.NewOrigPtrExponentialHistogramDataPoint_Buckets(), sharedState))
 	})
 }
 

pdata/pmetric/generated_gauge.go

@@ -32,7 +32,7 @@ func newGauge(orig *otlpmetrics.Gauge, state *internal.State) Gauge {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewGauge() Gauge {
-	return newGauge(&otlpmetrics.Gauge{}, internal.NewState())
+	return newGauge(internal.NewOrigPtrGauge(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_gauge_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"go.opentelemetry.io/collector/pdata/internal"
-	otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1"
 )
 
 func TestGauge_MoveTo(t *testing.T) {
@@ -25,8 +24,8 @@ func TestGauge_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestGauge(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newGauge(&otlpmetrics.Gauge{}, sharedState)) })
-	assert.Panics(t, func() { newGauge(&otlpmetrics.Gauge{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newGauge(internal.NewOrigPtrGauge(), sharedState)) })
+	assert.Panics(t, func() { newGauge(internal.NewOrigPtrGauge(), sharedState).MoveTo(dest) })
 }
 
 func TestGauge_CopyTo(t *testing.T) {
@@ -39,7 +38,7 @@ func TestGauge_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newGauge(&otlpmetrics.Gauge{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newGauge(internal.NewOrigPtrGauge(), sharedState)) })
 }
 
 func TestGauge_DataPoints(t *testing.T) {

pdata/pmetric/generated_histogram.go

@@ -32,7 +32,7 @@ func newHistogram(orig *otlpmetrics.Histogram, state *internal.State) Histogram
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewHistogram() Histogram {
-	return newHistogram(&otlpmetrics.Histogram{}, internal.NewState())
+	return newHistogram(internal.NewOrigPtrHistogram(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_histogram_test.go

@@ -25,8 +25,8 @@ func TestHistogram_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestHistogram(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newHistogram(&otlpmetrics.Histogram{}, sharedState)) })
-	assert.Panics(t, func() { newHistogram(&otlpmetrics.Histogram{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newHistogram(internal.NewOrigPtrHistogram(), sharedState)) })
+	assert.Panics(t, func() { newHistogram(internal.NewOrigPtrHistogram(), sharedState).MoveTo(dest) })
 }
 
 func TestHistogram_CopyTo(t *testing.T) {
@@ -39,7 +39,7 @@ func TestHistogram_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newHistogram(&otlpmetrics.Histogram{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newHistogram(internal.NewOrigPtrHistogram(), sharedState)) })
 }
 
 func TestHistogram_DataPoints(t *testing.T) {

pdata/pmetric/generated_histogramdatapoint.go

@@ -33,7 +33,7 @@ func newHistogramDataPoint(orig *otlpmetrics.HistogramDataPoint, state *internal
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewHistogramDataPoint() HistogramDataPoint {
-	return newHistogramDataPoint(&otlpmetrics.HistogramDataPoint{}, internal.NewState())
+	return newHistogramDataPoint(internal.NewOrigPtrHistogramDataPoint(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_histogramdatapoint_test.go

@@ -26,8 +26,8 @@ func TestHistogramDataPoint_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestHistogramDataPoint(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newHistogramDataPoint(&otlpmetrics.HistogramDataPoint{}, sharedState)) })
-	assert.Panics(t, func() { newHistogramDataPoint(&otlpmetrics.HistogramDataPoint{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newHistogramDataPoint(internal.NewOrigPtrHistogramDataPoint(), sharedState)) })
+	assert.Panics(t, func() { newHistogramDataPoint(internal.NewOrigPtrHistogramDataPoint(), sharedState).MoveTo(dest) })
 }
 
 func TestHistogramDataPoint_CopyTo(t *testing.T) {
@@ -40,7 +40,7 @@ func TestHistogramDataPoint_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newHistogramDataPoint(&otlpmetrics.HistogramDataPoint{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newHistogramDataPoint(internal.NewOrigPtrHistogramDataPoint(), sharedState)) })
 }
 
 func TestHistogramDataPoint_Attributes(t *testing.T) {

pdata/pmetric/generated_metric.go

@@ -34,7 +34,7 @@ func newMetric(orig *otlpmetrics.Metric, state *internal.State) Metric {
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewMetric() Metric {
-	return newMetric(&otlpmetrics.Metric{}, internal.NewState())
+	return newMetric(internal.NewOrigPtrMetric(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_metric_test.go

@@ -26,8 +26,8 @@ func TestMetric_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestMetric(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newMetric(&otlpmetrics.Metric{}, sharedState)) })
-	assert.Panics(t, func() { newMetric(&otlpmetrics.Metric{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newMetric(internal.NewOrigPtrMetric(), sharedState)) })
+	assert.Panics(t, func() { newMetric(internal.NewOrigPtrMetric(), sharedState).MoveTo(dest) })
 }
 
 func TestMetric_CopyTo(t *testing.T) {
@@ -40,7 +40,7 @@ func TestMetric_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newMetric(&otlpmetrics.Metric{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newMetric(internal.NewOrigPtrMetric(), sharedState)) })
 }
 
 func TestMetric_Name(t *testing.T) {

pdata/pmetric/generated_metrics.go

@@ -30,7 +30,7 @@ func newMetrics(orig *otlpcollectormetrics.ExportMetricsServiceRequest, state *i
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewMetrics() Metrics {
-	return newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, internal.NewState())
+	return newMetrics(internal.NewOrigPtrExportMetricsServiceRequest(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_metrics_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"go.opentelemetry.io/collector/pdata/internal"
-	otlpcollectormetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/collector/metrics/v1"
 )
 
 func TestMetrics_MoveTo(t *testing.T) {
@@ -25,8 +24,8 @@ func TestMetrics_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestMetrics(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, sharedState)) })
-	assert.Panics(t, func() { newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newMetrics(internal.NewOrigPtrExportMetricsServiceRequest(), sharedState)) })
+	assert.Panics(t, func() { newMetrics(internal.NewOrigPtrExportMetricsServiceRequest(), sharedState).MoveTo(dest) })
 }
 
 func TestMetrics_CopyTo(t *testing.T) {
@@ -39,7 +38,7 @@ func TestMetrics_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newMetrics(&otlpcollectormetrics.ExportMetricsServiceRequest{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newMetrics(internal.NewOrigPtrExportMetricsServiceRequest(), sharedState)) })
 }
 
 func TestMetrics_ResourceMetrics(t *testing.T) {

pdata/pmetric/generated_numberdatapoint.go

@@ -33,7 +33,7 @@ func newNumberDataPoint(orig *otlpmetrics.NumberDataPoint, state *internal.State
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewNumberDataPoint() NumberDataPoint {
-	return newNumberDataPoint(&otlpmetrics.NumberDataPoint{}, internal.NewState())
+	return newNumberDataPoint(internal.NewOrigPtrNumberDataPoint(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and

pdata/pmetric/generated_numberdatapoint_test.go

@@ -26,8 +26,8 @@ func TestNumberDataPoint_MoveTo(t *testing.T) {
 	assert.Equal(t, generateTestNumberDataPoint(), dest)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.MoveTo(newNumberDataPoint(&otlpmetrics.NumberDataPoint{}, sharedState)) })
-	assert.Panics(t, func() { newNumberDataPoint(&otlpmetrics.NumberDataPoint{}, sharedState).MoveTo(dest) })
+	assert.Panics(t, func() { ms.MoveTo(newNumberDataPoint(internal.NewOrigPtrNumberDataPoint(), sharedState)) })
+	assert.Panics(t, func() { newNumberDataPoint(internal.NewOrigPtrNumberDataPoint(), sharedState).MoveTo(dest) })
 }
 
 func TestNumberDataPoint_CopyTo(t *testing.T) {
@@ -40,7 +40,7 @@ func TestNumberDataPoint_CopyTo(t *testing.T) {
 	assert.Equal(t, orig, ms)
 	sharedState := internal.NewState()
 	sharedState.MarkReadOnly()
-	assert.Panics(t, func() { ms.CopyTo(newNumberDataPoint(&otlpmetrics.NumberDataPoint{}, sharedState)) })
+	assert.Panics(t, func() { ms.CopyTo(newNumberDataPoint(internal.NewOrigPtrNumberDataPoint(), sharedState)) })
 }
 
 func TestNumberDataPoint_Attributes(t *testing.T) {

pdata/pmetric/generated_resourcemetrics.go

@@ -33,7 +33,7 @@ func newResourceMetrics(orig *otlpmetrics.ResourceMetrics, state *internal.State
 // This must be used only in testing code. Users should use "AppendEmpty" when part of a Slice,
 // OR directly access the member if this is embedded in another struct.
 func NewResourceMetrics() ResourceMetrics {
-	return newResourceMetrics(&otlpmetrics.ResourceMetrics{}, internal.NewState())
+	return newResourceMetrics(internal.NewOrigPtrResourceMetrics(), internal.NewState())
 }
 
 // MoveTo moves all properties from the current struct overriding the destination and